From fa7c01bd0b870949a939f2173018ad0037f0f53c Mon Sep 17 00:00:00 2001 From: Denis Kirillov Date: Thu, 25 Nov 2021 11:28:23 +0300 Subject: [PATCH] [#74] Fix some tests For some tests enough empty results. Signed-off-by: Denis Kirillov --- pool/mock_test.go | 319 ++++++++++++++++++++++++++++++++++++++++--- pool/pool_test.go | 6 +- pool/sampler_test.go | 22 +-- 3 files changed, 311 insertions(+), 36 deletions(-) diff --git a/pool/mock_test.go b/pool/mock_test.go index 796c2ad..ae42ece 100644 --- a/pool/mock_test.go +++ b/pool/mock_test.go @@ -5,15 +5,21 @@ package pool import ( + context "context" + io "io" reflect "reflect" gomock "github.com/golang/mock/gomock" + client "github.com/nspcc-dev/neofs-api-go/v2/rpc/client" client0 "github.com/nspcc-dev/neofs-sdk-go/client" + container "github.com/nspcc-dev/neofs-sdk-go/container" + cid "github.com/nspcc-dev/neofs-sdk-go/container/id" + eacl "github.com/nspcc-dev/neofs-sdk-go/eacl" + owner "github.com/nspcc-dev/neofs-sdk-go/owner" ) // MockClient is a mock of Client interface. type MockClient struct { - client0.Client ctrl *gomock.Controller recorder *MockClientMockRecorder } @@ -35,6 +41,19 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } +// AnnounceContainerUsedSpace mocks base method. +func (m *MockClient) AnnounceContainerUsedSpace(arg0 context.Context, arg1 []container.UsedSpaceAnnouncement, arg2 ...client0.CallOption) (*client0.AnnounceSpaceRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AnnounceContainerUsedSpace", varargs...) + ret0, _ := ret[0].(*client0.AnnounceSpaceRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // AnnounceContainerUsedSpace indicates an expected call of AnnounceContainerUsedSpace. func (mr *MockClientMockRecorder) AnnounceContainerUsedSpace(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -42,6 +61,19 @@ func (mr *MockClientMockRecorder) AnnounceContainerUsedSpace(arg0, arg1 interfac return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceContainerUsedSpace", reflect.TypeOf((*MockClient)(nil).AnnounceContainerUsedSpace), varargs...) } +// AnnounceIntermediateTrust mocks base method. +func (m *MockClient) AnnounceIntermediateTrust(arg0 context.Context, arg1 client0.AnnounceIntermediateTrustPrm, arg2 ...client0.CallOption) (*client0.AnnounceIntermediateTrustRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AnnounceIntermediateTrust", varargs...) + ret0, _ := ret[0].(*client0.AnnounceIntermediateTrustRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // AnnounceIntermediateTrust indicates an expected call of AnnounceIntermediateTrust. func (mr *MockClientMockRecorder) AnnounceIntermediateTrust(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -49,6 +81,19 @@ func (mr *MockClientMockRecorder) AnnounceIntermediateTrust(arg0, arg1 interface return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceIntermediateTrust", reflect.TypeOf((*MockClient)(nil).AnnounceIntermediateTrust), varargs...) } +// AnnounceLocalTrust mocks base method. +func (m *MockClient) AnnounceLocalTrust(arg0 context.Context, arg1 client0.AnnounceLocalTrustPrm, arg2 ...client0.CallOption) (*client0.AnnounceLocalTrustRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AnnounceLocalTrust", varargs...) + ret0, _ := ret[0].(*client0.AnnounceLocalTrustRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // AnnounceLocalTrust indicates an expected call of AnnounceLocalTrust. func (mr *MockClientMockRecorder) AnnounceLocalTrust(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -56,12 +101,33 @@ func (mr *MockClientMockRecorder) AnnounceLocalTrust(arg0, arg1 interface{}, arg return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceLocalTrust", reflect.TypeOf((*MockClient)(nil).AnnounceLocalTrust), varargs...) } +// Conn mocks base method. +func (m *MockClient) Conn() io.Closer { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Conn") + ret0, _ := ret[0].(io.Closer) + return ret0 +} + // Conn indicates an expected call of Conn. func (mr *MockClientMockRecorder) Conn() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Conn", reflect.TypeOf((*MockClient)(nil).Conn)) } +// CreateSession mocks base method. +func (m *MockClient) CreateSession(arg0 context.Context, arg1 uint64, arg2 ...client0.CallOption) (*client0.CreateSessionRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSession", varargs...) + ret0, _ := ret[0].(*client0.CreateSessionRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // CreateSession indicates an expected call of CreateSession. func (mr *MockClientMockRecorder) CreateSession(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -69,6 +135,19 @@ func (mr *MockClientMockRecorder) CreateSession(arg0, arg1 interface{}, arg2 ... return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSession", reflect.TypeOf((*MockClient)(nil).CreateSession), varargs...) } +// DeleteContainer mocks base method. +func (m *MockClient) DeleteContainer(arg0 context.Context, arg1 *cid.ID, arg2 ...client0.CallOption) (*client0.ContainerDeleteRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteContainer", varargs...) + ret0, _ := ret[0].(*client0.ContainerDeleteRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // DeleteContainer indicates an expected call of DeleteContainer. func (mr *MockClientMockRecorder) DeleteContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -76,6 +155,19 @@ func (mr *MockClientMockRecorder) DeleteContainer(arg0, arg1 interface{}, arg2 . return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainer", reflect.TypeOf((*MockClient)(nil).DeleteContainer), varargs...) } +// DeleteObject mocks base method. +func (m *MockClient) DeleteObject(arg0 context.Context, arg1 *client0.DeleteObjectParams, arg2 ...client0.CallOption) (*client0.ObjectDeleteRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteObject", varargs...) + ret0, _ := ret[0].(*client0.ObjectDeleteRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // DeleteObject indicates an expected call of DeleteObject. func (mr *MockClientMockRecorder) DeleteObject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -83,6 +175,39 @@ func (mr *MockClientMockRecorder) DeleteObject(arg0, arg1 interface{}, arg2 ...i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockClient)(nil).DeleteObject), varargs...) } +// EACL mocks base method. +func (m *MockClient) EACL(arg0 context.Context, arg1 *cid.ID, arg2 ...client0.CallOption) (*client0.EACLRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EACL", varargs...) + ret0, _ := ret[0].(*client0.EACLRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EACL indicates an expected call of EACL. +func (mr *MockClientMockRecorder) EACL(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EACL", reflect.TypeOf((*MockClient)(nil).EACL), varargs...) +} + +// EndpointInfo mocks base method. +func (m *MockClient) EndpointInfo(arg0 context.Context, arg1 ...client0.CallOption) (*client0.EndpointInfoRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EndpointInfo", varargs...) + ret0, _ := ret[0].(*client0.EndpointInfoRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // EndpointInfo indicates an expected call of EndpointInfo. func (mr *MockClientMockRecorder) EndpointInfo(arg0 interface{}, arg1 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -90,6 +215,19 @@ func (mr *MockClientMockRecorder) EndpointInfo(arg0 interface{}, arg1 ...interfa return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndpointInfo", reflect.TypeOf((*MockClient)(nil).EndpointInfo), varargs...) } +// GetBalance mocks base method. +func (m *MockClient) GetBalance(arg0 context.Context, arg1 *owner.ID, arg2 ...client0.CallOption) (*client0.BalanceOfRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBalance", varargs...) + ret0, _ := ret[0].(*client0.BalanceOfRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // GetBalance indicates an expected call of GetBalance. func (mr *MockClientMockRecorder) GetBalance(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -97,6 +235,19 @@ func (mr *MockClientMockRecorder) GetBalance(arg0, arg1 interface{}, arg2 ...int return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockClient)(nil).GetBalance), varargs...) } +// GetContainer mocks base method. +func (m *MockClient) GetContainer(arg0 context.Context, arg1 *cid.ID, arg2 ...client0.CallOption) (*client0.ContainerGetRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetContainer", varargs...) + ret0, _ := ret[0].(*client0.ContainerGetRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // GetContainer indicates an expected call of GetContainer. func (mr *MockClientMockRecorder) GetContainer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -104,11 +255,17 @@ func (mr *MockClientMockRecorder) GetContainer(arg0, arg1 interface{}, arg2 ...i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainer", reflect.TypeOf((*MockClient)(nil).GetContainer), varargs...) } -// GetEACL indicates an expected call of GetEACL. -func (mr *MockClientMockRecorder) GetEACL(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EACL", reflect.TypeOf((*MockClient)(nil).EACL), varargs...) +// GetObject mocks base method. +func (m *MockClient) GetObject(arg0 context.Context, arg1 *client0.GetObjectParams, arg2 ...client0.CallOption) (*client0.ObjectGetRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetObject", varargs...) + ret0, _ := ret[0].(*client0.ObjectGetRes) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetObject indicates an expected call of GetObject. @@ -118,13 +275,59 @@ func (mr *MockClientMockRecorder) GetObject(arg0, arg1 interface{}, arg2 ...inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockClient)(nil).GetObject), varargs...) } -// GetObjectHeader indicates an expected call of GetObjectHeader. -func (mr *MockClientMockRecorder) GetObjectHeader(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// HashObjectPayloadRanges mocks base method. +func (m *MockClient) HashObjectPayloadRanges(arg0 context.Context, arg1 *client0.RangeChecksumParams, arg2 ...client0.CallOption) (*client0.ObjectRangeHashRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HashObjectPayloadRanges", varargs...) + ret0, _ := ret[0].(*client0.ObjectRangeHashRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HashObjectPayloadRanges indicates an expected call of HashObjectPayloadRanges. +func (mr *MockClientMockRecorder) HashObjectPayloadRanges(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashObjectPayloadRanges", reflect.TypeOf((*MockClient)(nil).HashObjectPayloadRanges), varargs...) +} + +// HeadObject mocks base method. +func (m *MockClient) HeadObject(arg0 context.Context, arg1 *client0.ObjectHeaderParams, arg2 ...client0.CallOption) (*client0.ObjectHeadRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HeadObject", varargs...) + ret0, _ := ret[0].(*client0.ObjectHeadRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeadObject indicates an expected call of HeadObject. +func (mr *MockClientMockRecorder) HeadObject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockClient)(nil).HeadObject), varargs...) } +// ListContainers mocks base method. +func (m *MockClient) ListContainers(arg0 context.Context, arg1 *owner.ID, arg2 ...client0.CallOption) (*client0.ContainerListRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListContainers", varargs...) + ret0, _ := ret[0].(*client0.ContainerListRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // ListContainers indicates an expected call of ListContainers. func (mr *MockClientMockRecorder) ListContainers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -132,6 +335,19 @@ func (mr *MockClientMockRecorder) ListContainers(arg0, arg1 interface{}, arg2 .. return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockClient)(nil).ListContainers), varargs...) } +// NetworkInfo mocks base method. +func (m *MockClient) NetworkInfo(arg0 context.Context, arg1 ...client0.CallOption) (*client0.NetworkInfoRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "NetworkInfo", varargs...) + ret0, _ := ret[0].(*client0.NetworkInfoRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // NetworkInfo indicates an expected call of NetworkInfo. func (mr *MockClientMockRecorder) NetworkInfo(arg0 interface{}, arg1 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -139,6 +355,19 @@ func (mr *MockClientMockRecorder) NetworkInfo(arg0 interface{}, arg1 ...interfac return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInfo", reflect.TypeOf((*MockClient)(nil).NetworkInfo), varargs...) } +// ObjectPayloadRangeData mocks base method. +func (m *MockClient) ObjectPayloadRangeData(arg0 context.Context, arg1 *client0.RangeDataParams, arg2 ...client0.CallOption) (*client0.ObjectRangeRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ObjectPayloadRangeData", varargs...) + ret0, _ := ret[0].(*client0.ObjectRangeRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // ObjectPayloadRangeData indicates an expected call of ObjectPayloadRangeData. func (mr *MockClientMockRecorder) ObjectPayloadRangeData(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -146,18 +375,17 @@ func (mr *MockClientMockRecorder) ObjectPayloadRangeData(arg0, arg1 interface{}, return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectPayloadRangeData", reflect.TypeOf((*MockClient)(nil).ObjectPayloadRangeData), varargs...) } -// ObjectPayloadRangeSHA256 indicates an expected call of ObjectPayloadRangeSHA256. -func (mr *MockClientMockRecorder) ObjectPayloadRangeSHA256(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashObjectPayloadRanges", reflect.TypeOf((*MockClient)(nil).HashObjectPayloadRanges), varargs...) -} - -// ObjectPayloadRangeTZ indicates an expected call of ObjectPayloadRangeTZ. -func (mr *MockClientMockRecorder) ObjectPayloadRangeTZ(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashObjectPayloadRanges", reflect.TypeOf((*MockClient)(nil).HashObjectPayloadRanges), varargs...) +// PutContainer mocks base method. +func (m *MockClient) PutContainer(arg0 context.Context, arg1 *container.Container, arg2 ...client0.CallOption) (*client0.ContainerPutRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutContainer", varargs...) + ret0, _ := ret[0].(*client0.ContainerPutRes) + ret1, _ := ret[1].(error) + return ret0, ret1 } // PutContainer indicates an expected call of PutContainer. @@ -167,6 +395,19 @@ func (mr *MockClientMockRecorder) PutContainer(arg0, arg1 interface{}, arg2 ...i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutContainer", reflect.TypeOf((*MockClient)(nil).PutContainer), varargs...) } +// PutObject mocks base method. +func (m *MockClient) PutObject(arg0 context.Context, arg1 *client0.PutObjectParams, arg2 ...client0.CallOption) (*client0.ObjectPutRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutObject", varargs...) + ret0, _ := ret[0].(*client0.ObjectPutRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // PutObject indicates an expected call of PutObject. func (mr *MockClientMockRecorder) PutObject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() @@ -174,19 +415,53 @@ func (mr *MockClientMockRecorder) PutObject(arg0, arg1 interface{}, arg2 ...inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockClient)(nil).PutObject), varargs...) } +// Raw mocks base method. +func (m *MockClient) Raw() *client.Client { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Raw") + ret0, _ := ret[0].(*client.Client) + return ret0 +} + // Raw indicates an expected call of Raw. func (mr *MockClientMockRecorder) Raw() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Raw", reflect.TypeOf((*MockClient)(nil).Raw)) } -// SearchObject indicates an expected call of SearchObject. -func (mr *MockClientMockRecorder) SearchObject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// SearchObjects mocks base method. +func (m *MockClient) SearchObjects(arg0 context.Context, arg1 *client0.SearchObjectParams, arg2 ...client0.CallOption) (*client0.ObjectSearchRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchObjects", varargs...) + ret0, _ := ret[0].(*client0.ObjectSearchRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchObjects indicates an expected call of SearchObjects. +func (mr *MockClientMockRecorder) SearchObjects(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchObjects", reflect.TypeOf((*MockClient)(nil).SearchObjects), varargs...) } +// SetEACL mocks base method. +func (m *MockClient) SetEACL(arg0 context.Context, arg1 *eacl.Table, arg2 ...client0.CallOption) (*client0.SetEACLRes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetEACL", varargs...) + ret0, _ := ret[0].(*client0.SetEACLRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + // SetEACL indicates an expected call of SetEACL. func (mr *MockClientMockRecorder) SetEACL(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() diff --git a/pool/pool_test.go b/pool/pool_test.go index bd8bc37..b46a94a 100644 --- a/pool/pool_test.go +++ b/pool/pool_test.go @@ -39,8 +39,6 @@ func TestBuildPoolClientFailed(t *testing.T) { } func TestBuildPoolCreateSessionFailed(t *testing.T) { - t.Skip("NeoFS API client can't be mocked") // neofs-sdk-go#85 - ctrl := gomock.NewController(t) ni := &netmap.NodeInfo{} @@ -49,7 +47,7 @@ func TestBuildPoolCreateSessionFailed(t *testing.T) { clientBuilder := func(opts ...client.Option) (client.Client, error) { mockClient := NewMockClient(ctrl) mockClient.EXPECT().CreateSession(gomock.Any(), gomock.Any()).Return(nil, fmt.Errorf("error session")).AnyTimes() - mockClient.EXPECT().EndpointInfo(gomock.Any(), gomock.Any()).Return(&client.EndpointInfo{}, nil).AnyTimes() + mockClient.EXPECT().EndpointInfo(gomock.Any(), gomock.Any()).Return(&client.EndpointInfoRes{}, nil).AnyTimes() return mockClient, nil } @@ -486,8 +484,6 @@ func newToken(t *testing.T) *session.Token { } func TestWaitPresence(t *testing.T) { - t.Skip("NeoFS API client can't be mocked") // neofs-sdk-go#85 - ctrl := gomock.NewController(t) mockClient := NewMockClient(ctrl) diff --git a/pool/sampler_test.go b/pool/sampler_test.go index dce8dd3..a286739 100644 --- a/pool/sampler_test.go +++ b/pool/sampler_test.go @@ -48,17 +48,23 @@ type clientMock struct { err error } -func newNetmapMock(name string, needErr bool) clientMock { +func (c *clientMock) EndpointInfo(context.Context, ...client.CallOption) (*client.EndpointInfoRes, error) { + return nil, nil +} + +func (c *clientMock) NetworkInfo(context.Context, ...client.CallOption) (*client.NetworkInfoRes, error) { + return nil, nil +} + +func newNetmapMock(name string, needErr bool) *clientMock { var err error if needErr { err = fmt.Errorf("not available") } - return clientMock{name: name, err: err} + return &clientMock{name: name, err: err} } func TestHealthyReweight(t *testing.T) { - t.Skip("NeoFS API client can't be mocked") // neofs-sdk-go#85 - var ( weights = []float64{0.9, 0.1} names = []string{"node0", "node1"} @@ -84,14 +90,14 @@ func TestHealthyReweight(t *testing.T) { // check getting first node connection before rebalance happened connection0, _, err := p.Connection() require.NoError(t, err) - mock0 := connection0.(clientMock) + mock0 := connection0.(*clientMock) require.Equal(t, names[0], mock0.name) updateInnerNodesHealth(context.TODO(), p, 0, options, buffer) connection1, _, err := p.Connection() require.NoError(t, err) - mock1 := connection1.(clientMock) + mock1 := connection1.(*clientMock) require.Equal(t, names[1], mock1.name) // enabled first node again @@ -104,13 +110,11 @@ func TestHealthyReweight(t *testing.T) { connection0, _, err = p.Connection() require.NoError(t, err) - mock0 = connection0.(clientMock) + mock0 = connection0.(*clientMock) require.Equal(t, names[0], mock0.name) } func TestHealthyNoReweight(t *testing.T) { - t.Skip("NeoFS API client can't be mocked") // neofs-sdk-go#85 - var ( weights = []float64{0.9, 0.1} names = []string{"node0", "node1"}