From d9fd2521afd7b9e2ed55e5e63ab1795773138da4 Mon Sep 17 00:00:00 2001 From: Victor Farazdagi Date: Tue, 14 Jul 2020 19:51:39 +0300 Subject: [PATCH] Applies assertion funcs to p2p tests (#6597) * applies assertion funcs to p2p/encoder tests * applies assertion funcs to p2p/peers tests * addr_factory_test + broadcaster_test updated * connection_gater_test updated * applies assertion funcs to p2p/service tests * Merge branch 'master' into p2p-apply-testutils-assertions * minor fixes * Merge branch 'master' into p2p-apply-testutils-assertions * Merge refs/heads/master into p2p-apply-testutils-assertions --- beacon-chain/p2p/BUILD.bazel | 2 + beacon-chain/p2p/addr_factory_test.go | 22 +- beacon-chain/p2p/broadcaster_test.go | 30 +- beacon-chain/p2p/connection_gater_test.go | 156 +++------ beacon-chain/p2p/dial_relay_node_test.go | 30 +- beacon-chain/p2p/discovery_test.go | 55 +-- beacon-chain/p2p/encoder/BUILD.bazel | 2 + beacon-chain/p2p/encoder/snappy_test.go | 11 +- beacon-chain/p2p/encoder/ssz_test.go | 37 +- beacon-chain/p2p/encoder/varint_test.go | 21 +- beacon-chain/p2p/fork_test.go | 94 ++--- beacon-chain/p2p/options_test.go | 25 +- beacon-chain/p2p/parameter_test.go | 28 +- beacon-chain/p2p/peers/BUILD.bazel | 2 + beacon-chain/p2p/peers/status_test.go | 361 +++++--------------- beacon-chain/p2p/rpc_topic_mappings_test.go | 25 +- beacon-chain/p2p/sender_test.go | 23 +- beacon-chain/p2p/service_test.go | 117 ++----- beacon-chain/p2p/subnets_test.go | 38 +-- 19 files changed, 293 insertions(+), 786 deletions(-) diff --git a/beacon-chain/p2p/BUILD.bazel b/beacon-chain/p2p/BUILD.bazel index 405c14c88f..cb1989705e 100644 --- a/beacon-chain/p2p/BUILD.bazel +++ b/beacon-chain/p2p/BUILD.bazel @@ -121,6 +121,8 @@ go_test( "//shared/p2putils:go_default_library", "//shared/params:go_default_library", "//shared/testutil:go_default_library", + "//shared/testutil/assert:go_default_library", + "//shared/testutil/require:go_default_library", "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library", "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library", "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library", diff --git a/beacon-chain/p2p/addr_factory_test.go b/beacon-chain/p2p/addr_factory_test.go index 75f398d52f..e6df018105 100644 --- a/beacon-chain/p2p/addr_factory_test.go +++ b/beacon-chain/p2p/addr_factory_test.go @@ -1,10 +1,11 @@ package p2p import ( - "reflect" "testing" ma "github.com/multiformats/go-multiaddr" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestRelayAddrs_OnlyFactory(t *testing.T) { @@ -12,16 +13,11 @@ func TestRelayAddrs_OnlyFactory(t *testing.T) { f := withRelayAddrs(relay) a, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/33201/p2p/QmaXZhW44pwQxBSeLkE5FNeLz8tGTTEsRciFg1DNWXXrWG") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) addrs := []ma.Multiaddr{a} result := f(addrs) - - if len(result) != 2 { - t.Errorf("Unexpected number of addresses. Wanted %d, got %d", 2, len(result)) - } + assert.Equal(t, 2, len(result), "Unexpected number of addresses") expected := "/ip4/127.0.0.1/tcp/6660/p2p/QmQ7zhY7nGY66yK1n8hLGevfVyjbtvHSgtZuXkCH9oTrgi/p2p-circuit/ip4/127.0.0.1/tcp/33201/p2p/QmaXZhW44pwQxBSeLkE5FNeLz8tGTTEsRciFg1DNWXXrWG" if result[1].String() != expected { @@ -48,12 +44,6 @@ func TestRelayAddrs_UseNonRelayAddrs(t *testing.T) { } result := f(addrs) - - if len(result) != 2 { - t.Errorf("Unexpected number of addresses. Wanted %d, got %d", 2, len(result)) - } - - if !reflect.DeepEqual(result, addrs) { - t.Errorf("Wanted %v, got %v", addrs, result) - } + assert.Equal(t, 2, len(result), "Unexpected number of addresses") + assert.DeepEqual(t, addrs, result) } diff --git a/beacon-chain/p2p/broadcaster_test.go b/beacon-chain/p2p/broadcaster_test.go index 57aec664c2..507f53a284 100644 --- a/beacon-chain/p2p/broadcaster_test.go +++ b/beacon-chain/p2p/broadcaster_test.go @@ -15,6 +15,8 @@ import ( p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" testpb "github.com/prysmaticlabs/prysm/proto/testing" "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestService_Broadcast(t *testing.T) { @@ -42,17 +44,13 @@ func TestService_Broadcast(t *testing.T) { // Set a test gossip mapping for testpb.TestSimpleMessage. GossipTypeMapping[reflect.TypeOf(msg)] = topic digest, err := p.forkDigest() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) topic = fmt.Sprintf(topic, digest) // External peer subscribes to the topic. topic += p.Encoding().ProtocolSuffix() sub, err := p2.SubscribeToTopic(topic) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) time.Sleep(50 * time.Millisecond) // libp2p fails without this delay... @@ -65,23 +63,17 @@ func TestService_Broadcast(t *testing.T) { defer cancel() incomingMessage, err := sub.Next(ctx) - if err != nil { - tt.Fatal(err) - } + require.NoError(t, err) result := &testpb.TestSimpleMessage{} - if err := p.Encoding().DecodeGossip(incomingMessage.Data, result); err != nil { - tt.Fatal(err) - } + require.NoError(t, p.Encoding().DecodeGossip(incomingMessage.Data, result)) if !proto.Equal(result, msg) { tt.Errorf("Did not receive expected message, got %+v, wanted %+v", result, msg) } }(t) // Broadcast to peers and wait. - if err := p.Broadcast(context.Background(), msg); err != nil { - t.Fatal(err) - } + require.NoError(t, p.Broadcast(context.Background(), msg)) if testutil.WaitTimeout(&wg, 1*time.Second) { t.Error("Failed to receive pubsub within 1s") } @@ -92,9 +84,7 @@ func TestService_Broadcast_ReturnsErr_TopicNotMapped(t *testing.T) { genesisTime: time.Now(), genesisValidatorsRoot: []byte{'A'}, } - if err := p.Broadcast(context.Background(), &testpb.AddressBook{}); err != ErrMessageNotMapped { - t.Fatalf("Expected error %v, got %v", ErrMessageNotMapped, err) - } + assert.ErrorContains(t, ErrMessageNotMapped.Error(), p.Broadcast(context.Background(), &testpb.AddressBook{})) } func TestService_Attestation_Subnet(t *testing.T) { @@ -136,8 +126,6 @@ func TestService_Attestation_Subnet(t *testing.T) { } for _, tt := range tests { subnet := helpers.ComputeSubnetFromCommitteeAndSlot(100, tt.att.Data.CommitteeIndex, tt.att.Data.Slot) - if res := attestationToTopic(subnet, [4]byte{} /* fork digest */); res != tt.topic { - t.Errorf("Wrong topic, got %s wanted %s", res, tt.topic) - } + assert.Equal(t, tt.topic, attestationToTopic(subnet, [4]byte{} /* fork digest */), "Wrong topic") } } diff --git a/beacon-chain/p2p/connection_gater_test.go b/beacon-chain/p2p/connection_gater_test.go index 1cdfe6da0c..cc9b72baf9 100644 --- a/beacon-chain/p2p/connection_gater_test.go +++ b/beacon-chain/p2p/connection_gater_test.go @@ -9,6 +9,8 @@ import ( "github.com/libp2p/go-libp2p-core/peer" "github.com/multiformats/go-multiaddr" "github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestPeer_AtMaxLimit(t *testing.T) { @@ -17,52 +19,34 @@ func TestPeer_AtMaxLimit(t *testing.T) { ipAddr2, pkey2 := createAddrAndPrivKey(t) listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr, 2000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") s := &Service{} s.peers = peers.NewStatus(3) s.cfg = &Config{MaxPeers: 0} s.addrFilter, err = configureFilter(&Config{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) h1, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey), libp2p.ListenAddrs(listen), libp2p.ConnectionGater(s)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.host = h1 defer func() { err := h1.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() // create alternate host listen, err = multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr2, 3000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") h2, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey2), libp2p.ListenAddrs(listen)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer func() { err := h2.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() multiAddress, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d/p2p/%s", ipAddr, 2000, h1.ID())) addrInfo, err := peer.AddrInfoFromP2pAddr(multiAddress) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) err = h2.Connect(context.Background(), *addrInfo) - if err == nil { - t.Error("Wanted connection to fail with max peer") - } + require.NotNil(t, err, "Wanted connection to fail with max peer") } func TestPeer_BelowMaxLimit(t *testing.T) { @@ -71,52 +55,34 @@ func TestPeer_BelowMaxLimit(t *testing.T) { ipAddr2, pkey2 := createAddrAndPrivKey(t) listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr, 2000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") s := &Service{} s.peers = peers.NewStatus(3) s.cfg = &Config{MaxPeers: 1} s.addrFilter, err = configureFilter(&Config{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) h1, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey), libp2p.ListenAddrs(listen), libp2p.ConnectionGater(s)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.host = h1 defer func() { err := h1.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() // create alternate host listen, err = multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr2, 3000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") h2, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey2), libp2p.ListenAddrs(listen)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer func() { err := h2.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() multiAddress, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d/p2p/%s", ipAddr, 2000, h1.ID())) addrInfo, err := peer.AddrInfoFromP2pAddr(multiAddress) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) err = h2.Connect(context.Background(), *addrInfo) - if err != nil { - t.Errorf("Wanted connection to succeed: %v", err) - } + assert.NoError(t, err, "Wanted connection to succeed") } func TestPeerAllowList(t *testing.T) { @@ -130,50 +96,33 @@ func TestPeerAllowList(t *testing.T) { cidr := "202.35.89.12/16" listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr, 2000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") s := &Service{} s.addrFilter, err = configureFilter(&Config{AllowListCIDR: cidr}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) h1, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey), libp2p.ListenAddrs(listen), libp2p.ConnectionGater(s)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.host = h1 defer func() { err := h1.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() // create alternate host listen, err = multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr2, 3000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") h2, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey2), libp2p.ListenAddrs(listen)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer func() { err := h2.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() multiAddress, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d/p2p/%s", ipAddr2, 3000, h2.ID())) addrInfo, err := peer.AddrInfoFromP2pAddr(multiAddress) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) err = h1.Connect(context.Background(), *addrInfo) - if err == nil { - t.Error("Wanted connection to fail with allow list") - } + assert.NotNil(t, err, "Wanted connection to fail with allow list") + assert.ErrorContains(t, "no good addresses", err) } func TestPeerDenyList(t *testing.T) { @@ -187,50 +136,33 @@ func TestPeerDenyList(t *testing.T) { cidr := maskedIP.String() + fmt.Sprintf("/%d", ones) listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr, 2000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") s := &Service{} s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr}}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) h1, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey), libp2p.ListenAddrs(listen), libp2p.ConnectionGater(s)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.host = h1 defer func() { err := h1.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() // create alternate host listen, err = multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ipAddr2, 3000)) - if err != nil { - t.Fatalf("Failed to p2p listen: %v", err) - } + require.NoError(t, err, "Failed to p2p listen") h2, err := libp2p.New(context.Background(), []libp2p.Option{privKeyOption(pkey2), libp2p.ListenAddrs(listen)}...) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer func() { err := h2.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) }() multiAddress, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d/p2p/%s", ipAddr2, 3000, h2.ID())) addrInfo, err := peer.AddrInfoFromP2pAddr(multiAddress) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) err = h1.Connect(context.Background(), *addrInfo) - if err == nil { - t.Error("Wanted connection to fail with deny list") - } + assert.NotNil(t, err, "Wanted connection to fail with deny list") + assert.ErrorContains(t, "no good addresses", err) } func TestService_InterceptAddrDial_Allow(t *testing.T) { @@ -238,14 +170,10 @@ func TestService_InterceptAddrDial_Allow(t *testing.T) { var err error cidr := "212.67.89.112/16" s.addrFilter, err = configureFilter(&Config{AllowListCIDR: cidr}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) ip := "212.67.10.122" multiAddress, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ip, 3000)) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) valid := s.InterceptAddrDial("", multiAddress) if !valid { t.Errorf("Expected multiaddress with ip %s to not be rejected with an allow cidr mask of %s", ip, cidr) diff --git a/beacon-chain/p2p/dial_relay_node_test.go b/beacon-chain/p2p/dial_relay_node_test.go index c5b0625bed..96e7ace98e 100644 --- a/beacon-chain/p2p/dial_relay_node_test.go +++ b/beacon-chain/p2p/dial_relay_node_test.go @@ -7,44 +7,32 @@ import ( bh "github.com/libp2p/go-libp2p-blankhost" swarmt "github.com/libp2p/go-libp2p-swarm/testing" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestMakePeer_InvalidMultiaddress(t *testing.T) { _, err := MakePeer("/ip4") - if err == nil { - t.Error("Expect error when invalid multiaddress was provided") - } + assert.ErrorContains(t, "failed to parse multiaddr \"/ip4\"", err, "Expect error when invalid multiaddress was provided") } func TestMakePeer_OK(t *testing.T) { a, err := MakePeer("/ip4/127.0.0.1/tcp/5678/p2p/QmUn6ycS8Fu6L462uZvuEfDoSgYX6kqP4aSZWMa7z1tWAX") - if err != nil { - t.Fatalf("Unexpected error when making a valid peer: %v", err) - } - - if a.ID.Pretty() != "QmUn6ycS8Fu6L462uZvuEfDoSgYX6kqP4aSZWMa7z1tWAX" { - t.Errorf("Unexpected peer ID %v", a.ID.Pretty()) - } + require.NoError(t, err, "Unexpected error when making a valid peer") + assert.Equal(t, "QmUn6ycS8Fu6L462uZvuEfDoSgYX6kqP4aSZWMa7z1tWAX", a.ID.Pretty(), "Unexpected peer ID") } func TestDialRelayNode_InvalidPeerString(t *testing.T) { - if err := dialRelayNode(context.Background(), nil, "/ip4"); err == nil { - t.Fatal("Expected to fail with invalid peer string, but there was no error") - } + err := dialRelayNode(context.Background(), nil, "/ip4") + assert.ErrorContains(t, "failed to parse multiaddr \"/ip4\"", err, "Expected to fail with invalid peer string") } func TestDialRelayNode_OK(t *testing.T) { ctx := context.Background() relay := bh.NewBlankHost(swarmt.GenSwarm(t, ctx)) host := bh.NewBlankHost(swarmt.GenSwarm(t, ctx)) - relayAddr := fmt.Sprintf("%s/p2p/%s", relay.Addrs()[0], relay.ID().Pretty()) - if err := dialRelayNode(ctx, host, relayAddr); err != nil { - t.Errorf("Unexpected error when dialing relay node %v", err) - } - - if host.Peerstore().PeerInfo(relay.ID()).ID != relay.ID() { - t.Error("Host peerstore does not have peer info on relay node") - } + assert.NoError(t, dialRelayNode(ctx, host, relayAddr), "Unexpected error when dialing relay node") + assert.Equal(t, relay.ID(), host.Peerstore().PeerInfo(relay.ID()).ID, "Host peerstore does not have peer info on relay node") } diff --git a/beacon-chain/p2p/discovery_test.go b/beacon-chain/p2p/discovery_test.go index bae49565f3..e2f24a10b8 100644 --- a/beacon-chain/p2p/discovery_test.go +++ b/beacon-chain/p2p/discovery_test.go @@ -19,6 +19,8 @@ import ( statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state" "github.com/prysmaticlabs/prysm/shared/iputils" "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" logTest "github.com/sirupsen/logrus/hooks/test" ) @@ -37,14 +39,9 @@ func createAddrAndPrivKey(t *testing.T) (net.IP, *ecdsa.PrivateKey) { temp := testutil.TempDir() randNum := rand.Int() tempPath := path.Join(temp, strconv.Itoa(randNum)) - err = os.Mkdir(tempPath, 0700) - if err != nil { - t.Fatal(err) - } + require.NoError(t, os.Mkdir(tempPath, 0700)) pkey, err := privKey(&Config{DataDir: tempPath}) - if err != nil { - t.Fatalf("Could not get private key: %v", err) - } + require.NoError(t, err, "Could not get private key") return ipAddr, pkey } @@ -57,18 +54,12 @@ func TestCreateListener(t *testing.T) { cfg: &Config{UDPPort: uint(port)}, } listener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer listener.Close() - if !listener.Self().IP().Equal(ipAddr) { - t.Errorf("Ip address is not the expected type, wanted %s but got %s", ipAddr.String(), listener.Self().IP().String()) - } + assert.Equal(t, true, listener.Self().IP().Equal(ipAddr), "IP address is not the expected type") + assert.Equal(t, port, listener.Self().UDP(), "Incorrect port number") - if port != listener.Self().UDP() { - t.Errorf("In correct port number, wanted %d but got %d", port, listener.Self().UDP()) - } pubkey := listener.Self().Pubkey() XisSame := pkey.PublicKey.X.Cmp(pubkey.X) == 0 YisSame := pkey.PublicKey.Y.Cmp(pubkey.Y) == 0 @@ -89,9 +80,7 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } bootListener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer bootListener.Close() bootNode := bootListener.Self() @@ -110,9 +99,7 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } listener, err := s.startDiscoveryV5(ipAddr, pkey) - if err != nil { - t.Errorf("Could not start discovery for node: %v", err) - } + assert.NoError(t, err, "Could not start discovery for node") listeners = append(listeners, listener) } defer func() { @@ -141,13 +128,9 @@ func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) { genesisValidatorsRoot: []byte{'A'}, } node, err := s.createLocalNode(pkey, addr, 0, 0) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) multiAddr := convertToMultiAddr([]*enode.Node{node.Node()}) - if len(multiAddr) != 0 { - t.Error("Invalid ip address converted successfully") - } + assert.Equal(t, 0, len(multiAddr), "Invalid ip address converted successfully") } func TestMultiAddrConversion_OK(t *testing.T) { @@ -162,9 +145,7 @@ func TestMultiAddrConversion_OK(t *testing.T) { genesisValidatorsRoot: []byte{'A'}, } listener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer listener.Close() _ = convertToMultiAddr([]*enode.Node{listener.Self()}) @@ -201,9 +182,7 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) { cfg.StateNotifier = &mock.MockStateNotifier{} cfg.NoDiscovery = true s, err := NewService(cfg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) exitRoutine := make(chan bool) go func() { @@ -222,11 +201,7 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) { } time.Sleep(4 * time.Second) peers := s.host.Network().Peers() - if len(peers) != 5 { - t.Errorf("Not all peers added to peerstore, wanted %d but got %d", 5, len(peers)) - } - if err := s.Stop(); err != nil { - t.Fatal(err) - } + assert.Equal(t, 5, len(peers), "Not all peers added to peerstore") + require.NoError(t, s.Stop()) exitRoutine <- true } diff --git a/beacon-chain/p2p/encoder/BUILD.bazel b/beacon-chain/p2p/encoder/BUILD.bazel index 77fb793606..da194e5809 100644 --- a/beacon-chain/p2p/encoder/BUILD.bazel +++ b/beacon-chain/p2p/encoder/BUILD.bazel @@ -34,6 +34,8 @@ go_test( deps = [ "//proto/testing:go_default_library", "//shared/params:go_default_library", + "//shared/testutil/assert:go_default_library", + "//shared/testutil/require:go_default_library", "@com_github_gogo_protobuf//proto:go_default_library", "@com_github_golang_snappy//:go_default_library", ], diff --git a/beacon-chain/p2p/encoder/snappy_test.go b/beacon-chain/p2p/encoder/snappy_test.go index 2bace68ba4..1d6ee51ad7 100644 --- a/beacon-chain/p2p/encoder/snappy_test.go +++ b/beacon-chain/p2p/encoder/snappy_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/golang/snappy" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) func TestSszNetworkEncoder_BufferedReader(t *testing.T) { @@ -18,10 +19,7 @@ func TestSszNetworkEncoder_BufferedReader(t *testing.T) { rdr := newBufferedReader(bytes.NewBuffer(r2)) nPtr := reflect.ValueOf(rdr).Pointer() - - if nPtr != ptr { - t.Errorf("wanted pointer value of %d but got %d", ptr, nPtr) - } + assert.Equal(t, ptr, nPtr, "invalid pointer value") } func TestSszNetworkEncoder_BufferedWriter(t *testing.T) { @@ -34,8 +32,5 @@ func TestSszNetworkEncoder_BufferedWriter(t *testing.T) { rdr := newBufferedWriter(bytes.NewBuffer(r2)) nPtr := reflect.ValueOf(rdr).Pointer() - - if nPtr != ptr { - t.Errorf("wanted pointer value of %d but got %d", ptr, nPtr) - } + assert.Equal(t, ptr, nPtr, "invalid pointer value") } diff --git a/beacon-chain/p2p/encoder/ssz_test.go b/beacon-chain/p2p/encoder/ssz_test.go index 9d2422e2ea..a0e74bead2 100644 --- a/beacon-chain/p2p/encoder/ssz_test.go +++ b/beacon-chain/p2p/encoder/ssz_test.go @@ -3,13 +3,14 @@ package encoder_test import ( "bytes" "fmt" - "strings" "testing" "github.com/gogo/protobuf/proto" "github.com/prysmaticlabs/prysm/beacon-chain/p2p/encoder" testpb "github.com/prysmaticlabs/prysm/proto/testing" "github.com/prysmaticlabs/prysm/shared/params" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestSszNetworkEncoder_RoundTrip(t *testing.T) { @@ -31,13 +32,9 @@ func testRoundTripWithLength(t *testing.T, e *encoder.SszNetworkEncoder) { Bar: 9001, } _, err := e.EncodeWithMaxLength(buf, msg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) decoded := &testpb.TestSimpleMessage{} - if err := e.DecodeWithMaxLength(buf, decoded); err != nil { - t.Fatal(err) - } + require.NoError(t, e.DecodeWithMaxLength(buf, decoded)) if !proto.Equal(decoded, msg) { t.Logf("decoded=%+v\n", decoded) t.Error("Decoded message is not the same as original") @@ -51,13 +48,9 @@ func testRoundTripWithGossip(t *testing.T, e *encoder.SszNetworkEncoder) { Bar: 9001, } _, err := e.EncodeGossip(buf, msg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) decoded := &testpb.TestSimpleMessage{} - if err := e.DecodeGossip(buf.Bytes(), decoded); err != nil { - t.Fatal(err) - } + require.NoError(t, e.DecodeGossip(buf.Bytes(), decoded)) if !proto.Equal(decoded, msg) { t.Logf("decoded=%+v\n", decoded) t.Error("Decoded message is not the same as original") @@ -77,12 +70,7 @@ func TestSszNetworkEncoder_EncodeWithMaxLength(t *testing.T) { params.OverrideBeaconNetworkConfig(c) _, err := e.EncodeWithMaxLength(buf, msg) wanted := fmt.Sprintf("which is larger than the provided max limit of %d", params.BeaconNetworkConfig().MaxChunkSize) - if err == nil { - t.Fatalf("wanted this error %s but got nothing", wanted) - } - if !strings.Contains(err.Error(), wanted) { - t.Errorf("error did not contain wanted message. Wanted: %s but Got: %s", wanted, err.Error()) - } + assert.ErrorContains(t, wanted, err) } func TestSszNetworkEncoder_DecodeWithMaxLength(t *testing.T) { @@ -98,16 +86,9 @@ func TestSszNetworkEncoder_DecodeWithMaxLength(t *testing.T) { c.MaxChunkSize = maxChunkSize params.OverrideBeaconNetworkConfig(c) _, err := e.EncodeGossip(buf, msg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) decoded := &testpb.TestSimpleMessage{} err = e.DecodeWithMaxLength(buf, decoded) wanted := fmt.Sprintf("goes over the provided max limit of %d", maxChunkSize) - if err == nil { - t.Fatalf("wanted this error %s but got nothing", wanted) - } - if !strings.Contains(err.Error(), wanted) { - t.Errorf("error did not contain wanted message. Wanted: %s but Got: %s", wanted, err.Error()) - } + assert.ErrorContains(t, wanted, err) } diff --git a/beacon-chain/p2p/encoder/varint_test.go b/beacon-chain/p2p/encoder/varint_test.go index d6b41ca14e..6170a0e5b5 100644 --- a/beacon-chain/p2p/encoder/varint_test.go +++ b/beacon-chain/p2p/encoder/varint_test.go @@ -5,6 +5,8 @@ import ( "testing" "github.com/gogo/protobuf/proto" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestReadVarint(t *testing.T) { @@ -12,12 +14,8 @@ func TestReadVarint(t *testing.T) { prefixedData := append(proto.EncodeVarint(uint64(len(data))), data...) vi, err := readVarint(bytes.NewBuffer(prefixedData)) - if err != nil { - t.Fatal(err) - } - if vi != uint64(len(data)) { - t.Errorf("Received wrong varint. Wanted %d, got %d", len(data), vi) - } + require.NoError(t, err) + assert.Equal(t, uint64(len(data)), vi, "Received wrong varint") } func TestReadVarint_ExceedsMaxLength(t *testing.T) { @@ -30,18 +28,11 @@ func TestReadVarint_ExceedsMaxLength(t *testing.T) { } header = append(header, tByte) _, err := readVarint(bytes.NewBuffer(header)) - if err != nil { - t.Fatal("Expected no error from reading valid header") - } + require.NoError(t, err, "Expected no error from reading valid header") length := len(header) // Add an additional byte to make header invalid. header = append(header[:length-1], []byte{fByte, tByte}...) _, err = readVarint(bytes.NewBuffer(header)) - if err == nil { - t.Fatal("Expected error from reading invalid header") - } - if err != errExcessMaxLength { - t.Errorf("Got incorrect error, wanted %v but got %v", errExcessMaxLength, err) - } + assert.ErrorContains(t, errExcessMaxLength.Error(), err, "Expected error from reading invalid header") } diff --git a/beacon-chain/p2p/fork_test.go b/beacon-chain/p2p/fork_test.go index 754709e579..0ba248d4af 100644 --- a/beacon-chain/p2p/fork_test.go +++ b/beacon-chain/p2p/fork_test.go @@ -18,6 +18,8 @@ import ( "github.com/prysmaticlabs/prysm/shared/p2putils" "github.com/prysmaticlabs/prysm/shared/params" "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" "github.com/sirupsen/logrus" logTest "github.com/sirupsen/logrus/hooks/test" ) @@ -33,9 +35,7 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } bootListener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer bootListener.Close() bootNode := bootListener.Self() @@ -61,9 +61,7 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) { genesisValidatorsRoot: root, } listener, err := s.startDiscoveryV5(ipAddr, pkey) - if err != nil { - t.Errorf("Could not start discovery for node: %v", err) - } + assert.NoError(t, err, "Could not start discovery for node") listeners = append(listeners, listener) } defer func() { @@ -100,20 +98,14 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) { for _, n := range nodes { if s.filterPeer(n) { addr, err := convertToSingleMultiAddr(n) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) addrs = append(addrs, addr) } } // We should not have valid peers if the fork digest mismatched. - if len(addrs) != 0 { - t.Errorf("Expected 0 valid peers, got %d", len(addrs)) - } - if err := s.Stop(); err != nil { - t.Fatal(err) - } + assert.Equal(t, 0, len(addrs), "Expected 0 valid peers") + require.NoError(t, s.Stop()) } func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) { @@ -129,9 +121,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } bootListener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer bootListener.Close() bootNode := bootListener.Self() @@ -161,9 +151,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } listener, err := s.startDiscoveryV5(ipAddr, pkey) - if err != nil { - t.Errorf("Could not start discovery for node: %v", err) - } + assert.NoError(t, err, "Could not start discovery for node") listeners = append(listeners, listener) } defer func() { @@ -189,9 +177,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) { cfg.TCPPort = 14001 cfg.MaxPeers = 30 s, err = NewService(cfg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.genesisTime = genesisTime s.genesisValidatorsRoot = make([]byte, 32) @@ -201,9 +187,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) { for _, n := range nodes { if s.filterPeer(n) { addr, err := convertToSingleMultiAddr(n) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) addrs = append(addrs, addr) } } @@ -212,9 +196,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) { } testutil.AssertLogsContain(t, hook, "Peer matches fork digest but has different next fork epoch") - if err := s.Stop(); err != nil { - t.Fatal(err) - } + require.NoError(t, s.Stop()) } func TestDiscv5_AddRetrieveForkEntryENR(t *testing.T) { @@ -233,83 +215,57 @@ func TestDiscv5_AddRetrieveForkEntryENR(t *testing.T) { genesisTime := time.Now() genesisValidatorsRoot := make([]byte, 32) digest, err := p2putils.CreateForkDigest(genesisTime, make([]byte, 32)) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) enrForkID := &pb.ENRForkID{ CurrentForkDigest: digest[:], NextForkVersion: nextForkVersion, NextForkEpoch: nextForkEpoch, } enc, err := enrForkID.MarshalSSZ() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) forkEntry := enr.WithEntry(eth2ENRKey, enc) // In epoch 1 of current time, the fork version should be // {0, 0, 0, 1} according to the configuration override above. temp := testutil.TempDir() randNum := rand.Int() tempPath := path.Join(temp, strconv.Itoa(randNum)) - if err := os.Mkdir(tempPath, 0700); err != nil { - t.Fatal(err) - } + require.NoError(t, os.Mkdir(tempPath, 0700)) pkey, err := privKey(&Config{DataDir: tempPath}) - if err != nil { - t.Fatalf("Could not get private key: %v", err) - } + require.NoError(t, err, "Could not get private key") db, err := enode.OpenDB("") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) localNode := enode.NewLocalNode(db, pkey) localNode.Set(forkEntry) want, err := helpers.ComputeForkDigest([]byte{0, 0, 0, 0}, genesisValidatorsRoot) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) resp, err := retrieveForkEntry(localNode.Node().Record()) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) if !bytes.Equal(resp.CurrentForkDigest, want[:]) { t.Errorf("Wanted fork digest: %v, received %v", want, resp.CurrentForkDigest) } if !bytes.Equal(resp.NextForkVersion[:], nextForkVersion) { t.Errorf("Wanted next fork version: %v, received %v", nextForkVersion, resp.NextForkVersion) } - if resp.NextForkEpoch != nextForkEpoch { - t.Errorf("Wanted next for epoch: %d, received: %d", nextForkEpoch, resp.NextForkEpoch) - } + assert.Equal(t, nextForkEpoch, resp.NextForkEpoch, "Unexpected next fork epoch") } func TestAddForkEntry_Genesis(t *testing.T) { temp := testutil.TempDir() randNum := rand.Int() tempPath := path.Join(temp, strconv.Itoa(randNum)) - if err := os.Mkdir(tempPath, 0700); err != nil { - t.Fatal(err) - } + require.NoError(t, os.Mkdir(tempPath, 0700)) pkey, err := privKey(&Config{DataDir: tempPath}) - if err != nil { - t.Fatalf("Could not get private key: %v", err) - } + require.NoError(t, err, "Could not get private key") db, err := enode.OpenDB("") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) localNode := enode.NewLocalNode(db, pkey) localNode, err = addForkEntry(localNode, time.Now().Add(10*time.Second), []byte{'A', 'B', 'C', 'D'}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) forkEntry, err := retrieveForkEntry(localNode.Node().Record()) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) if !bytes.Equal(forkEntry.NextForkVersion, params.BeaconConfig().GenesisForkVersion) { t.Errorf("Wanted Next Fork Version to be equal to genesis fork version, instead got %#x", forkEntry.NextForkVersion) } diff --git a/beacon-chain/p2p/options_test.go b/beacon-chain/p2p/options_test.go index 7ab6c2b6e0..5c40c556e4 100644 --- a/beacon-chain/p2p/options_test.go +++ b/beacon-chain/p2p/options_test.go @@ -11,22 +11,19 @@ import ( "github.com/libp2p/go-libp2p-core/crypto" "github.com/prysmaticlabs/prysm/shared/params" "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestPrivateKeyLoading(t *testing.T) { file, err := ioutil.TempFile(testutil.TempDir(), "key") - if err != nil { - log.Fatal(err) - } + require.NoError(t, err) defer func() { if err := os.Remove(file.Name()); err != nil { t.Log(err) } }() key, _, err := crypto.GenerateSecp256k1Key(rand.Reader) - if err != nil { - t.Fatalf("Could not generate key: %v", err) - } + require.NoError(t, err, "Could not generate key") raw, err := key.Raw() if err != nil { panic(err) @@ -34,26 +31,18 @@ func TestPrivateKeyLoading(t *testing.T) { out := hex.EncodeToString(raw) err = ioutil.WriteFile(file.Name(), []byte(out), params.BeaconIoConfig().ReadWritePermissions) - if err != nil { - t.Fatalf("Could not write key to file: %v", err) - } + require.NoError(t, err, "Could not write key to file") log.WithField("file", file.Name()).WithField("key", out).Info("Wrote key to file") cfg := &Config{ PrivateKey: file.Name(), } pKey, err := privKey(cfg) - if err != nil { - t.Fatalf("Could not apply option: %v", err) - } + require.NoError(t, err, "Could not apply option") newPkey := convertToInterfacePrivkey(pKey) rawBytes, err := key.Raw() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) newRaw, err := newPkey.Raw() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) if !bytes.Equal(newRaw, rawBytes) { t.Errorf("Private keys do not match got %#x but wanted %#x", rawBytes, newRaw) } diff --git a/beacon-chain/p2p/parameter_test.go b/beacon-chain/p2p/parameter_test.go index 004d7f9e92..31637dbd56 100644 --- a/beacon-chain/p2p/parameter_test.go +++ b/beacon-chain/p2p/parameter_test.go @@ -4,6 +4,7 @@ import ( "testing" pubsub "github.com/libp2p/go-libp2p-pubsub" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) const ( @@ -27,27 +28,14 @@ const ( ) func TestOverlayParameters(t *testing.T) { - if pubsub.GossipSubD != gossipSubD { - t.Errorf("gossipSubD, wanted: %d, got: %d", gossipSubD, pubsub.GossipSubD) - } - - if pubsub.GossipSubDlo != gossipSubDlo { - t.Errorf("gossipSubDlo, wanted: %d, got: %d", gossipSubDlo, pubsub.GossipSubDlo) - } - - if pubsub.GossipSubDhi != gossipSubDhi { - t.Errorf("gossipSubDhi, wanted: %d, got: %d", gossipSubDhi, pubsub.GossipSubDhi) - } + assert.Equal(t, gossipSubD, pubsub.GossipSubD, "gossipSubD") + assert.Equal(t, gossipSubDlo, pubsub.GossipSubDlo, "gossipSubDlo") + assert.Equal(t, gossipSubDhi, pubsub.GossipSubDhi, "gossipSubDhi") } func TestGossipParameters(t *testing.T) { - if pubsub.GossipSubHistoryLength != gossipSubHistoryLength { - t.Errorf("gossipSubHistoryLength, wanted: %d, got: %d", gossipSubHistoryLength, pubsub.GossipSubHistoryLength) - } - - if pubsub.GossipSubHistoryGossip != gossipSubHistoryGossip { - t.Errorf("gossipSubHistoryGossip, wanted: %d, got: %d", gossipSubHistoryGossip, pubsub.GossipSubDlo) - } + assert.Equal(t, gossipSubHistoryLength, pubsub.GossipSubHistoryLength, "gossipSubHistoryLength") + assert.Equal(t, gossipSubHistoryGossip, pubsub.GossipSubHistoryGossip, "gossipSubHistoryGossip") } func TestFanoutParameters(t *testing.T) { @@ -63,7 +51,5 @@ func TestHeartbeatParameters(t *testing.T) { } func TestMiscParameters(t *testing.T) { - if pubsub.RandomSubD != randomSubD { - t.Errorf("randomSubD, wanted: %d, got: %d", randomSubD, pubsub.RandomSubD) - } + assert.Equal(t, randomSubD, pubsub.RandomSubD, "randomSubD") } diff --git a/beacon-chain/p2p/peers/BUILD.bazel b/beacon-chain/p2p/peers/BUILD.bazel index 67efdef301..afd59b4008 100644 --- a/beacon-chain/p2p/peers/BUILD.bazel +++ b/beacon-chain/p2p/peers/BUILD.bazel @@ -30,6 +30,8 @@ go_test( deps = [ "//proto/beacon/p2p/v1:go_default_library", "//shared/params:go_default_library", + "//shared/testutil/assert:go_default_library", + "//shared/testutil/require:go_default_library", "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library", "@com_github_libp2p_go_libp2p_core//network:go_default_library", "@com_github_libp2p_go_libp2p_core//peer:go_default_library", diff --git a/beacon-chain/p2p/peers/status_test.go b/beacon-chain/p2p/peers/status_test.go index 0f7f2b0549..3aa809d281 100644 --- a/beacon-chain/p2p/peers/status_test.go +++ b/beacon-chain/p2p/peers/status_test.go @@ -2,7 +2,6 @@ package peers_test import ( "crypto/rand" - "reflect" "testing" "github.com/ethereum/go-ethereum/p2p/enr" @@ -13,17 +12,15 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers" pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" "github.com/prysmaticlabs/prysm/shared/params" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestStatus(t *testing.T) { maxBadResponses := 2 p := peers.NewStatus(maxBadResponses) - if p == nil { - t.Fatalf("p not created") - } - if p.MaxBadResponses() != maxBadResponses { - t.Errorf("maxBadResponses incorrect value: expected %v, received %v", maxBadResponses, p.MaxBadResponses()) - } + require.NotNil(t, p, "p not created") + assert.Equal(t, maxBadResponses, p.MaxBadResponses(), "maxBadResponses incorrect value") } func TestPeerExplicitAdd(t *testing.T) { @@ -31,55 +28,33 @@ func TestPeerExplicitAdd(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatalf("Failed to create ID: %v", err) - } + require.NoError(t, err, "Failed to create ID") address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err, "Failed to create address") direction := network.DirInbound p.Add(new(enr.Record), id, address, direction) resAddress, err := p.Address(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resAddress != address { - t.Errorf("Unexpected address: expected %v, received %v", address, resAddress) - } + require.NoError(t, err) + assert.Equal(t, address, resAddress, "Unexpected address") resDirection, err := p.Direction(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resDirection != direction { - t.Errorf("Unexpected direction: expected %v, received %v", direction, resDirection) - } + require.NoError(t, err) + assert.Equal(t, direction, resDirection, "Unexpected direction") // Update with another explicit add address2, err := ma.NewMultiaddr("/ip4/52.23.23.253/tcp/30000/ipfs/QmfAgkmjiZNZhr2wFN9TwaRgHouMTBT6HELyzE5A3BT2wK/p2p-circuit") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err) direction2 := network.DirOutbound p.Add(new(enr.Record), id, address2, direction2) resAddress2, err := p.Address(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resAddress2 != address2 { - t.Errorf("Unexpected address: expected %v, received %v", address2, resAddress2) - } + require.NoError(t, err) + assert.Equal(t, address2, resAddress2, "Unexpected address") resDirection2, err := p.Direction(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resDirection2 != direction2 { - t.Errorf("Unexpected direction: expected %v, received %v", direction2, resDirection2) - } + require.NoError(t, err) + assert.Equal(t, direction2, resDirection2, "Unexpected direction") } func TestPeerNoENR(t *testing.T) { @@ -87,23 +62,16 @@ func TestPeerNoENR(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatalf("Failed to create ID: %v", err) - } + require.NoError(t, err, "Failed to create ID") address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err, "Failed to create address") direction := network.DirInbound p.Add(nil, id, address, direction) retrievedENR, err := p.ENR(id) - if err != nil { - t.Fatalf("Could not retrieve chainstate: %v", err) - } - if retrievedENR != nil { - t.Error("Wanted a nil enr to be saved") - } + require.NoError(t, err, "Could not retrieve chainstate") + var nilENR *enr.Record + assert.Equal(t, nilENR, retrievedENR, "Wanted a nil enr to be saved") } func TestPeerNoOverwriteENR(t *testing.T) { @@ -111,13 +79,9 @@ func TestPeerNoOverwriteENR(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatalf("Failed to create ID: %v", err) - } + require.NoError(t, err, "Failed to create ID") address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err, "Failed to create address") direction := network.DirInbound record := new(enr.Record) record.Set(enr.WithEntry("test", []byte{'a'})) @@ -126,12 +90,8 @@ func TestPeerNoOverwriteENR(t *testing.T) { p.Add(nil, id, address, direction) retrievedENR, err := p.ENR(id) - if err != nil { - t.Fatalf("Could not retrieve chainstate: %v", err) - } - if retrievedENR == nil { - t.Error("Wanted a non-nil enr") - } + require.NoError(t, err, "Could not retrieve chainstate") + require.NotNil(t, retrievedENR, "Wanted a non-nil enr") } func TestErrUnknownPeer(t *testing.T) { @@ -139,39 +99,25 @@ func TestErrUnknownPeer(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) _, err = p.Address(id) - if err != peers.ErrPeerUnknown { - t.Errorf("Unexpected error: expected %v, received %v", peers.ErrPeerUnknown, err) - } + assert.ErrorContains(t, peers.ErrPeerUnknown.Error(), err) _, err = p.Direction(id) - if err != peers.ErrPeerUnknown { - t.Errorf("Unexpected error: expected %v, received %v", peers.ErrPeerUnknown, err) - } + assert.ErrorContains(t, peers.ErrPeerUnknown.Error(), err) _, err = p.ChainState(id) - if err != peers.ErrPeerUnknown { - t.Errorf("Unexpected error: expected %v, received %v", peers.ErrPeerUnknown, err) - } + assert.ErrorContains(t, peers.ErrPeerUnknown.Error(), err) _, err = p.ConnectionState(id) - if err != peers.ErrPeerUnknown { - t.Errorf("Unexpected error: expected %v, received %v", peers.ErrPeerUnknown, err) - } + assert.ErrorContains(t, peers.ErrPeerUnknown.Error(), err) _, err = p.ChainStateLastUpdated(id) - if err != peers.ErrPeerUnknown { - t.Errorf("Unexpected error: expected %v, received %v", peers.ErrPeerUnknown, err) - } + assert.ErrorContains(t, peers.ErrPeerUnknown.Error(), err) _, err = p.BadResponses(id) - if err != peers.ErrPeerUnknown { - t.Errorf("Unexpected error: expected %v, received %v", peers.ErrPeerUnknown, err) - } + assert.ErrorContains(t, peers.ErrPeerUnknown.Error(), err) } func TestPeerCommitteeIndices(t *testing.T) { @@ -179,13 +125,9 @@ func TestPeerCommitteeIndices(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatalf("Failed to create ID: %v", err) - } + require.NoError(t, err, "Failed to create ID") address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err, "Failed to create address") direction := network.DirInbound record := new(enr.Record) record.Set(enr.WithEntry("test", []byte{'a'})) @@ -204,13 +146,8 @@ func TestPeerCommitteeIndices(t *testing.T) { wantedIndices := []uint64{2, 8, 9} indices, err := p.CommitteeIndices(id) - if err != nil { - t.Fatalf("Could not retrieve committee indices: %v", err) - } - - if !reflect.DeepEqual(indices, wantedIndices) { - t.Errorf("Wanted indices of %v but got %v", wantedIndices, indices) - } + require.NoError(t, err, "Could not retrieve committee indices") + assert.DeepEqual(t, wantedIndices, indices) } func TestPeerSubscribedToSubnet(t *testing.T) { @@ -238,28 +175,16 @@ func TestPeerSubscribedToSubnet(t *testing.T) { addPeer(t, p, peers.PeerDisconnected) } peers := p.SubscribedToSubnet(2) - if len(peers) != 1 { - t.Errorf("Expected num of peers to be %d but got %d", 1, len(peers)) - } - if peers[0] != expectedPeer { - t.Errorf("Expected peer of %s but got %s", expectedPeer, peers[0]) - } + assert.Equal(t, 1, len(peers), "Unexpected num of peers") + assert.Equal(t, expectedPeer, peers[0]) peers = p.SubscribedToSubnet(8) - if len(peers) != 1 { - t.Errorf("Expected num of peers to be %d but got %d", 1, len(peers)) - } - if peers[0] != expectedPeer { - t.Errorf("Expected peer of %s but got %s", expectedPeer, peers[0]) - } + assert.Equal(t, 1, len(peers), "Unexpected num of peers") + assert.Equal(t, expectedPeer, peers[0]) peers = p.SubscribedToSubnet(9) - if len(peers) != 1 { - t.Errorf("Expected num of peers to be %d but got %d", 1, len(peers)) - } - if peers[0] != expectedPeer { - t.Errorf("Expected peer of %s but got %s", expectedPeer, peers[0]) - } + assert.Equal(t, 1, len(peers), "Unexpected num of peers") + assert.Equal(t, expectedPeer, peers[0]) } func TestPeerImplicitAdd(t *testing.T) { @@ -267,21 +192,15 @@ func TestPeerImplicitAdd(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) connectionState := peers.PeerConnecting p.SetConnectionState(id, connectionState) resConnectionState, err := p.ConnectionState(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } + require.NoError(t, err) - if resConnectionState != connectionState { - t.Errorf("Unexpected connection state: expected %v, received %v", connectionState, resConnectionState) - } + assert.Equal(t, connectionState, resConnectionState, "Unexpected connection state") } func TestPeerChainState(t *testing.T) { @@ -289,36 +208,24 @@ func TestPeerChainState(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err, "Failed to create address") direction := network.DirInbound p.Add(new(enr.Record), id, address, direction) oldChainStartLastUpdated, err := p.ChainStateLastUpdated(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } + require.NoError(t, err) finalizedEpoch := uint64(123) p.SetChainState(id, &pb.Status{FinalizedEpoch: finalizedEpoch}) resChainState, err := p.ChainState(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resChainState.FinalizedEpoch != finalizedEpoch { - t.Errorf("Unexpected finalized epoch: expected %v, received %v", finalizedEpoch, resChainState.FinalizedEpoch) - } + require.NoError(t, err) + assert.Equal(t, finalizedEpoch, resChainState.FinalizedEpoch, "Unexpected finalized epoch") newChainStartLastUpdated, err := p.ChainStateLastUpdated(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } + require.NoError(t, err) if !newChainStartLastUpdated.After(oldChainStartLastUpdated) { t.Errorf("Last updated did not increase: old %v new %v", oldChainStartLastUpdated, newChainStartLastUpdated) } @@ -329,74 +236,41 @@ func TestPeerBadResponses(t *testing.T) { p := peers.NewStatus(maxBadResponses) id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) { - bytes, err := id.MarshalBinary() - if err != nil { - t.Fatal(err) - } - t.Logf("%x\n", bytes) + _, err := id.MarshalBinary() + require.NoError(t, err) } - if p.IsBad(id) { - t.Error("Peer marked as bad when should be good") - } + assert.Equal(t, false, p.IsBad(id), "Peer marked as bad when should be good") address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000") - if err != nil { - t.Fatalf("Failed to create address: %v", err) - } + require.NoError(t, err, "Failed to create address") direction := network.DirInbound p.Add(new(enr.Record), id, address, direction) resBadResponses, err := p.BadResponses(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resBadResponses != 0 { - t.Errorf("Unexpected bad responses: expected 0, received %v", resBadResponses) - } - if p.IsBad(id) { - t.Error("Peer marked as bad when should be good") - } + require.NoError(t, err) + assert.Equal(t, 0, resBadResponses, "Unexpected bad responses") + assert.Equal(t, false, p.IsBad(id), "Peer marked as bad when should be good") p.IncrementBadResponses(id) resBadResponses, err = p.BadResponses(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resBadResponses != 1 { - t.Errorf("Unexpected bad responses: expected 1, received %v", resBadResponses) - } - if p.IsBad(id) { - t.Error("Peer marked as bad when should be good") - } + require.NoError(t, err) + assert.Equal(t, 1, resBadResponses, "Unexpected bad responses") + assert.Equal(t, false, p.IsBad(id), "Peer marked as bad when should be good") p.IncrementBadResponses(id) resBadResponses, err = p.BadResponses(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resBadResponses != 2 { - t.Errorf("Unexpected bad responses: expected 2, received %v", resBadResponses) - } - if !p.IsBad(id) { - t.Error("Peer not marked as bad when it should be") - } + require.NoError(t, err) + assert.Equal(t, 2, resBadResponses, "Unexpected bad responses") + assert.Equal(t, true, p.IsBad(id), "Peer not marked as bad when it should be") p.IncrementBadResponses(id) resBadResponses, err = p.BadResponses(id) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - if resBadResponses != 3 { - t.Errorf("Unexpected bad responses: expected 3, received %v", resBadResponses) - } - if !p.IsBad(id) { - t.Error("Peer not marked as bad when it should be") - } + require.NoError(t, err) + assert.Equal(t, 3, resBadResponses, "Unexpected bad responses") + assert.Equal(t, true, p.IsBad(id), "Peer not marked as bad when it should be") } func TestAddMetaData(t *testing.T) { @@ -417,12 +291,8 @@ func TestAddMetaData(t *testing.T) { p.SetMetadata(newPeer, newMetaData) md, err := p.Metadata(newPeer) - if err != nil { - t.Fatal(err) - } - if md.SeqNumber != newMetaData.SeqNumber { - t.Errorf("Wanted sequence number of %d but got %d", newMetaData.SeqNumber, md.SeqNumber) - } + require.NoError(t, err) + assert.Equal(t, newMetaData.SeqNumber, md.SeqNumber, "Unexpected sequence number") } func TestPeerConnectionStatuses(t *testing.T) { @@ -448,30 +318,16 @@ func TestPeerConnectionStatuses(t *testing.T) { } // Now confirm the states - if len(p.Disconnected()) != numPeersDisconnected { - t.Errorf("Unexpected number of disconnected peers: expected %v, received %v", numPeersDisconnected, len(p.Disconnected())) - } - if len(p.Connecting()) != numPeersConnecting { - t.Errorf("Unexpected number of connecting peers: expected %v, received %v", numPeersConnecting, len(p.Connecting())) - } - if len(p.Connected()) != numPeersConnected { - t.Errorf("Unexpected number of connected peers: expected %v, received %v", numPeersConnected, len(p.Connected())) - } - if len(p.Disconnecting()) != numPeersDisconnecting { - t.Errorf("Unexpected number of disconnecting peers: expected %v, received %v", numPeersDisconnecting, len(p.Disconnecting())) - } + assert.Equal(t, numPeersDisconnected, len(p.Disconnected()), "Unexpected number of disconnected peers") + assert.Equal(t, numPeersConnecting, len(p.Connecting()), "Unexpected number of connecting peers") + assert.Equal(t, numPeersConnected, len(p.Connected()), "Unexpected number of connected peers") + assert.Equal(t, numPeersDisconnecting, len(p.Disconnecting()), "Unexpected number of disconnecting peers") numPeersActive := numPeersConnecting + numPeersConnected - if len(p.Active()) != numPeersActive { - t.Errorf("Unexpected number of active peers: expected %v, received %v", numPeersActive, len(p.Active())) - } + assert.Equal(t, numPeersActive, len(p.Active()), "Unexpected number of active peers") numPeersInactive := numPeersDisconnecting + numPeersDisconnected - if len(p.Inactive()) != numPeersInactive { - t.Errorf("Unexpected number of inactive peers: expected %v, received %v", numPeersInactive, len(p.Inactive())) - } + assert.Equal(t, numPeersInactive, len(p.Inactive()), "Unexpected number of inactive peers") numPeersAll := numPeersActive + numPeersInactive - if len(p.All()) != numPeersAll { - t.Errorf("Unexpected number of peers: expected %v, received %v", numPeersAll, len(p.All())) - } + assert.Equal(t, numPeersAll, len(p.All()), "Unexpected number of peers") } func TestDecay(t *testing.T) { @@ -493,26 +349,14 @@ func TestDecay(t *testing.T) { // Ensure the new values are as expected badResponses1, err := p.BadResponses(pid1) - if err != nil { - t.Fatal(err) - } - if badResponses1 != 0 { - t.Errorf("Unexpected bad responses for peer 0: expected 0, received %v", badResponses1) - } + require.NoError(t, err) + assert.Equal(t, 0, badResponses1, "Unexpected bad responses for peer 1") badResponses2, err := p.BadResponses(pid2) - if err != nil { - t.Fatal(err) - } - if badResponses2 != 0 { - t.Errorf("Unexpected bad responses for peer 0: expected 0, received %v", badResponses2) - } + require.NoError(t, err) + assert.Equal(t, 0, badResponses2, "Unexpected bad responses for peer 2") badResponses3, err := p.BadResponses(pid3) - if err != nil { - t.Fatal(err) - } - if badResponses3 != 1 { - t.Errorf("Unexpected bad responses for peer 0: expected 0, received %v", badResponses3) - } + require.NoError(t, err) + assert.Equal(t, 1, badResponses3, "Unexpected bad responses for peer 3") } func TestTrimmedOrderedPeers(t *testing.T) { @@ -560,23 +404,13 @@ func TestTrimmedOrderedPeers(t *testing.T) { }) target, pids := p.BestFinalized(maxPeers, 0) - if target != expectedTarget { - t.Errorf("Incorrect target epoch retrieved; wanted %v but got %v", expectedTarget, target) - } - if len(pids) != maxPeers { - t.Errorf("Incorrect number of peers retrieved; wanted %v but got %v", maxPeers, len(pids)) - } + assert.Equal(t, expectedTarget, target, "Incorrect target epoch retrieved") + assert.Equal(t, maxPeers, len(pids), "Incorrect number of peers retrieved") // Expect the returned list to be ordered by finalized epoch and trimmed to max peers. - if pids[0] != pid3 { - t.Errorf("Incorrect first peer; wanted %v but got %v", pid3, pids[0]) - } - if pids[1] != pid2 { - t.Errorf("Incorrect second peer; wanted %v but got %v", pid2, pids[1]) - } - if pids[2] != pid1 { - t.Errorf("Incorrect third peer; wanted %v but got %v", pid1, pids[2]) - } + assert.Equal(t, pid3, pids[0], "Incorrect first peer") + assert.Equal(t, pid2, pids[1], "Incorrect second peer") + assert.Equal(t, pid1, pids[2], "Incorrect third peer") } func TestBestPeer(t *testing.T) { @@ -623,9 +457,7 @@ func TestBestPeer(t *testing.T) { FinalizedRoot: junkRoot[:], }) retEpoch, _ := p.BestFinalized(15, 0) - if retEpoch != expectedFinEpoch { - t.Errorf("Incorrect Finalized epoch retrieved; wanted %v but got %v", expectedFinEpoch, retEpoch) - } + assert.Equal(t, expectedFinEpoch, retEpoch, "Incorrect Finalized epoch retrieved") } func TestBestFinalized_returnsMaxValue(t *testing.T) { @@ -642,9 +474,7 @@ func TestBestFinalized_returnsMaxValue(t *testing.T) { } _, pids := p.BestFinalized(maxPeers, 0) - if len(pids) != maxPeers { - t.Fatalf("returned wrong number of peers, wanted %d, got %d", maxPeers, len(pids)) - } + assert.Equal(t, maxPeers, len(pids), "Wrong number of peers returned") } func TestStatus_CurrentEpoch(t *testing.T) { @@ -666,9 +496,7 @@ func TestStatus_CurrentEpoch(t *testing.T) { HeadSlot: params.BeaconConfig().SlotsPerEpoch * 4, }) - if p.HighestEpoch() != 5 { - t.Fatalf("Expected current epoch to be 5, got %d", p.HighestEpoch()) - } + assert.Equal(t, uint64(5), p.HighestEpoch(), "Expected current epoch to be 5") } // addPeer is a helper to add a peer with a given connection state) @@ -676,14 +504,11 @@ func addPeer(t *testing.T, p *peers.Status, state peers.PeerConnectionState) pee // Set up some peers with different states mhBytes := []byte{0x11, 0x04} idBytes := make([]byte, 4) - if _, err := rand.Read(idBytes); err != nil { - t.Fatal(err) - } + _, err := rand.Read(idBytes) + require.NoError(t, err) mhBytes = append(mhBytes, idBytes...) id, err := peer.IDFromBytes(mhBytes) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } + require.NoError(t, err) p.Add(new(enr.Record), id, nil, network.DirUnknown) p.SetConnectionState(id, state) p.SetMetadata(id, &pb.MetaData{ diff --git a/beacon-chain/p2p/rpc_topic_mappings_test.go b/beacon-chain/p2p/rpc_topic_mappings_test.go index 33ad46c74a..b986939d06 100644 --- a/beacon-chain/p2p/rpc_topic_mappings_test.go +++ b/beacon-chain/p2p/rpc_topic_mappings_test.go @@ -4,28 +4,17 @@ import ( "testing" pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) func TestVerifyRPCMappings(t *testing.T) { - if err := VerifyTopicMapping(RPCStatusTopic, &pb.Status{}); err != nil { - t.Errorf("Failed to verify status rpc topic: %v", err) - } - if err := VerifyTopicMapping(RPCStatusTopic, new([]byte)); err == nil { - t.Errorf("Incorrect message type verified for status rpc topic") - } + assert.NoError(t, VerifyTopicMapping(RPCStatusTopic, &pb.Status{}), "Failed to verify status rpc topic") + assert.NotNil(t, VerifyTopicMapping(RPCStatusTopic, new([]byte)), "Incorrect message type verified for status rpc topic") - if err := VerifyTopicMapping(RPCMetaDataTopic, new(interface{})); err != nil { - t.Errorf("Failed to verify metadata rpc topic: %v", err) - } - if err := VerifyTopicMapping(RPCStatusTopic, new([]byte)); err == nil { - t.Error("Incorrect message type verified for metadata rpc topic") - } + assert.NoError(t, VerifyTopicMapping(RPCMetaDataTopic, new(interface{})), "Failed to verify metadata rpc topic") + assert.NotNil(t, VerifyTopicMapping(RPCStatusTopic, new([]byte)), "Incorrect message type verified for metadata rpc topic") // TODO(#6408) Remove once issue is resolved - if err := VerifyTopicMapping(RPCBlocksByRootTopic, [][32]byte{}); err != nil { - t.Errorf("Failed to verify blocks by root rpc topic: %v", err) - } - if err := VerifyTopicMapping(RPCBlocksByRootTopic, new(pb.BeaconBlocksByRootRequest)); err != nil { - t.Errorf("Failed to verify blocks by root rpc topic: %v", err) - } + assert.NoError(t, VerifyTopicMapping(RPCBlocksByRootTopic, [][32]byte{}), "Failed to verify blocks by root rpc topic") + assert.NoError(t, VerifyTopicMapping(RPCBlocksByRootTopic, new(pb.BeaconBlocksByRootRequest)), "Failed to verify blocks by root rpc topic") } diff --git a/beacon-chain/p2p/sender_test.go b/beacon-chain/p2p/sender_test.go index 7496f8ea11..52394bc2ea 100644 --- a/beacon-chain/p2p/sender_test.go +++ b/beacon-chain/p2p/sender_test.go @@ -11,6 +11,8 @@ import ( testp2p "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" testpb "github.com/prysmaticlabs/prysm/proto/testing" "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestService_Send(t *testing.T) { @@ -38,29 +40,20 @@ func TestService_Send(t *testing.T) { }() p2.SetStreamHandler(topic+"/ssz_snappy", func(stream network.Stream) { rcvd := &testpb.TestSimpleMessage{} - if err := svc.Encoding().DecodeWithMaxLength(stream, rcvd); err != nil { - t.Fatal(err) - } - if _, err := svc.Encoding().EncodeWithMaxLength(stream, rcvd); err != nil { - t.Fatal(err) - } - if err := stream.Close(); err != nil { - t.Error(err) - } + require.NoError(t, svc.Encoding().DecodeWithMaxLength(stream, rcvd)) + _, err := svc.Encoding().EncodeWithMaxLength(stream, rcvd) + require.NoError(t, err) + assert.NoError(t, stream.Close()) wg.Done() }) stream, err := svc.Send(context.Background(), msg, "/testing/1", p2.BHost.ID()) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) testutil.WaitTimeout(&wg, 1*time.Second) rcvd := &testpb.TestSimpleMessage{} - if err := svc.Encoding().DecodeWithMaxLength(stream, rcvd); err != nil { - t.Fatal(err) - } + require.NoError(t, svc.Encoding().DecodeWithMaxLength(stream, rcvd)) if !proto.Equal(rcvd, msg) { t.Errorf("Expected identical message to be received. got %v want %v", rcvd, msg) } diff --git a/beacon-chain/p2p/service_test.go b/beacon-chain/p2p/service_test.go index bd9ab26a88..93b4238732 100644 --- a/beacon-chain/p2p/service_test.go +++ b/beacon-chain/p2p/service_test.go @@ -5,7 +5,6 @@ import ( "crypto/ecdsa" "fmt" "net" - "strings" "testing" "time" @@ -19,6 +18,8 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/core/feed" statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state" "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" logTest "github.com/sirupsen/logrus/hooks/test" ) @@ -76,28 +77,17 @@ func createHost(t *testing.T, port int) (host.Host, *ecdsa.PrivateKey, net.IP) { func TestService_Stop_SetsStartedToFalse(t *testing.T) { s, err := NewService(&Config{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.started = true s.dv5Listener = &mockListener{} - if err := s.Stop(); err != nil { - t.Error(err) - } - - if s.started != false { - t.Error("Expected Service.started to be false, got true") - } + assert.NoError(t, s.Stop()) + assert.Equal(t, false, s.started) } func TestService_Stop_DontPanicIfDv5ListenerIsNotInited(t *testing.T) { s, err := NewService(&Config{}) - if err != nil { - t.Fatal(err) - } - if err := s.Stop(); err != nil { - t.Error(err) - } + require.NoError(t, err) + assert.NoError(t, s.Stop()) } func TestService_Start_OnlyStartsOnce(t *testing.T) { @@ -108,9 +98,7 @@ func TestService_Start_OnlyStartsOnce(t *testing.T) { UDPPort: 2000, } s, err := NewService(cfg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.stateNotifier = &mock.MockStateNotifier{} s.dv5Listener = &mockListener{} exitRoutine := make(chan bool) @@ -129,23 +117,17 @@ func TestService_Start_OnlyStartsOnce(t *testing.T) { }) } time.Sleep(time.Second * 2) - if s.started != true { - t.Error("Expected service to be started") - } + assert.Equal(t, true, s.started, "Expected service to be started") s.Start() testutil.AssertLogsContain(t, hook, "Attempted to start p2p service when it was already started") - if err := s.Stop(); err != nil { - t.Fatal(err) - } + require.NoError(t, s.Stop()) exitRoutine <- true } func TestService_Status_NotRunning(t *testing.T) { s := &Service{started: false} s.dv5Listener = &mockListener{} - if s.Status().Error() != "not running" { - t.Errorf("Status returned wrong error, got %v", s.Status()) - } + assert.ErrorContains(t, "not running", s.Status(), "Status returned wrong error") } func TestListenForNewNodes(t *testing.T) { @@ -163,9 +145,7 @@ func TestListenForNewNodes(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } bootListener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer bootListener.Close() // Use shorter period for testing. @@ -195,9 +175,7 @@ func TestListenForNewNodes(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } listener, err := s.startDiscoveryV5(ipAddr, pkey) - if err != nil { - t.Errorf("Could not start discovery for node: %v", err) - } + assert.NoError(t, err, "Could not start discovery for node") listeners = append(listeners, listener) hosts = append(hosts, h) } @@ -221,9 +199,7 @@ func TestListenForNewNodes(t *testing.T) { cfg.TCPPort = 14001 s, err = NewService(cfg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) s.stateNotifier = &mock.MockStateNotifier{} exitRoutine := make(chan bool) go func() { @@ -242,12 +218,8 @@ func TestListenForNewNodes(t *testing.T) { } time.Sleep(4 * time.Second) peers := s.host.Network().Peers() - if len(peers) != 5 { - t.Errorf("Not all peers added to peerstore, wanted %d but got %d", 5, len(peers)) - } - if err := s.Stop(); err != nil { - t.Fatal(err) - } + assert.Equal(t, 5, len(peers), "Not all peers added to peerstore") + require.NoError(t, s.Stop()) exitRoutine <- true } @@ -271,63 +243,34 @@ func TestPeer_Disconnect(t *testing.T) { }() h2Addr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d/p2p/%s", ipaddr, 5001, h2.ID())) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) addrInfo, err := peer.AddrInfoFromP2pAddr(h2Addr) - if err != nil { - t.Fatal(err) - } - if err := s.host.Connect(context.Background(), *addrInfo); err != nil { - t.Fatal(err) - } - if len(s.host.Network().Peers()) != 1 { - t.Fatalf("Number of peers is %d when it was supposed to be %d", len(s.host.Network().Peers()), 1) - } - if len(s.host.Network().Conns()) != 1 { - t.Fatalf("Number of connections is %d when it was supposed to be %d", len(s.host.Network().Conns()), 1) - } - if err := s.Disconnect(h2.ID()); err != nil { - t.Fatal(err) - } - if len(s.host.Network().Conns()) != 0 { - t.Fatalf("Number of connections is %d when it was supposed to be %d", len(s.host.Network().Conns()), 0) - } + require.NoError(t, err) + require.NoError(t, s.host.Connect(context.Background(), *addrInfo)) + assert.Equal(t, 1, len(s.host.Network().Peers()), "Invalid number of peers") + assert.Equal(t, 1, len(s.host.Network().Conns()), "Invalid number of connections") + require.NoError(t, s.Disconnect(h2.ID())) + assert.Equal(t, 0, len(s.host.Network().Conns()), "Invalid number of connections") } func TestService_JoinLeaveTopic(t *testing.T) { s, err := NewService(&Config{}) - if err != nil { - t.Fatal(err) - } - - if len(s.joinedTopics) != 0 { - t.Errorf("want: %v, got: %v", 0, len(s.joinedTopics)) - } + require.NoError(t, err) + assert.Equal(t, 0, len(s.joinedTopics)) topic := fmt.Sprintf(AttestationSubnetTopicFormat, 42, 42) topicHandle, err := s.JoinTopic(topic) - if err != nil { - t.Error(err) - } - if len(s.joinedTopics) != 1 { - t.Errorf("want: %v, got: %v", 1, len(s.joinedTopics)) - } + assert.NoError(t, err) + assert.Equal(t, 1, len(s.joinedTopics)) sub, err := topicHandle.Subscribe() - if err != nil { - t.Error(err) - } + assert.NoError(t, err) // Try leaving topic that has subscriptions. want := "cannot close topic: outstanding event handlers or subscriptions" - if err := s.LeaveTopic(topic); err == nil || !strings.Contains(err.Error(), want) { - t.Errorf("Expected error not thrown, want: %v, got: %v", want, err) - } + assert.ErrorContains(t, want, s.LeaveTopic(topic)) // After subscription is cancelled, leaving topic should not result in error. sub.Cancel() - if err := s.LeaveTopic(topic); err != nil { - t.Error(err) - } + assert.NoError(t, s.LeaveTopic(topic)) } diff --git a/beacon-chain/p2p/subnets_test.go b/beacon-chain/p2p/subnets_test.go index bc3b02eba3..84322c9d4c 100644 --- a/beacon-chain/p2p/subnets_test.go +++ b/beacon-chain/p2p/subnets_test.go @@ -12,6 +12,8 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/core/feed" statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state" pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" + "github.com/prysmaticlabs/prysm/shared/testutil/assert" + "github.com/prysmaticlabs/prysm/shared/testutil/require" ) func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) { @@ -25,9 +27,7 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } bootListener, err := s.createListener(ipAddr, pkey) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer bootListener.Close() bootNode := bootListener.Self() @@ -54,9 +54,7 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) { genesisValidatorsRoot: genesisValidatorsRoot, } listener, err := s.startDiscoveryV5(ipAddr, pkey) - if err != nil { - t.Errorf("Could not start discovery for node: %v", err) - } + assert.NoError(t, err, "Could not start discovery for node") bitV := bitfield.NewBitvector64() bitV.SetBitAt(uint64(i), true) @@ -81,9 +79,7 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) { } cfg.StateNotifier = &mock.MockStateNotifier{} s, err = NewService(cfg) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) exitRoutine := make(chan bool) go func() { s.Start() @@ -105,17 +101,11 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) { // look up 3 different subnets exists, err := s.FindPeersWithSubnet(1) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) exists2, err := s.FindPeersWithSubnet(2) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) exists3, err := s.FindPeersWithSubnet(3) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) if !exists || !exists2 || !exists3 { t.Fatal("Peer with subnet doesn't exist") } @@ -130,15 +120,9 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) { time.Sleep(2 * time.Second) exists, err = s.FindPeersWithSubnet(2) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) - if !exists { - t.Fatal("Peer with subnet doesn't exist") - } - if err := s.Stop(); err != nil { - t.Fatal(err) - } + assert.Equal(t, true, exists, "Peer with subnet doesn't exist") + assert.NoError(t, s.Stop()) exitRoutine <- true }