diff --git a/.mockery.yaml b/.mockery.yaml index fae90326f9e..f2ae8be1b93 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -18,6 +18,7 @@ packages: TxStrategy: TxAttemptBuilder: TxStore: + Finalizer: github.com/smartcontractkit/chainlink/v2/core/bridges: interfaces: ORM: @@ -60,6 +61,18 @@ packages: interfaces: EvmTxStore: ChainReceipt: + ConfirmerI: + config: + mockname: Confirmer + filename: confirmer.go + BroadcasterI: + config: + mockname: Broadcaster + filename: broadcaster.go + TrackerI: + config: + mockname: Tracker + filename: tracker.go github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm: config: dir: common/chains/mocks diff --git a/common/txmgr/mocks/broadcaster.go b/common/txmgr/mocks/broadcaster.go new file mode 100644 index 00000000000..dd2ff7a923f --- /dev/null +++ b/common/txmgr/mocks/broadcaster.go @@ -0,0 +1,368 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package mocks + +import ( + common "github.com/ethereum/go-ethereum/common" + chains "github.com/smartcontractkit/chainlink-framework/chains" + + context "context" + + mock "github.com/stretchr/testify/mock" + + txmgr "github.com/smartcontractkit/chainlink-framework/chains/txmgr" +) + +// Broadcaster is an autogenerated mock type for the BroadcasterI type +type Broadcaster[ADDR chains.Hashable] struct { + mock.Mock +} + +type Broadcaster_Expecter[ADDR chains.Hashable] struct { + mock *mock.Mock +} + +func (_m *Broadcaster[ADDR]) EXPECT() *Broadcaster_Expecter[ADDR] { + return &Broadcaster_Expecter[ADDR]{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *Broadcaster[ADDR]) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Broadcaster_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Broadcaster_Close_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Broadcaster_Expecter[ADDR]) Close() *Broadcaster_Close_Call[ADDR] { + return &Broadcaster_Close_Call[ADDR]{Call: _e.mock.On("Close")} +} + +func (_c *Broadcaster_Close_Call[ADDR]) Run(run func()) *Broadcaster_Close_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Broadcaster_Close_Call[ADDR]) Return(_a0 error) *Broadcaster_Close_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Broadcaster_Close_Call[ADDR]) RunAndReturn(run func() error) *Broadcaster_Close_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// HealthReport provides a mock function with no fields +func (_m *Broadcaster[ADDR]) HealthReport() map[string]error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for HealthReport") + } + + var r0 map[string]error + if rf, ok := ret.Get(0).(func() map[string]error); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]error) + } + } + + return r0 +} + +// Broadcaster_HealthReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthReport' +type Broadcaster_HealthReport_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// HealthReport is a helper method to define mock.On call +func (_e *Broadcaster_Expecter[ADDR]) HealthReport() *Broadcaster_HealthReport_Call[ADDR] { + return &Broadcaster_HealthReport_Call[ADDR]{Call: _e.mock.On("HealthReport")} +} + +func (_c *Broadcaster_HealthReport_Call[ADDR]) Run(run func()) *Broadcaster_HealthReport_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Broadcaster_HealthReport_Call[ADDR]) Return(_a0 map[string]error) *Broadcaster_HealthReport_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Broadcaster_HealthReport_Call[ADDR]) RunAndReturn(run func() map[string]error) *Broadcaster_HealthReport_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with no fields +func (_m *Broadcaster[ADDR]) Name() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Name") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Broadcaster_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type Broadcaster_Name_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *Broadcaster_Expecter[ADDR]) Name() *Broadcaster_Name_Call[ADDR] { + return &Broadcaster_Name_Call[ADDR]{Call: _e.mock.On("Name")} +} + +func (_c *Broadcaster_Name_Call[ADDR]) Run(run func()) *Broadcaster_Name_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Broadcaster_Name_Call[ADDR]) Return(_a0 string) *Broadcaster_Name_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Broadcaster_Name_Call[ADDR]) RunAndReturn(run func() string) *Broadcaster_Name_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// Ready provides a mock function with no fields +func (_m *Broadcaster[ADDR]) Ready() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Ready") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Broadcaster_Ready_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ready' +type Broadcaster_Ready_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Ready is a helper method to define mock.On call +func (_e *Broadcaster_Expecter[ADDR]) Ready() *Broadcaster_Ready_Call[ADDR] { + return &Broadcaster_Ready_Call[ADDR]{Call: _e.mock.On("Ready")} +} + +func (_c *Broadcaster_Ready_Call[ADDR]) Run(run func()) *Broadcaster_Ready_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Broadcaster_Ready_Call[ADDR]) Return(_a0 error) *Broadcaster_Ready_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Broadcaster_Ready_Call[ADDR]) RunAndReturn(run func() error) *Broadcaster_Ready_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// SetEnabledAddresses provides a mock function with given fields: _a0 +func (_m *Broadcaster[ADDR]) SetEnabledAddresses(_a0 []common.Address) { + _m.Called(_a0) +} + +// Broadcaster_SetEnabledAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEnabledAddresses' +type Broadcaster_SetEnabledAddresses_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// SetEnabledAddresses is a helper method to define mock.On call +// - _a0 []common.Address +func (_e *Broadcaster_Expecter[ADDR]) SetEnabledAddresses(_a0 interface{}) *Broadcaster_SetEnabledAddresses_Call[ADDR] { + return &Broadcaster_SetEnabledAddresses_Call[ADDR]{Call: _e.mock.On("SetEnabledAddresses", _a0)} +} + +func (_c *Broadcaster_SetEnabledAddresses_Call[ADDR]) Run(run func(_a0 []common.Address)) *Broadcaster_SetEnabledAddresses_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]common.Address)) + }) + return _c +} + +func (_c *Broadcaster_SetEnabledAddresses_Call[ADDR]) Return() *Broadcaster_SetEnabledAddresses_Call[ADDR] { + _c.Call.Return() + return _c +} + +func (_c *Broadcaster_SetEnabledAddresses_Call[ADDR]) RunAndReturn(run func([]common.Address)) *Broadcaster_SetEnabledAddresses_Call[ADDR] { + _c.Run(run) + return _c +} + +// SetResumeCallback provides a mock function with given fields: _a0 +func (_m *Broadcaster[ADDR]) SetResumeCallback(_a0 txmgr.ResumeCallback) { + _m.Called(_a0) +} + +// Broadcaster_SetResumeCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResumeCallback' +type Broadcaster_SetResumeCallback_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// SetResumeCallback is a helper method to define mock.On call +// - _a0 txmgr.ResumeCallback +func (_e *Broadcaster_Expecter[ADDR]) SetResumeCallback(_a0 interface{}) *Broadcaster_SetResumeCallback_Call[ADDR] { + return &Broadcaster_SetResumeCallback_Call[ADDR]{Call: _e.mock.On("SetResumeCallback", _a0)} +} + +func (_c *Broadcaster_SetResumeCallback_Call[ADDR]) Run(run func(_a0 txmgr.ResumeCallback)) *Broadcaster_SetResumeCallback_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(txmgr.ResumeCallback)) + }) + return _c +} + +func (_c *Broadcaster_SetResumeCallback_Call[ADDR]) Return() *Broadcaster_SetResumeCallback_Call[ADDR] { + _c.Call.Return() + return _c +} + +func (_c *Broadcaster_SetResumeCallback_Call[ADDR]) RunAndReturn(run func(txmgr.ResumeCallback)) *Broadcaster_SetResumeCallback_Call[ADDR] { + _c.Run(run) + return _c +} + +// Start provides a mock function with given fields: _a0 +func (_m *Broadcaster[ADDR]) Start(_a0 context.Context) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Broadcaster_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type Broadcaster_Start_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - _a0 context.Context +func (_e *Broadcaster_Expecter[ADDR]) Start(_a0 interface{}) *Broadcaster_Start_Call[ADDR] { + return &Broadcaster_Start_Call[ADDR]{Call: _e.mock.On("Start", _a0)} +} + +func (_c *Broadcaster_Start_Call[ADDR]) Run(run func(_a0 context.Context)) *Broadcaster_Start_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Broadcaster_Start_Call[ADDR]) Return(_a0 error) *Broadcaster_Start_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Broadcaster_Start_Call[ADDR]) RunAndReturn(run func(context.Context) error) *Broadcaster_Start_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// Trigger provides a mock function with given fields: _a0 +func (_m *Broadcaster[ADDR]) Trigger(_a0 common.Address) { + _m.Called(_a0) +} + +// Broadcaster_Trigger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trigger' +type Broadcaster_Trigger_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Trigger is a helper method to define mock.On call +// - _a0 common.Address +func (_e *Broadcaster_Expecter[ADDR]) Trigger(_a0 interface{}) *Broadcaster_Trigger_Call[ADDR] { + return &Broadcaster_Trigger_Call[ADDR]{Call: _e.mock.On("Trigger", _a0)} +} + +func (_c *Broadcaster_Trigger_Call[ADDR]) Run(run func(_a0 common.Address)) *Broadcaster_Trigger_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(common.Address)) + }) + return _c +} + +func (_c *Broadcaster_Trigger_Call[ADDR]) Return() *Broadcaster_Trigger_Call[ADDR] { + _c.Call.Return() + return _c +} + +func (_c *Broadcaster_Trigger_Call[ADDR]) RunAndReturn(run func(common.Address)) *Broadcaster_Trigger_Call[ADDR] { + _c.Run(run) + return _c +} + +// NewBroadcaster creates a new instance of Broadcaster. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBroadcaster[ADDR chains.Hashable](t interface { + mock.TestingT + Cleanup(func()) +}) *Broadcaster[ADDR] { + mock := &Broadcaster[ADDR]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/common/txmgr/mocks/confirmer.go b/common/txmgr/mocks/confirmer.go new file mode 100644 index 00000000000..13e98ebeef4 --- /dev/null +++ b/common/txmgr/mocks/confirmer.go @@ -0,0 +1,370 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package mocks + +import ( + common "github.com/ethereum/go-ethereum/common" + chains "github.com/smartcontractkit/chainlink-framework/chains" + + context "context" + + mock "github.com/stretchr/testify/mock" + + txmgr "github.com/smartcontractkit/chainlink-framework/chains/txmgr" + + types "github.com/smartcontractkit/chainlink-evm/pkg/types" +) + +// Confirmer is an autogenerated mock type for the ConfirmerI type +type Confirmer[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + mock.Mock +} + +type Confirmer_Expecter[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + mock *mock.Mock +} + +func (_m *Confirmer[HEAD, ADDR, BHASH]) EXPECT() *Confirmer_Expecter[HEAD, ADDR, BHASH] { + return &Confirmer_Expecter[HEAD, ADDR, BHASH]{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *Confirmer[HEAD, ADDR, BHASH]) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Confirmer_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Confirmer_Close_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) Close() *Confirmer_Close_Call[HEAD, ADDR, BHASH] { + return &Confirmer_Close_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("Close")} +} + +func (_c *Confirmer_Close_Call[HEAD, ADDR, BHASH]) Run(run func()) *Confirmer_Close_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Confirmer_Close_Call[HEAD, ADDR, BHASH]) Return(_a0 error) *Confirmer_Close_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Confirmer_Close_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func() error) *Confirmer_Close_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(run) + return _c +} + +// Deliver provides a mock function with given fields: _a0 +func (_m *Confirmer[HEAD, ADDR, BHASH]) Deliver(_a0 *types.Head) { + _m.Called(_a0) +} + +// Confirmer_Deliver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deliver' +type Confirmer_Deliver_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// Deliver is a helper method to define mock.On call +// - _a0 *types.Head +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) Deliver(_a0 interface{}) *Confirmer_Deliver_Call[HEAD, ADDR, BHASH] { + return &Confirmer_Deliver_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("Deliver", _a0)} +} + +func (_c *Confirmer_Deliver_Call[HEAD, ADDR, BHASH]) Run(run func(_a0 *types.Head)) *Confirmer_Deliver_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*types.Head)) + }) + return _c +} + +func (_c *Confirmer_Deliver_Call[HEAD, ADDR, BHASH]) Return() *Confirmer_Deliver_Call[HEAD, ADDR, BHASH] { + _c.Call.Return() + return _c +} + +func (_c *Confirmer_Deliver_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func(*types.Head)) *Confirmer_Deliver_Call[HEAD, ADDR, BHASH] { + _c.Run(run) + return _c +} + +// HealthReport provides a mock function with no fields +func (_m *Confirmer[HEAD, ADDR, BHASH]) HealthReport() map[string]error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for HealthReport") + } + + var r0 map[string]error + if rf, ok := ret.Get(0).(func() map[string]error); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]error) + } + } + + return r0 +} + +// Confirmer_HealthReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthReport' +type Confirmer_HealthReport_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// HealthReport is a helper method to define mock.On call +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) HealthReport() *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH] { + return &Confirmer_HealthReport_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("HealthReport")} +} + +func (_c *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH]) Run(run func()) *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH]) Return(_a0 map[string]error) *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func() map[string]error) *Confirmer_HealthReport_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with no fields +func (_m *Confirmer[HEAD, ADDR, BHASH]) Name() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Name") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Confirmer_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type Confirmer_Name_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) Name() *Confirmer_Name_Call[HEAD, ADDR, BHASH] { + return &Confirmer_Name_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("Name")} +} + +func (_c *Confirmer_Name_Call[HEAD, ADDR, BHASH]) Run(run func()) *Confirmer_Name_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Confirmer_Name_Call[HEAD, ADDR, BHASH]) Return(_a0 string) *Confirmer_Name_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Confirmer_Name_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func() string) *Confirmer_Name_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(run) + return _c +} + +// Ready provides a mock function with no fields +func (_m *Confirmer[HEAD, ADDR, BHASH]) Ready() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Ready") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Confirmer_Ready_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ready' +type Confirmer_Ready_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// Ready is a helper method to define mock.On call +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) Ready() *Confirmer_Ready_Call[HEAD, ADDR, BHASH] { + return &Confirmer_Ready_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("Ready")} +} + +func (_c *Confirmer_Ready_Call[HEAD, ADDR, BHASH]) Run(run func()) *Confirmer_Ready_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Confirmer_Ready_Call[HEAD, ADDR, BHASH]) Return(_a0 error) *Confirmer_Ready_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Confirmer_Ready_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func() error) *Confirmer_Ready_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(run) + return _c +} + +// SetEnabledAddresses provides a mock function with given fields: _a0 +func (_m *Confirmer[HEAD, ADDR, BHASH]) SetEnabledAddresses(_a0 []common.Address) { + _m.Called(_a0) +} + +// Confirmer_SetEnabledAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEnabledAddresses' +type Confirmer_SetEnabledAddresses_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// SetEnabledAddresses is a helper method to define mock.On call +// - _a0 []common.Address +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) SetEnabledAddresses(_a0 interface{}) *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH] { + return &Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("SetEnabledAddresses", _a0)} +} + +func (_c *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH]) Run(run func(_a0 []common.Address)) *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]common.Address)) + }) + return _c +} + +func (_c *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH]) Return() *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH] { + _c.Call.Return() + return _c +} + +func (_c *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func([]common.Address)) *Confirmer_SetEnabledAddresses_Call[HEAD, ADDR, BHASH] { + _c.Run(run) + return _c +} + +// SetResumeCallback provides a mock function with given fields: _a0 +func (_m *Confirmer[HEAD, ADDR, BHASH]) SetResumeCallback(_a0 txmgr.ResumeCallback) { + _m.Called(_a0) +} + +// Confirmer_SetResumeCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResumeCallback' +type Confirmer_SetResumeCallback_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// SetResumeCallback is a helper method to define mock.On call +// - _a0 txmgr.ResumeCallback +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) SetResumeCallback(_a0 interface{}) *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH] { + return &Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("SetResumeCallback", _a0)} +} + +func (_c *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH]) Run(run func(_a0 txmgr.ResumeCallback)) *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(txmgr.ResumeCallback)) + }) + return _c +} + +func (_c *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH]) Return() *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH] { + _c.Call.Return() + return _c +} + +func (_c *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func(txmgr.ResumeCallback)) *Confirmer_SetResumeCallback_Call[HEAD, ADDR, BHASH] { + _c.Run(run) + return _c +} + +// Start provides a mock function with given fields: _a0 +func (_m *Confirmer[HEAD, ADDR, BHASH]) Start(_a0 context.Context) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Confirmer_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type Confirmer_Start_Call[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable] struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - _a0 context.Context +func (_e *Confirmer_Expecter[HEAD, ADDR, BHASH]) Start(_a0 interface{}) *Confirmer_Start_Call[HEAD, ADDR, BHASH] { + return &Confirmer_Start_Call[HEAD, ADDR, BHASH]{Call: _e.mock.On("Start", _a0)} +} + +func (_c *Confirmer_Start_Call[HEAD, ADDR, BHASH]) Run(run func(_a0 context.Context)) *Confirmer_Start_Call[HEAD, ADDR, BHASH] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Confirmer_Start_Call[HEAD, ADDR, BHASH]) Return(_a0 error) *Confirmer_Start_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Confirmer_Start_Call[HEAD, ADDR, BHASH]) RunAndReturn(run func(context.Context) error) *Confirmer_Start_Call[HEAD, ADDR, BHASH] { + _c.Call.Return(run) + return _c +} + +// NewConfirmer creates a new instance of Confirmer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewConfirmer[HEAD chains.Head[BHASH], ADDR chains.Hashable, BHASH chains.Hashable](t interface { + mock.TestingT + Cleanup(func()) +}) *Confirmer[HEAD, ADDR, BHASH] { + mock := &Confirmer[HEAD, ADDR, BHASH]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/common/txmgr/mocks/tracker.go b/common/txmgr/mocks/tracker.go new file mode 100644 index 00000000000..6b47c999506 --- /dev/null +++ b/common/txmgr/mocks/tracker.go @@ -0,0 +1,380 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package mocks + +import ( + common "github.com/ethereum/go-ethereum/common" + chains "github.com/smartcontractkit/chainlink-framework/chains" + + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// Tracker is an autogenerated mock type for the TrackerI type +type Tracker[ADDR chains.Hashable] struct { + mock.Mock +} + +type Tracker_Expecter[ADDR chains.Hashable] struct { + mock *mock.Mock +} + +func (_m *Tracker[ADDR]) EXPECT() *Tracker_Expecter[ADDR] { + return &Tracker_Expecter[ADDR]{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *Tracker[ADDR]) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Tracker_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Tracker_Close_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Tracker_Expecter[ADDR]) Close() *Tracker_Close_Call[ADDR] { + return &Tracker_Close_Call[ADDR]{Call: _e.mock.On("Close")} +} + +func (_c *Tracker_Close_Call[ADDR]) Run(run func()) *Tracker_Close_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Tracker_Close_Call[ADDR]) Return(_a0 error) *Tracker_Close_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracker_Close_Call[ADDR]) RunAndReturn(run func() error) *Tracker_Close_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// Deliver provides a mock function with given fields: _a0 +func (_m *Tracker[ADDR]) Deliver(_a0 int64) { + _m.Called(_a0) +} + +// Tracker_Deliver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deliver' +type Tracker_Deliver_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Deliver is a helper method to define mock.On call +// - _a0 int64 +func (_e *Tracker_Expecter[ADDR]) Deliver(_a0 interface{}) *Tracker_Deliver_Call[ADDR] { + return &Tracker_Deliver_Call[ADDR]{Call: _e.mock.On("Deliver", _a0)} +} + +func (_c *Tracker_Deliver_Call[ADDR]) Run(run func(_a0 int64)) *Tracker_Deliver_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int64)) + }) + return _c +} + +func (_c *Tracker_Deliver_Call[ADDR]) Return() *Tracker_Deliver_Call[ADDR] { + _c.Call.Return() + return _c +} + +func (_c *Tracker_Deliver_Call[ADDR]) RunAndReturn(run func(int64)) *Tracker_Deliver_Call[ADDR] { + _c.Run(run) + return _c +} + +// GetEnabledAddresses provides a mock function with no fields +func (_m *Tracker[ADDR]) GetEnabledAddresses() []common.Address { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetEnabledAddresses") + } + + var r0 []common.Address + if rf, ok := ret.Get(0).(func() []common.Address); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]common.Address) + } + } + + return r0 +} + +// Tracker_GetEnabledAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnabledAddresses' +type Tracker_GetEnabledAddresses_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// GetEnabledAddresses is a helper method to define mock.On call +func (_e *Tracker_Expecter[ADDR]) GetEnabledAddresses() *Tracker_GetEnabledAddresses_Call[ADDR] { + return &Tracker_GetEnabledAddresses_Call[ADDR]{Call: _e.mock.On("GetEnabledAddresses")} +} + +func (_c *Tracker_GetEnabledAddresses_Call[ADDR]) Run(run func()) *Tracker_GetEnabledAddresses_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Tracker_GetEnabledAddresses_Call[ADDR]) Return(_a0 []common.Address) *Tracker_GetEnabledAddresses_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracker_GetEnabledAddresses_Call[ADDR]) RunAndReturn(run func() []common.Address) *Tracker_GetEnabledAddresses_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// HealthReport provides a mock function with no fields +func (_m *Tracker[ADDR]) HealthReport() map[string]error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for HealthReport") + } + + var r0 map[string]error + if rf, ok := ret.Get(0).(func() map[string]error); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]error) + } + } + + return r0 +} + +// Tracker_HealthReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthReport' +type Tracker_HealthReport_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// HealthReport is a helper method to define mock.On call +func (_e *Tracker_Expecter[ADDR]) HealthReport() *Tracker_HealthReport_Call[ADDR] { + return &Tracker_HealthReport_Call[ADDR]{Call: _e.mock.On("HealthReport")} +} + +func (_c *Tracker_HealthReport_Call[ADDR]) Run(run func()) *Tracker_HealthReport_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Tracker_HealthReport_Call[ADDR]) Return(_a0 map[string]error) *Tracker_HealthReport_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracker_HealthReport_Call[ADDR]) RunAndReturn(run func() map[string]error) *Tracker_HealthReport_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with no fields +func (_m *Tracker[ADDR]) Name() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Name") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Tracker_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type Tracker_Name_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *Tracker_Expecter[ADDR]) Name() *Tracker_Name_Call[ADDR] { + return &Tracker_Name_Call[ADDR]{Call: _e.mock.On("Name")} +} + +func (_c *Tracker_Name_Call[ADDR]) Run(run func()) *Tracker_Name_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Tracker_Name_Call[ADDR]) Return(_a0 string) *Tracker_Name_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracker_Name_Call[ADDR]) RunAndReturn(run func() string) *Tracker_Name_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// Ready provides a mock function with no fields +func (_m *Tracker[ADDR]) Ready() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Ready") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Tracker_Ready_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ready' +type Tracker_Ready_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Ready is a helper method to define mock.On call +func (_e *Tracker_Expecter[ADDR]) Ready() *Tracker_Ready_Call[ADDR] { + return &Tracker_Ready_Call[ADDR]{Call: _e.mock.On("Ready")} +} + +func (_c *Tracker_Ready_Call[ADDR]) Run(run func()) *Tracker_Ready_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Tracker_Ready_Call[ADDR]) Return(_a0 error) *Tracker_Ready_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracker_Ready_Call[ADDR]) RunAndReturn(run func() error) *Tracker_Ready_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// SetEnabledAddresses provides a mock function with given fields: _a0 +func (_m *Tracker[ADDR]) SetEnabledAddresses(_a0 []common.Address) { + _m.Called(_a0) +} + +// Tracker_SetEnabledAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEnabledAddresses' +type Tracker_SetEnabledAddresses_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// SetEnabledAddresses is a helper method to define mock.On call +// - _a0 []common.Address +func (_e *Tracker_Expecter[ADDR]) SetEnabledAddresses(_a0 interface{}) *Tracker_SetEnabledAddresses_Call[ADDR] { + return &Tracker_SetEnabledAddresses_Call[ADDR]{Call: _e.mock.On("SetEnabledAddresses", _a0)} +} + +func (_c *Tracker_SetEnabledAddresses_Call[ADDR]) Run(run func(_a0 []common.Address)) *Tracker_SetEnabledAddresses_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]common.Address)) + }) + return _c +} + +func (_c *Tracker_SetEnabledAddresses_Call[ADDR]) Return() *Tracker_SetEnabledAddresses_Call[ADDR] { + _c.Call.Return() + return _c +} + +func (_c *Tracker_SetEnabledAddresses_Call[ADDR]) RunAndReturn(run func([]common.Address)) *Tracker_SetEnabledAddresses_Call[ADDR] { + _c.Run(run) + return _c +} + +// Start provides a mock function with given fields: _a0 +func (_m *Tracker[ADDR]) Start(_a0 context.Context) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Tracker_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type Tracker_Start_Call[ADDR chains.Hashable] struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - _a0 context.Context +func (_e *Tracker_Expecter[ADDR]) Start(_a0 interface{}) *Tracker_Start_Call[ADDR] { + return &Tracker_Start_Call[ADDR]{Call: _e.mock.On("Start", _a0)} +} + +func (_c *Tracker_Start_Call[ADDR]) Run(run func(_a0 context.Context)) *Tracker_Start_Call[ADDR] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Tracker_Start_Call[ADDR]) Return(_a0 error) *Tracker_Start_Call[ADDR] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracker_Start_Call[ADDR]) RunAndReturn(run func(context.Context) error) *Tracker_Start_Call[ADDR] { + _c.Call.Return(run) + return _c +} + +// NewTracker creates a new instance of Tracker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTracker[ADDR chains.Hashable](t interface { + mock.TestingT + Cleanup(func()) +}) *Tracker[ADDR] { + mock := &Tracker[ADDR]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/common/txmgr/types/mocks/finalizer.go b/common/txmgr/types/mocks/finalizer.go new file mode 100644 index 00000000000..e4b31e576f7 --- /dev/null +++ b/common/txmgr/types/mocks/finalizer.go @@ -0,0 +1,347 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package mocks + +import ( + context "context" + + chains "github.com/smartcontractkit/chainlink-framework/chains" + + mock "github.com/stretchr/testify/mock" + + uuid "github.com/google/uuid" +) + +// Finalizer is an autogenerated mock type for the Finalizer type +type Finalizer[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + mock.Mock +} + +type Finalizer_Expecter[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + mock *mock.Mock +} + +func (_m *Finalizer[BLOCK_HASH, HEAD]) EXPECT() *Finalizer_Expecter[BLOCK_HASH, HEAD] { + return &Finalizer_Expecter[BLOCK_HASH, HEAD]{mock: &_m.Mock} +} + +// Close provides a mock function with no fields +func (_m *Finalizer[BLOCK_HASH, HEAD]) Close() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Finalizer_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Finalizer_Close_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) Close() *Finalizer_Close_Call[BLOCK_HASH, HEAD] { + return &Finalizer_Close_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("Close")} +} + +func (_c *Finalizer_Close_Call[BLOCK_HASH, HEAD]) Run(run func()) *Finalizer_Close_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Finalizer_Close_Call[BLOCK_HASH, HEAD]) Return(_a0 error) *Finalizer_Close_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Finalizer_Close_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func() error) *Finalizer_Close_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(run) + return _c +} + +// DeliverLatestHead provides a mock function with given fields: head +func (_m *Finalizer[BLOCK_HASH, HEAD]) DeliverLatestHead(head HEAD) bool { + ret := _m.Called(head) + + if len(ret) == 0 { + panic("no return value specified for DeliverLatestHead") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(HEAD) bool); ok { + r0 = rf(head) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Finalizer_DeliverLatestHead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeliverLatestHead' +type Finalizer_DeliverLatestHead_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// DeliverLatestHead is a helper method to define mock.On call +// - head HEAD +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) DeliverLatestHead(head interface{}) *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD] { + return &Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("DeliverLatestHead", head)} +} + +func (_c *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD]) Run(run func(head HEAD)) *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(HEAD)) + }) + return _c +} + +func (_c *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD]) Return(_a0 bool) *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func(HEAD) bool) *Finalizer_DeliverLatestHead_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(run) + return _c +} + +// HealthReport provides a mock function with no fields +func (_m *Finalizer[BLOCK_HASH, HEAD]) HealthReport() map[string]error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for HealthReport") + } + + var r0 map[string]error + if rf, ok := ret.Get(0).(func() map[string]error); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]error) + } + } + + return r0 +} + +// Finalizer_HealthReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthReport' +type Finalizer_HealthReport_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// HealthReport is a helper method to define mock.On call +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) HealthReport() *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD] { + return &Finalizer_HealthReport_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("HealthReport")} +} + +func (_c *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD]) Run(run func()) *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD]) Return(_a0 map[string]error) *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func() map[string]error) *Finalizer_HealthReport_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with no fields +func (_m *Finalizer[BLOCK_HASH, HEAD]) Name() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Name") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Finalizer_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type Finalizer_Name_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) Name() *Finalizer_Name_Call[BLOCK_HASH, HEAD] { + return &Finalizer_Name_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("Name")} +} + +func (_c *Finalizer_Name_Call[BLOCK_HASH, HEAD]) Run(run func()) *Finalizer_Name_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Finalizer_Name_Call[BLOCK_HASH, HEAD]) Return(_a0 string) *Finalizer_Name_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Finalizer_Name_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func() string) *Finalizer_Name_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(run) + return _c +} + +// Ready provides a mock function with no fields +func (_m *Finalizer[BLOCK_HASH, HEAD]) Ready() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Ready") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Finalizer_Ready_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ready' +type Finalizer_Ready_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// Ready is a helper method to define mock.On call +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) Ready() *Finalizer_Ready_Call[BLOCK_HASH, HEAD] { + return &Finalizer_Ready_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("Ready")} +} + +func (_c *Finalizer_Ready_Call[BLOCK_HASH, HEAD]) Run(run func()) *Finalizer_Ready_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Finalizer_Ready_Call[BLOCK_HASH, HEAD]) Return(_a0 error) *Finalizer_Ready_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Finalizer_Ready_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func() error) *Finalizer_Ready_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(run) + return _c +} + +// SetResumeCallback provides a mock function with given fields: callback +func (_m *Finalizer[BLOCK_HASH, HEAD]) SetResumeCallback(callback func(context.Context, uuid.UUID, interface{}, error) error) { + _m.Called(callback) +} + +// Finalizer_SetResumeCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResumeCallback' +type Finalizer_SetResumeCallback_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// SetResumeCallback is a helper method to define mock.On call +// - callback func(context.Context , uuid.UUID , interface{} , error) error +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) SetResumeCallback(callback interface{}) *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD] { + return &Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("SetResumeCallback", callback)} +} + +func (_c *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD]) Run(run func(callback func(context.Context, uuid.UUID, interface{}, error) error)) *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, uuid.UUID, interface{}, error) error)) + }) + return _c +} + +func (_c *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD]) Return() *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD] { + _c.Call.Return() + return _c +} + +func (_c *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func(func(context.Context, uuid.UUID, interface{}, error) error)) *Finalizer_SetResumeCallback_Call[BLOCK_HASH, HEAD] { + _c.Run(run) + return _c +} + +// Start provides a mock function with given fields: _a0 +func (_m *Finalizer[BLOCK_HASH, HEAD]) Start(_a0 context.Context) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Finalizer_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type Finalizer_Start_Call[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]] struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - _a0 context.Context +func (_e *Finalizer_Expecter[BLOCK_HASH, HEAD]) Start(_a0 interface{}) *Finalizer_Start_Call[BLOCK_HASH, HEAD] { + return &Finalizer_Start_Call[BLOCK_HASH, HEAD]{Call: _e.mock.On("Start", _a0)} +} + +func (_c *Finalizer_Start_Call[BLOCK_HASH, HEAD]) Run(run func(_a0 context.Context)) *Finalizer_Start_Call[BLOCK_HASH, HEAD] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Finalizer_Start_Call[BLOCK_HASH, HEAD]) Return(_a0 error) *Finalizer_Start_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Finalizer_Start_Call[BLOCK_HASH, HEAD]) RunAndReturn(run func(context.Context) error) *Finalizer_Start_Call[BLOCK_HASH, HEAD] { + _c.Call.Return(run) + return _c +} + +// NewFinalizer creates a new instance of Finalizer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFinalizer[BLOCK_HASH chains.Hashable, HEAD chains.Head[BLOCK_HASH]](t interface { + mock.TestingT + Cleanup(func()) +}) *Finalizer[BLOCK_HASH, HEAD] { + mock := &Finalizer[BLOCK_HASH, HEAD]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/core/internal/cltest/cltest.go b/core/internal/cltest/cltest.go index 73eebc91d33..5b6cac6ab91 100644 --- a/core/internal/cltest/cltest.go +++ b/core/internal/cltest/cltest.go @@ -627,10 +627,12 @@ func NewEthMocksWithStartupAssertions(t testing.TB) *clienttest.Client { c.On("SendTransaction", mock.Anything, mock.Anything).Maybe().Return(nil) c.On("HeadByNumber", mock.Anything, mock.Anything).Maybe().Return(Head(0), nil) c.On("ConfiguredChainID").Maybe().Return(&FixtureChainID) - c.On("CallContract", mock.Anything, mock.Anything, mock.Anything).Maybe().Return([]byte{}, nil) c.On("SubscribeFilterLogs", mock.Anything, mock.Anything, mock.Anything).Maybe().Return(nil, errors.New("mocked")) c.On("CodeAt", mock.Anything, mock.Anything, mock.Anything).Maybe().Return([]byte{}, nil) + c.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Maybe().Return(uint64(0), nil) + c.On("PendingNonceAt", mock.Anything, mock.Anything, mock.Anything).Maybe().Return(uint64(0), nil) c.On("Close").Maybe().Return() + c.On("BatchCallContext", mock.Anything, mock.Anything).Maybe().Return(nil) block := &types.Header{ Number: big.NewInt(100), diff --git a/core/internal/features/features_test.go b/core/internal/features/features_test.go index 60d7b24f2d5..500054909d4 100644 --- a/core/internal/features/features_test.go +++ b/core/internal/features/features_test.go @@ -41,7 +41,6 @@ import ( ocrtypes "github.com/smartcontractkit/libocr/offchainreporting/types" commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" - "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" "github.com/smartcontractkit/chainlink-common/pkg/utils/tests" @@ -54,7 +53,6 @@ import ( "github.com/smartcontractkit/chainlink-evm/gethwrappers/operatorforwarder/generated/authorized_forwarder" "github.com/smartcontractkit/chainlink-evm/gethwrappers/operatorforwarder/generated/operator" "github.com/smartcontractkit/chainlink-evm/pkg/assets" - "github.com/smartcontractkit/chainlink-evm/pkg/client" "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" "github.com/smartcontractkit/chainlink-evm/pkg/forwarders" evmtestutils "github.com/smartcontractkit/chainlink-evm/pkg/testutils" @@ -1282,23 +1280,12 @@ func TestIntegration_BlockHistoryEstimator(t *testing.T) { }) ethClient := cltest.NewEthMocks(t) - ethClient.On("ConfiguredChainID").Return(big.NewInt(client.NullClientChainID)).Maybe() chchNewHeads := make(chan evmtestutils.RawSub[*types.Head], 1) db := pgtest.NewSqlxDB(t) kst := cltest.NewKeyStore(t, db) require.NoError(t, kst.Unlock(ctx, cltest.Password)) - legacyChains := evmtest.NewLegacyChains(t, evmtest.TestChainOpts{ - ChainConfigs: cfg.EVMConfigs(), - DatabaseConfig: cfg.Database(), - FeatureConfig: cfg.Feature(), - ListenerConfig: cfg.Database().Listener(), - KeyStore: kst.Eth(), - DB: db, - Client: ethClient, - }) - b41 := types.Block{ Number: 41, Hash: evmutils.NewHash(), @@ -1346,16 +1333,23 @@ func TestIntegration_BlockHistoryEstimator(t *testing.T) { }) ethClient.On("Dial", mock.Anything).Return(nil) - ethClient.On("ConfiguredChainID", mock.Anything).Return(*evmtest.MustGetDefaultChainID(t, cfg.EVMConfigs()), nil) + ethClient.On("ConfiguredChainID", mock.Anything).Return(evmtest.MustGetDefaultChainID(t, cfg.EVMConfigs()), nil) ethClient.On("BalanceAt", mock.Anything, mock.Anything, mock.Anything).Maybe().Return(oneETH.ToInt(), nil) // HeadTracker backfill ethClient.On("HeadByHash", mock.Anything, h40.Hash).Return(&h40, nil).Maybe() ethClient.On("HeadByHash", mock.Anything, h41.Hash).Return(&h41, nil).Maybe() ethClient.On("HeadByHash", mock.Anything, h42.Hash).Return(&h42, nil).Maybe() - for _, re := range legacyChains.Slice() { - servicetest.Run(t, re) - } + legacyChains := evmtest.NewLegacyChains(t, evmtest.TestChainOpts{ + ChainConfigs: cfg.EVMConfigs(), + DatabaseConfig: cfg.Database(), + FeatureConfig: cfg.Feature(), + ListenerConfig: cfg.Database().Listener(), + KeyStore: kst.Eth(), + DB: db, + Client: ethClient, + }) + var newHeads evmtestutils.RawSub[*types.Head] select { case newHeads = <-chchNewHeads: diff --git a/core/internal/testutils/evmtest/evmtest.go b/core/internal/testutils/evmtest/evmtest.go index ed8556f590b..a7a053861e9 100644 --- a/core/internal/testutils/evmtest/evmtest.go +++ b/core/internal/testutils/evmtest/evmtest.go @@ -72,6 +72,9 @@ func NewLegacyChains(t testing.TB, testopts TestChainOpts) *legacyevm.LegacyChai lggr, ks, opts := NewChainOpts(t, testopts) cc, err := evmrelay.NewLegacyChainsAndConfig(lggr, ks, opts) require.NoError(t, err) + for _, c := range cc.Slice() { + servicetest.Run(t, c) + } return cc.NewLegacyChains() } diff --git a/core/services/blockhashstore/bhs_test.go b/core/services/blockhashstore/bhs_test.go index 6effae4c914..c6e14d2413c 100644 --- a/core/services/blockhashstore/bhs_test.go +++ b/core/services/blockhashstore/bhs_test.go @@ -1,15 +1,17 @@ package blockhashstore_test import ( + "math/big" "testing" "github.com/ethereum/go-ethereum/common" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "github.com/smartcontractkit/chainlink-common/pkg/logger" "github.com/smartcontractkit/chainlink-evm/gethwrappers/generated/blockhash_store" "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" + "github.com/smartcontractkit/chainlink-evm/pkg/client" "github.com/smartcontractkit/chainlink-evm/pkg/keys" "github.com/smartcontractkit/chainlink-evm/pkg/keys/keystest" "github.com/smartcontractkit/chainlink-evm/pkg/txmgr" @@ -26,7 +28,7 @@ import ( func TestStoreRotatesFromAddresses(t *testing.T) { ctx := testutils.Context(t) db := pgtest.NewSqlxDB(t) - ethClient := clienttest.NewClientWithDefaultChainID(t) + ethClient := client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.Test(t)) cfg := configtest.NewTestGeneralConfig(t) kst := cltest.NewKeyStore(t, db) require.NoError(t, kst.Unlock(ctx, cltest.Password)) diff --git a/core/services/blockhashstore/delegate_test.go b/core/services/blockhashstore/delegate_test.go index 95b3f6f432e..55f977af9da 100644 --- a/core/services/blockhashstore/delegate_test.go +++ b/core/services/blockhashstore/delegate_test.go @@ -2,6 +2,7 @@ package blockhashstore_test import ( "math" + "math/big" "testing" "time" @@ -12,9 +13,10 @@ import ( "go.uber.org/zap/zaptest/observer" "github.com/smartcontractkit/chainlink-common/keystore/corekeys/ethkey" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" + "github.com/smartcontractkit/chainlink-evm/pkg/client" "github.com/smartcontractkit/chainlink-evm/pkg/logpoller" lpmocks "github.com/smartcontractkit/chainlink/v2/common/logpoller/mocks" "github.com/smartcontractkit/chainlink/v2/core/internal/cltest" @@ -39,7 +41,6 @@ func TestDelegate_JobType(t *testing.T) { } type testData struct { - ethClient *clienttest.Client ethKeyStore keystore.Eth legacyChains legacyevm.LegacyChainContainer sendingKey ethkey.KeyV2 @@ -50,16 +51,17 @@ func createTestDelegate(t *testing.T) (*blockhashstore.Delegate, *testData) { t.Helper() lggr, logs := logger.TestLoggerObserved(t, zapcore.DebugLevel) - ethClient := clienttest.NewClientWithDefaultChainID(t) + ethClient := client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.TestLogger(t)) cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.Feature.LogPoller = func(b bool) *bool { return &b }(true) }) db := pgtest.NewSqlxDB(t) kst := cltest.NewKeyStore(t, db).Eth() sendingKey, _ := cltest.MustInsertRandomKey(t, kst) - lp := &lpmocks.LogPoller{} - lp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) - lp.On("LatestBlock", mock.Anything).Return(logpoller.Block{}, nil) + lp := lpmocks.NewLogPoller(t) + servicetest.SetupNoOpMock(lp) + lp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil).Maybe() + lp.On("LatestBlock", mock.Anything).Return(logpoller.Block{}, nil).Maybe() legacyChains := evmtest.NewLegacyChains( t, @@ -75,7 +77,6 @@ func createTestDelegate(t *testing.T) (*blockhashstore.Delegate, *testData) { }, ) return blockhashstore.NewDelegate(cfg, lggr, legacyChains, kst), &testData{ - ethClient: ethClient, ethKeyStore: kst, legacyChains: legacyChains, sendingKey: sendingKey, diff --git a/core/services/directrequest/delegate_test.go b/core/services/directrequest/delegate_test.go index dc783563b8c..4fa3eb3e968 100644 --- a/core/services/directrequest/delegate_test.go +++ b/core/services/directrequest/delegate_test.go @@ -19,9 +19,9 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" "github.com/smartcontractkit/chainlink-common/pkg/utils/mailbox/mailboxtest" + "github.com/smartcontractkit/chainlink-evm/pkg/client" "github.com/smartcontractkit/chainlink-evm/gethwrappers/operatorforwarder/generated/operator" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" "github.com/smartcontractkit/chainlink-evm/pkg/log" log_mocks "github.com/smartcontractkit/chainlink/v2/common/log/mocks" "github.com/smartcontractkit/chainlink/v2/core/bridges" @@ -39,7 +39,7 @@ import ( ) func TestDelegate_ServicesForSpec(t *testing.T) { - ethClient := clienttest.NewClientWithDefaultChainID(t) + ethClient := client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.TestLogger(t)) runner := pipeline_mocks.NewRunner(t) db := pgtest.NewSqlxDB(t) cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { @@ -86,9 +86,10 @@ type DirectRequestUniverse struct { } func NewDirectRequestUniverseWithConfig(t *testing.T, cfg chainlink.GeneralConfig, specF func(spec *job.Job)) *DirectRequestUniverse { - ethClient := clienttest.NewClientWithDefaultChainID(t) - broadcaster := log_mocks.NewBroadcaster(t) + ethClient := client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.TestLogger(t)) runner := pipeline_mocks.NewRunner(t) + broadcaster := log_mocks.NewBroadcaster(t) + servicetest.SetupNoOpMock(broadcaster) broadcaster.On("AddDependents", 1) mailMon := servicetest.Run(t, mailboxtest.NewMonitor(t)) diff --git a/core/services/functions/listener_test.go b/core/services/functions/listener_test.go index 0d4ec259226..826c2ce67f7 100644 --- a/core/services/functions/listener_test.go +++ b/core/services/functions/listener_test.go @@ -23,9 +23,9 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/utils/mailbox/mailboxtest" "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" + "github.com/smartcontractkit/chainlink-evm/pkg/client" evmconfig "github.com/smartcontractkit/chainlink-evm/pkg/config" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" log_mocks "github.com/smartcontractkit/chainlink/v2/common/log/mocks" "github.com/smartcontractkit/chainlink/v2/core/internal/cltest" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils" @@ -80,9 +80,10 @@ func NewFunctionsListenerUniverse(t *testing.T, timeoutSec int, pruneFrequencySe cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].MinIncomingConfirmations = ptr[uint32](1) }) - ethClient := clienttest.NewClientWithDefaultChainID(t) + ethClient := client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.TestLogger(t)) broadcaster := log_mocks.NewBroadcaster(t) broadcaster.On("AddDependents", 1) + servicetest.SetupNoOpMock(broadcaster) mailMon := servicetest.Run(t, mailboxtest.NewMonitor(t)) db := pgtest.NewSqlxDB(t) diff --git a/core/services/job/helpers_test.go b/core/services/job/helpers_test.go index 225dce1f11f..e4c1962c849 100644 --- a/core/services/job/helpers_test.go +++ b/core/services/job/helpers_test.go @@ -18,8 +18,9 @@ import ( "github.com/jmoiron/sqlx" "github.com/smartcontractkit/chainlink-common/keystore/corekeys" + "github.com/smartcontractkit/chainlink-common/pkg/logger" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" + "github.com/smartcontractkit/chainlink-evm/pkg/client" "github.com/smartcontractkit/chainlink/v2/core/internal/cltest" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils/evmtest" @@ -219,7 +220,7 @@ func makeMinimalHTTPOracleSpec(t *testing.T, db *sqlx.DB, cfg chainlink.GeneralC FeatureConfig: cfg.Feature(), ListenerConfig: cfg.Database().Listener(), DB: db, - Client: clienttest.NewClientWithDefaultChainID(t), + Client: client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.Test(t)), KeyStore: keyStore.Eth(), }) _, err := ocr.ValidatedOracleSpecToml(cfg, legacyChains, s) diff --git a/core/services/job/job_pipeline_orm_integration_test.go b/core/services/job/job_pipeline_orm_integration_test.go index 2a2e17674ba..98bccd92e64 100644 --- a/core/services/job/job_pipeline_orm_integration_test.go +++ b/core/services/job/job_pipeline_orm_integration_test.go @@ -1,6 +1,7 @@ package job_test import ( + "math/big" "testing" "time" @@ -11,8 +12,8 @@ import ( commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" + "github.com/smartcontractkit/chainlink-evm/pkg/client" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" "github.com/smartcontractkit/chainlink/v2/core/bridges" "github.com/smartcontractkit/chainlink/v2/core/internal/cltest" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils" @@ -160,7 +161,7 @@ func TestPipelineORM_Integration(t *testing.T) { DatabaseConfig: config.Database(), FeatureConfig: config.Feature(), ListenerConfig: config.Database().Listener(), - Client: clienttest.NewClientWithDefaultChainID(t), + Client: client.NewNullClient(big.NewInt(evmtest.NullClientChainID), logger.TestLogger(t)), DB: db, KeyStore: keyStore.Eth(), }) diff --git a/core/services/job/runner_integration_test.go b/core/services/job/runner_integration_test.go index 71b87b5225c..54569026246 100644 --- a/core/services/job/runner_integration_test.go +++ b/core/services/job/runner_integration_test.go @@ -76,9 +76,11 @@ func TestRunner(t *testing.T) { c.Insecure.OCRDevelopmentMode = ptr(true) }) - ethClient := cltest.NewEthMocksWithDefaultChain(t) + ethClient := cltest.NewEthMocksWithStartupAssertions(t) + ethClient.On("ConfiguredChainID").Return(testutils.FixtureChainID).Maybe() ethClient.On("HeadByNumber", mock.Anything, (*big.Int)(nil)).Return(cltest.Head(10), nil) ethClient.On("CallContract", mock.Anything, mock.Anything, mock.Anything).Maybe().Return(nil, nil) + ethClient.On("BalanceAt", mock.Anything, mock.Anything, mock.Anything).Return(big.NewInt(0), nil).Maybe() pipelineORM := pipeline.NewORM(db, logger.TestLogger(t), config.JobPipeline().MaxSuccessfulRuns()) require.NoError(t, pipelineORM.Start(ctx)) diff --git a/core/services/job/spawner_test.go b/core/services/job/spawner_test.go index 26172f275ee..4170be90317 100644 --- a/core/services/job/spawner_test.go +++ b/core/services/job/spawner_test.go @@ -2,6 +2,7 @@ package job_test import ( "context" + "math/big" "testing" "time" @@ -92,13 +93,15 @@ func TestSpawner_CreateJobDeleteJob(t *testing.T) { _, bridge := cltest.MustCreateBridge(t, db, cltest.BridgeOpts{}) _, bridge2 := cltest.MustCreateBridge(t, db, cltest.BridgeOpts{}) - ethClient := cltest.NewEthMocksWithDefaultChain(t) + ethClient := cltest.NewEthMocksWithStartupAssertions(t) + ethClient.On("ConfiguredChainID").Return(testutils.FixtureChainID).Maybe() ethClient.On("CallContext", mock.Anything, mock.Anything, "eth_getBlockByNumber", mock.Anything, false). Run(func(args mock.Arguments) { head := args.Get(1).(**evmtypes.Head) *head = cltest.Head(10) }). Return(nil).Maybe() + ethClient.On("BalanceAt", mock.Anything, mock.Anything, mock.Anything).Return(big.NewInt(0), nil).Maybe() legacyChains := evmtest.NewLegacyChains(t, evmtest.TestChainOpts{ DB: db, @@ -284,7 +287,8 @@ func TestSpawner_CreateJobDeleteJob(t *testing.T) { config = configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.Feature.LogPoller = func(b bool) *bool { return &b }(true) }) - lp := &lpmocks.LogPoller{} + lp := lpmocks.NewLogPoller(t) + servicetest.SetupNoOpMock(lp) csaKeystore := &keystore.CSASigner{CSA: keyStore.CSA()} testopts := evmtest.TestChainOpts{ @@ -329,6 +333,7 @@ func TestSpawner_CreateJobDeleteJob(t *testing.T) { spawner := job.NewSpawner(orm, config.Database(), noopChecker{}, map[job.Type]job.Delegate{ jobOCR2Keeper.Type: delegateOCR2, }, lggr, nil) + servicetest.Run(t, spawner) ctx := testutils.Context(t) err = spawner.CreateJob(ctx, nil, jobOCR2Keeper) @@ -344,9 +349,6 @@ func TestSpawner_CreateJobDeleteJob(t *testing.T) { require.NoError(t, err) lp.AssertNumberOfCalls(t, "UnregisterFilter", 6) - - lp.On("Close").Return(nil).Once() - spawner.Close() }) } diff --git a/core/services/keeper/registry1_3_synchronizer_test.go b/core/services/keeper/registry1_3_synchronizer_test.go index faec78dd709..fb4c0997649 100644 --- a/core/services/keeper/registry1_3_synchronizer_test.go +++ b/core/services/keeper/registry1_3_synchronizer_test.go @@ -260,6 +260,8 @@ func Test_RegistrySynchronizer1_3_ConfigSetLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryConfigSet{} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -311,6 +313,8 @@ func Test_RegistrySynchronizer1_3_KeepersUpdatedLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryKeepersUpdated{} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -353,6 +357,8 @@ func Test_RegistrySynchronizer1_3_UpkeepCanceledLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryUpkeepCanceled{Id: big.NewInt(3)} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -395,6 +401,8 @@ func Test_RegistrySynchronizer1_3_UpkeepRegisteredLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryUpkeepRegistered{Id: big.NewInt(420)} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -438,6 +446,8 @@ func Test_RegistrySynchronizer1_3_UpkeepPerformedLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash, BlockNumber: 200} log := registry1_3.KeeperRegistryUpkeepPerformed{Id: big.NewInt(3), From: fromAddress} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -503,6 +513,8 @@ func Test_RegistrySynchronizer1_3_UpkeepGasLimitSetLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryUpkeepGasLimitSet{Id: big.NewInt(3), GasLimit: big.NewInt(4_000_000)} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -545,6 +557,8 @@ func Test_RegistrySynchronizer1_3_UpkeepReceivedLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryUpkeepReceived{Id: big.NewInt(420)} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -584,6 +598,8 @@ func Test_RegistrySynchronizer1_3_UpkeepMigratedLog(t *testing.T) { rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryUpkeepMigrated{Id: big.NewInt(3)} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -625,6 +641,8 @@ func Test_RegistrySynchronizer1_3_UpkeepPausedLog_UpkeepUnpausedLog(t *testing.T rawLog := types.Log{BlockHash: head.Hash} log := registry1_3.KeeperRegistryUpkeepPaused{Id: upkeepId} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&log) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") @@ -700,6 +718,8 @@ func Test_RegistrySynchronizer1_3_UpkeepCheckDataUpdatedLog(t *testing.T) { updatedLog := registry1_3.KeeperRegistryUpkeepCheckDataUpdated{Id: upkeepId, NewCheckData: newCheckData} logBroadcast := logmocks.NewBroadcast(t) + logBroadcast.On("Start").Return(nil).Maybe() + logBroadcast.On("Close").Return(nil).Maybe() logBroadcast.On("DecodedLog").Return(&updatedLog) logBroadcast.On("RawLog").Return(rawLog) logBroadcast.On("String").Maybe().Return("") diff --git a/core/services/keeper/registry_synchronizer_helper_test.go b/core/services/keeper/registry_synchronizer_helper_test.go index 89eccefa01a..08edda55391 100644 --- a/core/services/keeper/registry_synchronizer_helper_test.go +++ b/core/services/keeper/registry_synchronizer_helper_test.go @@ -1,6 +1,7 @@ package keeper_test import ( + "math/big" "testing" "time" @@ -12,7 +13,6 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/utils/mailbox/mailboxtest" - "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" "github.com/smartcontractkit/chainlink-evm/pkg/log" logmocks "github.com/smartcontractkit/chainlink/v2/common/log/mocks" @@ -38,9 +38,11 @@ func setupRegistrySync(t *testing.T, version keeper.RegistryVersion) ( db := pgtest.NewSqlxDB(t) cfg := configtest.NewGeneralConfig(t, nil) korm := keeper.NewORM(db, logger.TestLogger(t)) - ethClient := clienttest.NewClientWithDefaultChainID(t) + ethClient := cltest.NewEthMocksWithStartupAssertions(t) + ethClient.On("ConfiguredChainID").Return(big.NewInt(evmtest.NullClientChainID)).Maybe() keyStore := cltest.NewKeyStore(t, db) lbMock := logmocks.NewBroadcaster(t) + servicetest.SetupNoOpMock(lbMock) lbMock.On("AddDependents", 1).Maybe() j := cltest.MustInsertKeeperJob(t, db, korm, cltest.NewEIP55Address(), cltest.NewEIP55Address()) legacyChains := evmtest.NewLegacyChains(t, evmtest.TestChainOpts{ diff --git a/core/services/keeper/upkeep_executer_test.go b/core/services/keeper/upkeep_executer_test.go index 9810dac6120..6f6d04887e0 100644 --- a/core/services/keeper/upkeep_executer_test.go +++ b/core/services/keeper/upkeep_executer_test.go @@ -63,11 +63,13 @@ func setup(t *testing.T, overrideFn func(c *chainlink.Config, s *chainlink.Secre }) db := pgtest.NewSqlxDB(t) keyStore := cltest.NewKeyStore(t, db) - ethClient := evmtest.NewEthClientMock(t) + ethClient := cltest.NewEthMocksWithStartupAssertions(t) ethClient.On("ConfiguredChainID").Return(cfg.EVMConfigs()[0].ChainID.ToInt()).Maybe() ethClient.On("IsL2").Return(false).Maybe() ethClient.On("HeadByNumber", mock.Anything, mock.Anything).Maybe().Return(&evmtypes.Head{Number: 1, Hash: utils.NewHash()}, nil) txm := txmmocks.NewMockEvmTxManager(t) + servicetest.SetupNoOpMock(txm) + txm.On("OnNewLongestChain", mock.Anything, mock.Anything).Return().Maybe() legacyChains := evmtest.NewLegacyChains(t, evmtest.TestChainOpts{ TxManager: txm, DB: db, diff --git a/core/services/ocr2/delegate_test.go b/core/services/ocr2/delegate_test.go index 27c82271426..ca5676a0eb5 100644 --- a/core/services/ocr2/delegate_test.go +++ b/core/services/ocr2/delegate_test.go @@ -9,6 +9,7 @@ import ( "github.com/stretchr/testify/require" "gopkg.in/guregu/null.v4" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" "github.com/smartcontractkit/chainlink-common/pkg/types" "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" @@ -51,6 +52,7 @@ func TestGetEVMEffectiveTransmitterID(t *testing.T) { lggr := logger.TestLogger(t) txManager := txmmocks.NewMockEvmTxManager(t) + servicetest.SetupNoOpMock(txManager) legacyChains := evmtest.NewLegacyChains(t, evmtest.TestChainOpts{ DB: db, ChainConfigs: config.EVMConfigs(), diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v20/registry_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v20/registry_test.go index 4c6ade2233b..49280dfe141 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v20/registry_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v20/registry_test.go @@ -188,7 +188,7 @@ func TestPollLogs(t *testing.T) { for _, test := range tests { t.Run(test.Name, func(t *testing.T) { ctx := testutils.Context(t) - mp := new(mocks.LogPoller) + mp := mocks.NewLogPoller(t) if test.LatestBlock != nil { mp.On("LatestBlock", mock.Anything). diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/block_subscriber_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/block_subscriber_test.go index c550bc43700..2be56d4c9e5 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/block_subscriber_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/block_subscriber_test.go @@ -97,7 +97,7 @@ func TestBlockSubscriber_GetBlockRange(t *testing.T) { for _, tc := range tests { t.Run(tc.Name, func(t *testing.T) { - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) lp.On("LatestBlock", mock.Anything).Return(logpoller.Block{BlockNumber: tc.LatestBlock}, tc.LatestBlockErr) bs := NewBlockSubscriber(hb, lp, finality, lggr) bs.blockHistorySize = historySize @@ -155,7 +155,7 @@ func TestBlockSubscriber_InitializeBlocks(t *testing.T) { for _, tc := range tests { t.Run(tc.Name, func(t *testing.T) { - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) lp.On("GetBlocksRange", mock.Anything, tc.Blocks).Return(tc.PollerBlocks, tc.Error) bs := NewBlockSubscriber(hb, lp, finality, lggr) bs.blockHistorySize = historySize @@ -179,7 +179,7 @@ func TestBlockSubscriber_InitializeBlocks(t *testing.T) { func TestBlockSubscriber_BuildHistory(t *testing.T) { lggr := logger.TestLogger(t) var hb heads.Broadcaster - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) tests := []struct { Name string @@ -229,7 +229,7 @@ func TestBlockSubscriber_BuildHistory(t *testing.T) { func TestBlockSubscriber_Cleanup(t *testing.T) { lggr := logger.TestLogger(t) var hb heads.Broadcaster - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) tests := []struct { Name string @@ -278,7 +278,7 @@ func TestBlockSubscriber_Start(t *testing.T) { lggr := logger.TestLogger(t) hb := headstest.NewBroadcaster[*evmtypes.Head, common.Hash](t) hb.On("Subscribe", mock.Anything).Return(&evmtypes.Head{Number: 42}, func() {}) - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) lp.On("LatestBlock", mock.Anything).Return(logpoller.Block{BlockNumber: 100}, nil) blocks := []uint64{97, 98, 99, 100} pollerBlocks := []logpoller.Block{ diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_life_cycle_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_life_cycle_test.go index 5da9b1b6f59..92a453463e2 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_life_cycle_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_life_cycle_test.go @@ -11,6 +11,7 @@ import ( "github.com/stretchr/testify/require" "github.com/smartcontractkit/chainlink-automation/pkg/v3/types" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-evm/pkg/logpoller" "github.com/smartcontractkit/chainlink/v2/common/logpoller/mocks" @@ -107,19 +108,14 @@ func TestLogEventProvider_LifeCycle(t *testing.T) { ctx := testutils.Context(t) if tc.mockPoller { - lp := new(mocks.LogPoller) - lp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) - lp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil) - lp.On("LatestBlock", mock.Anything).Return(logpoller.Block{}, nil) - hasFitlerTimes := 1 - if tc.unregister { - hasFitlerTimes = 2 - } - lp.On("HasFilter", p.filterName(tc.upkeepID)).Return(tc.hasFilter).Times(hasFitlerTimes) + lp := mocks.NewLogPoller(t) + servicetest.SetupNoOpMock(lp) + lp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil).Maybe() + lp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil).Maybe() + lp.On("LatestBlock", mock.Anything).Return(logpoller.Block{}, nil).Maybe() + lp.On("HasFilter", p.filterName(tc.upkeepID)).Return(tc.hasFilter).Maybe() if tc.replyed { lp.On("ReplayAsync", mock.Anything).Return(nil).Times(1) - } else { - lp.On("ReplayAsync", mock.Anything).Return(nil).Times(0) } p.lock.Lock() p.poller = lp @@ -145,9 +141,8 @@ func TestLogEventProvider_LifeCycle(t *testing.T) { func TestEventLogProvider_RefreshActiveUpkeeps(t *testing.T) { ctx := testutils.Context(t) - mp := new(mocks.LogPoller) + mp := mocks.NewLogPoller(t) mp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) - mp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil) mp.On("HasFilter", mock.Anything).Return(false) mp.On("LatestBlock", mock.Anything).Return(logpoller.Block{}, nil) mp.On("ReplayAsync", mock.Anything).Return(nil) diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_test.go index dd132506ff4..e3b1d00b31a 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider/provider_test.go @@ -109,7 +109,7 @@ func TestLogEventProvider_UpdateEntriesLastPoll(t *testing.T) { } func TestLogEventProvider_ScheduleReadJobs(t *testing.T) { - mp := new(mocks.LogPoller) + mp := mocks.NewLogPoller(t) tests := []struct { name string @@ -241,19 +241,19 @@ func TestLogEventProvider_ScheduleReadJobs(t *testing.T) { func TestLogEventProvider_ReadLogs(t *testing.T) { ctx := testutils.Context(t) - mp := new(mocks.LogPoller) + mp := mocks.NewLogPoller(t) mp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) mp.On("ReplayAsync", mock.Anything).Return() mp.On("HasFilter", mock.Anything).Return(false) - mp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil) + mp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil).Maybe() mp.On("LatestBlock", mock.Anything).Return(logpoller.Block{BlockNumber: int64(1)}, nil) mp.On("LogsWithSigs", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return([]logpoller.Log{ { BlockNumber: 1, TxHash: common.HexToHash("0x1"), }, - }, nil) + }, nil).Maybe() filterStore := NewUpkeepFilterStore() p := NewLogProvider(logger.TestLogger(t), mp, big.NewInt(1), &mockedPacker{}, filterStore, NewOptions(200, big.NewInt(1))) diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/registry_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/registry_test.go index be20b8f0a2a..0b1af526557 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/registry_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/registry_test.go @@ -189,7 +189,7 @@ func TestPollLogs(t *testing.T) { for _, test := range tests { t.Run(test.Name, func(t *testing.T) { ctx := testutils.Context(t) - mp := new(mocks.LogPoller) + mp := mocks.NewLogPoller(t) if test.LatestBlock != nil { mp.On("LatestBlock", mock.Anything). diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/transmit/event_provider_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/transmit/event_provider_test.go index fb25ad2dda2..59f62bb6373 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/transmit/event_provider_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/transmit/event_provider_test.go @@ -26,7 +26,7 @@ import ( func TestTransmitEventProvider_Sanity(t *testing.T) { ctx := testutils.Context(t) - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) lp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) @@ -101,7 +101,7 @@ func TestTransmitEventProvider_Sanity(t *testing.T) { } func TestTransmitEventProvider_ProcessLogs(t *testing.T) { - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) lp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) client := clienttest.NewClient(t) ctx := testutils.Context(t) diff --git a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/upkeepstate/scanner_test.go b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/upkeepstate/scanner_test.go index 6c78e019717..949b12477cd 100644 --- a/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/upkeepstate/scanner_test.go +++ b/core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/upkeepstate/scanner_test.go @@ -82,9 +82,9 @@ func TestPerformedEventsScanner(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - mp := new(mocks.LogPoller) - mp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) - mp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil) + mp := mocks.NewLogPoller(t) + mp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil).Maybe() + mp.On("UnregisterFilter", mock.Anything, mock.Anything).Return(nil).Maybe() scanner := NewPerformedEventsScanner(lggr, mp, registryAddr, 100) go func() { @@ -94,7 +94,7 @@ func TestPerformedEventsScanner(t *testing.T) { _ = scanner.Close() }() - mp.On("IndexedLogs", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tc.pollerResults, tc.pollerErr) + mp.On("IndexedLogs", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tc.pollerResults, tc.pollerErr).Maybe() results, err := scanner.ScanWorkIDs(ctx, tc.workIDs...) if tc.errored { @@ -115,7 +115,7 @@ func TestPerformedEventsScanner_Batch(t *testing.T) { ctx := testutils.Context(t) registryAddr := common.HexToAddress("0x12345") lggr := logger.TestLogger(t) - lp := new(mocks.LogPoller) + lp := mocks.NewLogPoller(t) scanner := NewPerformedEventsScanner(lggr, lp, registryAddr, 100) lp.On("IndexedLogs", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return([]logpoller.Log{ diff --git a/core/services/pipeline/task.eth_call_test.go b/core/services/pipeline/task.eth_call_test.go index e7d42a7ef1b..228504e2326 100644 --- a/core/services/pipeline/task.eth_call_test.go +++ b/core/services/pipeline/task.eth_call_test.go @@ -11,6 +11,7 @@ import ( "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-evm/pkg/chains" "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" @@ -306,7 +307,9 @@ func TestETHCallTask(t *testing.T) { lggr := logger.TestLogger(t) keyStore := keystoremocks.NewEth(t) + keyStore.On("EnabledAddressesForChain", mock.Anything, testutils.FixtureChainID).Return([]common.Address{}, nil).Maybe() txManager := txmmocks.NewMockEvmTxManager(t) + servicetest.SetupNoOpMock(txManager) db := pgtest.NewSqlxDB(t) var legacyChains legacyevm.LegacyChainContainer diff --git a/core/services/pipeline/task.eth_tx_test.go b/core/services/pipeline/task.eth_tx_test.go index ad7093436db..6b5fe14eb60 100644 --- a/core/services/pipeline/task.eth_tx_test.go +++ b/core/services/pipeline/task.eth_tx_test.go @@ -10,6 +10,7 @@ import ( "github.com/stretchr/testify/require" "gopkg.in/guregu/null.v4" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" clnull "github.com/smartcontractkit/chainlink-common/pkg/utils/null" "github.com/smartcontractkit/chainlink-evm/pkg/chains" "github.com/smartcontractkit/chainlink-evm/pkg/txmgr" @@ -570,7 +571,9 @@ func TestETHTxTask(t *testing.T) { } keyStore := keystoremocks.NewEth(t) + keyStore.On("EnabledAddressesForChain", mock.Anything, testutils.FixtureChainID).Return([]common.Address{}, nil) txManager := txmmocks.NewMockEvmTxManager(t) + servicetest.SetupNoOpMock(txManager) db := pgtest.NewSqlxDB(t) cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].GasEstimator.LimitDefault = ptr(defaultGasLimit) diff --git a/core/services/relay/evm/config_poller_test.go b/core/services/relay/evm/config_poller_test.go index b3efccd8755..af2b8fd37b6 100644 --- a/core/services/relay/evm/config_poller_test.go +++ b/core/services/relay/evm/config_poller_test.go @@ -185,7 +185,7 @@ func TestConfigPoller(t *testing.T) { t.Run("LatestConfigDetails, when logs have been pruned and config store contract is configured", func(t *testing.T) { // Give it a log poller that will never return logs - mp := new(mocks.LogPoller) + mp := mocks.NewLogPoller(t) mp.On("RegisterFilter", mock.Anything, mock.Anything).Return(nil) mp.On("LatestLogByEventSigWithConfs", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, sql.ErrNoRows) diff --git a/core/services/vrf/delegate_test.go b/core/services/vrf/delegate_test.go index 77a8a8ae44b..3a703ccfa4c 100644 --- a/core/services/vrf/delegate_test.go +++ b/core/services/vrf/delegate_test.go @@ -15,22 +15,24 @@ import ( "github.com/stretchr/testify/require" commonkeystore "github.com/smartcontractkit/chainlink-common/keystore" + "github.com/smartcontractkit/chainlink-common/keystore/corekeys/vrfkey" + "github.com/smartcontractkit/chainlink-common/keystore/corekeys/vrfkey/secp256k1" "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/utils/mailbox/mailboxtest" - "github.com/smartcontractkit/chainlink-evm/pkg/keys" - + "github.com/smartcontractkit/chainlink-evm/gethwrappers/generated/solidity_vrf_coordinator_interface" "github.com/smartcontractkit/chainlink-evm/pkg/assets" + "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" "github.com/smartcontractkit/chainlink-evm/pkg/client/clienttest" + "github.com/smartcontractkit/chainlink-evm/pkg/gas" "github.com/smartcontractkit/chainlink-evm/pkg/heads" + "github.com/smartcontractkit/chainlink-evm/pkg/heads/headstest" + "github.com/smartcontractkit/chainlink-evm/pkg/keys" + "github.com/smartcontractkit/chainlink-evm/pkg/log" + "github.com/smartcontractkit/chainlink-evm/pkg/logpoller" + "github.com/smartcontractkit/chainlink-evm/pkg/txmgr" evmtypes "github.com/smartcontractkit/chainlink-evm/pkg/types" evmutils "github.com/smartcontractkit/chainlink-evm/pkg/utils" - "github.com/smartcontractkit/chainlink-common/keystore/corekeys/vrfkey" - "github.com/smartcontractkit/chainlink-common/keystore/corekeys/vrfkey/secp256k1" - "github.com/smartcontractkit/chainlink-evm/gethwrappers/generated/solidity_vrf_coordinator_interface" - "github.com/smartcontractkit/chainlink-evm/pkg/chains/legacyevm" - "github.com/smartcontractkit/chainlink-evm/pkg/log" - "github.com/smartcontractkit/chainlink-evm/pkg/txmgr" log_mocks "github.com/smartcontractkit/chainlink/v2/common/log/mocks" "github.com/smartcontractkit/chainlink/v2/core/bridges" "github.com/smartcontractkit/chainlink/v2/core/internal/cltest" @@ -70,9 +72,10 @@ func buildVrfUni(t *testing.T, db *sqlx.DB, cfg chainlink.GeneralConfig) vrfUniv ctx := testutils.Context(t) // Mock all chain interactions lb := log_mocks.NewBroadcaster(t) + servicetest.SetupNoOpMock(lb) lb.On("AddDependents", 1).Maybe() lb.On("Register", mock.Anything, mock.Anything).Return(func() {}).Maybe() - ec := clienttest.NewClient(t) + ec := cltest.NewEthMocksWithStartupAssertions(t) ec.On("ConfiguredChainID").Return(testutils.FixtureChainID) ec.On("LatestBlockHeight", mock.Anything).Return(big.NewInt(51), nil).Maybe() lggr := logger.TestLogger(t) @@ -82,9 +85,22 @@ func buildVrfUni(t *testing.T, db *sqlx.DB, cfg chainlink.GeneralConfig) vrfUniv prm := pipeline.NewORM(db, lggr, cfg.JobPipeline().MaxSuccessfulRuns()) btORM := bridges.NewORM(db) ks := keystore.NewInMemory(db, commonkeystore.FastScryptParams, lggr.Infof) + require.NoError(t, ks.Unlock(ctx, testutils.Password)) _, dbConfig, evmConfig := txmgr.MakeTestConfigs(t) evmKs := keys.NewChainStore(keystore.NewEthSigner(ks.Eth(), ec.ConfiguredChainID()), ec.ConfiguredChainID()) - txm, err := txmgr.NewTxm(db, evmConfig, evmConfig.GasEstimator(), evmConfig.Transactions(), nil, dbConfig, dbConfig.Listener(), ec, logger.TestLogger(t), nil, evmKs, nil, nil, nil, false) + estimator, err := gas.NewEstimator(logger.TestLogger(t), ec, evmConfig.ChainType(), ec.ConfiguredChainID(), evmConfig.GasEstimator(), nil) + require.NoError(t, err) + lpOpts := logpoller.Opts{ + PollPeriod: 100 * time.Millisecond, + FinalityDepth: 2, + BackfillBatchSize: 3, + RPCBatchSize: 2, + KeepFinalizedBlocksDepth: 1000, + } + ht := headstest.NewSimulatedHeadTracker(ec, lpOpts.UseFinalityTag, lpOpts.FinalityDepth) + lp := logpoller.NewLogPoller(logpoller.NewORM(testutils.FixtureChainID, db, lggr), ec, lggr, ht, lpOpts) + txm, err := txmgr.NewTxm(db, evmConfig, evmConfig.GasEstimator(), evmConfig.Transactions(), nil, dbConfig, dbConfig.Listener(), ec, logger.TestLogger(t), lp, evmKs, estimator, nil, nil, false) + require.NoError(t, err) orm := heads.NewORM(*testutils.FixtureChainID, db, 0) require.NoError(t, orm.IdempotentInsertHead(testutils.Context(t), cltest.Head(51))) jrm := job.NewORM(db, prm, btORM, ks, lggr) diff --git a/core/services/vrf/v2/integration_v2_test.go b/core/services/vrf/v2/integration_v2_test.go index fc609b2e649..2ca7f81b7bd 100644 --- a/core/services/vrf/v2/integration_v2_test.go +++ b/core/services/vrf/v2/integration_v2_test.go @@ -32,6 +32,7 @@ import ( commonkeystore "github.com/smartcontractkit/chainlink-common/keystore" commonassets "github.com/smartcontractkit/chainlink-common/pkg/assets" commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" commontypes "github.com/smartcontractkit/chainlink-common/pkg/types" "github.com/smartcontractkit/chainlink-common/pkg/utils/tests" @@ -46,6 +47,8 @@ import ( evmutils "github.com/smartcontractkit/chainlink-evm/pkg/utils" txmgrcommon "github.com/smartcontractkit/chainlink-framework/chains/txmgr" txmgrtypes "github.com/smartcontractkit/chainlink-framework/chains/txmgr/types" + mocks2 "github.com/smartcontractkit/chainlink/v2/common/txmgr/mocks" + "github.com/smartcontractkit/chainlink/v2/common/txmgr/types/mocks" "github.com/smartcontractkit/chainlink-common/keystore/corekeys/ethkey" "github.com/smartcontractkit/chainlink-common/keystore/corekeys/vrfkey" @@ -144,8 +147,19 @@ func makeTestTxm(t *testing.T, txStore txmgr.TestEvmTxStore, keyStore keystore.E _, _, evmConfig := txmgr.MakeTestConfigs(t) txmConfig := txmgr.NewEvmTxmConfig(evmConfig) ks := keys.NewStore(keystore.NewEthSigner(keyStore, ec.ConfiguredChainID())) + builder := mocks.NewTxAttemptBuilder[*big.Int, *types.Head, common.Address, common.Hash, common.Hash, types.Nonce, gas.EvmFee](t) + servicetest.SetupNoOpMock(builder) + broadcaster := mocks2.NewBroadcaster[common.Address](t) + servicetest.SetupNoOpMock(broadcaster) + confirmer := mocks2.NewConfirmer[*types.Head, common.Address, common.Hash](t) + servicetest.SetupNoOpMock(confirmer) + tracker := mocks2.NewTracker[common.Address](t) + servicetest.SetupNoOpMock(tracker) + tracker.On("GetEnabledAddresses").Return(nil).Maybe() + finalizer := mocks.NewFinalizer[common.Hash, *types.Head](t) + servicetest.SetupNoOpMock(finalizer) txm := txmgr.NewEvmTxm(ec.ConfiguredChainID(), txmConfig, evmConfig.Transactions(), ks, logger.TestLogger(t), nil, nil, - nil, txStore, nil, nil, nil, nil, nil, nil, false) + builder, txStore, broadcaster, confirmer, nil, tracker, finalizer, nil, false) return txm } @@ -2107,11 +2121,13 @@ func TestFulfillmentCost(t *testing.T) { func TestStartingCountsV1(t *testing.T) { cfg, db := heavyweight.FullTestDBNoFixturesV2(t, nil) - ctx := testutils.Context(t) + ctx := t.Context() txStore := txmgr.NewTxStore(db, logger.TestLogger(t)) lggr := logger.TestLogger(t) ks := keystore.NewInMemory(db, commonkeystore.FastScryptParams, lggr.Infof) ec := clienttest.NewClient(t) + ec.On("Dial", mock.Anything).Maybe().Return(nil) + ec.On("Close").Maybe().Return(nil) ec.On("ConfiguredChainID").Return(testutils.SimulatedChainID) ec.On("LatestBlockHeight", mock.Anything).Return(big.NewInt(2), nil).Maybe() txm := makeTestTxm(t, txStore, ks.Eth(), ec) diff --git a/core/services/vrf/v2/listener_v2_test.go b/core/services/vrf/v2/listener_v2_test.go index 0ce1e496aa1..3764dcc5f7d 100644 --- a/core/services/vrf/v2/listener_v2_test.go +++ b/core/services/vrf/v2/listener_v2_test.go @@ -13,6 +13,7 @@ import ( "github.com/stretchr/testify/require" commonkeystore "github.com/smartcontractkit/chainlink-common/keystore" + "github.com/smartcontractkit/chainlink-common/pkg/services/servicetest" "github.com/smartcontractkit/chainlink-common/pkg/sqlutil" clnull "github.com/smartcontractkit/chainlink-common/pkg/utils/null" "github.com/smartcontractkit/chainlink-evm/gethwrappers/generated/vrf_coordinator_v2" @@ -25,6 +26,8 @@ import ( txmgrcommon "github.com/smartcontractkit/chainlink-framework/chains/txmgr" txmgrtypes "github.com/smartcontractkit/chainlink-framework/chains/txmgr/types" evmmocks "github.com/smartcontractkit/chainlink/v2/common/chains/mocks" + mocks2 "github.com/smartcontractkit/chainlink/v2/common/txmgr/mocks" + "github.com/smartcontractkit/chainlink/v2/common/txmgr/types/mocks" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils/pgtest" "github.com/smartcontractkit/chainlink/v2/core/logger" @@ -39,8 +42,19 @@ func makeTestTxm(t *testing.T, txStore txmgr.TestEvmTxStore, keyStore keystore.M ec := clienttest.NewClientWithDefaultChainID(t) txmConfig := txmgr.NewEvmTxmConfig(evmConfig) ks := keys.NewChainStore(keystore.NewEthSigner(keyStore.Eth(), ec.ConfiguredChainID()), ec.ConfiguredChainID()) + builder := mocks.NewTxAttemptBuilder[*big.Int, *evmtypes.Head, common.Address, common.Hash, common.Hash, evmtypes.Nonce, gas.EvmFee](t) + servicetest.SetupNoOpMock(builder) + broadcaster := mocks2.NewBroadcaster[common.Address](t) + servicetest.SetupNoOpMock(broadcaster) + confirmer := mocks2.NewConfirmer[*evmtypes.Head, common.Address, common.Hash](t) + servicetest.SetupNoOpMock(confirmer) + tracker := mocks2.NewTracker[common.Address](t) + servicetest.SetupNoOpMock(tracker) + tracker.On("GetEnabledAddresses").Return(nil).Maybe() + finalizer := mocks.NewFinalizer[common.Hash, *evmtypes.Head](t) + servicetest.SetupNoOpMock(finalizer) txm := txmgr.NewEvmTxm(ec.ConfiguredChainID(), txmConfig, evmConfig.Transactions(), ks, logger.TestLogger(t), nil, nil, - nil, txStore, nil, nil, nil, nil, nil, nil, false) + builder, txStore, broadcaster, confirmer, nil, tracker, finalizer, nil, false) return txm } diff --git a/core/web/eth_keys_controller_test.go b/core/web/eth_keys_controller_test.go index dd756f86de2..a898d12d2dd 100644 --- a/core/web/eth_keys_controller_test.go +++ b/core/web/eth_keys_controller_test.go @@ -31,7 +31,6 @@ func TestETHKeysController_Index_Success(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -82,7 +81,6 @@ func TestETHKeysController_Index_Errors(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -153,7 +151,6 @@ func TestETHKeysController_Index_NotDev(t *testing.T) { t.Parallel() ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -250,7 +247,6 @@ func TestETHKeysController_ChainSuccess_UpdateNonce(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -292,7 +288,6 @@ func TestETHKeysController_ChainSuccess_Disable(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -454,7 +449,6 @@ func TestETHKeysController_ChainFailure_InvalidAbandon(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -488,7 +482,6 @@ func TestETHKeysController_ChainFailure_InvalidEnabled(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -609,7 +602,6 @@ func TestETHKeysController_ChainFailure_MissingChainID(t *testing.T) { ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) @@ -641,7 +633,6 @@ func TestETHKeysController_DeleteSuccess(t *testing.T) { t.Parallel() ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Twice() cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.EVM[0].NonceAutoSync = ptr(false) c.EVM[0].BalanceMonitor.Enabled = ptr(false) diff --git a/core/web/jobs_controller_test.go b/core/web/jobs_controller_test.go index 9fbb08435a7..0cd63741189 100644 --- a/core/web/jobs_controller_test.go +++ b/core/web/jobs_controller_test.go @@ -813,10 +813,9 @@ func setupJobsControllerTests(t *testing.T) (ta *cltest.TestApplication, cc clte func setupEthClientForControllerTests(t *testing.T) *clienttest.Client { ec := cltest.NewEthMocksWithStartupAssertions(t) - ec.On("PendingNonceAt", mock.Anything, mock.Anything).Return(uint64(0), nil).Maybe() - ec.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() ec.On("LatestBlockHeight", mock.Anything).Return(big.NewInt(100), nil).Maybe() ec.On("BalanceAt", mock.Anything, mock.Anything, mock.Anything).Once().Return(big.NewInt(0), nil).Maybe() + ec.On("CallContract", mock.Anything, mock.Anything, mock.Anything).Return(nil, nil).Maybe() return ec } diff --git a/core/web/pipeline_runs_controller_test.go b/core/web/pipeline_runs_controller_test.go index 395298d81bb..d509e51ae9e 100644 --- a/core/web/pipeline_runs_controller_test.go +++ b/core/web/pipeline_runs_controller_test.go @@ -255,7 +255,7 @@ func setupPipelineRunsControllerTests(t *testing.T) (cltest.HTTPClientCleaner, i t.Parallel() ctx := testutils.Context(t) ethClient := cltest.NewEthMocksWithStartupAssertions(t) - ethClient.On("NonceAt", mock.Anything, mock.Anything, mock.Anything).Return(uint64(0), nil).Once() + ethClient.On("CallContract", mock.Anything, mock.Anything, mock.Anything).Maybe().Return(nil, nil) cfg := configtest.NewGeneralConfig(t, func(c *chainlink.Config, s *chainlink.Secrets) { c.OCR.Enabled = ptr(true) c.P2P.V2.Enabled = ptr(true)