helpers/akeyless/service/mock_akeylessAPIClient.go

// Code generated by mockery v2.53.3. DO NOT EDIT.

package service

import (
	context "context"

	akeyless "github.com/akeylesslabs/akeyless-go/v4"

	mock "github.com/stretchr/testify/mock"
)

// mockAkeylessAPIClient is an autogenerated mock type for the akeylessAPIClient type
type mockAkeylessAPIClient struct {
	mock.Mock
}

type mockAkeylessAPIClient_Expecter struct {
	mock *mock.Mock
}

func (_m *mockAkeylessAPIClient) EXPECT() *mockAkeylessAPIClient_Expecter {
	return &mockAkeylessAPIClient_Expecter{mock: &_m.Mock}
}

// Auth provides a mock function with given fields: ctx, params
func (_m *mockAkeylessAPIClient) Auth(ctx context.Context, params akeyless.Auth) (akeyless.AuthOutput, error) {
	ret := _m.Called(ctx, params)

	if len(ret) == 0 {
		panic("no return value specified for Auth")
	}

	var r0 akeyless.AuthOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.Auth) (akeyless.AuthOutput, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.Auth) akeyless.AuthOutput); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Get(0).(akeyless.AuthOutput)
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.Auth) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_Auth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Auth'
type mockAkeylessAPIClient_Auth_Call struct {
	*mock.Call
}

// Auth is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.Auth
func (_e *mockAkeylessAPIClient_Expecter) Auth(ctx interface{}, params interface{}) *mockAkeylessAPIClient_Auth_Call {
	return &mockAkeylessAPIClient_Auth_Call{Call: _e.mock.On("Auth", ctx, params)}
}

func (_c *mockAkeylessAPIClient_Auth_Call) Run(run func(ctx context.Context, params akeyless.Auth)) *mockAkeylessAPIClient_Auth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.Auth))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_Auth_Call) Return(_a0 akeyless.AuthOutput, _a1 error) *mockAkeylessAPIClient_Auth_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_Auth_Call) RunAndReturn(run func(context.Context, akeyless.Auth) (akeyless.AuthOutput, error)) *mockAkeylessAPIClient_Auth_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeItem provides a mock function with given fields: ctx, params
func (_m *mockAkeylessAPIClient) DescribeItem(ctx context.Context, params akeyless.DescribeItem) (akeyless.Item, error) {
	ret := _m.Called(ctx, params)

	if len(ret) == 0 {
		panic("no return value specified for DescribeItem")
	}

	var r0 akeyless.Item
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.DescribeItem) (akeyless.Item, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.DescribeItem) akeyless.Item); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Get(0).(akeyless.Item)
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.DescribeItem) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_DescribeItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeItem'
type mockAkeylessAPIClient_DescribeItem_Call struct {
	*mock.Call
}

// DescribeItem is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.DescribeItem
func (_e *mockAkeylessAPIClient_Expecter) DescribeItem(ctx interface{}, params interface{}) *mockAkeylessAPIClient_DescribeItem_Call {
	return &mockAkeylessAPIClient_DescribeItem_Call{Call: _e.mock.On("DescribeItem", ctx, params)}
}

func (_c *mockAkeylessAPIClient_DescribeItem_Call) Run(run func(ctx context.Context, params akeyless.DescribeItem)) *mockAkeylessAPIClient_DescribeItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.DescribeItem))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_DescribeItem_Call) Return(_a0 akeyless.Item, _a1 error) *mockAkeylessAPIClient_DescribeItem_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_DescribeItem_Call) RunAndReturn(run func(context.Context, akeyless.DescribeItem) (akeyless.Item, error)) *mockAkeylessAPIClient_DescribeItem_Call {
	_c.Call.Return(run)
	return _c
}

