github.com/number571/tendermint@v0.34.11-gost/internal/p2p/p2ptest/require.go (about)

     1  package p2ptest
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/gogo/protobuf/proto"
     8  	"github.com/stretchr/testify/require"
     9  
    10  	"github.com/number571/tendermint/internal/p2p"
    11  	"github.com/number571/tendermint/types"
    12  )
    13  
    14  // RequireEmpty requires that the given channel is empty.
    15  func RequireEmpty(t *testing.T, channels ...*p2p.Channel) {
    16  	for _, channel := range channels {
    17  		select {
    18  		case e := <-channel.In:
    19  			require.Fail(t, "unexpected message", "channel %v should be empty, got %v", channel.ID, e)
    20  		case <-time.After(10 * time.Millisecond):
    21  		}
    22  	}
    23  }
    24  
    25  // RequireReceive requires that the given envelope is received on the channel.
    26  func RequireReceive(t *testing.T, channel *p2p.Channel, expect p2p.Envelope) {
    27  	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
    28  	defer timer.Stop()
    29  
    30  	select {
    31  	case e, ok := <-channel.In:
    32  		require.True(t, ok, "channel %v is closed", channel.ID)
    33  		require.Equal(t, expect, e)
    34  
    35  	case <-channel.Done():
    36  		require.Fail(t, "channel %v is closed", channel.ID)
    37  
    38  	case <-timer.C:
    39  		require.Fail(t, "timed out waiting for message", "%v on channel %v", expect, channel.ID)
    40  	}
    41  }
    42  
    43  // RequireReceiveUnordered requires that the given envelopes are all received on
    44  // the channel, ignoring order.
    45  func RequireReceiveUnordered(t *testing.T, channel *p2p.Channel, expect []p2p.Envelope) {
    46  	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
    47  	defer timer.Stop()
    48  
    49  	actual := []p2p.Envelope{}
    50  	for {
    51  		select {
    52  		case e, ok := <-channel.In:
    53  			require.True(t, ok, "channel %v is closed", channel.ID)
    54  			actual = append(actual, e)
    55  			if len(actual) == len(expect) {
    56  				require.ElementsMatch(t, expect, actual)
    57  				return
    58  			}
    59  
    60  		case <-channel.Done():
    61  			require.Fail(t, "channel %v is closed", channel.ID)
    62  
    63  		case <-timer.C:
    64  			require.ElementsMatch(t, expect, actual)
    65  			return
    66  		}
    67  	}
    68  
    69  }
    70  
    71  // RequireSend requires that the given envelope is sent on the channel.
    72  func RequireSend(t *testing.T, channel *p2p.Channel, envelope p2p.Envelope) {
    73  	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
    74  	defer timer.Stop()
    75  	select {
    76  	case channel.Out <- envelope:
    77  	case <-timer.C:
    78  		require.Fail(t, "timed out sending message", "%v on channel %v", envelope, channel.ID)
    79  	}
    80  }
    81  
    82  // RequireSendReceive requires that a given Protobuf message is sent to the
    83  // given peer, and then that the given response is received back.
    84  func RequireSendReceive(
    85  	t *testing.T,
    86  	channel *p2p.Channel,
    87  	peerID types.NodeID,
    88  	send proto.Message,
    89  	receive proto.Message,
    90  ) {
    91  	RequireSend(t, channel, p2p.Envelope{To: peerID, Message: send})
    92  	RequireReceive(t, channel, p2p.Envelope{From: peerID, Message: send})
    93  }
    94  
    95  // RequireNoUpdates requires that a PeerUpdates subscription is empty.
    96  func RequireNoUpdates(t *testing.T, peerUpdates *p2p.PeerUpdates) {
    97  	t.Helper()
    98  	select {
    99  	case update := <-peerUpdates.Updates():
   100  		require.Fail(t, "unexpected peer updates", "got %v", update)
   101  	default:
   102  	}
   103  }
   104  
   105  // RequireError requires that the given peer error is submitted for a peer.
   106  func RequireError(t *testing.T, channel *p2p.Channel, peerError p2p.PeerError) {
   107  	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
   108  	defer timer.Stop()
   109  	select {
   110  	case channel.Error <- peerError:
   111  	case <-timer.C:
   112  		require.Fail(t, "timed out reporting error", "%v on %v", peerError, channel.ID)
   113  	}
   114  }
   115  
   116  // RequireUpdate requires that a PeerUpdates subscription yields the given update.
   117  func RequireUpdate(t *testing.T, peerUpdates *p2p.PeerUpdates, expect p2p.PeerUpdate) {
   118  	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
   119  	defer timer.Stop()
   120  
   121  	select {
   122  	case update := <-peerUpdates.Updates():
   123  		require.Equal(t, expect, update, "peer update did not match")
   124  
   125  	case <-peerUpdates.Done():
   126  		require.Fail(t, "peer updates subscription is closed")
   127  
   128  	case <-timer.C:
   129  		require.Fail(t, "timed out waiting for peer update", "expected %v", expect)
   130  	}
   131  }
   132  
   133  // RequireUpdates requires that a PeerUpdates subscription yields the given updates
   134  // in the given order.
   135  func RequireUpdates(t *testing.T, peerUpdates *p2p.PeerUpdates, expect []p2p.PeerUpdate) {
   136  	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
   137  	defer timer.Stop()
   138  
   139  	actual := []p2p.PeerUpdate{}
   140  	for {
   141  		select {
   142  		case update := <-peerUpdates.Updates():
   143  			actual = append(actual, update)
   144  			if len(actual) == len(expect) {
   145  				require.Equal(t, expect, actual)
   146  				return
   147  			}
   148  
   149  		case <-peerUpdates.Done():
   150  			require.Fail(t, "peer updates subscription is closed")
   151  
   152  		case <-timer.C:
   153  			require.Equal(t, expect, actual, "did not receive expected peer updates")
   154  			return
   155  		}
   156  	}
   157  }