mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

whisper/whisperv6: improve test error messages (#21348)

Browse Source
pull/21357/head
rene 4 years ago committed by GitHub
parent 7163a6664e
commit 123864fc05
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 93 additions and 96 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 189
      whisper/whisperv6/whisper_test.go

189
whisper/whisperv6/whisper_test.go
Unescape View File

@ -42,13 +42,13 @@ func TestWhisperBasic(t *testing.T) {
t.Fatalf("failed Protocol Length: %v.", shh.Length) t.Fatalf("failed Protocol Length: %v.", shh.Length)
} }
if shh.Run == nil { if shh.Run == nil {
t.Fatalf("failed shh.Run.") t.Fatal("failed shh.Run.")
} }
if uint64(w.Version()) != ProtocolVersion { if uint64(w.Version()) != ProtocolVersion {
t.Fatalf("failed whisper Version: %v.", shh.Version) t.Fatalf("failed whisper Version: %v.", shh.Version)
} }
if w.GetFilter("non-existent") != nil { if w.GetFilter("non-existent") != nil {
t.Fatalf("failed GetFilter.") t.Fatal("failed GetFilter.")
} }
peerID := make([]byte, 64) peerID := make([]byte, 64)
@ -58,22 +58,22 @@ func TestWhisperBasic(t *testing.T) {
t.Fatal("found peer for random key.") t.Fatal("found peer for random key.")
} }
if err := w.AllowP2PMessagesFromPeer(peerID); err == nil { if err := w.AllowP2PMessagesFromPeer(peerID); err == nil {
t.Fatalf("failed MarkPeerTrusted.") t.Fatal("failed MarkPeerTrusted.")
} }
exist := w.HasSymKey("non-existing") exist := w.HasSymKey("non-existing")
if exist { if exist {
t.Fatalf("failed HasSymKey.") t.Fatal("failed HasSymKey.")
} }
key, err := w.GetSymKey("non-existing") key, err := w.GetSymKey("non-existing")
if err == nil { if err == nil {
t.Fatalf("failed GetSymKey(non-existing): false positive.") t.Fatalf("failed GetSymKey(non-existing): false positive. key=%v", key)
} }
if key != nil { if key != nil {
t.Fatalf("failed GetSymKey: false positive.") t.Fatalf("failed GetSymKey: false positive. key=%v", key)
} }
mail := w.Envelopes() mail := w.Envelopes()
if len(mail) != 0 { if len(mail) != 0 {
t.Fatalf("failed w.Envelopes().") t.Fatalf("failed w.Envelopes(). length=%d", len(mail))
} }
derived := pbkdf2.Key(peerID, nil, 65356, aesKeyLength, sha256.New) derived := pbkdf2.Key(peerID, nil, 65356, aesKeyLength, sha256.New)
@ -96,11 +96,11 @@ func TestWhisperBasic(t *testing.T) {
id, err := w.NewKeyPair() id, err := w.NewKeyPair()
if err != nil { if err != nil {
t.Fatalf("failed to generate new key pair: %s.", err) t.Fatalf("failed to generate new key pair: %v.", err)
} }
pk, err := w.GetPrivateKey(id) pk, err := w.GetPrivateKey(id)
if err != nil { if err != nil {
t.Fatalf("failed to retrieve new key pair: %s.", err) t.Fatalf("failed to retrieve new key pair: %v.", err)
} }
if !validatePrivateKey(pk) { if !validatePrivateKey(pk) {
t.Fatalf("failed validatePrivateKey: %v.", pk) t.Fatalf("failed validatePrivateKey: %v.", pk)
@ -130,7 +130,7 @@ func TestWhisperAsymmetricKeyImport(t *testing.T) {
privateKeys = append(privateKeys, pk) privateKeys = append(privateKeys, pk)
if !w.DeleteKeyPair(id) { if !w.DeleteKeyPair(id) {
t.Fatalf("could not delete private key") t.Fatal("could not delete private key")
} }
} }
@ -161,101 +161,101 @@ func TestWhisperIdentityManagement(t *testing.T) {
} }
if !w.HasKeyPair(id1) { if !w.HasKeyPair(id1) {
t.Fatalf("failed HasIdentity(pk1).") t.Fatal("failed HasIdentity(pk1).")
} }
if !w.HasKeyPair(id2) { if !w.HasKeyPair(id2) {
t.Fatalf("failed HasIdentity(pk2).") t.Fatal("failed HasIdentity(pk2).")
} }
if pk1 == nil { if pk1 == nil {
t.Fatalf("failed GetIdentity(pk1).") t.Fatal("failed GetIdentity(pk1).")
} }
if pk2 == nil { if pk2 == nil {
t.Fatalf("failed GetIdentity(pk2).") t.Fatal("failed GetIdentity(pk2).")
} }
if !validatePrivateKey(pk1) { if !validatePrivateKey(pk1) {
t.Fatalf("pk1 is invalid.") t.Fatal("pk1 is invalid.")
} }
if !validatePrivateKey(pk2) { if !validatePrivateKey(pk2) {
t.Fatalf("pk2 is invalid.") t.Fatal("pk2 is invalid.")
} }
// Delete one identity // Delete one identity
done := w.DeleteKeyPair(id1) done := w.DeleteKeyPair(id1)
if !done { if !done {
t.Fatalf("failed to delete id1.") t.Fatal("failed to delete id1.")
} }
pk1, err = w.GetPrivateKey(id1) pk1, err = w.GetPrivateKey(id1)
if err == nil { if err == nil {
t.Fatalf("retrieve the key pair: false positive.") t.Fatalf("retrieve the key pair: false positive. key=%v", pk1)
} }
pk2, err = w.GetPrivateKey(id2) pk2, err = w.GetPrivateKey(id2)
if err != nil { if err != nil {
t.Fatalf("failed to retrieve the key pair: %s.", err) t.Fatalf("failed to retrieve the key pair: %s.", err)
} }
if w.HasKeyPair(id1) { if w.HasKeyPair(id1) {
t.Fatalf("failed DeleteIdentity(pub1): still exist.") t.Fatal("failed DeleteIdentity(pub1): still exist.")
} }
if !w.HasKeyPair(id2) { if !w.HasKeyPair(id2) {
t.Fatalf("failed DeleteIdentity(pub1): pub2 does not exist.") t.Fatal("failed DeleteIdentity(pub1): pub2 does not exist.")
} }
if pk1 != nil { if pk1 != nil {
t.Fatalf("failed DeleteIdentity(pub1): first key still exist.") t.Fatal("failed DeleteIdentity(pub1): first key still exist.")
} }
if pk2 == nil { if pk2 == nil {
t.Fatalf("failed DeleteIdentity(pub1): second key does not exist.") t.Fatal("failed DeleteIdentity(pub1): second key does not exist.")
} }
// Delete again non-existing identity // Delete again non-existing identity
done = w.DeleteKeyPair(id1) done = w.DeleteKeyPair(id1)
if done { if done {
t.Fatalf("delete id1: false positive.") t.Fatal("delete id1: false positive.")
} }
pk1, err = w.GetPrivateKey(id1) pk1, err = w.GetPrivateKey(id1)
if err == nil { if err == nil {
t.Fatalf("retrieve the key pair: false positive.") t.Fatalf("retrieve the key pair: false positive. key=%v", pk1)
} }
pk2, err = w.GetPrivateKey(id2) pk2, err = w.GetPrivateKey(id2)
if err != nil { if err != nil {
t.Fatalf("failed to retrieve the key pair: %s.", err) t.Fatalf("failed to retrieve the key pair: %s.", err)
} }
if w.HasKeyPair(id1) { if w.HasKeyPair(id1) {
t.Fatalf("failed delete non-existing identity: exist.") t.Fatal("failed delete non-existing identity: exist.")
} }
if !w.HasKeyPair(id2) { if !w.HasKeyPair(id2) {
t.Fatalf("failed delete non-existing identity: pub2 does not exist.") t.Fatal("failed delete non-existing identity: pub2 does not exist.")
} }
if pk1 != nil { if pk1 != nil {
t.Fatalf("failed delete non-existing identity: first key exist.") t.Fatalf("failed delete non-existing identity: first key exist. key=%v", pk1)
} }
if pk2 == nil { if pk2 == nil {
t.Fatalf("failed delete non-existing identity: second key does not exist.") t.Fatal("failed delete non-existing identity: second key does not exist.")
} }
// Delete second identity // Delete second identity
done = w.DeleteKeyPair(id2) done = w.DeleteKeyPair(id2)
if !done { if !done {
t.Fatalf("failed to delete id2.") t.Fatal("failed to delete id2.")
} }
pk1, err = w.GetPrivateKey(id1) pk1, err = w.GetPrivateKey(id1)
if err == nil { if err == nil {
t.Fatalf("retrieve the key pair: false positive.") t.Fatalf("retrieve the key pair: false positive. key=%v", pk1)
} }
pk2, err = w.GetPrivateKey(id2) pk2, err = w.GetPrivateKey(id2)
if err == nil { if err == nil {
t.Fatalf("retrieve the key pair: false positive.") t.Fatalf("retrieve the key pair: false positive. key=%v", pk2)
} }
if w.HasKeyPair(id1) { if w.HasKeyPair(id1) {
t.Fatalf("failed delete second identity: first identity exist.") t.Fatal("failed delete second identity: first identity exist.")
} }
if w.HasKeyPair(id2) { if w.HasKeyPair(id2) {
t.Fatalf("failed delete second identity: still exist.") t.Fatal("failed delete second identity: still exist.")
} }
if pk1 != nil { if pk1 != nil {
t.Fatalf("failed delete second identity: first key exist.") t.Fatalf("failed delete second identity: first key exist. key=%v", pk1)
} }
if pk2 != nil { if pk2 != nil {
t.Fatalf("failed delete second identity: second key exist.") t.Fatalf("failed delete second identity: second key exist. key=%v", pk2)
} }
} }
@ -274,23 +274,23 @@ func TestWhisperSymKeyManagement(t *testing.T) {
k1, err = w.GetSymKey(id1) k1, err = w.GetSymKey(id1)
if err != nil { if err != nil {
t.Fatalf("failed GetSymKey(id1).") t.Fatalf("failed GetSymKey(id1). err=%v", err)
} }
k2, err = w.GetSymKey(id2) k2, err = w.GetSymKey(id2)
if err == nil { if err == nil {
t.Fatalf("failed GetSymKey(id2): false positive.") t.Fatalf("failed GetSymKey(id2): false positive. key=%v", k2)
} }
if !w.HasSymKey(id1) { if !w.HasSymKey(id1) {
t.Fatalf("failed HasSymKey(id1).") t.Fatal("failed HasSymKey(id1).")
} }
if w.HasSymKey(id2) { if w.HasSymKey(id2) {
t.Fatalf("failed HasSymKey(id2): false positive.") t.Fatal("failed HasSymKey(id2): false positive.")
} }
if k1 == nil { if k1 == nil {
t.Fatalf("first key does not exist.") t.Fatal("first key does not exist.")
} }
if k2 != nil { if k2 != nil {
t.Fatalf("second key still exist.") t.Fatalf("second key still exist. key=%v", k2)
} }
// add existing id, nothing should change // add existing id, nothing should change
@ -303,26 +303,26 @@ func TestWhisperSymKeyManagement(t *testing.T) {
k1, err = w.GetSymKey(id1) k1, err = w.GetSymKey(id1)
if err != nil { if err != nil {
t.Fatalf("failed w.GetSymKey(id1).") t.Fatalf("failed w.GetSymKey(id1). err=%v", err)
} }
k2, err = w.GetSymKey(id2) k2, err = w.GetSymKey(id2)
if err == nil { if err == nil {
t.Fatalf("failed w.GetSymKey(id2): false positive.") t.Fatalf("failed w.GetSymKey(id2): false positive. key=%v", k2)
} }
if !w.HasSymKey(id1) { if !w.HasSymKey(id1) {
t.Fatalf("failed w.HasSymKey(id1).") t.Fatal("failed w.HasSymKey(id1).")
} }
if w.HasSymKey(id2) { if w.HasSymKey(id2) {
t.Fatalf("failed w.HasSymKey(id2): false positive.") t.Fatal("failed w.HasSymKey(id2): false positive.")
} }
if k1 == nil { if k1 == nil {
t.Fatalf("first key does not exist.") t.Fatal("first key does not exist.")
} }
if !bytes.Equal(k1, randomKey) { if !bytes.Equal(k1, randomKey) {
t.Fatalf("k1 != randomKey.") t.Fatal("k1 != randomKey.")
} }
if k2 != nil { if k2 != nil {
t.Fatalf("second key already exist.") t.Fatalf("second key already exist. key=%v", k2)
} }
id2, err = w.AddSymKeyDirect(randomKey) id2, err = w.AddSymKeyDirect(randomKey)
@ -331,35 +331,35 @@ func TestWhisperSymKeyManagement(t *testing.T) {
} }
k1, err = w.GetSymKey(id1) k1, err = w.GetSymKey(id1)
if err != nil { if err != nil {
t.Fatalf("failed w.GetSymKey(id1).") t.Fatalf("failed w.GetSymKey(id1). err=%v", err)
} }
k2, err = w.GetSymKey(id2) k2, err = w.GetSymKey(id2)
if err != nil { if err != nil {
t.Fatalf("failed w.GetSymKey(id2).") t.Fatalf("failed w.GetSymKey(id2). err=%v", err)
} }
if !w.HasSymKey(id1) { if !w.HasSymKey(id1) {
t.Fatalf("HasSymKey(id1) failed.") t.Fatal("HasSymKey(id1) failed.")
} }
if !w.HasSymKey(id2) { if !w.HasSymKey(id2) {
t.Fatalf("HasSymKey(id2) failed.") t.Fatal("HasSymKey(id2) failed.")
} }
if k1 == nil { if k1 == nil {
t.Fatalf("k1 does not exist.") t.Fatal("k1 does not exist.")
} }
if k2 == nil { if k2 == nil {
t.Fatalf("k2 does not exist.") t.Fatal("k2 does not exist.")
} }
if !bytes.Equal(k1, k2) { if !bytes.Equal(k1, k2) {
t.Fatalf("k1 != k2.") t.Fatal("k1 != k2.")
} }
if !bytes.Equal(k1, randomKey) { if !bytes.Equal(k1, randomKey) {
t.Fatalf("k1 != randomKey.") t.Fatal("k1 != randomKey.")
} }
if len(k1) != aesKeyLength { if len(k1) != aesKeyLength {
t.Fatalf("wrong length of k1.") t.Fatalf("wrong length of k1. length=%d", len(k1))
} }
if len(k2) != aesKeyLength { if len(k2) != aesKeyLength {
t.Fatalf("wrong length of k2.") t.Fatalf("wrong length of k2. length=%d", len(k2))
} }
w.DeleteSymKey(id1) w.DeleteSymKey(id1)
@ -368,49 +368,46 @@ func TestWhisperSymKeyManagement(t *testing.T) {
t.Fatalf("failed w.GetSymKey(id1): false positive.") t.Fatalf("failed w.GetSymKey(id1): false positive.")
} }
if k1 != nil { if k1 != nil {
t.Fatalf("failed GetSymKey(id1): false positive.") t.Fatalf("failed GetSymKey(id1): false positive. key=%v", k1)
} }
k2, err = w.GetSymKey(id2) k2, err = w.GetSymKey(id2)
if err != nil { if err != nil {
t.Fatalf("failed w.GetSymKey(id2).") t.Fatalf("failed w.GetSymKey(id2). err=%v", err)
} }
if w.HasSymKey(id1) { if w.HasSymKey(id1) {
t.Fatalf("failed to delete first key: still exist.") t.Fatal("failed to delete first key: still exist.")
} }
if !w.HasSymKey(id2) { if !w.HasSymKey(id2) {
t.Fatalf("failed to delete first key: second key does not exist.") t.Fatal("failed to delete first key: second key does not exist.")
}
if k1 != nil {
t.Fatalf("failed to delete first key.")
} }
if k2 == nil { if k2 == nil {
t.Fatalf("failed to delete first key: second key is nil.") t.Fatal("failed to delete first key: second key is nil.")
} }
w.DeleteSymKey(id1) w.DeleteSymKey(id1)
w.DeleteSymKey(id2) w.DeleteSymKey(id2)
k1, err = w.GetSymKey(id1) k1, err = w.GetSymKey(id1)
if err == nil { if err == nil {
t.Fatalf("failed w.GetSymKey(id1): false positive.") t.Fatalf("failed w.GetSymKey(id1): false positive. key=%v", k1)
} }
k2, err = w.GetSymKey(id2) k2, err = w.GetSymKey(id2)
if err == nil { if err == nil {
t.Fatalf("failed w.GetSymKey(id2): false positive.") t.Fatalf("failed w.GetSymKey(id2): false positive. key=%v", k2)
} }
if k1 != nil || k2 != nil { if k1 != nil || k2 != nil {
t.Fatalf("k1 or k2 is not nil") t.Fatal("k1 or k2 is not nil")
} }
if w.HasSymKey(id1) { if w.HasSymKey(id1) {
t.Fatalf("failed to delete second key: first key exist.") t.Fatal("failed to delete second key: first key exist.")
} }
if w.HasSymKey(id2) { if w.HasSymKey(id2) {
t.Fatalf("failed to delete second key: still exist.") t.Fatal("failed to delete second key: still exist.")
} }
if k1 != nil { if k1 != nil {
t.Fatalf("failed to delete second key: first key is not nil.") t.Fatal("failed to delete second key: first key is not nil.")
} }
if k2 != nil { if k2 != nil {
t.Fatalf("failed to delete second key: second key is not nil.") t.Fatal("failed to delete second key: second key is not nil.")
} }
randomKey = make([]byte, aesKeyLength+1) randomKey = make([]byte, aesKeyLength+1)
@ -431,23 +428,23 @@ func TestWhisperSymKeyManagement(t *testing.T) {
} }
k1, err = w.GetSymKey(id1) k1, err = w.GetSymKey(id1)
if err != nil { if err != nil {
t.Fatalf("failed w.GetSymKey(id1).") t.Fatalf("failed w.GetSymKey(id1). err=%v", err)
} }
k2, err = w.GetSymKey(id2) k2, err = w.GetSymKey(id2)
if err != nil { if err != nil {
t.Fatalf("failed w.GetSymKey(id2).") t.Fatalf("failed w.GetSymKey(id2). err=%v", err)
} }
if !w.HasSymKey(id1) { if !w.HasSymKey(id1) {
t.Fatalf("HasSymKey(id1) failed.") t.Fatal("HasSymKey(id1) failed.")
} }
if !w.HasSymKey(id2) { if !w.HasSymKey(id2) {
t.Fatalf("HasSymKey(id2) failed.") t.Fatal("HasSymKey(id2) failed.")
} }
if !validateDataIntegrity(k2, aesKeyLength) { if !validateDataIntegrity(k2, aesKeyLength) {
t.Fatalf("key validation failed.") t.Fatal("key validation failed.")
} }
if !bytes.Equal(k1, k2) { if !bytes.Equal(k1, k2) {
t.Fatalf("k1 != k2.") t.Fatal("k1 != k2.")
} }
} }
@ -606,7 +603,7 @@ func TestCustomization(t *testing.T) {
<-ticker.C <-ticker.C
mail := f.Retrieve() mail := f.Retrieve()
if len(mail) > 0 { if len(mail) > 0 {
t.Fatalf("received premature mail") t.Fatalf("received premature mail. mail=%v", mail)
} }
} }
@ -693,10 +690,10 @@ func TestSymmetricSendCycle(t *testing.T) {
mail1 := filter1.Retrieve() mail1 := filter1.Retrieve()
mail2 := filter2.Retrieve() mail2 := filter2.Retrieve()
if len(mail2) == 0 { if len(mail2) == 0 {
t.Fatalf("did not receive any email for filter 2") t.Fatal("did not receive any email for filter 2.")
} }
if len(mail1) == 0 { if len(mail1) == 0 {
t.Fatalf("did not receive any email for filter 1") t.Fatal("did not receive any email for filter 1.")
} }
} }
@ -767,7 +764,7 @@ func TestSymmetricSendWithoutAKey(t *testing.T) {
<-ticker.C <-ticker.C
mail := filter.Retrieve() mail := filter.Retrieve()
if len(mail) == 0 { if len(mail) == 0 {
t.Fatalf("did not receive message in spite of not setting a public key") t.Fatal("did not receive message in spite of not setting a public key")
} }
} }
@ -835,7 +832,7 @@ func TestSymmetricSendKeyMismatch(t *testing.T) {
<-ticker.C <-ticker.C
mail := filter.Retrieve() mail := filter.Retrieve()
if len(mail) > 0 { if len(mail) > 0 {
t.Fatalf("received a message when keys weren't matching") t.Fatalf("received a message when keys weren't matching. message=%v", mail)
} }
} }
@ -847,48 +844,48 @@ func TestBloom(t *testing.T) {
x[32] = byte(1) x[32] = byte(1)
x[BloomFilterSize-1] = byte(128) x[BloomFilterSize-1] = byte(128)
if !BloomFilterMatch(x, b) || !BloomFilterMatch(b, x) { if !BloomFilterMatch(x, b) || !BloomFilterMatch(b, x) {
t.Fatalf("bloom filter does not match the mask") t.Fatal("bloom filter does not match the mask")
} }
_, err := mrand.Read(b) _, err := mrand.Read(b)
if err != nil { if err != nil {
t.Fatalf("math rand error") t.Fatalf("math rand error. err=%v", err)
} }
_, err = mrand.Read(x) _, err = mrand.Read(x)
if err != nil { if err != nil {
t.Fatalf("math rand error") t.Fatalf("math rand error. err=%v", err)
} }
if !BloomFilterMatch(b, b) { if !BloomFilterMatch(b, b) {
t.Fatalf("bloom filter does not match self") t.Fatal("bloom filter does not match self")
} }
x = addBloom(x, b) x = addBloom(x, b)
if !BloomFilterMatch(x, b) { if !BloomFilterMatch(x, b) {
t.Fatalf("bloom filter does not match combined bloom") t.Fatal("bloom filter does not match combined bloom")
} }
if !isFullNode(nil) { if !isFullNode(nil) {
t.Fatalf("isFullNode did not recognize nil as full node") t.Fatal("isFullNode did not recognize nil as full node")
} }
x[17] = 254 x[17] = 254
if isFullNode(x) { if isFullNode(x) {
t.Fatalf("isFullNode false positive") t.Fatal("isFullNode false positive")
} }
for i := 0; i < BloomFilterSize; i++ { for i := 0; i < BloomFilterSize; i++ {
b[i] = byte(255) b[i] = byte(255)
} }
if !isFullNode(b) { if !isFullNode(b) {
t.Fatalf("isFullNode false negative") t.Fatal("isFullNode false negative")
} }
if BloomFilterMatch(x, b) { if BloomFilterMatch(x, b) {
t.Fatalf("bloomFilterMatch false positive") t.Fatal("bloomFilterMatch false positive")
} }
if !BloomFilterMatch(b, x) { if !BloomFilterMatch(b, x) {
t.Fatalf("bloomFilterMatch false negative") t.Fatal("bloomFilterMatch false negative")
} }
w := New(&DefaultConfig) w := New(&DefaultConfig)
f := w.BloomFilter() f := w.BloomFilter()
if f != nil { if f != nil {
t.Fatalf("wrong bloom on creation") t.Fatal("wrong bloom on creation")
} }
err = w.SetBloomFilter(x) err = w.SetBloomFilter(x)
if err != nil { if err != nil {
@ -896,6 +893,6 @@ func TestBloom(t *testing.T) {
} }
f = w.BloomFilter() f = w.BloomFilter()
if !BloomFilterMatch(f, x) || !BloomFilterMatch(x, f) { if !BloomFilterMatch(f, x) || !BloomFilterMatch(x, f) {
t.Fatalf("retireved wrong bloom filter") t.Fatal("retireved wrong bloom filter")
} }
} }

Write Preview
Loading…
Cancel
Save