mocks

package
v0.2.9-alpha Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 22, 2026 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockActressAliasRepositoryInterface 

type MockActressAliasRepositoryInterface struct {
	mock.Mock
}

MockActressAliasRepositoryInterface is an autogenerated mock type for the ActressAliasRepositoryInterface type

func NewMockActressAliasRepositoryInterface 

func NewMockActressAliasRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockActressAliasRepositoryInterface

NewMockActressAliasRepositoryInterface creates a new instance of MockActressAliasRepositoryInterface. 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 (*MockActressAliasRepositoryInterface) Create 

func (_mock *MockActressAliasRepositoryInterface) Create(alias *models.ActressAlias) error

Create provides a mock function for the type MockActressAliasRepositoryInterface

func (*MockActressAliasRepositoryInterface) Delete 

func (_mock *MockActressAliasRepositoryInterface) Delete(aliasName string) error

Delete provides a mock function for the type MockActressAliasRepositoryInterface

func (*MockActressAliasRepositoryInterface) EXPECT 

func (_m *MockActressAliasRepositoryInterface) EXPECT() *MockActressAliasRepositoryInterface_Expecter

func (*MockActressAliasRepositoryInterface) FindByAliasName 

func (_mock *MockActressAliasRepositoryInterface) FindByAliasName(aliasName string) (*models.ActressAlias, error)

FindByAliasName provides a mock function for the type MockActressAliasRepositoryInterface

func (*MockActressAliasRepositoryInterface) FindByCanonicalName 

func (_mock *MockActressAliasRepositoryInterface) FindByCanonicalName(canonicalName string) ([]models.ActressAlias, error)

FindByCanonicalName provides a mock function for the type MockActressAliasRepositoryInterface

func (*MockActressAliasRepositoryInterface) GetAliasMap 

func (_mock *MockActressAliasRepositoryInterface) GetAliasMap() (map[string]string, error)

GetAliasMap provides a mock function for the type MockActressAliasRepositoryInterface

func (*MockActressAliasRepositoryInterface) List 

func (_mock *MockActressAliasRepositoryInterface) List() ([]models.ActressAlias, error)

List provides a mock function for the type MockActressAliasRepositoryInterface

func (*MockActressAliasRepositoryInterface) Upsert 

func (_mock *MockActressAliasRepositoryInterface) Upsert(alias *models.ActressAlias) error

Upsert provides a mock function for the type MockActressAliasRepositoryInterface

type MockActressAliasRepositoryInterface_Create_Call 

type MockActressAliasRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockActressAliasRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockActressAliasRepositoryInterface_Create_Call) Return 

func (_c *MockActressAliasRepositoryInterface_Create_Call) Return(err error) *MockActressAliasRepositoryInterface_Create_Call

func (*MockActressAliasRepositoryInterface_Create_Call) Run 

func (_c *MockActressAliasRepositoryInterface_Create_Call) Run(run func(alias *models.ActressAlias)) *MockActressAliasRepositoryInterface_Create_Call

func (*MockActressAliasRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_Create_Call) RunAndReturn(run func(alias *models.ActressAlias) error) *MockActressAliasRepositoryInterface_Create_Call

type MockActressAliasRepositoryInterface_Delete_Call 

type MockActressAliasRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockActressAliasRepositoryInterface_Delete_Call) Return 

func (_c *MockActressAliasRepositoryInterface_Delete_Call) Return(err error) *MockActressAliasRepositoryInterface_Delete_Call

func (*MockActressAliasRepositoryInterface_Delete_Call) Run 

func (_c *MockActressAliasRepositoryInterface_Delete_Call) Run(run func(aliasName string)) *MockActressAliasRepositoryInterface_Delete_Call

func (*MockActressAliasRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_Delete_Call) RunAndReturn(run func(aliasName string) error) *MockActressAliasRepositoryInterface_Delete_Call

type MockActressAliasRepositoryInterface_Expecter 

type MockActressAliasRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockActressAliasRepositoryInterface_Expecter) Create 

func (_e *MockActressAliasRepositoryInterface_Expecter) Create(alias interface{}) *MockActressAliasRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • alias *models.ActressAlias

func (*MockActressAliasRepositoryInterface_Expecter) Delete 

func (_e *MockActressAliasRepositoryInterface_Expecter) Delete(aliasName interface{}) *MockActressAliasRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • aliasName string

func (*MockActressAliasRepositoryInterface_Expecter) FindByAliasName 

func (_e *MockActressAliasRepositoryInterface_Expecter) FindByAliasName(aliasName interface{}) *MockActressAliasRepositoryInterface_FindByAliasName_Call

FindByAliasName is a helper method to define mock.On call

  • aliasName string

func (*MockActressAliasRepositoryInterface_Expecter) FindByCanonicalName 

func (_e *MockActressAliasRepositoryInterface_Expecter) FindByCanonicalName(canonicalName interface{}) *MockActressAliasRepositoryInterface_FindByCanonicalName_Call

FindByCanonicalName is a helper method to define mock.On call

  • canonicalName string

func (*MockActressAliasRepositoryInterface_Expecter) GetAliasMap 

func (_e *MockActressAliasRepositoryInterface_Expecter) GetAliasMap() *MockActressAliasRepositoryInterface_GetAliasMap_Call

GetAliasMap is a helper method to define mock.On call

func (*MockActressAliasRepositoryInterface_Expecter) List 

func (_e *MockActressAliasRepositoryInterface_Expecter) List() *MockActressAliasRepositoryInterface_List_Call

List is a helper method to define mock.On call

func (*MockActressAliasRepositoryInterface_Expecter) Upsert 

func (_e *MockActressAliasRepositoryInterface_Expecter) Upsert(alias interface{}) *MockActressAliasRepositoryInterface_Upsert_Call

Upsert is a helper method to define mock.On call

  • alias *models.ActressAlias

type MockActressAliasRepositoryInterface_FindByAliasName_Call 

type MockActressAliasRepositoryInterface_FindByAliasName_Call struct {
	*mock.Call
}

MockActressAliasRepositoryInterface_FindByAliasName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByAliasName'

func (*MockActressAliasRepositoryInterface_FindByAliasName_Call) Return 

func (_c *MockActressAliasRepositoryInterface_FindByAliasName_Call) Return(actressAlias *models.ActressAlias, err error) *MockActressAliasRepositoryInterface_FindByAliasName_Call

func (*MockActressAliasRepositoryInterface_FindByAliasName_Call) Run 

func (_c *MockActressAliasRepositoryInterface_FindByAliasName_Call) Run(run func(aliasName string)) *MockActressAliasRepositoryInterface_FindByAliasName_Call

func (*MockActressAliasRepositoryInterface_FindByAliasName_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_FindByAliasName_Call) RunAndReturn(run func(aliasName string) (*models.ActressAlias, error)) *MockActressAliasRepositoryInterface_FindByAliasName_Call

type MockActressAliasRepositoryInterface_FindByCanonicalName_Call 

type MockActressAliasRepositoryInterface_FindByCanonicalName_Call struct {
	*mock.Call
}

MockActressAliasRepositoryInterface_FindByCanonicalName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByCanonicalName'

func (*MockActressAliasRepositoryInterface_FindByCanonicalName_Call) Return 

func (_c *MockActressAliasRepositoryInterface_FindByCanonicalName_Call) Return(actressAliass []models.ActressAlias, err error) *MockActressAliasRepositoryInterface_FindByCanonicalName_Call

func (*MockActressAliasRepositoryInterface_FindByCanonicalName_Call) Run 

func (_c *MockActressAliasRepositoryInterface_FindByCanonicalName_Call) Run(run func(canonicalName string)) *MockActressAliasRepositoryInterface_FindByCanonicalName_Call

func (*MockActressAliasRepositoryInterface_FindByCanonicalName_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_FindByCanonicalName_Call) RunAndReturn(run func(canonicalName string) ([]models.ActressAlias, error)) *MockActressAliasRepositoryInterface_FindByCanonicalName_Call

type MockActressAliasRepositoryInterface_GetAliasMap_Call 

type MockActressAliasRepositoryInterface_GetAliasMap_Call struct {
	*mock.Call
}

MockActressAliasRepositoryInterface_GetAliasMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAliasMap'

func (*MockActressAliasRepositoryInterface_GetAliasMap_Call) Return 

func (_c *MockActressAliasRepositoryInterface_GetAliasMap_Call) Return(stringToString map[string]string, err error) *MockActressAliasRepositoryInterface_GetAliasMap_Call

func (*MockActressAliasRepositoryInterface_GetAliasMap_Call) Run 

func (_c *MockActressAliasRepositoryInterface_GetAliasMap_Call) Run(run func()) *MockActressAliasRepositoryInterface_GetAliasMap_Call

func (*MockActressAliasRepositoryInterface_GetAliasMap_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_GetAliasMap_Call) RunAndReturn(run func() (map[string]string, error)) *MockActressAliasRepositoryInterface_GetAliasMap_Call

type MockActressAliasRepositoryInterface_List_Call 

type MockActressAliasRepositoryInterface_List_Call struct {
	*mock.Call
}

MockActressAliasRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockActressAliasRepositoryInterface_List_Call) Return 

func (_c *MockActressAliasRepositoryInterface_List_Call) Return(actressAliass []models.ActressAlias, err error) *MockActressAliasRepositoryInterface_List_Call

func (*MockActressAliasRepositoryInterface_List_Call) Run 

func (_c *MockActressAliasRepositoryInterface_List_Call) Run(run func()) *MockActressAliasRepositoryInterface_List_Call

func (*MockActressAliasRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_List_Call) RunAndReturn(run func() ([]models.ActressAlias, error)) *MockActressAliasRepositoryInterface_List_Call

type MockActressAliasRepositoryInterface_Upsert_Call 

type MockActressAliasRepositoryInterface_Upsert_Call struct {
	*mock.Call
}

MockActressAliasRepositoryInterface_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'

func (*MockActressAliasRepositoryInterface_Upsert_Call) Return 

func (_c *MockActressAliasRepositoryInterface_Upsert_Call) Return(err error) *MockActressAliasRepositoryInterface_Upsert_Call

func (*MockActressAliasRepositoryInterface_Upsert_Call) Run 

func (_c *MockActressAliasRepositoryInterface_Upsert_Call) Run(run func(alias *models.ActressAlias)) *MockActressAliasRepositoryInterface_Upsert_Call

func (*MockActressAliasRepositoryInterface_Upsert_Call) RunAndReturn 

func (_c *MockActressAliasRepositoryInterface_Upsert_Call) RunAndReturn(run func(alias *models.ActressAlias) error) *MockActressAliasRepositoryInterface_Upsert_Call

type MockActressRepositoryInterface 

type MockActressRepositoryInterface struct {
	mock.Mock
}

MockActressRepositoryInterface is an autogenerated mock type for the ActressRepositoryInterface type

func NewMockActressRepositoryInterface 

func NewMockActressRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockActressRepositoryInterface

NewMockActressRepositoryInterface creates a new instance of MockActressRepositoryInterface. 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 (*MockActressRepositoryInterface) Create 

func (_mock *MockActressRepositoryInterface) Create(actress *models.Actress) error

Create provides a mock function for the type MockActressRepositoryInterface

func (*MockActressRepositoryInterface) EXPECT 

func (_m *MockActressRepositoryInterface) EXPECT() *MockActressRepositoryInterface_Expecter

func (*MockActressRepositoryInterface) FindByJapaneseName 

func (_mock *MockActressRepositoryInterface) FindByJapaneseName(name string) (*models.Actress, error)

FindByJapaneseName provides a mock function for the type MockActressRepositoryInterface

func (*MockActressRepositoryInterface) FindOrCreate 

func (_mock *MockActressRepositoryInterface) FindOrCreate(actress *models.Actress) error

FindOrCreate provides a mock function for the type MockActressRepositoryInterface

func (*MockActressRepositoryInterface) List 

func (_mock *MockActressRepositoryInterface) List(limit int, offset int) ([]models.Actress, error)

List provides a mock function for the type MockActressRepositoryInterface

func (*MockActressRepositoryInterface) Search 

func (_mock *MockActressRepositoryInterface) Search(query string) ([]models.Actress, error)

Search provides a mock function for the type MockActressRepositoryInterface

func (*MockActressRepositoryInterface) Update 

func (_mock *MockActressRepositoryInterface) Update(actress *models.Actress) error

Update provides a mock function for the type MockActressRepositoryInterface

type MockActressRepositoryInterface_Create_Call 

type MockActressRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockActressRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockActressRepositoryInterface_Create_Call) Return 

func (_c *MockActressRepositoryInterface_Create_Call) Return(err error) *MockActressRepositoryInterface_Create_Call

func (*MockActressRepositoryInterface_Create_Call) Run 

func (_c *MockActressRepositoryInterface_Create_Call) Run(run func(actress *models.Actress)) *MockActressRepositoryInterface_Create_Call

func (*MockActressRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockActressRepositoryInterface_Create_Call) RunAndReturn(run func(actress *models.Actress) error) *MockActressRepositoryInterface_Create_Call

type MockActressRepositoryInterface_Expecter 

type MockActressRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockActressRepositoryInterface_Expecter) Create 

func (_e *MockActressRepositoryInterface_Expecter) Create(actress interface{}) *MockActressRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • actress *models.Actress

func (*MockActressRepositoryInterface_Expecter) FindByJapaneseName 

func (_e *MockActressRepositoryInterface_Expecter) FindByJapaneseName(name interface{}) *MockActressRepositoryInterface_FindByJapaneseName_Call

FindByJapaneseName is a helper method to define mock.On call

  • name string

func (*MockActressRepositoryInterface_Expecter) FindOrCreate 

func (_e *MockActressRepositoryInterface_Expecter) FindOrCreate(actress interface{}) *MockActressRepositoryInterface_FindOrCreate_Call

FindOrCreate is a helper method to define mock.On call

  • actress *models.Actress

func (*MockActressRepositoryInterface_Expecter) List 

func (_e *MockActressRepositoryInterface_Expecter) List(limit interface{}, offset interface{}) *MockActressRepositoryInterface_List_Call

List is a helper method to define mock.On call

  • limit int
  • offset int

func (*MockActressRepositoryInterface_Expecter) Search 

func (_e *MockActressRepositoryInterface_Expecter) Search(query interface{}) *MockActressRepositoryInterface_Search_Call

Search is a helper method to define mock.On call

  • query string

func (*MockActressRepositoryInterface_Expecter) Update 

func (_e *MockActressRepositoryInterface_Expecter) Update(actress interface{}) *MockActressRepositoryInterface_Update_Call

Update is a helper method to define mock.On call

  • actress *models.Actress

type MockActressRepositoryInterface_FindByJapaneseName_Call 

type MockActressRepositoryInterface_FindByJapaneseName_Call struct {
	*mock.Call
}

MockActressRepositoryInterface_FindByJapaneseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByJapaneseName'

func (*MockActressRepositoryInterface_FindByJapaneseName_Call) Return 

func (_c *MockActressRepositoryInterface_FindByJapaneseName_Call) Return(actress *models.Actress, err error) *MockActressRepositoryInterface_FindByJapaneseName_Call

func (*MockActressRepositoryInterface_FindByJapaneseName_Call) Run 

func (_c *MockActressRepositoryInterface_FindByJapaneseName_Call) Run(run func(name string)) *MockActressRepositoryInterface_FindByJapaneseName_Call

func (*MockActressRepositoryInterface_FindByJapaneseName_Call) RunAndReturn 

func (_c *MockActressRepositoryInterface_FindByJapaneseName_Call) RunAndReturn(run func(name string) (*models.Actress, error)) *MockActressRepositoryInterface_FindByJapaneseName_Call

type MockActressRepositoryInterface_FindOrCreate_Call 

type MockActressRepositoryInterface_FindOrCreate_Call struct {
	*mock.Call
}

MockActressRepositoryInterface_FindOrCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindOrCreate'

func (*MockActressRepositoryInterface_FindOrCreate_Call) Return 

func (_c *MockActressRepositoryInterface_FindOrCreate_Call) Return(err error) *MockActressRepositoryInterface_FindOrCreate_Call

func (*MockActressRepositoryInterface_FindOrCreate_Call) Run 

func (_c *MockActressRepositoryInterface_FindOrCreate_Call) Run(run func(actress *models.Actress)) *MockActressRepositoryInterface_FindOrCreate_Call

func (*MockActressRepositoryInterface_FindOrCreate_Call) RunAndReturn 

func (_c *MockActressRepositoryInterface_FindOrCreate_Call) RunAndReturn(run func(actress *models.Actress) error) *MockActressRepositoryInterface_FindOrCreate_Call

type MockActressRepositoryInterface_List_Call 

type MockActressRepositoryInterface_List_Call struct {
	*mock.Call
}

MockActressRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockActressRepositoryInterface_List_Call) Return 

func (_c *MockActressRepositoryInterface_List_Call) Return(actresss []models.Actress, err error) *MockActressRepositoryInterface_List_Call

func (*MockActressRepositoryInterface_List_Call) Run 

func (_c *MockActressRepositoryInterface_List_Call) Run(run func(limit int, offset int)) *MockActressRepositoryInterface_List_Call

func (*MockActressRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockActressRepositoryInterface_List_Call) RunAndReturn(run func(limit int, offset int) ([]models.Actress, error)) *MockActressRepositoryInterface_List_Call

type MockActressRepositoryInterface_Search_Call 

type MockActressRepositoryInterface_Search_Call struct {
	*mock.Call
}

MockActressRepositoryInterface_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'

func (*MockActressRepositoryInterface_Search_Call) Return 

