mocks

Documentation

Index

• type EventSerializer
  • func NewEventSerializer(t interface{ ... }) *EventSerializer
  • func (_m *EventSerializer) ContentType() string
  • func (_m *EventSerializer) Deserialize(data []byte, eventType string, contentType string) (interface{}, error)
  • func (_m *EventSerializer) DeserializeEvent(data []byte, eventType string, contentType string) (interface{}, error)
  • func (_m *EventSerializer) DeserializeMessage(data []byte, eventType string, contentType string) (interface{}, error)
  • func (_m *EventSerializer) DeserializeType(data []byte, eventType reflect.Type, contentType string) (interface{}, error)
  • func (_m *EventSerializer) EXPECT() *EventSerializer_Expecter
  • func (_m *EventSerializer) Serialize(event interface{}) (*serializer.EventSerializationResult, error)
  • func (_m *EventSerializer) Serializer() serializer.Serializer
• type EventSerializer_ContentType_Call
  • func (_c *EventSerializer_ContentType_Call) Return(_a0 string) *EventSerializer_ContentType_Call
  • func (_c *EventSerializer_ContentType_Call) Run(run func()) *EventSerializer_ContentType_Call
  • func (_c *EventSerializer_ContentType_Call) RunAndReturn(run func() string) *EventSerializer_ContentType_Call
• type EventSerializer_DeserializeEvent_Call
  • func (_c *EventSerializer_DeserializeEvent_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_DeserializeEvent_Call
  • func (_c *EventSerializer_DeserializeEvent_Call) Run(run func(data []byte, eventType string, contentType string)) *EventSerializer_DeserializeEvent_Call
  • func (_c *EventSerializer_DeserializeEvent_Call) RunAndReturn(run func([]byte, string, string) (interface{}, error)) *EventSerializer_DeserializeEvent_Call
• type EventSerializer_DeserializeMessage_Call
  • func (_c *EventSerializer_DeserializeMessage_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_DeserializeMessage_Call
  • func (_c *EventSerializer_DeserializeMessage_Call) Run(run func(data []byte, eventType string, contentType string)) *EventSerializer_DeserializeMessage_Call
  • func (_c *EventSerializer_DeserializeMessage_Call) RunAndReturn(run func([]byte, string, string) (interface{}, error)) *EventSerializer_DeserializeMessage_Call
• type EventSerializer_DeserializeType_Call
  • func (_c *EventSerializer_DeserializeType_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_DeserializeType_Call
  • func (_c *EventSerializer_DeserializeType_Call) Run(run func(data []byte, eventType reflect.Type, contentType string)) *EventSerializer_DeserializeType_Call
  • func (_c *EventSerializer_DeserializeType_Call) RunAndReturn(run func([]byte, reflect.Type, string) (interface{}, error)) *EventSerializer_DeserializeType_Call
• type EventSerializer_Deserialize_Call
  • func (_c *EventSerializer_Deserialize_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_Deserialize_Call
  • func (_c *EventSerializer_Deserialize_Call) Run(run func(data []byte, eventType string, contentType string)) *EventSerializer_Deserialize_Call
  • func (_c *EventSerializer_Deserialize_Call) RunAndReturn(run func([]byte, string, string) (interface{}, error)) *EventSerializer_Deserialize_Call
• type EventSerializer_Expecter
  • func (_e *EventSerializer_Expecter) ContentType() *EventSerializer_ContentType_Call
  • func (_e *EventSerializer_Expecter) Deserialize(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_Deserialize_Call
  • func (_e *EventSerializer_Expecter) DeserializeEvent(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_DeserializeEvent_Call
  • func (_e *EventSerializer_Expecter) DeserializeMessage(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_DeserializeMessage_Call
  • func (_e *EventSerializer_Expecter) DeserializeType(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_DeserializeType_Call
  • func (_e *EventSerializer_Expecter) Serialize(event interface{}) *EventSerializer_Serialize_Call
  • func (_e *EventSerializer_Expecter) Serializer() *EventSerializer_Serializer_Call
• type EventSerializer_Serialize_Call
  • func (_c *EventSerializer_Serialize_Call) Return(_a0 *serializer.EventSerializationResult, _a1 error) *EventSerializer_Serialize_Call
  • func (_c *EventSerializer_Serialize_Call) Run(run func(event interface{})) *EventSerializer_Serialize_Call
  • func (_c *EventSerializer_Serialize_Call) RunAndReturn(run func(interface{}) (*serializer.EventSerializationResult, error)) *EventSerializer_Serialize_Call
• type EventSerializer_Serializer_Call
  • func (_c *EventSerializer_Serializer_Call) Return(_a0 serializer.Serializer) *EventSerializer_Serializer_Call
  • func (_c *EventSerializer_Serializer_Call) Run(run func()) *EventSerializer_Serializer_Call
  • func (_c *EventSerializer_Serializer_Call) RunAndReturn(run func() serializer.Serializer) *EventSerializer_Serializer_Call
• type GenericRepository
  • func NewGenericRepository[TEntity interface{}](t interface{ ... }) *GenericRepository[TEntity]
  • func (_m *GenericRepository[TEntity]) Add(ctx context.Context, entity TEntity) error
  • func (_m *GenericRepository[TEntity]) AddAll(ctx context.Context, entities []TEntity) error
  • func (_m *GenericRepository[TEntity]) Count(ctx context.Context) int64
  • func (_m *GenericRepository[TEntity]) Delete(ctx context.Context, id uuid.UUID) error
  • func (_m *GenericRepository[TEntity]) EXPECT() *GenericRepository_Expecter[TEntity]
  • func (_m *GenericRepository[TEntity]) Find(ctx context.Context, _a1 specification.Specification) ([]TEntity, error)
  • func (_m *GenericRepository[TEntity]) FirstOrDefault(ctx context.Context, filters map[string]interface{}) (TEntity, error)
  • func (_m *GenericRepository[TEntity]) GetAll(ctx context.Context, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)
  • func (_m *GenericRepository[TEntity]) GetByFilter(ctx context.Context, filters map[string]interface{}) ([]TEntity, error)
  • func (_m *GenericRepository[TEntity]) GetByFuncFilter(ctx context.Context, filterFunc func(TEntity) bool) ([]TEntity, error)
  • func (_m *GenericRepository[TEntity]) GetById(ctx context.Context, id uuid.UUID) (TEntity, error)
  • func (_m *GenericRepository[TEntity]) Search(ctx context.Context, searchTerm string, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)
  • func (_m *GenericRepository[TEntity]) SkipTake(ctx context.Context, skip int, take int) ([]TEntity, error)
  • func (_m *GenericRepository[TEntity]) Update(ctx context.Context, entity TEntity) error
  • func (_m *GenericRepository[TEntity]) UpdateAll(ctx context.Context, entities []TEntity) error
• type GenericRepositoryWithDataModel
  • func NewGenericRepositoryWithDataModel[TDataModel interface{}, TEntity interface{}](t interface{ ... }) *GenericRepositoryWithDataModel[TDataModel, TEntity]
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Add(ctx context.Context, entity TEntity) error
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) AddAll(ctx context.Context, entities []TEntity) error
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Count(ctx context.Context) int64
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Delete(ctx context.Context, id uuid.UUID) error
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) EXPECT() *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Find(ctx context.Context, _a1 specification.Specification) ([]TEntity, error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) FirstOrDefault(ctx context.Context, filters map[string]interface{}) (TEntity, error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetAll(ctx context.Context, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetByFilter(ctx context.Context, filters map[string]interface{}) ([]TEntity, error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetByFuncFilter(ctx context.Context, filterFunc func(TEntity) bool) ([]TEntity, error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetById(ctx context.Context, id uuid.UUID) (TEntity, error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Search(ctx context.Context, searchTerm string, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) SkipTake(ctx context.Context, skip int, take int) ([]TEntity, error)
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Update(ctx context.Context, entity TEntity) error
  • func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) UpdateAll(ctx context.Context, entities []TEntity) error
• type GenericRepositoryWithDataModel_AddAll_Call
  • func (_c *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Add_Call
  • func (_c *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Count_Call
  • func (_c *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) Return(_a0 int64) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) Run(run func(ctx context.Context)) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context) int64) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Delete_Call
  • func (_c *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) error) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Expecter
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Add(ctx interface{}, entity interface{}) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) AddAll(ctx interface{}, entities interface{}) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Count(ctx interface{}) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Delete(ctx interface{}, id interface{}) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Find(ctx interface{}, _a1 interface{}) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) FirstOrDefault(ctx interface{}, filters interface{}) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetAll(ctx interface{}, listQuery interface{}) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetByFilter(ctx interface{}, filters interface{}) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetByFuncFilter(ctx interface{}, filterFunc interface{}) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetById(ctx interface{}, id interface{}) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Search(ctx interface{}, searchTerm interface{}, listQuery interface{}) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) SkipTake(ctx interface{}, skip interface{}, take interface{}) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Update(ctx interface{}, entity interface{}) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]
  • func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) UpdateAll(ctx interface{}, entities interface{}) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Find_Call
  • func (_c *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, _a1 specification.Specification)) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, specification.Specification) ([]TEntity, error)) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_FirstOrDefault_Call
  • func (_c *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) (TEntity, error)) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_GetAll_Call
  • func (_c *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, listQuery *utils.ListQuery)) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) RunAndReturn(...) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_GetByFilter_Call
  • func (_c *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) ([]TEntity, error)) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_GetByFuncFilter_Call
  • func (_c *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, filterFunc func(TEntity) bool)) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, func(TEntity) bool) ([]TEntity, error)) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_GetById_Call
  • func (_c *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) (TEntity, error)) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Search_Call
  • func (_c *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, searchTerm string, listQuery *utils.ListQuery)) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) RunAndReturn(...) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_SkipTake_Call
  • func (_c *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, skip int, take int)) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, int, int) ([]TEntity, error)) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_UpdateAll_Call
  • func (_c *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]
• type GenericRepositoryWithDataModel_Update_Call
  • func (_c *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]
  • func (_c *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]
• type GenericRepository_AddAll_Call
  • func (_c *GenericRepository_AddAll_Call[TEntity]) Return(_a0 error) *GenericRepository_AddAll_Call[TEntity]
  • func (_c *GenericRepository_AddAll_Call[TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepository_AddAll_Call[TEntity]
  • func (_c *GenericRepository_AddAll_Call[TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepository_AddAll_Call[TEntity]
• type GenericRepository_Add_Call
  • func (_c *GenericRepository_Add_Call[TEntity]) Return(_a0 error) *GenericRepository_Add_Call[TEntity]
  • func (_c *GenericRepository_Add_Call[TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepository_Add_Call[TEntity]
  • func (_c *GenericRepository_Add_Call[TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepository_Add_Call[TEntity]
• type GenericRepository_Count_Call
  • func (_c *GenericRepository_Count_Call[TEntity]) Return(_a0 int64) *GenericRepository_Count_Call[TEntity]
  • func (_c *GenericRepository_Count_Call[TEntity]) Run(run func(ctx context.Context)) *GenericRepository_Count_Call[TEntity]
  • func (_c *GenericRepository_Count_Call[TEntity]) RunAndReturn(run func(context.Context) int64) *GenericRepository_Count_Call[TEntity]
• type GenericRepository_Delete_Call
  • func (_c *GenericRepository_Delete_Call[TEntity]) Return(_a0 error) *GenericRepository_Delete_Call[TEntity]
  • func (_c *GenericRepository_Delete_Call[TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepository_Delete_Call[TEntity]
  • func (_c *GenericRepository_Delete_Call[TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) error) *GenericRepository_Delete_Call[TEntity]
• type GenericRepository_Expecter
  • func (_e *GenericRepository_Expecter[TEntity]) Add(ctx interface{}, entity interface{}) *GenericRepository_Add_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) AddAll(ctx interface{}, entities interface{}) *GenericRepository_AddAll_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) Count(ctx interface{}) *GenericRepository_Count_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) Delete(ctx interface{}, id interface{}) *GenericRepository_Delete_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) Find(ctx interface{}, _a1 interface{}) *GenericRepository_Find_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) FirstOrDefault(ctx interface{}, filters interface{}) *GenericRepository_FirstOrDefault_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) GetAll(ctx interface{}, listQuery interface{}) *GenericRepository_GetAll_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) GetByFilter(ctx interface{}, filters interface{}) *GenericRepository_GetByFilter_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) GetByFuncFilter(ctx interface{}, filterFunc interface{}) *GenericRepository_GetByFuncFilter_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) GetById(ctx interface{}, id interface{}) *GenericRepository_GetById_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) Search(ctx interface{}, searchTerm interface{}, listQuery interface{}) *GenericRepository_Search_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) SkipTake(ctx interface{}, skip interface{}, take interface{}) *GenericRepository_SkipTake_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) Update(ctx interface{}, entity interface{}) *GenericRepository_Update_Call[TEntity]
  • func (_e *GenericRepository_Expecter[TEntity]) UpdateAll(ctx interface{}, entities interface{}) *GenericRepository_UpdateAll_Call[TEntity]
