You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
4.7 KiB
167 lines
4.7 KiB
package p2ptest
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gogo/protobuf/proto"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/tendermint/internal/p2p"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// RequireEmpty requires that the given channel is empty.
|
|
func RequireEmpty(ctx context.Context, t *testing.T, channels ...*p2p.Channel) {
|
|
t.Helper()
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
|
|
defer cancel()
|
|
|
|
iter := p2p.MergedChannelIterator(ctx, channels...)
|
|
count := 0
|
|
for iter.Next(ctx) {
|
|
count++
|
|
require.Nil(t, iter.Envelope())
|
|
}
|
|
require.Zero(t, count)
|
|
require.Error(t, ctx.Err())
|
|
}
|
|
|
|
// RequireReceive requires that the given envelope is received on the channel.
|
|
func RequireReceive(ctx context.Context, t *testing.T, channel *p2p.Channel, expect p2p.Envelope) {
|
|
t.Helper()
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
|
defer cancel()
|
|
|
|
iter := channel.Receive(ctx)
|
|
count := 0
|
|
for iter.Next(ctx) {
|
|
count++
|
|
envelope := iter.Envelope()
|
|
require.Equal(t, expect.From, envelope.From)
|
|
require.Equal(t, expect.Message, envelope.Message)
|
|
}
|
|
|
|
if !assert.True(t, count >= 1) {
|
|
require.NoError(t, ctx.Err(), "timed out waiting for message %v", expect)
|
|
}
|
|
}
|
|
|
|
// RequireReceiveUnordered requires that the given envelopes are all received on
|
|
// the channel, ignoring order.
|
|
func RequireReceiveUnordered(ctx context.Context, t *testing.T, channel *p2p.Channel, expect []*p2p.Envelope) {
|
|
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
|
defer cancel()
|
|
|
|
actual := []*p2p.Envelope{}
|
|
|
|
iter := channel.Receive(ctx)
|
|
for iter.Next(ctx) {
|
|
actual = append(actual, iter.Envelope())
|
|
if len(actual) == len(expect) {
|
|
require.ElementsMatch(t, expect, actual, "len=%d", len(actual))
|
|
return
|
|
}
|
|
}
|
|
|
|
if errors.Is(ctx.Err(), context.DeadlineExceeded) {
|
|
require.ElementsMatch(t, expect, actual)
|
|
}
|
|
}
|
|
|
|
// RequireSend requires that the given envelope is sent on the channel.
|
|
func RequireSend(ctx context.Context, t *testing.T, channel *p2p.Channel, envelope p2p.Envelope) {
|
|
tctx, cancel := context.WithTimeout(ctx, time.Second)
|
|
defer cancel()
|
|
|
|
err := channel.Send(tctx, envelope)
|
|
switch {
|
|
case errors.Is(err, context.DeadlineExceeded):
|
|
require.Fail(t, "timed out sending message to %q", envelope.To)
|
|
default:
|
|
require.NoError(t, err, "unexpected error")
|
|
}
|
|
}
|
|
|
|
// RequireSendReceive requires that a given Protobuf message is sent to the
|
|
// given peer, and then that the given response is received back.
|
|
func RequireSendReceive(
|
|
ctx context.Context,
|
|
t *testing.T,
|
|
channel *p2p.Channel,
|
|
peerID types.NodeID,
|
|
send proto.Message,
|
|
receive proto.Message,
|
|
) {
|
|
RequireSend(ctx, t, channel, p2p.Envelope{To: peerID, Message: send})
|
|
RequireReceive(ctx, t, channel, p2p.Envelope{From: peerID, Message: send})
|
|
}
|
|
|
|
// RequireNoUpdates requires that a PeerUpdates subscription is empty.
|
|
func RequireNoUpdates(ctx context.Context, t *testing.T, peerUpdates *p2p.PeerUpdates) {
|
|
t.Helper()
|
|
select {
|
|
case update := <-peerUpdates.Updates():
|
|
if ctx.Err() == nil {
|
|
require.Fail(t, "unexpected peer updates", "got %v", update)
|
|
}
|
|
case <-ctx.Done():
|
|
default:
|
|
}
|
|
}
|
|
|
|
// RequireError requires that the given peer error is submitted for a peer.
|
|
func RequireError(ctx context.Context, t *testing.T, channel *p2p.Channel, peerError p2p.PeerError) {
|
|
tctx, tcancel := context.WithTimeout(ctx, time.Second)
|
|
defer tcancel()
|
|
|
|
err := channel.SendError(tctx, peerError)
|
|
switch {
|
|
case errors.Is(err, context.DeadlineExceeded):
|
|
require.Fail(t, "timed out reporting error", "%v on %v", peerError, channel.ID)
|
|
default:
|
|
require.NoError(t, err, "unexpected error")
|
|
}
|
|
}
|
|
|
|
// RequireUpdate requires that a PeerUpdates subscription yields the given update.
|
|
func RequireUpdate(t *testing.T, peerUpdates *p2p.PeerUpdates, expect p2p.PeerUpdate) {
|
|
timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
|
|
defer timer.Stop()
|
|
|
|
select {
|
|
case update := <-peerUpdates.Updates():
|
|
require.Equal(t, expect, update, "peer update did not match")
|
|
|
|
case <-timer.C:
|
|
require.Fail(t, "timed out waiting for peer update", "expected %v", expect)
|
|
}
|
|
}
|
|
|
|
// RequireUpdates requires that a PeerUpdates subscription yields the given updates
|
|
// in the given order.
|
|
func RequireUpdates(t *testing.T, peerUpdates *p2p.PeerUpdates, expect []p2p.PeerUpdate) {
|
|
timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
|
|
defer timer.Stop()
|
|
|
|
actual := []p2p.PeerUpdate{}
|
|
for {
|
|
select {
|
|
case update := <-peerUpdates.Updates():
|
|
actual = append(actual, update)
|
|
if len(actual) == len(expect) {
|
|
require.Equal(t, expect, actual)
|
|
return
|
|
}
|
|
|
|
case <-timer.C:
|
|
require.Equal(t, expect, actual, "did not receive expected peer updates")
|
|
return
|
|
}
|
|
}
|
|
}
|