func (_c *MockActressRepositoryInterface_Search_Call) Return(actresss []models.Actress, err error) *MockActressRepositoryInterface_Search_Call

func (*MockActressRepositoryInterface_Search_Call) Run 

func (_c *MockActressRepositoryInterface_Search_Call) Run(run func(query string)) *MockActressRepositoryInterface_Search_Call

func (*MockActressRepositoryInterface_Search_Call) RunAndReturn 

func (_c *MockActressRepositoryInterface_Search_Call) RunAndReturn(run func(query string) ([]models.Actress, error)) *MockActressRepositoryInterface_Search_Call

type MockActressRepositoryInterface_Update_Call 

type MockActressRepositoryInterface_Update_Call struct {
	*mock.Call
}

MockActressRepositoryInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockActressRepositoryInterface_Update_Call) Return 

func (_c *MockActressRepositoryInterface_Update_Call) Return(err error) *MockActressRepositoryInterface_Update_Call

func (*MockActressRepositoryInterface_Update_Call) Run 

func (_c *MockActressRepositoryInterface_Update_Call) Run(run func(actress *models.Actress)) *MockActressRepositoryInterface_Update_Call

func (*MockActressRepositoryInterface_Update_Call) RunAndReturn 

func (_c *MockActressRepositoryInterface_Update_Call) RunAndReturn(run func(actress *models.Actress) error) *MockActressRepositoryInterface_Update_Call

type MockAggregatorInterface 

type MockAggregatorInterface struct {
	mock.Mock
}

MockAggregatorInterface is an autogenerated mock type for the AggregatorInterface type

func NewMockAggregatorInterface 

func NewMockAggregatorInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAggregatorInterface

NewMockAggregatorInterface creates a new instance of MockAggregatorInterface. 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 (*MockAggregatorInterface) Aggregate 

func (_mock *MockAggregatorInterface) Aggregate(results []*models.ScraperResult) (*models.Movie, error)

Aggregate provides a mock function for the type MockAggregatorInterface

func (*MockAggregatorInterface) AggregateWithPriority 

func (_mock *MockAggregatorInterface) AggregateWithPriority(results []*models.ScraperResult, customPriority []string) (*models.Movie, error)

AggregateWithPriority provides a mock function for the type MockAggregatorInterface

func (*MockAggregatorInterface) EXPECT 

func (_m *MockAggregatorInterface) EXPECT() *MockAggregatorInterface_Expecter

func (*MockAggregatorInterface) GetResolvedPriorities 

func (_mock *MockAggregatorInterface) GetResolvedPriorities() map[string][]string

GetResolvedPriorities provides a mock function for the type MockAggregatorInterface

type MockAggregatorInterface_AggregateWithPriority_Call 

type MockAggregatorInterface_AggregateWithPriority_Call struct {
	*mock.Call
}

MockAggregatorInterface_AggregateWithPriority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AggregateWithPriority'

func (*MockAggregatorInterface_AggregateWithPriority_Call) Return 

func (_c *MockAggregatorInterface_AggregateWithPriority_Call) Return(movie *models.Movie, err error) *MockAggregatorInterface_AggregateWithPriority_Call

func (*MockAggregatorInterface_AggregateWithPriority_Call) Run 

func (_c *MockAggregatorInterface_AggregateWithPriority_Call) Run(run func(results []*models.ScraperResult, customPriority []string)) *MockAggregatorInterface_AggregateWithPriority_Call

func (*MockAggregatorInterface_AggregateWithPriority_Call) RunAndReturn 

func (_c *MockAggregatorInterface_AggregateWithPriority_Call) RunAndReturn(run func(results []*models.ScraperResult, customPriority []string) (*models.Movie, error)) *MockAggregatorInterface_AggregateWithPriority_Call

type MockAggregatorInterface_Aggregate_Call 

type MockAggregatorInterface_Aggregate_Call struct {
	*mock.Call
}

MockAggregatorInterface_Aggregate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Aggregate'

func (*MockAggregatorInterface_Aggregate_Call) Return 

func (_c *MockAggregatorInterface_Aggregate_Call) Return(movie *models.Movie, err error) *MockAggregatorInterface_Aggregate_Call

func (*MockAggregatorInterface_Aggregate_Call) Run 

func (_c *MockAggregatorInterface_Aggregate_Call) Run(run func(results []*models.ScraperResult)) *MockAggregatorInterface_Aggregate_Call

func (*MockAggregatorInterface_Aggregate_Call) RunAndReturn 

func (_c *MockAggregatorInterface_Aggregate_Call) RunAndReturn(run func(results []*models.ScraperResult) (*models.Movie, error)) *MockAggregatorInterface_Aggregate_Call

type MockAggregatorInterface_Expecter 

type MockAggregatorInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockAggregatorInterface_Expecter) Aggregate 

func (_e *MockAggregatorInterface_Expecter) Aggregate(results interface{}) *MockAggregatorInterface_Aggregate_Call

Aggregate is a helper method to define mock.On call

  • results []*models.ScraperResult

func (*MockAggregatorInterface_Expecter) AggregateWithPriority 

func (_e *MockAggregatorInterface_Expecter) AggregateWithPriority(results interface{}, customPriority interface{}) *MockAggregatorInterface_AggregateWithPriority_Call

AggregateWithPriority is a helper method to define mock.On call

  • results []*models.ScraperResult
  • customPriority []string

func (*MockAggregatorInterface_Expecter) GetResolvedPriorities 

func (_e *MockAggregatorInterface_Expecter) GetResolvedPriorities() *MockAggregatorInterface_GetResolvedPriorities_Call

GetResolvedPriorities is a helper method to define mock.On call

type MockAggregatorInterface_GetResolvedPriorities_Call 

type MockAggregatorInterface_GetResolvedPriorities_Call struct {
	*mock.Call
}

MockAggregatorInterface_GetResolvedPriorities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResolvedPriorities'

func (*MockAggregatorInterface_GetResolvedPriorities_Call) Return 

func (_c *MockAggregatorInterface_GetResolvedPriorities_Call) Return(stringToStrings map[string][]string) *MockAggregatorInterface_GetResolvedPriorities_Call

func (*MockAggregatorInterface_GetResolvedPriorities_Call) Run 

func (_c *MockAggregatorInterface_GetResolvedPriorities_Call) Run(run func()) *MockAggregatorInterface_GetResolvedPriorities_Call

func (*MockAggregatorInterface_GetResolvedPriorities_Call) RunAndReturn 

func (_c *MockAggregatorInterface_GetResolvedPriorities_Call) RunAndReturn(run func() map[string][]string) *MockAggregatorInterface_GetResolvedPriorities_Call

type MockBatchFileOperationRepositoryInterface 

type MockBatchFileOperationRepositoryInterface struct {
	mock.Mock
}

MockBatchFileOperationRepositoryInterface is an autogenerated mock type for the BatchFileOperationRepositoryInterface type

func NewMockBatchFileOperationRepositoryInterface 

func NewMockBatchFileOperationRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBatchFileOperationRepositoryInterface

NewMockBatchFileOperationRepositoryInterface creates a new instance of MockBatchFileOperationRepositoryInterface. 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 (*MockBatchFileOperationRepositoryInterface) CountByBatchJobID 

func (_mock *MockBatchFileOperationRepositoryInterface) CountByBatchJobID(batchJobID string) (int64, error)

CountByBatchJobID provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) CountByBatchJobIDAndRevertStatus 

func (_mock *MockBatchFileOperationRepositoryInterface) CountByBatchJobIDAndRevertStatus(batchJobID string, status string) (int64, error)

CountByBatchJobIDAndRevertStatus provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) Create 

func (_mock *MockBatchFileOperationRepositoryInterface) Create(op *models.BatchFileOperation) error

Create provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) CreateBatch 

func (_mock *MockBatchFileOperationRepositoryInterface) CreateBatch(ops []*models.BatchFileOperation) error

CreateBatch provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) EXPECT 

func (_m *MockBatchFileOperationRepositoryInterface) EXPECT() *MockBatchFileOperationRepositoryInterface_Expecter

func (*MockBatchFileOperationRepositoryInterface) FindByBatchJobID 

func (_mock *MockBatchFileOperationRepositoryInterface) FindByBatchJobID(batchJobID string) ([]models.BatchFileOperation, error)

FindByBatchJobID provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) FindByBatchJobIDAndRevertStatus 

func (_mock *MockBatchFileOperationRepositoryInterface) FindByBatchJobIDAndRevertStatus(batchJobID string, revertStatus string) ([]models.BatchFileOperation, error)

FindByBatchJobIDAndRevertStatus provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) FindByID 

func (_mock *MockBatchFileOperationRepositoryInterface) FindByID(id uint) (*models.BatchFileOperation, error)

FindByID provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) Update 

func (_mock *MockBatchFileOperationRepositoryInterface) Update(op *models.BatchFileOperation) error

Update provides a mock function for the type MockBatchFileOperationRepositoryInterface

func (*MockBatchFileOperationRepositoryInterface) UpdateRevertStatus 

func (_mock *MockBatchFileOperationRepositoryInterface) UpdateRevertStatus(id uint, status string) error

UpdateRevertStatus provides a mock function for the type MockBatchFileOperationRepositoryInterface

type MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call 

type MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByBatchJobIDAndRevertStatus'

func (*MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call) Return(n int64, err error) *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call

func (*MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call) Run(run func(batchJobID string, status string)) *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call

func (*MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call) RunAndReturn(run func(batchJobID string, status string) (int64, error)) *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call

type MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call 

type MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByBatchJobID'

func (*MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call) Return(n int64, err error) *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call

func (*MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call) Run(run func(batchJobID string)) *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call

func (*MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call) RunAndReturn(run func(batchJobID string) (int64, error)) *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call

type MockBatchFileOperationRepositoryInterface_CreateBatch_Call 

type MockBatchFileOperationRepositoryInterface_CreateBatch_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_CreateBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBatch'

func (*MockBatchFileOperationRepositoryInterface_CreateBatch_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_CreateBatch_Call) Return(err error) *MockBatchFileOperationRepositoryInterface_CreateBatch_Call

func (*MockBatchFileOperationRepositoryInterface_CreateBatch_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_CreateBatch_Call) Run(run func(ops []*models.BatchFileOperation)) *MockBatchFileOperationRepositoryInterface_CreateBatch_Call

func (*MockBatchFileOperationRepositoryInterface_CreateBatch_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_CreateBatch_Call) RunAndReturn(run func(ops []*models.BatchFileOperation) error) *MockBatchFileOperationRepositoryInterface_CreateBatch_Call

type MockBatchFileOperationRepositoryInterface_Create_Call 

type MockBatchFileOperationRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockBatchFileOperationRepositoryInterface_Create_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_Create_Call) Return(err error) *MockBatchFileOperationRepositoryInterface_Create_Call

func (*MockBatchFileOperationRepositoryInterface_Create_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_Create_Call) Run(run func(op *models.BatchFileOperation)) *MockBatchFileOperationRepositoryInterface_Create_Call

func (*MockBatchFileOperationRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_Create_Call) RunAndReturn(run func(op *models.BatchFileOperation) error) *MockBatchFileOperationRepositoryInterface_Create_Call

type MockBatchFileOperationRepositoryInterface_Expecter 

type MockBatchFileOperationRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockBatchFileOperationRepositoryInterface_Expecter) CountByBatchJobID 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) CountByBatchJobID(batchJobID interface{}) *MockBatchFileOperationRepositoryInterface_CountByBatchJobID_Call

CountByBatchJobID is a helper method to define mock.On call

  • batchJobID string

func (*MockBatchFileOperationRepositoryInterface_Expecter) CountByBatchJobIDAndRevertStatus 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) CountByBatchJobIDAndRevertStatus(batchJobID interface{}, status interface{}) *MockBatchFileOperationRepositoryInterface_CountByBatchJobIDAndRevertStatus_Call

CountByBatchJobIDAndRevertStatus is a helper method to define mock.On call

  • batchJobID string
  • status string

func (*MockBatchFileOperationRepositoryInterface_Expecter) Create 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) Create(op interface{}) *MockBatchFileOperationRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • op *models.BatchFileOperation

func (*MockBatchFileOperationRepositoryInterface_Expecter) CreateBatch 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) CreateBatch(ops interface{}) *MockBatchFileOperationRepositoryInterface_CreateBatch_Call

CreateBatch is a helper method to define mock.On call

  • ops []*models.BatchFileOperation

func (*MockBatchFileOperationRepositoryInterface_Expecter) FindByBatchJobID 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) FindByBatchJobID(batchJobID interface{}) *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call

FindByBatchJobID is a helper method to define mock.On call

  • batchJobID string

func (*MockBatchFileOperationRepositoryInterface_Expecter) FindByBatchJobIDAndRevertStatus 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) FindByBatchJobIDAndRevertStatus(batchJobID interface{}, revertStatus interface{}) *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call

FindByBatchJobIDAndRevertStatus is a helper method to define mock.On call

  • batchJobID string
  • revertStatus string

func (*MockBatchFileOperationRepositoryInterface_Expecter) FindByID 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) FindByID(id interface{}) *MockBatchFileOperationRepositoryInterface_FindByID_Call

FindByID is a helper method to define mock.On call

  • id uint

func (*MockBatchFileOperationRepositoryInterface_Expecter) Update 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) Update(op interface{}) *MockBatchFileOperationRepositoryInterface_Update_Call

Update is a helper method to define mock.On call

  • op *models.BatchFileOperation

func (*MockBatchFileOperationRepositoryInterface_Expecter) UpdateRevertStatus 

func (_e *MockBatchFileOperationRepositoryInterface_Expecter) UpdateRevertStatus(id interface{}, status interface{}) *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call

UpdateRevertStatus is a helper method to define mock.On call

  • id uint
  • status string

type MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call 

type MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByBatchJobIDAndRevertStatus'

func (*MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call) Return(batchFileOperations []models.BatchFileOperation, err error) *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call

func (*MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call) Run(run func(batchJobID string, revertStatus string)) *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call

func (*MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call) RunAndReturn(run func(batchJobID string, revertStatus string) ([]models.BatchFileOperation, error)) *MockBatchFileOperationRepositoryInterface_FindByBatchJobIDAndRevertStatus_Call

type MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call 

type MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByBatchJobID'

func (*MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call) Return(batchFileOperations []models.BatchFileOperation, err error) *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call

func (*MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call) Run(run func(batchJobID string)) *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call

func (*MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call) RunAndReturn(run func(batchJobID string) ([]models.BatchFileOperation, error)) *MockBatchFileOperationRepositoryInterface_FindByBatchJobID_Call

type MockBatchFileOperationRepositoryInterface_FindByID_Call 

type MockBatchFileOperationRepositoryInterface_FindByID_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockBatchFileOperationRepositoryInterface_FindByID_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_FindByID_Call) Return(batchFileOperation *models.BatchFileOperation, err error) *MockBatchFileOperationRepositoryInterface_FindByID_Call

func (*MockBatchFileOperationRepositoryInterface_FindByID_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_FindByID_Call) Run(run func(id uint)) *MockBatchFileOperationRepositoryInterface_FindByID_Call

func (*MockBatchFileOperationRepositoryInterface_FindByID_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_FindByID_Call) RunAndReturn(run func(id uint) (*models.BatchFileOperation, error)) *MockBatchFileOperationRepositoryInterface_FindByID_Call

type MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call 

type MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRevertStatus'

func (*MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call) Return(err error) *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call

func (*MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call) Run(run func(id uint, status string)) *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call

func (*MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call) RunAndReturn(run func(id uint, status string) error) *MockBatchFileOperationRepositoryInterface_UpdateRevertStatus_Call

type MockBatchFileOperationRepositoryInterface_Update_Call 

type MockBatchFileOperationRepositoryInterface_Update_Call struct {
	*mock.Call
}

MockBatchFileOperationRepositoryInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockBatchFileOperationRepositoryInterface_Update_Call) Return 

func (_c *MockBatchFileOperationRepositoryInterface_Update_Call) Return(err error) *MockBatchFileOperationRepositoryInterface_Update_Call

func (*MockBatchFileOperationRepositoryInterface_Update_Call) Run 

func (_c *MockBatchFileOperationRepositoryInterface_Update_Call) Run(run func(op *models.BatchFileOperation)) *MockBatchFileOperationRepositoryInterface_Update_Call

func (*MockBatchFileOperationRepositoryInterface_Update_Call) RunAndReturn 

func (_c *MockBatchFileOperationRepositoryInterface_Update_Call) RunAndReturn(run func(op *models.BatchFileOperation) error) *MockBatchFileOperationRepositoryInterface_Update_Call

type MockContentIDMappingRepositoryInterface 

type MockContentIDMappingRepositoryInterface struct {
	mock.Mock
}

MockContentIDMappingRepositoryInterface is an autogenerated mock type for the ContentIDMappingRepositoryInterface type

func NewMockContentIDMappingRepositoryInterface 

func NewMockContentIDMappingRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockContentIDMappingRepositoryInterface

NewMockContentIDMappingRepositoryInterface creates a new instance of MockContentIDMappingRepositoryInterface. 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 (*MockContentIDMappingRepositoryInterface) Create 

func (_mock *MockContentIDMappingRepositoryInterface) Create(mapping *models.ContentIDMapping) error

Create provides a mock function for the type MockContentIDMappingRepositoryInterface

func (*MockContentIDMappingRepositoryInterface) Delete 

func (_mock *MockContentIDMappingRepositoryInterface) Delete(searchID string) error

Delete provides a mock function for the type MockContentIDMappingRepositoryInterface

func (*MockContentIDMappingRepositoryInterface) EXPECT 

