// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"github.com/bnema/gordon/internal/boundaries/out"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockDomainSecretStore is an autogenerated mock type for the DomainSecretStore type
type MockDomainSecretStore struct {
	mock.Mock
}

type MockDomainSecretStore_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDomainSecretStore) EXPECT() *MockDomainSecretStore_Expecter {
	return &MockDomainSecretStore_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) Delete(domain string, key string) error {
	ret := _mock.Called(domain, key)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(domain, key)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - domain string
//   - key string
func (_e *MockDomainSecretStore_Expecter) Delete(domain interface{}, key interface{}) *MockDomainSecretStore_Delete_Call {
	return &MockDomainSecretStore_Delete_Call{Call: _e.mock.On("Delete", domain, key)}
}

func (_c *MockDomainSecretStore_Delete_Call) Run(run func(domain string, key string)) *MockDomainSecretStore_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_Delete_Call) Return(err error) *MockDomainSecretStore_Delete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockDomainSecretStore_Delete_Call) RunAndReturn(run func(domain string, key string) error) *MockDomainSecretStore_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAttachment provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) DeleteAttachment(containerName string, key string) error {
	ret := _mock.Called(containerName, key)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(containerName, key)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteAttachment is a helper method to define mock.On call
//   - containerName string
//   - key string
func (_e *MockDomainSecretStore_Expecter) DeleteAttachment(containerName interface{}, key interface{}) *MockDomainSecretStore_DeleteAttachment_Call {
	return &MockDomainSecretStore_DeleteAttachment_Call{Call: _e.mock.On("DeleteAttachment", containerName, key)}
}

func (_c *MockDomainSecretStore_DeleteAttachment_Call) Run(run func(containerName string, key string)) *MockDomainSecretStore_DeleteAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_DeleteAttachment_Call) Return(err error) *MockDomainSecretStore_DeleteAttachment_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockDomainSecretStore_DeleteAttachment_Call) RunAndReturn(run func(containerName string, key string) error) *MockDomainSecretStore_DeleteAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// GetAll provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) GetAll(domain string) (map[string]string, error) {
	ret := _mock.Called(domain)

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

	var r0 map[string]string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (map[string]string, error)); ok {
		return returnFunc(domain)
	}
	if returnFunc, ok := ret.Get(0).(func(string) map[string]string); ok {
		r0 = returnFunc(domain)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(domain)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetAll is a helper method to define mock.On call
//   - domain string
func (_e *MockDomainSecretStore_Expecter) GetAll(domain interface{}) *MockDomainSecretStore_GetAll_Call {
	return &MockDomainSecretStore_GetAll_Call{Call: _e.mock.On("GetAll", domain)}
}

func (_c *MockDomainSecretStore_GetAll_Call) Run(run func(domain string)) *MockDomainSecretStore_GetAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_GetAll_Call) Return(stringToString map[string]string, err error) *MockDomainSecretStore_GetAll_Call {
	_c.Call.Return(stringToString, err)
	return _c
}

func (_c *MockDomainSecretStore_GetAll_Call) RunAndReturn(run func(domain string) (map[string]string, error)) *MockDomainSecretStore_GetAll_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllAttachment provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) GetAllAttachment(containerName string) (map[string]string, error) {
	ret := _mock.Called(containerName)

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

	var r0 map[string]string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (map[string]string, error)); ok {
		return returnFunc(containerName)
	}
	if returnFunc, ok := ret.Get(0).(func(string) map[string]string); ok {
		r0 = returnFunc(containerName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(containerName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetAllAttachment is a helper method to define mock.On call
//   - containerName string
func (_e *MockDomainSecretStore_Expecter) GetAllAttachment(containerName interface{}) *MockDomainSecretStore_GetAllAttachment_Call {
	return &MockDomainSecretStore_GetAllAttachment_Call{Call: _e.mock.On("GetAllAttachment", containerName)}
}

func (_c *MockDomainSecretStore_GetAllAttachment_Call) Run(run func(containerName string)) *MockDomainSecretStore_GetAllAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_GetAllAttachment_Call) Return(stringToString map[string]string, err error) *MockDomainSecretStore_GetAllAttachment_Call {
	_c.Call.Return(stringToString, err)
	return _c
}

func (_c *MockDomainSecretStore_GetAllAttachment_Call) RunAndReturn(run func(containerName string) (map[string]string, error)) *MockDomainSecretStore_GetAllAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// ListAttachmentKeys provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) ListAttachmentKeys(domain string) ([]out.AttachmentSecrets, error) {
	ret := _mock.Called(domain)

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

	var r0 []out.AttachmentSecrets
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) ([]out.AttachmentSecrets, error)); ok {
		return returnFunc(domain)
	}
	if returnFunc, ok := ret.Get(0).(func(string) []out.AttachmentSecrets); ok {
		r0 = returnFunc(domain)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]out.AttachmentSecrets)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(domain)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListAttachmentKeys is a helper method to define mock.On call
