package reservation import ( "context" "encoding/hex" "errors" "testing" "github.com/btcsuite/btcd/btcec/v2" "github.com/btcsuite/btcd/btcutil" "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/lndclient" "github.com/lightninglabs/loop/fsm" "github.com/lightninglabs/loop/swapserverrpc" "github.com/lightninglabs/loop/test" "github.com/lightningnetwork/lnd/chainntnfs" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "google.golang.org/grpc" ) var ( defaultPubkeyBytes, _ = hex.DecodeString("021c97a90a411ff2b10dc2a8e32de2f29d2fa49d41bfbb52bd416e460db0747d0d") defaultPubkey, _ = btcec.ParsePubKey(defaultPubkeyBytes) defaultValue = btcutil.Amount(100) defaultExpiry = uint32(100) ) func newValidInitReservationContext() *InitReservationContext { return &InitReservationContext{ reservationID: ID{0x01}, serverPubkey: defaultPubkey, value: defaultValue, expiry: defaultExpiry, heightHint: 0, } } func newValidClientReturn() *swapserverrpc.ServerOpenReservationResponse { return &swapserverrpc.ServerOpenReservationResponse{} } type mockReservationClient struct { mock.Mock } func (m *mockReservationClient) OpenReservation(ctx context.Context, in *swapserverrpc.ServerOpenReservationRequest, opts ...grpc.CallOption) (*swapserverrpc.ServerOpenReservationResponse, error) { args := m.Called(ctx, in, opts) return args.Get(0).(*swapserverrpc.ServerOpenReservationResponse), args.Error(1) } func (m *mockReservationClient) ReservationNotificationStream( ctx context.Context, in *swapserverrpc.ReservationNotificationRequest, opts ...grpc.CallOption, ) (swapserverrpc.ReservationService_ReservationNotificationStreamClient, error) { args := m.Called(ctx, in, opts) return args.Get(0).(swapserverrpc.ReservationService_ReservationNotificationStreamClient), args.Error(1) } func (m *mockReservationClient) FetchL402(ctx context.Context, in *swapserverrpc.FetchL402Request, opts ...grpc.CallOption) (*swapserverrpc.FetchL402Response, error) { args := m.Called(ctx, in, opts) return args.Get(0).(*swapserverrpc.FetchL402Response), args.Error(1) } type mockStore struct { mock.Mock Store } func (m *mockStore) CreateReservation(ctx context.Context, reservation *Reservation) error { args := m.Called(ctx, reservation) return args.Error(0) } // TestInitReservationAction tests the InitReservationAction of the reservation // state machine. func TestInitReservationAction(t *testing.T) { tests := []struct { name string eventCtx fsm.EventContext mockStoreErr error mockClientReturn *swapserverrpc.ServerOpenReservationResponse mockClientErr error expectedEvent fsm.EventType }{ { name: "success", eventCtx: newValidInitReservationContext(), mockClientReturn: newValidClientReturn(), expectedEvent: OnBroadcast, }, { name: "invalid context", eventCtx: struct{}{}, expectedEvent: fsm.OnError, }, { name: "reservation server error", eventCtx: newValidInitReservationContext(), mockClientErr: errors.New("reservation server error"), expectedEvent: fsm.OnError, }, { name: "store error", eventCtx: newValidInitReservationContext(), mockClientReturn: newValidClientReturn(), mockStoreErr: errors.New("store error"), expectedEvent: fsm.OnError, }, } for _, tc := range tests { tc := tc ctxb := context.Background() mockLnd := test.NewMockLnd() mockReservationClient := new(mockReservationClient) mockReservationClient.On( "OpenReservation", mock.Anything, mock.Anything, mock.Anything, ).Return(tc.mockClientReturn, tc.mockClientErr) mockStore := new(mockStore) mockStore.On( "CreateReservation", mock.Anything, mock.Anything, ).Return(tc.mockStoreErr) reservationFSM := &FSM{ ctx: ctxb, cfg: &Config{ Wallet: mockLnd.WalletKit, ChainNotifier: mockLnd.ChainNotifier, ReservationClient: mockReservationClient, Store: mockStore, }, StateMachine: &fsm.StateMachine{}, } event := reservationFSM.InitAction(tc.eventCtx) require.Equal(t, tc.expectedEvent, event) } } type MockChainNotifier struct { mock.Mock } func (m *MockChainNotifier) RegisterConfirmationsNtfn(ctx context.Context, txid *chainhash.Hash, pkScript []byte, numConfs, heightHint int32, options ...lndclient.NotifierOption) (chan *chainntnfs.TxConfirmation, chan error, error) { args := m.Called(ctx, txid, pkScript, numConfs, heightHint) return args.Get(0).(chan *chainntnfs.TxConfirmation), args.Get(1).(chan error), args.Error(2) } func (m *MockChainNotifier) RegisterBlockEpochNtfn(ctx context.Context) ( chan int32, chan error, error) { args := m.Called(ctx) return args.Get(0).(chan int32), args.Get(1).(chan error), args.Error(2) } func (m *MockChainNotifier) RegisterSpendNtfn(ctx context.Context, outpoint *wire.OutPoint, pkScript []byte, heightHint int32) ( chan *chainntnfs.SpendDetail, chan error, error) { args := m.Called(ctx, pkScript, heightHint) return args.Get(0).(chan *chainntnfs.SpendDetail), args.Get(1).(chan error), args.Error(2) } // TestSubscribeToConfirmationAction tests the SubscribeToConfirmationAction of // the reservation state machine. func TestSubscribeToConfirmationAction(t *testing.T) { tests := []struct { name string blockHeight int32 blockErr error sendTxConf bool confErr error expectedEvent fsm.EventType }{ { name: "success", blockHeight: 0, sendTxConf: true, expectedEvent: OnConfirmed, }, { name: "expired", blockHeight: 100, expectedEvent: OnTimedOut, }, { name: "block error", blockHeight: 0, blockErr: errors.New("block error"), expectedEvent: fsm.OnError, }, { name: "tx confirmation error", blockHeight: 0, confErr: errors.New("tx confirmation error"), expectedEvent: fsm.OnError, }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { chainNotifier := new(MockChainNotifier) // Create the FSM. r := NewFSMFromReservation( context.Background(), &Config{ ChainNotifier: chainNotifier, }, &Reservation{ Expiry: defaultExpiry, ServerPubkey: defaultPubkey, ClientPubkey: defaultPubkey, Value: defaultValue, }, ) pkScript, err := r.reservation.GetPkScript() require.NoError(t, err) confChan := make(chan *chainntnfs.TxConfirmation) confErrChan := make(chan error) blockChan := make(chan int32) blockErrChan := make(chan error) // Define the expected return values for the mocks. chainNotifier.On( "RegisterConfirmationsNtfn", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, ).Return(confChan, confErrChan, nil) chainNotifier.On("RegisterBlockEpochNtfn", mock.Anything).Return( blockChan, blockErrChan, nil, ) go func() { // Send the tx confirmation. if tc.sendTxConf { confChan <- &chainntnfs.TxConfirmation{ Tx: &wire.MsgTx{ TxIn: []*wire.TxIn{}, TxOut: []*wire.TxOut{ { Value: int64(defaultValue), PkScript: pkScript, }, }, }, } } }() go func() { // Send the block notification. if tc.blockHeight != 0 { blockChan <- tc.blockHeight } }() go func() { // Send the block notification error. if tc.blockErr != nil { blockErrChan <- tc.blockErr } }() go func() { // Send the tx confirmation error. if tc.confErr != nil { confErrChan <- tc.confErr } }() eventType := r.SubscribeToConfirmationAction(nil) // Assert that the return value is as expected require.Equal(t, tc.expectedEvent, eventType) // Assert that the expected functions were called on the mocks chainNotifier.AssertExpectations(t) }) } } // AsyncWaitForExpiredOrSweptAction tests the AsyncWaitForExpiredOrSweptAction // of the reservation state machine. func TestAsyncWaitForExpiredOrSweptAction(t *testing.T) { tests := []struct { name string blockErr error spendErr error expectedEvent fsm.EventType }{ { name: "noop", expectedEvent: fsm.NoOp, }, { name: "block error", blockErr: errors.New("block error"), expectedEvent: fsm.OnError, }, { name: "spend error", spendErr: errors.New("spend error"), expectedEvent: fsm.OnError, }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { // Create a mock ChainNotifier and Reservation chainNotifier := new(MockChainNotifier) // Define your FSM r := NewFSMFromReservation( context.Background(), &Config{ ChainNotifier: chainNotifier, }, &Reservation{ ServerPubkey: defaultPubkey, ClientPubkey: defaultPubkey, Expiry: defaultExpiry, }, ) // Define the expected return values for your mocks chainNotifier.On("RegisterBlockEpochNtfn", mock.Anything).Return( make(chan int32), make(chan error), tc.blockErr, ) chainNotifier.On( "RegisterSpendNtfn", mock.Anything, mock.Anything, mock.Anything, ).Return( make(chan *chainntnfs.SpendDetail), make(chan error), tc.spendErr, ) eventType := r.AsyncWaitForExpiredOrSweptAction(nil) // Assert that the return value is as expected require.Equal(t, tc.expectedEvent, eventType) }) } } // TesthandleSubcriptions tests the handleSubcriptions function of the // reservation state machine. func TestHandleSubcriptions(t *testing.T) { var ( blockErr = errors.New("block error") spendErr = errors.New("spend error") ) tests := []struct { name string blockHeight int32 blockErr error spendDetail *chainntnfs.SpendDetail spendErr error expectedEvent fsm.EventType expectedErr error }{ { name: "expired", blockHeight: 100, expectedEvent: OnTimedOut, }, { name: "block error", blockErr: blockErr, expectedEvent: fsm.OnError, expectedErr: blockErr, }, { name: "spent", spendDetail: &chainntnfs.SpendDetail{}, expectedEvent: OnSpent, }, { name: "spend error", spendErr: spendErr, expectedEvent: fsm.OnError, expectedErr: spendErr, }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { chainNotifier := new(MockChainNotifier) // Create the FSM. r := NewFSMFromReservation( context.Background(), &Config{ ChainNotifier: chainNotifier, }, &Reservation{ ServerPubkey: defaultPubkey, ClientPubkey: defaultPubkey, Expiry: defaultExpiry, }, ) blockChan := make(chan int32) blockErrChan := make(chan error) spendChan := make(chan *chainntnfs.SpendDetail) spendErrChan := make(chan error) go func() { if tc.blockHeight != 0 { blockChan <- tc.blockHeight } if tc.blockErr != nil { blockErrChan <- tc.blockErr } if tc.spendDetail != nil { spendChan <- tc.spendDetail } if tc.spendErr != nil { spendErrChan <- tc.spendErr } }() eventType, err := r.handleSubcriptions( context.Background(), blockChan, spendChan, blockErrChan, spendErrChan, ) require.Equal(t, tc.expectedErr, err) require.Equal(t, tc.expectedEvent, eventType) }) } }