func (_m *MockContentIDMappingRepositoryInterface) EXPECT() *MockContentIDMappingRepositoryInterface_Expecter

func (*MockContentIDMappingRepositoryInterface) FindBySearchID 

func (_mock *MockContentIDMappingRepositoryInterface) FindBySearchID(searchID string) (*models.ContentIDMapping, error)

FindBySearchID provides a mock function for the type MockContentIDMappingRepositoryInterface

func (*MockContentIDMappingRepositoryInterface) GetAll 

func (_mock *MockContentIDMappingRepositoryInterface) GetAll() ([]models.ContentIDMapping, error)

GetAll provides a mock function for the type MockContentIDMappingRepositoryInterface

type MockContentIDMappingRepositoryInterface_Create_Call 

type MockContentIDMappingRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockContentIDMappingRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockContentIDMappingRepositoryInterface_Create_Call) Return 

func (_c *MockContentIDMappingRepositoryInterface_Create_Call) Return(err error) *MockContentIDMappingRepositoryInterface_Create_Call

func (*MockContentIDMappingRepositoryInterface_Create_Call) Run 

func (_c *MockContentIDMappingRepositoryInterface_Create_Call) Run(run func(mapping *models.ContentIDMapping)) *MockContentIDMappingRepositoryInterface_Create_Call

func (*MockContentIDMappingRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockContentIDMappingRepositoryInterface_Create_Call) RunAndReturn(run func(mapping *models.ContentIDMapping) error) *MockContentIDMappingRepositoryInterface_Create_Call

type MockContentIDMappingRepositoryInterface_Delete_Call 

type MockContentIDMappingRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockContentIDMappingRepositoryInterface_Delete_Call) Return 

func (_c *MockContentIDMappingRepositoryInterface_Delete_Call) Return(err error) *MockContentIDMappingRepositoryInterface_Delete_Call

func (*MockContentIDMappingRepositoryInterface_Delete_Call) Run 

func (_c *MockContentIDMappingRepositoryInterface_Delete_Call) Run(run func(searchID string)) *MockContentIDMappingRepositoryInterface_Delete_Call

func (*MockContentIDMappingRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockContentIDMappingRepositoryInterface_Delete_Call) RunAndReturn(run func(searchID string) error) *MockContentIDMappingRepositoryInterface_Delete_Call

type MockContentIDMappingRepositoryInterface_Expecter 

type MockContentIDMappingRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockContentIDMappingRepositoryInterface_Expecter) Create 

func (_e *MockContentIDMappingRepositoryInterface_Expecter) Create(mapping interface{}) *MockContentIDMappingRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • mapping *models.ContentIDMapping

func (*MockContentIDMappingRepositoryInterface_Expecter) Delete 

func (_e *MockContentIDMappingRepositoryInterface_Expecter) Delete(searchID interface{}) *MockContentIDMappingRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • searchID string

func (*MockContentIDMappingRepositoryInterface_Expecter) FindBySearchID 

func (_e *MockContentIDMappingRepositoryInterface_Expecter) FindBySearchID(searchID interface{}) *MockContentIDMappingRepositoryInterface_FindBySearchID_Call

FindBySearchID is a helper method to define mock.On call

  • searchID string

func (*MockContentIDMappingRepositoryInterface_Expecter) GetAll 

func (_e *MockContentIDMappingRepositoryInterface_Expecter) GetAll() *MockContentIDMappingRepositoryInterface_GetAll_Call

GetAll is a helper method to define mock.On call

type MockContentIDMappingRepositoryInterface_FindBySearchID_Call 

type MockContentIDMappingRepositoryInterface_FindBySearchID_Call struct {
	*mock.Call
}

MockContentIDMappingRepositoryInterface_FindBySearchID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindBySearchID'

func (*MockContentIDMappingRepositoryInterface_FindBySearchID_Call) Return 

func (_c *MockContentIDMappingRepositoryInterface_FindBySearchID_Call) Return(contentIDMapping *models.ContentIDMapping, err error) *MockContentIDMappingRepositoryInterface_FindBySearchID_Call

func (*MockContentIDMappingRepositoryInterface_FindBySearchID_Call) Run 

func (_c *MockContentIDMappingRepositoryInterface_FindBySearchID_Call) Run(run func(searchID string)) *MockContentIDMappingRepositoryInterface_FindBySearchID_Call

func (*MockContentIDMappingRepositoryInterface_FindBySearchID_Call) RunAndReturn 

func (_c *MockContentIDMappingRepositoryInterface_FindBySearchID_Call) RunAndReturn(run func(searchID string) (*models.ContentIDMapping, error)) *MockContentIDMappingRepositoryInterface_FindBySearchID_Call

type MockContentIDMappingRepositoryInterface_GetAll_Call 

type MockContentIDMappingRepositoryInterface_GetAll_Call struct {
	*mock.Call
}

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

func (*MockContentIDMappingRepositoryInterface_GetAll_Call) Return 

func (_c *MockContentIDMappingRepositoryInterface_GetAll_Call) Return(contentIDMappings []models.ContentIDMapping, err error) *MockContentIDMappingRepositoryInterface_GetAll_Call

func (*MockContentIDMappingRepositoryInterface_GetAll_Call) Run 

func (_c *MockContentIDMappingRepositoryInterface_GetAll_Call) Run(run func()) *MockContentIDMappingRepositoryInterface_GetAll_Call

func (*MockContentIDMappingRepositoryInterface_GetAll_Call) RunAndReturn 

func (_c *MockContentIDMappingRepositoryInterface_GetAll_Call) RunAndReturn(run func() ([]models.ContentIDMapping, error)) *MockContentIDMappingRepositoryInterface_GetAll_Call

type MockEventEmitter 

type MockEventEmitter struct {
	mock.Mock
}

MockEventEmitter is an autogenerated mock type for the EventEmitter type

func NewMockEventEmitter 

func NewMockEventEmitter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEventEmitter

NewMockEventEmitter creates a new instance of MockEventEmitter. 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 (*MockEventEmitter) EXPECT 

func (_m *MockEventEmitter) EXPECT() *MockEventEmitter_Expecter

func (*MockEventEmitter) EmitOrganizeEvent 

func (_mock *MockEventEmitter) EmitOrganizeEvent(source string, message string, severity string, context map[string]interface{}) error

EmitOrganizeEvent provides a mock function for the type MockEventEmitter

func (*MockEventEmitter) EmitScraperEvent 

func (_mock *MockEventEmitter) EmitScraperEvent(source string, message string, severity string, context map[string]interface{}) error

EmitScraperEvent provides a mock function for the type MockEventEmitter

func (*MockEventEmitter) EmitSystemEvent 

func (_mock *MockEventEmitter) EmitSystemEvent(source string, message string, severity string, context map[string]interface{}) error

EmitSystemEvent provides a mock function for the type MockEventEmitter

type MockEventEmitter_EmitOrganizeEvent_Call 

type MockEventEmitter_EmitOrganizeEvent_Call struct {
	*mock.Call
}

MockEventEmitter_EmitOrganizeEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EmitOrganizeEvent'

func (*MockEventEmitter_EmitOrganizeEvent_Call) Return 

func (_c *MockEventEmitter_EmitOrganizeEvent_Call) Return(err error) *MockEventEmitter_EmitOrganizeEvent_Call

func (*MockEventEmitter_EmitOrganizeEvent_Call) Run 

func (_c *MockEventEmitter_EmitOrganizeEvent_Call) Run(run func(source string, message string, severity string, context map[string]interface{})) *MockEventEmitter_EmitOrganizeEvent_Call

func (*MockEventEmitter_EmitOrganizeEvent_Call) RunAndReturn 

func (_c *MockEventEmitter_EmitOrganizeEvent_Call) RunAndReturn(run func(source string, message string, severity string, context map[string]interface{}) error) *MockEventEmitter_EmitOrganizeEvent_Call

type MockEventEmitter_EmitScraperEvent_Call 

type MockEventEmitter_EmitScraperEvent_Call struct {
	*mock.Call
}

MockEventEmitter_EmitScraperEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EmitScraperEvent'

func (*MockEventEmitter_EmitScraperEvent_Call) Return 

func (_c *MockEventEmitter_EmitScraperEvent_Call) Return(err error) *MockEventEmitter_EmitScraperEvent_Call

func (*MockEventEmitter_EmitScraperEvent_Call) Run 

func (_c *MockEventEmitter_EmitScraperEvent_Call) Run(run func(source string, message string, severity string, context map[string]interface{})) *MockEventEmitter_EmitScraperEvent_Call

func (*MockEventEmitter_EmitScraperEvent_Call) RunAndReturn 

func (_c *MockEventEmitter_EmitScraperEvent_Call) RunAndReturn(run func(source string, message string, severity string, context map[string]interface{}) error) *MockEventEmitter_EmitScraperEvent_Call

type MockEventEmitter_EmitSystemEvent_Call 

type MockEventEmitter_EmitSystemEvent_Call struct {
	*mock.Call
}

MockEventEmitter_EmitSystemEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EmitSystemEvent'

func (*MockEventEmitter_EmitSystemEvent_Call) Return 

func (_c *MockEventEmitter_EmitSystemEvent_Call) Return(err error) *MockEventEmitter_EmitSystemEvent_Call

func (*MockEventEmitter_EmitSystemEvent_Call) Run 

func (_c *MockEventEmitter_EmitSystemEvent_Call) Run(run func(source string, message string, severity string, context map[string]interface{})) *MockEventEmitter_EmitSystemEvent_Call

func (*MockEventEmitter_EmitSystemEvent_Call) RunAndReturn 

func (_c *MockEventEmitter_EmitSystemEvent_Call) RunAndReturn(run func(source string, message string, severity string, context map[string]interface{}) error) *MockEventEmitter_EmitSystemEvent_Call

type MockEventEmitter_Expecter 

type MockEventEmitter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockEventEmitter_Expecter) EmitOrganizeEvent 

func (_e *MockEventEmitter_Expecter) EmitOrganizeEvent(source interface{}, message interface{}, severity interface{}, context interface{}) *MockEventEmitter_EmitOrganizeEvent_Call

EmitOrganizeEvent is a helper method to define mock.On call

  • source string
  • message string
  • severity string
  • context map[string]interface{}

func (*MockEventEmitter_Expecter) EmitScraperEvent 

func (_e *MockEventEmitter_Expecter) EmitScraperEvent(source interface{}, message interface{}, severity interface{}, context interface{}) *MockEventEmitter_EmitScraperEvent_Call

EmitScraperEvent is a helper method to define mock.On call

  • source string
  • message string
  • severity string
  • context map[string]interface{}

func (*MockEventEmitter_Expecter) EmitSystemEvent 

func (_e *MockEventEmitter_Expecter) EmitSystemEvent(source interface{}, message interface{}, severity interface{}, context interface{}) *MockEventEmitter_EmitSystemEvent_Call

EmitSystemEvent is a helper method to define mock.On call

  • source string
  • message string
  • severity string
  • context map[string]interface{}

type MockEventRepositoryInterface 

type MockEventRepositoryInterface struct {
	mock.Mock
}

MockEventRepositoryInterface is an autogenerated mock type for the EventRepositoryInterface type

func NewMockEventRepositoryInterface 

func NewMockEventRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEventRepositoryInterface

NewMockEventRepositoryInterface creates a new instance of MockEventRepositoryInterface. 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 (*MockEventRepositoryInterface) Count 

func (_mock *MockEventRepositoryInterface) Count() (int64, error)

Count provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountByDateRange 

func (_mock *MockEventRepositoryInterface) CountByDateRange(start time.Time, end time.Time) (int64, error)

CountByDateRange provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountBySeverity 

func (_mock *MockEventRepositoryInterface) CountBySeverity(severity string) (int64, error)

CountBySeverity provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountBySource 

func (_mock *MockEventRepositoryInterface) CountBySource(source string) (int64, error)

CountBySource provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountByType 

func (_mock *MockEventRepositoryInterface) CountByType(eventType string) (int64, error)

CountByType provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountByTypeAndSeverity 

func (_mock *MockEventRepositoryInterface) CountByTypeAndSeverity(eventType string, severity string) (int64, error)

CountByTypeAndSeverity provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountFiltered 

func (_mock *MockEventRepositoryInterface) CountFiltered(filter database.EventFilter) (int64, error)

CountFiltered provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) CountGroupBySource 

func (_mock *MockEventRepositoryInterface) CountGroupBySource() (map[string]int64, error)

CountGroupBySource provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) Create 

func (_mock *MockEventRepositoryInterface) Create(event *models.Event) error

Create provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) DeleteOlderThan 

func (_mock *MockEventRepositoryInterface) DeleteOlderThan(date time.Time) error

DeleteOlderThan provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) EXPECT 

func (_m *MockEventRepositoryInterface) EXPECT() *MockEventRepositoryInterface_Expecter

func (*MockEventRepositoryInterface) FindByDateRange 

func (_mock *MockEventRepositoryInterface) FindByDateRange(start time.Time, end time.Time, limit int, offset int) ([]models.Event, error)

FindByDateRange provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) FindByID 

func (_mock *MockEventRepositoryInterface) FindByID(id uint) (*models.Event, error)

FindByID provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) FindBySeverity 

func (_mock *MockEventRepositoryInterface) FindBySeverity(severity string, limit int, offset int) ([]models.Event, error)

FindBySeverity provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) FindBySource 

func (_mock *MockEventRepositoryInterface) FindBySource(source string, limit int, offset int) ([]models.Event, error)

FindBySource provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) FindByType 

func (_mock *MockEventRepositoryInterface) FindByType(eventType string, limit int, offset int) ([]models.Event, error)

FindByType provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) FindByTypeAndSeverity 

func (_mock *MockEventRepositoryInterface) FindByTypeAndSeverity(eventType string, severity string, limit int, offset int) ([]models.Event, error)

FindByTypeAndSeverity provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) FindFiltered 

func (_mock *MockEventRepositoryInterface) FindFiltered(filter database.EventFilter, limit int, offset int) ([]models.Event, error)

FindFiltered provides a mock function for the type MockEventRepositoryInterface

func (*MockEventRepositoryInterface) List 

func (_mock *MockEventRepositoryInterface) List(limit int, offset int) ([]models.Event, error)

List provides a mock function for the type MockEventRepositoryInterface

type MockEventRepositoryInterface_CountByDateRange_Call 

type MockEventRepositoryInterface_CountByDateRange_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountByDateRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByDateRange'

func (*MockEventRepositoryInterface_CountByDateRange_Call) Return 

func (_c *MockEventRepositoryInterface_CountByDateRange_Call) Return(n int64, err error) *MockEventRepositoryInterface_CountByDateRange_Call

func (*MockEventRepositoryInterface_CountByDateRange_Call) Run 

func (_c *MockEventRepositoryInterface_CountByDateRange_Call) Run(run func(start time.Time, end time.Time)) *MockEventRepositoryInterface_CountByDateRange_Call

func (*MockEventRepositoryInterface_CountByDateRange_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountByDateRange_Call) RunAndReturn(run func(start time.Time, end time.Time) (int64, error)) *MockEventRepositoryInterface_CountByDateRange_Call

type MockEventRepositoryInterface_CountBySeverity_Call 

type MockEventRepositoryInterface_CountBySeverity_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountBySeverity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountBySeverity'

func (*MockEventRepositoryInterface_CountBySeverity_Call) Return 

func (_c *MockEventRepositoryInterface_CountBySeverity_Call) Return(n int64, err error) *MockEventRepositoryInterface_CountBySeverity_Call

func (*MockEventRepositoryInterface_CountBySeverity_Call) Run 

func (_c *MockEventRepositoryInterface_CountBySeverity_Call) Run(run func(severity string)) *MockEventRepositoryInterface_CountBySeverity_Call

func (*MockEventRepositoryInterface_CountBySeverity_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountBySeverity_Call) RunAndReturn(run func(severity string) (int64, error)) *MockEventRepositoryInterface_CountBySeverity_Call

type MockEventRepositoryInterface_CountBySource_Call 

type MockEventRepositoryInterface_CountBySource_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountBySource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountBySource'

func (*MockEventRepositoryInterface_CountBySource_Call) Return 

func (_c *MockEventRepositoryInterface_CountBySource_Call) Return(n int64, err error) *MockEventRepositoryInterface_CountBySource_Call

func (*MockEventRepositoryInterface_CountBySource_Call) Run 

func (_c *MockEventRepositoryInterface_CountBySource_Call) Run(run func(source string)) *MockEventRepositoryInterface_CountBySource_Call

func (*MockEventRepositoryInterface_CountBySource_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountBySource_Call) RunAndReturn(run func(source string) (int64, error)) *MockEventRepositoryInterface_CountBySource_Call

type MockEventRepositoryInterface_CountByTypeAndSeverity_Call 

type MockEventRepositoryInterface_CountByTypeAndSeverity_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountByTypeAndSeverity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByTypeAndSeverity'

func (*MockEventRepositoryInterface_CountByTypeAndSeverity_Call) Return 

func (_c *MockEventRepositoryInterface_CountByTypeAndSeverity_Call) Return(n int64, err error) *MockEventRepositoryInterface_CountByTypeAndSeverity_Call

func (*MockEventRepositoryInterface_CountByTypeAndSeverity_Call) Run 

func (_c *MockEventRepositoryInterface_CountByTypeAndSeverity_Call) Run(run func(eventType string, severity string)) *MockEventRepositoryInterface_CountByTypeAndSeverity_Call