// GetDynamicSecretValue provides a mock function with given fields: ctx, params
func (_m *mockAkeylessAPIClient) GetDynamicSecretValue(ctx context.Context, params akeyless.GetDynamicSecretValue) (map[string]interface{}, error) {
	ret := _m.Called(ctx, params)

	if len(ret) == 0 {
		panic("no return value specified for GetDynamicSecretValue")
	}

	var r0 map[string]interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetDynamicSecretValue) (map[string]interface{}, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetDynamicSecretValue) map[string]interface{}); ok {
		r0 = rf(ctx, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.GetDynamicSecretValue) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_GetDynamicSecretValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDynamicSecretValue'
type mockAkeylessAPIClient_GetDynamicSecretValue_Call struct {
	*mock.Call
}

// GetDynamicSecretValue is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetDynamicSecretValue
func (_e *mockAkeylessAPIClient_Expecter) GetDynamicSecretValue(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	return &mockAkeylessAPIClient_GetDynamicSecretValue_Call{Call: _e.mock.On("GetDynamicSecretValue", ctx, params)}
}

func (_c *mockAkeylessAPIClient_GetDynamicSecretValue_Call) Run(run func(ctx context.Context, params akeyless.GetDynamicSecretValue)) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.GetDynamicSecretValue))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_GetDynamicSecretValue_Call) Return(_a0 map[string]interface{}, _a1 error) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_GetDynamicSecretValue_Call) RunAndReturn(run func(context.Context, akeyless.GetDynamicSecretValue) (map[string]interface{}, error)) *mockAkeylessAPIClient_GetDynamicSecretValue_Call {
	_c.Call.Return(run)
	return _c
}

// GetPKICertificate provides a mock function with given fields: ctx, params
func (_m *mockAkeylessAPIClient) GetPKICertificate(ctx context.Context, params akeyless.GetPKICertificate) (akeyless.GetPKICertificateOutput, error) {
	ret := _m.Called(ctx, params)

	if len(ret) == 0 {
		panic("no return value specified for GetPKICertificate")
	}

	var r0 akeyless.GetPKICertificateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetPKICertificate) (akeyless.GetPKICertificateOutput, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetPKICertificate) akeyless.GetPKICertificateOutput); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Get(0).(akeyless.GetPKICertificateOutput)
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.GetPKICertificate) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_GetPKICertificate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPKICertificate'
type mockAkeylessAPIClient_GetPKICertificate_Call struct {
	*mock.Call
}

// GetPKICertificate is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetPKICertificate
func (_e *mockAkeylessAPIClient_Expecter) GetPKICertificate(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetPKICertificate_Call {
	return &mockAkeylessAPIClient_GetPKICertificate_Call{Call: _e.mock.On("GetPKICertificate", ctx, params)}
}

func (_c *mockAkeylessAPIClient_GetPKICertificate_Call) Run(run func(ctx context.Context, params akeyless.GetPKICertificate)) *mockAkeylessAPIClient_GetPKICertificate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.GetPKICertificate))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_GetPKICertificate_Call) Return(_a0 akeyless.GetPKICertificateOutput, _a1 error) *mockAkeylessAPIClient_GetPKICertificate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_GetPKICertificate_Call) RunAndReturn(run func(context.Context, akeyless.GetPKICertificate) (akeyless.GetPKICertificateOutput, error)) *mockAkeylessAPIClient_GetPKICertificate_Call {
	_c.Call.Return(run)
	return _c
}

// GetRotatedSecretValue provides a mock function with given fields: ctx, params
func (_m *mockAkeylessAPIClient) GetRotatedSecretValue(ctx context.Context, params akeyless.GetRotatedSecretValue) (map[string]interface{}, error) {
	ret := _m.Called(ctx, params)

	if len(ret) == 0 {
		panic("no return value specified for GetRotatedSecretValue")
	}

	var r0 map[string]interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetRotatedSecretValue) (map[string]interface{}, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetRotatedSecretValue) map[string]interface{}); ok {
		r0 = rf(ctx, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.GetRotatedSecretValue) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_GetRotatedSecretValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRotatedSecretValue'
type mockAkeylessAPIClient_GetRotatedSecretValue_Call struct {
	*mock.Call
}

// GetRotatedSecretValue is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetRotatedSecretValue
func (_e *mockAkeylessAPIClient_Expecter) GetRotatedSecretValue(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	return &mockAkeylessAPIClient_GetRotatedSecretValue_Call{Call: _e.mock.On("GetRotatedSecretValue", ctx, params)}
}

func (_c *mockAkeylessAPIClient_GetRotatedSecretValue_Call) Run(run func(ctx context.Context, params akeyless.GetRotatedSecretValue)) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.GetRotatedSecretValue))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_GetRotatedSecretValue_Call) Return(_a0 map[string]interface{}, _a1 error) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_GetRotatedSecretValue_Call) RunAndReturn(run func(context.Context, akeyless.GetRotatedSecretValue) (map[string]interface{}, error)) *mockAkeylessAPIClient_GetRotatedSecretValue_Call {
	_c.Call.Return(run)
	return _c
}

