From 87aaba552996d74ad6e8b9ba10515734daf63b08 Mon Sep 17 00:00:00 2001 From: Dmitrii Neeman Date: Mon, 5 Aug 2024 17:37:53 +0300 Subject: [PATCH] FMWK-521-as-client-interface - added mock --- internal/asinfo/mocks/asClient_mock.go | 83 ++++ mocks/AsClient_mock.go | 596 +++++++++++++++++++++++++ 2 files changed, 679 insertions(+) create mode 100644 internal/asinfo/mocks/asClient_mock.go create mode 100644 mocks/AsClient_mock.go diff --git a/internal/asinfo/mocks/asClient_mock.go b/internal/asinfo/mocks/asClient_mock.go new file mode 100644 index 00000000..a700e68e --- /dev/null +++ b/internal/asinfo/mocks/asClient_mock.go @@ -0,0 +1,83 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +package mocks + +import ( + aerospike "github.com/aerospike/aerospike-client-go/v7" + + mock "github.com/stretchr/testify/mock" +) + +// MockasClient is an autogenerated mock type for the asClient type +type MockasClient struct { + mock.Mock +} + +type MockasClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockasClient) EXPECT() *MockasClient_Expecter { + return &MockasClient_Expecter{mock: &_m.Mock} +} + +// Cluster provides a mock function with given fields: +func (_m *MockasClient) Cluster() *aerospike.Cluster { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Cluster") + } + + var r0 *aerospike.Cluster + if rf, ok := ret.Get(0).(func() *aerospike.Cluster); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.Cluster) + } + } + + return r0 +} + +// MockasClient_Cluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cluster' +type MockasClient_Cluster_Call struct { + *mock.Call +} + +// Cluster is a helper method to define mock.On call +func (_e *MockasClient_Expecter) Cluster() *MockasClient_Cluster_Call { + return &MockasClient_Cluster_Call{Call: _e.mock.On("Cluster")} +} + +func (_c *MockasClient_Cluster_Call) Run(run func()) *MockasClient_Cluster_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockasClient_Cluster_Call) Return(_a0 *aerospike.Cluster) *MockasClient_Cluster_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockasClient_Cluster_Call) RunAndReturn(run func() *aerospike.Cluster) *MockasClient_Cluster_Call { + _c.Call.Return(run) + return _c +} + +// NewMockasClient creates a new instance of MockasClient. 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 NewMockasClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockasClient { + mock := &MockasClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mocks/AsClient_mock.go b/mocks/AsClient_mock.go new file mode 100644 index 00000000..cc04499d --- /dev/null +++ b/mocks/AsClient_mock.go @@ -0,0 +1,596 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +package mocks + +import ( + aerospike "github.com/aerospike/aerospike-client-go/v7" + + mock "github.com/stretchr/testify/mock" +) + +// MockAsClient is an autogenerated mock type for the AsClient type +type MockAsClient struct { + mock.Mock +} + +type MockAsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAsClient) EXPECT() *MockAsClient_Expecter { + return &MockAsClient_Expecter{mock: &_m.Mock} +} + +// BatchOperate provides a mock function with given fields: policy, records +func (_m *MockAsClient) BatchOperate(policy *aerospike.BatchPolicy, records []aerospike.BatchRecordIfc) aerospike.Error { + ret := _m.Called(policy, records) + + if len(ret) == 0 { + panic("no return value specified for BatchOperate") + } + + var r0 aerospike.Error + if rf, ok := ret.Get(0).(func(*aerospike.BatchPolicy, []aerospike.BatchRecordIfc) aerospike.Error); ok { + r0 = rf(policy, records) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(aerospike.Error) + } + } + + return r0 +} + +// MockAsClient_BatchOperate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchOperate' +type MockAsClient_BatchOperate_Call struct { + *mock.Call +} + +// BatchOperate is a helper method to define mock.On call +// - policy *aerospike.BatchPolicy +// - records []aerospike.BatchRecordIfc +func (_e *MockAsClient_Expecter) BatchOperate(policy interface{}, records interface{}) *MockAsClient_BatchOperate_Call { + return &MockAsClient_BatchOperate_Call{Call: _e.mock.On("BatchOperate", policy, records)} +} + +func (_c *MockAsClient_BatchOperate_Call) Run(run func(policy *aerospike.BatchPolicy, records []aerospike.BatchRecordIfc)) *MockAsClient_BatchOperate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*aerospike.BatchPolicy), args[1].([]aerospike.BatchRecordIfc)) + }) + return _c +} + +func (_c *MockAsClient_BatchOperate_Call) Return(_a0 aerospike.Error) *MockAsClient_BatchOperate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_BatchOperate_Call) RunAndReturn(run func(*aerospike.BatchPolicy, []aerospike.BatchRecordIfc) aerospike.Error) *MockAsClient_BatchOperate_Call { + _c.Call.Return(run) + return _c +} + +// Cluster provides a mock function with given fields: +func (_m *MockAsClient) Cluster() *aerospike.Cluster { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Cluster") + } + + var r0 *aerospike.Cluster + if rf, ok := ret.Get(0).(func() *aerospike.Cluster); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.Cluster) + } + } + + return r0 +} + +// MockAsClient_Cluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cluster' +type MockAsClient_Cluster_Call struct { + *mock.Call +} + +// Cluster is a helper method to define mock.On call +func (_e *MockAsClient_Expecter) Cluster() *MockAsClient_Cluster_Call { + return &MockAsClient_Cluster_Call{Call: _e.mock.On("Cluster")} +} + +func (_c *MockAsClient_Cluster_Call) Run(run func()) *MockAsClient_Cluster_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsClient_Cluster_Call) Return(_a0 *aerospike.Cluster) *MockAsClient_Cluster_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_Cluster_Call) RunAndReturn(run func() *aerospike.Cluster) *MockAsClient_Cluster_Call { + _c.Call.Return(run) + return _c +} + +// CreateComplexIndex provides a mock function with given fields: policy, namespace, set, indexName, binName, indexType, indexCollectionType, ctx +func (_m *MockAsClient) CreateComplexIndex(policy *aerospike.WritePolicy, namespace string, set string, indexName string, binName string, indexType aerospike.IndexType, indexCollectionType aerospike.IndexCollectionType, ctx ...*aerospike.CDTContext) (*aerospike.IndexTask, aerospike.Error) { + _va := make([]interface{}, len(ctx)) + for _i := range ctx { + _va[_i] = ctx[_i] + } + var _ca []interface{} + _ca = append(_ca, policy, namespace, set, indexName, binName, indexType, indexCollectionType) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateComplexIndex") + } + + var r0 *aerospike.IndexTask + var r1 aerospike.Error + if rf, ok := ret.Get(0).(func(*aerospike.WritePolicy, string, string, string, string, aerospike.IndexType, aerospike.IndexCollectionType, ...*aerospike.CDTContext) (*aerospike.IndexTask, aerospike.Error)); ok { + return rf(policy, namespace, set, indexName, binName, indexType, indexCollectionType, ctx...) + } + if rf, ok := ret.Get(0).(func(*aerospike.WritePolicy, string, string, string, string, aerospike.IndexType, aerospike.IndexCollectionType, ...*aerospike.CDTContext) *aerospike.IndexTask); ok { + r0 = rf(policy, namespace, set, indexName, binName, indexType, indexCollectionType, ctx...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.IndexTask) + } + } + + if rf, ok := ret.Get(1).(func(*aerospike.WritePolicy, string, string, string, string, aerospike.IndexType, aerospike.IndexCollectionType, ...*aerospike.CDTContext) aerospike.Error); ok { + r1 = rf(policy, namespace, set, indexName, binName, indexType, indexCollectionType, ctx...) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(aerospike.Error) + } + } + + return r0, r1 +} + +// MockAsClient_CreateComplexIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateComplexIndex' +type MockAsClient_CreateComplexIndex_Call struct { + *mock.Call +} + +// CreateComplexIndex is a helper method to define mock.On call +// - policy *aerospike.WritePolicy +// - namespace string +// - set string +// - indexName string +// - binName string +// - indexType aerospike.IndexType +// - indexCollectionType aerospike.IndexCollectionType +// - ctx ...*aerospike.CDTContext +func (_e *MockAsClient_Expecter) CreateComplexIndex(policy interface{}, namespace interface{}, set interface{}, indexName interface{}, binName interface{}, indexType interface{}, indexCollectionType interface{}, ctx ...interface{}) *MockAsClient_CreateComplexIndex_Call { + return &MockAsClient_CreateComplexIndex_Call{Call: _e.mock.On("CreateComplexIndex", + append([]interface{}{policy, namespace, set, indexName, binName, indexType, indexCollectionType}, ctx...)...)} +} + +func (_c *MockAsClient_CreateComplexIndex_Call) Run(run func(policy *aerospike.WritePolicy, namespace string, set string, indexName string, binName string, indexType aerospike.IndexType, indexCollectionType aerospike.IndexCollectionType, ctx ...*aerospike.CDTContext)) *MockAsClient_CreateComplexIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]*aerospike.CDTContext, len(args)-7) + for i, a := range args[7:] { + if a != nil { + variadicArgs[i] = a.(*aerospike.CDTContext) + } + } + run(args[0].(*aerospike.WritePolicy), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(aerospike.IndexType), args[6].(aerospike.IndexCollectionType), variadicArgs...) + }) + return _c +} + +func (_c *MockAsClient_CreateComplexIndex_Call) Return(_a0 *aerospike.IndexTask, _a1 aerospike.Error) *MockAsClient_CreateComplexIndex_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAsClient_CreateComplexIndex_Call) RunAndReturn(run func(*aerospike.WritePolicy, string, string, string, string, aerospike.IndexType, aerospike.IndexCollectionType, ...*aerospike.CDTContext) (*aerospike.IndexTask, aerospike.Error)) *MockAsClient_CreateComplexIndex_Call { + _c.Call.Return(run) + return _c +} + +// DropIndex provides a mock function with given fields: policy, namespace, set, indexName +func (_m *MockAsClient) DropIndex(policy *aerospike.WritePolicy, namespace string, set string, indexName string) aerospike.Error { + ret := _m.Called(policy, namespace, set, indexName) + + if len(ret) == 0 { + panic("no return value specified for DropIndex") + } + + var r0 aerospike.Error + if rf, ok := ret.Get(0).(func(*aerospike.WritePolicy, string, string, string) aerospike.Error); ok { + r0 = rf(policy, namespace, set, indexName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(aerospike.Error) + } + } + + return r0 +} + +// MockAsClient_DropIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropIndex' +type MockAsClient_DropIndex_Call struct { + *mock.Call +} + +// DropIndex is a helper method to define mock.On call +// - policy *aerospike.WritePolicy +// - namespace string +// - set string +// - indexName string +func (_e *MockAsClient_Expecter) DropIndex(policy interface{}, namespace interface{}, set interface{}, indexName interface{}) *MockAsClient_DropIndex_Call { + return &MockAsClient_DropIndex_Call{Call: _e.mock.On("DropIndex", policy, namespace, set, indexName)} +} + +func (_c *MockAsClient_DropIndex_Call) Run(run func(policy *aerospike.WritePolicy, namespace string, set string, indexName string)) *MockAsClient_DropIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*aerospike.WritePolicy), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockAsClient_DropIndex_Call) Return(_a0 aerospike.Error) *MockAsClient_DropIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_DropIndex_Call) RunAndReturn(run func(*aerospike.WritePolicy, string, string, string) aerospike.Error) *MockAsClient_DropIndex_Call { + _c.Call.Return(run) + return _c +} + +// GetDefaultInfoPolicy provides a mock function with given fields: +func (_m *MockAsClient) GetDefaultInfoPolicy() *aerospike.InfoPolicy { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDefaultInfoPolicy") + } + + var r0 *aerospike.InfoPolicy + if rf, ok := ret.Get(0).(func() *aerospike.InfoPolicy); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.InfoPolicy) + } + } + + return r0 +} + +// MockAsClient_GetDefaultInfoPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultInfoPolicy' +type MockAsClient_GetDefaultInfoPolicy_Call struct { + *mock.Call +} + +// GetDefaultInfoPolicy is a helper method to define mock.On call +func (_e *MockAsClient_Expecter) GetDefaultInfoPolicy() *MockAsClient_GetDefaultInfoPolicy_Call { + return &MockAsClient_GetDefaultInfoPolicy_Call{Call: _e.mock.On("GetDefaultInfoPolicy")} +} + +func (_c *MockAsClient_GetDefaultInfoPolicy_Call) Run(run func()) *MockAsClient_GetDefaultInfoPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsClient_GetDefaultInfoPolicy_Call) Return(_a0 *aerospike.InfoPolicy) *MockAsClient_GetDefaultInfoPolicy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_GetDefaultInfoPolicy_Call) RunAndReturn(run func() *aerospike.InfoPolicy) *MockAsClient_GetDefaultInfoPolicy_Call { + _c.Call.Return(run) + return _c +} + +// GetDefaultScanPolicy provides a mock function with given fields: +func (_m *MockAsClient) GetDefaultScanPolicy() *aerospike.ScanPolicy { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDefaultScanPolicy") + } + + var r0 *aerospike.ScanPolicy + if rf, ok := ret.Get(0).(func() *aerospike.ScanPolicy); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.ScanPolicy) + } + } + + return r0 +} + +// MockAsClient_GetDefaultScanPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultScanPolicy' +type MockAsClient_GetDefaultScanPolicy_Call struct { + *mock.Call +} + +// GetDefaultScanPolicy is a helper method to define mock.On call +func (_e *MockAsClient_Expecter) GetDefaultScanPolicy() *MockAsClient_GetDefaultScanPolicy_Call { + return &MockAsClient_GetDefaultScanPolicy_Call{Call: _e.mock.On("GetDefaultScanPolicy")} +} + +func (_c *MockAsClient_GetDefaultScanPolicy_Call) Run(run func()) *MockAsClient_GetDefaultScanPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsClient_GetDefaultScanPolicy_Call) Return(_a0 *aerospike.ScanPolicy) *MockAsClient_GetDefaultScanPolicy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_GetDefaultScanPolicy_Call) RunAndReturn(run func() *aerospike.ScanPolicy) *MockAsClient_GetDefaultScanPolicy_Call { + _c.Call.Return(run) + return _c +} + +// GetDefaultWritePolicy provides a mock function with given fields: +func (_m *MockAsClient) GetDefaultWritePolicy() *aerospike.WritePolicy { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDefaultWritePolicy") + } + + var r0 *aerospike.WritePolicy + if rf, ok := ret.Get(0).(func() *aerospike.WritePolicy); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.WritePolicy) + } + } + + return r0 +} + +// MockAsClient_GetDefaultWritePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultWritePolicy' +type MockAsClient_GetDefaultWritePolicy_Call struct { + *mock.Call +} + +// GetDefaultWritePolicy is a helper method to define mock.On call +func (_e *MockAsClient_Expecter) GetDefaultWritePolicy() *MockAsClient_GetDefaultWritePolicy_Call { + return &MockAsClient_GetDefaultWritePolicy_Call{Call: _e.mock.On("GetDefaultWritePolicy")} +} + +func (_c *MockAsClient_GetDefaultWritePolicy_Call) Run(run func()) *MockAsClient_GetDefaultWritePolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsClient_GetDefaultWritePolicy_Call) Return(_a0 *aerospike.WritePolicy) *MockAsClient_GetDefaultWritePolicy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_GetDefaultWritePolicy_Call) RunAndReturn(run func() *aerospike.WritePolicy) *MockAsClient_GetDefaultWritePolicy_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: policy, key, bins +func (_m *MockAsClient) Put(policy *aerospike.WritePolicy, key *aerospike.Key, bins aerospike.BinMap) aerospike.Error { + ret := _m.Called(policy, key, bins) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 aerospike.Error + if rf, ok := ret.Get(0).(func(*aerospike.WritePolicy, *aerospike.Key, aerospike.BinMap) aerospike.Error); ok { + r0 = rf(policy, key, bins) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(aerospike.Error) + } + } + + return r0 +} + +// MockAsClient_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type MockAsClient_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - policy *aerospike.WritePolicy +// - key *aerospike.Key +// - bins aerospike.BinMap +func (_e *MockAsClient_Expecter) Put(policy interface{}, key interface{}, bins interface{}) *MockAsClient_Put_Call { + return &MockAsClient_Put_Call{Call: _e.mock.On("Put", policy, key, bins)} +} + +func (_c *MockAsClient_Put_Call) Run(run func(policy *aerospike.WritePolicy, key *aerospike.Key, bins aerospike.BinMap)) *MockAsClient_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*aerospike.WritePolicy), args[1].(*aerospike.Key), args[2].(aerospike.BinMap)) + }) + return _c +} + +func (_c *MockAsClient_Put_Call) Return(_a0 aerospike.Error) *MockAsClient_Put_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAsClient_Put_Call) RunAndReturn(run func(*aerospike.WritePolicy, *aerospike.Key, aerospike.BinMap) aerospike.Error) *MockAsClient_Put_Call { + _c.Call.Return(run) + return _c +} + +// RegisterUDF provides a mock function with given fields: policy, udfBody, serverPath, language +func (_m *MockAsClient) RegisterUDF(policy *aerospike.WritePolicy, udfBody []byte, serverPath string, language aerospike.Language) (*aerospike.RegisterTask, aerospike.Error) { + ret := _m.Called(policy, udfBody, serverPath, language) + + if len(ret) == 0 { + panic("no return value specified for RegisterUDF") + } + + var r0 *aerospike.RegisterTask + var r1 aerospike.Error + if rf, ok := ret.Get(0).(func(*aerospike.WritePolicy, []byte, string, aerospike.Language) (*aerospike.RegisterTask, aerospike.Error)); ok { + return rf(policy, udfBody, serverPath, language) + } + if rf, ok := ret.Get(0).(func(*aerospike.WritePolicy, []byte, string, aerospike.Language) *aerospike.RegisterTask); ok { + r0 = rf(policy, udfBody, serverPath, language) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.RegisterTask) + } + } + + if rf, ok := ret.Get(1).(func(*aerospike.WritePolicy, []byte, string, aerospike.Language) aerospike.Error); ok { + r1 = rf(policy, udfBody, serverPath, language) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(aerospike.Error) + } + } + + return r0, r1 +} + +// MockAsClient_RegisterUDF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterUDF' +type MockAsClient_RegisterUDF_Call struct { + *mock.Call +} + +// RegisterUDF is a helper method to define mock.On call +// - policy *aerospike.WritePolicy +// - udfBody []byte +// - serverPath string +// - language aerospike.Language +func (_e *MockAsClient_Expecter) RegisterUDF(policy interface{}, udfBody interface{}, serverPath interface{}, language interface{}) *MockAsClient_RegisterUDF_Call { + return &MockAsClient_RegisterUDF_Call{Call: _e.mock.On("RegisterUDF", policy, udfBody, serverPath, language)} +} + +func (_c *MockAsClient_RegisterUDF_Call) Run(run func(policy *aerospike.WritePolicy, udfBody []byte, serverPath string, language aerospike.Language)) *MockAsClient_RegisterUDF_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*aerospike.WritePolicy), args[1].([]byte), args[2].(string), args[3].(aerospike.Language)) + }) + return _c +} + +func (_c *MockAsClient_RegisterUDF_Call) Return(_a0 *aerospike.RegisterTask, _a1 aerospike.Error) *MockAsClient_RegisterUDF_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAsClient_RegisterUDF_Call) RunAndReturn(run func(*aerospike.WritePolicy, []byte, string, aerospike.Language) (*aerospike.RegisterTask, aerospike.Error)) *MockAsClient_RegisterUDF_Call { + _c.Call.Return(run) + return _c +} + +// ScanPartitions provides a mock function with given fields: scanPolicy, partitionFilter, namespace, setName, binNames +func (_m *MockAsClient) ScanPartitions(scanPolicy *aerospike.ScanPolicy, partitionFilter *aerospike.PartitionFilter, namespace string, setName string, binNames ...string) (*aerospike.Recordset, aerospike.Error) { + _va := make([]interface{}, len(binNames)) + for _i := range binNames { + _va[_i] = binNames[_i] + } + var _ca []interface{} + _ca = append(_ca, scanPolicy, partitionFilter, namespace, setName) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ScanPartitions") + } + + var r0 *aerospike.Recordset + var r1 aerospike.Error + if rf, ok := ret.Get(0).(func(*aerospike.ScanPolicy, *aerospike.PartitionFilter, string, string, ...string) (*aerospike.Recordset, aerospike.Error)); ok { + return rf(scanPolicy, partitionFilter, namespace, setName, binNames...) + } + if rf, ok := ret.Get(0).(func(*aerospike.ScanPolicy, *aerospike.PartitionFilter, string, string, ...string) *aerospike.Recordset); ok { + r0 = rf(scanPolicy, partitionFilter, namespace, setName, binNames...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aerospike.Recordset) + } + } + + if rf, ok := ret.Get(1).(func(*aerospike.ScanPolicy, *aerospike.PartitionFilter, string, string, ...string) aerospike.Error); ok { + r1 = rf(scanPolicy, partitionFilter, namespace, setName, binNames...) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(aerospike.Error) + } + } + + return r0, r1 +} + +// MockAsClient_ScanPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanPartitions' +type MockAsClient_ScanPartitions_Call struct { + *mock.Call +} + +// ScanPartitions is a helper method to define mock.On call +// - scanPolicy *aerospike.ScanPolicy +// - partitionFilter *aerospike.PartitionFilter +// - namespace string +// - setName string +// - binNames ...string +func (_e *MockAsClient_Expecter) ScanPartitions(scanPolicy interface{}, partitionFilter interface{}, namespace interface{}, setName interface{}, binNames ...interface{}) *MockAsClient_ScanPartitions_Call { + return &MockAsClient_ScanPartitions_Call{Call: _e.mock.On("ScanPartitions", + append([]interface{}{scanPolicy, partitionFilter, namespace, setName}, binNames...)...)} +} + +func (_c *MockAsClient_ScanPartitions_Call) Run(run func(scanPolicy *aerospike.ScanPolicy, partitionFilter *aerospike.PartitionFilter, namespace string, setName string, binNames ...string)) *MockAsClient_ScanPartitions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(*aerospike.ScanPolicy), args[1].(*aerospike.PartitionFilter), args[2].(string), args[3].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockAsClient_ScanPartitions_Call) Return(_a0 *aerospike.Recordset, _a1 aerospike.Error) *MockAsClient_ScanPartitions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAsClient_ScanPartitions_Call) RunAndReturn(run func(*aerospike.ScanPolicy, *aerospike.PartitionFilter, string, string, ...string) (*aerospike.Recordset, aerospike.Error)) *MockAsClient_ScanPartitions_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAsClient creates a new instance of MockAsClient. 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 NewMockAsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAsClient { + mock := &MockAsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}