func (*MockEventRepositoryInterface_CountByTypeAndSeverity_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountByTypeAndSeverity_Call) RunAndReturn(run func(eventType string, severity string) (int64, error)) *MockEventRepositoryInterface_CountByTypeAndSeverity_Call

type MockEventRepositoryInterface_CountByType_Call 

type MockEventRepositoryInterface_CountByType_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountByType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByType'

func (*MockEventRepositoryInterface_CountByType_Call) Return 

func (_c *MockEventRepositoryInterface_CountByType_Call) Return(n int64, err error) *MockEventRepositoryInterface_CountByType_Call

func (*MockEventRepositoryInterface_CountByType_Call) Run 

func (_c *MockEventRepositoryInterface_CountByType_Call) Run(run func(eventType string)) *MockEventRepositoryInterface_CountByType_Call

func (*MockEventRepositoryInterface_CountByType_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountByType_Call) RunAndReturn(run func(eventType string) (int64, error)) *MockEventRepositoryInterface_CountByType_Call

type MockEventRepositoryInterface_CountFiltered_Call 

type MockEventRepositoryInterface_CountFiltered_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountFiltered_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountFiltered'

func (*MockEventRepositoryInterface_CountFiltered_Call) Return 

func (_c *MockEventRepositoryInterface_CountFiltered_Call) Return(n int64, err error) *MockEventRepositoryInterface_CountFiltered_Call

func (*MockEventRepositoryInterface_CountFiltered_Call) Run 

func (_c *MockEventRepositoryInterface_CountFiltered_Call) Run(run func(filter database.EventFilter)) *MockEventRepositoryInterface_CountFiltered_Call

func (*MockEventRepositoryInterface_CountFiltered_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountFiltered_Call) RunAndReturn(run func(filter database.EventFilter) (int64, error)) *MockEventRepositoryInterface_CountFiltered_Call

type MockEventRepositoryInterface_CountGroupBySource_Call 

type MockEventRepositoryInterface_CountGroupBySource_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_CountGroupBySource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountGroupBySource'

func (*MockEventRepositoryInterface_CountGroupBySource_Call) Return 

func (_c *MockEventRepositoryInterface_CountGroupBySource_Call) Return(stringToInt64 map[string]int64, err error) *MockEventRepositoryInterface_CountGroupBySource_Call

func (*MockEventRepositoryInterface_CountGroupBySource_Call) Run 

func (_c *MockEventRepositoryInterface_CountGroupBySource_Call) Run(run func()) *MockEventRepositoryInterface_CountGroupBySource_Call

func (*MockEventRepositoryInterface_CountGroupBySource_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_CountGroupBySource_Call) RunAndReturn(run func() (map[string]int64, error)) *MockEventRepositoryInterface_CountGroupBySource_Call

type MockEventRepositoryInterface_Count_Call 

type MockEventRepositoryInterface_Count_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_Count_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Count'

func (*MockEventRepositoryInterface_Count_Call) Return 

func (_c *MockEventRepositoryInterface_Count_Call) Return(n int64, err error) *MockEventRepositoryInterface_Count_Call

func (*MockEventRepositoryInterface_Count_Call) Run 

func (_c *MockEventRepositoryInterface_Count_Call) Run(run func()) *MockEventRepositoryInterface_Count_Call

func (*MockEventRepositoryInterface_Count_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_Count_Call) RunAndReturn(run func() (int64, error)) *MockEventRepositoryInterface_Count_Call

type MockEventRepositoryInterface_Create_Call 

type MockEventRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockEventRepositoryInterface_Create_Call) Return 

func (_c *MockEventRepositoryInterface_Create_Call) Return(err error) *MockEventRepositoryInterface_Create_Call

func (*MockEventRepositoryInterface_Create_Call) Run 

func (_c *MockEventRepositoryInterface_Create_Call) Run(run func(event *models.Event)) *MockEventRepositoryInterface_Create_Call

func (*MockEventRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_Create_Call) RunAndReturn(run func(event *models.Event) error) *MockEventRepositoryInterface_Create_Call

type MockEventRepositoryInterface_DeleteOlderThan_Call 

type MockEventRepositoryInterface_DeleteOlderThan_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_DeleteOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOlderThan'

func (*MockEventRepositoryInterface_DeleteOlderThan_Call) Return 

func (_c *MockEventRepositoryInterface_DeleteOlderThan_Call) Return(err error) *MockEventRepositoryInterface_DeleteOlderThan_Call

func (*MockEventRepositoryInterface_DeleteOlderThan_Call) Run 

func (_c *MockEventRepositoryInterface_DeleteOlderThan_Call) Run(run func(date time.Time)) *MockEventRepositoryInterface_DeleteOlderThan_Call

func (*MockEventRepositoryInterface_DeleteOlderThan_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_DeleteOlderThan_Call) RunAndReturn(run func(date time.Time) error) *MockEventRepositoryInterface_DeleteOlderThan_Call

type MockEventRepositoryInterface_Expecter 

type MockEventRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockEventRepositoryInterface_Expecter) Count 

func (_e *MockEventRepositoryInterface_Expecter) Count() *MockEventRepositoryInterface_Count_Call

Count is a helper method to define mock.On call

func (*MockEventRepositoryInterface_Expecter) CountByDateRange 

func (_e *MockEventRepositoryInterface_Expecter) CountByDateRange(start interface{}, end interface{}) *MockEventRepositoryInterface_CountByDateRange_Call

CountByDateRange is a helper method to define mock.On call

  • start time.Time
  • end time.Time

func (*MockEventRepositoryInterface_Expecter) CountBySeverity 

func (_e *MockEventRepositoryInterface_Expecter) CountBySeverity(severity interface{}) *MockEventRepositoryInterface_CountBySeverity_Call

CountBySeverity is a helper method to define mock.On call

  • severity string

func (*MockEventRepositoryInterface_Expecter) CountBySource 

func (_e *MockEventRepositoryInterface_Expecter) CountBySource(source interface{}) *MockEventRepositoryInterface_CountBySource_Call

CountBySource is a helper method to define mock.On call

  • source string

func (*MockEventRepositoryInterface_Expecter) CountByType 

func (_e *MockEventRepositoryInterface_Expecter) CountByType(eventType interface{}) *MockEventRepositoryInterface_CountByType_Call

CountByType is a helper method to define mock.On call

  • eventType string

func (*MockEventRepositoryInterface_Expecter) CountByTypeAndSeverity 

func (_e *MockEventRepositoryInterface_Expecter) CountByTypeAndSeverity(eventType interface{}, severity interface{}) *MockEventRepositoryInterface_CountByTypeAndSeverity_Call

CountByTypeAndSeverity is a helper method to define mock.On call

  • eventType string
  • severity string

func (*MockEventRepositoryInterface_Expecter) CountFiltered 

func (_e *MockEventRepositoryInterface_Expecter) CountFiltered(filter interface{}) *MockEventRepositoryInterface_CountFiltered_Call

CountFiltered is a helper method to define mock.On call

  • filter database.EventFilter

func (*MockEventRepositoryInterface_Expecter) CountGroupBySource 

func (_e *MockEventRepositoryInterface_Expecter) CountGroupBySource() *MockEventRepositoryInterface_CountGroupBySource_Call

CountGroupBySource is a helper method to define mock.On call

func (*MockEventRepositoryInterface_Expecter) Create 

func (_e *MockEventRepositoryInterface_Expecter) Create(event interface{}) *MockEventRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • event *models.Event

func (*MockEventRepositoryInterface_Expecter) DeleteOlderThan 

func (_e *MockEventRepositoryInterface_Expecter) DeleteOlderThan(date interface{}) *MockEventRepositoryInterface_DeleteOlderThan_Call

DeleteOlderThan is a helper method to define mock.On call

  • date time.Time

func (*MockEventRepositoryInterface_Expecter) FindByDateRange 

func (_e *MockEventRepositoryInterface_Expecter) FindByDateRange(start interface{}, end interface{}, limit interface{}, offset interface{}) *MockEventRepositoryInterface_FindByDateRange_Call

FindByDateRange is a helper method to define mock.On call

  • start time.Time
  • end time.Time
  • limit int
  • offset int

func (*MockEventRepositoryInterface_Expecter) FindByID 

func (_e *MockEventRepositoryInterface_Expecter) FindByID(id interface{}) *MockEventRepositoryInterface_FindByID_Call

FindByID is a helper method to define mock.On call

  • id uint

func (*MockEventRepositoryInterface_Expecter) FindBySeverity 

func (_e *MockEventRepositoryInterface_Expecter) FindBySeverity(severity interface{}, limit interface{}, offset interface{}) *MockEventRepositoryInterface_FindBySeverity_Call

FindBySeverity is a helper method to define mock.On call

  • severity string
  • limit int
  • offset int

func (*MockEventRepositoryInterface_Expecter) FindBySource 

func (_e *MockEventRepositoryInterface_Expecter) FindBySource(source interface{}, limit interface{}, offset interface{}) *MockEventRepositoryInterface_FindBySource_Call

FindBySource is a helper method to define mock.On call

  • source string
  • limit int
  • offset int

func (*MockEventRepositoryInterface_Expecter) FindByType 

func (_e *MockEventRepositoryInterface_Expecter) FindByType(eventType interface{}, limit interface{}, offset interface{}) *MockEventRepositoryInterface_FindByType_Call

FindByType is a helper method to define mock.On call

  • eventType string
  • limit int
  • offset int

func (*MockEventRepositoryInterface_Expecter) FindByTypeAndSeverity 

func (_e *MockEventRepositoryInterface_Expecter) FindByTypeAndSeverity(eventType interface{}, severity interface{}, limit interface{}, offset interface{}) *MockEventRepositoryInterface_FindByTypeAndSeverity_Call

FindByTypeAndSeverity is a helper method to define mock.On call

  • eventType string
  • severity string
  • limit int
  • offset int

func (*MockEventRepositoryInterface_Expecter) FindFiltered 

func (_e *MockEventRepositoryInterface_Expecter) FindFiltered(filter interface{}, limit interface{}, offset interface{}) *MockEventRepositoryInterface_FindFiltered_Call

FindFiltered is a helper method to define mock.On call

  • filter database.EventFilter
  • limit int
  • offset int

func (*MockEventRepositoryInterface_Expecter) List 

func (_e *MockEventRepositoryInterface_Expecter) List(limit interface{}, offset interface{}) *MockEventRepositoryInterface_List_Call

List is a helper method to define mock.On call

  • limit int
  • offset int

type MockEventRepositoryInterface_FindByDateRange_Call 

type MockEventRepositoryInterface_FindByDateRange_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindByDateRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByDateRange'

func (*MockEventRepositoryInterface_FindByDateRange_Call) Return 