• type GenericRepository_Find_Call
  • func (_c *GenericRepository_Find_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_Find_Call[TEntity]
  • func (_c *GenericRepository_Find_Call[TEntity]) Run(run func(ctx context.Context, _a1 specification.Specification)) *GenericRepository_Find_Call[TEntity]
  • func (_c *GenericRepository_Find_Call[TEntity]) RunAndReturn(run func(context.Context, specification.Specification) ([]TEntity, error)) *GenericRepository_Find_Call[TEntity]
• type GenericRepository_FirstOrDefault_Call
  • func (_c *GenericRepository_FirstOrDefault_Call[TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepository_FirstOrDefault_Call[TEntity]
  • func (_c *GenericRepository_FirstOrDefault_Call[TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepository_FirstOrDefault_Call[TEntity]
  • func (_c *GenericRepository_FirstOrDefault_Call[TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) (TEntity, error)) *GenericRepository_FirstOrDefault_Call[TEntity]
• type GenericRepository_GetAll_Call
  • func (_c *GenericRepository_GetAll_Call[TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepository_GetAll_Call[TEntity]
  • func (_c *GenericRepository_GetAll_Call[TEntity]) Run(run func(ctx context.Context, listQuery *utils.ListQuery)) *GenericRepository_GetAll_Call[TEntity]
  • func (_c *GenericRepository_GetAll_Call[TEntity]) RunAndReturn(...) *GenericRepository_GetAll_Call[TEntity]
• type GenericRepository_GetByFilter_Call
  • func (_c *GenericRepository_GetByFilter_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_GetByFilter_Call[TEntity]
  • func (_c *GenericRepository_GetByFilter_Call[TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepository_GetByFilter_Call[TEntity]
  • func (_c *GenericRepository_GetByFilter_Call[TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) ([]TEntity, error)) *GenericRepository_GetByFilter_Call[TEntity]
• type GenericRepository_GetByFuncFilter_Call
  • func (_c *GenericRepository_GetByFuncFilter_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_GetByFuncFilter_Call[TEntity]
  • func (_c *GenericRepository_GetByFuncFilter_Call[TEntity]) Run(run func(ctx context.Context, filterFunc func(TEntity) bool)) *GenericRepository_GetByFuncFilter_Call[TEntity]
  • func (_c *GenericRepository_GetByFuncFilter_Call[TEntity]) RunAndReturn(run func(context.Context, func(TEntity) bool) ([]TEntity, error)) *GenericRepository_GetByFuncFilter_Call[TEntity]
• type GenericRepository_GetById_Call
  • func (_c *GenericRepository_GetById_Call[TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepository_GetById_Call[TEntity]
  • func (_c *GenericRepository_GetById_Call[TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepository_GetById_Call[TEntity]
  • func (_c *GenericRepository_GetById_Call[TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) (TEntity, error)) *GenericRepository_GetById_Call[TEntity]
• type GenericRepository_Search_Call
  • func (_c *GenericRepository_Search_Call[TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepository_Search_Call[TEntity]
  • func (_c *GenericRepository_Search_Call[TEntity]) Run(run func(ctx context.Context, searchTerm string, listQuery *utils.ListQuery)) *GenericRepository_Search_Call[TEntity]
  • func (_c *GenericRepository_Search_Call[TEntity]) RunAndReturn(...) *GenericRepository_Search_Call[TEntity]
• type GenericRepository_SkipTake_Call
  • func (_c *GenericRepository_SkipTake_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_SkipTake_Call[TEntity]
  • func (_c *GenericRepository_SkipTake_Call[TEntity]) Run(run func(ctx context.Context, skip int, take int)) *GenericRepository_SkipTake_Call[TEntity]
  • func (_c *GenericRepository_SkipTake_Call[TEntity]) RunAndReturn(run func(context.Context, int, int) ([]TEntity, error)) *GenericRepository_SkipTake_Call[TEntity]
• type GenericRepository_UpdateAll_Call
  • func (_c *GenericRepository_UpdateAll_Call[TEntity]) Return(_a0 error) *GenericRepository_UpdateAll_Call[TEntity]
  • func (_c *GenericRepository_UpdateAll_Call[TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepository_UpdateAll_Call[TEntity]
  • func (_c *GenericRepository_UpdateAll_Call[TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepository_UpdateAll_Call[TEntity]
• type GenericRepository_Update_Call
  • func (_c *GenericRepository_Update_Call[TEntity]) Return(_a0 error) *GenericRepository_Update_Call[TEntity]
  • func (_c *GenericRepository_Update_Call[TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepository_Update_Call[TEntity]
  • func (_c *GenericRepository_Update_Call[TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepository_Update_Call[TEntity]
• type IAggregateRoot
  • func NewIAggregateRoot(t interface{ ... }) *IAggregateRoot
  • func (_m *IAggregateRoot) AddDomainEvents(event domain.IDomainEvent) error
  • func (_m *IAggregateRoot) CreatedAt() time.Time
  • func (_m *IAggregateRoot) EXPECT() *IAggregateRoot_Expecter
  • func (_m *IAggregateRoot) GetUncommittedEvents() []domain.IDomainEvent
  • func (_m *IAggregateRoot) HasUncommittedEvents() bool
  • func (_m *IAggregateRoot) Id() uuid.UUID
  • func (_m *IAggregateRoot) MarkUncommittedEventAsCommitted()
  • func (_m *IAggregateRoot) OriginalVersion() int64
  • func (_m *IAggregateRoot) SetEntityType(entityType string)
  • func (_m *IAggregateRoot) SetId(id uuid.UUID)
  • func (_m *IAggregateRoot) SetUpdatedAt(updatedAt time.Time)
  • func (_m *IAggregateRoot) String() string
  • func (_m *IAggregateRoot) UpdatedAt() time.Time
• type IAggregateRoot_AddDomainEvents_Call
  • func (_c *IAggregateRoot_AddDomainEvents_Call) Return(_a0 error) *IAggregateRoot_AddDomainEvents_Call
  • func (_c *IAggregateRoot_AddDomainEvents_Call) Run(run func(event domain.IDomainEvent)) *IAggregateRoot_AddDomainEvents_Call
  • func (_c *IAggregateRoot_AddDomainEvents_Call) RunAndReturn(run func(domain.IDomainEvent) error) *IAggregateRoot_AddDomainEvents_Call
• type IAggregateRoot_CreatedAt_Call
  • func (_c *IAggregateRoot_CreatedAt_Call) Return(_a0 time.Time) *IAggregateRoot_CreatedAt_Call
  • func (_c *IAggregateRoot_CreatedAt_Call) Run(run func()) *IAggregateRoot_CreatedAt_Call
  • func (_c *IAggregateRoot_CreatedAt_Call) RunAndReturn(run func() time.Time) *IAggregateRoot_CreatedAt_Call
• type IAggregateRoot_Expecter
  • func (_e *IAggregateRoot_Expecter) AddDomainEvents(event interface{}) *IAggregateRoot_AddDomainEvents_Call
  • func (_e *IAggregateRoot_Expecter) CreatedAt() *IAggregateRoot_CreatedAt_Call
  • func (_e *IAggregateRoot_Expecter) GetUncommittedEvents() *IAggregateRoot_GetUncommittedEvents_Call
  • func (_e *IAggregateRoot_Expecter) HasUncommittedEvents() *IAggregateRoot_HasUncommittedEvents_Call
  • func (_e *IAggregateRoot_Expecter) Id() *IAggregateRoot_Id_Call
  • func (_e *IAggregateRoot_Expecter) MarkUncommittedEventAsCommitted() *IAggregateRoot_MarkUncommittedEventAsCommitted_Call
  • func (_e *IAggregateRoot_Expecter) OriginalVersion() *IAggregateRoot_OriginalVersion_Call
  • func (_e *IAggregateRoot_Expecter) SetEntityType(entityType interface{}) *IAggregateRoot_SetEntityType_Call
  • func (_e *IAggregateRoot_Expecter) SetId(id interface{}) *IAggregateRoot_SetId_Call
  • func (_e *IAggregateRoot_Expecter) SetUpdatedAt(updatedAt interface{}) *IAggregateRoot_SetUpdatedAt_Call
  • func (_e *IAggregateRoot_Expecter) String() *IAggregateRoot_String_Call
  • func (_e *IAggregateRoot_Expecter) UpdatedAt() *IAggregateRoot_UpdatedAt_Call
• type IAggregateRoot_GetUncommittedEvents_Call
  • func (_c *IAggregateRoot_GetUncommittedEvents_Call) Return(_a0 []domain.IDomainEvent) *IAggregateRoot_GetUncommittedEvents_Call
  • func (_c *IAggregateRoot_GetUncommittedEvents_Call) Run(run func()) *IAggregateRoot_GetUncommittedEvents_Call
  • func (_c *IAggregateRoot_GetUncommittedEvents_Call) RunAndReturn(run func() []domain.IDomainEvent) *IAggregateRoot_GetUncommittedEvents_Call
• type IAggregateRoot_HasUncommittedEvents_Call
  • func (_c *IAggregateRoot_HasUncommittedEvents_Call) Return(_a0 bool) *IAggregateRoot_HasUncommittedEvents_Call
  • func (_c *IAggregateRoot_HasUncommittedEvents_Call) Run(run func()) *IAggregateRoot_HasUncommittedEvents_Call
  • func (_c *IAggregateRoot_HasUncommittedEvents_Call) RunAndReturn(run func() bool) *IAggregateRoot_HasUncommittedEvents_Call
• type IAggregateRoot_Id_Call
  • func (_c *IAggregateRoot_Id_Call) Return(_a0 uuid.UUID) *IAggregateRoot_Id_Call
  • func (_c *IAggregateRoot_Id_Call) Run(run func()) *IAggregateRoot_Id_Call
  • func (_c *IAggregateRoot_Id_Call) RunAndReturn(run func() uuid.UUID) *IAggregateRoot_Id_Call
• type IAggregateRoot_MarkUncommittedEventAsCommitted_Call
  • func (_c *IAggregateRoot_MarkUncommittedEventAsCommitted_Call) Return() *IAggregateRoot_MarkUncommittedEventAsCommitted_Call
  • func (_c *IAggregateRoot_MarkUncommittedEventAsCommitted_Call) Run(run func()) *IAggregateRoot_MarkUncommittedEventAsCommitted_Call
  • func (_c *IAggregateRoot_MarkUncommittedEventAsCommitted_Call) RunAndReturn(run func()) *IAggregateRoot_MarkUncommittedEventAsCommitted_Call
• type IAggregateRoot_OriginalVersion_Call
  • func (_c *IAggregateRoot_OriginalVersion_Call) Return(_a0 int64) *IAggregateRoot_OriginalVersion_Call
  • func (_c *IAggregateRoot_OriginalVersion_Call) Run(run func()) *IAggregateRoot_OriginalVersion_Call
  • func (_c *IAggregateRoot_OriginalVersion_Call) RunAndReturn(run func() int64) *IAggregateRoot_OriginalVersion_Call
• type IAggregateRoot_SetEntityType_Call
  • func (_c *IAggregateRoot_SetEntityType_Call) Return() *IAggregateRoot_SetEntityType_Call
  • func (_c *IAggregateRoot_SetEntityType_Call) Run(run func(entityType string)) *IAggregateRoot_SetEntityType_Call
  • func (_c *IAggregateRoot_SetEntityType_Call) RunAndReturn(run func(string)) *IAggregateRoot_SetEntityType_Call
• type IAggregateRoot_SetId_Call
  • func (_c *IAggregateRoot_SetId_Call) Return() *IAggregateRoot_SetId_Call
  • func (_c *IAggregateRoot_SetId_Call) Run(run func(id uuid.UUID)) *IAggregateRoot_SetId_Call
  • func (_c *IAggregateRoot_SetId_Call) RunAndReturn(run func(uuid.UUID)) *IAggregateRoot_SetId_Call
• type IAggregateRoot_SetUpdatedAt_Call
  • func (_c *IAggregateRoot_SetUpdatedAt_Call) Return() *IAggregateRoot_SetUpdatedAt_Call
  • func (_c *IAggregateRoot_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IAggregateRoot_SetUpdatedAt_Call
  • func (_c *IAggregateRoot_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IAggregateRoot_SetUpdatedAt_Call
• type IAggregateRoot_String_Call
  • func (_c *IAggregateRoot_String_Call) Return(_a0 string) *IAggregateRoot_String_Call
  • func (_c *IAggregateRoot_String_Call) Run(run func()) *IAggregateRoot_String_Call
  • func (_c *IAggregateRoot_String_Call) RunAndReturn(run func() string) *IAggregateRoot_String_Call
• type IAggregateRoot_UpdatedAt_Call
  • func (_c *IAggregateRoot_UpdatedAt_Call) Return(_a0 time.Time) *IAggregateRoot_UpdatedAt_Call
  • func (_c *IAggregateRoot_UpdatedAt_Call) Run(run func()) *IAggregateRoot_UpdatedAt_Call
  • func (_c *IAggregateRoot_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IAggregateRoot_UpdatedAt_Call
• type IDomainEvent
  • func NewIDomainEvent(t interface{ ... }) *IDomainEvent
  • func (_m *IDomainEvent) EXPECT() *IDomainEvent_Expecter
  • func (_m *IDomainEvent) GetAggregateId() uuid.UUID
  • func (_m *IDomainEvent) GetAggregateSequenceNumber() int64
  • func (_m *IDomainEvent) GetEventId() uuid.UUID
  • func (_m *IDomainEvent) GetEventType() string
  • func (_m *IDomainEvent) GetOccurredOn() time.Time
  • func (_m *IDomainEvent) WithAggregate(aggregateId uuid.UUID, aggregateSequenceNumber int64) *domain.DomainEvent
• type IDomainEvent_Expecter
  • func (_e *IDomainEvent_Expecter) GetAggregateId() *IDomainEvent_GetAggregateId_Call
  • func (_e *IDomainEvent_Expecter) GetAggregateSequenceNumber() *IDomainEvent_GetAggregateSequenceNumber_Call
  • func (_e *IDomainEvent_Expecter) GetEventId() *IDomainEvent_GetEventId_Call
  • func (_e *IDomainEvent_Expecter) GetEventType() *IDomainEvent_GetEventType_Call
  • func (_e *IDomainEvent_Expecter) GetOccurredOn() *IDomainEvent_GetOccurredOn_Call
  • func (_e *IDomainEvent_Expecter) WithAggregate(aggregateId interface{}, aggregateSequenceNumber interface{}) *IDomainEvent_WithAggregate_Call
• type IDomainEvent_GetAggregateId_Call
  • func (_c *IDomainEvent_GetAggregateId_Call) Return(_a0 uuid.UUID) *IDomainEvent_GetAggregateId_Call
  • func (_c *IDomainEvent_GetAggregateId_Call) Run(run func()) *IDomainEvent_GetAggregateId_Call
  • func (_c *IDomainEvent_GetAggregateId_Call) RunAndReturn(run func() uuid.UUID) *IDomainEvent_GetAggregateId_Call
• type IDomainEvent_GetAggregateSequenceNumber_Call
  • func (_c *IDomainEvent_GetAggregateSequenceNumber_Call) Return(_a0 int64) *IDomainEvent_GetAggregateSequenceNumber_Call
  • func (_c *IDomainEvent_GetAggregateSequenceNumber_Call) Run(run func()) *IDomainEvent_GetAggregateSequenceNumber_Call
  • func (_c *IDomainEvent_GetAggregateSequenceNumber_Call) RunAndReturn(run func() int64) *IDomainEvent_GetAggregateSequenceNumber_Call
• type IDomainEvent_GetEventId_Call
  • func (_c *IDomainEvent_GetEventId_Call) Return(_a0 uuid.UUID) *IDomainEvent_GetEventId_Call
  • func (_c *IDomainEvent_GetEventId_Call) Run(run func()) *IDomainEvent_GetEventId_Call
  • func (_c *IDomainEvent_GetEventId_Call) RunAndReturn(run func() uuid.UUID) *IDomainEvent_GetEventId_Call
• type IDomainEvent_GetEventType_Call
  • func (_c *IDomainEvent_GetEventType_Call) Return(_a0 string) *IDomainEvent_GetEventType_Call
  • func (_c *IDomainEvent_GetEventType_Call) Run(run func()) *IDomainEvent_GetEventType_Call
  • func (_c *IDomainEvent_GetEventType_Call) RunAndReturn(run func() string) *IDomainEvent_GetEventType_Call
• type IDomainEvent_GetOccurredOn_Call
  • func (_c *IDomainEvent_GetOccurredOn_Call) Return(_a0 time.Time) *IDomainEvent_GetOccurredOn_Call
  • func (_c *IDomainEvent_GetOccurredOn_Call) Run(run func()) *IDomainEvent_GetOccurredOn_Call
  • func (_c *IDomainEvent_GetOccurredOn_Call) RunAndReturn(run func() time.Time) *IDomainEvent_GetOccurredOn_Call
• type IDomainEvent_WithAggregate_Call
  • func (_c *IDomainEvent_WithAggregate_Call) Return(_a0 *domain.DomainEvent) *IDomainEvent_WithAggregate_Call
  • func (_c *IDomainEvent_WithAggregate_Call) Run(run func(aggregateId uuid.UUID, aggregateSequenceNumber int64)) *IDomainEvent_WithAggregate_Call
  • func (_c *IDomainEvent_WithAggregate_Call) RunAndReturn(run func(uuid.UUID, int64) *domain.DomainEvent) *IDomainEvent_WithAggregate_Call
• type IEntity
  • func NewIEntity(t interface{ ... }) *IEntity
  • func (_m *IEntity) CreatedAt() time.Time
  • func (_m *IEntity) EXPECT() *IEntity_Expecter
  • func (_m *IEntity) Id() uuid.UUID
  • func (_m *IEntity) SetEntityType(entityType string)
  • func (_m *IEntity) SetId(id uuid.UUID)
  • func (_m *IEntity) SetUpdatedAt(updatedAt time.Time)
  • func (_m *IEntity) UpdatedAt() time.Time
• type IEntity_CreatedAt_Call
  • func (_c *IEntity_CreatedAt_Call) Return(_a0 time.Time) *IEntity_CreatedAt_Call
  • func (_c *IEntity_CreatedAt_Call) Run(run func()) *IEntity_CreatedAt_Call
  • func (_c *IEntity_CreatedAt_Call) RunAndReturn(run func() time.Time) *IEntity_CreatedAt_Call
• type IEntity_Expecter
  • func (_e *IEntity_Expecter) CreatedAt() *IEntity_CreatedAt_Call
  • func (_e *IEntity_Expecter) Id() *IEntity_Id_Call
  • func (_e *IEntity_Expecter) SetEntityType(entityType interface{}) *IEntity_SetEntityType_Call
  • func (_e *IEntity_Expecter) SetId(id interface{}) *IEntity_SetId_Call
  • func (_e *IEntity_Expecter) SetUpdatedAt(updatedAt interface{}) *IEntity_SetUpdatedAt_Call
  • func (_e *IEntity_Expecter) UpdatedAt() *IEntity_UpdatedAt_Call
• type IEntity_Id_Call
  • func (_c *IEntity_Id_Call) Return(_a0 uuid.UUID) *IEntity_Id_Call
  • func (_c *IEntity_Id_Call) Run(run func()) *IEntity_Id_Call
  • func (_c *IEntity_Id_Call) RunAndReturn(run func() uuid.UUID) *IEntity_Id_Call
• type IEntity_SetEntityType_Call
  • func (_c *IEntity_SetEntityType_Call) Return() *IEntity_SetEntityType_Call
  • func (_c *IEntity_SetEntityType_Call) Run(run func(entityType string)) *IEntity_SetEntityType_Call
  • func (_c *IEntity_SetEntityType_Call) RunAndReturn(run func(string)) *IEntity_SetEntityType_Call
• type IEntity_SetId_Call
  • func (_c *IEntity_SetId_Call) Return() *IEntity_SetId_Call
  • func (_c *IEntity_SetId_Call) Run(run func(id uuid.UUID)) *IEntity_SetId_Call
  • func (_c *IEntity_SetId_Call) RunAndReturn(run func(uuid.UUID)) *IEntity_SetId_Call
• type IEntity_SetUpdatedAt_Call
  • func (_c *IEntity_SetUpdatedAt_Call) Return() *IEntity_SetUpdatedAt_Call
  • func (_c *IEntity_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IEntity_SetUpdatedAt_Call
  • func (_c *IEntity_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IEntity_SetUpdatedAt_Call
• type IEntity_UpdatedAt_Call
  • func (_c *IEntity_UpdatedAt_Call) Return(_a0 time.Time) *IEntity_UpdatedAt_Call
  • func (_c *IEntity_UpdatedAt_Call) Run(run func()) *IEntity_UpdatedAt_Call
  • func (_c *IEntity_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IEntity_UpdatedAt_Call
• type IEvent
  • func NewIEvent(t interface{ ... }) *IEvent
  • func (_m *IEvent) EXPECT() *IEvent_Expecter
  • func (_m *IEvent) GetEventId() uuid.UUID
  • func (_m *IEvent) GetEventType() string
  • func (_m *IEvent) GetOccurredOn() time.Time
• type IEvent_Expecter
  • func (_e *IEvent_Expecter) GetEventId() *IEvent_GetEventId_Call
  • func (_e *IEvent_Expecter) GetEventType() *IEvent_GetEventType_Call
  • func (_e *IEvent_Expecter) GetOccurredOn() *IEvent_GetOccurredOn_Call
• type IEvent_GetEventId_Call
  • func (_c *IEvent_GetEventId_Call) Return(_a0 uuid.UUID) *IEvent_GetEventId_Call
  • func (_c *IEvent_GetEventId_Call) Run(run func()) *IEvent_GetEventId_Call
  • func (_c *IEvent_GetEventId_Call) RunAndReturn(run func() uuid.UUID) *IEvent_GetEventId_Call
• type IEvent_GetEventType_Call
  • func (_c *IEvent_GetEventType_Call) Return(_a0 string) *IEvent_GetEventType_Call
  • func (_c *IEvent_GetEventType_Call) Run(run func()) *IEvent_GetEventType_Call
  • func (_c *IEvent_GetEventType_Call) RunAndReturn(run func() string) *IEvent_GetEventType_Call
• type IEvent_GetOccurredOn_Call
  • func (_c *IEvent_GetOccurredOn_Call) Return(_a0 time.Time) *IEvent_GetOccurredOn_Call
  • func (_c *IEvent_GetOccurredOn_Call) Run(run func()) *IEvent_GetOccurredOn_Call
  • func (_c *IEvent_GetOccurredOn_Call) RunAndReturn(run func() time.Time) *IEvent_GetOccurredOn_Call
• type MetadataSerializer
  • func NewMetadataSerializer(t interface{ ... }) *MetadataSerializer
  • func (_m *MetadataSerializer) Deserialize(bytes []byte) (metadata.Metadata, error)
  • func (_m *MetadataSerializer) EXPECT() *MetadataSerializer_Expecter
  • func (_m *MetadataSerializer) Serialize(meta metadata.Metadata) ([]byte, error)
• type MetadataSerializer_Deserialize_Call
  • func (_c *MetadataSerializer_Deserialize_Call) Return(_a0 metadata.Metadata, _a1 error) *MetadataSerializer_Deserialize_Call
  • func (_c *MetadataSerializer_Deserialize_Call) Run(run func(bytes []byte)) *MetadataSerializer_Deserialize_Call
  • func (_c *MetadataSerializer_Deserialize_Call) RunAndReturn(run func([]byte) (metadata.Metadata, error)) *MetadataSerializer_Deserialize_Call
• type MetadataSerializer_Expecter
  • func (_e *MetadataSerializer_Expecter) Deserialize(bytes interface{}) *MetadataSerializer_Deserialize_Call
  • func (_e *MetadataSerializer_Expecter) Serialize(meta interface{}) *MetadataSerializer_Serialize_Call
• type MetadataSerializer_Serialize_Call
  • func (_c *MetadataSerializer_Serialize_Call) Return(_a0 []byte, _a1 error) *MetadataSerializer_Serialize_Call
  • func (_c *MetadataSerializer_Serialize_Call) Run(run func(meta metadata.Metadata)) *MetadataSerializer_Serialize_Call
  • func (_c *MetadataSerializer_Serialize_Call) RunAndReturn(run func(metadata.Metadata) ([]byte, error)) *MetadataSerializer_Serialize_Call
• type Serializer
  • func NewSerializer(t interface{ ... }) *Serializer
  • func (_m *Serializer) ColoredPrettyPrint(data interface{}) string
  • func (_m *Serializer) DecodeWithMapStructure(input interface{}, output interface{}) error
  • func (_m *Serializer) EXPECT() *Serializer_Expecter
  • func (_m *Serializer) Marshal(v interface{}) ([]byte, error)
  • func (_m *Serializer) PrettyPrint(data interface{}) string
  • func (_m *Serializer) Unmarshal(data []byte, v interface{}) error
  • func (_m *Serializer) UnmarshalFromJson(data string, v interface{}) error
  • func (_m *Serializer) UnmarshalToMap(data []byte, v *map[string]interface{}) error
  • func (_m *Serializer) UnmarshalToMapFromJson(data string, v *map[string]interface{}) error
• type Serializer_ColoredPrettyPrint_Call
  • func (_c *Serializer_ColoredPrettyPrint_Call) Return(_a0 string) *Serializer_ColoredPrettyPrint_Call
  • func (_c *Serializer_ColoredPrettyPrint_Call) Run(run func(data interface{})) *Serializer_ColoredPrettyPrint_Call
  • func (_c *Serializer_ColoredPrettyPrint_Call) RunAndReturn(run func(interface{}) string) *Serializer_ColoredPrettyPrint_Call
• type Serializer_DecodeWithMapStructure_Call
  • func (_c *Serializer_DecodeWithMapStructure_Call) Return(_a0 error) *Serializer_DecodeWithMapStructure_Call
  • func (_c *Serializer_DecodeWithMapStructure_Call) Run(run func(input interface{}, output interface{})) *Serializer_DecodeWithMapStructure_Call
  • func (_c *Serializer_DecodeWithMapStructure_Call) RunAndReturn(run func(interface{}, interface{}) error) *Serializer_DecodeWithMapStructure_Call
• type Serializer_Expecter
  • func (_e *Serializer_Expecter) ColoredPrettyPrint(data interface{}) *Serializer_ColoredPrettyPrint_Call
  • func (_e *Serializer_Expecter) DecodeWithMapStructure(input interface{}, output interface{}) *Serializer_DecodeWithMapStructure_Call
  • func (_e *Serializer_Expecter) Marshal(v interface{}) *Serializer_Marshal_Call
  • func (_e *Serializer_Expecter) PrettyPrint(data interface{}) *Serializer_PrettyPrint_Call
  • func (_e *Serializer_Expecter) Unmarshal(data interface{}, v interface{}) *Serializer_Unmarshal_Call
  • func (_e *Serializer_Expecter) UnmarshalFromJson(data interface{}, v interface{}) *Serializer_UnmarshalFromJson_Call
  • func (_e *Serializer_Expecter) UnmarshalToMap(data interface{}, v interface{}) *Serializer_UnmarshalToMap_Call
  • func (_e *Serializer_Expecter) UnmarshalToMapFromJson(data interface{}, v interface{}) *Serializer_UnmarshalToMapFromJson_Call
• type Serializer_Marshal_Call
  • func (_c *Serializer_Marshal_Call) Return(_a0 []byte, _a1 error) *Serializer_Marshal_Call
  • func (_c *Serializer_Marshal_Call) Run(run func(v interface{})) *Serializer_Marshal_Call
  • func (_c *Serializer_Marshal_Call) RunAndReturn(run func(interface{}) ([]byte, error)) *Serializer_Marshal_Call
• type Serializer_PrettyPrint_Call
  • func (_c *Serializer_PrettyPrint_Call) Return(_a0 string) *Serializer_PrettyPrint_Call
  • func (_c *Serializer_PrettyPrint_Call) Run(run func(data interface{})) *Serializer_PrettyPrint_Call
  • func (_c *Serializer_PrettyPrint_Call) RunAndReturn(run func(interface{}) string) *Serializer_PrettyPrint_Call
• type Serializer_UnmarshalFromJson_Call
  • func (_c *Serializer_UnmarshalFromJson_Call) Return(_a0 error) *Serializer_UnmarshalFromJson_Call
  • func (_c *Serializer_UnmarshalFromJson_Call) Run(run func(data string, v interface{})) *Serializer_UnmarshalFromJson_Call
  • func (_c *Serializer_UnmarshalFromJson_Call) RunAndReturn(run func(string, interface{}) error) *Serializer_UnmarshalFromJson_Call
• type Serializer_UnmarshalToMapFromJson_Call
  • func (_c *Serializer_UnmarshalToMapFromJson_Call) Return(_a0 error) *Serializer_UnmarshalToMapFromJson_Call
  • func (_c *Serializer_UnmarshalToMapFromJson_Call) Run(run func(data string, v *map[string]interface{})) *Serializer_UnmarshalToMapFromJson_Call
  • func (_c *Serializer_UnmarshalToMapFromJson_Call) RunAndReturn(run func(string, *map[string]interface{}) error) *Serializer_UnmarshalToMapFromJson_Call
• type Serializer_UnmarshalToMap_Call
  • func (_c *Serializer_UnmarshalToMap_Call) Return(_a0 error) *Serializer_UnmarshalToMap_Call
  • func (_c *Serializer_UnmarshalToMap_Call) Run(run func(data []byte, v *map[string]interface{})) *Serializer_UnmarshalToMap_Call
  • func (_c *Serializer_UnmarshalToMap_Call) RunAndReturn(run func([]byte, *map[string]interface{}) error) *Serializer_UnmarshalToMap_Call
• type Serializer_Unmarshal_Call
  • func (_c *Serializer_Unmarshal_Call) Return(_a0 error) *Serializer_Unmarshal_Call
  • func (_c *Serializer_Unmarshal_Call) Run(run func(data []byte, v interface{})) *Serializer_Unmarshal_Call
  • func (_c *Serializer_Unmarshal_Call) RunAndReturn(run func([]byte, interface{}) error) *Serializer_Unmarshal_Call
• type Specification
  • func NewSpecification(t interface{ ... }) *Specification
  • func (_m *Specification) EXPECT() *Specification_Expecter
  • func (_m *Specification) GetQuery() string
  • func (_m *Specification) GetValues() []interface{}
• type Specification_Expecter
  • func (_e *Specification_Expecter) GetQuery() *Specification_GetQuery_Call
  • func (_e *Specification_Expecter) GetValues() *Specification_GetValues_Call
• type Specification_GetQuery_Call
  • func (_c *Specification_GetQuery_Call) Return(_a0 string) *Specification_GetQuery_Call
  • func (_c *Specification_GetQuery_Call) Run(run func()) *Specification_GetQuery_Call
  • func (_c *Specification_GetQuery_Call) RunAndReturn(run func() string) *Specification_GetQuery_Call
• type Specification_GetValues_Call
  • func (_c *Specification_GetValues_Call) Return(_a0 []interface{}) *Specification_GetValues_Call
  • func (_c *Specification_GetValues_Call) Run(run func()) *Specification_GetValues_Call
  • func (_c *Specification_GetValues_Call) RunAndReturn(run func() []interface{}) *Specification_GetValues_Call

Types

type EventSerializer

type EventSerializer struct {
	mock.Mock
}

EventSerializer is an autogenerated mock type for the EventSerializer type

func NewEventSerializer

func NewEventSerializer(t interface {
	mock.TestingT
	Cleanup(func())
}) *EventSerializer

NewEventSerializer creates a new instance of EventSerializer. 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 (*EventSerializer) ContentType

func (_m *EventSerializer) ContentType() string

ContentType provides a mock function with given fields:

func (*EventSerializer) Deserialize

func (_m *EventSerializer) Deserialize(data []byte, eventType string, contentType string) (interface{}, error)

Deserialize provides a mock function with given fields: data, eventType, contentType

func (*EventSerializer) DeserializeEvent

func (_m *EventSerializer) DeserializeEvent(data []byte, eventType string, contentType string) (interface{}, error)

DeserializeEvent provides a mock function with given fields: data, eventType, contentType

func (*EventSerializer) DeserializeMessage

func (_m *EventSerializer) DeserializeMessage(data []byte, eventType string, contentType string) (interface{}, error)

DeserializeMessage provides a mock function with given fields: data, eventType, contentType

func (*EventSerializer) DeserializeType

func (_m *EventSerializer) DeserializeType(data []byte, eventType reflect.Type, contentType string) (interface{}, error)

DeserializeType provides a mock function with given fields: data, eventType, contentType

func (*EventSerializer) EXPECT

func (_m *EventSerializer) EXPECT() *EventSerializer_Expecter

func (*EventSerializer) Serialize

func (_m *EventSerializer) Serialize(event interface{}) (*serializer.EventSerializationResult, error)

Serialize provides a mock function with given fields: event

func (*EventSerializer) Serializer

func (_m *EventSerializer) Serializer() serializer.Serializer

Serializer provides a mock function with given fields:

type EventSerializer_ContentType_Call

type EventSerializer_ContentType_Call struct {
	*mock.Call
}

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

func (*EventSerializer_ContentType_Call) Return

func (_c *EventSerializer_ContentType_Call) Return(_a0 string) *EventSerializer_ContentType_Call

func (*EventSerializer_ContentType_Call) Run

func (_c *EventSerializer_ContentType_Call) Run(run func()) *EventSerializer_ContentType_Call

func (*EventSerializer_ContentType_Call) RunAndReturn

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

type EventSerializer_DeserializeEvent_Call

type EventSerializer_DeserializeEvent_Call struct {
	*mock.Call
}

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

func (*EventSerializer_DeserializeEvent_Call) Return

func (_c *EventSerializer_DeserializeEvent_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_DeserializeEvent_Call

func (*EventSerializer_DeserializeEvent_Call) Run

func (_c *EventSerializer_DeserializeEvent_Call) Run(run func(data []byte, eventType string, contentType string)) *EventSerializer_DeserializeEvent_Call

func (*EventSerializer_DeserializeEvent_Call) RunAndReturn

func (_c *EventSerializer_DeserializeEvent_Call) RunAndReturn(run func([]byte, string, string) (interface{}, error)) *EventSerializer_DeserializeEvent_Call

type EventSerializer_DeserializeMessage_Call

type EventSerializer_DeserializeMessage_Call struct {
	*mock.Call
}

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

func (*EventSerializer_DeserializeMessage_Call) Return

func (_c *EventSerializer_DeserializeMessage_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_DeserializeMessage_Call

func (*EventSerializer_DeserializeMessage_Call) Run

func (_c *EventSerializer_DeserializeMessage_Call) Run(run func(data []byte, eventType string, contentType string)) *EventSerializer_DeserializeMessage_Call

func (*EventSerializer_DeserializeMessage_Call) RunAndReturn

func (_c *EventSerializer_DeserializeMessage_Call) RunAndReturn(run func([]byte, string, string) (interface{}, error)) *EventSerializer_DeserializeMessage_Call

type EventSerializer_DeserializeType_Call

type EventSerializer_DeserializeType_Call struct {
	*mock.Call
}

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

func (*EventSerializer_DeserializeType_Call) Return

func (_c *EventSerializer_DeserializeType_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_DeserializeType_Call

func (*EventSerializer_DeserializeType_Call) Run

func (_c *EventSerializer_DeserializeType_Call) Run(run func(data []byte, eventType reflect.Type, contentType string)) *EventSerializer_DeserializeType_Call

func (*EventSerializer_DeserializeType_Call) RunAndReturn

func (_c *EventSerializer_DeserializeType_Call) RunAndReturn(run func([]byte, reflect.Type, string) (interface{}, error)) *EventSerializer_DeserializeType_Call

type EventSerializer_Deserialize_Call

type EventSerializer_Deserialize_Call struct {
	*mock.Call
}

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

func (*EventSerializer_Deserialize_Call) Return

func (_c *EventSerializer_Deserialize_Call) Return(_a0 interface{}, _a1 error) *EventSerializer_Deserialize_Call

func (*EventSerializer_Deserialize_Call) Run

func (_c *EventSerializer_Deserialize_Call) Run(run func(data []byte, eventType string, contentType string)) *EventSerializer_Deserialize_Call

func (*EventSerializer_Deserialize_Call) RunAndReturn

func (_c *EventSerializer_Deserialize_Call) RunAndReturn(run func([]byte, string, string) (interface{}, error)) *EventSerializer_Deserialize_Call

type EventSerializer_Expecter

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

func (*EventSerializer_Expecter) ContentType

func (_e *EventSerializer_Expecter) ContentType() *EventSerializer_ContentType_Call

ContentType is a helper method to define mock.On call

func (*EventSerializer_Expecter) Deserialize

func (_e *EventSerializer_Expecter) Deserialize(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_Deserialize_Call

Deserialize is a helper method to define mock.On call

• data []byte
• eventType string
• contentType string

func (*EventSerializer_Expecter) DeserializeEvent

func (_e *EventSerializer_Expecter) DeserializeEvent(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_DeserializeEvent_Call

DeserializeEvent is a helper method to define mock.On call

• data []byte
• eventType string
• contentType string

func (*EventSerializer_Expecter) DeserializeMessage

func (_e *EventSerializer_Expecter) DeserializeMessage(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_DeserializeMessage_Call

DeserializeMessage is a helper method to define mock.On call

• data []byte
• eventType string
• contentType string

func (*EventSerializer_Expecter) DeserializeType

func (_e *EventSerializer_Expecter) DeserializeType(data interface{}, eventType interface{}, contentType interface{}) *EventSerializer_DeserializeType_Call

DeserializeType is a helper method to define mock.On call

• data []byte
• eventType reflect.Type
• contentType string

func (*EventSerializer_Expecter) Serialize

func (_e *EventSerializer_Expecter) Serialize(event interface{}) *EventSerializer_Serialize_Call

Serialize is a helper method to define mock.On call

• event interface{}

func (*EventSerializer_Expecter) Serializer

func (_e *EventSerializer_Expecter) Serializer() *EventSerializer_Serializer_Call

Serializer is a helper method to define mock.On call

type EventSerializer_Serialize_Call

type EventSerializer_Serialize_Call struct {
	*mock.Call
}

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

func (*EventSerializer_Serialize_Call) Return

func (_c *EventSerializer_Serialize_Call) Return(_a0 *serializer.EventSerializationResult, _a1 error) *EventSerializer_Serialize_Call

func (*EventSerializer_Serialize_Call) Run

func (_c *EventSerializer_Serialize_Call) Run(run func(event interface{})) *EventSerializer_Serialize_Call

func (*EventSerializer_Serialize_Call) RunAndReturn

func (_c *EventSerializer_Serialize_Call) RunAndReturn(run func(interface{}) (*serializer.EventSerializationResult, error)) *EventSerializer_Serialize_Call

type EventSerializer_Serializer_Call

type EventSerializer_Serializer_Call struct {
	*mock.Call
}

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

func (*EventSerializer_Serializer_Call) Return

func (_c *EventSerializer_Serializer_Call) Return(_a0 serializer.Serializer) *EventSerializer_Serializer_Call

func (*EventSerializer_Serializer_Call) Run

func (_c *EventSerializer_Serializer_Call) Run(run func()) *EventSerializer_Serializer_Call

func (*EventSerializer_Serializer_Call) RunAndReturn

func (_c *EventSerializer_Serializer_Call) RunAndReturn(run func() serializer.Serializer) *EventSerializer_Serializer_Call

type GenericRepository

type GenericRepository[TEntity interface{}] struct {
	mock.Mock
}

GenericRepository is an autogenerated mock type for the GenericRepository type

func NewGenericRepository

func NewGenericRepository[TEntity interface{}](t interface {
	mock.TestingT
	Cleanup(func())
}) *GenericRepository[TEntity]

NewGenericRepository creates a new instance of GenericRepository. 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 (*GenericRepository[TEntity]) Add

func (_m *GenericRepository[TEntity]) Add(ctx context.Context, entity TEntity) error

Add provides a mock function with given fields: ctx, entity

func (*GenericRepository[TEntity]) AddAll

func (_m *GenericRepository[TEntity]) AddAll(ctx context.Context, entities []TEntity) error

AddAll provides a mock function with given fields: ctx, entities

func (*GenericRepository[TEntity]) Count

func (_m *GenericRepository[TEntity]) Count(ctx context.Context) int64

Count provides a mock function with given fields: ctx

func (*GenericRepository[TEntity]) Delete

func (_m *GenericRepository[TEntity]) Delete(ctx context.Context, id uuid.UUID) error

Delete provides a mock function with given fields: ctx, id

func (*GenericRepository[TEntity]) EXPECT

func (_m *GenericRepository[TEntity]) EXPECT() *GenericRepository_Expecter[TEntity]

func (*GenericRepository[TEntity]) Find

func (_m *GenericRepository[TEntity]) Find(ctx context.Context, _a1 specification.Specification) ([]TEntity, error)

Find provides a mock function with given fields: ctx, _a1

func (*GenericRepository[TEntity]) FirstOrDefault

func (_m *GenericRepository[TEntity]) FirstOrDefault(ctx context.Context, filters map[string]interface{}) (TEntity, error)

FirstOrDefault provides a mock function with given fields: ctx, filters

func (*GenericRepository[TEntity]) GetAll

func (_m *GenericRepository[TEntity]) GetAll(ctx context.Context, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)

GetAll provides a mock function with given fields: ctx, listQuery

func (*GenericRepository[TEntity]) GetByFilter

func (_m *GenericRepository[TEntity]) GetByFilter(ctx context.Context, filters map[string]interface{}) ([]TEntity, error)

GetByFilter provides a mock function with given fields: ctx, filters

func (*GenericRepository[TEntity]) GetByFuncFilter

func (_m *GenericRepository[TEntity]) GetByFuncFilter(ctx context.Context, filterFunc func(TEntity) bool) ([]TEntity, error)

GetByFuncFilter provides a mock function with given fields: ctx, filterFunc

func (*GenericRepository[TEntity]) GetById

func (_m *GenericRepository[TEntity]) GetById(ctx context.Context, id uuid.UUID) (TEntity, error)

GetById provides a mock function with given fields: ctx, id

func (*GenericRepository[TEntity]) Search

func (_m *GenericRepository[TEntity]) Search(ctx context.Context, searchTerm string, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)

Search provides a mock function with given fields: ctx, searchTerm, listQuery

func (*GenericRepository[TEntity]) SkipTake

func (_m *GenericRepository[TEntity]) SkipTake(ctx context.Context, skip int, take int) ([]TEntity, error)

SkipTake provides a mock function with given fields: ctx, skip, take

func (*GenericRepository[TEntity]) Update

func (_m *GenericRepository[TEntity]) Update(ctx context.Context, entity TEntity) error

Update provides a mock function with given fields: ctx, entity

func (*GenericRepository[TEntity]) UpdateAll

func (_m *GenericRepository[TEntity]) UpdateAll(ctx context.Context, entities []TEntity) error

UpdateAll provides a mock function with given fields: ctx, entities

type GenericRepositoryWithDataModel

type GenericRepositoryWithDataModel[TDataModel interface{}, TEntity interface{}] struct {
	mock.Mock
}

GenericRepositoryWithDataModel is an autogenerated mock type for the GenericRepositoryWithDataModel type

func NewGenericRepositoryWithDataModel

func NewGenericRepositoryWithDataModel[TDataModel interface{}, TEntity interface{}](t interface {
	mock.TestingT
	Cleanup(func())
}) *GenericRepositoryWithDataModel[TDataModel, TEntity]

NewGenericRepositoryWithDataModel creates a new instance of GenericRepositoryWithDataModel. 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 (*GenericRepositoryWithDataModel[TDataModel, TEntity]) Add

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Add(ctx context.Context, entity TEntity) error

Add provides a mock function with given fields: ctx, entity

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) AddAll

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) AddAll(ctx context.Context, entities []TEntity) error

AddAll provides a mock function with given fields: ctx, entities

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) Count

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Count(ctx context.Context) int64

Count provides a mock function with given fields: ctx

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) Delete

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Delete(ctx context.Context, id uuid.UUID) error

Delete provides a mock function with given fields: ctx, id

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) EXPECT

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) EXPECT() *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) Find

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Find(ctx context.Context, _a1 specification.Specification) ([]TEntity, error)

Find provides a mock function with given fields: ctx, _a1

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) FirstOrDefault

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) FirstOrDefault(ctx context.Context, filters map[string]interface{}) (TEntity, error)

FirstOrDefault provides a mock function with given fields: ctx, filters

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) GetAll

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetAll(ctx context.Context, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)

GetAll provides a mock function with given fields: ctx, listQuery

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) GetByFilter

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetByFilter(ctx context.Context, filters map[string]interface{}) ([]TEntity, error)

GetByFilter provides a mock function with given fields: ctx, filters

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) GetByFuncFilter

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetByFuncFilter(ctx context.Context, filterFunc func(TEntity) bool) ([]TEntity, error)

GetByFuncFilter provides a mock function with given fields: ctx, filterFunc

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) GetById

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) GetById(ctx context.Context, id uuid.UUID) (TEntity, error)

GetById provides a mock function with given fields: ctx, id

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) Search

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Search(ctx context.Context, searchTerm string, listQuery *utils.ListQuery) (*utils.ListResult[TEntity], error)

Search provides a mock function with given fields: ctx, searchTerm, listQuery

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) SkipTake

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) SkipTake(ctx context.Context, skip int, take int) ([]TEntity, error)

SkipTake provides a mock function with given fields: ctx, skip, take

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) Update

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) Update(ctx context.Context, entity TEntity) error

Update provides a mock function with given fields: ctx, entity

func (*GenericRepositoryWithDataModel[TDataModel, TEntity]) UpdateAll

func (_m *GenericRepositoryWithDataModel[TDataModel, TEntity]) UpdateAll(ctx context.Context, entities []TEntity) error

UpdateAll provides a mock function with given fields: ctx, entities

type GenericRepositoryWithDataModel_AddAll_Call

type GenericRepositoryWithDataModel_AddAll_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_Add_Call

type GenericRepositoryWithDataModel_Add_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_Count_Call

type GenericRepositoryWithDataModel_Count_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) Return(_a0 int64) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) Run(run func(ctx context.Context)) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context) int64) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_Delete_Call

type GenericRepositoryWithDataModel_Delete_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) error) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_Expecter

type GenericRepositoryWithDataModel_Expecter[TDataModel interface{}, TEntity interface{}] struct {
	// contains filtered or unexported fields
}

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Add

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Add(ctx interface{}, entity interface{}) *GenericRepositoryWithDataModel_Add_Call[TDataModel, TEntity]

Add is a helper method to define mock.On call

• ctx context.Context
• entity TEntity

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) AddAll

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) AddAll(ctx interface{}, entities interface{}) *GenericRepositoryWithDataModel_AddAll_Call[TDataModel, TEntity]

AddAll is a helper method to define mock.On call

• ctx context.Context
• entities []TEntity

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Count

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Count(ctx interface{}) *GenericRepositoryWithDataModel_Count_Call[TDataModel, TEntity]

Count is a helper method to define mock.On call

• ctx context.Context

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Delete

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Delete(ctx interface{}, id interface{}) *GenericRepositoryWithDataModel_Delete_Call[TDataModel, TEntity]

Delete is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Find

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Find(ctx interface{}, _a1 interface{}) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]

Find is a helper method to define mock.On call

• ctx context.Context
• _a1 specification.Specification

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) FirstOrDefault

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) FirstOrDefault(ctx interface{}, filters interface{}) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]

FirstOrDefault is a helper method to define mock.On call

• ctx context.Context
• filters map[string]interface{}

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetAll

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetAll(ctx interface{}, listQuery interface{}) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]

GetAll is a helper method to define mock.On call

• ctx context.Context
• listQuery *utils.ListQuery

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetByFilter

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetByFilter(ctx interface{}, filters interface{}) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]

GetByFilter is a helper method to define mock.On call

• ctx context.Context
• filters map[string]interface{}

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetByFuncFilter

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetByFuncFilter(ctx interface{}, filterFunc interface{}) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]

GetByFuncFilter is a helper method to define mock.On call

• ctx context.Context
• filterFunc func(TEntity) bool

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetById

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) GetById(ctx interface{}, id interface{}) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]

GetById is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Search

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Search(ctx interface{}, searchTerm interface{}, listQuery interface{}) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]

Search is a helper method to define mock.On call

• ctx context.Context
• searchTerm string
• listQuery *utils.ListQuery

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) SkipTake

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) SkipTake(ctx interface{}, skip interface{}, take interface{}) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]

