mock_repository.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/brittonhayes/aos (interfaces: Repository)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	fs "io/fs"
	reflect "reflect"

	api "github.com/brittonhayes/aos/api"
	gomock "go.uber.org/mock/gomock"
)

// MockRepository is a mock of Repository interface.
type MockRepository struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryMockRecorder
}

// MockRepositoryMockRecorder is the mock recorder for MockRepository.
type MockRepositoryMockRecorder struct {
	mock *MockRepository
}

// NewMockRepository creates a new mock instance.
func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
	mock := &MockRepository{ctrl: ctrl}
	mock.recorder = &MockRepositoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
	return m.recorder
}

// Generate mocks base method.
func (m *MockRepository) Generate(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Generate", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Generate indicates an expected call of Generate.
func (mr *MockRepositoryMockRecorder) Generate(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockRepository)(nil).Generate), arg0, arg1)
}

// GetAbilitiesForUnitByID mocks base method.
func (m *MockRepository) GetAbilitiesForUnitByID(arg0 context.Context, arg1 string) ([]api.Ability, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAbilitiesForUnitByID", arg0, arg1)
	ret0, _ := ret[0].([]api.Ability)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAbilitiesForUnitByID indicates an expected call of GetAbilitiesForUnitByID.
func (mr *MockRepositoryMockRecorder) GetAbilitiesForUnitByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAbilitiesForUnitByID", reflect.TypeOf((*MockRepository)(nil).GetAbilitiesForUnitByID), arg0, arg1)
}