func (_c *MockEventRepositoryInterface_FindByDateRange_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_FindByDateRange_Call

func (*MockEventRepositoryInterface_FindByDateRange_Call) Run 

func (_c *MockEventRepositoryInterface_FindByDateRange_Call) Run(run func(start time.Time, end time.Time, limit int, offset int)) *MockEventRepositoryInterface_FindByDateRange_Call

func (*MockEventRepositoryInterface_FindByDateRange_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindByDateRange_Call) RunAndReturn(run func(start time.Time, end time.Time, limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_FindByDateRange_Call

type MockEventRepositoryInterface_FindByID_Call 

type MockEventRepositoryInterface_FindByID_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockEventRepositoryInterface_FindByID_Call) Return 

func (_c *MockEventRepositoryInterface_FindByID_Call) Return(event *models.Event, err error) *MockEventRepositoryInterface_FindByID_Call

func (*MockEventRepositoryInterface_FindByID_Call) Run 

func (_c *MockEventRepositoryInterface_FindByID_Call) Run(run func(id uint)) *MockEventRepositoryInterface_FindByID_Call

func (*MockEventRepositoryInterface_FindByID_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindByID_Call) RunAndReturn(run func(id uint) (*models.Event, error)) *MockEventRepositoryInterface_FindByID_Call

type MockEventRepositoryInterface_FindBySeverity_Call 

type MockEventRepositoryInterface_FindBySeverity_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindBySeverity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindBySeverity'

func (*MockEventRepositoryInterface_FindBySeverity_Call) Return 

func (_c *MockEventRepositoryInterface_FindBySeverity_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_FindBySeverity_Call

func (*MockEventRepositoryInterface_FindBySeverity_Call) Run 

func (_c *MockEventRepositoryInterface_FindBySeverity_Call) Run(run func(severity string, limit int, offset int)) *MockEventRepositoryInterface_FindBySeverity_Call

func (*MockEventRepositoryInterface_FindBySeverity_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindBySeverity_Call) RunAndReturn(run func(severity string, limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_FindBySeverity_Call

type MockEventRepositoryInterface_FindBySource_Call 

type MockEventRepositoryInterface_FindBySource_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindBySource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindBySource'

func (*MockEventRepositoryInterface_FindBySource_Call) Return 

func (_c *MockEventRepositoryInterface_FindBySource_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_FindBySource_Call

func (*MockEventRepositoryInterface_FindBySource_Call) Run 

func (_c *MockEventRepositoryInterface_FindBySource_Call) Run(run func(source string, limit int, offset int)) *MockEventRepositoryInterface_FindBySource_Call

func (*MockEventRepositoryInterface_FindBySource_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindBySource_Call) RunAndReturn(run func(source string, limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_FindBySource_Call

type MockEventRepositoryInterface_FindByTypeAndSeverity_Call 

type MockEventRepositoryInterface_FindByTypeAndSeverity_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindByTypeAndSeverity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByTypeAndSeverity'

func (*MockEventRepositoryInterface_FindByTypeAndSeverity_Call) Return 

func (_c *MockEventRepositoryInterface_FindByTypeAndSeverity_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_FindByTypeAndSeverity_Call

func (*MockEventRepositoryInterface_FindByTypeAndSeverity_Call) Run 

func (_c *MockEventRepositoryInterface_FindByTypeAndSeverity_Call) Run(run func(eventType string, severity string, limit int, offset int)) *MockEventRepositoryInterface_FindByTypeAndSeverity_Call

func (*MockEventRepositoryInterface_FindByTypeAndSeverity_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindByTypeAndSeverity_Call) RunAndReturn(run func(eventType string, severity string, limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_FindByTypeAndSeverity_Call

type MockEventRepositoryInterface_FindByType_Call 

type MockEventRepositoryInterface_FindByType_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindByType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByType'

func (*MockEventRepositoryInterface_FindByType_Call) Return 

func (_c *MockEventRepositoryInterface_FindByType_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_FindByType_Call

func (*MockEventRepositoryInterface_FindByType_Call) Run 

func (_c *MockEventRepositoryInterface_FindByType_Call) Run(run func(eventType string, limit int, offset int)) *MockEventRepositoryInterface_FindByType_Call

func (*MockEventRepositoryInterface_FindByType_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindByType_Call) RunAndReturn(run func(eventType string, limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_FindByType_Call

type MockEventRepositoryInterface_FindFiltered_Call 

type MockEventRepositoryInterface_FindFiltered_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_FindFiltered_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindFiltered'

func (*MockEventRepositoryInterface_FindFiltered_Call) Return 

func (_c *MockEventRepositoryInterface_FindFiltered_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_FindFiltered_Call

func (*MockEventRepositoryInterface_FindFiltered_Call) Run 

func (_c *MockEventRepositoryInterface_FindFiltered_Call) Run(run func(filter database.EventFilter, limit int, offset int)) *MockEventRepositoryInterface_FindFiltered_Call

func (*MockEventRepositoryInterface_FindFiltered_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_FindFiltered_Call) RunAndReturn(run func(filter database.EventFilter, limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_FindFiltered_Call

type MockEventRepositoryInterface_List_Call 

type MockEventRepositoryInterface_List_Call struct {
	*mock.Call
}

MockEventRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockEventRepositoryInterface_List_Call) Return 

func (_c *MockEventRepositoryInterface_List_Call) Return(events []models.Event, err error) *MockEventRepositoryInterface_List_Call

func (*MockEventRepositoryInterface_List_Call) Run 

func (_c *MockEventRepositoryInterface_List_Call) Run(run func(limit int, offset int)) *MockEventRepositoryInterface_List_Call

func (*MockEventRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockEventRepositoryInterface_List_Call) RunAndReturn(run func(limit int, offset int) ([]models.Event, error)) *MockEventRepositoryInterface_List_Call

type MockGenreReplacementRepositoryInterface 

type MockGenreReplacementRepositoryInterface struct {
	mock.Mock
}

MockGenreReplacementRepositoryInterface is an autogenerated mock type for the GenreReplacementRepositoryInterface type

func NewMockGenreReplacementRepositoryInterface 

func NewMockGenreReplacementRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGenreReplacementRepositoryInterface

NewMockGenreReplacementRepositoryInterface creates a new instance of MockGenreReplacementRepositoryInterface. 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 (*MockGenreReplacementRepositoryInterface) Create 

func (_mock *MockGenreReplacementRepositoryInterface) Create(replacement *models.GenreReplacement) error

Create provides a mock function for the type MockGenreReplacementRepositoryInterface

func (*MockGenreReplacementRepositoryInterface) Delete 

func (_mock *MockGenreReplacementRepositoryInterface) Delete(original string) error

Delete provides a mock function for the type MockGenreReplacementRepositoryInterface

func (*MockGenreReplacementRepositoryInterface) EXPECT 

func (_m *MockGenreReplacementRepositoryInterface) EXPECT() *MockGenreReplacementRepositoryInterface_Expecter

func (*MockGenreReplacementRepositoryInterface) FindByOriginal 

func (_mock *MockGenreReplacementRepositoryInterface) FindByOriginal(original string) (*models.GenreReplacement, error)

FindByOriginal provides a mock function for the type MockGenreReplacementRepositoryInterface

func (*MockGenreReplacementRepositoryInterface) GetReplacementMap 

func (_mock *MockGenreReplacementRepositoryInterface) GetReplacementMap() (map[string]string, error)

GetReplacementMap provides a mock function for the type MockGenreReplacementRepositoryInterface

func (*MockGenreReplacementRepositoryInterface) List 

func (_mock *MockGenreReplacementRepositoryInterface) List() ([]models.GenreReplacement, error)

List provides a mock function for the type MockGenreReplacementRepositoryInterface

func (*MockGenreReplacementRepositoryInterface) Upsert 

func (_mock *MockGenreReplacementRepositoryInterface) Upsert(replacement *models.GenreReplacement) error

Upsert provides a mock function for the type MockGenreReplacementRepositoryInterface

type MockGenreReplacementRepositoryInterface_Create_Call 

type MockGenreReplacementRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockGenreReplacementRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockGenreReplacementRepositoryInterface_Create_Call) Return 

func (_c *MockGenreReplacementRepositoryInterface_Create_Call) Return(err error) *MockGenreReplacementRepositoryInterface_Create_Call

func (*MockGenreReplacementRepositoryInterface_Create_Call) Run 

func (_c *MockGenreReplacementRepositoryInterface_Create_Call) Run(run func(replacement *models.GenreReplacement)) *MockGenreReplacementRepositoryInterface_Create_Call

func (*MockGenreReplacementRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockGenreReplacementRepositoryInterface_Create_Call) RunAndReturn(run func(replacement *models.GenreReplacement) error) *MockGenreReplacementRepositoryInterface_Create_Call

type MockGenreReplacementRepositoryInterface_Delete_Call 

type MockGenreReplacementRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockGenreReplacementRepositoryInterface_Delete_Call) Return 

func (_c *MockGenreReplacementRepositoryInterface_Delete_Call) Return(err error) *MockGenreReplacementRepositoryInterface_Delete_Call

func (*MockGenreReplacementRepositoryInterface_Delete_Call) Run 

func (_c *MockGenreReplacementRepositoryInterface_Delete_Call) Run(run func(original string)) *MockGenreReplacementRepositoryInterface_Delete_Call

func (*MockGenreReplacementRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockGenreReplacementRepositoryInterface_Delete_Call) RunAndReturn(run func(original string) error) *MockGenreReplacementRepositoryInterface_Delete_Call

type MockGenreReplacementRepositoryInterface_Expecter 

type MockGenreReplacementRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockGenreReplacementRepositoryInterface_Expecter) Create 

func (_e *MockGenreReplacementRepositoryInterface_Expecter) Create(replacement interface{}) *MockGenreReplacementRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • replacement *models.GenreReplacement

func (*MockGenreReplacementRepositoryInterface_Expecter) Delete 

func (_e *MockGenreReplacementRepositoryInterface_Expecter) Delete(original interface{}) *MockGenreReplacementRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • original string

func (*MockGenreReplacementRepositoryInterface_Expecter) FindByOriginal 

func (_e *MockGenreReplacementRepositoryInterface_Expecter) FindByOriginal(original interface{}) *MockGenreReplacementRepositoryInterface_FindByOriginal_Call

FindByOriginal is a helper method to define mock.On call

  • original string

func (*MockGenreReplacementRepositoryInterface_Expecter) GetReplacementMap 

func (_e *MockGenreReplacementRepositoryInterface_Expecter) GetReplacementMap() *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call

GetReplacementMap is a helper method to define mock.On call

func (*MockGenreReplacementRepositoryInterface_Expecter) List 

func (_e *MockGenreReplacementRepositoryInterface_Expecter) List() *MockGenreReplacementRepositoryInterface_List_Call

List is a helper method to define mock.On call

func (*MockGenreReplacementRepositoryInterface_Expecter) Upsert 

func (_e *MockGenreReplacementRepositoryInterface_Expecter) Upsert(replacement interface{}) *MockGenreReplacementRepositoryInterface_Upsert_Call

Upsert is a helper method to define mock.On call

  • replacement *models.GenreReplacement

type MockGenreReplacementRepositoryInterface_FindByOriginal_Call 

type MockGenreReplacementRepositoryInterface_FindByOriginal_Call struct {
	*mock.Call
}

MockGenreReplacementRepositoryInterface_FindByOriginal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByOriginal'

func (*MockGenreReplacementRepositoryInterface_FindByOriginal_Call) Return 

func (_c *MockGenreReplacementRepositoryInterface_FindByOriginal_Call) Return(genreReplacement *models.GenreReplacement, err error) *MockGenreReplacementRepositoryInterface_FindByOriginal_Call

func (*MockGenreReplacementRepositoryInterface_FindByOriginal_Call) Run 

func (_c *MockGenreReplacementRepositoryInterface_FindByOriginal_Call) Run(run func(original string)) *MockGenreReplacementRepositoryInterface_FindByOriginal_Call

func (*MockGenreReplacementRepositoryInterface_FindByOriginal_Call) RunAndReturn 

func (_c *MockGenreReplacementRepositoryInterface_FindByOriginal_Call) RunAndReturn(run func(original string) (*models.GenreReplacement, error)) *MockGenreReplacementRepositoryInterface_FindByOriginal_Call

type MockGenreReplacementRepositoryInterface_GetReplacementMap_Call 

type MockGenreReplacementRepositoryInterface_GetReplacementMap_Call struct {
	*mock.Call
}

MockGenreReplacementRepositoryInterface_GetReplacementMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplacementMap'

func (*MockGenreReplacementRepositoryInterface_GetReplacementMap_Call) Return 

func (_c *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call) Return(stringToString map[string]string, err error) *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call

func (*MockGenreReplacementRepositoryInterface_GetReplacementMap_Call) Run 

func (_c *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call) Run(run func()) *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call

func (*MockGenreReplacementRepositoryInterface_GetReplacementMap_Call) RunAndReturn 

func (_c *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call) RunAndReturn(run func() (map[string]string, error)) *MockGenreReplacementRepositoryInterface_GetReplacementMap_Call

type MockGenreReplacementRepositoryInterface_List_Call 

type MockGenreReplacementRepositoryInterface_List_Call struct {
	*mock.Call
}

MockGenreReplacementRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockGenreReplacementRepositoryInterface_List_Call) Return 

func (_c *MockGenreReplacementRepositoryInterface_List_Call) Return(genreReplacements []models.GenreReplacement, err error) *MockGenreReplacementRepositoryInterface_List_Call

func (*MockGenreReplacementRepositoryInterface_List_Call) Run 

func (_c *MockGenreReplacementRepositoryInterface_List_Call) Run(run func()) *MockGenreReplacementRepositoryInterface_List_Call

func (*MockGenreReplacementRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockGenreReplacementRepositoryInterface_List_Call) RunAndReturn(run func() ([]models.GenreReplacement, error)) *MockGenreReplacementRepositoryInterface_List_Call

type MockGenreReplacementRepositoryInterface_Upsert_Call 

type MockGenreReplacementRepositoryInterface_Upsert_Call struct {
	*mock.Call
}

MockGenreReplacementRepositoryInterface_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'

func (*MockGenreReplacementRepositoryInterface_Upsert_Call) Return 

func (_c *MockGenreReplacementRepositoryInterface_Upsert_Call) Return(err error) *MockGenreReplacementRepositoryInterface_Upsert_Call

func (*MockGenreReplacementRepositoryInterface_Upsert_Call) Run 

func (_c *MockGenreReplacementRepositoryInterface_Upsert_Call) Run(run func(replacement *models.GenreReplacement)) *MockGenreReplacementRepositoryInterface_Upsert_Call

func (*MockGenreReplacementRepositoryInterface_Upsert_Call) RunAndReturn 

func (_c *MockGenreReplacementRepositoryInterface_Upsert_Call) RunAndReturn(run func(replacement *models.GenreReplacement) error) *MockGenreReplacementRepositoryInterface_Upsert_Call

type MockHTTPClient 

type MockHTTPClient struct {
	mock.Mock
}

MockHTTPClient is an autogenerated mock type for the HTTPClient type

func NewMockHTTPClient 

func NewMockHTTPClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockHTTPClient

NewMockHTTPClient creates a new instance of MockHTTPClient. 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 (*MockHTTPClient) Do 

func (_mock *MockHTTPClient) Do(req *http.Request) (*http.Response, error)

Do provides a mock function for the type MockHTTPClient

func (*MockHTTPClient) EXPECT 

func (_m *MockHTTPClient) EXPECT() *MockHTTPClient_Expecter

type MockHTTPClient_Do_Call 

type MockHTTPClient_Do_Call struct {
	*mock.Call
}

MockHTTPClient_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'

func (*MockHTTPClient_Do_Call) Return 

func (_c *MockHTTPClient_Do_Call) Return(response *http.Response, err error) *MockHTTPClient_Do_Call

func (*MockHTTPClient_Do_Call) Run 

func (_c *MockHTTPClient_Do_Call) Run(run func(req *http.Request)) *MockHTTPClient_Do_Call

func (*MockHTTPClient_Do_Call) RunAndReturn 

func (_c *MockHTTPClient_Do_Call) RunAndReturn(run func(req *http.Request) (*http.Response, error)) *MockHTTPClient_Do_Call

type MockHTTPClient_Expecter 

type MockHTTPClient_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockHTTPClient_Expecter) Do 

func (_e *MockHTTPClient_Expecter) Do(req interface{}) *MockHTTPClient_Do_Call

Do is a helper method to define mock.On call

  • req *http.Request

type MockHistoryRepositoryInterface 

type MockHistoryRepositoryInterface struct {
	mock.Mock
}

MockHistoryRepositoryInterface is an autogenerated mock type for the HistoryRepositoryInterface type

func NewMockHistoryRepositoryInterface 

func NewMockHistoryRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockHistoryRepositoryInterface

NewMockHistoryRepositoryInterface creates a new instance of MockHistoryRepositoryInterface. 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 (*MockHistoryRepositoryInterface) Count 

func (_mock *MockHistoryRepositoryInterface) Count() (int64, error)

Count provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) CountByOperation 

func (_mock *MockHistoryRepositoryInterface) CountByOperation(operation string) (int64, error)

CountByOperation provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) CountByStatus 

func (_mock *MockHistoryRepositoryInterface) CountByStatus(status string) (int64, error)

CountByStatus provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) Create 

func (_mock *MockHistoryRepositoryInterface) Create(history *models.History) error

Create provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) Delete 

func (_mock *MockHistoryRepositoryInterface) Delete(id uint) error

Delete provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) DeleteByMovieID 

func (_mock *MockHistoryRepositoryInterface) DeleteByMovieID(movieID string) error

DeleteByMovieID provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) DeleteOlderThan 

func (_mock *MockHistoryRepositoryInterface) DeleteOlderThan(date time.Time) error

DeleteOlderThan provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) EXPECT 

func (_m *MockHistoryRepositoryInterface) EXPECT() *MockHistoryRepositoryInterface_Expecter

func (*MockHistoryRepositoryInterface) FindByBatchJobID 

func (_mock *MockHistoryRepositoryInterface) FindByBatchJobID(batchJobID string) ([]models.History, error)

FindByBatchJobID provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) FindByDateRange 

func (_mock *MockHistoryRepositoryInterface) FindByDateRange(start time.Time, end time.Time) ([]models.History, error)

FindByDateRange provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) FindByID 

func (_mock *MockHistoryRepositoryInterface) FindByID(id uint) (*models.History, error)

FindByID provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) FindByMovieID 

func (_mock *MockHistoryRepositoryInterface) FindByMovieID(movieID string) ([]models.History, error)

FindByMovieID provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) FindByOperation 

func (_mock *MockHistoryRepositoryInterface) FindByOperation(operation string, limit int) ([]models.History, error)

FindByOperation provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) FindByStatus 

func (_mock *MockHistoryRepositoryInterface) FindByStatus(status string, limit int) ([]models.History, error)

FindByStatus provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) FindRecent 

func (_mock *MockHistoryRepositoryInterface) FindRecent(limit int) ([]models.History, error)

FindRecent provides a mock function for the type MockHistoryRepositoryInterface

func (*MockHistoryRepositoryInterface) List 

func (_mock *MockHistoryRepositoryInterface) List(limit int, offset int) ([]models.History, error)

List provides a mock function for the type MockHistoryRepositoryInterface

type MockHistoryRepositoryInterface_CountByOperation_Call 

type MockHistoryRepositoryInterface_CountByOperation_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_CountByOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByOperation'

func (*MockHistoryRepositoryInterface_CountByOperation_Call) Return 

func (_c *MockHistoryRepositoryInterface_CountByOperation_Call) Return(n int64, err error) *MockHistoryRepositoryInterface_CountByOperation_Call

func (*MockHistoryRepositoryInterface_CountByOperation_Call) Run 

func (_c *MockHistoryRepositoryInterface_CountByOperation_Call) Run(run func(operation string)) *MockHistoryRepositoryInterface_CountByOperation_Call

func (*MockHistoryRepositoryInterface_CountByOperation_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_CountByOperation_Call) RunAndReturn(run func(operation string) (int64, error)) *MockHistoryRepositoryInterface_CountByOperation_Call

type MockHistoryRepositoryInterface_CountByStatus_Call 

type MockHistoryRepositoryInterface_CountByStatus_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_CountByStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByStatus'

func (*MockHistoryRepositoryInterface_CountByStatus_Call) Return 

func (_c *MockHistoryRepositoryInterface_CountByStatus_Call) Return(n int64, err error) *MockHistoryRepositoryInterface_CountByStatus_Call

func (*MockHistoryRepositoryInterface_CountByStatus_Call) Run 

func (_c *MockHistoryRepositoryInterface_CountByStatus_Call) Run(run func(status string)) *MockHistoryRepositoryInterface_CountByStatus_Call

func (*MockHistoryRepositoryInterface_CountByStatus_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_CountByStatus_Call) RunAndReturn(run func(status string) (int64, error)) *MockHistoryRepositoryInterface_CountByStatus_Call

type MockHistoryRepositoryInterface_Count_Call 

type MockHistoryRepositoryInterface_Count_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_Count_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Count'

func (*MockHistoryRepositoryInterface_Count_Call) Return 

func (_c *MockHistoryRepositoryInterface_Count_Call) Return(n int64, err error) *MockHistoryRepositoryInterface_Count_Call

func (*MockHistoryRepositoryInterface_Count_Call) Run 

func (_c *MockHistoryRepositoryInterface_Count_Call) Run(run func()) *MockHistoryRepositoryInterface_Count_Call

func (*MockHistoryRepositoryInterface_Count_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_Count_Call) RunAndReturn(run func() (int64, error)) *MockHistoryRepositoryInterface_Count_Call

type MockHistoryRepositoryInterface_Create_Call 

type MockHistoryRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockHistoryRepositoryInterface_Create_Call) Return 

func (_c *MockHistoryRepositoryInterface_Create_Call) Return(err error) *MockHistoryRepositoryInterface_Create_Call

func (*MockHistoryRepositoryInterface_Create_Call) Run 

func (_c *MockHistoryRepositoryInterface_Create_Call) Run(run func(history *models.History)) *MockHistoryRepositoryInterface_Create_Call

func (*MockHistoryRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_Create_Call) RunAndReturn(run func(history *models.History) error) *MockHistoryRepositoryInterface_Create_Call

type MockHistoryRepositoryInterface_DeleteByMovieID_Call 

type MockHistoryRepositoryInterface_DeleteByMovieID_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_DeleteByMovieID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByMovieID'

func (*MockHistoryRepositoryInterface_DeleteByMovieID_Call) Return 

func (_c *MockHistoryRepositoryInterface_DeleteByMovieID_Call) Return(err error) *MockHistoryRepositoryInterface_DeleteByMovieID_Call

func (*MockHistoryRepositoryInterface_DeleteByMovieID_Call) Run 

func (_c *MockHistoryRepositoryInterface_DeleteByMovieID_Call) Run(run func(movieID string)) *MockHistoryRepositoryInterface_DeleteByMovieID_Call

func (*MockHistoryRepositoryInterface_DeleteByMovieID_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_DeleteByMovieID_Call) RunAndReturn(run func(movieID string) error) *MockHistoryRepositoryInterface_DeleteByMovieID_Call

type MockHistoryRepositoryInterface_DeleteOlderThan_Call 

type MockHistoryRepositoryInterface_DeleteOlderThan_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_DeleteOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOlderThan'

func (*MockHistoryRepositoryInterface_DeleteOlderThan_Call) Return 

func (_c *MockHistoryRepositoryInterface_DeleteOlderThan_Call) Return(err error) *MockHistoryRepositoryInterface_DeleteOlderThan_Call

func (*MockHistoryRepositoryInterface_DeleteOlderThan_Call) Run 

func (_c *MockHistoryRepositoryInterface_DeleteOlderThan_Call) Run(run func(date time.Time)) *MockHistoryRepositoryInterface_DeleteOlderThan_Call

func (*MockHistoryRepositoryInterface_DeleteOlderThan_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_DeleteOlderThan_Call) RunAndReturn(run func(date time.Time) error) *MockHistoryRepositoryInterface_DeleteOlderThan_Call

type MockHistoryRepositoryInterface_Delete_Call 

type MockHistoryRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockHistoryRepositoryInterface_Delete_Call) Return 

func (_c *MockHistoryRepositoryInterface_Delete_Call) Return(err error) *MockHistoryRepositoryInterface_Delete_Call