SkipTake is a helper method to define mock.On call

• ctx context.Context
• skip int
• take int

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Update

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) Update(ctx interface{}, entity interface{}) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]

Update is a helper method to define mock.On call

• ctx context.Context
• entity TEntity

func (*GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) UpdateAll

func (_e *GenericRepositoryWithDataModel_Expecter[TDataModel, TEntity]) UpdateAll(ctx interface{}, entities interface{}) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]

UpdateAll is a helper method to define mock.On call

• ctx context.Context
• entities []TEntity

type GenericRepositoryWithDataModel_Find_Call

type GenericRepositoryWithDataModel_Find_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, _a1 specification.Specification)) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, specification.Specification) ([]TEntity, error)) *GenericRepositoryWithDataModel_Find_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_FirstOrDefault_Call

type GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) (TEntity, error)) *GenericRepositoryWithDataModel_FirstOrDefault_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_GetAll_Call

type GenericRepositoryWithDataModel_GetAll_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, listQuery *utils.ListQuery)) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, *utils.ListQuery) (*utils.ListResult[TEntity], error)) *GenericRepositoryWithDataModel_GetAll_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_GetByFilter_Call

type GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) ([]TEntity, error)) *GenericRepositoryWithDataModel_GetByFilter_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_GetByFuncFilter_Call

type GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, filterFunc func(TEntity) bool)) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, func(TEntity) bool) ([]TEntity, error)) *GenericRepositoryWithDataModel_GetByFuncFilter_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_GetById_Call

type GenericRepositoryWithDataModel_GetById_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) (TEntity, error)) *GenericRepositoryWithDataModel_GetById_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_Search_Call

type GenericRepositoryWithDataModel_Search_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, searchTerm string, listQuery *utils.ListQuery)) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, string, *utils.ListQuery) (*utils.ListResult[TEntity], error)) *GenericRepositoryWithDataModel_Search_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_SkipTake_Call

type GenericRepositoryWithDataModel_SkipTake_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, skip int, take int)) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, int, int) ([]TEntity, error)) *GenericRepositoryWithDataModel_SkipTake_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_UpdateAll_Call

type GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepositoryWithDataModel_UpdateAll_Call[TDataModel, TEntity]

type GenericRepositoryWithDataModel_Update_Call

type GenericRepositoryWithDataModel_Update_Call[TDataModel interface{}, TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) Return

func (_c *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) Return(_a0 error) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) Run

func (_c *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]

func (*GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) RunAndReturn

func (_c *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepositoryWithDataModel_Update_Call[TDataModel, TEntity]

type GenericRepository_AddAll_Call

type GenericRepository_AddAll_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_AddAll_Call[TEntity]) Return

