tornadocontrib/go-ethereum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
rene 2020-07-21 10:53:06 +02:00 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 Stats Download Patch File Download Diff File Expand all files Collapse all files

189
whisper/whisperv6/whisper_test.go
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")
} }
} }