func (*MockHistoryRepositoryInterface_Delete_Call) Run 

func (_c *MockHistoryRepositoryInterface_Delete_Call) Run(run func(id uint)) *MockHistoryRepositoryInterface_Delete_Call

func (*MockHistoryRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_Delete_Call) RunAndReturn(run func(id uint) error) *MockHistoryRepositoryInterface_Delete_Call

type MockHistoryRepositoryInterface_Expecter 

type MockHistoryRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockHistoryRepositoryInterface_Expecter) Count 

func (_e *MockHistoryRepositoryInterface_Expecter) Count() *MockHistoryRepositoryInterface_Count_Call

Count is a helper method to define mock.On call

func (*MockHistoryRepositoryInterface_Expecter) CountByOperation 

func (_e *MockHistoryRepositoryInterface_Expecter) CountByOperation(operation interface{}) *MockHistoryRepositoryInterface_CountByOperation_Call

CountByOperation is a helper method to define mock.On call

  • operation string

func (*MockHistoryRepositoryInterface_Expecter) CountByStatus 

func (_e *MockHistoryRepositoryInterface_Expecter) CountByStatus(status interface{}) *MockHistoryRepositoryInterface_CountByStatus_Call

CountByStatus is a helper method to define mock.On call

  • status string

func (*MockHistoryRepositoryInterface_Expecter) Create 

func (_e *MockHistoryRepositoryInterface_Expecter) Create(history interface{}) *MockHistoryRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • history *models.History

func (*MockHistoryRepositoryInterface_Expecter) Delete 

func (_e *MockHistoryRepositoryInterface_Expecter) Delete(id interface{}) *MockHistoryRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • id uint

func (*MockHistoryRepositoryInterface_Expecter) DeleteByMovieID 

func (_e *MockHistoryRepositoryInterface_Expecter) DeleteByMovieID(movieID interface{}) *MockHistoryRepositoryInterface_DeleteByMovieID_Call

DeleteByMovieID is a helper method to define mock.On call

  • movieID string

func (*MockHistoryRepositoryInterface_Expecter) DeleteOlderThan 

func (_e *MockHistoryRepositoryInterface_Expecter) DeleteOlderThan(date interface{}) *MockHistoryRepositoryInterface_DeleteOlderThan_Call

DeleteOlderThan is a helper method to define mock.On call

  • date time.Time

func (*MockHistoryRepositoryInterface_Expecter) FindByBatchJobID 

func (_e *MockHistoryRepositoryInterface_Expecter) FindByBatchJobID(batchJobID interface{}) *MockHistoryRepositoryInterface_FindByBatchJobID_Call

FindByBatchJobID is a helper method to define mock.On call

  • batchJobID string

func (*MockHistoryRepositoryInterface_Expecter) FindByDateRange 

func (_e *MockHistoryRepositoryInterface_Expecter) FindByDateRange(start interface{}, end interface{}) *MockHistoryRepositoryInterface_FindByDateRange_Call

FindByDateRange is a helper method to define mock.On call

  • start time.Time
  • end time.Time

func (*MockHistoryRepositoryInterface_Expecter) FindByID 

func (_e *MockHistoryRepositoryInterface_Expecter) FindByID(id interface{}) *MockHistoryRepositoryInterface_FindByID_Call

FindByID is a helper method to define mock.On call

  • id uint

func (*MockHistoryRepositoryInterface_Expecter) FindByMovieID 

func (_e *MockHistoryRepositoryInterface_Expecter) FindByMovieID(movieID interface{}) *MockHistoryRepositoryInterface_FindByMovieID_Call

FindByMovieID is a helper method to define mock.On call

  • movieID string

func (*MockHistoryRepositoryInterface_Expecter) FindByOperation 

func (_e *MockHistoryRepositoryInterface_Expecter) FindByOperation(operation interface{}, limit interface{}) *MockHistoryRepositoryInterface_FindByOperation_Call

FindByOperation is a helper method to define mock.On call

  • operation string
  • limit int

func (*MockHistoryRepositoryInterface_Expecter) FindByStatus 

func (_e *MockHistoryRepositoryInterface_Expecter) FindByStatus(status interface{}, limit interface{}) *MockHistoryRepositoryInterface_FindByStatus_Call

FindByStatus is a helper method to define mock.On call

  • status string
  • limit int

func (*MockHistoryRepositoryInterface_Expecter) FindRecent 

func (_e *MockHistoryRepositoryInterface_Expecter) FindRecent(limit interface{}) *MockHistoryRepositoryInterface_FindRecent_Call

FindRecent is a helper method to define mock.On call

  • limit int

func (*MockHistoryRepositoryInterface_Expecter) List 

func (_e *MockHistoryRepositoryInterface_Expecter) List(limit interface{}, offset interface{}) *MockHistoryRepositoryInterface_List_Call

List is a helper method to define mock.On call

  • limit int
  • offset int

type MockHistoryRepositoryInterface_FindByBatchJobID_Call 

type MockHistoryRepositoryInterface_FindByBatchJobID_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindByBatchJobID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByBatchJobID'

func (*MockHistoryRepositoryInterface_FindByBatchJobID_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindByBatchJobID_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_FindByBatchJobID_Call

func (*MockHistoryRepositoryInterface_FindByBatchJobID_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindByBatchJobID_Call) Run(run func(batchJobID string)) *MockHistoryRepositoryInterface_FindByBatchJobID_Call

func (*MockHistoryRepositoryInterface_FindByBatchJobID_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindByBatchJobID_Call) RunAndReturn(run func(batchJobID string) ([]models.History, error)) *MockHistoryRepositoryInterface_FindByBatchJobID_Call

type MockHistoryRepositoryInterface_FindByDateRange_Call 

type MockHistoryRepositoryInterface_FindByDateRange_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindByDateRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByDateRange'

func (*MockHistoryRepositoryInterface_FindByDateRange_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindByDateRange_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_FindByDateRange_Call

func (*MockHistoryRepositoryInterface_FindByDateRange_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindByDateRange_Call) Run(run func(start time.Time, end time.Time)) *MockHistoryRepositoryInterface_FindByDateRange_Call

func (*MockHistoryRepositoryInterface_FindByDateRange_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindByDateRange_Call) RunAndReturn(run func(start time.Time, end time.Time) ([]models.History, error)) *MockHistoryRepositoryInterface_FindByDateRange_Call

type MockHistoryRepositoryInterface_FindByID_Call 

type MockHistoryRepositoryInterface_FindByID_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockHistoryRepositoryInterface_FindByID_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindByID_Call) Return(history *models.History, err error) *MockHistoryRepositoryInterface_FindByID_Call

func (*MockHistoryRepositoryInterface_FindByID_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindByID_Call) Run(run func(id uint)) *MockHistoryRepositoryInterface_FindByID_Call

func (*MockHistoryRepositoryInterface_FindByID_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindByID_Call) RunAndReturn(run func(id uint) (*models.History, error)) *MockHistoryRepositoryInterface_FindByID_Call

type MockHistoryRepositoryInterface_FindByMovieID_Call 

type MockHistoryRepositoryInterface_FindByMovieID_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindByMovieID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByMovieID'

func (*MockHistoryRepositoryInterface_FindByMovieID_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindByMovieID_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_FindByMovieID_Call

func (*MockHistoryRepositoryInterface_FindByMovieID_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindByMovieID_Call) Run(run func(movieID string)) *MockHistoryRepositoryInterface_FindByMovieID_Call

func (*MockHistoryRepositoryInterface_FindByMovieID_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindByMovieID_Call) RunAndReturn(run func(movieID string) ([]models.History, error)) *MockHistoryRepositoryInterface_FindByMovieID_Call

type MockHistoryRepositoryInterface_FindByOperation_Call 

type MockHistoryRepositoryInterface_FindByOperation_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindByOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByOperation'

func (*MockHistoryRepositoryInterface_FindByOperation_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindByOperation_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_FindByOperation_Call

func (*MockHistoryRepositoryInterface_FindByOperation_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindByOperation_Call) Run(run func(operation string, limit int)) *MockHistoryRepositoryInterface_FindByOperation_Call

func (*MockHistoryRepositoryInterface_FindByOperation_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindByOperation_Call) RunAndReturn(run func(operation string, limit int) ([]models.History, error)) *MockHistoryRepositoryInterface_FindByOperation_Call

type MockHistoryRepositoryInterface_FindByStatus_Call 

type MockHistoryRepositoryInterface_FindByStatus_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindByStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByStatus'

func (*MockHistoryRepositoryInterface_FindByStatus_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindByStatus_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_FindByStatus_Call

func (*MockHistoryRepositoryInterface_FindByStatus_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindByStatus_Call) Run(run func(status string, limit int)) *MockHistoryRepositoryInterface_FindByStatus_Call

func (*MockHistoryRepositoryInterface_FindByStatus_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindByStatus_Call) RunAndReturn(run func(status string, limit int) ([]models.History, error)) *MockHistoryRepositoryInterface_FindByStatus_Call

type MockHistoryRepositoryInterface_FindRecent_Call 

type MockHistoryRepositoryInterface_FindRecent_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_FindRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindRecent'

func (*MockHistoryRepositoryInterface_FindRecent_Call) Return 

func (_c *MockHistoryRepositoryInterface_FindRecent_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_FindRecent_Call

func (*MockHistoryRepositoryInterface_FindRecent_Call) Run 

func (_c *MockHistoryRepositoryInterface_FindRecent_Call) Run(run func(limit int)) *MockHistoryRepositoryInterface_FindRecent_Call

func (*MockHistoryRepositoryInterface_FindRecent_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_FindRecent_Call) RunAndReturn(run func(limit int) ([]models.History, error)) *MockHistoryRepositoryInterface_FindRecent_Call

type MockHistoryRepositoryInterface_List_Call 

type MockHistoryRepositoryInterface_List_Call struct {
	*mock.Call
}

MockHistoryRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockHistoryRepositoryInterface_List_Call) Return 

func (_c *MockHistoryRepositoryInterface_List_Call) Return(historys []models.History, err error) *MockHistoryRepositoryInterface_List_Call

func (*MockHistoryRepositoryInterface_List_Call) Run 

func (_c *MockHistoryRepositoryInterface_List_Call) Run(run func(limit int, offset int)) *MockHistoryRepositoryInterface_List_Call

func (*MockHistoryRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockHistoryRepositoryInterface_List_Call) RunAndReturn(run func(limit int, offset int) ([]models.History, error)) *MockHistoryRepositoryInterface_List_Call

type MockJobRepositoryInterface 

type MockJobRepositoryInterface struct {
	mock.Mock
}

MockJobRepositoryInterface is an autogenerated mock type for the JobRepositoryInterface type

func NewMockJobRepositoryInterface 

func NewMockJobRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockJobRepositoryInterface

NewMockJobRepositoryInterface creates a new instance of MockJobRepositoryInterface. 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 (*MockJobRepositoryInterface) Create 

func (_mock *MockJobRepositoryInterface) Create(job *models.Job) error

Create provides a mock function for the type MockJobRepositoryInterface

func (*MockJobRepositoryInterface) Delete 

func (_mock *MockJobRepositoryInterface) Delete(id string) error

Delete provides a mock function for the type MockJobRepositoryInterface

func (*MockJobRepositoryInterface) DeleteOrganizedOlderThan 

func (_mock *MockJobRepositoryInterface) DeleteOrganizedOlderThan(date time.Time) error

DeleteOrganizedOlderThan provides a mock function for the type MockJobRepositoryInterface

func (*MockJobRepositoryInterface) EXPECT 

func (_m *MockJobRepositoryInterface) EXPECT() *MockJobRepositoryInterface_Expecter

func (*MockJobRepositoryInterface) FindByID 

func (_mock *MockJobRepositoryInterface) FindByID(id string) (*models.Job, error)

FindByID provides a mock function for the type MockJobRepositoryInterface

func (*MockJobRepositoryInterface) List 

func (_mock *MockJobRepositoryInterface) List() ([]models.Job, error)

List provides a mock function for the type MockJobRepositoryInterface

func (*MockJobRepositoryInterface) Update 

func (_mock *MockJobRepositoryInterface) Update(job *models.Job) error

Update provides a mock function for the type MockJobRepositoryInterface

func (*MockJobRepositoryInterface) Upsert 

func (_mock *MockJobRepositoryInterface) Upsert(job *models.Job) error

Upsert provides a mock function for the type MockJobRepositoryInterface

type MockJobRepositoryInterface_Create_Call 

type MockJobRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockJobRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockJobRepositoryInterface_Create_Call) Return 

func (_c *MockJobRepositoryInterface_Create_Call) Return(err error) *MockJobRepositoryInterface_Create_Call

func (*MockJobRepositoryInterface_Create_Call) Run 

func (_c *MockJobRepositoryInterface_Create_Call) Run(run func(job *models.Job)) *MockJobRepositoryInterface_Create_Call

func (*MockJobRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_Create_Call) RunAndReturn(run func(job *models.Job) error) *MockJobRepositoryInterface_Create_Call

type MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call 

type MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call struct {
	*mock.Call
}

MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganizedOlderThan'

func (*MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call) Return 

func (_c *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call) Return(err error) *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call

func (*MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call) Run 

func (_c *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call) Run(run func(date time.Time)) *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call

func (*MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call) RunAndReturn(run func(date time.Time) error) *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call

type MockJobRepositoryInterface_Delete_Call 

type MockJobRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockJobRepositoryInterface_Delete_Call) Return 

func (_c *MockJobRepositoryInterface_Delete_Call) Return(err error) *MockJobRepositoryInterface_Delete_Call

func (*MockJobRepositoryInterface_Delete_Call) Run 

func (_c *MockJobRepositoryInterface_Delete_Call) Run(run func(id string)) *MockJobRepositoryInterface_Delete_Call

func (*MockJobRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_Delete_Call) RunAndReturn(run func(id string) error) *MockJobRepositoryInterface_Delete_Call

type MockJobRepositoryInterface_Expecter 

type MockJobRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockJobRepositoryInterface_Expecter) Create 

func (_e *MockJobRepositoryInterface_Expecter) Create(job interface{}) *MockJobRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • job *models.Job

func (*MockJobRepositoryInterface_Expecter) Delete 

func (_e *MockJobRepositoryInterface_Expecter) Delete(id interface{}) *MockJobRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • id string

func (*MockJobRepositoryInterface_Expecter) DeleteOrganizedOlderThan 

func (_e *MockJobRepositoryInterface_Expecter) DeleteOrganizedOlderThan(date interface{}) *MockJobRepositoryInterface_DeleteOrganizedOlderThan_Call

DeleteOrganizedOlderThan is a helper method to define mock.On call

  • date time.Time

func (*MockJobRepositoryInterface_Expecter) FindByID 

func (_e *MockJobRepositoryInterface_Expecter) FindByID(id interface{}) *MockJobRepositoryInterface_FindByID_Call

FindByID is a helper method to define mock.On call

  • id string

func (*MockJobRepositoryInterface_Expecter) List 

func (_e *MockJobRepositoryInterface_Expecter) List() *MockJobRepositoryInterface_List_Call

List is a helper method to define mock.On call

func (*MockJobRepositoryInterface_Expecter) Update 

func (_e *MockJobRepositoryInterface_Expecter) Update(job interface{}) *MockJobRepositoryInterface_Update_Call

Update is a helper method to define mock.On call

  • job *models.Job

func (*MockJobRepositoryInterface_Expecter) Upsert 

func (_e *MockJobRepositoryInterface_Expecter) Upsert(job interface{}) *MockJobRepositoryInterface_Upsert_Call

Upsert is a helper method to define mock.On call

  • job *models.Job

type MockJobRepositoryInterface_FindByID_Call 

type MockJobRepositoryInterface_FindByID_Call struct {
	*mock.Call
}

MockJobRepositoryInterface_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockJobRepositoryInterface_FindByID_Call) Return 

func (_c *MockJobRepositoryInterface_FindByID_Call) Return(job *models.Job, err error) *MockJobRepositoryInterface_FindByID_Call

func (*MockJobRepositoryInterface_FindByID_Call) Run 

func (_c *MockJobRepositoryInterface_FindByID_Call) Run(run func(id string)) *MockJobRepositoryInterface_FindByID_Call

func (*MockJobRepositoryInterface_FindByID_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_FindByID_Call) RunAndReturn(run func(id string) (*models.Job, error)) *MockJobRepositoryInterface_FindByID_Call

type MockJobRepositoryInterface_List_Call 

type MockJobRepositoryInterface_List_Call struct {
	*mock.Call
}

MockJobRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockJobRepositoryInterface_List_Call) Return 

func (_c *MockJobRepositoryInterface_List_Call) Return(jobs []models.Job, err error) *MockJobRepositoryInterface_List_Call

func (*MockJobRepositoryInterface_List_Call) Run 

func (_c *MockJobRepositoryInterface_List_Call) Run(run func()) *MockJobRepositoryInterface_List_Call

func (*MockJobRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_List_Call) RunAndReturn(run func() ([]models.Job, error)) *MockJobRepositoryInterface_List_Call

type MockJobRepositoryInterface_Update_Call 

type MockJobRepositoryInterface_Update_Call struct {
	*mock.Call
}

MockJobRepositoryInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockJobRepositoryInterface_Update_Call) Return 

func (_c *MockJobRepositoryInterface_Update_Call) Return(err error) *MockJobRepositoryInterface_Update_Call

func (*MockJobRepositoryInterface_Update_Call) Run 

func (_c *MockJobRepositoryInterface_Update_Call) Run(run func(job *models.Job)) *MockJobRepositoryInterface_Update_Call

