happy path test

addresses review comment #457 (comment)

signature-aggregator/aggregator/aggregator_test.go

@@ -1,23 +1,35 @@
 package aggregator
 
 import (
+	"os"
 	"testing"
 
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/message"
+	"github.com/ava-labs/avalanchego/subnets"
+	"github.com/ava-labs/avalanchego/utils"
 	"github.com/ava-labs/avalanchego/utils/constants"
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
 	"github.com/ava-labs/avalanchego/utils/logging"
+	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp"
 	"github.com/ava-labs/awm-relayer/peers"
 	"github.com/ava-labs/awm-relayer/peers/mocks"
 	"github.com/ava-labs/awm-relayer/signature-aggregator/metrics"
+	evmMsg "github.com/ava-labs/subnet-evm/plugin/evm/message"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+var (
+	sigAggMetrics *metrics.SignatureAggregatorMetrics
+	messageCreator message.Creator
+	validatorSecretKey *bls.SecretKey
 )
 
-var sigAggMetrics *metrics.SignatureAggregatorMetrics
-var messageCreator message.Creator
 
 func instantiateAggregator(t *testing.T) (
 	*SignatureAggregator,
@@ -39,7 +51,16 @@ func instantiateAggregator(t *testing.T) (
 	}
 	aggregator, err := NewSignatureAggregator(
 		mockNetwork,
-		logging.NoLog{},
+		logging.NewLogger(
+			"aggregator_test",
+			logging.NewWrappedCore(
+				logging.Debug,
+				os.Stdout,
+				zapcore.NewConsoleEncoder(
+					zap.NewProductionEncoderConfig(),
+				),
+			),
+		),
 		1024,
 		sigAggMetrics,
 		messageCreator,
@@ -48,6 +69,50 @@ func instantiateAggregator(t *testing.T) (
 	return aggregator, mockNetwork
 }
 
+func minimumViableConnectedValidators() *peers.ConnectedCanonicalValidators {
+	if validatorSecretKey == nil {
+		var err error
+		validatorSecretKey, err = bls.NewSecretKey()
+		if err != nil {
+			panic(err)
+		}
+	}
+	pubKey := bls.PublicFromSecretKey(validatorSecretKey)
+
+	nodeID, err := ids.ToNodeID(utils.RandomBytes(20))
+	if err != nil {
+		panic(err)
+	}
+
+	return &peers.ConnectedCanonicalValidators{
+		ConnectedWeight:      1,
+		TotalValidatorWeight: 1,
+		ValidatorSet:         []*warp.Validator{
+			&warp.Validator{
+				PublicKey:      pubKey,
+				PublicKeyBytes: bls.PublicKeyToUncompressedBytes(pubKey),
+				Weight:         1,
+				NodeIDs:        []ids.NodeID{nodeID},
+			},
+		},
+	}
+}
+
+func minimumViableAppRequest(requestID uint32, nodeID ids.NodeID) ids.RequestID {
+	chainID, err := ids.ToID(utils.RandomBytes(32))
+	if err != nil {
+		panic(err)
+	}
+
+	return ids.RequestID{
+		NodeID:             nodeID,
+		SourceChainID:      chainID,
+		DestinationChainID: chainID,
+		RequestID:          requestID,
+		Op:                 byte(message.AppResponseOp),
+	}
+}
+
 func TestCreateSignedMessageFailsWithNoValidators(t *testing.T) {
 	aggregator, mockNetwork := instantiateAggregator(t)
 	msg, err := warp.NewUnsignedMessage(0, ids.Empty, []byte{})
@@ -85,3 +150,116 @@ func TestCreateSignedMessageFailsWithoutSufficientConnectedStake(t *testing.T) {
 		"failed to connect to a threshold of stake",
 	)
 }
+
+func TestCreateSignedMessageRetriesAndFailsWithoutP2PResponses(t *testing.T) {
+	aggregator, mockNetwork := instantiateAggregator(t)
+
+	var (
+		connectedValidators = minimumViableConnectedValidators()
+		requestID = aggregator.currentRequestID.Load() + 1
+		appRequest = minimumViableAppRequest(
+			requestID,
+			connectedValidators.ValidatorSet[0].NodeIDs[0],
+		)
+	)
+
+	msg, err := warp.NewUnsignedMessage(0, appRequest.SourceChainID, []byte{})
+	require.Equal(t, err, nil)
+
+	subnetID, err := ids.ToID(utils.RandomBytes(32))
+	require.Equal(t, err, nil)
+	mockNetwork.EXPECT().GetSubnetID(appRequest.SourceChainID).Return(subnetID, nil)
+
+	mockNetwork.EXPECT().ConnectToCanonicalValidators(subnetID).Return(
+		connectedValidators,
+		nil,
+	)
+
+	mockNetwork.EXPECT().RegisterAppRequest(
+		appRequest,
+	).MaxTimes(maxRelayerQueryAttempts)
+
+	mockNetwork.EXPECT().RegisterRequestID(requestID, 1).Return(
+		make(chan message.InboundMessage, 1),
+	).MaxTimes(maxRelayerQueryAttempts)
+
+	mockNetwork.EXPECT().Send(
+		gomock.Any(),
+		set.Of(appRequest.NodeID),
+		subnetID,
+		subnets.NoOpAllower,
+	).MaxTimes(maxRelayerQueryAttempts)
+
+	_, err = aggregator.CreateSignedMessage(msg, subnetID, 80)
+	require.ErrorContains(
+		t,
+		err,
+		"failed to collect a threshold of signatures",
+	)
+}
+
+func TestCreateSignedMessageSucceeds(t *testing.T) {
+	aggregator, mockNetwork := instantiateAggregator(t)
+
+	var (
+		connectedValidators = minimumViableConnectedValidators()
+		requestID = aggregator.currentRequestID.Load() + 1
+		appRequest = minimumViableAppRequest(
+			requestID,
+			connectedValidators.ValidatorSet[0].NodeIDs[0],
+		)
+	)
+
+	msg, err := warp.NewUnsignedMessage(
+		0,
+		appRequest.SourceChainID,
+		utils.RandomBytes(1234),
+	)
+	require.Equal(t, err, nil)
+
+	subnetID, err := ids.ToID(utils.RandomBytes(32))
+	require.Equal(t, err, nil)
+	mockNetwork.EXPECT().GetSubnetID(appRequest.SourceChainID).Return(subnetID, nil)
+
+	mockNetwork.EXPECT().ConnectToCanonicalValidators(subnetID).Return(
+		connectedValidators,
+		nil,
+	)
+
+	mockNetwork.EXPECT().RegisterAppRequest(appRequest).Times(1)
+
+	responseChan := make(chan message.InboundMessage, 1)
+	responseBytes, err := evmMsg.Codec.Marshal(
+		0,
+		&evmMsg.SignatureResponse {
+			Signature: [bls.SignatureLen]byte(
+				bls.SignatureToBytes(
+					bls.Sign(
+						validatorSecretKey,
+						msg.Bytes(),
+					),
+				),
+			),
+		},
+	)
+	require.Equal(t, err, nil)
+	responseChan <- message.InboundAppResponse(
+		appRequest.SourceChainID,
+		requestID,
+		responseBytes,
+		appRequest.NodeID,
+	)
+	mockNetwork.EXPECT().RegisterRequestID(requestID, 1).Return(
+		responseChan,
+	).Times(1)
+
+	mockNetwork.EXPECT().Send(
+		gomock.Any(),
+		set.Of(appRequest.NodeID),
+		subnetID,
+		subnets.NoOpAllower,
+	).Times(1).Return(set.Of(appRequest.NodeID))
+
+	_, err = aggregator.CreateSignedMessage(msg, subnetID, 80)
+	require.Equal(t, err, nil)
+}