From 40f82078a8aad779393ea7204ae14c6aaa261abb Mon Sep 17 00:00:00 2001 From: mrz1836 Date: Sat, 14 Nov 2020 19:51:54 -0500 Subject: [PATCH] Refactored all easy tests to use testify --- address_test.go | 17 ++-- encryption_test.go | 102 ++++++++++------------ hd_key_test.go | 205 ++++++++++++++------------------------------ private_key_test.go | 61 ++----------- pubkey_test.go | 20 ++--- transaction_test.go | 135 ++++++++++------------------- verify_test.go | 123 +++++++++++--------------- 7 files changed, 223 insertions(+), 440 deletions(-) diff --git a/address_test.go b/address_test.go index 0d3ff27..2649cf8 100644 --- a/address_test.go +++ b/address_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/bitcoinsv/bsvd/bsvec" + "github.com/stretchr/testify/assert" ) // TestValidA58 will test the method ValidA58() @@ -101,25 +102,17 @@ func TestGetAddressFromPrivateKey(t *testing.T) { func TestGetAddressFromPrivateKeyCompression(t *testing.T) { privateKey, err := bsvec.NewPrivateKey(bsvec.S256()) - if err != nil { - t.Fatal(err) - } + assert.NoError(t, err) var addressUncompressed string addressUncompressed, err = GetAddressFromPrivateKey(privateKey, false) - if err != nil { - t.Fatal(err) - } + assert.NoError(t, err) var addressCompressed string addressCompressed, err = GetAddressFromPrivateKey(privateKey, true) - if err != nil { - t.Fatal(err) - } + assert.NoError(t, err) - if addressCompressed == addressUncompressed { - t.Fatalf("compressed and uncompressed addresses cannot match") - } + assert.NotEqual(t, addressCompressed, addressUncompressed) } // ExampleGetAddressFromPrivateKey example using GetAddressFromPrivateKey() diff --git a/encryption_test.go b/encryption_test.go index 026f595..396074b 100644 --- a/encryption_test.go +++ b/encryption_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/bitcoinsv/bsvd/bsvec" + "github.com/stretchr/testify/assert" ) const testEncryptionMessage = "testing 1, 2, 3..." @@ -16,9 +17,8 @@ func TestEncryptWithPrivateKey(t *testing.T) { // Create a valid private key privateKey, err := CreatePrivateKey() - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, privateKey) // Create the list of tests var tests = []struct { @@ -53,16 +53,10 @@ func TestEncryptWithPrivateKey(t *testing.T) { func TestEncryptWithPrivateKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := EncryptWithPrivateKey(nil, "") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.Panics(t, func() { + _, err := EncryptWithPrivateKey(nil, "") + assert.Error(t, err) + }) } // ExampleEncryptWithPrivateKey example using EncryptWithPrivateKey() @@ -104,9 +98,8 @@ func TestEncryptWithPrivateKeyString(t *testing.T) { // Create a valid private key privateKey, err := CreatePrivateKeyString() - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, privateKey) // Create the list of tests var tests = []struct { @@ -177,9 +170,8 @@ func TestDecryptWithPrivateKey(t *testing.T) { // Create a valid private key privateKey, err := PrivateKeyFromString("bb66a48a9f6dd7b8fb469a6f08a75c25770591dc509c72129b2aaeca77a5269e") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, privateKey) // Create the list of tests var tests = []struct { @@ -419,31 +411,32 @@ func TestEncryptShared(t *testing.T) { t.Parallel() // User 1's private key - privKey1, _ := CreatePrivateKey() + privKey1, err := CreatePrivateKey() + assert.NoError(t, err) + assert.NotNil(t, privKey1) // User 2's private key - privKey2, _ := CreatePrivateKey() + var privKey2 *bsvec.PrivateKey + privKey2, err = CreatePrivateKey() + assert.NoError(t, err) + assert.NotNil(t, privKey1) // User 1 encrypts using their private key and user 2's pubkey - _, _, encryptedData, err := EncryptShared(privKey1, privKey2.PubKey(), []byte(testEncryptionMessage)) - if err != nil { - t.Fatalf("failed to encrypt data for sharing %s", err) - } + var encryptedData []byte + _, _, encryptedData, err = EncryptShared(privKey1, privKey2.PubKey(), []byte(testEncryptionMessage)) + assert.NoError(t, err) // Generate the shared key user2SharedPrivKey, _ := GenerateSharedKeyPair(privKey2, privKey1.PubKey()) + assert.NotNil(t, user2SharedPrivKey) // User 2 can decrypt using the shared private key var decryptedTestData []byte decryptedTestData, err = bsvec.Decrypt(user2SharedPrivKey, encryptedData) - if err != nil { - t.Fatalf("failed to decrypt test data %s", err) - } + assert.NoError(t, err) // Test the result - if string(decryptedTestData) != testEncryptionMessage { - t.Fatalf("decrypted string doesnt match %s", decryptedTestData) - } + assert.Equal(t, testEncryptionMessage, string(decryptedTestData)) // todo: test bad keys? } @@ -452,18 +445,11 @@ func TestEncryptShared(t *testing.T) { func TestEncryptSharedPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - privateKey, _, _, err := EncryptShared(nil, nil, []byte("")) - if err == nil { - t.Fatalf("expected error") - } else if privateKey != nil { - t.Fatalf("expected privateKey to be nil") - } + assert.Panics(t, func() { + privateKey, _, _, err := EncryptShared(nil, nil, []byte("")) + assert.Error(t, err) + assert.Nil(t, privateKey) + }) } // todo: examples and benchmark for EncryptShared() @@ -473,35 +459,35 @@ func TestEncryptSharedString(t *testing.T) { t.Parallel() // User 1's private key - privKey1, _ := CreatePrivateKey() + privKey1, err := CreatePrivateKey() + assert.NoError(t, err) + assert.NotNil(t, privKey1) // User 2's private key - privKey2, _ := CreatePrivateKey() + var privKey2 *bsvec.PrivateKey + privKey2, err = CreatePrivateKey() + assert.NoError(t, err) + assert.NotNil(t, privKey1) // User 1 encrypts using their private key and user 2's pubkey - _, _, encryptedData, err := EncryptSharedString(privKey1, privKey2.PubKey(), testEncryptionMessage) - if err != nil { - t.Fatalf("failed to encrypt data for sharing %s", err) - } + var encryptedData string + _, _, encryptedData, err = EncryptSharedString(privKey1, privKey2.PubKey(), testEncryptionMessage) + assert.NoError(t, err) // Generate the shared key user2SharedPrivKey, _ := GenerateSharedKeyPair(privKey2, privKey1.PubKey()) + assert.NotNil(t, user2SharedPrivKey) // User 2 can decrypt using the shared private key var decryptedTestData, decoded []byte decoded, err = hex.DecodeString(encryptedData) - if err != nil { - t.Fatalf("failed to decoded %s", err) - } + assert.NoError(t, err) + decryptedTestData, err = bsvec.Decrypt(user2SharedPrivKey, decoded) - if err != nil { - t.Fatalf("failed to decrypt test data %s", err) - } + assert.NoError(t, err) // Test the result - if string(decryptedTestData) != testEncryptionMessage { - t.Fatalf("decrypted string doesnt match %s", decryptedTestData) - } + assert.Equal(t, testEncryptionMessage, string(decryptedTestData)) // todo: test bad keys? } diff --git a/hd_key_test.go b/hd_key_test.go index b2b826c..2f24270 100644 --- a/hd_key_test.go +++ b/hd_key_test.go @@ -8,6 +8,7 @@ import ( "github.com/bitcoinsv/bsvd/bsvec" "github.com/bitcoinsv/bsvutil" "github.com/bitcoinsv/bsvutil/hdkeychain" + "github.com/stretchr/testify/assert" ) // TestGenerateHDKey will test the method GenerateHDKey() @@ -184,16 +185,10 @@ func TestGetPrivateKeyByPath(t *testing.T) { func TestGetPrivateKeyByPathPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetPrivateKeyByPath(nil, 0, 1) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetPrivateKeyByPath(nil, 0, 1) + assert.Error(t, err) + }) } // ExampleGetPrivateKeyByPath example using GetPrivateKeyByPath() @@ -231,9 +226,8 @@ func TestGetHDKeyByPath(t *testing.T) { // Generate a valid key validKey, err := GenerateHDKey(RecommendedSeedLength) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validKey) // Max depth key /* @@ -296,16 +290,10 @@ func TestGetHDKeyByPath(t *testing.T) { func TestGetHDKeyByPathPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetHDKeyByPath(nil, 0, 1) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetHDKeyByPath(nil, 0, 1) + assert.Error(t, err) + }) } // ExampleGetHDKeyByPath example using GetHDKeyByPath() @@ -343,9 +331,8 @@ func TestGetHDKeyChild(t *testing.T) { // Generate a valid key validKey, err := GenerateHDKey(RecommendedSeedLength) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validKey) // Max depth key /* @@ -414,16 +401,10 @@ func TestGetHDKeyChild(t *testing.T) { func TestGetHDKeyChildPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetHDKeyChild(nil, 1) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetHDKeyChild(nil, 1) + assert.Error(t, err) + }) } // ExampleGetHDKeyChild example using GetHDKeyChild() @@ -514,9 +495,8 @@ func TestGetPrivateKeyFromHDKey(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -549,16 +529,10 @@ func TestGetPrivateKeyFromHDKey(t *testing.T) { func TestGetPrivateKeyFromHDKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetPrivateKeyFromHDKey(nil) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetPrivateKeyFromHDKey(nil) + assert.Error(t, err) + }) } // ExampleGetPrivateKeyFromHDKey example using GetPrivateKeyFromHDKey() @@ -593,9 +567,8 @@ func TestGetPrivateKeyStringFromHDKey(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -624,16 +597,10 @@ func TestGetPrivateKeyStringFromHDKey(t *testing.T) { func TestGetPrivateKeyStringFromHDKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetPrivateKeyStringFromHDKey(nil) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetPrivateKeyStringFromHDKey(nil) + assert.Error(t, err) + }) } // ExampleGetPrivateKeyStringFromHDKey example using GetPrivateKeyStringFromHDKey() @@ -668,9 +635,8 @@ func TestGetPublicKeyFromHDKey(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -704,16 +670,10 @@ func TestGetPublicKeyFromHDKey(t *testing.T) { func TestGetPublicKeyFromHDKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetPublicKeyFromHDKey(nil) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetPublicKeyFromHDKey(nil) + assert.Error(t, err) + }) } // ExampleGetPublicKeyFromHDKey example using GetPublicKeyFromHDKey() @@ -748,9 +708,8 @@ func TestGetAddressFromHDKey(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -784,16 +743,10 @@ func TestGetAddressFromHDKey(t *testing.T) { func TestGetAddressFromHDKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetAddressFromHDKey(nil) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetAddressFromHDKey(nil) + assert.Error(t, err) + }) } // ExampleGetAddressFromHDKey example using GetAddressFromHDKey() @@ -828,9 +781,8 @@ func TestGetAddressStringFromHDKey(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -859,16 +811,10 @@ func TestGetAddressStringFromHDKey(t *testing.T) { func TestGetAddressStringFromHDKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetAddressStringFromHDKey(nil) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetAddressStringFromHDKey(nil) + assert.Error(t, err) + }) } // ExampleGetAddressStringFromHDKey example using GetAddressStringFromHDKey() @@ -903,9 +849,8 @@ func TestGetPublicKeysForPath(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -946,16 +891,10 @@ func TestGetPublicKeysForPath(t *testing.T) { func TestGetPublicKeysForPathPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetPublicKeysForPath(nil, 1) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetPublicKeysForPath(nil, 1) + assert.Error(t, err) + }) } // ExampleGetPublicKeysForPath example using GetPublicKeysForPath() @@ -991,9 +930,8 @@ func TestGetAddressesForPath(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -1032,16 +970,10 @@ func TestGetAddressesForPath(t *testing.T) { func TestGetAddressesForPathPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetAddressesForPath(nil, 1) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetAddressesForPath(nil, 1) + assert.Error(t, err) + }) } // ExampleGetAddressesForPath example using GetAddressesForPath() @@ -1075,9 +1007,8 @@ func TestGetExtendedPublicKey(t *testing.T) { t.Parallel() validHdKey, err := GenerateHDKeyFromString("xprv9s21ZrQH143K4FdJCmPQe1CFUvK3PKVrcp3b5xVr5Bs3cP5ab6ytszeHggTmHoqTXpaa8CgYPxZZzigSGCDjtyWdUDJqPogb1JGWAPkBLdF") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, validHdKey) // Create the list of tests var tests = []struct { @@ -1106,16 +1037,10 @@ func TestGetExtendedPublicKey(t *testing.T) { func TestGetExtendedPublicKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _, err := GetExtendedPublicKey(nil) - if err == nil { - t.Fatalf("error expected") - } + assert.Panics(t, func() { + _, err := GetExtendedPublicKey(nil) + assert.Error(t, err) + }) } // ExampleGetExtendedPublicKey example using GetExtendedPublicKey() diff --git a/private_key_test.go b/private_key_test.go index 7ec5e17..f85e10a 100644 --- a/private_key_test.go +++ b/private_key_test.go @@ -5,57 +5,15 @@ import ( "fmt" "testing" - "github.com/bitcoinsv/bsvd/bsvec" + "github.com/stretchr/testify/assert" ) -// TestGenerateSharedKeyPair will test creating a shared key that can be used to -// encrypt data that can be decrypted by yourself (privkey) and also the owner -// of the given public key -func TestGenerateSharedKeyPair(t *testing.T) { - t.Parallel() - - // User 1 - privKey1, _ := CreatePrivateKey() - - // User 2 - privKey2, _ := CreatePrivateKey() - - _, user1SharedPubKey := GenerateSharedKeyPair(privKey1, privKey2.PubKey()) - - // encrypt something with the shared public key - encryptTest, err := bsvec.Encrypt(user1SharedPubKey, []byte(testEncryptionMessage)) - if err != nil { - t.Fatalf("Failed to encrypt test data %s", err) - } - - // user 2 decrypts it - user2SharedPrivKey, _ := GenerateSharedKeyPair(privKey2, privKey1.PubKey()) - - var decryptedTestData []byte - decryptedTestData, err = bsvec.Decrypt(user2SharedPrivKey, encryptTest) - if err != nil { - t.Fatalf("Failed to decrypt test data %s", err) - } - - if string(decryptedTestData) != testEncryptionMessage { - t.Fatalf("Decrypted string doesnt match %s", decryptedTestData) - } -} - -// todo: examples and benchmark for GenerateSharedKeyPair() - // TestCreatePrivateKey will test the method CreatePrivateKey() func TestCreatePrivateKey(t *testing.T) { rawKey, err := CreatePrivateKey() - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - if rawKey == nil { - t.Fatalf("private key was nil") - } - if len(rawKey.Serialize()) == 0 { - t.Fatalf("key length was invalid") - } + assert.NoError(t, err) + assert.NotNil(t, rawKey) + assert.Equal(t, 32, len(rawKey.Serialize())) } // ExampleCreatePrivateKey example using CreatePrivateKey() @@ -80,15 +38,8 @@ func BenchmarkCreatePrivateKey(b *testing.B) { // TestCreatePrivateKeyString will test the method CreatePrivateKeyString() func TestCreatePrivateKeyString(t *testing.T) { key, err := CreatePrivateKeyString() - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - if len(key) == 0 { - t.Fatalf("private key is empty") - } - if len(key) != 64 { - t.Fatalf("key length is not 64") - } + assert.NoError(t, err) + assert.Equal(t, 64, len(key)) } // ExampleCreatePrivateKeyString example using CreatePrivateKeyString() diff --git a/pubkey_test.go b/pubkey_test.go index 05e38a9..db2eb18 100644 --- a/pubkey_test.go +++ b/pubkey_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/bitcoinsv/bsvd/bsvec" + "github.com/stretchr/testify/assert" ) // TestPubKeyFromPrivateKeyString will test the method PubKeyFromPrivateKeyString() @@ -59,9 +60,8 @@ func TestPubKeyFromPrivateKey(t *testing.T) { t.Parallel() priv, err := PrivateKeyFromString("54035dd4c7dda99ac473905a3d82f7864322b49bab1ff441cc457183b9bd8abd") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, priv) // Create the list of tests var tests = []struct { @@ -84,16 +84,10 @@ func TestPubKeyFromPrivateKey(t *testing.T) { func TestPubKeyFromPrivateKeyPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - pubKey := PubKeyFromPrivateKey(nil, true) - if len(pubKey) > 0 { - t.Fatalf("no pubkey expected, got: %s", pubKey) - } + assert.Panics(t, func() { + pubKey := PubKeyFromPrivateKey(nil, true) + assert.NotEqual(t, 0, len(pubKey)) + }) } // ExamplePubKeyFromPrivateKey example using PubKeyFromPrivateKey() diff --git a/transaction_test.go b/transaction_test.go index cffb09b..257b28d 100644 --- a/transaction_test.go +++ b/transaction_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/libsv/go-bt" + "github.com/stretchr/testify/assert" ) // TestTxFromHex will test the method TxFromHex() @@ -84,41 +85,35 @@ func TestCreateTx(t *testing.T) { // Private key (from wif) privateKey, err := WifToPrivateKey("L3VJH2hcRGYYG6YrbWGmsxQC1zyYixA82YjgEyrEUWDs4ALgk8Vu") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, privateKey) // Generate the TX - var rawTx *bt.Tx - rawTx, err = CreateTx( + var tx *bt.Tx + tx, err = CreateTx( []*Utxo{utxo}, []*PayToAddress{payTo}, []OpReturnData{opReturn1, opReturn2}, privateKey, ) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - - // Show the results - t.Logf("created tx: %s", rawTx.ToString()) + assert.NoError(t, err) + assert.NotNil(t, tx) + assert.Equal(t, + "0100000001760595866e99c1ce920197844740f5598b34763878696371d41b3a7c0a65b0b7000000006b483045022100eea3d606bd1627be6459a9de4860919225db74843d2fc7f4e7caa5e01f42c2d0022017978d9c6a0e934955a70e7dda71d68cb614f7dd89eb7b9d560aea761834ddd4412102ea87d1fd77d169bd56a71e700628113d0f8dfe57faa0ba0e55a36f9ce8e10be3ffffffff03f4010000000000001976a9147a1980655efbfec416b2b0c663a7b3ac0b6a25d288ac00000000000000001a006a07707265666978310c6578616d706c65206461746102133700000000000000001c006a0770726566697832116d6f7265206578616d706c65206461746100000000", + tx.ToString(), + ) } func TestCreateEmptyTx(t *testing.T) { - // Generate the TX - var rawTx *bt.Tx - rawTx, err := CreateTx( + tx, err := CreateTx( nil, nil, nil, nil, ) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - - // Show the results - t.Logf("created tx: %s", rawTx.ToString()) + assert.NoError(t, err) + assert.NotNil(t, tx) + assert.Equal(t, "01000000000000000000", tx.ToString()) } // ExampleCreateTx example using CreateTx() @@ -307,6 +302,7 @@ func TestCreateTxErrors(t *testing.T) { } // Run tests + var rawTx *bt.Tx for _, test := range tests { // Private key (from wif) @@ -315,7 +311,7 @@ func TestCreateTxErrors(t *testing.T) { t.Fatalf("error occurred: %s", err.Error()) } - if rawTx, err := CreateTx(test.inputUtxos, test.inputAddresses, test.inputOpReturns, privateKey); err != nil && !test.expectedError { + if rawTx, err = CreateTx(test.inputUtxos, test.inputAddresses, test.inputOpReturns, privateKey); err != nil && !test.expectedError { t.Fatalf("%s Failed: [%v] [%v] [%v] [%s] inputted and error not expected but got: %s", t.Name(), test.inputUtxos, test.inputAddresses, test.inputOpReturns, test.inputWif, err.Error()) } else if err == nil && test.expectedError { t.Fatalf("%s Failed: [%v] [%v] [%v] [%s] inputted and error was expected", t.Name(), test.inputUtxos, test.inputAddresses, test.inputOpReturns, test.inputWif) @@ -353,26 +349,24 @@ func TestCreateTxUsingWif(t *testing.T) { opReturn2 := OpReturnData{[]byte("prefix2"), []byte("more example data")} // Generate the TX - _, err := CreateTxUsingWif( + tx, err := CreateTxUsingWif( []*Utxo{utxo}, []*PayToAddress{payTo}, []OpReturnData{opReturn1, opReturn2}, "L3VJH2hcRGYYG6YrbWGmsxQC1zyYixA82YjgEyrEUWDs4ALgk8Vu", ) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, tx) // Invalid wif - _, err = CreateTxUsingWif( + tx, err = CreateTxUsingWif( []*Utxo{utxo}, []*PayToAddress{payTo}, []OpReturnData{opReturn1, opReturn2}, "", ) - if err == nil { - t.Fatalf("error should have occurred") - } + assert.Error(t, err) + assert.Nil(t, tx) } // ExampleCreateTxUsingWif example using CreateTxUsingWif() @@ -463,20 +457,14 @@ func TestCalculateFeeForTx(t *testing.T) { []OpReturnData{opReturn1, opReturn2}, "L3VJH2hcRGYYG6YrbWGmsxQC1zyYixA82YjgEyrEUWDs4ALgk8Vu", ) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - - expectedFee := uint64(132) + assert.NoError(t, err) // Tx to calculate // t.Log(rawTx.ToString()) // t.Log("tx size: ", len(rawTx.ToBytes())) // Calculate fee - if fee := CalculateFeeForTx(rawTx, nil, nil); fee != expectedFee { - t.Fatalf("expected fee: %d got: %d", expectedFee, fee) - } + assert.Equal(t, uint64(132), CalculateFeeForTx(rawTx, nil, nil)) } // TestCalculateFeeForTxVariousTxs will test the method CalculateFeeForTx() @@ -570,9 +558,8 @@ func TestCalculateFeeForTxVariousTxs(t *testing.T) { // Get the tx from hex string tx, err := TxFromHex(test.inputHex) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, tx) // Test the function if satoshis = CalculateFeeForTx(tx, test.inputStandardRate, test.inputDataRate); satoshis != test.expectedSatoshis { @@ -593,10 +580,8 @@ func TestA25_ComputeChecksum(t *testing.T) { Satoshis: 1000, } tx, err := CreateTxUsingWif([]*Utxo{utxo}, nil, nil, "L3VJH2hcRGYYG6YrbWGmsxQC1zyYixA82YjgEyrEUWDs4ALgk8Vu") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - t.Log(tx.ToString()) + assert.NoError(t, err) + assert.NotNil(t, tx) } // ExampleCalculateFeeForTx example using CalculateFeeForTx() @@ -637,13 +622,9 @@ func BenchmarkCalculateFeeForTx(b *testing.B) { func TestCalculateFeeForTxPanic(t *testing.T) { t.Parallel() - defer func() { - if r := recover(); r == nil { - t.Fatalf("the code did not panic") - } - }() - - _ = CalculateFeeForTx(nil, nil, nil) + assert.Panics(t, func() { + _ = CalculateFeeForTx(nil, nil, nil) + }) } // TestCreateTxWithChange tests for nil case in CreateTxWithChange() @@ -669,9 +650,8 @@ func TestCreateTxWithChange(t *testing.T) { // Private key (from wif) privateKey, err := WifToPrivateKey("L3VJH2hcRGYYG6YrbWGmsxQC1zyYixA82YjgEyrEUWDs4ALgk8Vu") - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) + assert.NotNil(t, privateKey) // Generate the TX var rawTx *bt.Tx @@ -684,29 +664,18 @@ func TestCreateTxWithChange(t *testing.T) { nil, privateKey, ) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } + assert.NoError(t, err) // Show the results - t.Logf("created tx: %s", rawTx.ToString()) - - // Expected - expectedFee := uint64(149) - expectedChange := uint64(351) + // t.Logf("created tx: %s", rawTx.ToString()) // Test the right fee - fee := CalculateFeeForTx(rawTx, nil, nil) - if fee != expectedFee { - t.Fatalf("fee expected: %d vs %d", expectedFee, fee) - } + assert.Equal(t, uint64(149), CalculateFeeForTx(rawTx, nil, nil)) // Test that we got the right amount of change (satoshis) for _, out := range rawTx.GetOutputs() { if out.GetLockingScriptHexString() == "76a914c9d8699bdea34b131e737447b50a8b1af0b040bf88ac" { - if out.Satoshis != expectedChange { - t.Fatalf("incorrect change expected: %d vs %d", out.Satoshis, expectedChange) - } + assert.Equal(t, uint64(351), out.Satoshis) } } } @@ -1036,34 +1005,21 @@ func TestCreateTxWithChangeUsingWif(t *testing.T) { nil, "L3VJH2hcRGYYG6YrbWGmsxQC1zyYixA82YjgEyrEUWDs4ALgk8Vu", ) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } - - // Show the results - t.Logf("created tx: %s", rawTx.ToString()) - - // Expected - expectedFee := uint64(149) - expectedChange := uint64(351) + assert.NoError(t, err) + assert.NotNil(t, rawTx) // Test the right fee - fee := CalculateFeeForTx(rawTx, nil, nil) - if fee != expectedFee { - t.Fatalf("fee expected: %d vs %d", expectedFee, fee) - } + assert.Equal(t, uint64(149), CalculateFeeForTx(rawTx, nil, nil)) // Test that we got the right amount of change (satoshis) for _, out := range rawTx.GetOutputs() { if out.GetLockingScriptHexString() == "76a914c9d8699bdea34b131e737447b50a8b1af0b040bf88ac" { - if out.Satoshis != expectedChange { - t.Fatalf("incorrect change expected: %d vs %d", out.Satoshis, expectedChange) - } + assert.Equal(t, uint64(351), out.Satoshis) } } // Invalid wif - _, err = CreateTxWithChangeUsingWif( + rawTx, err = CreateTxWithChangeUsingWif( []*Utxo{utxo}, []*PayToAddress{payTo}, []OpReturnData{opReturn1, opReturn2}, @@ -1072,9 +1028,8 @@ func TestCreateTxWithChangeUsingWif(t *testing.T) { nil, "", ) - if err == nil { - t.Fatalf("error should have occurred") - } + assert.Error(t, err) + assert.Nil(t, rawTx) } // ExampleCreateTxWithChangeUsingWif example using CreateTxWithChangeUsingWif() diff --git a/verify_test.go b/verify_test.go index 11d7942..ad60916 100644 --- a/verify_test.go +++ b/verify_test.go @@ -7,6 +7,7 @@ import ( "testing" "github.com/piotrnar/gocoin/lib/secp256k1" + "github.com/stretchr/testify/assert" ) const ( @@ -163,17 +164,9 @@ func TestVerifyMessageSigRecover(t *testing.T) { exp.Y.SetHex(vs[i][5]) success := secp256k1.RecoverPublicKey(sig.R.Bytes(), sig.S.Bytes(), msg.Bytes(), int(rid), &pubkey) - - if success { - if !exp.X.Equals(&pubkey.X) { - t.Error("X mismatch at vector", i) - } - if !exp.Y.Equals(&pubkey.Y) { - t.Error("Y mismatch at vector", i) - } - } else { - t.Error("sig.recover failed") - } + assert.Equal(t, true, success) + assert.Equal(t, true, exp.X.Equals(&pubkey.X)) + assert.Equal(t, true, exp.Y.Equals(&pubkey.Y)) } } @@ -225,15 +218,15 @@ func TestVerifyMessageSigRecoverFailed(t *testing.T) { sig.S.SetHex(vs[i][1]) msg.SetHex(vs[i][2]) rid, err := strconv.ParseInt(vs[i][3], 10, 32) - if err != nil { - t.Fatalf("failed in ParseInt: %s", err.Error()) - } + assert.NoError(t, err) + exp.X.SetHex(vs[i][4]) exp.Y.SetHex(vs[i][5]) - if secp256k1.RecoverPublicKey(sig.R.Bytes(), sig.S.Bytes(), msg.Bytes(), int(rid), &pubkey) { - t.Fatalf("sigRecover should have failed") - } + assert.Equal(t, + false, + secp256k1.RecoverPublicKey(sig.R.Bytes(), sig.S.Bytes(), msg.Bytes(), int(rid), &pubkey), + ) } } @@ -246,61 +239,47 @@ func TestVerifyMessageDER(t *testing.T) { invalidMessage := []byte("invalid-message") validHash := sha256.Sum256(message) - // Test a valid signature - verified, err := VerifyMessageDER(validHash, testDERPubKey, testDERSignature) - if err != nil { - t.Fatalf("error occurred: %s", err.Error()) - } else if !verified { - t.Fatalf("expected verified to be true") - } - - // Test an invalid pubkey - verified, err = VerifyMessageDER(validHash, testDERPubKey+"00", testDERSignature) - if err == nil { - t.Fatalf("error should have occurred") - } else if verified { - t.Fatalf("expected verified to be false") - } - - // Test an invalid pubkey - verified, err = VerifyMessageDER(validHash, "0", testDERSignature) - if err == nil { - t.Fatalf("error should have occurred") - } else if verified { - t.Fatalf("expected verified to be false") - } - - // Test an invalid signature - verified, err = VerifyMessageDER(validHash, testDERPubKey, "0"+testDERSignature) - if verified { - t.Fatalf("expected verified to be false but got: %v", verified) - } else if err == nil { - t.Fatalf("expected error not be nil") - } - - // Test an invalid signature - verified, err = VerifyMessageDER(validHash, testDERPubKey, testDERSignature+"-1") - if verified { - t.Fatalf("expected verified to be false but got: %v", verified) - } else if err == nil { - t.Fatalf("expected error not be nil") - } - - // Test an invalid signature - verified, err = VerifyMessageDER(validHash, testDERPubKey, "1234567") - if verified { - t.Fatalf("expected verified to be false but got: %v", verified) - } else if err == nil { - t.Fatalf("expected error not be nil") - } - - // Test an invalid message - verified, err = VerifyMessageDER(sha256.Sum256(invalidMessage), testDERPubKey, testDERSignature) - if verified { - t.Fatalf("expected verified to be false") - } else if err != nil { - t.Fatalf("expected error to be nil, but got: %s", err.Error()) - } + t.Run("valid signature", func(t *testing.T) { + verified, err := VerifyMessageDER(validHash, testDERPubKey, testDERSignature) + assert.NoError(t, err) + assert.Equal(t, true, verified) + }) + + t.Run("invalid pubkey", func(t *testing.T) { + verified, err := VerifyMessageDER(validHash, testDERPubKey+"00", testDERSignature) + assert.Error(t, err) + assert.Equal(t, false, verified) + }) + + t.Run("invalid pubkey 2", func(t *testing.T) { + verified, err := VerifyMessageDER(validHash, "0", testDERSignature) + assert.Error(t, err) + assert.Equal(t, false, verified) + }) + + t.Run("invalid signature (prefix)", func(t *testing.T) { + verified, err := VerifyMessageDER(validHash, testDERPubKey, "0"+testDERSignature) + assert.Error(t, err) + assert.Equal(t, false, verified) + }) + + t.Run("invalid signature (suffix)", func(t *testing.T) { + verified, err := VerifyMessageDER(validHash, testDERPubKey, testDERSignature+"-1") + assert.Error(t, err) + assert.Equal(t, false, verified) + }) + + t.Run("invalid signature (length)", func(t *testing.T) { + verified, err := VerifyMessageDER(validHash, testDERPubKey, "1234567") + assert.Error(t, err) + assert.Equal(t, false, verified) + }) + + t.Run("invalid message", func(t *testing.T) { + verified, err := VerifyMessageDER(sha256.Sum256(invalidMessage), testDERPubKey, testDERSignature) + assert.NoError(t, err) + assert.Equal(t, false, verified) + }) } // ExampleVerifyMessageDER example using VerifyMessageDER()