//   - domain string
func (_e *MockDomainSecretStore_Expecter) ListAttachmentKeys(domain interface{}) *MockDomainSecretStore_ListAttachmentKeys_Call {
	return &MockDomainSecretStore_ListAttachmentKeys_Call{Call: _e.mock.On("ListAttachmentKeys", domain)}
}

func (_c *MockDomainSecretStore_ListAttachmentKeys_Call) Run(run func(domain string)) *MockDomainSecretStore_ListAttachmentKeys_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_ListAttachmentKeys_Call) Return(attachmentSecretss []out.AttachmentSecrets, err error) *MockDomainSecretStore_ListAttachmentKeys_Call {
	_c.Call.Return(attachmentSecretss, err)
	return _c
}

func (_c *MockDomainSecretStore_ListAttachmentKeys_Call) RunAndReturn(run func(domain string) ([]out.AttachmentSecrets, error)) *MockDomainSecretStore_ListAttachmentKeys_Call {
	_c.Call.Return(run)
	return _c
}

// ListKeys provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) ListKeys(domain string) ([]string, error) {
	ret := _mock.Called(domain)

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

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) ([]string, error)); ok {
		return returnFunc(domain)
	}
	if returnFunc, ok := ret.Get(0).(func(string) []string); ok {
		r0 = returnFunc(domain)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(domain)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListKeys is a helper method to define mock.On call
//   - domain string
func (_e *MockDomainSecretStore_Expecter) ListKeys(domain interface{}) *MockDomainSecretStore_ListKeys_Call {
	return &MockDomainSecretStore_ListKeys_Call{Call: _e.mock.On("ListKeys", domain)}
}

func (_c *MockDomainSecretStore_ListKeys_Call) Run(run func(domain string)) *MockDomainSecretStore_ListKeys_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_ListKeys_Call) Return(strings []string, err error) *MockDomainSecretStore_ListKeys_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockDomainSecretStore_ListKeys_Call) RunAndReturn(run func(domain string) ([]string, error)) *MockDomainSecretStore_ListKeys_Call {
	_c.Call.Return(run)
	return _c
}

// Set provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) Set(domain string, secrets map[string]string) error {
	ret := _mock.Called(domain, secrets)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, map[string]string) error); ok {
		r0 = returnFunc(domain, secrets)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Set is a helper method to define mock.On call
//   - domain string
//   - secrets map[string]string
func (_e *MockDomainSecretStore_Expecter) Set(domain interface{}, secrets interface{}) *MockDomainSecretStore_Set_Call {
	return &MockDomainSecretStore_Set_Call{Call: _e.mock.On("Set", domain, secrets)}
}

func (_c *MockDomainSecretStore_Set_Call) Run(run func(domain string, secrets map[string]string)) *MockDomainSecretStore_Set_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_Set_Call) Return(err error) *MockDomainSecretStore_Set_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockDomainSecretStore_Set_Call) RunAndReturn(run func(domain string, secrets map[string]string) error) *MockDomainSecretStore_Set_Call {
	_c.Call.Return(run)
	return _c
}

// SetAttachment provides a mock function for the type MockDomainSecretStore
func (_mock *MockDomainSecretStore) SetAttachment(containerName string, secrets map[string]string) error {
	ret := _mock.Called(containerName, secrets)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, map[string]string) error); ok {
		r0 = returnFunc(containerName, secrets)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetAttachment is a helper method to define mock.On call
//   - containerName string
//   - secrets map[string]string
func (_e *MockDomainSecretStore_Expecter) SetAttachment(containerName interface{}, secrets interface{}) *MockDomainSecretStore_SetAttachment_Call {
	return &MockDomainSecretStore_SetAttachment_Call{Call: _e.mock.On("SetAttachment", containerName, secrets)}
}

func (_c *MockDomainSecretStore_SetAttachment_Call) Run(run func(containerName string, secrets map[string]string)) *MockDomainSecretStore_SetAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockDomainSecretStore_SetAttachment_Call) Return(err error) *MockDomainSecretStore_SetAttachment_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockDomainSecretStore_SetAttachment_Call) RunAndReturn(run func(containerName string, secrets map[string]string) error) *MockDomainSecretStore_SetAttachment_Call {
	_c.Call.Return(run)
	return _c
}