aggkit/aggsender/aggsender_validator_test.go at 9956a2cdfb9155d355c2b8812c7907a0a51260eb · agglayer/aggkit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package aggsender

import (
	"context"
	"errors"
	"testing"

	agglayertypes "github.com/agglayer/aggkit/agglayer/types"
	"github.com/agglayer/aggkit/aggsender/mocks"
	aggsendertypes "github.com/agglayer/aggkit/aggsender/types"
	validatorcfg "github.com/agglayer/aggkit/aggsender/validator"
	aggkitgrpc "github.com/agglayer/aggkit/grpc"
	"github.com/agglayer/aggkit/log"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"
)

func newTestAggsenderValidator(t *testing.T) *AggsenderValidator {
	t.Helper()
	grpcServer, err := aggkitgrpc.NewServer(aggkitgrpc.ServerConfig{
		Host: "127.0.0.1",
		Port: 0,
	})
	require.NoError(t, err)
	return &AggsenderValidator{
		log:              log.WithFields("module", "aggsender-validator-test"),
		validatorService: grpcServer,
		cfg:              validatorcfg.Config{},
	}
}

// TestAggsenderValidatorStart_SetClaimSyncerFails checks that Start panics (via Fatalf)
// when SetClaimSyncerNextRequiredBlock returns an error.
func TestAggsenderValidatorStart_SetClaimSyncerFails(t *testing.T) {
	sut := newTestAggsenderValidator(t)
	mockSetter := mocks.NewInitialBlockClaimSyncerSetter(t)
	mockSetter.EXPECT().
		SetClaimSyncerNextRequiredBlock(mock.Anything, mock.Anything, mock.Anything).
		Return(errors.New("setter error")).Once()
	sut.initialBlockClaimSyncerSetter = mockSetter

	require.Panics(t, func() {
		sut.Start(t.Context())
	})
}

// TestAggsenderValidatorStart_Success checks that Start succeeds when
// SetClaimSyncerNextRequiredBlock returns nil and the gRPC server starts normally.
func TestAggsenderValidatorStart_Success(t *testing.T) {
	sut := newTestAggsenderValidator(t)
	mockSetter := mocks.NewInitialBlockClaimSyncerSetter(t)
	mockSetter.EXPECT().
		SetClaimSyncerNextRequiredBlock(mock.Anything, mock.Anything, mock.Anything).
		Return(nil).Once()
	sut.initialBlockClaimSyncerSetter = mockSetter

	// Cancel the context immediately so the gRPC server stops right after starting.
	ctx, cancel := context.WithCancel(t.Context())
	cancel()

	require.NotPanics(t, func() {
		sut.Start(ctx)
	})
}

// TestAggsenderValidatorValidateCertificate_Success checks that ValidateCertificate
// delegates to the inner validator and returns nil on success.
func TestAggsenderValidatorValidateCertificate_Success(t *testing.T) {
	sut := newTestAggsenderValidator(t)
	mockValidator := mocks.NewCertificateValidator(t)
	params := aggsendertypes.VerifyIncomingRequest{
		Certificate: &agglayertypes.Certificate{},
	}
	mockValidator.EXPECT().ValidateCertificate(mock.Anything, params).Return(nil).Once()
	sut.validator = mockValidator

	err := sut.ValidateCertificate(t.Context(), params)
	require.NoError(t, err)
}

// TestAggsenderValidatorValidateCertificate_Error checks that ValidateCertificate
// propagates the error returned by the inner validator.
func TestAggsenderValidatorValidateCertificate_Error(t *testing.T) {
	sut := newTestAggsenderValidator(t)
	mockValidator := mocks.NewCertificateValidator(t)
	expectedErr := errors.New("validation failed")
	params := aggsendertypes.VerifyIncomingRequest{
		Certificate: &agglayertypes.Certificate{},
	}
	mockValidator.EXPECT().ValidateCertificate(mock.Anything, params).Return(expectedErr).Once()
	sut.validator = mockValidator

	err := sut.ValidateCertificate(t.Context(), params)
	require.ErrorIs(t, err, expectedErr)
}