[#74] Fix some tests

For some tests enough empty results.

Signed-off-by: Denis Kirillov <denis@nspcc.ru>

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.
+// GetObject mocks base method.
-func (mr *MockClientMockRecorder) GetEACL(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (m *MockClient) GetObject(arg0 context.Context, arg1 *client0.GetObjectParams, arg2 ...client0.CallOption) (*client0.ObjectGetRes, error) {
-	mr.mock.ctrl.T.Helper()
+	m.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := []interface{}{arg0, arg1}
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EACL", reflect.TypeOf((*MockClient)(nil).EACL), varargs...)
+	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.
+// HashObjectPayloadRanges mocks base method.
-func (mr *MockClientMockRecorder) GetObjectHeader(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+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.
+// PutContainer mocks base method.
-func (mr *MockClientMockRecorder) ObjectPayloadRangeSHA256(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (m *MockClient) PutContainer(arg0 context.Context, arg1 *container.Container, arg2 ...client0.CallOption) (*client0.ContainerPutRes, error) {
-	mr.mock.ctrl.T.Helper()
+	m.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := []interface{}{arg0, arg1}
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashObjectPayloadRanges", reflect.TypeOf((*MockClient)(nil).HashObjectPayloadRanges), varargs...)
+	for _, a := range arg2 {
-}
+		varargs = append(varargs, a)
-
+	}
-// ObjectPayloadRangeTZ indicates an expected call of ObjectPayloadRangeTZ.
+	ret := m.ctrl.Call(m, "PutContainer", varargs...)
-func (mr *MockClientMockRecorder) ObjectPayloadRangeTZ(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	ret0, _ := ret[0].(*client0.ContainerPutRes)
-	mr.mock.ctrl.T.Helper()
+	ret1, _ := ret[1].(error)
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return ret0, ret1
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashObjectPayloadRanges", reflect.TypeOf((*MockClient)(nil).HashObjectPayloadRanges), varargs...)
 }
 
 // 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.
+// SearchObjects mocks base method.
-func (mr *MockClientMockRecorder) SearchObject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+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()

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)

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"}