func (_c *GenericRepository_AddAll_Call[TEntity]) Return(_a0 error) *GenericRepository_AddAll_Call[TEntity]

func (*GenericRepository_AddAll_Call[TEntity]) Run

func (_c *GenericRepository_AddAll_Call[TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepository_AddAll_Call[TEntity]

func (*GenericRepository_AddAll_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_AddAll_Call[TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepository_AddAll_Call[TEntity]

type GenericRepository_Add_Call

type GenericRepository_Add_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_Add_Call[TEntity]) Return

func (_c *GenericRepository_Add_Call[TEntity]) Return(_a0 error) *GenericRepository_Add_Call[TEntity]

func (*GenericRepository_Add_Call[TEntity]) Run

func (_c *GenericRepository_Add_Call[TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepository_Add_Call[TEntity]

func (*GenericRepository_Add_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_Add_Call[TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepository_Add_Call[TEntity]

type GenericRepository_Count_Call

type GenericRepository_Count_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_Count_Call[TEntity]) Return

func (_c *GenericRepository_Count_Call[TEntity]) Return(_a0 int64) *GenericRepository_Count_Call[TEntity]

func (*GenericRepository_Count_Call[TEntity]) Run

func (_c *GenericRepository_Count_Call[TEntity]) Run(run func(ctx context.Context)) *GenericRepository_Count_Call[TEntity]

func (*GenericRepository_Count_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_Count_Call[TEntity]) RunAndReturn(run func(context.Context) int64) *GenericRepository_Count_Call[TEntity]

type GenericRepository_Delete_Call

type GenericRepository_Delete_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_Delete_Call[TEntity]) Return

func (_c *GenericRepository_Delete_Call[TEntity]) Return(_a0 error) *GenericRepository_Delete_Call[TEntity]

func (*GenericRepository_Delete_Call[TEntity]) Run

func (_c *GenericRepository_Delete_Call[TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepository_Delete_Call[TEntity]

func (*GenericRepository_Delete_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_Delete_Call[TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) error) *GenericRepository_Delete_Call[TEntity]

type GenericRepository_Expecter

type GenericRepository_Expecter[TEntity interface{}] struct {
	// contains filtered or unexported fields
}

func (*GenericRepository_Expecter[TEntity]) Add

func (_e *GenericRepository_Expecter[TEntity]) Add(ctx interface{}, entity interface{}) *GenericRepository_Add_Call[TEntity]

Add is a helper method to define mock.On call

• ctx context.Context
• entity TEntity

func (*GenericRepository_Expecter[TEntity]) AddAll

func (_e *GenericRepository_Expecter[TEntity]) AddAll(ctx interface{}, entities interface{}) *GenericRepository_AddAll_Call[TEntity]

AddAll is a helper method to define mock.On call

• ctx context.Context
• entities []TEntity

func (*GenericRepository_Expecter[TEntity]) Count

func (_e *GenericRepository_Expecter[TEntity]) Count(ctx interface{}) *GenericRepository_Count_Call[TEntity]

Count is a helper method to define mock.On call

• ctx context.Context

func (*GenericRepository_Expecter[TEntity]) Delete

func (_e *GenericRepository_Expecter[TEntity]) Delete(ctx interface{}, id interface{}) *GenericRepository_Delete_Call[TEntity]

Delete is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*GenericRepository_Expecter[TEntity]) Find

func (_e *GenericRepository_Expecter[TEntity]) Find(ctx interface{}, _a1 interface{}) *GenericRepository_Find_Call[TEntity]

Find is a helper method to define mock.On call

• ctx context.Context
• _a1 specification.Specification

func (*GenericRepository_Expecter[TEntity]) FirstOrDefault

func (_e *GenericRepository_Expecter[TEntity]) FirstOrDefault(ctx interface{}, filters interface{}) *GenericRepository_FirstOrDefault_Call[TEntity]

FirstOrDefault is a helper method to define mock.On call

• ctx context.Context
• filters map[string]interface{}

func (*GenericRepository_Expecter[TEntity]) GetAll

func (_e *GenericRepository_Expecter[TEntity]) GetAll(ctx interface{}, listQuery interface{}) *GenericRepository_GetAll_Call[TEntity]

GetAll is a helper method to define mock.On call

• ctx context.Context
• listQuery *utils.ListQuery

func (*GenericRepository_Expecter[TEntity]) GetByFilter

func (_e *GenericRepository_Expecter[TEntity]) GetByFilter(ctx interface{}, filters interface{}) *GenericRepository_GetByFilter_Call[TEntity]

GetByFilter is a helper method to define mock.On call

• ctx context.Context
• filters map[string]interface{}

func (*GenericRepository_Expecter[TEntity]) GetByFuncFilter

func (_e *GenericRepository_Expecter[TEntity]) GetByFuncFilter(ctx interface{}, filterFunc interface{}) *GenericRepository_GetByFuncFilter_Call[TEntity]

GetByFuncFilter is a helper method to define mock.On call

• ctx context.Context
• filterFunc func(TEntity) bool

func (*GenericRepository_Expecter[TEntity]) GetById

func (_e *GenericRepository_Expecter[TEntity]) GetById(ctx interface{}, id interface{}) *GenericRepository_GetById_Call[TEntity]

GetById is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*GenericRepository_Expecter[TEntity]) Search

func (_e *GenericRepository_Expecter[TEntity]) Search(ctx interface{}, searchTerm interface{}, listQuery interface{}) *GenericRepository_Search_Call[TEntity]

Search is a helper method to define mock.On call

• ctx context.Context
• searchTerm string
• listQuery *utils.ListQuery

func (*GenericRepository_Expecter[TEntity]) SkipTake

func (_e *GenericRepository_Expecter[TEntity]) SkipTake(ctx interface{}, skip interface{}, take interface{}) *GenericRepository_SkipTake_Call[TEntity]

SkipTake is a helper method to define mock.On call

• ctx context.Context
• skip int
• take int

func (*GenericRepository_Expecter[TEntity]) Update

func (_e *GenericRepository_Expecter[TEntity]) Update(ctx interface{}, entity interface{}) *GenericRepository_Update_Call[TEntity]

Update is a helper method to define mock.On call

• ctx context.Context
• entity TEntity

func (*GenericRepository_Expecter[TEntity]) UpdateAll

func (_e *GenericRepository_Expecter[TEntity]) UpdateAll(ctx interface{}, entities interface{}) *GenericRepository_UpdateAll_Call[TEntity]

UpdateAll is a helper method to define mock.On call

• ctx context.Context
• entities []TEntity

type GenericRepository_Find_Call

type GenericRepository_Find_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_Find_Call[TEntity]) Return

func (_c *GenericRepository_Find_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_Find_Call[TEntity]

func (*GenericRepository_Find_Call[TEntity]) Run

func (_c *GenericRepository_Find_Call[TEntity]) Run(run func(ctx context.Context, _a1 specification.Specification)) *GenericRepository_Find_Call[TEntity]

func (*GenericRepository_Find_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_Find_Call[TEntity]) RunAndReturn(run func(context.Context, specification.Specification) ([]TEntity, error)) *GenericRepository_Find_Call[TEntity]

type GenericRepository_FirstOrDefault_Call

type GenericRepository_FirstOrDefault_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_FirstOrDefault_Call[TEntity]) Return

func (_c *GenericRepository_FirstOrDefault_Call[TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepository_FirstOrDefault_Call[TEntity]

func (*GenericRepository_FirstOrDefault_Call[TEntity]) Run

func (_c *GenericRepository_FirstOrDefault_Call[TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepository_FirstOrDefault_Call[TEntity]

func (*GenericRepository_FirstOrDefault_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_FirstOrDefault_Call[TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) (TEntity, error)) *GenericRepository_FirstOrDefault_Call[TEntity]

type GenericRepository_GetAll_Call

type GenericRepository_GetAll_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_GetAll_Call[TEntity]) Return

func (_c *GenericRepository_GetAll_Call[TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepository_GetAll_Call[TEntity]

func (*GenericRepository_GetAll_Call[TEntity]) Run

func (_c *GenericRepository_GetAll_Call[TEntity]) Run(run func(ctx context.Context, listQuery *utils.ListQuery)) *GenericRepository_GetAll_Call[TEntity]

func (*GenericRepository_GetAll_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_GetAll_Call[TEntity]) RunAndReturn(run func(context.Context, *utils.ListQuery) (*utils.ListResult[TEntity], error)) *GenericRepository_GetAll_Call[TEntity]

type GenericRepository_GetByFilter_Call

type GenericRepository_GetByFilter_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_GetByFilter_Call[TEntity]) Return

func (_c *GenericRepository_GetByFilter_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_GetByFilter_Call[TEntity]

func (*GenericRepository_GetByFilter_Call[TEntity]) Run

func (_c *GenericRepository_GetByFilter_Call[TEntity]) Run(run func(ctx context.Context, filters map[string]interface{})) *GenericRepository_GetByFilter_Call[TEntity]

func (*GenericRepository_GetByFilter_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_GetByFilter_Call[TEntity]) RunAndReturn(run func(context.Context, map[string]interface{}) ([]TEntity, error)) *GenericRepository_GetByFilter_Call[TEntity]

type GenericRepository_GetByFuncFilter_Call

type GenericRepository_GetByFuncFilter_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_GetByFuncFilter_Call[TEntity]) Return

func (_c *GenericRepository_GetByFuncFilter_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_GetByFuncFilter_Call[TEntity]

func (*GenericRepository_GetByFuncFilter_Call[TEntity]) Run

func (_c *GenericRepository_GetByFuncFilter_Call[TEntity]) Run(run func(ctx context.Context, filterFunc func(TEntity) bool)) *GenericRepository_GetByFuncFilter_Call[TEntity]

func (*GenericRepository_GetByFuncFilter_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_GetByFuncFilter_Call[TEntity]) RunAndReturn(run func(context.Context, func(TEntity) bool) ([]TEntity, error)) *GenericRepository_GetByFuncFilter_Call[TEntity]

type GenericRepository_GetById_Call

type GenericRepository_GetById_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_GetById_Call[TEntity]) Return

func (_c *GenericRepository_GetById_Call[TEntity]) Return(_a0 TEntity, _a1 error) *GenericRepository_GetById_Call[TEntity]

func (*GenericRepository_GetById_Call[TEntity]) Run

func (_c *GenericRepository_GetById_Call[TEntity]) Run(run func(ctx context.Context, id uuid.UUID)) *GenericRepository_GetById_Call[TEntity]

func (*GenericRepository_GetById_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_GetById_Call[TEntity]) RunAndReturn(run func(context.Context, uuid.UUID) (TEntity, error)) *GenericRepository_GetById_Call[TEntity]

type GenericRepository_Search_Call

type GenericRepository_Search_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_Search_Call[TEntity]) Return

func (_c *GenericRepository_Search_Call[TEntity]) Return(_a0 *utils.ListResult[TEntity], _a1 error) *GenericRepository_Search_Call[TEntity]

func (*GenericRepository_Search_Call[TEntity]) Run

func (_c *GenericRepository_Search_Call[TEntity]) Run(run func(ctx context.Context, searchTerm string, listQuery *utils.ListQuery)) *GenericRepository_Search_Call[TEntity]

func (*GenericRepository_Search_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_Search_Call[TEntity]) RunAndReturn(run func(context.Context, string, *utils.ListQuery) (*utils.ListResult[TEntity], error)) *GenericRepository_Search_Call[TEntity]

type GenericRepository_SkipTake_Call

type GenericRepository_SkipTake_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_SkipTake_Call[TEntity]) Return

func (_c *GenericRepository_SkipTake_Call[TEntity]) Return(_a0 []TEntity, _a1 error) *GenericRepository_SkipTake_Call[TEntity]

func (*GenericRepository_SkipTake_Call[TEntity]) Run

func (_c *GenericRepository_SkipTake_Call[TEntity]) Run(run func(ctx context.Context, skip int, take int)) *GenericRepository_SkipTake_Call[TEntity]

func (*GenericRepository_SkipTake_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_SkipTake_Call[TEntity]) RunAndReturn(run func(context.Context, int, int) ([]TEntity, error)) *GenericRepository_SkipTake_Call[TEntity]

type GenericRepository_UpdateAll_Call

type GenericRepository_UpdateAll_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_UpdateAll_Call[TEntity]) Return

func (_c *GenericRepository_UpdateAll_Call[TEntity]) Return(_a0 error) *GenericRepository_UpdateAll_Call[TEntity]

func (*GenericRepository_UpdateAll_Call[TEntity]) Run

func (_c *GenericRepository_UpdateAll_Call[TEntity]) Run(run func(ctx context.Context, entities []TEntity)) *GenericRepository_UpdateAll_Call[TEntity]

func (*GenericRepository_UpdateAll_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_UpdateAll_Call[TEntity]) RunAndReturn(run func(context.Context, []TEntity) error) *GenericRepository_UpdateAll_Call[TEntity]

type GenericRepository_Update_Call

type GenericRepository_Update_Call[TEntity interface{}] struct {
	*mock.Call
}

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

func (*GenericRepository_Update_Call[TEntity]) Return

func (_c *GenericRepository_Update_Call[TEntity]) Return(_a0 error) *GenericRepository_Update_Call[TEntity]

func (*GenericRepository_Update_Call[TEntity]) Run

func (_c *GenericRepository_Update_Call[TEntity]) Run(run func(ctx context.Context, entity TEntity)) *GenericRepository_Update_Call[TEntity]

func (*GenericRepository_Update_Call[TEntity]) RunAndReturn

func (_c *GenericRepository_Update_Call[TEntity]) RunAndReturn(run func(context.Context, TEntity) error) *GenericRepository_Update_Call[TEntity]

type IAggregateRoot

type IAggregateRoot struct {
	mock.Mock
}

IAggregateRoot is an autogenerated mock type for the IAggregateRoot type

func NewIAggregateRoot

func NewIAggregateRoot(t interface {
	mock.TestingT
	Cleanup(func())
}) *IAggregateRoot

NewIAggregateRoot creates a new instance of IAggregateRoot. 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 (*IAggregateRoot) AddDomainEvents

func (_m *IAggregateRoot) AddDomainEvents(event domain.IDomainEvent) error

AddDomainEvents provides a mock function with given fields: event

func (*IAggregateRoot) CreatedAt

func (_m *IAggregateRoot) CreatedAt() time.Time

CreatedAt provides a mock function with given fields:

func (*IAggregateRoot) EXPECT

func (_m *IAggregateRoot) EXPECT() *IAggregateRoot_Expecter

func (*IAggregateRoot) GetUncommittedEvents

func (_m *IAggregateRoot) GetUncommittedEvents() []domain.IDomainEvent

GetUncommittedEvents provides a mock function with given fields:

func (*IAggregateRoot) HasUncommittedEvents

func (_m *IAggregateRoot) HasUncommittedEvents() bool

HasUncommittedEvents provides a mock function with given fields:

func (*IAggregateRoot) Id

func (_m *IAggregateRoot) Id() uuid.UUID

Id provides a mock function with given fields:

func (*IAggregateRoot) MarkUncommittedEventAsCommitted

func (_m *IAggregateRoot) MarkUncommittedEventAsCommitted()

MarkUncommittedEventAsCommitted provides a mock function with given fields:

func (*IAggregateRoot) OriginalVersion

func (_m *IAggregateRoot) OriginalVersion() int64

OriginalVersion provides a mock function with given fields:

func (*IAggregateRoot) SetEntityType

func (_m *IAggregateRoot) SetEntityType(entityType string)

SetEntityType provides a mock function with given fields: entityType

func (*IAggregateRoot) SetId

func (_m *IAggregateRoot) SetId(id uuid.UUID)

SetId provides a mock function with given fields: id

func (*IAggregateRoot) SetUpdatedAt

func (_m *IAggregateRoot) SetUpdatedAt(updatedAt time.Time)

SetUpdatedAt provides a mock function with given fields: updatedAt

func (*IAggregateRoot) String

func (_m *IAggregateRoot) String() string

String provides a mock function with given fields:

func (*IAggregateRoot) UpdatedAt

func (_m *IAggregateRoot) UpdatedAt() time.Time

UpdatedAt provides a mock function with given fields:

type IAggregateRoot_AddDomainEvents_Call

type IAggregateRoot_AddDomainEvents_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_AddDomainEvents_Call) Return

func (_c *IAggregateRoot_AddDomainEvents_Call) Return(_a0 error) *IAggregateRoot_AddDomainEvents_Call

func (*IAggregateRoot_AddDomainEvents_Call) Run

func (_c *IAggregateRoot_AddDomainEvents_Call) Run(run func(event domain.IDomainEvent)) *IAggregateRoot_AddDomainEvents_Call

func (*IAggregateRoot_AddDomainEvents_Call) RunAndReturn

func (_c *IAggregateRoot_AddDomainEvents_Call) RunAndReturn(run func(domain.IDomainEvent) error) *IAggregateRoot_AddDomainEvents_Call

type IAggregateRoot_CreatedAt_Call

type IAggregateRoot_CreatedAt_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_CreatedAt_Call) Return

func (_c *IAggregateRoot_CreatedAt_Call) Return(_a0 time.Time) *IAggregateRoot_CreatedAt_Call

func (*IAggregateRoot_CreatedAt_Call) Run

func (_c *IAggregateRoot_CreatedAt_Call) Run(run func()) *IAggregateRoot_CreatedAt_Call

func (*IAggregateRoot_CreatedAt_Call) RunAndReturn

func (_c *IAggregateRoot_CreatedAt_Call) RunAndReturn(run func() time.Time) *IAggregateRoot_CreatedAt_Call

type IAggregateRoot_Expecter

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

func (*IAggregateRoot_Expecter) AddDomainEvents

func (_e *IAggregateRoot_Expecter) AddDomainEvents(event interface{}) *IAggregateRoot_AddDomainEvents_Call

AddDomainEvents is a helper method to define mock.On call

• event domain.IDomainEvent

func (*IAggregateRoot_Expecter) CreatedAt

func (_e *IAggregateRoot_Expecter) CreatedAt() *IAggregateRoot_CreatedAt_Call

CreatedAt is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) GetUncommittedEvents

func (_e *IAggregateRoot_Expecter) GetUncommittedEvents() *IAggregateRoot_GetUncommittedEvents_Call

GetUncommittedEvents is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) HasUncommittedEvents

func (_e *IAggregateRoot_Expecter) HasUncommittedEvents() *IAggregateRoot_HasUncommittedEvents_Call

HasUncommittedEvents is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) Id