func (*MockJobRepositoryInterface_Update_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_Update_Call) RunAndReturn(run func(job *models.Job) error) *MockJobRepositoryInterface_Update_Call

type MockJobRepositoryInterface_Upsert_Call 

type MockJobRepositoryInterface_Upsert_Call struct {
	*mock.Call
}

MockJobRepositoryInterface_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'

func (*MockJobRepositoryInterface_Upsert_Call) Return 

func (_c *MockJobRepositoryInterface_Upsert_Call) Return(err error) *MockJobRepositoryInterface_Upsert_Call

func (*MockJobRepositoryInterface_Upsert_Call) Run 

func (_c *MockJobRepositoryInterface_Upsert_Call) Run(run func(job *models.Job)) *MockJobRepositoryInterface_Upsert_Call

func (*MockJobRepositoryInterface_Upsert_Call) RunAndReturn 

func (_c *MockJobRepositoryInterface_Upsert_Call) RunAndReturn(run func(job *models.Job) error) *MockJobRepositoryInterface_Upsert_Call

type MockMovieRepositoryInterface 

type MockMovieRepositoryInterface struct {
	mock.Mock
}

MockMovieRepositoryInterface is an autogenerated mock type for the MovieRepositoryInterface type

func NewMockMovieRepositoryInterface 

func NewMockMovieRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMovieRepositoryInterface

NewMockMovieRepositoryInterface creates a new instance of MockMovieRepositoryInterface. 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 (*MockMovieRepositoryInterface) Create 

func (_mock *MockMovieRepositoryInterface) Create(movie *models.Movie) error

Create provides a mock function for the type MockMovieRepositoryInterface

func (*MockMovieRepositoryInterface) Delete 

func (_mock *MockMovieRepositoryInterface) Delete(id string) error

Delete provides a mock function for the type MockMovieRepositoryInterface

func (*MockMovieRepositoryInterface) EXPECT 

func (_m *MockMovieRepositoryInterface) EXPECT() *MockMovieRepositoryInterface_Expecter

func (*MockMovieRepositoryInterface) FindByContentID 

func (_mock *MockMovieRepositoryInterface) FindByContentID(contentID string) (*models.Movie, error)

FindByContentID provides a mock function for the type MockMovieRepositoryInterface

func (*MockMovieRepositoryInterface) FindByID 

func (_mock *MockMovieRepositoryInterface) FindByID(id string) (*models.Movie, error)

FindByID provides a mock function for the type MockMovieRepositoryInterface

func (*MockMovieRepositoryInterface) List 

func (_mock *MockMovieRepositoryInterface) List(limit int, offset int) ([]models.Movie, error)

List provides a mock function for the type MockMovieRepositoryInterface

func (*MockMovieRepositoryInterface) Update 

func (_mock *MockMovieRepositoryInterface) Update(movie *models.Movie) error

Update provides a mock function for the type MockMovieRepositoryInterface

func (*MockMovieRepositoryInterface) Upsert 

func (_mock *MockMovieRepositoryInterface) Upsert(movie *models.Movie) (*models.Movie, error)

Upsert provides a mock function for the type MockMovieRepositoryInterface

type MockMovieRepositoryInterface_Create_Call 

type MockMovieRepositoryInterface_Create_Call struct {
	*mock.Call
}

MockMovieRepositoryInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockMovieRepositoryInterface_Create_Call) Return 

func (_c *MockMovieRepositoryInterface_Create_Call) Return(err error) *MockMovieRepositoryInterface_Create_Call

func (*MockMovieRepositoryInterface_Create_Call) Run 

func (_c *MockMovieRepositoryInterface_Create_Call) Run(run func(movie *models.Movie)) *MockMovieRepositoryInterface_Create_Call

func (*MockMovieRepositoryInterface_Create_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_Create_Call) RunAndReturn(run func(movie *models.Movie) error) *MockMovieRepositoryInterface_Create_Call

type MockMovieRepositoryInterface_Delete_Call 

type MockMovieRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockMovieRepositoryInterface_Delete_Call) Return 

func (_c *MockMovieRepositoryInterface_Delete_Call) Return(err error) *MockMovieRepositoryInterface_Delete_Call

func (*MockMovieRepositoryInterface_Delete_Call) Run 

func (_c *MockMovieRepositoryInterface_Delete_Call) Run(run func(id string)) *MockMovieRepositoryInterface_Delete_Call

func (*MockMovieRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_Delete_Call) RunAndReturn(run func(id string) error) *MockMovieRepositoryInterface_Delete_Call

type MockMovieRepositoryInterface_Expecter 

type MockMovieRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMovieRepositoryInterface_Expecter) Create 

func (_e *MockMovieRepositoryInterface_Expecter) Create(movie interface{}) *MockMovieRepositoryInterface_Create_Call

Create is a helper method to define mock.On call

  • movie *models.Movie

func (*MockMovieRepositoryInterface_Expecter) Delete 

func (_e *MockMovieRepositoryInterface_Expecter) Delete(id interface{}) *MockMovieRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • id string

func (*MockMovieRepositoryInterface_Expecter) FindByContentID 

func (_e *MockMovieRepositoryInterface_Expecter) FindByContentID(contentID interface{}) *MockMovieRepositoryInterface_FindByContentID_Call

FindByContentID is a helper method to define mock.On call

  • contentID string

func (*MockMovieRepositoryInterface_Expecter) FindByID 

func (_e *MockMovieRepositoryInterface_Expecter) FindByID(id interface{}) *MockMovieRepositoryInterface_FindByID_Call

FindByID is a helper method to define mock.On call

  • id string

func (*MockMovieRepositoryInterface_Expecter) List 

func (_e *MockMovieRepositoryInterface_Expecter) List(limit interface{}, offset interface{}) *MockMovieRepositoryInterface_List_Call

List is a helper method to define mock.On call

  • limit int
  • offset int

func (*MockMovieRepositoryInterface_Expecter) Update 

func (_e *MockMovieRepositoryInterface_Expecter) Update(movie interface{}) *MockMovieRepositoryInterface_Update_Call

Update is a helper method to define mock.On call

  • movie *models.Movie

func (*MockMovieRepositoryInterface_Expecter) Upsert 

func (_e *MockMovieRepositoryInterface_Expecter) Upsert(movie interface{}) *MockMovieRepositoryInterface_Upsert_Call

Upsert is a helper method to define mock.On call

  • movie *models.Movie

type MockMovieRepositoryInterface_FindByContentID_Call 

type MockMovieRepositoryInterface_FindByContentID_Call struct {
	*mock.Call
}

MockMovieRepositoryInterface_FindByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByContentID'

func (*MockMovieRepositoryInterface_FindByContentID_Call) Return 

func (_c *MockMovieRepositoryInterface_FindByContentID_Call) Return(movie *models.Movie, err error) *MockMovieRepositoryInterface_FindByContentID_Call

func (*MockMovieRepositoryInterface_FindByContentID_Call) Run 

func (_c *MockMovieRepositoryInterface_FindByContentID_Call) Run(run func(contentID string)) *MockMovieRepositoryInterface_FindByContentID_Call

func (*MockMovieRepositoryInterface_FindByContentID_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_FindByContentID_Call) RunAndReturn(run func(contentID string) (*models.Movie, error)) *MockMovieRepositoryInterface_FindByContentID_Call

type MockMovieRepositoryInterface_FindByID_Call 

type MockMovieRepositoryInterface_FindByID_Call struct {
	*mock.Call
}

MockMovieRepositoryInterface_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockMovieRepositoryInterface_FindByID_Call) Return 

func (_c *MockMovieRepositoryInterface_FindByID_Call) Return(movie *models.Movie, err error) *MockMovieRepositoryInterface_FindByID_Call

func (*MockMovieRepositoryInterface_FindByID_Call) Run 

func (_c *MockMovieRepositoryInterface_FindByID_Call) Run(run func(id string)) *MockMovieRepositoryInterface_FindByID_Call

func (*MockMovieRepositoryInterface_FindByID_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_FindByID_Call) RunAndReturn(run func(id string) (*models.Movie, error)) *MockMovieRepositoryInterface_FindByID_Call

type MockMovieRepositoryInterface_List_Call 

type MockMovieRepositoryInterface_List_Call struct {
	*mock.Call
}

MockMovieRepositoryInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockMovieRepositoryInterface_List_Call) Return 

func (_c *MockMovieRepositoryInterface_List_Call) Return(movies []models.Movie, err error) *MockMovieRepositoryInterface_List_Call

func (*MockMovieRepositoryInterface_List_Call) Run 

func (_c *MockMovieRepositoryInterface_List_Call) Run(run func(limit int, offset int)) *MockMovieRepositoryInterface_List_Call

func (*MockMovieRepositoryInterface_List_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_List_Call) RunAndReturn(run func(limit int, offset int) ([]models.Movie, error)) *MockMovieRepositoryInterface_List_Call

type MockMovieRepositoryInterface_Update_Call 

type MockMovieRepositoryInterface_Update_Call struct {
	*mock.Call
}

MockMovieRepositoryInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockMovieRepositoryInterface_Update_Call) Return 

func (_c *MockMovieRepositoryInterface_Update_Call) Return(err error) *MockMovieRepositoryInterface_Update_Call

func (*MockMovieRepositoryInterface_Update_Call) Run 

func (_c *MockMovieRepositoryInterface_Update_Call) Run(run func(movie *models.Movie)) *MockMovieRepositoryInterface_Update_Call

func (*MockMovieRepositoryInterface_Update_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_Update_Call) RunAndReturn(run func(movie *models.Movie) error) *MockMovieRepositoryInterface_Update_Call

type MockMovieRepositoryInterface_Upsert_Call 

type MockMovieRepositoryInterface_Upsert_Call struct {
	*mock.Call
}

MockMovieRepositoryInterface_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'

func (*MockMovieRepositoryInterface_Upsert_Call) Return 

func (_c *MockMovieRepositoryInterface_Upsert_Call) Return(movie1 *models.Movie, err error) *MockMovieRepositoryInterface_Upsert_Call

func (*MockMovieRepositoryInterface_Upsert_Call) Run 

func (_c *MockMovieRepositoryInterface_Upsert_Call) Run(run func(movie *models.Movie)) *MockMovieRepositoryInterface_Upsert_Call

func (*MockMovieRepositoryInterface_Upsert_Call) RunAndReturn 

func (_c *MockMovieRepositoryInterface_Upsert_Call) RunAndReturn(run func(movie *models.Movie) (*models.Movie, error)) *MockMovieRepositoryInterface_Upsert_Call

type MockMovieTagRepositoryInterface 

type MockMovieTagRepositoryInterface struct {
	mock.Mock
}

MockMovieTagRepositoryInterface is an autogenerated mock type for the MovieTagRepositoryInterface type

func NewMockMovieTagRepositoryInterface 

func NewMockMovieTagRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMovieTagRepositoryInterface

NewMockMovieTagRepositoryInterface creates a new instance of MockMovieTagRepositoryInterface. 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 (*MockMovieTagRepositoryInterface) AddTag 

func (_mock *MockMovieTagRepositoryInterface) AddTag(movieID string, tag string) error

AddTag provides a mock function for the type MockMovieTagRepositoryInterface

func (*MockMovieTagRepositoryInterface) EXPECT 

func (_m *MockMovieTagRepositoryInterface) EXPECT() *MockMovieTagRepositoryInterface_Expecter

func (*MockMovieTagRepositoryInterface) GetMoviesWithTag 

func (_mock *MockMovieTagRepositoryInterface) GetMoviesWithTag(tag string) ([]string, error)

GetMoviesWithTag provides a mock function for the type MockMovieTagRepositoryInterface

func (*MockMovieTagRepositoryInterface) GetTagsForMovie 

func (_mock *MockMovieTagRepositoryInterface) GetTagsForMovie(movieID string) ([]string, error)

GetTagsForMovie provides a mock function for the type MockMovieTagRepositoryInterface

func (*MockMovieTagRepositoryInterface) GetUniqueTagsList 

func (_mock *MockMovieTagRepositoryInterface) GetUniqueTagsList() ([]string, error)

GetUniqueTagsList provides a mock function for the type MockMovieTagRepositoryInterface

func (*MockMovieTagRepositoryInterface) ListAll 

func (_mock *MockMovieTagRepositoryInterface) ListAll() (map[string][]string, error)

ListAll provides a mock function for the type MockMovieTagRepositoryInterface

func (*MockMovieTagRepositoryInterface) RemoveAllTags 

func (_mock *MockMovieTagRepositoryInterface) RemoveAllTags(movieID string) error

RemoveAllTags provides a mock function for the type MockMovieTagRepositoryInterface

func (*MockMovieTagRepositoryInterface) RemoveTag 

func (_mock *MockMovieTagRepositoryInterface) RemoveTag(movieID string, tag string) error

RemoveTag provides a mock function for the type MockMovieTagRepositoryInterface

type MockMovieTagRepositoryInterface_AddTag_Call 

type MockMovieTagRepositoryInterface_AddTag_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_AddTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTag'

func (*MockMovieTagRepositoryInterface_AddTag_Call) Return 

func (_c *MockMovieTagRepositoryInterface_AddTag_Call) Return(err error) *MockMovieTagRepositoryInterface_AddTag_Call

func (*MockMovieTagRepositoryInterface_AddTag_Call) Run 

func (_c *MockMovieTagRepositoryInterface_AddTag_Call) Run(run func(movieID string, tag string)) *MockMovieTagRepositoryInterface_AddTag_Call

func (*MockMovieTagRepositoryInterface_AddTag_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_AddTag_Call) RunAndReturn(run func(movieID string, tag string) error) *MockMovieTagRepositoryInterface_AddTag_Call

type MockMovieTagRepositoryInterface_Expecter 

type MockMovieTagRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMovieTagRepositoryInterface_Expecter) AddTag 

func (_e *MockMovieTagRepositoryInterface_Expecter) AddTag(movieID interface{}, tag interface{}) *MockMovieTagRepositoryInterface_AddTag_Call

AddTag is a helper method to define mock.On call

  • movieID string
  • tag string

func (*MockMovieTagRepositoryInterface_Expecter) GetMoviesWithTag 

func (_e *MockMovieTagRepositoryInterface_Expecter) GetMoviesWithTag(tag interface{}) *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call

GetMoviesWithTag is a helper method to define mock.On call

  • tag string

func (*MockMovieTagRepositoryInterface_Expecter) GetTagsForMovie 

func (_e *MockMovieTagRepositoryInterface_Expecter) GetTagsForMovie(movieID interface{}) *MockMovieTagRepositoryInterface_GetTagsForMovie_Call

GetTagsForMovie is a helper method to define mock.On call

  • movieID string

func (*MockMovieTagRepositoryInterface_Expecter) GetUniqueTagsList 

func (_e *MockMovieTagRepositoryInterface_Expecter) GetUniqueTagsList() *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call

GetUniqueTagsList is a helper method to define mock.On call

func (*MockMovieTagRepositoryInterface_Expecter) ListAll 

func (_e *MockMovieTagRepositoryInterface_Expecter) ListAll() *MockMovieTagRepositoryInterface_ListAll_Call

ListAll is a helper method to define mock.On call

func (*MockMovieTagRepositoryInterface_Expecter) RemoveAllTags 

func (_e *MockMovieTagRepositoryInterface_Expecter) RemoveAllTags(movieID interface{}) *MockMovieTagRepositoryInterface_RemoveAllTags_Call

RemoveAllTags is a helper method to define mock.On call

  • movieID string

func (*MockMovieTagRepositoryInterface_Expecter) RemoveTag 

func (_e *MockMovieTagRepositoryInterface_Expecter) RemoveTag(movieID interface{}, tag interface{}) *MockMovieTagRepositoryInterface_RemoveTag_Call

RemoveTag is a helper method to define mock.On call

  • movieID string
  • tag string

type MockMovieTagRepositoryInterface_GetMoviesWithTag_Call 

type MockMovieTagRepositoryInterface_GetMoviesWithTag_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_GetMoviesWithTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMoviesWithTag'

func (*MockMovieTagRepositoryInterface_GetMoviesWithTag_Call) Return 

func (_c *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call) Return(strings []string, err error) *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call

func (*MockMovieTagRepositoryInterface_GetMoviesWithTag_Call) Run 

func (_c *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call) Run(run func(tag string)) *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call

func (*MockMovieTagRepositoryInterface_GetMoviesWithTag_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call) RunAndReturn(run func(tag string) ([]string, error)) *MockMovieTagRepositoryInterface_GetMoviesWithTag_Call

type MockMovieTagRepositoryInterface_GetTagsForMovie_Call 

type MockMovieTagRepositoryInterface_GetTagsForMovie_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_GetTagsForMovie_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTagsForMovie'

func (*MockMovieTagRepositoryInterface_GetTagsForMovie_Call) Return 

func (_c *MockMovieTagRepositoryInterface_GetTagsForMovie_Call) Return(strings []string, err error) *MockMovieTagRepositoryInterface_GetTagsForMovie_Call

func (*MockMovieTagRepositoryInterface_GetTagsForMovie_Call) Run 

func (_c *MockMovieTagRepositoryInterface_GetTagsForMovie_Call) Run(run func(movieID string)) *MockMovieTagRepositoryInterface_GetTagsForMovie_Call

func (*MockMovieTagRepositoryInterface_GetTagsForMovie_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_GetTagsForMovie_Call) RunAndReturn(run func(movieID string) ([]string, error)) *MockMovieTagRepositoryInterface_GetTagsForMovie_Call

type MockMovieTagRepositoryInterface_GetUniqueTagsList_Call 

type MockMovieTagRepositoryInterface_GetUniqueTagsList_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_GetUniqueTagsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUniqueTagsList'

