diff --git a/.avalanche-golangci.yml b/.avalanche-golangci.yml index ecb14ae843..5fd641f0f8 100644 --- a/.avalanche-golangci.yml +++ b/.avalanche-golangci.yml @@ -77,7 +77,7 @@ linters: - spancheck # - staticcheck - tagalign - # - testifylint + - testifylint - unconvert - unparam - unused @@ -208,16 +208,16 @@ linters: - serialize strict: true testifylint: - # Enable all checkers (https://github.com/Antonboom/testifylint#checkers). - # Default: false - enable-all: true - # Disable checkers by name - # (in addition to default - # suite-thelper - # ). - disable: - - go-require - - float-compare + # Enable all checkers (https://github.com/Antonboom/testifylint#checkers). + # Default: false + enable-all: true + # Disable checkers by name + # (in addition to default + # suite-thelper + # ). + disable: + - go-require + - float-compare unused: # Mark all struct fields that have been written to as used. # Default: true diff --git a/accounts/abi/abi_extra_test.go b/accounts/abi/abi_extra_test.go index ed412467f7..31c014ebf4 100644 --- a/accounts/abi/abi_extra_test.go +++ b/accounts/abi/abi_extra_test.go @@ -4,7 +4,6 @@ package abi import ( - "bytes" "math/big" "strings" "testing" @@ -82,14 +81,10 @@ func TestUnpackInputIntoInterface(t *testing.T) { err = abi.UnpackInputIntoInterface(&v, "receive", data, test.strictMode) // skips 4 byte selector if test.expectedErrorSubstring != "" { - require.Error(t, err) require.ErrorContains(t, err, test.expectedErrorSubstring) } else { require.NoError(t, err) - // Verify unpacked values match input - require.Equal(t, v.Amount, input.Amount) - require.EqualValues(t, v.Amount, input.Amount) - require.True(t, bytes.Equal(v.Memo, input.Memo)) + require.Equal(t, input, v) } }) } diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index cbe5bd1b75..7204e3d4ec 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -1319,8 +1319,8 @@ func TestABI_PackEvent(t *testing.T) { t.Fatal(err) } - assert.EqualValues(t, test.expectedTopics, topics) - assert.EqualValues(t, test.expectedData, data) + assert.Equal(t, test.expectedTopics, topics) + assert.Equal(t, test.expectedData, data) }) } } diff --git a/core/blockchain_ext_test.go b/core/blockchain_ext_test.go index 9700614bd4..b4aeef208d 100644 --- a/core/blockchain_ext_test.go +++ b/core/blockchain_ext_test.go @@ -1677,11 +1677,11 @@ func StatefulPrecompiles(t *testing.T, create createFunc) { assert.Equal(allowlist.AdminRole, res) storedConfig := feemanager.GetStoredFeeConfig(sdb) - assert.EqualValues(testFeeConfig, storedConfig) + assert.Equal(testFeeConfig, storedConfig) feeConfig, _, err := blockchain.GetFeeConfigAt(blockchain.CurrentHeader()) - assert.NoError(err) - assert.EqualValues(testFeeConfig, feeConfig) + require.NoError(t, err) + assert.Equal(testFeeConfig, feeConfig) return nil }, verifyGenesis: func(sdb *state.StateDB) { @@ -1689,8 +1689,8 @@ func StatefulPrecompiles(t *testing.T, create createFunc) { assert.Equal(allowlist.AdminRole, res) feeConfig, _, err := blockchain.GetFeeConfigAt(blockchain.Genesis().Header()) - assert.NoError(err) - assert.EqualValues(params.GetExtra(&config).FeeConfig, feeConfig) + require.NoError(t, err) + assert.Equal(params.GetExtra(&config).FeeConfig, feeConfig) }, }, } diff --git a/core/genesis_extra_test.go b/core/genesis_extra_test.go index be1d9ab2b4..0cdf187253 100644 --- a/core/genesis_extra_test.go +++ b/core/genesis_extra_test.go @@ -102,7 +102,7 @@ func TestGenesisToBlockDecoding(t *testing.T) { readHeader := rawdb.ReadHeader(db, block.Hash(), 0) require.Equal(t, block.Hash(), readHeader.Hash()) require.Equal(t, previousHashes[fork], block.Hash()) - require.EqualValues(t, block.Header(), readHeader) + require.Equal(t, block.Header(), readHeader) }) } } diff --git a/core/state_manager_test.go b/core/state_manager_test.go index 4622106bba..3e50c7226b 100644 --- a/core/state_manager_test.go +++ b/core/state_manager_test.go @@ -9,7 +9,7 @@ import ( "github.com/ava-labs/libevm/common" "github.com/ava-labs/libevm/core/types" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // Default state history size @@ -42,7 +42,7 @@ func TestCappedMemoryTrieWriter(t *testing.T) { m := &MockTrieDB{} cacheConfig := &CacheConfig{Pruning: true, CommitInterval: 4096, StateHistory: uint64(tipBufferSize)} w := NewTrieWriter(m, cacheConfig) - assert := assert.New(t) + require := require.New(t) for i := 0; i < int(cacheConfig.CommitInterval)+1; i++ { bigI := big.NewInt(int64(i)) block := types.NewBlock( @@ -53,27 +53,27 @@ func TestCappedMemoryTrieWriter(t *testing.T) { nil, nil, nil, nil, ) - assert.NoError(w.InsertTrie(block)) - assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on insert") - assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on insert") + require.NoError(w.InsertTrie(block)) + require.Zero(m.LastDereference, "should not have dereferenced block on insert") + require.Zero(m.LastCommit, "should not have committed block on insert") w.AcceptTrie(block) if i <= tipBufferSize { - assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on accept") + require.Zero(m.LastDereference, "should not have dereferenced block on accept") } else { - assert.Equal(common.BigToHash(big.NewInt(int64(i-tipBufferSize))), m.LastDereference, "should have dereferenced old block on last accept") + require.Equal(common.BigToHash(big.NewInt(int64(i-tipBufferSize))), m.LastDereference, "should have dereferenced old block on last accept") m.LastDereference = common.Hash{} } if i < int(cacheConfig.CommitInterval) { - assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on accept") + require.Zero(m.LastCommit, "should not have committed block on accept") } else { - assert.Equal(block.Root(), m.LastCommit, "should have committed block after CommitInterval") + require.Equal(block.Root(), m.LastCommit, "should have committed block after CommitInterval") m.LastCommit = common.Hash{} } w.RejectTrie(block) - assert.Equal(block.Root(), m.LastDereference, "should have dereferenced block on reject") - assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on reject") + require.Equal(block.Root(), m.LastDereference, "should have dereferenced block on reject") + require.Zero(m.LastCommit, "should not have committed block on reject") m.LastDereference = common.Hash{} } } @@ -81,7 +81,7 @@ func TestCappedMemoryTrieWriter(t *testing.T) { func TestNoPruningTrieWriter(t *testing.T) { m := &MockTrieDB{} w := NewTrieWriter(m, &CacheConfig{}) - assert := assert.New(t) + require := require.New(t) for i := 0; i < tipBufferSize+1; i++ { bigI := big.NewInt(int64(i)) block := types.NewBlock( @@ -92,18 +92,18 @@ func TestNoPruningTrieWriter(t *testing.T) { nil, nil, nil, nil, ) - assert.NoError(w.InsertTrie(block)) - assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on insert") - assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on insert") + require.NoError(w.InsertTrie(block)) + require.Zero(m.LastDereference, "should not have dereferenced block on insert") + require.Zero(m.LastCommit, "should not have committed block on insert") w.AcceptTrie(block) - assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on accept") - assert.Equal(block.Root(), m.LastCommit, "should have committed block on accept") + require.Zero(m.LastDereference, "should not have dereferenced block on accept") + require.Equal(block.Root(), m.LastCommit, "should have committed block on accept") m.LastCommit = common.Hash{} w.RejectTrie(block) - assert.Equal(block.Root(), m.LastDereference, "should have dereferenced block on reject") - assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on reject") + require.Equal(block.Root(), m.LastDereference, "should have dereferenced block on reject") + require.Zero(m.LastCommit, "should not have committed block on reject") m.LastDereference = common.Hash{} } } diff --git a/network/network.go b/network/network.go index 50a8f44364..33ca5c322d 100644 --- a/network/network.go +++ b/network/network.go @@ -36,6 +36,7 @@ const ( var ( errAcquiringSemaphore = errors.New("error acquiring semaphore") errExpiredRequest = errors.New("expired request") + errNoPeersFound = errors.New("no peers found matching version") _ Network = (*network)(nil) _ validators.Connector = (*network)(nil) _ common.AppHandler = (*network)(nil) @@ -180,7 +181,7 @@ func (n *network) SendAppRequestAny(ctx context.Context, minVersion *version.App } n.activeAppRequests.Release(1) - return ids.EmptyNodeID, fmt.Errorf("no peers found matching version %s out of %d peers", minVersion, n.peers.Size()) + return ids.EmptyNodeID, fmt.Errorf("%w: version: %s, numPeers: %d", errNoPeersFound, minVersion, n.peers.Size()) } // SendAppRequest sends request message bytes to specified nodeID, notifying the responseHandler on response or failure diff --git a/network/network_test.go b/network/network_test.go index 9485b61082..d06d1ad34d 100644 --- a/network/network_test.go +++ b/network/network_test.go @@ -54,8 +54,8 @@ func TestNetworkDoesNotConnectToItself(t *testing.T) { ctx := snowtest.Context(t, snowtest.CChainID) n, err := NewNetwork(ctx, nil, nil, 1, prometheus.NewRegistry()) require.NoError(t, err) - assert.NoError(t, n.Connected(context.Background(), ctx.NodeID, defaultPeerVersion)) - assert.EqualValues(t, 0, n.Size()) + require.NoError(t, n.Connected(context.Background(), ctx.NodeID, defaultPeerVersion)) + require.Zero(t, n.Size()) } func TestRequestAnyRequestsRoutingAndResponse(t *testing.T) { @@ -93,12 +93,12 @@ func TestRequestAnyRequestsRoutingAndResponse(t *testing.T) { require.NoError(t, err) net.SetRequestHandler(&HelloGreetingRequestHandler{codec: codecManager}) nodeID := ids.GenerateTestNodeID() - assert.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion)) + require.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion)) requestMessage := HelloRequest{Message: "this is a request"} defer net.Shutdown() - assert.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion)) + require.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion)) totalRequests := 5000 numCallsPerRequest := 1 // on sending response @@ -125,7 +125,7 @@ func TestRequestAnyRequestsRoutingAndResponse(t *testing.T) { requestWg.Wait() senderWg.Wait() - assert.Equal(t, totalCalls, int(atomic.LoadUint32(&callNum))) + require.Equal(t, totalCalls, int(atomic.LoadUint32(&callNum))) } func TestAppRequestOnCtxCancellation(t *testing.T) { @@ -147,14 +147,14 @@ func TestAppRequestOnCtxCancellation(t *testing.T) { requestMessage := HelloRequest{Message: "this is a request"} requestBytes, err := message.RequestToBytes(codecManager, requestMessage) - assert.NoError(t, err) + require.NoError(t, err) nodeID := ids.GenerateTestNodeID() ctx, cancel := context.WithCancel(context.Background()) // cancel context prior to sending cancel() err = net.SendAppRequest(ctx, nodeID, requestBytes, nil) - assert.ErrorIs(t, err, context.Canceled) + require.ErrorIs(t, err, context.Canceled) } func TestRequestRequestsRoutingAndResponse(t *testing.T) { @@ -205,7 +205,7 @@ func TestRequestRequestsRoutingAndResponse(t *testing.T) { ids.GenerateTestNodeID(), } for _, nodeID := range nodes { - assert.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion)) + require.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion)) } requestMessage := HelloRequest{Message: "this is a request"} @@ -239,7 +239,7 @@ func TestRequestRequestsRoutingAndResponse(t *testing.T) { requestWg.Wait() senderWg.Wait() - assert.Equal(t, totalCalls, int(atomic.LoadUint32(&callNum))) + require.Equal(t, totalCalls, int(atomic.LoadUint32(&callNum))) for _, nodeID := range nodes { if _, exists := contactedNodes[nodeID]; !exists { t.Fatalf("expected nodeID %s to be contacted but was not", nodeID) @@ -247,7 +247,7 @@ func TestRequestRequestsRoutingAndResponse(t *testing.T) { } // ensure empty nodeID is not allowed - assert.ErrorContains(t, + require.ErrorContains(t, net.SendAppRequest(context.Background(), ids.EmptyNodeID, []byte("hello there"), nil), "cannot send request to empty nodeID", ) @@ -286,10 +286,10 @@ func TestAppRequestOnShutdown(t *testing.T) { go func() { defer wg.Done() requestBytes, err := message.RequestToBytes(codecManager, requestMessage) - require.NoError(t, err) + assert.NoError(t, err) responseBytes, _, err := net.SendSyncedAppRequestAny(context.Background(), defaultPeerVersion, requestBytes) - require.Error(t, err, errRequestFailed) - require.Nil(t, responseBytes) + assert.ErrorIs(t, err, errRequestFailed) + assert.Nil(t, responseBytes) }() wg.Wait() require.True(t, called) @@ -309,7 +309,7 @@ func TestSyncedAppRequestAnyOnCtxCancellation(t *testing.T) { return err } - assert.Len(t, nodes, 1) + require.Len(t, nodes, 1) sentAppRequest <- reqInfo{ nodeID: nodes.List()[0], requestID: requestID, @@ -325,7 +325,7 @@ func TestSyncedAppRequestAnyOnCtxCancellation(t *testing.T) { net, err := NewNetwork(snowCtx, sender, codecManager, 1, prometheus.NewRegistry()) require.NoError(t, err) net.SetRequestHandler(&HelloGreetingRequestHandler{codec: codecManager}) - assert.NoError(t, + require.NoError(t, net.Connected( context.Background(), ids.GenerateTestNodeID(), @@ -335,22 +335,22 @@ func TestSyncedAppRequestAnyOnCtxCancellation(t *testing.T) { requestMessage := HelloRequest{Message: "this is a request"} requestBytes, err := message.RequestToBytes(codecManager, requestMessage) - assert.NoError(t, err) + require.NoError(t, err) // cancel context prior to sending ctx, cancel := context.WithCancel(context.Background()) cancel() _, _, err = net.SendSyncedAppRequestAny(ctx, defaultPeerVersion, requestBytes) - assert.ErrorIs(t, err, context.Canceled) - // Assert we didn't send anything + require.ErrorIs(t, err, context.Canceled) + // require we didn't send anything select { case <-sentAppRequest: - assert.FailNow(t, "should not have sent request") + require.FailNow(t, "should not have sent request") default: } // Cancel context after sending - assert.Empty(t, net.(*network).outstandingRequestHandlers) // no outstanding requests + require.Empty(t, net.(*network).outstandingRequestHandlers) // no outstanding requests ctx, cancel = context.WithCancel(context.Background()) doneChan := make(chan struct{}) go func() { @@ -361,13 +361,17 @@ func TestSyncedAppRequestAnyOnCtxCancellation(t *testing.T) { // Wait until we've "sent" the app request over the network // before cancelling context. sentAppRequestInfo := <-sentAppRequest - assert.Len(t, net.(*network).outstandingRequestHandlers, 1) + require.Len(t, net.(*network).outstandingRequestHandlers, 1) cancel() <-doneChan // Should still be able to process a response after cancelling. - assert.Len(t, net.(*network).outstandingRequestHandlers, 1) // context cancellation SendAppRequestAny failure doesn't clear - assert.NoError(t, net.AppResponse(context.Background(), sentAppRequestInfo.nodeID, sentAppRequestInfo.requestID, []byte{})) - assert.Empty(t, net.(*network).outstandingRequestHandlers) // Received response + require.Len(t, net.(*network).outstandingRequestHandlers, 1) // context cancellation SendAppRequestAny failure doesn't clear + require.NoError(t, net.AppResponse( + context.Background(), + sentAppRequestInfo.nodeID, + sentAppRequestInfo.requestID, + []byte{})) + require.Empty(t, net.(*network).outstandingRequestHandlers) // Received response } func TestRequestMinVersion(t *testing.T) { @@ -379,8 +383,8 @@ func TestRequestMinVersion(t *testing.T) { sender := testAppSender{ sendAppRequestFn: func(_ context.Context, nodes set.Set[ids.NodeID], reqID uint32, _ []byte) error { atomic.AddUint32(&callNum, 1) - assert.True(t, nodes.Contains(nodeID), "request nodes should contain expected nodeID") - assert.Len(t, nodes, 1, "request nodes should contain exactly one node") + require.True(t, nodes.Contains(nodeID), "request nodes should contain expected nodeID") + require.Len(t, nodes, 1, "request nodes should contain exactly one node") go func() { time.Sleep(200 * time.Millisecond) @@ -401,8 +405,8 @@ func TestRequestMinVersion(t *testing.T) { require.NoError(t, err) requestMessage := TestMessage{Message: "this is a request"} requestBytes, err := message.RequestToBytes(codecManager, requestMessage) - assert.NoError(t, err) - assert.NoError(t, + require.NoError(t, err) + require.NoError(t, net.Connected( context.Background(), nodeID, @@ -426,18 +430,18 @@ func TestRequestMinVersion(t *testing.T) { }, requestBytes, ) - assert.Equal(t, err.Error(), "no peers found matching version avalanchego/2.0.0 out of 1 peers") - assert.Nil(t, responseBytes) + require.ErrorIs(t, err, errNoPeersFound) + require.Nil(t, responseBytes) // ensure version matches and the request goes through responseBytes, _, err = net.SendSyncedAppRequestAny(context.Background(), defaultPeerVersion, requestBytes) - assert.NoError(t, err) + require.NoError(t, err) var response TestMessage if _, err = codecManager.Unmarshal(responseBytes, &response); err != nil { t.Fatal("unexpected error during unmarshal", err) } - assert.Equal(t, "this is a response", response.Message) + require.Equal(t, "this is a response", response.Message) } func TestOnRequestHonoursDeadline(t *testing.T) { @@ -455,7 +459,7 @@ func TestOnRequestHonoursDeadline(t *testing.T) { codecManager := buildCodec(t, TestMessage{}) requestBytes, err := marshalStruct(codecManager, TestMessage{Message: "hello there"}) - assert.NoError(t, err) + require.NoError(t, err) requestHandler := &testRequestHandler{ processingDuration: 500 * time.Millisecond, @@ -468,16 +472,15 @@ func TestOnRequestHonoursDeadline(t *testing.T) { nodeID := ids.GenerateTestNodeID() requestHandler.response, err = marshalStruct(codecManager, TestMessage{Message: "hi there"}) - assert.NoError(t, err) - assert.NoError(t, net.AppRequest(context.Background(), nodeID, 0, time.Now().Add(1*time.Millisecond), requestBytes)) - + require.NoError(t, err) + require.NoError(t, net.AppRequest(context.Background(), nodeID, 0, time.Now().Add(1*time.Millisecond), requestBytes)) // ensure the handler didn't get called (as peer.Network would've dropped the request) - assert.EqualValues(t, requestHandler.calls, 0) + require.Zero(t, requestHandler.calls) requestHandler.processingDuration = 0 - assert.NoError(t, net.AppRequest(context.Background(), nodeID, 2, time.Now().Add(250*time.Millisecond), requestBytes)) - assert.True(t, responded) - assert.EqualValues(t, requestHandler.calls, 1) + require.NoError(t, net.AppRequest(context.Background(), nodeID, 2, time.Now().Add(250*time.Millisecond), requestBytes)) + require.True(t, responded) + require.Equal(t, uint32(1), requestHandler.calls) } func TestHandleInvalidMessages(t *testing.T) { @@ -494,18 +497,18 @@ func TestHandleInvalidMessages(t *testing.T) { require.NoError(t, err) clientNetwork.SetRequestHandler(&testRequestHandler{}) - assert.NoError(t, clientNetwork.Connected(context.Background(), nodeID, defaultPeerVersion)) + require.NoError(t, clientNetwork.Connected(context.Background(), nodeID, defaultPeerVersion)) defer clientNetwork.Shutdown() // Ensure a valid gossip message sent as any App specific message type does not trigger a fatal error marshaller := helloGossipMarshaller{codec: codecManager} gossipMsg, err := marshaller.MarshalGossip(&HelloGossip{Msg: "hello there!"}) - assert.NoError(t, err) + require.NoError(t, err) // Ensure a valid request message sent as any App specific message type does not trigger a fatal error requestMessage, err := marshalStruct(codecManager, TestMessage{Message: "Hello"}) - assert.NoError(t, err) + require.NoError(t, err) // Ensure a random message sent as any App specific message type does not trigger a fatal error garbageResponse := make([]byte, 10) @@ -515,21 +518,31 @@ func TestHandleInvalidMessages(t *testing.T) { var nilResponse []byte // Check for edge cases - assert.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, gossipMsg)) - assert.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, requestMessage)) - assert.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, garbageResponse)) - assert.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, emptyResponse)) - assert.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, nilResponse)) - assert.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), gossipMsg)) - assert.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), requestMessage)) - assert.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), garbageResponse)) - assert.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), emptyResponse)) - assert.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), nilResponse)) - assert.ErrorIs(t, p2p.ErrUnrequestedResponse, clientNetwork.AppResponse(context.Background(), nodeID, requestID, gossipMsg)) - assert.ErrorIs(t, p2p.ErrUnrequestedResponse, clientNetwork.AppResponse(context.Background(), nodeID, requestID, requestMessage)) - assert.ErrorIs(t, p2p.ErrUnrequestedResponse, clientNetwork.AppResponse(context.Background(), nodeID, requestID, garbageResponse)) - assert.ErrorIs(t, p2p.ErrUnrequestedResponse, clientNetwork.AppResponse(context.Background(), nodeID, requestID, emptyResponse)) - assert.ErrorIs(t, p2p.ErrUnrequestedResponse, clientNetwork.AppResponse(context.Background(), nodeID, requestID, nilResponse)) + require.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, gossipMsg)) + require.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, requestMessage)) + require.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, garbageResponse)) + require.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, emptyResponse)) + require.NoError(t, clientNetwork.AppGossip(context.Background(), nodeID, nilResponse)) + require.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), gossipMsg)) + require.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), requestMessage)) + require.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), garbageResponse)) + require.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), emptyResponse)) + require.NoError(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), nilResponse)) + + err = clientNetwork.AppResponse(context.Background(), nodeID, requestID, gossipMsg) + require.ErrorIs(t, err, p2p.ErrUnrequestedResponse) + + err = clientNetwork.AppResponse(context.Background(), nodeID, requestID, requestMessage) + require.ErrorIs(t, err, p2p.ErrUnrequestedResponse) + + err = clientNetwork.AppResponse(context.Background(), nodeID, requestID, garbageResponse) + require.ErrorIs(t, err, p2p.ErrUnrequestedResponse) + + err = clientNetwork.AppResponse(context.Background(), nodeID, requestID, emptyResponse) + require.ErrorIs(t, err, p2p.ErrUnrequestedResponse) + + err = clientNetwork.AppResponse(context.Background(), nodeID, requestID, nilResponse) + require.ErrorIs(t, err, p2p.ErrUnrequestedResponse) } func TestNetworkPropagatesRequestHandlerError(t *testing.T) { @@ -543,16 +556,16 @@ func TestNetworkPropagatesRequestHandlerError(t *testing.T) { require.NoError(t, err) clientNetwork.SetRequestHandler(&testRequestHandler{err: errors.New("fail")}) // Return an error from the request handler - assert.NoError(t, clientNetwork.Connected(context.Background(), nodeID, defaultPeerVersion)) + require.NoError(t, clientNetwork.Connected(context.Background(), nodeID, defaultPeerVersion)) defer clientNetwork.Shutdown() // Ensure a valid request message sent as any App specific message type does not trigger a fatal error requestMessage, err := marshalStruct(codecManager, TestMessage{Message: "Hello"}) - assert.NoError(t, err) + require.NoError(t, err) // Check that if the request handler returns an error, it is propagated as a fatal error. - assert.Error(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), requestMessage)) + require.ErrorContains(t, clientNetwork.AppRequest(context.Background(), nodeID, requestID, time.Now().Add(time.Second), requestMessage), "fail") } func TestNetworkAppRequestAfterShutdown(t *testing.T) { @@ -604,9 +617,9 @@ func buildCodec(t *testing.T, types ...interface{}) codec.Manager { codecManager := codec.NewDefaultManager() c := linearcodec.NewDefault() for _, typ := range types { - assert.NoError(t, c.RegisterType(typ)) + require.NoError(t, c.RegisterType(typ)) } - assert.NoError(t, codecManager.RegisterCodec(message.Version, c)) + require.NoError(t, codecManager.RegisterCodec(message.Version, c)) return codecManager } diff --git a/params/extras/network_upgrades_test.go b/params/extras/network_upgrades_test.go index c6b146a535..c3088ad696 100644 --- a/params/extras/network_upgrades_test.go +++ b/params/extras/network_upgrades_test.go @@ -346,9 +346,9 @@ func TestSetDefaultsTreatsZeroAsUnset(t *testing.T) { defaults := GetNetworkUpgrades(agoUpgrades) - require.EqualValues(t, defaults.SubnetEVMTimestamp, upgrades.SubnetEVMTimestamp) - require.EqualValues(t, defaults.DurangoTimestamp, upgrades.DurangoTimestamp) - require.EqualValues(t, defaults.EtnaTimestamp, upgrades.EtnaTimestamp) - require.EqualValues(t, defaults.FortunaTimestamp, upgrades.FortunaTimestamp) - require.EqualValues(t, defaults.GraniteTimestamp, upgrades.GraniteTimestamp) + require.Equal(t, defaults.SubnetEVMTimestamp, upgrades.SubnetEVMTimestamp) + require.Equal(t, defaults.DurangoTimestamp, upgrades.DurangoTimestamp) + require.Equal(t, defaults.EtnaTimestamp, upgrades.EtnaTimestamp) + require.Equal(t, defaults.FortunaTimestamp, upgrades.FortunaTimestamp) + require.Equal(t, defaults.GraniteTimestamp, upgrades.GraniteTimestamp) } diff --git a/params/extras/precompile_config_test.go b/params/extras/precompile_config_test.go index a978e3ae2b..a02a20afb7 100644 --- a/params/extras/precompile_config_test.go +++ b/params/extras/precompile_config_test.go @@ -325,7 +325,7 @@ func TestPrecompileUpgradeUnmarshalJSON(t *testing.T) { require.Len(upgradeConfig.PrecompileUpgrades, 2) rewardManagerConf := upgradeConfig.PrecompileUpgrades[0] - require.Equal(rewardManagerConf.Key(), rewardmanager.ConfigKey) + require.Equal(rewardmanager.ConfigKey, rewardManagerConf.Key()) testRewardManagerConfig := rewardmanager.NewConfig( utils.NewUint64(1671542573), []common.Address{common.HexToAddress("0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC")}, @@ -337,7 +337,7 @@ func TestPrecompileUpgradeUnmarshalJSON(t *testing.T) { require.True(rewardManagerConf.Equal(testRewardManagerConfig)) nativeMinterConfig := upgradeConfig.PrecompileUpgrades[1] - require.Equal(nativeMinterConfig.Key(), nativeminter.ConfigKey) + require.Equal(nativeminter.ConfigKey, nativeMinterConfig.Key()) expectedNativeMinterConfig := nativeminter.NewConfig(utils.NewUint64(1671543172), nil, nil, nil, nil) require.True(nativeMinterConfig.Equal(expectedNativeMinterConfig)) diff --git a/plugin/evm/config/config_test.go b/plugin/evm/config/config_test.go index f27d92ff81..ac978d15da 100644 --- a/plugin/evm/config/config_test.go +++ b/plugin/evm/config/config_test.go @@ -11,7 +11,6 @@ import ( "github.com/ava-labs/avalanchego/utils/constants" "github.com/ava-labs/libevm/common" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -114,11 +113,11 @@ func TestUnmarshalConfig(t *testing.T) { var tmp Config err := json.Unmarshal(tt.givenJSON, &tmp) if tt.expectedErr { - assert.Error(t, err) + require.Error(t, err) } else { - assert.NoError(t, err) + require.NoError(t, err) tmp.deprecate() - assert.Equal(t, tt.expected, tmp) + require.Equal(t, tt.expected, tmp) } }) } diff --git a/plugin/evm/gossiper_eth_gossiping_test.go b/plugin/evm/gossiper_eth_gossiping_test.go index acfdd08887..63444938e3 100644 --- a/plugin/evm/gossiper_eth_gossiping_test.go +++ b/plugin/evm/gossiper_eth_gossiping_test.go @@ -18,7 +18,7 @@ import ( "github.com/ava-labs/libevm/common" "github.com/ava-labs/libevm/core/types" "github.com/ava-labs/libevm/crypto" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/core" "github.com/ava-labs/subnet-evm/params" @@ -71,23 +71,22 @@ func getValidEthTxs(key *ecdsa.PrivateKey, count int, gasPrice *big.Int) []*type // show that a geth tx discovered from gossip is requested to the same node that // gossiped it func TestMempoolEthTxsAppGossipHandling(t *testing.T) { - assert := assert.New(t) + require := require.New(t) key, err := crypto.GenerateKey() - assert.NoError(err) + require.NoError(err) addr := crypto.PubkeyToAddress(key.PublicKey) genesisJSON, err := fundAddressByGenesis([]common.Address{addr}) - assert.NoError(err) + require.NoError(err) tvm := newVM(t, testVMConfig{ genesisJSON: genesisJSON, }) defer func() { - err := tvm.vm.Shutdown(context.Background()) - assert.NoError(err) + require.NoError(tvm.vm.Shutdown(context.Background())) }() tvm.vm.txPool.SetGasTip(common.Big1) tvm.vm.txPool.SetMinFee(common.Big0) @@ -112,9 +111,8 @@ func TestMempoolEthTxsAppGossipHandling(t *testing.T) { // Txs must be submitted over the API to be included in push gossip. // (i.e., txs received via p2p are not included in push gossip) - err = tvm.vm.eth.APIBackend.SendTx(context.Background(), tx) - assert.NoError(err) - assert.False(txRequested, "tx should not be requested") + require.NoError(tvm.vm.eth.APIBackend.SendTx(context.Background(), tx)) + require.False(txRequested, "tx should not be requested") // wait for transaction to be re-gossiped attemptAwait(t, &wg, 5*time.Second) diff --git a/plugin/evm/log/log_test.go b/plugin/evm/log/log_test.go index 220c0963d9..202c4fdfa6 100644 --- a/plugin/evm/log/log_test.go +++ b/plugin/evm/log/log_test.go @@ -28,7 +28,7 @@ func TestInitLogger(t *testing.T) { require := require.New(t) _, err := InitLogger("alias", test.logLevel, true, os.Stderr) if test.expectedErr { - require.Error(err) + require.ErrorContains(err, "unknown level") } else { require.NoError(err) } diff --git a/plugin/evm/message/block_request_test.go b/plugin/evm/message/block_request_test.go index dc3278f01e..31b2fcd2bd 100644 --- a/plugin/evm/message/block_request_test.go +++ b/plugin/evm/message/block_request_test.go @@ -9,10 +9,10 @@ import ( "testing" "github.com/ava-labs/libevm/common" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -// TestMarshalBlockRequest asserts that the structure or serialization logic hasn't changed, primarily to +// TestMarshalBlockRequest requires that the structure or serialization logic hasn't changed, primarily to // ensure compatibility with the network. func TestMarshalBlockRequest(t *testing.T) { blockRequest := BlockRequest{ @@ -24,18 +24,18 @@ func TestMarshalBlockRequest(t *testing.T) { base64BlockRequest := "AAAAAAAAAAAAAAAAAABzb21lIGhhc2ggaXMgaGVyZSB5bwAAAAAAAAU5AEA=" blockRequestBytes, err := Codec.Marshal(Version, blockRequest) - assert.NoError(t, err) - assert.Equal(t, base64BlockRequest, base64.StdEncoding.EncodeToString(blockRequestBytes)) + require.NoError(t, err) + require.Equal(t, base64BlockRequest, base64.StdEncoding.EncodeToString(blockRequestBytes)) var b BlockRequest _, err = Codec.Unmarshal(blockRequestBytes, &b) - assert.NoError(t, err) - assert.Equal(t, blockRequest.Hash, b.Hash) - assert.Equal(t, blockRequest.Height, b.Height) - assert.Equal(t, blockRequest.Parents, b.Parents) + require.NoError(t, err) + require.Equal(t, blockRequest.Hash, b.Hash) + require.Equal(t, blockRequest.Height, b.Height) + require.Equal(t, blockRequest.Parents, b.Parents) } -// TestMarshalBlockResponse asserts that the structure or serialization logic hasn't changed, primarily to +// TestMarshalBlockResponse requires that the structure or serialization logic hasn't changed, primarily to // ensure compatibility with the network. func TestMarshalBlockResponse(t *testing.T) { // create some random bytes @@ -45,7 +45,7 @@ func TestMarshalBlockResponse(t *testing.T) { for i := range blocksBytes { blocksBytes[i] = make([]byte, rand.Intn(32)+32) // min 32 length, max 64 _, err := rand.Read(blocksBytes[i]) - assert.NoError(t, err) + require.NoError(t, err) } blockResponse := BlockResponse{ @@ -55,11 +55,11 @@ func TestMarshalBlockResponse(t *testing.T) { base64BlockResponse := "AAAAAAAgAAAAIU8WP18PmmIdcpVmx00QA3xNe7sEB9HixkmBhVrYaB0NhgAAADnR6ZTSxCKs0gigByk5SH9pmeudGKRHhARdh/PGfPInRumVr1olNnlRuqL/bNRxxIPxX7kLrbN8WCEAAAA6tmgLTnyLdjobHUnUlVyEhiFjJSU/7HON16nii/khEZwWDwcCRIYVu9oIMT9qjrZo0gv1BZh1kh5migAAACtb3yx/xIRo0tbFL1BU4tCDa/hMcXTLdHY2TMPb2Wiw9xcu2FeUuzWLDDtSAAAAO12heG+f69ehnQ97usvgJVqlt9RL7ED4TIkrm//UNimwIjvupfT3Q5H0RdFa/UKUBAN09pJLmMv4cT+NAAAAMpYtJOLK/Mrjph+1hrFDI6a8j5598dkpMz/5k5M76m9bOvbeA3Q2bEcZ5DobBn2JvH8BAAAAOfHxekxyFaO1OeseWEnGB327VyL1cXoomiZvl2R5gZmOvqicC0s3OXARXoLtb0ElyPpzEeTX3vqSLQAAACc2zU8kq/ffhmuqVgODZ61hRd4e6PSosJk+vfiIOgrYvpw5eLBIg+UAAAAkahVqnexqQOmh0AfwM8KCMGG90Oqln45NpkMBBSINCyloi3NLAAAAKI6gENd8luqAp6Zl9gb2pjt/Pf0lZ8GJeeTWDyZobZvy+ybJAf81TN4AAAA8FgfuKbpk+Eq0PKDG5rkcH9O+iZBDQXnTr0SRo2kBLbktGE/DnRc0/1cWQolTu2hl/PkrDDoXyQKL6ZFOAAAAMwl50YMDVvKlTD3qsqS0R11jr76PtWmHx39YGFJvGBS+gjNQ6rE5NfMdhEhFF+kkrveK4QAAADhRwAdVkgww7CmjcDk0v1CijaECl13tp351hXnqPf5BNqv3UrO4Jx0D6USzyds2a3UEX479adIq5QAAADpBGUfLVbzqQGsy1hCL1oWE9X43yqxuM/6qMmOjmUNwJLqcmxRniidPAakQrilfbvv+X1q/RMzeJjtWAAAAKAZjPn05Bp8BojnENlhUw69/a0HWMfkrmo0S9BJXMl//My91drBiBVYAAAAqMEo+Pq6QGlJyDahcoeSzjq8/RMbG74Ni8vVPwA4J1vwlZAhUwV38rKqKAAAAOyzszlo6lLTTOKUUPmNAjYcksM8/rhej95vhBy+2PDXWBCxBYPOO6eKp8/tP+wAZtFTVIrX/oXYEGT+4AAAAMpZnz1PD9SDIibeb9QTPtXx2ASMtWJuszqnW4mPiXCd0HT9sYsu7FdmvvL9/faQasECOAAAALzk4vxd0rOdwmk8JHpqD/erg7FXrIzqbU5TLPHhWtUbTE8ijtMHA4FRH9Lo3DrNtAAAAPLz97PUi4qbx7Qr+wfjiD6q+32sWLnF9OnSKWGd6DFY0j4khomaxHQ8zTGL+UrpTrxl3nLKUi2Vw/6C3cwAAADqWPBMK15dRJSEPDvHDFAkPB8eab1ccJG8+msC3QT7xEL1YsAznO/9wb3/0tvRAkKMnEfMgjk5LictRAAAAJ2XOZAA98kaJKNWiO5ynQPgMk4LZxgNK0pYMeWUD4c4iFyX1DK8fvwAAADtcR6U9v459yvyeE4ZHpLRO1LzpZO1H90qllEaM7TI8t28NP6xHbJ+wP8kij7roj9WAZjoEVLaDEiB/CgAAADc7WExi1QJ84VpPClglDY+1Dnfyv08BUuXUlDWAf51Ll75vt3lwRmpWJv4zQIz56I4seXQIoy0pAAAAKkFrryBqmDIJgsharXA4SFnAWksTodWy9b/vWm7ZLaSCyqlWjltv6dip3QAAAC7Z6wkne1AJRMvoAKCxUn6mRymoYdL2SXoyNcN/QZJ3nsHZazscVCT84LcnsDByAAAAI+ZAq8lEj93rIZHZRcBHZ6+Eev0O212IV7eZrLGOSv+r4wN/AAAAL/7MQW5zTTc8Xr68nNzFlbzOPHvT2N+T+rfhJd3rr+ZaMb1dQeLSzpwrF4kvD+oZAAAAMTGikNy/poQG6HcHP/CINOGXpANKpIr6P4W4picIyuu6yIC1uJuT2lOBAWRAIQTmSLYAAAA1ImobDzE6id38RUxfj3KsibOLGfU3hMGem+rAPIdaJ9sCneN643pCMYgTSHaFkpNZyoxeuU4AAAA9FS3Br0LquOKSXG2u5N5e+fnc8I38vQK4CAk5hYWSig995QvhptwdV2joU3mI/dzlYum5SMkYu6PpM+XEAAAAAC3Nrne6HSWbGIpLIchvvCPXKLRTR+raZQryTFbQgAqGkTMgiKgFvVXERuJesHU=" blockResponseBytes, err := Codec.Marshal(Version, blockResponse) - assert.NoError(t, err) - assert.Equal(t, base64BlockResponse, base64.StdEncoding.EncodeToString(blockResponseBytes)) + require.NoError(t, err) + require.Equal(t, base64BlockResponse, base64.StdEncoding.EncodeToString(blockResponseBytes)) var b BlockResponse _, err = Codec.Unmarshal(blockResponseBytes, &b) - assert.NoError(t, err) - assert.Equal(t, blockResponse.Blocks, b.Blocks) + require.NoError(t, err) + require.Equal(t, blockResponse.Blocks, b.Blocks) } diff --git a/plugin/evm/message/code_request_test.go b/plugin/evm/message/code_request_test.go index 4e3ba23be9..96988da58d 100644 --- a/plugin/evm/message/code_request_test.go +++ b/plugin/evm/message/code_request_test.go @@ -9,10 +9,10 @@ import ( "testing" "github.com/ava-labs/libevm/common" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -// TestMarshalCodeRequest asserts that the structure or serialization logic hasn't changed, primarily to +// TestMarshalCodeRequest requires that the structure or serialization logic hasn't changed, primarily to // ensure compatibility with the network. func TestMarshalCodeRequest(t *testing.T) { codeRequest := CodeRequest{ @@ -22,16 +22,16 @@ func TestMarshalCodeRequest(t *testing.T) { base64CodeRequest := "AAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAHNvbWUgY29kZSBwbHM=" codeRequestBytes, err := Codec.Marshal(Version, codeRequest) - assert.NoError(t, err) - assert.Equal(t, base64CodeRequest, base64.StdEncoding.EncodeToString(codeRequestBytes)) + require.NoError(t, err) + require.Equal(t, base64CodeRequest, base64.StdEncoding.EncodeToString(codeRequestBytes)) var c CodeRequest _, err = Codec.Unmarshal(codeRequestBytes, &c) - assert.NoError(t, err) - assert.Equal(t, codeRequest.Hashes, c.Hashes) + require.NoError(t, err) + require.Equal(t, codeRequest.Hashes, c.Hashes) } -// TestMarshalCodeResponse asserts that the structure or serialization logic hasn't changed, primarily to +// TestMarshalCodeResponse requires that the structure or serialization logic hasn't changed, primarily to // ensure compatibility with the network. func TestMarshalCodeResponse(t *testing.T) { // generate some random code data @@ -39,7 +39,7 @@ func TestMarshalCodeResponse(t *testing.T) { rand := rand.New(rand.NewSource(1)) codeData := make([]byte, 50) _, err := rand.Read(codeData) - assert.NoError(t, err) + require.NoError(t, err) codeResponse := CodeResponse{ Data: [][]byte{codeData}, @@ -48,11 +48,11 @@ func TestMarshalCodeResponse(t *testing.T) { base64CodeResponse := "AAAAAAABAAAAMlL9/AchgmVPFj9fD5piHXKVZsdNEAN8TXu7BAfR4sZJgYVa2GgdDYbR6R4AFnk5y2aU" codeResponseBytes, err := Codec.Marshal(Version, codeResponse) - assert.NoError(t, err) - assert.Equal(t, base64CodeResponse, base64.StdEncoding.EncodeToString(codeResponseBytes)) + require.NoError(t, err) + require.Equal(t, base64CodeResponse, base64.StdEncoding.EncodeToString(codeResponseBytes)) var c CodeResponse _, err = Codec.Unmarshal(codeResponseBytes, &c) - assert.NoError(t, err) - assert.Equal(t, codeResponse.Data, c.Data) + require.NoError(t, err) + require.Equal(t, codeResponse.Data, c.Data) } diff --git a/plugin/evm/message/leafs_request_test.go b/plugin/evm/message/leafs_request_test.go index efe5920ecb..e1529596af 100644 --- a/plugin/evm/message/leafs_request_test.go +++ b/plugin/evm/message/leafs_request_test.go @@ -13,9 +13,10 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/libevm/common" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -// TestMarshalLeafsRequest asserts that the structure or serialization logic hasn't changed, primarily to +// TestMarshalLeafsRequest requires that the structure or serialization logic hasn't changed, primarily to // ensure compatibility with the network. func TestMarshalLeafsRequest(t *testing.T) { // generate some random code data @@ -26,10 +27,10 @@ func TestMarshalLeafsRequest(t *testing.T) { endBytes := make([]byte, common.HashLength) _, err := rand.Read(startBytes) - assert.NoError(t, err) + require.NoError(t, err) _, err = rand.Read(endBytes) - assert.NoError(t, err) + require.NoError(t, err) leafsRequest := LeafsRequest{ Root: common.BytesToHash([]byte("im ROOTing for ya")), @@ -41,19 +42,19 @@ func TestMarshalLeafsRequest(t *testing.T) { base64LeafsRequest := "AAAAAAAAAAAAAAAAAAAAAABpbSBST09UaW5nIGZvciB5YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFL9/AchgmVPFj9fD5piHXKVZsdNEAN8TXu7BAfR4sZJAAAAIIGFWthoHQ2G0ekeABZ5OctmlNLEIqzSCKAHKTlIf2mZBAA=" leafsRequestBytes, err := Codec.Marshal(Version, leafsRequest) - assert.NoError(t, err) - assert.Equal(t, base64LeafsRequest, base64.StdEncoding.EncodeToString(leafsRequestBytes)) + require.NoError(t, err) + require.Equal(t, base64LeafsRequest, base64.StdEncoding.EncodeToString(leafsRequestBytes)) var l LeafsRequest _, err = Codec.Unmarshal(leafsRequestBytes, &l) - assert.NoError(t, err) - assert.Equal(t, leafsRequest.Root, l.Root) - assert.Equal(t, leafsRequest.Start, l.Start) - assert.Equal(t, leafsRequest.End, l.End) - assert.Equal(t, leafsRequest.Limit, l.Limit) + require.NoError(t, err) + require.Equal(t, leafsRequest.Root, l.Root) + require.Equal(t, leafsRequest.Start, l.Start) + require.Equal(t, leafsRequest.End, l.End) + require.Equal(t, leafsRequest.Limit, l.Limit) } -// TestMarshalLeafsResponse asserts that the structure or serialization logic hasn't changed, primarily to +// TestMarshalLeafsResponse requires that the structure or serialization logic hasn't changed, primarily to // ensure compatibility with the network. func TestMarshalLeafsResponse(t *testing.T) { // generate some random code data @@ -67,21 +68,21 @@ func TestMarshalLeafsResponse(t *testing.T) { valsBytes[i] = make([]byte, rand.Intn(8)+8) // min 8 bytes, max 16 bytes _, err := rand.Read(keysBytes[i]) - assert.NoError(t, err) + require.NoError(t, err) _, err = rand.Read(valsBytes[i]) - assert.NoError(t, err) + require.NoError(t, err) } nextKey := make([]byte, common.HashLength) _, err := rand.Read(nextKey) - assert.NoError(t, err) + require.NoError(t, err) proofVals := make([][]byte, 4) for i := range proofVals { proofVals[i] = make([]byte, rand.Intn(8)+8) // min 8 bytes, max 16 bytes _, err = rand.Read(proofVals[i]) - assert.NoError(t, err) + require.NoError(t, err) } leafsResponse := LeafsResponse{ @@ -94,16 +95,16 @@ func TestMarshalLeafsResponse(t *testing.T) { base64LeafsResponse := "AAAAAAAQAAAAIE8WP18PmmIdcpVmx00QA3xNe7sEB9HixkmBhVrYaB0NAAAAIGagByk5SH9pmeudGKRHhARdh/PGfPInRumVr1olNnlRAAAAIK2zfFghtmgLTnyLdjobHUnUlVyEhiFjJSU/7HON16niAAAAIIYVu9oIMfUFmHWSHmaKW98sf8SERZLSVyvNBmjS1sUvAAAAIHHb2Wiw9xcu2FeUuzWLDDtSXaF4b5//CUJ52xlE69ehAAAAIPhMiSs77qX090OR9EXRWv1ClAQDdPaSS5jL+HE/jZYtAAAAIMr8yuOmvI+effHZKTM/+ZOTO+pvWzr23gN0NmxHGeQ6AAAAIBZZpE856x5YScYHfbtXIvVxeiiaJm+XZHmBmY6+qJwLAAAAIHOq53hmZ/fpNs1PJKv334ZrqlYDg2etYUXeHuj0qLCZAAAAIHiN5WOvpGfUnexqQOmh0AfwM8KCMGG90Oqln45NpkMBAAAAIKAQ13yW6oCnpmX2BvamO389/SVnwYl55NYPJmhtm/L7AAAAIAfuKbpk+Eq0PKDG5rkcH9O+iZBDQXnTr0SRo2kBLbktAAAAILsXyQKL6ZFOt2ScbJNHgAl50YMDVvKlTD3qsqS0R11jAAAAIOqxOTXzHYRIRRfpJK73iuFRwAdVklg2twdYhWUMMOwpAAAAIHnqPf5BNqv3UrO4Jx0D6USzyds2a3UEX479adIq5UEZAAAAIDLWEMqsbjP+qjJjo5lDcCS6nJsUZ4onTwGpEK4pX277AAAAEAAAAAmG0ekeABZ5OcsAAAAMuqL/bNRxxIPxX7kLAAAACov5IRGcFg8HAkQAAAAIUFTi0INr+EwAAAAOnQ97usvgJVqlt9RL7EAAAAAJfI0BkZLCQiTiAAAACxsGfYm8fwHx9XOYAAAADUs3OXARXoLtb0ElyPoAAAAKPr34iDoK2L6cOQAAAAoFIg0LKWiLc0uOAAAACCbJAf81TN4WAAAADBhPw50XNP9XFkKJUwAAAAuvvo+1aYfHf1gYUgAAAAqjcDk0v1CijaECAAAADkfLVT12lCZ670686kBrAAAADf5fWr9EzN4mO1YGYz4AAAAEAAAADlcyXwVWMEo+Pq4Uwo0MAAAADeo50qHks46vP0TGxu8AAAAOg2Ly9WQIVMFd/KyqiiwAAAAL7M5aOpS00zilFD4=" leafsResponseBytes, err := Codec.Marshal(Version, leafsResponse) - assert.NoError(t, err) - assert.Equal(t, base64LeafsResponse, base64.StdEncoding.EncodeToString(leafsResponseBytes)) + require.NoError(t, err) + require.Equal(t, base64LeafsResponse, base64.StdEncoding.EncodeToString(leafsResponseBytes)) var l LeafsResponse _, err = Codec.Unmarshal(leafsResponseBytes, &l) - assert.NoError(t, err) - assert.Equal(t, leafsResponse.Keys, l.Keys) - assert.Equal(t, leafsResponse.Vals, l.Vals) - assert.False(t, l.More) // make sure it is not serialized - assert.Equal(t, leafsResponse.ProofVals, l.ProofVals) + require.NoError(t, err) + require.Equal(t, leafsResponse.Keys, l.Keys) + require.Equal(t, leafsResponse.Vals, l.Vals) + require.False(t, l.More) // make sure it is not serialized + require.Equal(t, leafsResponse.ProofVals, l.ProofVals) } func TestLeafsRequestValidation(t *testing.T) { diff --git a/plugin/evm/syncervm_test.go b/plugin/evm/syncervm_test.go index e54a8cf99f..5d2da06f00 100644 --- a/plugin/evm/syncervm_test.go +++ b/plugin/evm/syncervm_test.go @@ -160,8 +160,8 @@ func TestStateSyncToggleEnabledToDisabled(t *testing.T) { t.Fatalf("Unexpected last accepted height: %d", height) } - enabled, err := syncDisabledVM.Client.StateSyncEnabled(context.Background()) - assert.NoError(t, err) + enabled, err := syncDisabledVM.StateSyncEnabled(context.Background()) + require.NoError(t, err) assert.False(t, enabled, "sync should be disabled") // Process the first 10 blocks from the serverVM @@ -226,14 +226,14 @@ func TestStateSyncToggleEnabledToDisabled(t *testing.T) { } // connect peer to [syncerVM] - assert.NoError(t, syncReEnabledVM.Connected( + require.NoError(t, syncReEnabledVM.Connected( context.Background(), vmSetup.serverVM.ctx.NodeID, statesyncclient.StateSyncVersion, )) enabled, err = syncReEnabledVM.StateSyncEnabled(context.Background()) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, enabled, "sync should be enabled") vmSetup.syncerVM = syncReEnabledVM @@ -435,7 +435,7 @@ func testSyncerVM(t *testing.T, vmSetup *syncVMSetup, test syncTest) { msg, err := syncerVM.WaitForEvent(context.Background()) require.NoError(err) - require.Equal(msg, commonEng.StateSyncDone) + require.Equal(commonEng.StateSyncDone, msg) // If the test is expected to error, assert the correct error is returned and finish the test. err = syncerVM.Client.Error() diff --git a/plugin/evm/tx_gossip_test.go b/plugin/evm/tx_gossip_test.go index 973ec32367..cf9209362d 100644 --- a/plugin/evm/tx_gossip_test.go +++ b/plugin/evm/tx_gossip_test.go @@ -133,7 +133,7 @@ func TestEthTxGossip(t *testing.T) { errs := vm.txPool.Add([]*types.Transaction{signedTx}, true, true) require.Len(errs, 1) - require.Nil(errs[0]) + require.NoError(errs[0]) // wait so we aren't throttled by the vm time.Sleep(5 * time.Second) diff --git a/plugin/evm/vm_test.go b/plugin/evm/vm_test.go index 2331bab992..99e1554b7e 100644 --- a/plugin/evm/vm_test.go +++ b/plugin/evm/vm_test.go @@ -2667,7 +2667,7 @@ func TestFeeManagerChangeFee(t *testing.T) { // Contract is initialized but no preconfig is given, reader should return genesis fee config feeConfig, lastChangedAt, err := tvm.vm.blockChain.GetFeeConfigAt(tvm.vm.blockChain.Genesis().Header()) require.NoError(t, err) - require.EqualValues(t, feeConfig, testLowFeeConfig) + require.Equal(t, testLowFeeConfig, feeConfig) require.Zero(t, tvm.vm.blockChain.CurrentBlock().Number.Cmp(lastChangedAt)) // set a different fee config now @@ -2708,8 +2708,8 @@ func TestFeeManagerChangeFee(t *testing.T) { feeConfig, lastChangedAt, err = tvm.vm.blockChain.GetFeeConfigAt(block.Header()) require.NoError(t, err) - require.EqualValues(t, testHighFeeConfig, feeConfig) - require.EqualValues(t, tvm.vm.blockChain.CurrentBlock().Number, lastChangedAt) + require.Equal(t, testHighFeeConfig, feeConfig) + require.Equal(t, tvm.vm.blockChain.CurrentBlock().Number, lastChangedAt) // should fail, with same params since fee is higher now tx2 := types.NewTx(&types.DynamicFeeTx{ @@ -3469,8 +3469,8 @@ func TestFeeManagerRegressionMempoolMinFeeAfterRestart(t *testing.T) { // return the chain config fee config and lastChangedAt as zero, which is not correct after activation. feeConfig, lastChangedAt, err := restartedVM.blockChain.GetFeeConfigAt(restartedVM.blockChain.CurrentBlock()) require.NoError(t, err) - require.EqualValues(t, feeConfig, testHighFeeConfig) - require.EqualValues(t, restartedVM.blockChain.CurrentBlock().Number, lastChangedAt) + require.Equal(t, testHighFeeConfig, feeConfig) + require.Equal(t, restartedVM.blockChain.CurrentBlock().Number, lastChangedAt) // set a lower fee config now through feemanager testLowFeeConfig := testHighFeeConfig @@ -3500,8 +3500,8 @@ func TestFeeManagerRegressionMempoolMinFeeAfterRestart(t *testing.T) { block := blk.(*chain.BlockWrapper).Block.(*wrappedBlock).ethBlock feeConfig, lastChangedAt, err = restartedVM.blockChain.GetFeeConfigAt(block.Header()) require.NoError(t, err) - require.EqualValues(t, restartedVM.blockChain.CurrentBlock().Number, lastChangedAt) - require.EqualValues(t, testLowFeeConfig, feeConfig) + require.Equal(t, restartedVM.blockChain.CurrentBlock().Number, lastChangedAt) + require.Equal(t, testLowFeeConfig, feeConfig) // send another tx with low fee tx = types.NewTransaction(uint64(2), testEthAddrs[0], common.Big0, 21000, big.NewInt(testLowFeeConfig.MinBaseFee.Int64()), nil) @@ -3584,8 +3584,8 @@ func TestWaitForEvent(t *testing.T) { go func() { defer wg.Done() msg, err := vm.WaitForEvent(ctx) - require.ErrorIs(t, err, context.DeadlineExceeded) - require.Zero(t, msg) + assert.ErrorIs(t, err, context.DeadlineExceeded) + assert.Zero(t, msg) }() wg.Wait() @@ -3600,8 +3600,8 @@ func TestWaitForEvent(t *testing.T) { go func() { defer wg.Done() msg, err := vm.WaitForEvent(context.Background()) - require.NoError(t, err) - require.Equal(t, commonEng.PendingTxs, msg) + assert.NoError(t, err) + assert.Equal(t, commonEng.PendingTxs, msg) }() tx := types.NewTransaction(uint64(0), testEthAddrs[1], firstTxAmount, 21000, big.NewInt(testMinGasPrice), nil) @@ -3628,8 +3628,8 @@ func TestWaitForEvent(t *testing.T) { go func() { defer wg.Done() msg, err := vm.WaitForEvent(ctx) - require.ErrorIs(t, err, context.DeadlineExceeded) - require.Zero(t, msg) + assert.ErrorIs(t, err, context.DeadlineExceeded) + assert.Zero(t, msg) }() wg.Wait() diff --git a/plugin/evm/vm_upgrade_bytes_test.go b/plugin/evm/vm_upgrade_bytes_test.go index 47b36f302e..9529eb8ca7 100644 --- a/plugin/evm/vm_upgrade_bytes_test.go +++ b/plugin/evm/vm_upgrade_bytes_test.go @@ -68,7 +68,7 @@ func TestVMUpgradeBytesPrecompile(t *testing.T) { // Submit a successful transaction tx0 := types.NewTransaction(uint64(0), testEthAddrs[0], big.NewInt(1), 21000, big.NewInt(testMinGasPrice), nil) signedTx0, err := types.SignTx(tx0, types.NewEIP155Signer(tvm.vm.chainConfig.ChainID), testKeys[0].ToECDSA()) - assert.NoError(t, err) + require.NoError(t, err) errs := tvm.vm.txPool.AddRemotesSync([]*types.Transaction{signedTx0}) if err := errs[0]; err != nil { @@ -220,7 +220,7 @@ func TestNetworkUpgradesOverridden(t *testing.T) { // Submit a successful transaction tx0 := types.NewTransaction(uint64(0), testEthAddrs[0], big.NewInt(1), 21000, big.NewInt(testMinGasPrice), nil) signedTx0, err := types.SignTx(tx0, types.NewEIP155Signer(restartedVM.chainConfig.ChainID), testKeys[0].ToECDSA()) - assert.NoError(t, err) + require.NoError(t, err) errs := restartedVM.txPool.AddRemotesSync([]*types.Transaction{signedTx0}) if err := errs[0]; err != nil { t.Fatalf("Failed to add tx at index: %s", err) @@ -349,19 +349,19 @@ func TestVMStateUpgrade(t *testing.T) { (*big.Int)(genesisAccountUpgrade.BalanceChange), ), ) - require.Equal(t, state.GetBalance(testEthAddrs[0]), expectedGenesisAccountBalance) - require.Equal(t, state.GetState(testEthAddrs[0], storageKey), genesisAccountUpgrade.Storage[storageKey]) - require.Equal(t, state.GetCode(testEthAddrs[0]), upgradedCode) - require.Equal(t, state.GetCodeHash(testEthAddrs[0]), crypto.Keccak256Hash(upgradedCode)) - require.Equal(t, state.GetNonce(testEthAddrs[0]), genesisAccount.Nonce) // Nonce should be preserved since it was non-zero + require.Equal(t, expectedGenesisAccountBalance, state.GetBalance(testEthAddrs[0])) + require.Equal(t, genesisAccountUpgrade.Storage[storageKey], state.GetState(testEthAddrs[0], storageKey)) + require.Equal(t, upgradedCode, state.GetCode(testEthAddrs[0])) + require.Equal(t, crypto.Keccak256Hash(upgradedCode), state.GetCodeHash(testEthAddrs[0])) + require.Equal(t, genesisAccount.Nonce, state.GetNonce(testEthAddrs[0])) // Nonce should be preserved since it was non-zero // New account expectedNewAccountBalance := uint256.MustFromBig((*big.Int)(newAccountUpgrade.BalanceChange)) - require.Equal(t, state.GetBalance(newAccount), expectedNewAccountBalance) - require.Equal(t, state.GetCode(newAccount), upgradedCode) - require.Equal(t, state.GetCodeHash(newAccount), crypto.Keccak256Hash(upgradedCode)) - require.Equal(t, state.GetNonce(newAccount), uint64(1)) // Nonce should be set to 1 when code is set if nonce was 0 - require.Equal(t, state.GetState(newAccount, storageKey), newAccountUpgrade.Storage[storageKey]) + require.Equal(t, expectedNewAccountBalance, state.GetBalance(newAccount)) + require.Equal(t, upgradedCode, state.GetCode(newAccount)) + require.Equal(t, crypto.Keccak256Hash(upgradedCode), state.GetCodeHash(newAccount)) + require.Equal(t, uint64(1), state.GetNonce(newAccount)) // Nonce should be set to 1 when code is set if nonce was 0 + require.Equal(t, newAccountUpgrade.Storage[storageKey], state.GetState(newAccount, storageKey)) } func TestVMEtnaActivatesCancun(t *testing.T) { diff --git a/plugin/evm/vm_warp_test.go b/plugin/evm/vm_warp_test.go index c379b737e9..e3de03f4c5 100644 --- a/plugin/evm/vm_warp_test.go +++ b/plugin/evm/vm_warp_test.go @@ -157,9 +157,9 @@ func testSendWarpMessage(t *testing.T, scheme string) { // Verify the signature cannot be fetched before the block is accepted _, err = tvm.vm.warpBackend.GetMessageSignature(context.TODO(), unsignedMessage) - require.Error(err) + require.ErrorContains(err, "unknown codec version") _, err = tvm.vm.warpBackend.GetBlockSignature(context.TODO(), blk.ID()) - require.Error(err) + require.ErrorContains(err, "failed to get block") require.NoError(tvm.vm.SetPreference(context.Background(), blk.ID())) require.NoError(blk.Accept(context.Background())) @@ -481,7 +481,7 @@ func testWarpVMTransaction(t *testing.T, scheme string, unsignedMessage *avalanc require.NoError(err) unmarshalResults := make(map[string]interface{}) require.NoError(json.Unmarshal(blockTxTraceResultBytes, &unmarshalResults)) - require.Equal("", unmarshalResults["returnValue"]) + require.Empty(unmarshalResults["returnValue"]) txTraceResult, err := tracerAPI.TraceTransaction(context.Background(), tx.Hash(), nil) require.NoError(err) @@ -921,7 +921,6 @@ func testSignatureRequestsToVM(t *testing.T, scheme string) { tvm.appSender.SendAppErrorF = func(context.Context, ids.NodeID, uint32, int32, string) error { calledSendAppErrorFn = true - require.ErrorIs(t, test.err, test.err) return nil } @@ -933,7 +932,8 @@ func testSignatureRequestsToVM(t *testing.T, scheme string) { // Send the app request and verify the response deadline := time.Now().Add(60 * time.Second) appErr := tvm.vm.Network.AppRequest(context.Background(), ids.GenerateTestNodeID(), 1, deadline, msg) - require.Nil(t, appErr) + require.NoError(t, appErr) + if test.err != nil { require.True(t, calledSendAppErrorFn) } else { diff --git a/precompile/allowlist/role_test.go b/precompile/allowlist/role_test.go index b781cb42e4..28383dc97d 100644 --- a/precompile/allowlist/role_test.go +++ b/precompile/allowlist/role_test.go @@ -4,7 +4,6 @@ package allowlist import ( - "fmt" "testing" "github.com/stretchr/testify/require" @@ -35,7 +34,7 @@ func TestIsNoRole(t *testing.T) { for index, test := range tests { isNoRole := test.role.IsNoRole() - require.Equal(t, test.expected, isNoRole, fmt.Sprintf("test index: %d", index)) + require.Equal(t, test.expected, isNoRole, "test index: %d", index) } } @@ -64,7 +63,7 @@ func TestIsEnabled(t *testing.T) { for index, test := range tests { isEnabled := test.role.IsEnabled() - require.Equal(t, test.expected, isEnabled, fmt.Sprintf("test index: %d", index)) + require.Equal(t, test.expected, isEnabled, "test index: %d", index) } } @@ -144,6 +143,6 @@ func TestCanModify(t *testing.T) { } for index, test := range tests { canModify := test.role.CanModify(test.from, test.target) - require.Equal(t, test.expected, canModify, fmt.Sprintf("test index: %d", index)) + require.Equal(t, test.expected, canModify, "test index: %d", index) } } diff --git a/precompile/contracts/feemanager/contract_test.go b/precompile/contracts/feemanager/contract_test.go index 23ab80d456..fe1dc67bfc 100644 --- a/precompile/contracts/feemanager/contract_test.go +++ b/precompile/contracts/feemanager/contract_test.go @@ -158,7 +158,7 @@ var ( feeConfig := GetStoredFeeConfig(state) require.Equal(t, testFeeConfig, feeConfig) lastChangedAt := GetFeeConfigLastChangedAt(state) - require.EqualValues(t, testBlockNumber, lastChangedAt) + require.Equal(t, testBlockNumber, lastChangedAt) logs := state.Logs() assertFeeEvent(t, logs, allowlisttest.TestAdminAddr, zeroFeeConfig, testFeeConfig) @@ -192,7 +192,7 @@ var ( feeConfig := GetStoredFeeConfig(state) lastChangedAt := GetFeeConfigLastChangedAt(state) require.Equal(t, testFeeConfig, feeConfig) - require.EqualValues(t, big.NewInt(6), lastChangedAt) + require.Equal(t, big.NewInt(6), lastChangedAt) }, }, { @@ -224,7 +224,7 @@ var ( feeConfig := GetStoredFeeConfig(state) lastChangedAt := GetFeeConfigLastChangedAt(state) require.Equal(t, testFeeConfig, feeConfig) - require.EqualValues(t, testBlockNumber, lastChangedAt) + require.Equal(t, testBlockNumber, lastChangedAt) }, }, { @@ -365,7 +365,7 @@ var ( feeConfig := GetStoredFeeConfig(state) require.Equal(t, testFeeConfig, feeConfig) lastChangedAt := GetFeeConfigLastChangedAt(state) - require.EqualValues(t, testBlockNumber, lastChangedAt) + require.Equal(t, testBlockNumber, lastChangedAt) logs := state.Logs() assertFeeEvent(t, logs, allowlisttest.TestEnabledAddr, zeroFeeConfig, testFeeConfig) @@ -411,7 +411,7 @@ var ( feeConfig := GetStoredFeeConfig(state) require.Equal(t, regressionFeeConfig, feeConfig) lastChangedAt := GetFeeConfigLastChangedAt(state) - require.EqualValues(t, testBlockNumber, lastChangedAt) + require.Equal(t, testBlockNumber, lastChangedAt) logs := state.Logs() assertFeeEvent(t, logs, allowlisttest.TestEnabledAddr, zeroFeeConfig, regressionFeeConfig) diff --git a/precompile/contracts/feemanager/unpack_pack_test.go b/precompile/contracts/feemanager/unpack_pack_test.go index a686dc1455..92b3f14f5d 100644 --- a/precompile/contracts/feemanager/unpack_pack_test.go +++ b/precompile/contracts/feemanager/unpack_pack_test.go @@ -370,9 +370,9 @@ func testOldPackGetLastChangedAtOutputEqual(t *testing.T, blockNumber *big.Int, return } require.NoError(t, err2) - require.True(t, value.Cmp(unpacked) == 0, "not equal: value %v, unpacked %v", value, unpacked) + require.Zero(t, value.Cmp(unpacked), "not equal: value %v, unpacked %v", value, unpacked) if checkOutputs { - require.True(t, blockNumber.Cmp(unpacked) == 0, "not equal: blockNumber %v, unpacked %v", blockNumber, unpacked) + require.Zero(t, blockNumber.Cmp(unpacked), "not equal: blockNumber %v, unpacked %v", blockNumber, unpacked) } }) } diff --git a/precompile/contracts/nativeminter/contract_test.go b/precompile/contracts/nativeminter/contract_test.go index 9294901563..beb4220d62 100644 --- a/precompile/contracts/nativeminter/contract_test.go +++ b/precompile/contracts/nativeminter/contract_test.go @@ -291,5 +291,5 @@ func assertNativeCoinMintedEvent(t testing.TB, require.NotEmpty(t, log.Data) amount, err := UnpackNativeCoinMintedEventData(log.Data) require.NoError(t, err) - require.True(t, expectedAmount.Cmp(amount) == 0, "expected", expectedAmount, "got", amount) + require.Zero(t, expectedAmount.Cmp(amount), "expected", expectedAmount, "got", amount) } diff --git a/precompile/contracts/nativeminter/unpack_pack_test.go b/precompile/contracts/nativeminter/unpack_pack_test.go index c133510e4f..5612762d7a 100644 --- a/precompile/contracts/nativeminter/unpack_pack_test.go +++ b/precompile/contracts/nativeminter/unpack_pack_test.go @@ -111,7 +111,7 @@ func TestUnpackMintNativeCoinInput(t *testing.T) { } else { require.NoError(t, err) require.Equal(t, test.expectedAddr, unpackedAddress) - require.True(t, test.expectedAmount.Cmp(unpackedAmount) == 0, "expected %s, got %s", test.expectedAmount.String(), unpackedAmount.String()) + require.Equal(t, test.expectedAmount, unpackedAmount, "expected %s, got %s", test.expectedAmount.String(), unpackedAmount.String()) } oldUnpackedAddress, oldUnpackedAmount, oldErr := OldUnpackMintNativeCoinInput(test.input) if test.expectedOldErr != "" { @@ -119,7 +119,7 @@ func TestUnpackMintNativeCoinInput(t *testing.T) { } else { require.NoError(t, oldErr) require.Equal(t, test.expectedAddr, oldUnpackedAddress) - require.True(t, test.expectedAmount.Cmp(oldUnpackedAmount) == 0, "expected %s, got %s", test.expectedAmount.String(), oldUnpackedAmount.String()) + require.Equal(t, test.expectedAmount, oldUnpackedAmount, "expected %s, got %s", test.expectedAmount.String(), oldUnpackedAmount.String()) } }) } diff --git a/sync/client/client_test.go b/sync/client/client_test.go index b357c87272..29f8cdd177 100644 --- a/sync/client/client_test.go +++ b/sync/client/client_test.go @@ -9,7 +9,6 @@ import ( "fmt" "math/rand" "os" - "strings" "testing" "github.com/ava-labs/avalanchego/ids" @@ -18,7 +17,7 @@ import ( "github.com/ava-labs/libevm/core/types" "github.com/ava-labs/libevm/crypto" "github.com/ava-labs/libevm/triedb" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/consensus/dummy" "github.com/ava-labs/subnet-evm/core" @@ -127,19 +126,18 @@ func TestGetCode(t *testing.T) { } codeBytes, err := stateSyncClient.GetCode(ctx, codeHashes) - // If we expect an error, assert that one occurred and return + require.ErrorIs(t, err, test.expectedErr) + // If we expected an error, verify retry behavior and return if test.expectedErr != nil { - assert.ErrorIs(t, err, test.expectedErr) - assert.EqualValues(t, 2, mockNetClient.numCalls) + require.Equal(t, uint(2), mockNetClient.numCalls) return } - // Otherwise, assert there was no error and that the result is as expected - assert.NoError(t, err) - assert.Equal(t, len(codeBytes), len(expectedCode)) + // Otherwise, require that the result is as expected + require.Len(t, codeBytes, len(expectedCode)) for i, code := range codeBytes { - assert.Equal(t, expectedCode[i], code) + require.Equal(t, expectedCode[i], code) } - assert.Equal(t, uint(1), mockNetClient.numCalls) + require.Equal(t, uint(1), mockNetClient.numCalls) }) } } @@ -157,7 +155,7 @@ func TestGetBlocks(t *testing.T) { if err != nil { t.Fatal("unexpected error when generating test blockchain", err) } - assert.Equal(t, numBlocks, len(blocks)) + require.Len(t, blocks, numBlocks) // Construct client mockNetClient := &mockNetwork{} @@ -210,7 +208,7 @@ func TestGetBlocks(t *testing.T) { return response }, assertResponse: func(t *testing.T, response []*types.Block) { - assert.Equal(t, 16, len(response)) + require.Len(t, response, 16) }, }, "fewer than requested blocks": { @@ -234,7 +232,7 @@ func TestGetBlocks(t *testing.T) { }, // If the server returns fewer than requested blocks, we should consider it valid assertResponse: func(t *testing.T, response []*types.Block) { - assert.Equal(t, 11, len(response)) + require.Len(t, response, 11) }, }, "gibberish response": { @@ -387,7 +385,7 @@ func TestGetBlocks(t *testing.T) { if err == nil { t.Fatalf("Expected error: %s, but found no error", test.expectedErr) } - assert.ErrorContains(t, err, test.expectedErr) + require.ErrorContains(t, err, test.expectedErr) return } if err != nil { @@ -430,10 +428,10 @@ func TestGetLeafs(t *testing.T) { }) tests := map[string]struct { - request message.LeafsRequest - getResponse func(t *testing.T, request message.LeafsRequest) []byte - assertResponse func(t *testing.T, response message.LeafsResponse) - expectedErr error + request message.LeafsRequest + getResponse func(t *testing.T, request message.LeafsRequest) []byte + requireResponse func(t *testing.T, response message.LeafsResponse) + expectedErr error }{ "full response for small (single request) trie": { request: message.LeafsRequest{ @@ -453,10 +451,10 @@ func TestGetLeafs(t *testing.T) { return response }, - assertResponse: func(t *testing.T, response message.LeafsResponse) { - assert.False(t, response.More) - assert.Equal(t, leafsLimit, len(response.Keys)) - assert.Equal(t, leafsLimit, len(response.Vals)) + requireResponse: func(t *testing.T, response message.LeafsResponse) { + require.False(t, response.More) + require.Len(t, response.Keys, leafsLimit) + require.Len(t, response.Vals, leafsLimit) }, }, "too many leaves in response": { @@ -499,10 +497,10 @@ func TestGetLeafs(t *testing.T) { return response }, - assertResponse: func(t *testing.T, response message.LeafsResponse) { - assert.True(t, response.More) - assert.Equal(t, leafsLimit, len(response.Keys)) - assert.Equal(t, leafsLimit, len(response.Vals)) + requireResponse: func(t *testing.T, response message.LeafsResponse) { + require.True(t, response.More) + require.Len(t, response.Keys, leafsLimit) + require.Len(t, response.Vals, leafsLimit) }, }, "partial response to request for middle range of trie (full leaf limit)": { @@ -523,10 +521,10 @@ func TestGetLeafs(t *testing.T) { } return response }, - assertResponse: func(t *testing.T, response message.LeafsResponse) { - assert.True(t, response.More) - assert.Equal(t, leafsLimit, len(response.Keys)) - assert.Equal(t, leafsLimit, len(response.Vals)) + requireResponse: func(t *testing.T, response message.LeafsResponse) { + require.True(t, response.More) + require.Len(t, response.Keys, leafsLimit) + require.Len(t, response.Vals, leafsLimit) }, }, "full response from near end of trie to end of trie (less than leaf limit)": { @@ -546,10 +544,10 @@ func TestGetLeafs(t *testing.T) { } return response }, - assertResponse: func(t *testing.T, response message.LeafsResponse) { - assert.False(t, response.More) - assert.Equal(t, 30, len(response.Keys)) - assert.Equal(t, 30, len(response.Vals)) + requireResponse: func(t *testing.T, response message.LeafsResponse) { + require.False(t, response.More) + require.Len(t, response.Keys, 30) + require.Len(t, response.Vals, 30) }, }, "full response for intermediate range of trie (less than leaf limit)": { @@ -570,10 +568,10 @@ func TestGetLeafs(t *testing.T) { return response }, - assertResponse: func(t *testing.T, response message.LeafsResponse) { - assert.True(t, response.More) - assert.Equal(t, 100, len(response.Keys)) - assert.Equal(t, 100, len(response.Vals)) + requireResponse: func(t *testing.T, response message.LeafsResponse) { + require.True(t, response.More) + require.Len(t, response.Keys, 100) + require.Len(t, response.Vals, 100) }, }, "removed first key in response": { @@ -763,23 +761,16 @@ func TestGetLeafs(t *testing.T) { responseBytes := test.getResponse(t, test.request) response, _, err := parseLeafsResponse(client.codec, test.request, responseBytes) + require.ErrorIs(t, err, test.expectedErr) if test.expectedErr != nil { - if err == nil { - t.Fatalf("Expected error: %s, but found no error", test.expectedErr) - } - assert.True(t, strings.Contains(err.Error(), test.expectedErr.Error())) return } - if err != nil { - t.Fatal(err) - } - leafsResponse, ok := response.(message.LeafsResponse) if !ok { t.Fatalf("parseLeafsResponse returned incorrect type %T", response) } - test.assertResponse(t, leafsResponse) + test.requireResponse(t, leafsResponse) }) } } @@ -811,15 +802,15 @@ func TestGetLeafsRetries(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() goodResponse, responseErr := handler.OnLeafsRequest(ctx, ids.GenerateTestNodeID(), 1, request) - assert.NoError(t, responseErr) + require.NoError(t, responseErr) mockNetClient.mockResponse(1, nil, goodResponse) res, err := client.GetLeafs(ctx, request) if err != nil { t.Fatal(err) } - assert.Equal(t, 1024, len(res.Keys)) - assert.Equal(t, 1024, len(res.Vals)) + require.Len(t, res.Keys, 1024) + require.Len(t, res.Vals, 1024) // Succeeds within the allotted number of attempts invalidResponse := []byte("invalid response") @@ -829,8 +820,8 @@ func TestGetLeafsRetries(t *testing.T) { if err != nil { t.Fatal(err) } - assert.Equal(t, 1024, len(res.Keys)) - assert.Equal(t, 1024, len(res.Vals)) + require.Len(t, res.Keys, 1024) + require.Len(t, res.Vals, 1024) // Test that GetLeafs stops after the context is cancelled numAttempts := 0 @@ -841,8 +832,7 @@ func TestGetLeafsRetries(t *testing.T) { } }, invalidResponse) _, err = client.GetLeafs(ctx, request) - assert.Error(t, err) - assert.True(t, strings.Contains(err.Error(), context.Canceled.Error())) + require.ErrorIs(t, err, context.Canceled) } func TestStateSyncNodes(t *testing.T) { @@ -874,12 +864,12 @@ func TestStateSyncNodes(t *testing.T) { // send some request, doesn't matter what it is because we're testing the interaction with state sync nodes here response, err := client.GetLeafs(ctx, message.LeafsRequest{}) - assert.Error(t, err) - assert.Empty(t, response) - - // assert all nodes were called - assert.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[0]) - assert.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[1]) - assert.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[2]) - assert.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[3]) + require.ErrorIs(t, err, context.Canceled) + require.Empty(t, response) + + // require all nodes were called + require.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[0]) + require.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[1]) + require.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[2]) + require.Contains(t, mockNetClient.nodesRequested, stateSyncNodes[3]) } diff --git a/sync/handlers/code_request_test.go b/sync/handlers/code_request_test.go index e835f7fb0c..82b3af4075 100644 --- a/sync/handlers/code_request_test.go +++ b/sync/handlers/code_request_test.go @@ -13,7 +13,7 @@ import ( "github.com/ava-labs/libevm/core/rawdb" "github.com/ava-labs/libevm/crypto" "github.com/ava-labs/libevm/ethdb/memorydb" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/plugin/evm/message" "github.com/ava-labs/subnet-evm/sync/handlers/stats" @@ -30,8 +30,8 @@ func TestCodeRequestHandler(t *testing.T) { maxSizeCodeBytes := make([]byte, ethparams.MaxCodeSize) n, err := rand.Read(maxSizeCodeBytes) - assert.NoError(t, err) - assert.Equal(t, ethparams.MaxCodeSize, n) + require.NoError(t, err) + require.Equal(t, ethparams.MaxCodeSize, n) maxSizeCodeHash := crypto.Keccak256Hash(maxSizeCodeBytes) rawdb.WriteCode(database, maxSizeCodeHash, maxSizeCodeBytes) @@ -49,8 +49,8 @@ func TestCodeRequestHandler(t *testing.T) { }, [][]byte{codeBytes} }, verifyStats: func(t *testing.T) { - assert.EqualValues(t, 1, mockHandlerStats.CodeRequestCount) - assert.EqualValues(t, len(codeBytes), mockHandlerStats.CodeBytesReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.CodeRequestCount) + require.Equal(t, uint32(len(codeBytes)), mockHandlerStats.CodeBytesReturnedSum) }, }, "duplicate hashes": { @@ -60,7 +60,7 @@ func TestCodeRequestHandler(t *testing.T) { }, nil }, verifyStats: func(t *testing.T) { - assert.EqualValues(t, 1, mockHandlerStats.DuplicateHashesRequested) + require.Equal(t, uint32(1), mockHandlerStats.DuplicateHashesRequested) }, }, "too many hashes": { @@ -70,7 +70,7 @@ func TestCodeRequestHandler(t *testing.T) { }, nil }, verifyStats: func(t *testing.T) { - assert.EqualValues(t, 1, mockHandlerStats.TooManyHashesRequested) + require.Equal(t, uint32(1), mockHandlerStats.TooManyHashesRequested) }, }, "max size code handled": { @@ -80,8 +80,8 @@ func TestCodeRequestHandler(t *testing.T) { }, [][]byte{maxSizeCodeBytes} }, verifyStats: func(t *testing.T) { - assert.EqualValues(t, 1, mockHandlerStats.CodeRequestCount) - assert.EqualValues(t, ethparams.MaxCodeSize, mockHandlerStats.CodeBytesReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.CodeRequestCount) + require.Equal(t, uint32(ethparams.MaxCodeSize), mockHandlerStats.CodeBytesReturnedSum) }, }, } @@ -93,11 +93,11 @@ func TestCodeRequestHandler(t *testing.T) { t.Run(name, func(t *testing.T) { request, expectedResponse := test.setup() responseBytes, err := codeRequestHandler.OnCodeRequest(context.Background(), ids.GenerateTestNodeID(), 1, request) - assert.NoError(t, err) + require.NoError(t, err) - // If the expected response is empty, assert that the handler returns an empty response and return early. + // If the expected response is empty, require that the handler returns an empty response and return early. if len(expectedResponse) == 0 { - assert.Len(t, responseBytes, 0, "expected response to be empty") + require.Empty(t, responseBytes, "expected response to be empty") return } var response message.CodeResponse @@ -108,8 +108,7 @@ func TestCodeRequestHandler(t *testing.T) { t.Fatalf("Unexpected length of code data expected %d != %d", len(expectedResponse), len(response.Data)) } for i, code := range expectedResponse { - // assert.True(t, bytes.Equal(code, response.Data[i]), "code bytes mismatch at index %d", i) - assert.Equal(t, code, response.Data[i], "code bytes mismatch at index %d", i) + require.Equal(t, code, response.Data[i], "code bytes mismatch at index %d", i) } test.verifyStats(t) }) diff --git a/sync/handlers/leafs_request_test.go b/sync/handlers/leafs_request_test.go index 0bfe48cbae..1a7139a966 100644 --- a/sync/handlers/leafs_request_test.go +++ b/sync/handlers/leafs_request_test.go @@ -17,7 +17,7 @@ import ( "github.com/ava-labs/libevm/ethdb" "github.com/ava-labs/libevm/trie" "github.com/ava-labs/libevm/triedb" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/core/state/snapshot" "github.com/ava-labs/subnet-evm/plugin/evm/message" @@ -85,8 +85,8 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { } tests := map[string]struct { - prepareTestFn func() (context.Context, message.LeafsRequest) - assertResponseFn func(*testing.T, message.LeafsRequest, []byte, error) + prepareTestFn func() (context.Context, message.LeafsRequest) + requireResponseFn func(*testing.T, message.LeafsRequest, []byte, error) }{ "zero limit dropped": { prepareTestFn: func() (context.Context, message.LeafsRequest) { @@ -97,10 +97,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: 0, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.InvalidLeafsRequestCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.InvalidLeafsRequestCount) }, }, "empty root dropped": { @@ -112,10 +112,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.InvalidLeafsRequestCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.InvalidLeafsRequestCount) }, }, "bad start len dropped": { @@ -127,10 +127,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.InvalidLeafsRequestCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.InvalidLeafsRequestCount) }, }, "bad end len dropped": { @@ -142,10 +142,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.InvalidLeafsRequestCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.InvalidLeafsRequestCount) }, }, "empty storage root dropped": { @@ -157,10 +157,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.InvalidLeafsRequestCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.InvalidLeafsRequestCount) }, }, "missing root dropped": { @@ -172,10 +172,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.MissingRootCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.MissingRootCount) }, }, "corrupted trie drops request": { @@ -187,10 +187,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, uint32(1), mockHandlerStats.TrieErrorCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.TrieErrorCount) }, }, "cancelled context dropped": { @@ -204,9 +204,9 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) }, }, "nil start and end range returns entire trie": { @@ -218,14 +218,14 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.Len(t, leafsResponse.Keys, 500) - assert.Len(t, leafsResponse.Vals, 500) - assert.Len(t, leafsResponse.ProofVals, 0) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, 500) + require.Len(t, leafsResponse.Vals, 500) + require.Empty(t, leafsResponse.ProofVals) }, }, "nil end range treated like greatest possible value": { @@ -237,13 +237,13 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.Len(t, leafsResponse.Keys, 500) - assert.Len(t, leafsResponse.Vals, 500) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, 500) + require.Len(t, leafsResponse.Vals, 500) }, }, "end greater than start dropped": { @@ -257,10 +257,10 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) - assert.EqualValues(t, 1, mockHandlerStats.InvalidLeafsRequestCount) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) + require.Equal(t, uint32(1), mockHandlerStats.InvalidLeafsRequestCount) }, }, "invalid node type dropped": { @@ -274,9 +274,9 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.Nil(t, response) - assert.Nil(t, err) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.Nil(t, response) + require.NoError(t, err) }, }, "max leaves overridden": { @@ -288,15 +288,15 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit * 10, } }, - assertResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, _ message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, len(leafsResponse.Keys), maxLeavesLimit) - assert.EqualValues(t, len(leafsResponse.Vals), maxLeavesLimit) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) }, }, "full range with nil start": { @@ -308,16 +308,16 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, len(leafsResponse.Keys), maxLeavesLimit) - assert.EqualValues(t, len(leafsResponse.Vals), maxLeavesLimit) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + requireRangeProofIsValid(t, &request, &leafsResponse, true) }, }, "full range with 0x00 start": { @@ -329,16 +329,16 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, len(leafsResponse.Keys), maxLeavesLimit) - assert.EqualValues(t, len(leafsResponse.Vals), maxLeavesLimit) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + requireRangeProofIsValid(t, &request, &leafsResponse, true) }, }, "partial mid range": { @@ -353,16 +353,16 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, 40, len(leafsResponse.Keys)) - assert.EqualValues(t, 40, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, 40) + require.Len(t, leafsResponse.Vals, 40) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + requireRangeProofIsValid(t, &request, &leafsResponse, true) }, }, "partial end range": { @@ -374,16 +374,16 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, 600, len(leafsResponse.Keys)) - assert.EqualValues(t, 600, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assertRangeProofIsValid(t, &request, &leafsResponse, false) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, 600) + require.Len(t, leafsResponse.Vals, 600) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + requireRangeProofIsValid(t, &request, &leafsResponse, false) }, }, "final end range": { @@ -395,16 +395,16 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, len(leafsResponse.Keys), 0) - assert.EqualValues(t, len(leafsResponse.Vals), 0) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assertRangeProofIsValid(t, &request, &leafsResponse, false) + require.NoError(t, err) + require.Empty(t, leafsResponse.Keys) + require.Empty(t, leafsResponse.Vals) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + requireRangeProofIsValid(t, &request, &leafsResponse, false) }, }, "small trie root": { @@ -416,20 +416,21 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NotEmpty(t, response) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NotEmpty(t, response) + require.NoError(t, err) var leafsResponse message.LeafsResponse if _, err = message.Codec.Unmarshal(response, &leafsResponse); err != nil { t.Fatalf("unexpected error when unmarshalling LeafsResponse: %v", err) } - assert.EqualValues(t, 500, len(leafsResponse.Keys)) - assert.EqualValues(t, 500, len(leafsResponse.Vals)) - assert.Empty(t, leafsResponse.ProofVals) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assertRangeProofIsValid(t, &request, &leafsResponse, false) + require.Len(t, leafsResponse.Keys, 500) + require.Len(t, leafsResponse.Vals, 500) + require.Empty(t, leafsResponse.ProofVals) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + requireRangeProofIsValid(t, &request, &leafsResponse, false) }, }, "account data served from snapshot": { @@ -444,18 +445,18 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Keys)) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadAttemptCount) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadSuccessCount) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadAttemptCount) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadSuccessCount) + requireRangeProofIsValid(t, &request, &leafsResponse, true) }, }, "partial account data served from snapshot": { @@ -491,23 +492,23 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Keys)) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadAttemptCount) - assert.EqualValues(t, 0, mockHandlerStats.SnapshotReadSuccessCount) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadAttemptCount) + require.Equal(t, uint32(0), mockHandlerStats.SnapshotReadSuccessCount) + requireRangeProofIsValid(t, &request, &leafsResponse, true) // expect 1/4th of segments to be invalid numSegments := maxLeavesLimit / segmentLen - assert.EqualValues(t, numSegments/4, mockHandlerStats.SnapshotSegmentInvalidCount) - assert.EqualValues(t, 3*numSegments/4, mockHandlerStats.SnapshotSegmentValidCount) + require.Equal(t, uint32(numSegments/4), mockHandlerStats.SnapshotSegmentInvalidCount) + require.Equal(t, uint32(3*numSegments/4), mockHandlerStats.SnapshotSegmentValidCount) }, }, "storage data served from snapshot": { @@ -523,18 +524,18 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Keys)) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadAttemptCount) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadSuccessCount) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadAttemptCount) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadSuccessCount) + requireRangeProofIsValid(t, &request, &leafsResponse, true) }, }, "partial storage data served from snapshot": { @@ -556,7 +557,7 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { if i%(segmentLen*4) == 0 { randomBytes := make([]byte, 5) _, err := rand.Read(randomBytes) - assert.NoError(t, err) + require.NoError(t, err) rawdb.WriteStorageSnapshot(memdb, largeStorageAccount, it.Hash(), randomBytes) } i++ @@ -568,23 +569,23 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Keys)) - assert.EqualValues(t, maxLeavesLimit, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadAttemptCount) - assert.EqualValues(t, 0, mockHandlerStats.SnapshotReadSuccessCount) - assertRangeProofIsValid(t, &request, &leafsResponse, true) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, int(maxLeavesLimit)) + require.Len(t, leafsResponse.Vals, int(maxLeavesLimit)) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadAttemptCount) + require.Equal(t, uint32(0), mockHandlerStats.SnapshotReadSuccessCount) + requireRangeProofIsValid(t, &request, &leafsResponse, true) // expect 1/4th of segments to be invalid numSegments := maxLeavesLimit / segmentLen - assert.EqualValues(t, numSegments/4, mockHandlerStats.SnapshotSegmentInvalidCount) - assert.EqualValues(t, 3*numSegments/4, mockHandlerStats.SnapshotSegmentValidCount) + require.Equal(t, uint32(numSegments/4), mockHandlerStats.SnapshotSegmentInvalidCount) + require.Equal(t, uint32(3*numSegments/4), mockHandlerStats.SnapshotSegmentValidCount) }, }, "last snapshot key removed": { @@ -608,18 +609,18 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, 500, len(leafsResponse.Keys)) - assert.EqualValues(t, 500, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadAttemptCount) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadSuccessCount) - assertRangeProofIsValid(t, &request, &leafsResponse, false) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, 500) + require.Len(t, leafsResponse.Vals, 500) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadAttemptCount) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadSuccessCount) + requireRangeProofIsValid(t, &request, &leafsResponse, false) }, }, "request last key when removed from snapshot": { @@ -644,18 +645,18 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { Limit: maxLeavesLimit, } }, - assertResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { - assert.NoError(t, err) + requireResponseFn: func(t *testing.T, request message.LeafsRequest, response []byte, err error) { + require.NoError(t, err) var leafsResponse message.LeafsResponse _, err = message.Codec.Unmarshal(response, &leafsResponse) - assert.NoError(t, err) - assert.EqualValues(t, 1, len(leafsResponse.Keys)) - assert.EqualValues(t, 1, len(leafsResponse.Vals)) - assert.EqualValues(t, 1, mockHandlerStats.LeafsRequestCount) - assert.EqualValues(t, len(leafsResponse.Keys), mockHandlerStats.LeafsReturnedSum) - assert.EqualValues(t, 1, mockHandlerStats.SnapshotReadAttemptCount) - assert.EqualValues(t, 0, mockHandlerStats.SnapshotReadSuccessCount) - assertRangeProofIsValid(t, &request, &leafsResponse, false) + require.NoError(t, err) + require.Len(t, leafsResponse.Keys, 1) + require.Len(t, leafsResponse.Vals, 1) + require.Equal(t, uint32(1), mockHandlerStats.LeafsRequestCount) + require.Equal(t, uint32(len(leafsResponse.Keys)), mockHandlerStats.LeafsReturnedSum) + require.Equal(t, uint32(1), mockHandlerStats.SnapshotReadAttemptCount) + require.Equal(t, uint32(0), mockHandlerStats.SnapshotReadSuccessCount) + requireRangeProofIsValid(t, &request, &leafsResponse, false) }, }, } @@ -669,12 +670,12 @@ func TestLeafsRequestHandler_OnLeafsRequest(t *testing.T) { }) response, err := leafsHandler.OnLeafsRequest(ctx, ids.GenerateTestNodeID(), 1, request) - test.assertResponseFn(t, request, response, err) + test.requireResponseFn(t, request, response, err) }) } } -func assertRangeProofIsValid(t *testing.T, request *message.LeafsRequest, response *message.LeafsResponse, expectMore bool) { +func requireRangeProofIsValid(t *testing.T, request *message.LeafsRequest, response *message.LeafsResponse, expectMore bool) { t.Helper() var start []byte @@ -697,6 +698,6 @@ func assertRangeProofIsValid(t *testing.T, request *message.LeafsRequest, respon } more, err := trie.VerifyRangeProof(request.Root, start, response.Keys, response.Vals, proof) - assert.NoError(t, err) - assert.Equal(t, expectMore, more) + require.NoError(t, err) + require.Equal(t, expectMore, more) } diff --git a/sync/statesync/code_syncer_test.go b/sync/statesync/code_syncer_test.go index 972c056095..3c0a33045a 100644 --- a/sync/statesync/code_syncer_test.go +++ b/sync/statesync/code_syncer_test.go @@ -14,6 +14,7 @@ import ( "github.com/ava-labs/libevm/crypto" "github.com/ava-labs/libevm/ethdb/memorydb" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/plugin/evm/customrawdb" "github.com/ava-labs/subnet-evm/plugin/evm/message" @@ -65,7 +66,7 @@ func testCodeSyncer(t *testing.T, test codeSyncerTest) { if test.err == nil { t.Fatal(err) } else { - assert.ErrorIs(t, err, test.err) + require.ErrorIs(t, err, test.err) } } } diff --git a/sync/statesync/statesynctest/test_sync.go b/sync/statesync/statesynctest/test_sync.go index e380ca9d60..646e6d1c0a 100644 --- a/sync/statesync/statesynctest/test_sync.go +++ b/sync/statesync/statesynctest/test_sync.go @@ -16,6 +16,7 @@ import ( "github.com/ava-labs/libevm/rlp" "github.com/ava-labs/libevm/triedb" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/plugin/evm/customrawdb" "github.com/ava-labs/subnet-evm/utils/utilstest" @@ -56,7 +57,7 @@ func AssertDBConsistency(t testing.TB, root common.Hash, clientDB ethdb.Database codeHash := common.BytesToHash(acc.CodeHash) code := rawdb.ReadCode(clientDB, codeHash) actualHash := crypto.Keccak256Hash(code) - assert.NotZero(t, len(code)) + require.NotEmpty(t, code) assert.Equal(t, codeHash, actualHash) } if acc.Root == types.EmptyRootHash { diff --git a/sync/statesync/statesynctest/test_trie.go b/sync/statesync/statesynctest/test_trie.go index 29b9d41610..cb31b35f2a 100644 --- a/sync/statesync/statesynctest/test_trie.go +++ b/sync/statesync/statesynctest/test_trie.go @@ -17,7 +17,7 @@ import ( "github.com/ava-labs/libevm/trie/trienode" "github.com/ava-labs/libevm/triedb" "github.com/holiman/uint256" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ava-labs/subnet-evm/utils/utilstest" ) @@ -34,7 +34,7 @@ func GenerateTrie(t *testing.T, r *rand.Rand, trieDB *triedb.Database, numKeys i // FillTrie fills a given trie with [numKeys] random keys, each of size [keySize] // returns inserted keys and values -func FillTrie(t *testing.T, r *rand.Rand, start, numKeys int, keySize int, trieDB *triedb.Database, root common.Hash) (common.Hash, [][]byte, [][]byte) { +func FillTrie(t *testing.T, _ *rand.Rand, start, numKeys int, keySize int, trieDB *triedb.Database, root common.Hash) (common.Hash, [][]byte, [][]byte) { testTrie, err := trie.New(trie.TrieID(root), trieDB) if err != nil { t.Fatalf("error creating trie: %v", err) @@ -47,12 +47,12 @@ func FillTrie(t *testing.T, r *rand.Rand, start, numKeys int, keySize int, trieD for i := start; i < numKeys; i++ { key := make([]byte, keySize) binary.BigEndian.PutUint64(key[:wrappers.LongLen], uint64(i+1)) - _, err := r.Read(key[wrappers.LongLen:]) - assert.NoError(t, err) + _, err := rand.Read(key[wrappers.LongLen:]) + require.NoError(t, err) - value := make([]byte, r.Intn(128)+128) // min 128 bytes, max 256 bytes - _, err = r.Read(value) - assert.NoError(t, err) + value := make([]byte, rand.Intn(128)+128) // min 128 bytes, max 256 bytes + _, err = rand.Read(value) + require.NoError(t, err) testTrie.MustUpdate(key, value) @@ -62,11 +62,9 @@ func FillTrie(t *testing.T, r *rand.Rand, start, numKeys int, keySize int, trieD // Commit the root to [trieDB] nextRoot, nodes, err := testTrie.Commit(false) - assert.NoError(t, err) - err = trieDB.Update(nextRoot, root, 0, trienode.NewWithNodeSet(nodes), nil) - assert.NoError(t, err) - err = trieDB.Commit(nextRoot, false) - assert.NoError(t, err) + require.NoError(t, err) + require.NoError(t, trieDB.Update(nextRoot, root, 0, trienode.NewWithNodeSet(nodes), nil)) + require.NoError(t, trieDB.Commit(nextRoot, false)) return nextRoot, keys, values } @@ -96,19 +94,19 @@ func AssertTrieConsistency(t testing.TB, root common.Hash, a, b *triedb.Database count := 0 for itA.Next() && itB.Next() { count++ - assert.Equal(t, itA.Key, itB.Key) - assert.Equal(t, itA.Value, itB.Value) + require.Equal(t, itA.Key, itB.Key) + require.Equal(t, itA.Value, itB.Value) if onLeaf != nil { if err := onLeaf(itA.Key, itA.Value); err != nil { t.Fatalf("error in onLeaf callback: %v", err) } } } - assert.NoError(t, itA.Err) - assert.NoError(t, itB.Err) - assert.False(t, itA.Next()) - assert.False(t, itB.Next()) - assert.Greater(t, count, 0) + require.NoError(t, itA.Err) + require.NoError(t, itB.Err) + require.False(t, itA.Next()) + require.False(t, itB.Next()) + require.Positive(t, count) } // CorruptTrie deletes every [n]th trie node from the trie given by [tr] from the underlying [db]. diff --git a/sync/statesync/sync_test.go b/sync/statesync/sync_test.go index 63f1ed21a0..143d9ae268 100644 --- a/sync/statesync/sync_test.go +++ b/sync/statesync/sync_test.go @@ -263,7 +263,7 @@ func TestResumeSyncAccountsTrieInterrupted(t *testing.T) { GetLeafsIntercept: intercept.getLeafsIntercept, }) - require.EqualValues(t, 2, intercept.numRequests) + require.Equal(t, uint32(2), intercept.numRequests) testSync(t, syncTest{ prepareForTest: func(*testing.T, *rand.Rand) (ethdb.Database, ethdb.Database, *triedb.Database, common.Hash) { diff --git a/tests/warp/warp_test.go b/tests/warp/warp_test.go index 042018e9d8..7d7c802cb6 100644 --- a/tests/warp/warp_test.go +++ b/tests/warp/warp_test.go @@ -404,7 +404,7 @@ func (w *warpTest) aggregateSignaturesViaAPI() { validators, err = pChainClient.GetValidatorsAt(ctx, w.sendingSubnet.SubnetID, api.Height(pChainHeight)) } require.NoError(err) - require.NotZero(len(validators)) + require.NotEmpty(validators) totalWeight := uint64(0) warpValidators := make([]*avalancheWarp.Validator, 0, len(validators)) @@ -511,10 +511,10 @@ func (w *warpTest) deliverAddressedCallToReceivingSubnet() { Addresses: []common.Address{warp.Module.Address}, }) require.NoError(err) - require.Len(logs, 0) + require.Empty(logs) receipt, err := client.TransactionReceipt(ctx, signedTx.Hash()) require.NoError(err) - require.Equal(receipt.Status, types.ReceiptStatusSuccessful) + require.Equal(types.ReceiptStatusSuccessful, receipt.Status) } func (w *warpTest) deliverBlockHashPayload() { @@ -568,10 +568,10 @@ func (w *warpTest) deliverBlockHashPayload() { Addresses: []common.Address{warp.Module.Address}, }) require.NoError(err) - require.Len(logs, 0) + require.Empty(logs) receipt, err := client.TransactionReceipt(ctx, signedTx.Hash()) require.NoError(err) - require.Equal(receipt.Status, types.ReceiptStatusSuccessful) + require.Equal(types.ReceiptStatusSuccessful, receipt.Status) } func (w *warpTest) executeHardHatTest() { diff --git a/utils/bytes_test.go b/utils/bytes_test.go index 68c710b249..eed0d3cf54 100644 --- a/utils/bytes_test.go +++ b/utils/bytes_test.go @@ -9,7 +9,6 @@ import ( "github.com/ava-labs/avalanchego/utils" "github.com/ava-labs/libevm/common" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -35,7 +34,7 @@ func TestIncrOne(t *testing.T) { t.Run(name, func(t *testing.T) { output := common.CopyBytes(test.input) IncrOne(output) - assert.Equal(t, output, test.expected) + require.Equal(t, test.expected, output) }) } } diff --git a/warp/backend_test.go b/warp/backend_test.go index ea273b53ee..0094f3240d 100644 --- a/warp/backend_test.go +++ b/warp/backend_test.go @@ -74,7 +74,7 @@ func TestAddAndGetUnknownMessage(t *testing.T) { // Try getting a signature for a message that was not added. _, err = backend.GetMessageSignature(context.TODO(), testUnsignedMessage) - require.Error(t, err) + require.ErrorContains(t, err, "unknown codec version") } func TestGetBlockSignature(t *testing.T) { @@ -103,7 +103,7 @@ func TestGetBlockSignature(t *testing.T) { require.Equal(expectedSig, signature[:]) _, err = backend.GetBlockSignature(context.TODO(), ids.GenerateTestID()) - require.Error(err) + require.ErrorContains(err, "failed to get block") } func TestZeroSizedCache(t *testing.T) { diff --git a/warp/verifier_backend_test.go b/warp/verifier_backend_test.go index 3d72a63a60..000f55d05d 100644 --- a/warp/verifier_backend_test.go +++ b/warp/verifier_backend_test.go @@ -47,7 +47,7 @@ func TestAddressedCallSignatures(t *testing.T) { tests := map[string]struct { setup func(backend Backend) (request []byte, expectedResponse []byte) verifyStats func(t *testing.T, stats *verifierStats) - err error + err *common.AppError }{ "known message": { setup: func(backend Backend) (request []byte, expectedResponse []byte) { @@ -62,8 +62,8 @@ func TestAddressedCallSignatures(t *testing.T) { return msg.Bytes(), signature[:] }, verifyStats: func(t *testing.T, stats *verifierStats) { - require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count()) - require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count()) + require.Zero(t, stats.messageParseFail.Snapshot().Count()) + require.Zero(t, stats.blockValidationFail.Snapshot().Count()) }, }, "offchain message": { @@ -71,8 +71,8 @@ func TestAddressedCallSignatures(t *testing.T) { return offchainMessage.Bytes(), offchainSignature[:] }, verifyStats: func(t *testing.T, stats *verifierStats) { - require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count()) - require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count()) + require.Zero(t, stats.messageParseFail.Snapshot().Count()) + require.Zero(t, stats.blockValidationFail.Snapshot().Count()) }, }, "unknown message": { @@ -84,8 +84,8 @@ func TestAddressedCallSignatures(t *testing.T) { return unknownMessage.Bytes(), nil }, verifyStats: func(t *testing.T, stats *verifierStats) { - require.EqualValues(t, 1, stats.messageParseFail.Snapshot().Count()) - require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count()) + require.Equal(t, int64(1), stats.messageParseFail.Snapshot().Count()) + require.Zero(t, stats.blockValidationFail.Snapshot().Count()) }, err: &common.AppError{Code: ParseErrCode}, }, @@ -123,18 +123,12 @@ func TestAddressedCallSignatures(t *testing.T) { protoBytes, err := proto.Marshal(protoMsg) require.NoError(t, err) responseBytes, appErr := handler.AppRequest(context.Background(), ids.GenerateTestNodeID(), time.Time{}, protoBytes) - if test.err != nil { - require.Error(t, appErr) - require.ErrorIs(t, appErr, test.err) - } else { - require.Nil(t, appErr) - } - + require.ErrorIs(t, appErr, test.err) test.verifyStats(t, warpBackend.(*backend).stats) // If the expected response is empty, assert that the handler returns an empty response and return early. if len(expectedResponse) == 0 { - require.Len(t, responseBytes, 0, "expected response to be empty") + require.Empty(t, responseBytes, "expected response to be empty") return } // check cache is populated @@ -179,7 +173,7 @@ func TestBlockSignatures(t *testing.T) { tests := map[string]struct { setup func() (request []byte, expectedResponse []byte) verifyStats func(t *testing.T, stats *verifierStats) - err error + err *common.AppError }{ "known block": { setup: func() (request []byte, expectedResponse []byte) { @@ -192,8 +186,8 @@ func TestBlockSignatures(t *testing.T) { return toMessageBytes(knownBlkID), signature[:] }, verifyStats: func(t *testing.T, stats *verifierStats) { - require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count()) - require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count()) + require.Zero(t, stats.blockValidationFail.Snapshot().Count()) + require.Zero(t, stats.messageParseFail.Snapshot().Count()) }, }, "unknown block": { @@ -202,8 +196,8 @@ func TestBlockSignatures(t *testing.T) { return toMessageBytes(unknownBlockID), nil }, verifyStats: func(t *testing.T, stats *verifierStats) { - require.EqualValues(t, 1, stats.blockValidationFail.Snapshot().Count()) - require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count()) + require.Equal(t, int64(1), stats.blockValidationFail.Snapshot().Count()) + require.Zero(t, stats.messageParseFail.Snapshot().Count()) }, err: &common.AppError{Code: VerifyErrCode}, }, @@ -241,18 +235,13 @@ func TestBlockSignatures(t *testing.T) { protoBytes, err := proto.Marshal(protoMsg) require.NoError(t, err) responseBytes, appErr := handler.AppRequest(context.Background(), ids.GenerateTestNodeID(), time.Time{}, protoBytes) - if test.err != nil { - require.NotNil(t, appErr) - require.ErrorIs(t, test.err, appErr) - } else { - require.Nil(t, appErr) - } + require.ErrorIs(t, appErr, test.err) test.verifyStats(t, warpBackend.(*backend).stats) // If the expected response is empty, assert that the handler returns an empty response and return early. if len(expectedResponse) == 0 { - require.Len(t, responseBytes, 0, "expected response to be empty") + require.Empty(t, responseBytes, "expected response to be empty") return } // check cache is populated