func (_e *IAggregateRoot_Expecter) Id() *IAggregateRoot_Id_Call

Id is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) MarkUncommittedEventAsCommitted

func (_e *IAggregateRoot_Expecter) MarkUncommittedEventAsCommitted() *IAggregateRoot_MarkUncommittedEventAsCommitted_Call

MarkUncommittedEventAsCommitted is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) OriginalVersion

func (_e *IAggregateRoot_Expecter) OriginalVersion() *IAggregateRoot_OriginalVersion_Call

OriginalVersion is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) SetEntityType

func (_e *IAggregateRoot_Expecter) SetEntityType(entityType interface{}) *IAggregateRoot_SetEntityType_Call

SetEntityType is a helper method to define mock.On call

• entityType string

func (*IAggregateRoot_Expecter) SetId

func (_e *IAggregateRoot_Expecter) SetId(id interface{}) *IAggregateRoot_SetId_Call

SetId is a helper method to define mock.On call

• id uuid.UUID

func (*IAggregateRoot_Expecter) SetUpdatedAt

func (_e *IAggregateRoot_Expecter) SetUpdatedAt(updatedAt interface{}) *IAggregateRoot_SetUpdatedAt_Call

SetUpdatedAt is a helper method to define mock.On call

• updatedAt time.Time

func (*IAggregateRoot_Expecter) String

func (_e *IAggregateRoot_Expecter) String() *IAggregateRoot_String_Call

String is a helper method to define mock.On call

func (*IAggregateRoot_Expecter) UpdatedAt

func (_e *IAggregateRoot_Expecter) UpdatedAt() *IAggregateRoot_UpdatedAt_Call

UpdatedAt is a helper method to define mock.On call

type IAggregateRoot_GetUncommittedEvents_Call

type IAggregateRoot_GetUncommittedEvents_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_GetUncommittedEvents_Call) Return

func (_c *IAggregateRoot_GetUncommittedEvents_Call) Return(_a0 []domain.IDomainEvent) *IAggregateRoot_GetUncommittedEvents_Call

func (*IAggregateRoot_GetUncommittedEvents_Call) Run

func (_c *IAggregateRoot_GetUncommittedEvents_Call) Run(run func()) *IAggregateRoot_GetUncommittedEvents_Call

func (*IAggregateRoot_GetUncommittedEvents_Call) RunAndReturn

func (_c *IAggregateRoot_GetUncommittedEvents_Call) RunAndReturn(run func() []domain.IDomainEvent) *IAggregateRoot_GetUncommittedEvents_Call

type IAggregateRoot_HasUncommittedEvents_Call

type IAggregateRoot_HasUncommittedEvents_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_HasUncommittedEvents_Call) Return

func (_c *IAggregateRoot_HasUncommittedEvents_Call) Return(_a0 bool) *IAggregateRoot_HasUncommittedEvents_Call

func (*IAggregateRoot_HasUncommittedEvents_Call) Run

func (_c *IAggregateRoot_HasUncommittedEvents_Call) Run(run func()) *IAggregateRoot_HasUncommittedEvents_Call

func (*IAggregateRoot_HasUncommittedEvents_Call) RunAndReturn

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

type IAggregateRoot_Id_Call

type IAggregateRoot_Id_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_Id_Call) Return

func (_c *IAggregateRoot_Id_Call) Return(_a0 uuid.UUID) *IAggregateRoot_Id_Call

func (*IAggregateRoot_Id_Call) Run

func (_c *IAggregateRoot_Id_Call) Run(run func()) *IAggregateRoot_Id_Call

func (*IAggregateRoot_Id_Call) RunAndReturn

func (_c *IAggregateRoot_Id_Call) RunAndReturn(run func() uuid.UUID) *IAggregateRoot_Id_Call

type IAggregateRoot_MarkUncommittedEventAsCommitted_Call

type IAggregateRoot_MarkUncommittedEventAsCommitted_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_MarkUncommittedEventAsCommitted_Call) Return

func (_c *IAggregateRoot_MarkUncommittedEventAsCommitted_Call) Return() *IAggregateRoot_MarkUncommittedEventAsCommitted_Call

func (*IAggregateRoot_MarkUncommittedEventAsCommitted_Call) Run

func (_c *IAggregateRoot_MarkUncommittedEventAsCommitted_Call) Run(run func()) *IAggregateRoot_MarkUncommittedEventAsCommitted_Call

func (*IAggregateRoot_MarkUncommittedEventAsCommitted_Call) RunAndReturn

func (_c *IAggregateRoot_MarkUncommittedEventAsCommitted_Call) RunAndReturn(run func()) *IAggregateRoot_MarkUncommittedEventAsCommitted_Call

type IAggregateRoot_OriginalVersion_Call

type IAggregateRoot_OriginalVersion_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_OriginalVersion_Call) Return

func (_c *IAggregateRoot_OriginalVersion_Call) Return(_a0 int64) *IAggregateRoot_OriginalVersion_Call

func (*IAggregateRoot_OriginalVersion_Call) Run

func (_c *IAggregateRoot_OriginalVersion_Call) Run(run func()) *IAggregateRoot_OriginalVersion_Call

func (*IAggregateRoot_OriginalVersion_Call) RunAndReturn

func (_c *IAggregateRoot_OriginalVersion_Call) RunAndReturn(run func() int64) *IAggregateRoot_OriginalVersion_Call

type IAggregateRoot_SetEntityType_Call

type IAggregateRoot_SetEntityType_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_SetEntityType_Call) Return

func (_c *IAggregateRoot_SetEntityType_Call) Return() *IAggregateRoot_SetEntityType_Call

func (*IAggregateRoot_SetEntityType_Call) Run

func (_c *IAggregateRoot_SetEntityType_Call) Run(run func(entityType string)) *IAggregateRoot_SetEntityType_Call

func (*IAggregateRoot_SetEntityType_Call) RunAndReturn

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

type IAggregateRoot_SetId_Call

type IAggregateRoot_SetId_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_SetId_Call) Return

func (_c *IAggregateRoot_SetId_Call) Return() *IAggregateRoot_SetId_Call

func (*IAggregateRoot_SetId_Call) Run

func (_c *IAggregateRoot_SetId_Call) Run(run func(id uuid.UUID)) *IAggregateRoot_SetId_Call

func (*IAggregateRoot_SetId_Call) RunAndReturn

func (_c *IAggregateRoot_SetId_Call) RunAndReturn(run func(uuid.UUID)) *IAggregateRoot_SetId_Call

type IAggregateRoot_SetUpdatedAt_Call

type IAggregateRoot_SetUpdatedAt_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_SetUpdatedAt_Call) Return

func (_c *IAggregateRoot_SetUpdatedAt_Call) Return() *IAggregateRoot_SetUpdatedAt_Call

func (*IAggregateRoot_SetUpdatedAt_Call) Run