func (*MockMovieTagRepositoryInterface_GetUniqueTagsList_Call) Return 

func (_c *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call) Return(strings []string, err error) *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call

func (*MockMovieTagRepositoryInterface_GetUniqueTagsList_Call) Run 

func (_c *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call) Run(run func()) *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call

func (*MockMovieTagRepositoryInterface_GetUniqueTagsList_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call) RunAndReturn(run func() ([]string, error)) *MockMovieTagRepositoryInterface_GetUniqueTagsList_Call

type MockMovieTagRepositoryInterface_ListAll_Call 

type MockMovieTagRepositoryInterface_ListAll_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockMovieTagRepositoryInterface_ListAll_Call) Return 

func (_c *MockMovieTagRepositoryInterface_ListAll_Call) Return(stringToStrings map[string][]string, err error) *MockMovieTagRepositoryInterface_ListAll_Call

func (*MockMovieTagRepositoryInterface_ListAll_Call) Run 

func (_c *MockMovieTagRepositoryInterface_ListAll_Call) Run(run func()) *MockMovieTagRepositoryInterface_ListAll_Call

func (*MockMovieTagRepositoryInterface_ListAll_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_ListAll_Call) RunAndReturn(run func() (map[string][]string, error)) *MockMovieTagRepositoryInterface_ListAll_Call

type MockMovieTagRepositoryInterface_RemoveAllTags_Call 

type MockMovieTagRepositoryInterface_RemoveAllTags_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_RemoveAllTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllTags'

func (*MockMovieTagRepositoryInterface_RemoveAllTags_Call) Return 

func (_c *MockMovieTagRepositoryInterface_RemoveAllTags_Call) Return(err error) *MockMovieTagRepositoryInterface_RemoveAllTags_Call

func (*MockMovieTagRepositoryInterface_RemoveAllTags_Call) Run 

func (_c *MockMovieTagRepositoryInterface_RemoveAllTags_Call) Run(run func(movieID string)) *MockMovieTagRepositoryInterface_RemoveAllTags_Call

func (*MockMovieTagRepositoryInterface_RemoveAllTags_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_RemoveAllTags_Call) RunAndReturn(run func(movieID string) error) *MockMovieTagRepositoryInterface_RemoveAllTags_Call

type MockMovieTagRepositoryInterface_RemoveTag_Call 

type MockMovieTagRepositoryInterface_RemoveTag_Call struct {
	*mock.Call
}

MockMovieTagRepositoryInterface_RemoveTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTag'

func (*MockMovieTagRepositoryInterface_RemoveTag_Call) Return 

func (_c *MockMovieTagRepositoryInterface_RemoveTag_Call) Return(err error) *MockMovieTagRepositoryInterface_RemoveTag_Call

func (*MockMovieTagRepositoryInterface_RemoveTag_Call) Run 

func (_c *MockMovieTagRepositoryInterface_RemoveTag_Call) Run(run func(movieID string, tag string)) *MockMovieTagRepositoryInterface_RemoveTag_Call

func (*MockMovieTagRepositoryInterface_RemoveTag_Call) RunAndReturn 

func (_c *MockMovieTagRepositoryInterface_RemoveTag_Call) RunAndReturn(run func(movieID string, tag string) error) *MockMovieTagRepositoryInterface_RemoveTag_Call

type MockMovieTranslationRepositoryInterface 

type MockMovieTranslationRepositoryInterface struct {
	mock.Mock
}

MockMovieTranslationRepositoryInterface is an autogenerated mock type for the MovieTranslationRepositoryInterface type

func NewMockMovieTranslationRepositoryInterface 

func NewMockMovieTranslationRepositoryInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMovieTranslationRepositoryInterface

NewMockMovieTranslationRepositoryInterface creates a new instance of MockMovieTranslationRepositoryInterface. 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 (*MockMovieTranslationRepositoryInterface) Delete 

func (_mock *MockMovieTranslationRepositoryInterface) Delete(movieID string, language string) error

Delete provides a mock function for the type MockMovieTranslationRepositoryInterface

func (*MockMovieTranslationRepositoryInterface) EXPECT 

func (_m *MockMovieTranslationRepositoryInterface) EXPECT() *MockMovieTranslationRepositoryInterface_Expecter

func (*MockMovieTranslationRepositoryInterface) FindAllByMovie 

func (_mock *MockMovieTranslationRepositoryInterface) FindAllByMovie(movieID string) ([]models.MovieTranslation, error)

FindAllByMovie provides a mock function for the type MockMovieTranslationRepositoryInterface

func (*MockMovieTranslationRepositoryInterface) FindByMovieAndLanguage 

func (_mock *MockMovieTranslationRepositoryInterface) FindByMovieAndLanguage(movieID string, language string) (*models.MovieTranslation, error)

FindByMovieAndLanguage provides a mock function for the type MockMovieTranslationRepositoryInterface

func (*MockMovieTranslationRepositoryInterface) Upsert 

func (_mock *MockMovieTranslationRepositoryInterface) Upsert(translation *models.MovieTranslation) error

Upsert provides a mock function for the type MockMovieTranslationRepositoryInterface

func (*MockMovieTranslationRepositoryInterface) UpsertTx 

func (_mock *MockMovieTranslationRepositoryInterface) UpsertTx(tx *gorm.DB, translation *models.MovieTranslation) error

UpsertTx provides a mock function for the type MockMovieTranslationRepositoryInterface

type MockMovieTranslationRepositoryInterface_Delete_Call 

type MockMovieTranslationRepositoryInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockMovieTranslationRepositoryInterface_Delete_Call) Return 

func (_c *MockMovieTranslationRepositoryInterface_Delete_Call) Return(err error) *MockMovieTranslationRepositoryInterface_Delete_Call

func (*MockMovieTranslationRepositoryInterface_Delete_Call) Run 

func (_c *MockMovieTranslationRepositoryInterface_Delete_Call) Run(run func(movieID string, language string)) *MockMovieTranslationRepositoryInterface_Delete_Call

func (*MockMovieTranslationRepositoryInterface_Delete_Call) RunAndReturn 

func (_c *MockMovieTranslationRepositoryInterface_Delete_Call) RunAndReturn(run func(movieID string, language string) error) *MockMovieTranslationRepositoryInterface_Delete_Call

type MockMovieTranslationRepositoryInterface_Expecter 

type MockMovieTranslationRepositoryInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMovieTranslationRepositoryInterface_Expecter) Delete 

func (_e *MockMovieTranslationRepositoryInterface_Expecter) Delete(movieID interface{}, language interface{}) *MockMovieTranslationRepositoryInterface_Delete_Call

Delete is a helper method to define mock.On call

  • movieID string
  • language string

func (*MockMovieTranslationRepositoryInterface_Expecter) FindAllByMovie 

func (_e *MockMovieTranslationRepositoryInterface_Expecter) FindAllByMovie(movieID interface{}) *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call

FindAllByMovie is a helper method to define mock.On call

  • movieID string

func (*MockMovieTranslationRepositoryInterface_Expecter) FindByMovieAndLanguage 

func (_e *MockMovieTranslationRepositoryInterface_Expecter) FindByMovieAndLanguage(movieID interface{}, language interface{}) *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call

FindByMovieAndLanguage is a helper method to define mock.On call

  • movieID string
  • language string

func (*MockMovieTranslationRepositoryInterface_Expecter) Upsert 

func (_e *MockMovieTranslationRepositoryInterface_Expecter) Upsert(translation interface{}) *MockMovieTranslationRepositoryInterface_Upsert_Call

Upsert is a helper method to define mock.On call

  • translation *models.MovieTranslation

func (*MockMovieTranslationRepositoryInterface_Expecter) UpsertTx 

func (_e *MockMovieTranslationRepositoryInterface_Expecter) UpsertTx(tx interface{}, translation interface{}) *MockMovieTranslationRepositoryInterface_UpsertTx_Call

UpsertTx is a helper method to define mock.On call

  • tx *gorm.DB
  • translation *models.MovieTranslation

type MockMovieTranslationRepositoryInterface_FindAllByMovie_Call 

type MockMovieTranslationRepositoryInterface_FindAllByMovie_Call struct {
	*mock.Call
}

MockMovieTranslationRepositoryInterface_FindAllByMovie_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllByMovie'

func (*MockMovieTranslationRepositoryInterface_FindAllByMovie_Call) Return 

func (_c *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call) Return(movieTranslations []models.MovieTranslation, err error) *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call

func (*MockMovieTranslationRepositoryInterface_FindAllByMovie_Call) Run 

func (_c *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call) Run(run func(movieID string)) *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call

func (*MockMovieTranslationRepositoryInterface_FindAllByMovie_Call) RunAndReturn 

func (_c *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call) RunAndReturn(run func(movieID string) ([]models.MovieTranslation, error)) *MockMovieTranslationRepositoryInterface_FindAllByMovie_Call

type MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call 

type MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call struct {
	*mock.Call
}

MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByMovieAndLanguage'

func (*MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call) Return 

func (_c *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call) Return(movieTranslation *models.MovieTranslation, err error) *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call

func (*MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call) Run 

func (_c *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call) Run(run func(movieID string, language string)) *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call

func (*MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call) RunAndReturn 

func (_c *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call) RunAndReturn(run func(movieID string, language string) (*models.MovieTranslation, error)) *MockMovieTranslationRepositoryInterface_FindByMovieAndLanguage_Call

type MockMovieTranslationRepositoryInterface_UpsertTx_Call 

type MockMovieTranslationRepositoryInterface_UpsertTx_Call struct {
	*mock.Call
}

MockMovieTranslationRepositoryInterface_UpsertTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertTx'

func (*MockMovieTranslationRepositoryInterface_UpsertTx_Call) Return 

func (_c *MockMovieTranslationRepositoryInterface_UpsertTx_Call) Return(err error) *MockMovieTranslationRepositoryInterface_UpsertTx_Call

func (*MockMovieTranslationRepositoryInterface_UpsertTx_Call) Run 

func (_c *MockMovieTranslationRepositoryInterface_UpsertTx_Call) Run(run func(tx *gorm.DB, translation *models.MovieTranslation)) *MockMovieTranslationRepositoryInterface_UpsertTx_Call

func (*MockMovieTranslationRepositoryInterface_UpsertTx_Call) RunAndReturn 

func (_c *MockMovieTranslationRepositoryInterface_UpsertTx_Call) RunAndReturn(run func(tx *gorm.DB, translation *models.MovieTranslation) error) *MockMovieTranslationRepositoryInterface_UpsertTx_Call

type MockMovieTranslationRepositoryInterface_Upsert_Call 

type MockMovieTranslationRepositoryInterface_Upsert_Call struct {
	*mock.Call
}

MockMovieTranslationRepositoryInterface_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'

func (*MockMovieTranslationRepositoryInterface_Upsert_Call) Return 

func (_c *MockMovieTranslationRepositoryInterface_Upsert_Call) Return(err error) *MockMovieTranslationRepositoryInterface_Upsert_Call

func (*MockMovieTranslationRepositoryInterface_Upsert_Call) Run 

func (_c *MockMovieTranslationRepositoryInterface_Upsert_Call) Run(run func(translation *models.MovieTranslation)) *MockMovieTranslationRepositoryInterface_Upsert_Call

func (*MockMovieTranslationRepositoryInterface_Upsert_Call) RunAndReturn 

func (_c *MockMovieTranslationRepositoryInterface_Upsert_Call) RunAndReturn(run func(translation *models.MovieTranslation) error) *MockMovieTranslationRepositoryInterface_Upsert_Call

type MockScraper 

type MockScraper struct {
	mock.Mock
}

MockScraper is an autogenerated mock type for the Scraper type

func NewMockScraper 

func NewMockScraper(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockScraper

NewMockScraper creates a new instance of MockScraper. 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 (*MockScraper) Close 

func (_mock *MockScraper) Close() error

Close provides a mock function for the type MockScraper

func (*MockScraper) Config 

func (_mock *MockScraper) Config() *config.ScraperSettings

Config provides a mock function for the type MockScraper

func (*MockScraper) EXPECT 

func (_m *MockScraper) EXPECT() *MockScraper_Expecter

func (*MockScraper) GetURL 

func (_mock *MockScraper) GetURL(id string) (string, error)

GetURL provides a mock function for the type MockScraper

func (*MockScraper) IsEnabled 

func (_mock *MockScraper) IsEnabled() bool

IsEnabled provides a mock function for the type MockScraper

func (*MockScraper) Name 

func (_mock *MockScraper) Name() string

Name provides a mock function for the type MockScraper

func (*MockScraper) Search 

func (_mock *MockScraper) Search(ctx context.Context, id string) (*models.ScraperResult, error)

Search provides a mock function for the type MockScraper

type MockScraper_Close_Call 

type MockScraper_Close_Call struct {
	*mock.Call
}

MockScraper_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'

func (*MockScraper_Close_Call) Return 

func (_c *MockScraper_Close_Call) Return(err error) *MockScraper_Close_Call

func (*MockScraper_Close_Call) Run 

func (_c *MockScraper_Close_Call) Run(run func()) *MockScraper_Close_Call

func (*MockScraper_Close_Call) RunAndReturn 

func (_c *MockScraper_Close_Call) RunAndReturn(run func() error) *MockScraper_Close_Call

type MockScraper_Config_Call 

type MockScraper_Config_Call struct {
	*mock.Call
}

MockScraper_Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Config'

func (*MockScraper_Config_Call) Return 

func (_c *MockScraper_Config_Call) Return(scraperSettings *config.ScraperSettings) *MockScraper_Config_Call

func (*MockScraper_Config_Call) Run 

func (_c *MockScraper_Config_Call) Run(run func()) *MockScraper_Config_Call

func (*MockScraper_Config_Call) RunAndReturn 

func (_c *MockScraper_Config_Call) RunAndReturn(run func() *config.ScraperSettings) *MockScraper_Config_Call

type MockScraper_Expecter 

type MockScraper_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockScraper_Expecter) Close 

func (_e *MockScraper_Expecter) Close() *MockScraper_Close_Call

Close is a helper method to define mock.On call

func (*MockScraper_Expecter) Config 

func (_e *MockScraper_Expecter) Config() *MockScraper_Config_Call

Config is a helper method to define mock.On call

func (*MockScraper_Expecter) GetURL 

func (_e *MockScraper_Expecter) GetURL(id interface{}) *MockScraper_GetURL_Call

GetURL is a helper method to define mock.On call

  • id string

func (*MockScraper_Expecter) IsEnabled 

func (_e *MockScraper_Expecter) IsEnabled() *MockScraper_IsEnabled_Call

IsEnabled is a helper method to define mock.On call

func (*MockScraper_Expecter) Name 

func (_e *MockScraper_Expecter) Name() *MockScraper_Name_Call

Name is a helper method to define mock.On call

func (*MockScraper_Expecter) Search 

func (_e *MockScraper_Expecter) Search(ctx interface{}, id interface{}) *MockScraper_Search_Call

Search is a helper method to define mock.On call

  • ctx context.Context
  • id string

type MockScraper_GetURL_Call 

type MockScraper_GetURL_Call struct {
	*mock.Call
}

MockScraper_GetURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetURL'

func (*MockScraper_GetURL_Call) Return 

func (_c *MockScraper_GetURL_Call) Return(s string, err error) *MockScraper_GetURL_Call

func (*MockScraper_GetURL_Call) Run 

func (_c *MockScraper_GetURL_Call) Run(run func(id string)) *MockScraper_GetURL_Call

func (*MockScraper_GetURL_Call) RunAndReturn 

func (_c *MockScraper_GetURL_Call) RunAndReturn(run func(id string) (string, error)) *MockScraper_GetURL_Call

type MockScraper_IsEnabled_Call 

type MockScraper_IsEnabled_Call struct {
	*mock.Call
}

MockScraper_IsEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsEnabled'

func (*MockScraper_IsEnabled_Call) Return 

func (_c *MockScraper_IsEnabled_Call) Return(b bool) *MockScraper_IsEnabled_Call

func (*MockScraper_IsEnabled_Call) Run 

func (_c *MockScraper_IsEnabled_Call) Run(run func()) *MockScraper_IsEnabled_Call

func (*MockScraper_IsEnabled_Call) RunAndReturn 

func (_c *MockScraper_IsEnabled_Call) RunAndReturn(run func() bool) *MockScraper_IsEnabled_Call

type MockScraper_Name_Call 

type MockScraper_Name_Call struct {
	*mock.Call
}

MockScraper_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'

func (*MockScraper_Name_Call) Return 

func (_c *MockScraper_Name_Call) Return(s string) *MockScraper_Name_Call

func (*MockScraper_Name_Call) Run 

func (_c *MockScraper_Name_Call) Run(run func()) *MockScraper_Name_Call

func (*MockScraper_Name_Call) RunAndReturn 

func (_c *MockScraper_Name_Call) RunAndReturn(run func() string) *MockScraper_Name_Call

type MockScraper_Search_Call 

type MockScraper_Search_Call struct {
	*mock.Call
}

MockScraper_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'

func (*MockScraper_Search_Call) Return 

func (_c *MockScraper_Search_Call) Return(scraperResult *models.ScraperResult, err error) *MockScraper_Search_Call

func (*MockScraper_Search_Call) Run 

func (_c *MockScraper_Search_Call) Run(run func(ctx context.Context, id string)) *MockScraper_Search_Call

func (*MockScraper_Search_Call) RunAndReturn 

func (_c *MockScraper_Search_Call) RunAndReturn(run func(ctx context.Context, id string) (*models.ScraperResult, error)) *MockScraper_Search_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.