diff --git a/account/watcher/mock_interface_test.go b/account/watcher/mock_interface_test.go new file mode 100644 index 0000000..3e53765 --- /dev/null +++ b/account/watcher/mock_interface_test.go @@ -0,0 +1,240 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: account/watcher/interfaces.go + +// Package watcher is a generated GoMock package. +package watcher + +import ( + reflect "reflect" + + btcec "github.com/btcsuite/btcd/btcec" + chainhash "github.com/btcsuite/btcd/chaincfg/chainhash" + wire "github.com/btcsuite/btcd/wire" + gomock "github.com/golang/mock/gomock" + chainntnfs "github.com/lightningnetwork/lnd/chainntnfs" +) + +// MockController is a mock of Controller interface. +type MockController struct { + ctrl *gomock.Controller + recorder *MockControllerMockRecorder +} + +// MockControllerMockRecorder is the mock recorder for MockController. +type MockControllerMockRecorder struct { + mock *MockController +} + +// NewMockController creates a new mock instance. +func NewMockController(ctrl *gomock.Controller) *MockController { + mock := &MockController{ctrl: ctrl} + mock.recorder = &MockControllerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockController) EXPECT() *MockControllerMockRecorder { + return m.recorder +} + +// CancelAccountConf mocks base method. +func (m *MockController) CancelAccountConf(traderKey *btcec.PublicKey) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "CancelAccountConf", traderKey) +} + +// CancelAccountConf indicates an expected call of CancelAccountConf. +func (mr *MockControllerMockRecorder) CancelAccountConf(traderKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelAccountConf", reflect.TypeOf((*MockController)(nil).CancelAccountConf), traderKey) +} + +// CancelAccountSpend mocks base method. +func (m *MockController) CancelAccountSpend(traderKey *btcec.PublicKey) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "CancelAccountSpend", traderKey) +} + +// CancelAccountSpend indicates an expected call of CancelAccountSpend. +func (mr *MockControllerMockRecorder) CancelAccountSpend(traderKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelAccountSpend", reflect.TypeOf((*MockController)(nil).CancelAccountSpend), traderKey) +} + +// Start mocks base method. +func (m *MockController) Start() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Start") + ret0, _ := ret[0].(error) + return ret0 +} + +// Start indicates an expected call of Start. +func (mr *MockControllerMockRecorder) Start() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockController)(nil).Start)) +} + +// Stop mocks base method. +func (m *MockController) Stop() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Stop") +} + +// Stop indicates an expected call of Stop. +func (mr *MockControllerMockRecorder) Stop() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockController)(nil).Stop)) +} + +// WatchAccountConf mocks base method. +func (m *MockController) WatchAccountConf(traderKey *btcec.PublicKey, txHash chainhash.Hash, script []byte, numConfs, heightHint uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WatchAccountConf", traderKey, txHash, script, numConfs, heightHint) + ret0, _ := ret[0].(error) + return ret0 +} + +// WatchAccountConf indicates an expected call of WatchAccountConf. +func (mr *MockControllerMockRecorder) WatchAccountConf(traderKey, txHash, script, numConfs, heightHint interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchAccountConf", reflect.TypeOf((*MockController)(nil).WatchAccountConf), traderKey, txHash, script, numConfs, heightHint) +} + +// WatchAccountExpiration mocks base method. +func (m *MockController) WatchAccountExpiration(traderKey *btcec.PublicKey, expiry uint32) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "WatchAccountExpiration", traderKey, expiry) +} + +// WatchAccountExpiration indicates an expected call of WatchAccountExpiration. +func (mr *MockControllerMockRecorder) WatchAccountExpiration(traderKey, expiry interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchAccountExpiration", reflect.TypeOf((*MockController)(nil).WatchAccountExpiration), traderKey, expiry) +} + +// WatchAccountSpend mocks base method. +func (m *MockController) WatchAccountSpend(traderKey *btcec.PublicKey, accountPoint wire.OutPoint, script []byte, heightHint uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WatchAccountSpend", traderKey, accountPoint, script, heightHint) + ret0, _ := ret[0].(error) + return ret0 +} + +// WatchAccountSpend indicates an expected call of WatchAccountSpend. +func (mr *MockControllerMockRecorder) WatchAccountSpend(traderKey, accountPoint, script, heightHint interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchAccountSpend", reflect.TypeOf((*MockController)(nil).WatchAccountSpend), traderKey, accountPoint, script, heightHint) +} + +// MockEventHandler is a mock of EventHandler interface. +type MockEventHandler struct { + ctrl *gomock.Controller + recorder *MockEventHandlerMockRecorder +} + +// MockEventHandlerMockRecorder is the mock recorder for MockEventHandler. +type MockEventHandlerMockRecorder struct { + mock *MockEventHandler +} + +// NewMockEventHandler creates a new mock instance. +func NewMockEventHandler(ctrl *gomock.Controller) *MockEventHandler { + mock := &MockEventHandler{ctrl: ctrl} + mock.recorder = &MockEventHandlerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEventHandler) EXPECT() *MockEventHandlerMockRecorder { + return m.recorder +} + +// HandleAccountConf mocks base method. +func (m *MockEventHandler) HandleAccountConf(arg0 *btcec.PublicKey, arg1 *chainntnfs.TxConfirmation) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleAccountConf", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleAccountConf indicates an expected call of HandleAccountConf. +func (mr *MockEventHandlerMockRecorder) HandleAccountConf(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAccountConf", reflect.TypeOf((*MockEventHandler)(nil).HandleAccountConf), arg0, arg1) +} + +// HandleAccountExpiry mocks base method. +func (m *MockEventHandler) HandleAccountExpiry(arg0 *btcec.PublicKey, arg1 uint32) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleAccountExpiry", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleAccountExpiry indicates an expected call of HandleAccountExpiry. +func (mr *MockEventHandlerMockRecorder) HandleAccountExpiry(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAccountExpiry", reflect.TypeOf((*MockEventHandler)(nil).HandleAccountExpiry), arg0, arg1) +} + +// HandleAccountSpend mocks base method. +func (m *MockEventHandler) HandleAccountSpend(arg0 *btcec.PublicKey, arg1 *chainntnfs.SpendDetail) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleAccountSpend", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleAccountSpend indicates an expected call of HandleAccountSpend. +func (mr *MockEventHandlerMockRecorder) HandleAccountSpend(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAccountSpend", reflect.TypeOf((*MockEventHandler)(nil).HandleAccountSpend), arg0, arg1) +} + +// MockExpiryWatcher is a mock of ExpiryWatcher interface. +type MockExpiryWatcher struct { + ctrl *gomock.Controller + recorder *MockExpiryWatcherMockRecorder +} + +// MockExpiryWatcherMockRecorder is the mock recorder for MockExpiryWatcher. +type MockExpiryWatcherMockRecorder struct { + mock *MockExpiryWatcher +} + +// NewMockExpiryWatcher creates a new mock instance. +func NewMockExpiryWatcher(ctrl *gomock.Controller) *MockExpiryWatcher { + mock := &MockExpiryWatcher{ctrl: ctrl} + mock.recorder = &MockExpiryWatcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockExpiryWatcher) EXPECT() *MockExpiryWatcherMockRecorder { + return m.recorder +} + +// AddAccountExpiration mocks base method. +func (m *MockExpiryWatcher) AddAccountExpiration(traderKey *btcec.PublicKey, expiry uint32) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AddAccountExpiration", traderKey, expiry) +} + +// AddAccountExpiration indicates an expected call of AddAccountExpiration. +func (mr *MockExpiryWatcherMockRecorder) AddAccountExpiration(traderKey, expiry interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAccountExpiration", reflect.TypeOf((*MockExpiryWatcher)(nil).AddAccountExpiration), traderKey, expiry) +} + +// NewBlock mocks base method. +func (m *MockExpiryWatcher) NewBlock(bestHeight uint32) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "NewBlock", bestHeight) +} + +// NewBlock indicates an expected call of NewBlock. +func (mr *MockExpiryWatcherMockRecorder) NewBlock(bestHeight interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBlock", reflect.TypeOf((*MockExpiryWatcher)(nil).NewBlock), bestHeight) +} diff --git a/gen.go b/gen.go index fa42ee4..2f72aa6 100644 --- a/gen.go +++ b/gen.go @@ -7,3 +7,4 @@ package pool //go:generate mockgen -source=sidecar/interfaces.go -package=sidecar -destination=sidecar/mock_interfaces.go //go:generate mockgen -source=internal/test/interfaces.go -package=test -destination=internal/test/mock_interfaces.go +//go:generate mockgen -source=account/watcher/interfaces.go -package=watcher -destination=account/watcher/mock_interface_test.go diff --git a/internal/test/interfaces.go b/internal/test/interfaces.go index 30c5b36..1c77347 100644 --- a/internal/test/interfaces.go +++ b/internal/test/interfaces.go @@ -9,3 +9,7 @@ type SignerClient interface { type WalletKitClient interface { lndclient.WalletKitClient } + +type ChainNotifierClient interface { + lndclient.ChainNotifierClient +} diff --git a/internal/test/mock_interfaces.go b/internal/test/mock_interfaces.go index 244b824..482f6a6 100644 --- a/internal/test/mock_interfaces.go +++ b/internal/test/mock_interfaces.go @@ -10,11 +10,13 @@ import ( time "time" btcec "github.com/btcsuite/btcd/btcec" + chainhash "github.com/btcsuite/btcd/chaincfg/chainhash" wire "github.com/btcsuite/btcd/wire" btcutil "github.com/btcsuite/btcutil" wtxmgr "github.com/btcsuite/btcwallet/wtxmgr" gomock "github.com/golang/mock/gomock" lndclient "github.com/lightninglabs/lndclient" + chainntnfs "github.com/lightningnetwork/lnd/chainntnfs" input "github.com/lightningnetwork/lnd/input" keychain "github.com/lightningnetwork/lnd/keychain" walletrpc "github.com/lightningnetwork/lnd/lnrpc/walletrpc" @@ -319,3 +321,74 @@ func (mr *MockWalletKitClientMockRecorder) SendOutputs(ctx, outputs, feeRate, la mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendOutputs", reflect.TypeOf((*MockWalletKitClient)(nil).SendOutputs), ctx, outputs, feeRate, label) } + +// MockChainNotifierClient is a mock of ChainNotifierClient interface. +type MockChainNotifierClient struct { + ctrl *gomock.Controller + recorder *MockChainNotifierClientMockRecorder +} + +// MockChainNotifierClientMockRecorder is the mock recorder for MockChainNotifierClient. +type MockChainNotifierClientMockRecorder struct { + mock *MockChainNotifierClient +} + +// NewMockChainNotifierClient creates a new mock instance. +func NewMockChainNotifierClient(ctrl *gomock.Controller) *MockChainNotifierClient { + mock := &MockChainNotifierClient{ctrl: ctrl} + mock.recorder = &MockChainNotifierClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChainNotifierClient) EXPECT() *MockChainNotifierClientMockRecorder { + return m.recorder +} + +// RegisterBlockEpochNtfn mocks base method. +func (m *MockChainNotifierClient) RegisterBlockEpochNtfn(ctx context.Context) (chan int32, chan error, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterBlockEpochNtfn", ctx) + ret0, _ := ret[0].(chan int32) + ret1, _ := ret[1].(chan error) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// RegisterBlockEpochNtfn indicates an expected call of RegisterBlockEpochNtfn. +func (mr *MockChainNotifierClientMockRecorder) RegisterBlockEpochNtfn(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterBlockEpochNtfn", reflect.TypeOf((*MockChainNotifierClient)(nil).RegisterBlockEpochNtfn), ctx) +} + +// RegisterConfirmationsNtfn mocks base method. +func (m *MockChainNotifierClient) RegisterConfirmationsNtfn(ctx context.Context, txid *chainhash.Hash, pkScript []byte, numConfs, heightHint int32) (chan *chainntnfs.TxConfirmation, chan error, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterConfirmationsNtfn", ctx, txid, pkScript, numConfs, heightHint) + ret0, _ := ret[0].(chan *chainntnfs.TxConfirmation) + ret1, _ := ret[1].(chan error) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// RegisterConfirmationsNtfn indicates an expected call of RegisterConfirmationsNtfn. +func (mr *MockChainNotifierClientMockRecorder) RegisterConfirmationsNtfn(ctx, txid, pkScript, numConfs, heightHint interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterConfirmationsNtfn", reflect.TypeOf((*MockChainNotifierClient)(nil).RegisterConfirmationsNtfn), ctx, txid, pkScript, numConfs, heightHint) +} + +// RegisterSpendNtfn mocks base method. +func (m *MockChainNotifierClient) RegisterSpendNtfn(ctx context.Context, outpoint *wire.OutPoint, pkScript []byte, heightHint int32) (chan *chainntnfs.SpendDetail, chan error, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterSpendNtfn", ctx, outpoint, pkScript, heightHint) + ret0, _ := ret[0].(chan *chainntnfs.SpendDetail) + ret1, _ := ret[1].(chan error) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// RegisterSpendNtfn indicates an expected call of RegisterSpendNtfn. +func (mr *MockChainNotifierClientMockRecorder) RegisterSpendNtfn(ctx, outpoint, pkScript, heightHint interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterSpendNtfn", reflect.TypeOf((*MockChainNotifierClient)(nil).RegisterSpendNtfn), ctx, outpoint, pkScript, heightHint) +}