func (_c *IAggregateRoot_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IAggregateRoot_SetUpdatedAt_Call

func (*IAggregateRoot_SetUpdatedAt_Call) RunAndReturn

func (_c *IAggregateRoot_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IAggregateRoot_SetUpdatedAt_Call

type IAggregateRoot_String_Call

type IAggregateRoot_String_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_String_Call) Return

func (_c *IAggregateRoot_String_Call) Return(_a0 string) *IAggregateRoot_String_Call

func (*IAggregateRoot_String_Call) Run

func (_c *IAggregateRoot_String_Call) Run(run func()) *IAggregateRoot_String_Call

func (*IAggregateRoot_String_Call) RunAndReturn

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

type IAggregateRoot_UpdatedAt_Call

type IAggregateRoot_UpdatedAt_Call struct {
	*mock.Call
}

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

func (*IAggregateRoot_UpdatedAt_Call) Return

func (_c *IAggregateRoot_UpdatedAt_Call) Return(_a0 time.Time) *IAggregateRoot_UpdatedAt_Call

func (*IAggregateRoot_UpdatedAt_Call) Run

func (_c *IAggregateRoot_UpdatedAt_Call) Run(run func()) *IAggregateRoot_UpdatedAt_Call

func (*IAggregateRoot_UpdatedAt_Call) RunAndReturn

func (_c *IAggregateRoot_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IAggregateRoot_UpdatedAt_Call

type IDomainEvent

type IDomainEvent struct {
	mock.Mock
}

IDomainEvent is an autogenerated mock type for the IDomainEvent type

func NewIDomainEvent

func NewIDomainEvent(t interface {
	mock.TestingT
	Cleanup(func())
}) *IDomainEvent

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

func (_m *IDomainEvent) EXPECT() *IDomainEvent_Expecter

func (*IDomainEvent) GetAggregateId

func (_m *IDomainEvent) GetAggregateId() uuid.UUID

GetAggregateId provides a mock function with given fields:

func (*IDomainEvent) GetAggregateSequenceNumber

func (_m *IDomainEvent) GetAggregateSequenceNumber() int64

GetAggregateSequenceNumber provides a mock function with given fields:

func (*IDomainEvent) GetEventId

func (_m *IDomainEvent) GetEventId() uuid.UUID

GetEventId provides a mock function with given fields:

func (*IDomainEvent) GetEventType

func (_m *IDomainEvent) GetEventType() string

GetEventType provides a mock function with given fields:

func (*IDomainEvent) GetOccurredOn

func (_m *IDomainEvent) GetOccurredOn() time.Time

GetOccurredOn provides a mock function with given fields:

func (*IDomainEvent) WithAggregate

func (_m *IDomainEvent) WithAggregate(aggregateId uuid.UUID, aggregateSequenceNumber int64) *domain.DomainEvent

WithAggregate provides a mock function with given fields: aggregateId, aggregateSequenceNumber

type IDomainEvent_Expecter

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

func (*IDomainEvent_Expecter) GetAggregateId

func (_e *IDomainEvent_Expecter) GetAggregateId() *IDomainEvent_GetAggregateId_Call

GetAggregateId is a helper method to define mock.On call

func (*IDomainEvent_Expecter) GetAggregateSequenceNumber

func (_e *IDomainEvent_Expecter) GetAggregateSequenceNumber() *IDomainEvent_GetAggregateSequenceNumber_Call

GetAggregateSequenceNumber is a helper method to define mock.On call

func (*IDomainEvent_Expecter) GetEventId

func (_e *IDomainEvent_Expecter) GetEventId() *IDomainEvent_GetEventId_Call

GetEventId is a helper method to define mock.On call

func (*IDomainEvent_Expecter) GetEventType

func (_e *IDomainEvent_Expecter) GetEventType() *IDomainEvent_GetEventType_Call

GetEventType is a helper method to define mock.On call

func (*IDomainEvent_Expecter) GetOccurredOn

func (_e *IDomainEvent_Expecter) GetOccurredOn() *IDomainEvent_GetOccurredOn_Call

GetOccurredOn is a helper method to define mock.On call

func (*IDomainEvent_Expecter) WithAggregate

func (_e *IDomainEvent_Expecter) WithAggregate(aggregateId interface{}, aggregateSequenceNumber interface{}) *IDomainEvent_WithAggregate_Call

WithAggregate is a helper method to define mock.On call

• aggregateId uuid.UUID
• aggregateSequenceNumber int64

type IDomainEvent_GetAggregateId_Call

type IDomainEvent_GetAggregateId_Call struct {
	*mock.Call
}

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

func (*IDomainEvent_GetAggregateId_Call) Return

func (_c *IDomainEvent_GetAggregateId_Call) Return(_a0 uuid.UUID) *IDomainEvent_GetAggregateId_Call

func (*IDomainEvent_GetAggregateId_Call) Run

func (_c *IDomainEvent_GetAggregateId_Call) Run(run func()) *IDomainEvent_GetAggregateId_Call

func (*IDomainEvent_GetAggregateId_Call) RunAndReturn

func (_c *IDomainEvent_GetAggregateId_Call) RunAndReturn(run func() uuid.UUID) *IDomainEvent_GetAggregateId_Call

type IDomainEvent_GetAggregateSequenceNumber_Call

type IDomainEvent_GetAggregateSequenceNumber_Call struct {
	*mock.Call
}

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

func (*IDomainEvent_GetAggregateSequenceNumber_Call) Return

func (_c *IDomainEvent_GetAggregateSequenceNumber_Call) Return(_a0 int64) *IDomainEvent_GetAggregateSequenceNumber_Call

func (*IDomainEvent_GetAggregateSequenceNumber_Call) Run

func (_c *IDomainEvent_GetAggregateSequenceNumber_Call) Run(run func()) *IDomainEvent_GetAggregateSequenceNumber_Call

func (*IDomainEvent_GetAggregateSequenceNumber_Call) RunAndReturn

func (_c *IDomainEvent_GetAggregateSequenceNumber_Call) RunAndReturn(run func() int64) *IDomainEvent_GetAggregateSequenceNumber_Call

type IDomainEvent_GetEventId_Call

type IDomainEvent_GetEventId_Call struct {
	*mock.Call
}

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

func (*IDomainEvent_GetEventId_Call) Return

func (_c *IDomainEvent_GetEventId_Call) Return(_a0 uuid.UUID) *IDomainEvent_GetEventId_Call

func (*IDomainEvent_GetEventId_Call) Run

func (_c *IDomainEvent_GetEventId_Call) Run(run func()) *IDomainEvent_GetEventId_Call

func (*IDomainEvent_GetEventId_Call) RunAndReturn

func (_c *IDomainEvent_GetEventId_Call) RunAndReturn(run func() uuid.UUID) *IDomainEvent_GetEventId_Call

type IDomainEvent_GetEventType_Call

type IDomainEvent_GetEventType_Call struct {
	*mock.Call
}

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

func (*IDomainEvent_GetEventType_Call) Return

func (_c *IDomainEvent_GetEventType_Call) Return(_a0 string) *IDomainEvent_GetEventType_Call

func (*IDomainEvent_GetEventType_Call) Run

func (_c *IDomainEvent_GetEventType_Call) Run(run func()) *IDomainEvent_GetEventType_Call

func (*IDomainEvent_GetEventType_Call) RunAndReturn

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

type IDomainEvent_GetOccurredOn_Call

type IDomainEvent_GetOccurredOn_Call struct {
	*mock.Call
}

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

func (*IDomainEvent_GetOccurredOn_Call) Return

func (_c *IDomainEvent_GetOccurredOn_Call) Return(_a0 time.Time) *IDomainEvent_GetOccurredOn_Call

func (*IDomainEvent_GetOccurredOn_Call) Run

func (_c *IDomainEvent_GetOccurredOn_Call) Run(run func()) *IDomainEvent_GetOccurredOn_Call

func (*IDomainEvent_GetOccurredOn_Call) RunAndReturn

func (_c *IDomainEvent_GetOccurredOn_Call) RunAndReturn(run func() time.Time) *IDomainEvent_GetOccurredOn_Call

type IDomainEvent_WithAggregate_Call

type IDomainEvent_WithAggregate_Call struct {
	*mock.Call
}

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

func (*IDomainEvent_WithAggregate_Call) Return

func (_c *IDomainEvent_WithAggregate_Call) Return(_a0 *domain.DomainEvent) *IDomainEvent_WithAggregate_Call

func (*IDomainEvent_WithAggregate_Call) Run

func (_c *IDomainEvent_WithAggregate_Call) Run(run func(aggregateId uuid.UUID, aggregateSequenceNumber int64)) *IDomainEvent_WithAggregate_Call

func (*IDomainEvent_WithAggregate_Call) RunAndReturn

func (_c *IDomainEvent_WithAggregate_Call) RunAndReturn(run func(uuid.UUID, int64) *domain.DomainEvent) *IDomainEvent_WithAggregate_Call

type IEntity

type IEntity struct {
	mock.Mock
}

IEntity is an autogenerated mock type for the IEntity type

func NewIEntity

func NewIEntity(t interface {
	mock.TestingT
	Cleanup(func())
}) *IEntity

NewIEntity creates a new instance of IEntity. 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 (*IEntity) CreatedAt

func (_m *IEntity) CreatedAt() time.Time

CreatedAt provides a mock function with given fields:

func (*IEntity) EXPECT

func (_m *IEntity) EXPECT() *IEntity_Expecter

func (*IEntity) Id

func (_m *IEntity) Id() uuid.UUID

Id provides a mock function with given fields:

func (*IEntity) SetEntityType

func (_m *IEntity) SetEntityType(entityType string)

SetEntityType provides a mock function with given fields: entityType

func (*IEntity) SetId

func (_m *IEntity) SetId(id uuid.UUID)

SetId provides a mock function with given fields: id

func (*IEntity) SetUpdatedAt

func (_m *IEntity) SetUpdatedAt(updatedAt time.Time)

SetUpdatedAt provides a mock function with given fields: updatedAt

func (*IEntity) UpdatedAt

func (_m *IEntity) UpdatedAt() time.Time

UpdatedAt provides a mock function with given fields:

type IEntity_CreatedAt_Call

type IEntity_CreatedAt_Call struct {
	*mock.Call
}

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

func (*IEntity_CreatedAt_Call) Return

func (_c *IEntity_CreatedAt_Call) Return(_a0 time.Time) *IEntity_CreatedAt_Call

func (*IEntity_CreatedAt_Call) Run

func (_c *IEntity_CreatedAt_Call) Run(run func()) *IEntity_CreatedAt_Call

func (*IEntity_CreatedAt_Call) RunAndReturn

func (_c *IEntity_CreatedAt_Call) RunAndReturn(run func() time.Time) *IEntity_CreatedAt_Call

type IEntity_Expecter

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

func (*IEntity_Expecter) CreatedAt

func (_e *IEntity_Expecter) CreatedAt() *IEntity_CreatedAt_Call

CreatedAt is a helper method to define mock.On call

func (*IEntity_Expecter) Id

func (_e *IEntity_Expecter) Id() *IEntity_Id_Call

Id is a helper method to define mock.On call

func (*IEntity_Expecter) SetEntityType

func (_e *IEntity_Expecter) SetEntityType(entityType interface{}) *IEntity_SetEntityType_Call

SetEntityType is a helper method to define mock.On call

• entityType string

func (*IEntity_Expecter) SetId

func (_e *IEntity_Expecter) SetId(id interface{}) *IEntity_SetId_Call

SetId is a helper method to define mock.On call

• id uuid.UUID

func (*IEntity_Expecter) SetUpdatedAt

func (_e *IEntity_Expecter) SetUpdatedAt(updatedAt interface{}) *IEntity_SetUpdatedAt_Call

SetUpdatedAt is a helper method to define mock.On call

• updatedAt time.Time

func (*IEntity_Expecter) UpdatedAt

func (_e *IEntity_Expecter) UpdatedAt() *IEntity_UpdatedAt_Call

UpdatedAt is a helper method to define mock.On call

type IEntity_Id_Call

type IEntity_Id_Call struct {
	*mock.Call
}

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

func (*IEntity_Id_Call) Return

func (_c *IEntity_Id_Call) Return(_a0 uuid.UUID) *IEntity_Id_Call

func (*IEntity_Id_Call) Run

func (_c *IEntity_Id_Call) Run(run func()) *IEntity_Id_Call

func (*IEntity_Id_Call) RunAndReturn

func (_c *IEntity_Id_Call) RunAndReturn(run func() uuid.UUID) *IEntity_Id_Call

type IEntity_SetEntityType_Call

type IEntity_SetEntityType_Call struct {
	*mock.Call
}

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

func (*IEntity_SetEntityType_Call) Return

func (_c *IEntity_SetEntityType_Call) Return() *IEntity_SetEntityType_Call

func (*IEntity_SetEntityType_Call) Run

func (_c *IEntity_SetEntityType_Call) Run(run func(entityType string)) *IEntity_SetEntityType_Call

func (*IEntity_SetEntityType_Call) RunAndReturn

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

type IEntity_SetId_Call

type IEntity_SetId_Call struct {
	*mock.Call
}

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

func (*IEntity_SetId_Call) Return

func (_c *IEntity_SetId_Call) Return() *IEntity_SetId_Call

func (*IEntity_SetId_Call) Run

func (_c *IEntity_SetId_Call) Run(run func(id uuid.UUID)) *IEntity_SetId_Call

func (*IEntity_SetId_Call) RunAndReturn

func (_c *IEntity_SetId_Call) RunAndReturn(run func(uuid.UUID)) *IEntity_SetId_Call

type IEntity_SetUpdatedAt_Call

type IEntity_SetUpdatedAt_Call struct {
	*mock.Call
}

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

func (*IEntity_SetUpdatedAt_Call) Return

func (_c *IEntity_SetUpdatedAt_Call) Return() *IEntity_SetUpdatedAt_Call

func (*IEntity_SetUpdatedAt_Call) Run

func (_c *IEntity_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IEntity_SetUpdatedAt_Call

func (*IEntity_SetUpdatedAt_Call) RunAndReturn

func (_c *IEntity_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IEntity_SetUpdatedAt_Call

type IEntity_UpdatedAt_Call

type IEntity_UpdatedAt_Call struct {
	*mock.Call
}

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

func (*IEntity_UpdatedAt_Call) Return

func (_c *IEntity_UpdatedAt_Call) Return(_a0 time.Time) *IEntity_UpdatedAt_Call

func (*IEntity_UpdatedAt_Call) Run

func (_c *IEntity_UpdatedAt_Call) Run(run func()) *IEntity_UpdatedAt_Call

func (*IEntity_UpdatedAt_Call) RunAndReturn

func (_c *IEntity_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IEntity_UpdatedAt_Call

type IEvent

type IEvent struct {
	mock.Mock
}

IEvent is an autogenerated mock type for the IEvent type

func NewIEvent

func NewIEvent(t interface {
	mock.TestingT
	Cleanup(func())
}) *IEvent

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

func (_m *IEvent) EXPECT() *IEvent_Expecter

func (*IEvent) GetEventId

func (_m *IEvent) GetEventId() uuid.UUID

GetEventId provides a mock function with given fields:

func (*IEvent) GetEventType

func (_m *IEvent) GetEventType() string

GetEventType provides a mock function with given fields:

func (*IEvent) GetOccurredOn

func (_m *IEvent) GetOccurredOn() time.Time

GetOccurredOn provides a mock function with given fields:

type IEvent_Expecter

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

func (*IEvent_Expecter) GetEventId

func (_e *IEvent_Expecter) GetEventId() *IEvent_GetEventId_Call

GetEventId is a helper method to define mock.On call

func (*IEvent_Expecter) GetEventType

func (_e *IEvent_Expecter) GetEventType() *IEvent_GetEventType_Call

GetEventType is a helper method to define mock.On call

func (*IEvent_Expecter) GetOccurredOn

func (_e *IEvent_Expecter) GetOccurredOn() *IEvent_GetOccurredOn_Call

GetOccurredOn is a helper method to define mock.On call

type IEvent_GetEventId_Call

type IEvent_GetEventId_Call struct {
	*mock.Call
}

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

func (*IEvent_GetEventId_Call) Return

func (_c *IEvent_GetEventId_Call) Return(_a0 uuid.UUID) *IEvent_GetEventId_Call

func (*IEvent_GetEventId_Call) Run

func (_c *IEvent_GetEventId_Call) Run(run func()) *IEvent_GetEventId_Call

func (*IEvent_GetEventId_Call) RunAndReturn

func (_c *IEvent_GetEventId_Call) RunAndReturn(run func() uuid.UUID) *IEvent_GetEventId_Call

type IEvent_GetEventType_Call

type IEvent_GetEventType_Call struct {
	*mock.Call
}

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

func (*IEvent_GetEventType_Call) Return

func (_c *IEvent_GetEventType_Call) Return(_a0 string) *IEvent_GetEventType_Call

func (*IEvent_GetEventType_Call) Run

func (_c *IEvent_GetEventType_Call) Run(run func()) *IEvent_GetEventType_Call

func (*IEvent_GetEventType_Call) RunAndReturn

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

type IEvent_GetOccurredOn_Call

type IEvent_GetOccurredOn_Call struct {
	*mock.Call
}

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

func (*IEvent_GetOccurredOn_Call) Return

func (_c *IEvent_GetOccurredOn_Call) Return(_a0 time.Time) *IEvent_GetOccurredOn_Call

func (*IEvent_GetOccurredOn_Call) Run

func (_c *IEvent_GetOccurredOn_Call) Run(run func()) *IEvent_GetOccurredOn_Call

func (*IEvent_GetOccurredOn_Call) RunAndReturn

func (_c *IEvent_GetOccurredOn_Call) RunAndReturn(run func() time.Time) *IEvent_GetOccurredOn_Call

type MetadataSerializer

type MetadataSerializer struct {
	mock.Mock
}

MetadataSerializer is an autogenerated mock type for the MetadataSerializer type

func NewMetadataSerializer

func NewMetadataSerializer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MetadataSerializer

NewMetadataSerializer creates a new instance of MetadataSerializer. 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 (*MetadataSerializer) Deserialize

func (_m *MetadataSerializer) Deserialize(bytes []byte) (metadata.Metadata, error)

Deserialize provides a mock function with given fields: bytes

func (*MetadataSerializer) EXPECT

func (_m *MetadataSerializer) EXPECT() *MetadataSerializer_Expecter

func (*MetadataSerializer) Serialize

func (_m *MetadataSerializer) Serialize(meta metadata.Metadata) ([]byte, error)

Serialize provides a mock function with given fields: meta

type MetadataSerializer_Deserialize_Call

type MetadataSerializer_Deserialize_Call struct {
	*mock.Call
}

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

func (*MetadataSerializer_Deserialize_Call) Return

func (_c *MetadataSerializer_Deserialize_Call) Return(_a0 metadata.Metadata, _a1 error) *MetadataSerializer_Deserialize_Call

func (*MetadataSerializer_Deserialize_Call) Run

func (_c *MetadataSerializer_Deserialize_Call) Run(run func(bytes []byte)) *MetadataSerializer_Deserialize_Call

func (*MetadataSerializer_Deserialize_Call) RunAndReturn

func (_c *MetadataSerializer_Deserialize_Call) RunAndReturn(run func([]byte) (metadata.Metadata, error)) *MetadataSerializer_Deserialize_Call

type MetadataSerializer_Expecter

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

func (*MetadataSerializer_Expecter) Deserialize

func (_e *MetadataSerializer_Expecter) Deserialize(bytes interface{}) *MetadataSerializer_Deserialize_Call

Deserialize is a helper method to define mock.On call

• bytes []byte

func (*MetadataSerializer_Expecter) Serialize

func (_e *MetadataSerializer_Expecter) Serialize(meta interface{}) *MetadataSerializer_Serialize_Call

Serialize is a helper method to define mock.On call

• meta metadata.Metadata

type MetadataSerializer_Serialize_Call

type MetadataSerializer_Serialize_Call struct {
	*mock.Call
}

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

func (*MetadataSerializer_Serialize_Call) Return

func (_c *MetadataSerializer_Serialize_Call) Return(_a0 []byte, _a1 error) *MetadataSerializer_Serialize_Call

func (*MetadataSerializer_Serialize_Call) Run

func (_c *MetadataSerializer_Serialize_Call) Run(run func(meta metadata.Metadata)) *MetadataSerializer_Serialize_Call

func (*MetadataSerializer_Serialize_Call) RunAndReturn

func (_c *MetadataSerializer_Serialize_Call) RunAndReturn(run func(metadata.Metadata) ([]byte, error)) *MetadataSerializer_Serialize_Call

type Serializer

type Serializer struct {
	mock.Mock
}

Serializer is an autogenerated mock type for the Serializer type

func NewSerializer

func NewSerializer(t interface {
	mock.TestingT
	Cleanup(func())
}) *Serializer

NewSerializer creates a new instance of Serializer. 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 (*Serializer) ColoredPrettyPrint

func (_m *Serializer) ColoredPrettyPrint(data interface{}) string

ColoredPrettyPrint provides a mock function with given fields: data

func (*Serializer) DecodeWithMapStructure

func (_m *Serializer) DecodeWithMapStructure(input interface{}, output interface{}) error

DecodeWithMapStructure provides a mock function with given fields: input, output

func (*Serializer) EXPECT

func (_m *Serializer) EXPECT() *Serializer_Expecter

func (*Serializer) Marshal

func (_m *Serializer) Marshal(v interface{}) ([]byte, error)

Marshal provides a mock function with given fields: v

func (*Serializer) PrettyPrint

func (_m *Serializer) PrettyPrint(data interface{}) string

PrettyPrint provides a mock function with given fields: data

func (*Serializer) Unmarshal

func (_m *Serializer) Unmarshal(data []byte, v interface{}) error

Unmarshal provides a mock function with given fields: data, v

func (*Serializer) UnmarshalFromJson

func (_m *Serializer) UnmarshalFromJson(data string, v interface{}) error

UnmarshalFromJson provides a mock function with given fields: data, v

func (*Serializer) UnmarshalToMap

func (_m *Serializer) UnmarshalToMap(data []byte, v *map[string]interface{}) error

UnmarshalToMap provides a mock function with given fields: data, v

func (*Serializer) UnmarshalToMapFromJson

func (_m *Serializer) UnmarshalToMapFromJson(data string, v *map[string]interface{}) error

UnmarshalToMapFromJson provides a mock function with given fields: data, v

type Serializer_ColoredPrettyPrint_Call

type Serializer_ColoredPrettyPrint_Call struct {
	*mock.Call
}

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

func (*Serializer_ColoredPrettyPrint_Call) Return

func (_c *Serializer_ColoredPrettyPrint_Call) Return(_a0 string) *Serializer_ColoredPrettyPrint_Call

func (*Serializer_ColoredPrettyPrint_Call) Run

func (_c *Serializer_ColoredPrettyPrint_Call) Run(run func(data interface{})) *Serializer_ColoredPrettyPrint_Call

func (*Serializer_ColoredPrettyPrint_Call) RunAndReturn

func (_c *Serializer_ColoredPrettyPrint_Call) RunAndReturn(run func(interface{}) string) *Serializer_ColoredPrettyPrint_Call

type Serializer_DecodeWithMapStructure_Call

type Serializer_DecodeWithMapStructure_Call struct {
	*mock.Call
}

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

func (*Serializer_DecodeWithMapStructure_Call) Return

func (_c *Serializer_DecodeWithMapStructure_Call) Return(_a0 error) *Serializer_DecodeWithMapStructure_Call

func (*Serializer_DecodeWithMapStructure_Call) Run

func (_c *Serializer_DecodeWithMapStructure_Call) Run(run func(input interface{}, output interface{})) *Serializer_DecodeWithMapStructure_Call

func (*Serializer_DecodeWithMapStructure_Call) RunAndReturn

func (_c *Serializer_DecodeWithMapStructure_Call) RunAndReturn(run func(interface{}, interface{}) error) *Serializer_DecodeWithMapStructure_Call

type Serializer_Expecter

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

func (*Serializer_Expecter) ColoredPrettyPrint

func (_e *Serializer_Expecter) ColoredPrettyPrint(data interface{}) *Serializer_ColoredPrettyPrint_Call

ColoredPrettyPrint is a helper method to define mock.On call

• data interface{}

func (*Serializer_Expecter) DecodeWithMapStructure

func (_e *Serializer_Expecter) DecodeWithMapStructure(input interface{}, output interface{}) *Serializer_DecodeWithMapStructure_Call

DecodeWithMapStructure is a helper method to define mock.On call

• input interface{}
• output interface{}

func (*Serializer_Expecter) Marshal

func (_e *Serializer_Expecter) Marshal(v interface{}) *Serializer_Marshal_Call

Marshal is a helper method to define mock.On call

• v interface{}

func (*Serializer_Expecter) PrettyPrint

func (_e *Serializer_Expecter) PrettyPrint(data interface{}) *Serializer_PrettyPrint_Call

PrettyPrint is a helper method to define mock.On call

• data interface{}

func (*Serializer_Expecter) Unmarshal

func (_e *Serializer_Expecter) Unmarshal(data interface{}, v interface{}) *Serializer_Unmarshal_Call

Unmarshal is a helper method to define mock.On call

• data []byte
• v interface{}

func (*Serializer_Expecter) UnmarshalFromJson

func (_e *Serializer_Expecter) UnmarshalFromJson(data interface{}, v interface{}) *Serializer_UnmarshalFromJson_Call

UnmarshalFromJson is a helper method to define mock.On call

• data string
• v interface{}

func (*Serializer_Expecter) UnmarshalToMap

func (_e *Serializer_Expecter) UnmarshalToMap(data interface{}, v interface{}) *Serializer_UnmarshalToMap_Call

UnmarshalToMap is a helper method to define mock.On call

• data []byte
• v *map[string]interface{}

func (*Serializer_Expecter) UnmarshalToMapFromJson

func (_e *Serializer_Expecter) UnmarshalToMapFromJson(data interface{}, v interface{}) *Serializer_UnmarshalToMapFromJson_Call

UnmarshalToMapFromJson is a helper method to define mock.On call

• data string
• v *map[string]interface{}

type Serializer_Marshal_Call

type Serializer_Marshal_Call struct {
	*mock.Call
}

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

func (*Serializer_Marshal_Call) Return

func (_c *Serializer_Marshal_Call) Return(_a0 []byte, _a1 error) *Serializer_Marshal_Call

func (*Serializer_Marshal_Call) Run

func (_c *Serializer_Marshal_Call) Run(run func(v interface{})) *Serializer_Marshal_Call

func (*Serializer_Marshal_Call) RunAndReturn

func (_c *Serializer_Marshal_Call) RunAndReturn(run func(interface{}) ([]byte, error)) *Serializer_Marshal_Call

type Serializer_PrettyPrint_Call

type Serializer_PrettyPrint_Call struct {
	*mock.Call
}

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

func (*Serializer_PrettyPrint_Call) Return

func (_c *Serializer_PrettyPrint_Call) Return(_a0 string) *Serializer_PrettyPrint_Call

func (*Serializer_PrettyPrint_Call) Run

func (_c *Serializer_PrettyPrint_Call) Run(run func(data interface{})) *Serializer_PrettyPrint_Call

func (*Serializer_PrettyPrint_Call) RunAndReturn

func (_c *Serializer_PrettyPrint_Call) RunAndReturn(run func(interface{}) string) *Serializer_PrettyPrint_Call

type Serializer_UnmarshalFromJson_Call

type Serializer_UnmarshalFromJson_Call struct {
	*mock.Call
}

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

func (*Serializer_UnmarshalFromJson_Call) Return

func (_c *Serializer_UnmarshalFromJson_Call) Return(_a0 error) *Serializer_UnmarshalFromJson_Call

func (*Serializer_UnmarshalFromJson_Call) Run

func (_c *Serializer_UnmarshalFromJson_Call) Run(run func(data string, v interface{})) *Serializer_UnmarshalFromJson_Call

func (*Serializer_UnmarshalFromJson_Call) RunAndReturn

func (_c *Serializer_UnmarshalFromJson_Call) RunAndReturn(run func(string, interface{}) error) *Serializer_UnmarshalFromJson_Call

type Serializer_UnmarshalToMapFromJson_Call

type Serializer_UnmarshalToMapFromJson_Call struct {
	*mock.Call
}

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

func (*Serializer_UnmarshalToMapFromJson_Call) Return

func (_c *Serializer_UnmarshalToMapFromJson_Call) Return(_a0 error) *Serializer_UnmarshalToMapFromJson_Call

func (*Serializer_UnmarshalToMapFromJson_Call) Run

func (_c *Serializer_UnmarshalToMapFromJson_Call) Run(run func(data string, v *map[string]interface{})) *Serializer_UnmarshalToMapFromJson_Call

func (*Serializer_UnmarshalToMapFromJson_Call) RunAndReturn

func (_c *Serializer_UnmarshalToMapFromJson_Call) RunAndReturn(run func(string, *map[string]interface{}) error) *Serializer_UnmarshalToMapFromJson_Call

type Serializer_UnmarshalToMap_Call

type Serializer_UnmarshalToMap_Call struct {
	*mock.Call
}

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

func (*Serializer_UnmarshalToMap_Call) Return

func (_c *Serializer_UnmarshalToMap_Call) Return(_a0 error) *Serializer_UnmarshalToMap_Call

func (*Serializer_UnmarshalToMap_Call) Run

func (_c *Serializer_UnmarshalToMap_Call) Run(run func(data []byte, v *map[string]interface{})) *Serializer_UnmarshalToMap_Call

func (*Serializer_UnmarshalToMap_Call) RunAndReturn

func (_c *Serializer_UnmarshalToMap_Call) RunAndReturn(run func([]byte, *map[string]interface{}) error) *Serializer_UnmarshalToMap_Call

type Serializer_Unmarshal_Call

type Serializer_Unmarshal_Call struct {
	*mock.Call
}

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

func (*Serializer_Unmarshal_Call) Return

func (_c *Serializer_Unmarshal_Call) Return(_a0 error) *Serializer_Unmarshal_Call

func (*Serializer_Unmarshal_Call) Run

func (_c *Serializer_Unmarshal_Call) Run(run func(data []byte, v interface{})) *Serializer_Unmarshal_Call

func (*Serializer_Unmarshal_Call) RunAndReturn

func (_c *Serializer_Unmarshal_Call) RunAndReturn(run func([]byte, interface{}) error) *Serializer_Unmarshal_Call

type Specification

type Specification struct {
	mock.Mock
}

Specification is an autogenerated mock type for the Specification type

func NewSpecification

func NewSpecification(t interface {
	mock.TestingT
	Cleanup(func())
}) *Specification

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

func (_m *Specification) EXPECT() *Specification_Expecter

func (*Specification) GetQuery

func (_m *Specification) GetQuery() string

GetQuery provides a mock function with given fields:

func (*Specification) GetValues

func (_m *Specification) GetValues() []interface{}

GetValues provides a mock function with given fields:

type Specification_Expecter

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

func (*Specification_Expecter) GetQuery

func (_e *Specification_Expecter) GetQuery() *Specification_GetQuery_Call

GetQuery is a helper method to define mock.On call

func (*Specification_Expecter) GetValues

func (_e *Specification_Expecter) GetValues() *Specification_GetValues_Call

GetValues is a helper method to define mock.On call

type Specification_GetQuery_Call

type Specification_GetQuery_Call struct {
	*mock.Call
}

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

func (*Specification_GetQuery_Call) Return

func (_c *Specification_GetQuery_Call) Return(_a0 string) *Specification_GetQuery_Call

func (*Specification_GetQuery_Call) Run

func (_c *Specification_GetQuery_Call) Run(run func()) *Specification_GetQuery_Call

func (*Specification_GetQuery_Call) RunAndReturn

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

type Specification_GetValues_Call

type Specification_GetValues_Call struct {
	*mock.Call
}

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

func (*Specification_GetValues_Call) Return

func (_c *Specification_GetValues_Call) Return(_a0 []interface{}) *Specification_GetValues_Call

func (*Specification_GetValues_Call) Run

func (_c *Specification_GetValues_Call) Run(run func()) *Specification_GetValues_Call

func (*Specification_GetValues_Call) RunAndReturn

func (_c *Specification_GetValues_Call) RunAndReturn(run func() []interface{}) *Specification_GetValues_Call