test with require in place of assert

MixinNetwork · Aug 2, 2023 · 41649ba · 41649ba
1 parent 6e362a2
commit 41649ba
Show file tree

Hide file tree

Showing 74 changed files with 2,044 additions and 2,041 deletions.
diff --git a/common/address_test.go b/common/address_test.go
@@ -3,11 +3,11 @@ package common
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestAddress(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	seed := make([]byte, 64)
 	for i := 0; i < len(seed); i++ {
@@ -16,36 +16,36 @@ func TestAddress(t *testing.T) {
 	addr := "XIN8AJMgQUD11jZYN9ggbQDqkmozrha3zPEZxEkKxVFBufZpEVMtrR6PjtmgtNAH6jrg8dTUQFb9waqqw9euU7Ea8AC6DEu8"
 
 	_, err := NewAddressFromString(addr[:95] + "7")
-	assert.NotNil(err)
+	require.NotNil(err)
 
 	a := NewAddressFromSeed(seed)
-	assert.Equal(addr, a.String())
-	assert.Equal("af8f69545b784e71de5e0a0261cb107aea99e9d7fe0df35537899cd9f05ea644", a.PublicViewKey.String())
-	assert.Equal("36bb0e309e7e9a82f1527df2c6b0e48181589097fe90c1282c558207ea27ce66", a.PublicSpendKey.String())
-	assert.Equal("8665767180c62fa337b2ff051e0387af66f6feb46acacb82884b062f1fd5ed0b", a.PrivateViewKey.String())
-	assert.Equal("c91e0907d114fd83c1edc396490bb2dafa43c19815b0354e70dc80c317c3cb0a", a.PrivateSpendKey.String())
-	assert.Equal("013ada6acca01c3ba1fce30afa922a029bb224d4ab158127428b9e85c7175c32", a.Hash().String())
+	require.Equal(addr, a.String())
+	require.Equal("af8f69545b784e71de5e0a0261cb107aea99e9d7fe0df35537899cd9f05ea644", a.PublicViewKey.String())
+	require.Equal("36bb0e309e7e9a82f1527df2c6b0e48181589097fe90c1282c558207ea27ce66", a.PublicSpendKey.String())
+	require.Equal("8665767180c62fa337b2ff051e0387af66f6feb46acacb82884b062f1fd5ed0b", a.PrivateViewKey.String())
+	require.Equal("c91e0907d114fd83c1edc396490bb2dafa43c19815b0354e70dc80c317c3cb0a", a.PrivateSpendKey.String())
+	require.Equal("013ada6acca01c3ba1fce30afa922a029bb224d4ab158127428b9e85c7175c32", a.Hash().String())
 
 	j, err := a.MarshalJSON()
-	assert.Nil(err)
-	assert.Equal("\"XIN8AJMgQUD11jZYN9ggbQDqkmozrha3zPEZxEkKxVFBufZpEVMtrR6PjtmgtNAH6jrg8dTUQFb9waqqw9euU7Ea8AC6DEu8\"", string(j))
+	require.Nil(err)
+	require.Equal("\"XIN8AJMgQUD11jZYN9ggbQDqkmozrha3zPEZxEkKxVFBufZpEVMtrR6PjtmgtNAH6jrg8dTUQFb9waqqw9euU7Ea8AC6DEu8\"", string(j))
 	err = a.UnmarshalJSON([]byte("\"XIN8AJMgQUD11jZYN9ggbQDqkmozrha3zPEZxEkKxVFBufZpEVMtrR6PjtmgtNAH6jrg8dTUQFb9waqqw9euU7Ea8AC6DEu8\""))
-	assert.Nil(err)
-	assert.Equal("af8f69545b784e71de5e0a0261cb107aea99e9d7fe0df35537899cd9f05ea644", a.PublicViewKey.String())
-	assert.Equal("36bb0e309e7e9a82f1527df2c6b0e48181589097fe90c1282c558207ea27ce66", a.PublicSpendKey.String())
-	assert.Equal("0000000000000000000000000000000000000000000000000000000000000000", a.PrivateViewKey.String())
-	assert.Equal("0000000000000000000000000000000000000000000000000000000000000000", a.PrivateSpendKey.String())
-	assert.Equal("013ada6acca01c3ba1fce30afa922a029bb224d4ab158127428b9e85c7175c32", a.Hash().String())
+	require.Nil(err)
+	require.Equal("af8f69545b784e71de5e0a0261cb107aea99e9d7fe0df35537899cd9f05ea644", a.PublicViewKey.String())
+	require.Equal("36bb0e309e7e9a82f1527df2c6b0e48181589097fe90c1282c558207ea27ce66", a.PublicSpendKey.String())
+	require.Equal("0000000000000000000000000000000000000000000000000000000000000000", a.PrivateViewKey.String())
+	require.Equal("0000000000000000000000000000000000000000000000000000000000000000", a.PrivateSpendKey.String())
+	require.Equal("013ada6acca01c3ba1fce30afa922a029bb224d4ab158127428b9e85c7175c32", a.Hash().String())
 
 	b, err := NewAddressFromString(addr)
-	assert.Nil(err)
-	assert.Equal(addr, b.String())
-	assert.Equal("af8f69545b784e71de5e0a0261cb107aea99e9d7fe0df35537899cd9f05ea644", b.PublicViewKey.String())
-	assert.Equal("36bb0e309e7e9a82f1527df2c6b0e48181589097fe90c1282c558207ea27ce66", b.PublicSpendKey.String())
-	assert.Equal("0000000000000000000000000000000000000000000000000000000000000000", b.PrivateViewKey.String())
-	assert.Equal("0000000000000000000000000000000000000000000000000000000000000000", b.PrivateSpendKey.String())
-	assert.Equal("013ada6acca01c3ba1fce30afa922a029bb224d4ab158127428b9e85c7175c32", b.Hash().String())
+	require.Nil(err)
+	require.Equal(addr, b.String())
+	require.Equal("af8f69545b784e71de5e0a0261cb107aea99e9d7fe0df35537899cd9f05ea644", b.PublicViewKey.String())
+	require.Equal("36bb0e309e7e9a82f1527df2c6b0e48181589097fe90c1282c558207ea27ce66", b.PublicSpendKey.String())
+	require.Equal("0000000000000000000000000000000000000000000000000000000000000000", b.PrivateViewKey.String())
+	require.Equal("0000000000000000000000000000000000000000000000000000000000000000", b.PrivateSpendKey.String())
+	require.Equal("013ada6acca01c3ba1fce30afa922a029bb224d4ab158127428b9e85c7175c32", b.Hash().String())
 
 	z := NewAddressFromSeed(make([]byte, 64))
-	assert.Equal("XIN8b7CsqwqaBP7576hvWzo7uDgbU9TB5KGU4jdgYpQTi2qrQGpBtrW49ENQiLGNrYU45e2wwKRD7dEUPtuaJYps2jbR4dH", z.String())
+	require.Equal("XIN8b7CsqwqaBP7576hvWzo7uDgbU9TB5KGU4jdgYpQTi2qrQGpBtrW49ENQiLGNrYU45e2wwKRD7dEUPtuaJYps2jbR4dH", z.String())
 }
diff --git a/common/asset_test.go b/common/asset_test.go
@@ -5,11 +5,11 @@ import (
 
 	"github.com/MixinNetwork/mixin/crypto"
 	"github.com/MixinNetwork/mixin/domains/mobilecoin"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestAsset(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	mob := &Asset{
 		ChainId:  mobilecoin.MobileCoinChainId,
@@ -20,6 +20,6 @@ func TestAsset(t *testing.T) {
 		AssetKey: "MCIP0025:1",
 	}
 
-	assert.Equal(crypto.NewHash([]byte("eea900a8-b327-488c-8d8d-1428702fe240")), mob.FeeAssetId())
-	assert.Equal(crypto.NewHash([]byte("659c407a-0489-30bf-9e6f-84ef25c971c9")), eusd.FeeAssetId())
+	require.Equal(crypto.NewHash([]byte("eea900a8-b327-488c-8d8d-1428702fe240")), mob.FeeAssetId())
+	require.Equal(crypto.NewHash([]byte("659c407a-0489-30bf-9e6f-84ef25c971c9")), eusd.FeeAssetId())
 }
diff --git a/common/custodian_test.go b/common/custodian_test.go
@@ -11,7 +11,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestCustodian(t *testing.T) {
+func TestCustodianUpdateNodes(t *testing.T) {
+}
+
+func TestCustodianParseNode(t *testing.T) {
 	require := require.New(t)
 
 	msg := "AXjpmilx5N4AV7TfZYPGJ880VjHctV76u1mGhVF9l9obUUv5TNnZbEC4beqfAS2e0RAGMQeM3o6i5KdZgl0sh3h7zwSeoiwoeh45wPxN0t96wibGBO3aTkBKpwRaOM6QpXoom3wIdG8o1Bquqv05SrNaOZSxD6EFlFR99loc9lTr_xnpMHU4RsZ2w0AELVVHAhtdWb4xgfRxt_18My1hNnJrIxUfmf4SYq_01tB8RE-GTC1pk7jqwQ6y5KjI3neGqL9xGCDa8FJPQOLkmCNSCWqdGRVEHGUD-Irj4oAt2OgOD4C2hPhgghT-Q7QBHEbXbhg7WFavLCO7PWK9eiE7c79DaZUw51-08tF2nh9RC5sK4AeqkbaiZ47efzbHrQ1kCxgH0Ra85_kSGwPW_sVvTeMRYKaE3oxT4UKeZAeqpb5XfsY2Zl-X9zqvYkAfZuSsRilcKu3pDgOolHWNcB3NjgM"

diff --git a/common/deposit_test.go b/common/deposit_test.go
@@ -7,11 +7,11 @@ import (
 
 	"github.com/MixinNetwork/mixin/crypto"
 	"github.com/MixinNetwork/mixin/domains/ethereum"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDeposit(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	accounts := make([]*Address, 0)
 	for i := 0; i < 16; i++ {
@@ -52,8 +52,8 @@ func TestDeposit(t *testing.T) {
 	msg := ver.PayloadMarshal()
 	signed := &ver.SignedTransaction
 	err := signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid inputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid inputs"))
 
 	tx.AddDepositInput(&DepositData{
 		Chain:           ethereum.EthereumChainId,
@@ -73,8 +73,8 @@ func TestDeposit(t *testing.T) {
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid inputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid inputs"))
 
 	tx = NewTransactionV3(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -88,8 +88,8 @@ func TestDeposit(t *testing.T) {
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid outputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid outputs"))
 
 	tx = NewTransactionV3(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -109,8 +109,8 @@ func TestDeposit(t *testing.T) {
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid outputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid outputs"))
 
 	tx = NewTransactionV3(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -126,12 +126,12 @@ func TestDeposit(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain := parseKeyFromHex(sender.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid domain signature for deposit"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid domain signature for deposit"))
 
 	tx = NewTransactionV3(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -147,11 +147,11 @@ func TestDeposit(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain = parseKeyFromHex(receiver.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 
 	tx = NewTransactionV3(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -167,11 +167,11 @@ func TestDeposit(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain = parseKeyFromHex(receiver.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 
 	tx = NewTransactionV3(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -187,25 +187,25 @@ func TestDeposit(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain = parseKeyFromHex(receiver.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 
 	pm := ver.Marshal()
 	ver, err = DecompressUnmarshalVersionedTransaction(pm)
-	assert.Nil(err)
-	assert.Equal(1, len(ver.SignaturesMap))
-	assert.Equal(1, len(ver.SignaturesMap[0]))
+	require.Nil(err)
+	require.Equal(1, len(ver.SignaturesMap))
+	require.Equal(1, len(ver.SignaturesMap[0]))
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 }
 
 func TestDepositLegacy(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	accounts := make([]*Address, 0)
 	for i := 0; i < 16; i++ {
@@ -246,8 +246,8 @@ func TestDepositLegacy(t *testing.T) {
 	msg := ver.PayloadMarshal()
 	signed := &ver.SignedTransaction
 	err := signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid inputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid inputs"))
 
 	tx.AddDepositInput(&DepositData{
 		Chain:           ethereum.EthereumChainId,
@@ -267,8 +267,8 @@ func TestDepositLegacy(t *testing.T) {
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid inputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid inputs"))
 
 	tx = NewTransactionV2(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -282,8 +282,8 @@ func TestDepositLegacy(t *testing.T) {
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid outputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid outputs"))
 
 	tx = NewTransactionV2(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -303,8 +303,8 @@ func TestDepositLegacy(t *testing.T) {
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid outputs"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid outputs"))
 
 	tx = NewTransactionV2(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -320,12 +320,12 @@ func TestDepositLegacy(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain := parseKeyFromHex(sender.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.NotNil(err)
-	assert.True(strings.Contains(err.Error(), "invalid domain signature for deposit"))
+	require.NotNil(err)
+	require.True(strings.Contains(err.Error(), "invalid domain signature for deposit"))
 
 	tx = NewTransactionV2(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -341,11 +341,11 @@ func TestDepositLegacy(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain = parseKeyFromHex(receiver.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 
 	tx = NewTransactionV2(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -361,11 +361,11 @@ func TestDepositLegacy(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain = parseKeyFromHex(receiver.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 
 	tx = NewTransactionV2(assetID)
 	tx.AddDepositInput(&DepositData{
@@ -381,19 +381,19 @@ func TestDepositLegacy(t *testing.T) {
 	ver = tx.AsVersioned()
 	domain = parseKeyFromHex(receiver.SpendKey)
 	err = ver.SignRaw(domain)
-	assert.Nil(err)
+	require.Nil(err)
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 
 	pm := ver.Marshal()
 	ver, err = DecompressUnmarshalVersionedTransaction(pm)
-	assert.Nil(err)
-	assert.Equal(1, len(ver.SignaturesMap))
-	assert.Equal(1, len(ver.SignaturesMap[0]))
+	require.Nil(err)
+	require.Equal(1, len(ver.SignaturesMap))
+	require.Equal(1, len(ver.SignaturesMap[0]))
 	msg = ver.PayloadMarshal()
 	signed = &ver.SignedTransaction
 	err = signed.validateDeposit(store, msg, ver.PayloadHash(), ver.SignaturesMap)
-	assert.Nil(err)
+	require.Nil(err)
 }