// GetSSHCertificate provides a mock function with given fields: ctx, params
func (_m *mockAkeylessAPIClient) GetSSHCertificate(ctx context.Context, params akeyless.GetSSHCertificate) (akeyless.GetSSHCertificateOutput, error) {
	ret := _m.Called(ctx, params)

	if len(ret) == 0 {
		panic("no return value specified for GetSSHCertificate")
	}

	var r0 akeyless.GetSSHCertificateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetSSHCertificate) (akeyless.GetSSHCertificateOutput, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetSSHCertificate) akeyless.GetSSHCertificateOutput); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Get(0).(akeyless.GetSSHCertificateOutput)
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.GetSSHCertificate) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_GetSSHCertificate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSSHCertificate'
type mockAkeylessAPIClient_GetSSHCertificate_Call struct {
	*mock.Call
}

// GetSSHCertificate is a helper method to define mock.On call
//   - ctx context.Context
//   - params akeyless.GetSSHCertificate
func (_e *mockAkeylessAPIClient_Expecter) GetSSHCertificate(ctx interface{}, params interface{}) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	return &mockAkeylessAPIClient_GetSSHCertificate_Call{Call: _e.mock.On("GetSSHCertificate", ctx, params)}
}

func (_c *mockAkeylessAPIClient_GetSSHCertificate_Call) Run(run func(ctx context.Context, params akeyless.GetSSHCertificate)) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.GetSSHCertificate))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_GetSSHCertificate_Call) Return(_a0 akeyless.GetSSHCertificateOutput, _a1 error) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_GetSSHCertificate_Call) RunAndReturn(run func(context.Context, akeyless.GetSSHCertificate) (akeyless.GetSSHCertificateOutput, error)) *mockAkeylessAPIClient_GetSSHCertificate_Call {
	_c.Call.Return(run)
	return _c
}

// GetSecretValue provides a mock function with given fields: ctx, body
func (_m *mockAkeylessAPIClient) GetSecretValue(ctx context.Context, body akeyless.GetSecretValue) (map[string]interface{}, error) {
	ret := _m.Called(ctx, body)

	if len(ret) == 0 {
		panic("no return value specified for GetSecretValue")
	}

	var r0 map[string]interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetSecretValue) (map[string]interface{}, error)); ok {
		return rf(ctx, body)
	}
	if rf, ok := ret.Get(0).(func(context.Context, akeyless.GetSecretValue) map[string]interface{}); ok {
		r0 = rf(ctx, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, akeyless.GetSecretValue) error); ok {
		r1 = rf(ctx, body)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// mockAkeylessAPIClient_GetSecretValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecretValue'
type mockAkeylessAPIClient_GetSecretValue_Call struct {
	*mock.Call
}

// GetSecretValue is a helper method to define mock.On call
//   - ctx context.Context
//   - body akeyless.GetSecretValue
func (_e *mockAkeylessAPIClient_Expecter) GetSecretValue(ctx interface{}, body interface{}) *mockAkeylessAPIClient_GetSecretValue_Call {
	return &mockAkeylessAPIClient_GetSecretValue_Call{Call: _e.mock.On("GetSecretValue", ctx, body)}
}

func (_c *mockAkeylessAPIClient_GetSecretValue_Call) Run(run func(ctx context.Context, body akeyless.GetSecretValue)) *mockAkeylessAPIClient_GetSecretValue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(akeyless.GetSecretValue))
	})
	return _c
}

func (_c *mockAkeylessAPIClient_GetSecretValue_Call) Return(_a0 map[string]interface{}, _a1 error) *mockAkeylessAPIClient_GetSecretValue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *mockAkeylessAPIClient_GetSecretValue_Call) RunAndReturn(run func(context.Context, akeyless.GetSecretValue) (map[string]interface{}, error)) *mockAkeylessAPIClient_GetSecretValue_Call {
	_c.Call.Return(run)
	return _c
}

// newMockAkeylessAPIClient creates a new instance of mockAkeylessAPIClient. 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 newMockAkeylessAPIClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockAkeylessAPIClient {
	mock := &mockAkeylessAPIClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}