// GetAllegianceByID mocks base method.
func (m *MockRepository) GetAllegianceByID(arg0 context.Context, arg1 string) (*api.Allegiance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllegianceByID", arg0, arg1)
	ret0, _ := ret[0].(*api.Allegiance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllegianceByID indicates an expected call of GetAllegianceByID.
func (mr *MockRepositoryMockRecorder) GetAllegianceByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllegianceByID", reflect.TypeOf((*MockRepository)(nil).GetAllegianceByID), arg0, arg1)
}

// GetAllegiances mocks base method.
func (m *MockRepository) GetAllegiances(arg0 context.Context, arg1 *api.GetAllegiancesParams) ([]api.Allegiance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllegiances", arg0, arg1)
	ret0, _ := ret[0].([]api.Allegiance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllegiances indicates an expected call of GetAllegiances.
func (mr *MockRepositoryMockRecorder) GetAllegiances(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllegiances", reflect.TypeOf((*MockRepository)(nil).GetAllegiances), arg0, arg1)
}

// GetArmies mocks base method.
func (m *MockRepository) GetArmies(arg0 context.Context) ([]api.Army, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArmies", arg0)
	ret0, _ := ret[0].([]api.Army)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArmies indicates an expected call of GetArmies.
func (mr *MockRepositoryMockRecorder) GetArmies(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArmies", reflect.TypeOf((*MockRepository)(nil).GetArmies), arg0)
}

// GetArmyByID mocks base method.
func (m *MockRepository) GetArmyByID(arg0 context.Context, arg1 string) (*api.Army, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArmyByID", arg0, arg1)
	ret0, _ := ret[0].(*api.Army)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArmyByID indicates an expected call of GetArmyByID.
func (mr *MockRepositoryMockRecorder) GetArmyByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArmyByID", reflect.TypeOf((*MockRepository)(nil).GetArmyByID), arg0, arg1)
}

// GetCities mocks base method.
func (m *MockRepository) GetCities(arg0 context.Context, arg1 *api.GetCitiesParams) ([]api.City, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCities", arg0, arg1)
	ret0, _ := ret[0].([]api.City)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCities indicates an expected call of GetCities.
func (mr *MockRepositoryMockRecorder) GetCities(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCities", reflect.TypeOf((*MockRepository)(nil).GetCities), arg0, arg1)
}

// GetCityByID mocks base method.
func (m *MockRepository) GetCityByID(arg0 context.Context, arg1 string) (*api.City, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCityByID", arg0, arg1)
	ret0, _ := ret[0].(*api.City)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCityByID indicates an expected call of GetCityByID.
func (mr *MockRepositoryMockRecorder) GetCityByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCityByID", reflect.TypeOf((*MockRepository)(nil).GetCityByID), arg0, arg1)
}

// GetGrandAllianceByID mocks base method.
func (m *MockRepository) GetGrandAllianceByID(arg0 context.Context, arg1 string) (*api.GrandAlliance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGrandAllianceByID", arg0, arg1)
	ret0, _ := ret[0].(*api.GrandAlliance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGrandAllianceByID indicates an expected call of GetGrandAllianceByID.
func (mr *MockRepositoryMockRecorder) GetGrandAllianceByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrandAllianceByID", reflect.TypeOf((*MockRepository)(nil).GetGrandAllianceByID), arg0, arg1)
}

// GetGrandAlliances mocks base method.
func (m *MockRepository) GetGrandAlliances(arg0 context.Context) ([]api.GrandAlliance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGrandAlliances", arg0)
	ret0, _ := ret[0].([]api.GrandAlliance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGrandAlliances indicates an expected call of GetGrandAlliances.
func (mr *MockRepositoryMockRecorder) GetGrandAlliances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrandAlliances", reflect.TypeOf((*MockRepository)(nil).GetGrandAlliances), arg0)
}

// GetGrandStrategies mocks base method.
func (m *MockRepository) GetGrandStrategies(arg0 context.Context) ([]api.GrandStrategy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGrandStrategies", arg0)
	ret0, _ := ret[0].([]api.GrandStrategy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGrandStrategies indicates an expected call of GetGrandStrategies.
func (mr *MockRepositoryMockRecorder) GetGrandStrategies(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrandStrategies", reflect.TypeOf((*MockRepository)(nil).GetGrandStrategies), arg0)
}

// GetGrandStrategyByID mocks base method.
func (m *MockRepository) GetGrandStrategyByID(arg0 context.Context, arg1 string) (*api.GrandStrategy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGrandStrategyByID", arg0, arg1)
	ret0, _ := ret[0].(*api.GrandStrategy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGrandStrategyByID indicates an expected call of GetGrandStrategyByID.
func (mr *MockRepositoryMockRecorder) GetGrandStrategyByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrandStrategyByID", reflect.TypeOf((*MockRepository)(nil).GetGrandStrategyByID), arg0, arg1)
}

// GetUnitByID mocks base method.
func (m *MockRepository) GetUnitByID(arg0 context.Context, arg1 string) (*api.Unit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUnitByID", arg0, arg1)
	ret0, _ := ret[0].(*api.Unit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUnitByID indicates an expected call of GetUnitByID.
func (mr *MockRepositoryMockRecorder) GetUnitByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnitByID", reflect.TypeOf((*MockRepository)(nil).GetUnitByID), arg0, arg1)
}

// GetUnits mocks base method.
func (m *MockRepository) GetUnits(arg0 context.Context, arg1 *api.GetUnitsParams) ([]api.Unit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUnits", arg0, arg1)
	ret0, _ := ret[0].([]api.Unit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUnits indicates an expected call of GetUnits.
func (mr *MockRepositoryMockRecorder) GetUnits(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnits", reflect.TypeOf((*MockRepository)(nil).GetUnits), arg0, arg1)
}

// GetWarscrollByID mocks base method.
func (m *MockRepository) GetWarscrollByID(arg0 context.Context, arg1 string) (*api.Warscroll, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWarscrollByID", arg0, arg1)
	ret0, _ := ret[0].(*api.Warscroll)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWarscrollByID indicates an expected call of GetWarscrollByID.
func (mr *MockRepositoryMockRecorder) GetWarscrollByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWarscrollByID", reflect.TypeOf((*MockRepository)(nil).GetWarscrollByID), arg0, arg1)
}

// GetWarscrolls mocks base method.
func (m *MockRepository) GetWarscrolls(arg0 context.Context, arg1 *api.GetWarscrollsParams) ([]api.Warscroll, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWarscrolls", arg0, arg1)
	ret0, _ := ret[0].([]api.Warscroll)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWarscrolls indicates an expected call of GetWarscrolls.
func (mr *MockRepositoryMockRecorder) GetWarscrolls(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWarscrolls", reflect.TypeOf((*MockRepository)(nil).GetWarscrolls), arg0, arg1)
}

// GetWeaponsForUnitByID mocks base method.
func (m *MockRepository) GetWeaponsForUnitByID(arg0 context.Context, arg1 string) (*api.WeaponsGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWeaponsForUnitByID", arg0, arg1)
	ret0, _ := ret[0].(*api.WeaponsGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWeaponsForUnitByID indicates an expected call of GetWeaponsForUnitByID.
func (mr *MockRepositoryMockRecorder) GetWeaponsForUnitByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWeaponsForUnitByID", reflect.TypeOf((*MockRepository)(nil).GetWeaponsForUnitByID), arg0, arg1)
}

// Init mocks base method.
func (m *MockRepository) Init(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockRepositoryMockRecorder) Init(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockRepository)(nil).Init), arg0)
}

// Lock mocks base method.
func (m *MockRepository) Lock(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Lock", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Lock indicates an expected call of Lock.
func (mr *MockRepositoryMockRecorder) Lock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockRepository)(nil).Lock), arg0)
}

// Migrate mocks base method.
func (m *MockRepository) Migrate(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Migrate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Migrate indicates an expected call of Migrate.
func (mr *MockRepositoryMockRecorder) Migrate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockRepository)(nil).Migrate), arg0)
}

// Rollback mocks base method.
func (m *MockRepository) Rollback(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rollback", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback.
func (mr *MockRepositoryMockRecorder) Rollback(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockRepository)(nil).Rollback), arg0)
}

// Seed mocks base method.
func (m *MockRepository) Seed(arg0 context.Context, arg1 fs.FS, arg2 ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Seed", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Seed indicates an expected call of Seed.
func (mr *MockRepositoryMockRecorder) Seed(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, "Seed", reflect.TypeOf((*MockRepository)(nil).Seed), varargs...)
}

// Unlock mocks base method.
func (m *MockRepository) Unlock(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unlock", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unlock indicates an expected call of Unlock.
func (mr *MockRepositoryMockRecorder) Unlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockRepository)(nil).Unlock), arg0)
}