mocks

Oct 1, 2024

Changes in this version

type CollectionRepo

+ func (_m *CollectionRepo) AddPersonCollection(ctx context.Context, userID uint32, cat collection.PersonCollectCategory, ...) error

+ func (_m *CollectionRepo) CountPersonCollections(ctx context.Context, userID uint32, cat collection.PersonCollectCategory) (int64, error)

+ func (_m *CollectionRepo) GetPersonCollection(ctx context.Context, userID uint32, cat collection.PersonCollectCategory, ...) (collection.UserPersonCollection, error)

+ func (_m *CollectionRepo) ListPersonCollection(ctx context.Context, userID uint32, cat collection.PersonCollectCategory, ...) ([]collection.UserPersonCollection, error)

+ func (_m *CollectionRepo) RemovePersonCollection(ctx context.Context, userID uint32, cat collection.PersonCollectCategory, ...) error

+ type CollectionRepo_AddPersonCollection_Call struct

+ func (_c *CollectionRepo_AddPersonCollection_Call) Return(_a0 error) *CollectionRepo_AddPersonCollection_Call

+ func (_c *CollectionRepo_AddPersonCollection_Call) Run(...) *CollectionRepo_AddPersonCollection_Call

+ func (_c *CollectionRepo_AddPersonCollection_Call) RunAndReturn(...) *CollectionRepo_AddPersonCollection_Call

+ type CollectionRepo_CountPersonCollections_Call struct

+ func (_c *CollectionRepo_CountPersonCollections_Call) Return(_a0 int64, _a1 error) *CollectionRepo_CountPersonCollections_Call

+ func (_c *CollectionRepo_CountPersonCollections_Call) Run(...) *CollectionRepo_CountPersonCollections_Call

+ func (_c *CollectionRepo_CountPersonCollections_Call) RunAndReturn(...) *CollectionRepo_CountPersonCollections_Call

type CollectionRepo_Expecter

+ func (_e *CollectionRepo_Expecter) AddPersonCollection(ctx interface{}, userID interface{}, cat interface{}, targetID interface{}) *CollectionRepo_AddPersonCollection_Call

+ func (_e *CollectionRepo_Expecter) CountPersonCollections(ctx interface{}, userID interface{}, cat interface{}) *CollectionRepo_CountPersonCollections_Call

+ func (_e *CollectionRepo_Expecter) GetPersonCollection(ctx interface{}, userID interface{}, cat interface{}, targetID interface{}) *CollectionRepo_GetPersonCollection_Call

+ func (_e *CollectionRepo_Expecter) ListPersonCollection(ctx interface{}, userID interface{}, cat interface{}, limit interface{}, ...) *CollectionRepo_ListPersonCollection_Call

+ func (_e *CollectionRepo_Expecter) RemovePersonCollection(ctx interface{}, userID interface{}, cat interface{}, targetID interface{}) *CollectionRepo_RemovePersonCollection_Call

+ type CollectionRepo_GetPersonCollection_Call struct

+ func (_c *CollectionRepo_GetPersonCollection_Call) Return(_a0 collection.UserPersonCollection, _a1 error) *CollectionRepo_GetPersonCollection_Call

+ func (_c *CollectionRepo_GetPersonCollection_Call) Run(...) *CollectionRepo_GetPersonCollection_Call

+ func (_c *CollectionRepo_GetPersonCollection_Call) RunAndReturn(...) *CollectionRepo_GetPersonCollection_Call

+ type CollectionRepo_ListPersonCollection_Call struct

+ func (_c *CollectionRepo_ListPersonCollection_Call) Return(_a0 []collection.UserPersonCollection, _a1 error) *CollectionRepo_ListPersonCollection_Call

+ func (_c *CollectionRepo_ListPersonCollection_Call) Run(...) *CollectionRepo_ListPersonCollection_Call

+ func (_c *CollectionRepo_ListPersonCollection_Call) RunAndReturn(...) *CollectionRepo_ListPersonCollection_Call

+ type CollectionRepo_RemovePersonCollection_Call struct

+ func (_c *CollectionRepo_RemovePersonCollection_Call) Return(_a0 error) *CollectionRepo_RemovePersonCollection_Call

+ func (_c *CollectionRepo_RemovePersonCollection_Call) Run(...) *CollectionRepo_RemovePersonCollection_Call

+ func (_c *CollectionRepo_RemovePersonCollection_Call) RunAndReturn(...) *CollectionRepo_RemovePersonCollection_Call

type SubjectCachedRepo

+ func (_m *SubjectCachedRepo) Browse(ctx context.Context, filter subject.BrowseFilter, limit int, offset int) ([]model.Subject, error)

+ func (_m *SubjectCachedRepo) Count(ctx context.Context, filter subject.BrowseFilter) (int64, error)

+ type SubjectCachedRepo_Browse_Call struct

+ func (_c *SubjectCachedRepo_Browse_Call) Return(_a0 []model.Subject, _a1 error) *SubjectCachedRepo_Browse_Call

+ func (_c *SubjectCachedRepo_Browse_Call) Run(...) *SubjectCachedRepo_Browse_Call

+ func (_c *SubjectCachedRepo_Browse_Call) RunAndReturn(...) *SubjectCachedRepo_Browse_Call

+ type SubjectCachedRepo_Count_Call struct

+ func (_c *SubjectCachedRepo_Count_Call) Return(_a0 int64, _a1 error) *SubjectCachedRepo_Count_Call

+ func (_c *SubjectCachedRepo_Count_Call) Run(run func(ctx context.Context, filter subject.BrowseFilter)) *SubjectCachedRepo_Count_Call

+ func (_c *SubjectCachedRepo_Count_Call) RunAndReturn(run func(context.Context, subject.BrowseFilter) (int64, error)) *SubjectCachedRepo_Count_Call

type SubjectCachedRepo_Expecter

+ func (_e *SubjectCachedRepo_Expecter) Browse(ctx interface{}, filter interface{}, limit interface{}, offset interface{}) *SubjectCachedRepo_Browse_Call

+ func (_e *SubjectCachedRepo_Expecter) Count(ctx interface{}, filter interface{}) *SubjectCachedRepo_Count_Call

type SubjectRepo

+ func (_m *SubjectRepo) Browse(ctx context.Context, filter subject.BrowseFilter, limit int, offset int) ([]model.Subject, error)

+ func (_m *SubjectRepo) Count(ctx context.Context, filter subject.BrowseFilter) (int64, error)

+ type SubjectRepo_Browse_Call struct

+ func (_c *SubjectRepo_Browse_Call) Return(_a0 []model.Subject, _a1 error) *SubjectRepo_Browse_Call

+ func (_c *SubjectRepo_Browse_Call) Run(...) *SubjectRepo_Browse_Call

+ func (_c *SubjectRepo_Browse_Call) RunAndReturn(...) *SubjectRepo_Browse_Call

+ type SubjectRepo_Count_Call struct

+ func (_c *SubjectRepo_Count_Call) Return(_a0 int64, _a1 error) *SubjectRepo_Count_Call

+ func (_c *SubjectRepo_Count_Call) Run(run func(ctx context.Context, filter subject.BrowseFilter)) *SubjectRepo_Count_Call

+ func (_c *SubjectRepo_Count_Call) RunAndReturn(run func(context.Context, subject.BrowseFilter) (int64, error)) *SubjectRepo_Count_Call

type SubjectRepo_Expecter

+ func (_e *SubjectRepo_Expecter) Browse(ctx interface{}, filter interface{}, limit interface{}, offset interface{}) *SubjectRepo_Browse_Call

+ func (_e *SubjectRepo_Expecter) Count(ctx interface{}, filter interface{}) *SubjectRepo_Count_Call

type UserRepo

+ func (_m *UserRepo) GetFullUser(ctx context.Context, userID uint32) (user.FullUser, error)

type UserRepo_Expecter

+ func (_e *UserRepo_Expecter) GetFullUser(ctx interface{}, userID interface{}) *UserRepo_GetFullUser_Call

+ type UserRepo_GetFullUser_Call struct

+ func (_c *UserRepo_GetFullUser_Call) Return(_a0 user.FullUser, _a1 error) *UserRepo_GetFullUser_Call

+ func (_c *UserRepo_GetFullUser_Call) Run(run func(ctx context.Context, userID uint32)) *UserRepo_GetFullUser_Call

+ func (_c *UserRepo_GetFullUser_Call) RunAndReturn(run func(context.Context, uint32) (user.FullUser, error)) *UserRepo_GetFullUser_Call

May 3, 2023

Changes in this version

type CollectionRepo

+ func (_m *CollectionRepo) UpdateOrCreateSubjectCollection(ctx context.Context, userID uint32, subjectID uint32, at time.Time, ip string, ...) error

type CollectionRepo_Expecter

+ func (_e *CollectionRepo_Expecter) UpdateOrCreateSubjectCollection(ctx interface{}, userID interface{}, subjectID interface{}, at interface{}, ...) *CollectionRepo_UpdateOrCreateSubjectCollection_Call

+ type CollectionRepo_UpdateOrCreateSubjectCollection_Call struct

+ func (_c *CollectionRepo_UpdateOrCreateSubjectCollection_Call) Return(_a0 error) *CollectionRepo_UpdateOrCreateSubjectCollection_Call

+ func (_c *CollectionRepo_UpdateOrCreateSubjectCollection_Call) Run(...) *CollectionRepo_UpdateOrCreateSubjectCollection_Call

+ func (_c *CollectionRepo_UpdateOrCreateSubjectCollection_Call) RunAndReturn(run func(context.Context, uint32, uint32, time.Time, string, ...) error) *CollectionRepo_UpdateOrCreateSubjectCollection_Call

Mar 28, 2023

Changes in this version

type IndexRepo

+ func (_m *IndexRepo) AddIndexCollect(ctx context.Context, id uint32, uid uint32) error

+ func (_m *IndexRepo) DeleteIndexCollect(ctx context.Context, id uint32, uid uint32) error

+ func (_m *IndexRepo) GetIndexCollect(ctx context.Context, id uint32, uid uint32) (*index.IndexCollect, error)

+ type IndexRepo_AddIndexCollect_Call struct

+ func (_c *IndexRepo_AddIndexCollect_Call) Return(_a0 error) *IndexRepo_AddIndexCollect_Call

+ func (_c *IndexRepo_AddIndexCollect_Call) Run(run func(ctx context.Context, id uint32, uid uint32)) *IndexRepo_AddIndexCollect_Call

+ func (_c *IndexRepo_AddIndexCollect_Call) RunAndReturn(run func(context.Context, uint32, uint32) error) *IndexRepo_AddIndexCollect_Call

+ type IndexRepo_DeleteIndexCollect_Call struct

+ func (_c *IndexRepo_DeleteIndexCollect_Call) Return(_a0 error) *IndexRepo_DeleteIndexCollect_Call

+ func (_c *IndexRepo_DeleteIndexCollect_Call) Run(run func(ctx context.Context, id uint32, uid uint32)) *IndexRepo_DeleteIndexCollect_Call

+ func (_c *IndexRepo_DeleteIndexCollect_Call) RunAndReturn(run func(context.Context, uint32, uint32) error) *IndexRepo_DeleteIndexCollect_Call

type IndexRepo_Expecter

+ func (_e *IndexRepo_Expecter) AddIndexCollect(ctx interface{}, id interface{}, uid interface{}) *IndexRepo_AddIndexCollect_Call

+ func (_e *IndexRepo_Expecter) DeleteIndexCollect(ctx interface{}, id interface{}, uid interface{}) *IndexRepo_DeleteIndexCollect_Call

+ func (_e *IndexRepo_Expecter) GetIndexCollect(ctx interface{}, id interface{}, uid interface{}) *IndexRepo_GetIndexCollect_Call

+ type IndexRepo_GetIndexCollect_Call struct

+ func (_c *IndexRepo_GetIndexCollect_Call) Return(_a0 *index.IndexCollect, _a1 error) *IndexRepo_GetIndexCollect_Call

+ func (_c *IndexRepo_GetIndexCollect_Call) Run(run func(ctx context.Context, id uint32, uid uint32)) *IndexRepo_GetIndexCollect_Call

+ func (_c *IndexRepo_GetIndexCollect_Call) RunAndReturn(run func(context.Context, uint32, uint32) (*index.IndexCollect, error)) *IndexRepo_GetIndexCollect_Call

Feb 14, 2023

Changes in this version

type AuthRepo_CreateAccessToken_Call

+ func (_c *AuthRepo_CreateAccessToken_Call) RunAndReturn(run func(context.Context, uint32, string, time.Duration) (string, error)) *AuthRepo_CreateAccessToken_Call

type AuthRepo_DeleteAccessToken_Call

+ func (_c *AuthRepo_DeleteAccessToken_Call) RunAndReturn(run func(context.Context, uint32) (bool, error)) *AuthRepo_DeleteAccessToken_Call

type AuthRepo_GetByEmail_Call

+ func (_c *AuthRepo_GetByEmail_Call) RunAndReturn(run func(context.Context, string) (auth.UserInfo, []byte, error)) *AuthRepo_GetByEmail_Call

type AuthRepo_GetByToken_Call

+ func (_c *AuthRepo_GetByToken_Call) RunAndReturn(run func(context.Context, string) (auth.UserInfo, error)) *AuthRepo_GetByToken_Call

type AuthRepo_GetPermission_Call

+ func (_c *AuthRepo_GetPermission_Call) RunAndReturn(run func(context.Context, uint8) (auth.Permission, error)) *AuthRepo_GetPermission_Call

type AuthRepo_GetTokenByID_Call

+ func (_c *AuthRepo_GetTokenByID_Call) RunAndReturn(run func(context.Context, uint32) (auth.AccessToken, error)) *AuthRepo_GetTokenByID_Call

type AuthRepo_ListAccessToken_Call

+ func (_c *AuthRepo_ListAccessToken_Call) RunAndReturn(run func(context.Context, uint32) ([]auth.AccessToken, error)) *AuthRepo_ListAccessToken_Call

type AuthService_ComparePassword_Call

+ func (_c *AuthService_ComparePassword_Call) RunAndReturn(run func([]byte, string) (bool, error)) *AuthService_ComparePassword_Call

type AuthService_CreateAccessToken_Call

+ func (_c *AuthService_CreateAccessToken_Call) RunAndReturn(run func(context.Context, uint32, string, time.Duration) (string, error)) *AuthService_CreateAccessToken_Call

type AuthService_DeleteAccessToken_Call

+ func (_c *AuthService_DeleteAccessToken_Call) RunAndReturn(run func(context.Context, uint32) (bool, error)) *AuthService_DeleteAccessToken_Call

type AuthService_GetByID_Call

+ func (_c *AuthService_GetByID_Call) RunAndReturn(run func(context.Context, uint32) (auth.Auth, error)) *AuthService_GetByID_Call

type AuthService_GetByToken_Call

+ func (_c *AuthService_GetByToken_Call) RunAndReturn(run func(context.Context, string) (auth.Auth, error)) *AuthService_GetByToken_Call

type AuthService_GetTokenByID_Call

+ func (_c *AuthService_GetTokenByID_Call) RunAndReturn(run func(context.Context, uint32) (auth.AccessToken, error)) *AuthService_GetTokenByID_Call

type AuthService_ListAccessToken_Call

+ func (_c *AuthService_ListAccessToken_Call) RunAndReturn(run func(context.Context, uint32) ([]auth.AccessToken, error)) *AuthService_ListAccessToken_Call

type AuthService_Login_Call

+ func (_c *AuthService_Login_Call) RunAndReturn(run func(context.Context, string, string) (auth.Auth, bool, error)) *AuthService_Login_Call

type CharacterRepo

+ func (_m *CharacterRepo) GetSubjectRelationByIDs(ctx context.Context, ids []character.SubjectCompositeID) ([]domain.SubjectCharacterRelation, error)

type CharacterRepo_Expecter

+ func (_e *CharacterRepo_Expecter) GetSubjectRelationByIDs(ctx interface{}, ids interface{}) *CharacterRepo_GetSubjectRelationByIDs_Call

type CharacterRepo_GetByIDs_Call

+ func (_c *CharacterRepo_GetByIDs_Call) RunAndReturn(run func(context.Context, []uint32) (map[uint32]model.Character, error)) *CharacterRepo_GetByIDs_Call

type CharacterRepo_GetPersonRelated_Call

+ func (_c *CharacterRepo_GetPersonRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.PersonCharacterRelation, error)) *CharacterRepo_GetPersonRelated_Call

type CharacterRepo_GetSubjectRelated_Call

+ func (_c *CharacterRepo_GetSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectCharacterRelation, error)) *CharacterRepo_GetSubjectRelated_Call

+ type CharacterRepo_GetSubjectRelationByIDs_Call struct

+ func (_c *CharacterRepo_GetSubjectRelationByIDs_Call) Return(_a0 []domain.SubjectCharacterRelation, _a1 error) *CharacterRepo_GetSubjectRelationByIDs_Call

+ func (_c *CharacterRepo_GetSubjectRelationByIDs_Call) Run(run func(ctx context.Context, ids []character.SubjectCompositeID)) *CharacterRepo_GetSubjectRelationByIDs_Call

+ func (_c *CharacterRepo_GetSubjectRelationByIDs_Call) RunAndReturn(...) *CharacterRepo_GetSubjectRelationByIDs_Call

type CharacterRepo_Get_Call

+ func (_c *CharacterRepo_Get_Call) RunAndReturn(run func(context.Context, uint32) (model.Character, error)) *CharacterRepo_Get_Call

type CollectionRepo_CountSubjectCollections_Call

+ func (_c *CollectionRepo_CountSubjectCollections_Call) RunAndReturn(...) *CollectionRepo_CountSubjectCollections_Call

type CollectionRepo_GetSubjectCollection_Call

+ func (_c *CollectionRepo_GetSubjectCollection_Call) RunAndReturn(...) *CollectionRepo_GetSubjectCollection_Call

type CollectionRepo_GetSubjectEpisodesCollection_Call

+ func (_c *CollectionRepo_GetSubjectEpisodesCollection_Call) RunAndReturn(...) *CollectionRepo_GetSubjectEpisodesCollection_Call

type CollectionRepo_ListSubjectCollection_Call

+ func (_c *CollectionRepo_ListSubjectCollection_Call) RunAndReturn(...) *CollectionRepo_ListSubjectCollection_Call

type CollectionRepo_UpdateEpisodeCollection_Call

+ func (_c *CollectionRepo_UpdateEpisodeCollection_Call) RunAndReturn(...) *CollectionRepo_UpdateEpisodeCollection_Call

type CollectionRepo_UpdateSubjectCollection_Call

+ func (_c *CollectionRepo_UpdateSubjectCollection_Call) RunAndReturn(run func(context.Context, uint32, uint32, time.Time, string, ...) error) *CollectionRepo_UpdateSubjectCollection_Call

type CollectionRepo_WithQuery_Call

+ func (_c *CollectionRepo_WithQuery_Call) RunAndReturn(run func(*query.Query) collections.Repo) *CollectionRepo_WithQuery_Call

type EpisodeRepo_Count_Call

+ func (_c *EpisodeRepo_Count_Call) RunAndReturn(run func(context.Context, uint32, episode.Filter) (int64, error)) *EpisodeRepo_Count_Call

type EpisodeRepo_Get_Call

+ func (_c *EpisodeRepo_Get_Call) RunAndReturn(run func(context.Context, uint32) (episode.Episode, error)) *EpisodeRepo_Get_Call

type EpisodeRepo_List_Call

+ func (_c *EpisodeRepo_List_Call) RunAndReturn(...) *EpisodeRepo_List_Call

type EpisodeRepo_WithQuery_Call

+ func (_c *EpisodeRepo_WithQuery_Call) RunAndReturn(run func(*query.Query) episode.Repo) *EpisodeRepo_WithQuery_Call

type IndexRepo_AddOrUpdateIndexSubject_Call

+ func (_c *IndexRepo_AddOrUpdateIndexSubject_Call) RunAndReturn(...) *IndexRepo_AddOrUpdateIndexSubject_Call

type IndexRepo_CountSubjects_Call

+ func (_c *IndexRepo_CountSubjects_Call) RunAndReturn(run func(context.Context, uint32, uint8) (int64, error)) *IndexRepo_CountSubjects_Call

type IndexRepo_DeleteIndexSubject_Call

+ func (_c *IndexRepo_DeleteIndexSubject_Call) RunAndReturn(run func(context.Context, uint32, uint32) error) *IndexRepo_DeleteIndexSubject_Call

type IndexRepo_Delete_Call

+ func (_c *IndexRepo_Delete_Call) RunAndReturn(run func(context.Context, uint32) error) *IndexRepo_Delete_Call

type IndexRepo_Get_Call

+ func (_c *IndexRepo_Get_Call) RunAndReturn(run func(context.Context, uint32) (model.Index, error)) *IndexRepo_Get_Call

type IndexRepo_ListSubjects_Call

+ func (_c *IndexRepo_ListSubjects_Call) RunAndReturn(run func(context.Context, uint32, uint8, int, int) ([]index.Subject, error)) *IndexRepo_ListSubjects_Call

type IndexRepo_New_Call

+ func (_c *IndexRepo_New_Call) RunAndReturn(run func(context.Context, *model.Index) error) *IndexRepo_New_Call

type IndexRepo_Update_Call

+ func (_c *IndexRepo_Update_Call) RunAndReturn(run func(context.Context, uint32, string, string) error) *IndexRepo_Update_Call

type NotificationRepo_Count_Call

+ func (_c *NotificationRepo_Count_Call) RunAndReturn(run func(context.Context, uint32) (int64, error)) *NotificationRepo_Count_Call

type PersonRepo_GetByIDs_Call

+ func (_c *PersonRepo_GetByIDs_Call) RunAndReturn(run func(context.Context, []uint32) (map[uint32]model.Person, error)) *PersonRepo_GetByIDs_Call

type PersonRepo_GetCharacterRelated_Call

+ func (_c *PersonRepo_GetCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.PersonCharacterRelation, error)) *PersonRepo_GetCharacterRelated_Call

type PersonRepo_GetSubjectRelated_Call

+ func (_c *PersonRepo_GetSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectPersonRelation, error)) *PersonRepo_GetSubjectRelated_Call

type PersonRepo_Get_Call

+ func (_c *PersonRepo_Get_Call) RunAndReturn(run func(context.Context, uint32) (model.Person, error)) *PersonRepo_Get_Call

type PersonService_GetByIDs_Call

+ func (_c *PersonService_GetByIDs_Call) RunAndReturn(run func(context.Context, []uint32) (map[uint32]model.Person, error)) *PersonService_GetByIDs_Call

type PersonService_GetCharacterRelated_Call

+ func (_c *PersonService_GetCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.PersonCharacterRelation, error)) *PersonService_GetCharacterRelated_Call

type PersonService_GetSubjectRelated_Call

+ func (_c *PersonService_GetSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectPersonRelation, error)) *PersonService_GetSubjectRelated_Call

type PersonService_Get_Call

+ func (_c *PersonService_Get_Call) RunAndReturn(run func(context.Context, uint32) (model.Person, error)) *PersonService_Get_Call

type PrivateMessageRepo_CountByFolder_Call

+ func (_c *PrivateMessageRepo_CountByFolder_Call) RunAndReturn(run func(context.Context, uint32, pm.FolderType) (int64, error)) *PrivateMessageRepo_CountByFolder_Call

type PrivateMessageRepo_CountTypes_Call

+ func (_c *PrivateMessageRepo_CountTypes_Call) RunAndReturn(run func(context.Context, uint32) (pm.PrivateMessageTypeCounts, error)) *PrivateMessageRepo_CountTypes_Call

type PrivateMessageRepo_Create_Call

+ func (_c *PrivateMessageRepo_Create_Call) RunAndReturn(...) *PrivateMessageRepo_Create_Call

type PrivateMessageRepo_Delete_Call

+ func (_c *PrivateMessageRepo_Delete_Call) RunAndReturn(run func(context.Context, uint32, []uint32) error) *PrivateMessageRepo_Delete_Call

type PrivateMessageRepo_ListRecentContact_Call

+ func (_c *PrivateMessageRepo_ListRecentContact_Call) RunAndReturn(run func(context.Context, uint32) ([]uint32, error)) *PrivateMessageRepo_ListRecentContact_Call

type PrivateMessageRepo_ListRelated_Call

+ func (_c *PrivateMessageRepo_ListRelated_Call) RunAndReturn(run func(context.Context, uint32, uint32) ([]pm.PrivateMessage, error)) *PrivateMessageRepo_ListRelated_Call

type PrivateMessageRepo_List_Call

+ func (_c *PrivateMessageRepo_List_Call) RunAndReturn(...) *PrivateMessageRepo_List_Call

type PrivateMessageRepo_MarkRead_Call

+ func (_c *PrivateMessageRepo_MarkRead_Call) RunAndReturn(run func(context.Context, uint32, uint32) error) *PrivateMessageRepo_MarkRead_Call

type RedisCache_Del_Call

+ func (_c *RedisCache_Del_Call) RunAndReturn(run func(context.Context, ...string) error) *RedisCache_Del_Call

type RedisCache_Get_Call

+ func (_c *RedisCache_Get_Call) RunAndReturn(run func(context.Context, string, interface{}) (bool, error)) *RedisCache_Get_Call

type RedisCache_Set_Call

+ func (_c *RedisCache_Set_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) error) *RedisCache_Set_Call

type RevisionRepo_CountCharacterRelated_Call

+ func (_c *RevisionRepo_CountCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32) (int64, error)) *RevisionRepo_CountCharacterRelated_Call

type RevisionRepo_CountEpisodeRelated_Call

+ func (_c *RevisionRepo_CountEpisodeRelated_Call) RunAndReturn(run func(context.Context, uint32) (int64, error)) *RevisionRepo_CountEpisodeRelated_Call

type RevisionRepo_CountPersonRelated_Call

+ func (_c *RevisionRepo_CountPersonRelated_Call) RunAndReturn(run func(context.Context, uint32) (int64, error)) *RevisionRepo_CountPersonRelated_Call

type RevisionRepo_CountSubjectRelated_Call

+ func (_c *RevisionRepo_CountSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) (int64, error)) *RevisionRepo_CountSubjectRelated_Call

type RevisionRepo_GetCharacterRelated_Call

+ func (_c *RevisionRepo_GetCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32) (model.CharacterRevision, error)) *RevisionRepo_GetCharacterRelated_Call

type RevisionRepo_GetEpisodeRelated_Call

+ func (_c *RevisionRepo_GetEpisodeRelated_Call) RunAndReturn(run func(context.Context, uint32) (model.EpisodeRevision, error)) *RevisionRepo_GetEpisodeRelated_Call

type RevisionRepo_GetPersonRelated_Call

+ func (_c *RevisionRepo_GetPersonRelated_Call) RunAndReturn(run func(context.Context, uint32) (model.PersonRevision, error)) *RevisionRepo_GetPersonRelated_Call

type RevisionRepo_GetSubjectRelated_Call

+ func (_c *RevisionRepo_GetSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) (model.SubjectRevision, error)) *RevisionRepo_GetSubjectRelated_Call

type RevisionRepo_ListCharacterRelated_Call

+ func (_c *RevisionRepo_ListCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32, int, int) ([]model.CharacterRevision, error)) *RevisionRepo_ListCharacterRelated_Call

type RevisionRepo_ListEpisodeRelated_Call

+ func (_c *RevisionRepo_ListEpisodeRelated_Call) RunAndReturn(run func(context.Context, uint32, int, int) ([]model.EpisodeRevision, error)) *RevisionRepo_ListEpisodeRelated_Call

type RevisionRepo_ListPersonRelated_Call

+ func (_c *RevisionRepo_ListPersonRelated_Call) RunAndReturn(run func(context.Context, uint32, int, int) ([]model.PersonRevision, error)) *RevisionRepo_ListPersonRelated_Call

type RevisionRepo_ListSubjectRelated_Call

+ func (_c *RevisionRepo_ListSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32, int, int) ([]model.SubjectRevision, error)) *RevisionRepo_ListSubjectRelated_Call

type SearchClient_Close_Call

+ func (_c *SearchClient_Close_Call) RunAndReturn(run func()) *SearchClient_Close_Call

type SearchClient_Handle_Call

+ func (_c *SearchClient_Handle_Call) RunAndReturn(run func(echo.Context) error) *SearchClient_Handle_Call

type SearchClient_OnSubjectDelete_Call

+ func (_c *SearchClient_OnSubjectDelete_Call) RunAndReturn(run func(context.Context, uint32) error) *SearchClient_OnSubjectDelete_Call

type SearchClient_OnSubjectUpdate_Call

+ func (_c *SearchClient_OnSubjectUpdate_Call) RunAndReturn(run func(context.Context, uint32) error) *SearchClient_OnSubjectUpdate_Call

type SessionManager_Create_Call

+ func (_c *SessionManager_Create_Call) RunAndReturn(run func(context.Context, auth.Auth) (string, session.Session, error)) *SessionManager_Create_Call

type SessionManager_Get_Call

+ func (_c *SessionManager_Get_Call) RunAndReturn(run func(context.Context, string) (session.Session, error)) *SessionManager_Get_Call

type SessionManager_RevokeUser_Call

+ func (_c *SessionManager_RevokeUser_Call) RunAndReturn(run func(context.Context, uint32) error) *SessionManager_RevokeUser_Call

type SessionManager_Revoke_Call

+ func (_c *SessionManager_Revoke_Call) RunAndReturn(run func(context.Context, string) error) *SessionManager_Revoke_Call

type SessionRepo_Create_Call

+ func (_c *SessionRepo_Create_Call) RunAndReturn(...) *SessionRepo_Create_Call

type SessionRepo_Get_Call

+ func (_c *SessionRepo_Get_Call) RunAndReturn(run func(context.Context, string) (session.Session, error)) *SessionRepo_Get_Call

type SessionRepo_RevokeUser_Call

+ func (_c *SessionRepo_RevokeUser_Call) RunAndReturn(run func(context.Context, uint32) ([]string, error)) *SessionRepo_RevokeUser_Call

type SessionRepo_Revoke_Call

+ func (_c *SessionRepo_Revoke_Call) RunAndReturn(run func(context.Context, string) error) *SessionRepo_Revoke_Call

type SubjectCachedRepo_GetActors_Call

+ func (_c *SubjectCachedRepo_GetActors_Call) RunAndReturn(run func(context.Context, uint32, []uint32) (map[uint32][]uint32, error)) *SubjectCachedRepo_GetActors_Call

type SubjectCachedRepo_GetByIDs_Call

+ func (_c *SubjectCachedRepo_GetByIDs_Call) RunAndReturn(...) *SubjectCachedRepo_GetByIDs_Call

type SubjectCachedRepo_GetCharacterRelated_Call

+ func (_c *SubjectCachedRepo_GetCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectCharacterRelation, error)) *SubjectCachedRepo_GetCharacterRelated_Call

type SubjectCachedRepo_GetPersonRelated_Call

+ func (_c *SubjectCachedRepo_GetPersonRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectPersonRelation, error)) *SubjectCachedRepo_GetPersonRelated_Call

type SubjectCachedRepo_GetSubjectRelated_Call

+ func (_c *SubjectCachedRepo_GetSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectInternalRelation, error)) *SubjectCachedRepo_GetSubjectRelated_Call

type SubjectCachedRepo_Get_Call

+ func (_c *SubjectCachedRepo_Get_Call) RunAndReturn(run func(context.Context, uint32, subject.Filter) (model.Subject, error)) *SubjectCachedRepo_Get_Call

type SubjectRepo_GetActors_Call

+ func (_c *SubjectRepo_GetActors_Call) RunAndReturn(run func(context.Context, uint32, []uint32) (map[uint32][]uint32, error)) *SubjectRepo_GetActors_Call

type SubjectRepo_GetByIDs_Call

+ func (_c *SubjectRepo_GetByIDs_Call) RunAndReturn(...) *SubjectRepo_GetByIDs_Call

type SubjectRepo_GetCharacterRelated_Call

+ func (_c *SubjectRepo_GetCharacterRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectCharacterRelation, error)) *SubjectRepo_GetCharacterRelated_Call

type SubjectRepo_GetPersonRelated_Call

+ func (_c *SubjectRepo_GetPersonRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectPersonRelation, error)) *SubjectRepo_GetPersonRelated_Call

type SubjectRepo_GetSubjectRelated_Call

+ func (_c *SubjectRepo_GetSubjectRelated_Call) RunAndReturn(run func(context.Context, uint32) ([]domain.SubjectInternalRelation, error)) *SubjectRepo_GetSubjectRelated_Call

type SubjectRepo_Get_Call

+ func (_c *SubjectRepo_Get_Call) RunAndReturn(run func(context.Context, uint32, subject.Filter) (model.Subject, error)) *SubjectRepo_Get_Call

type TimeLineService_ChangeEpisodeStatus_Call

+ func (_c *TimeLineService_ChangeEpisodeStatus_Call) RunAndReturn(run func(context.Context, auth.Auth, model.Subject, episode.Episode) error) *TimeLineService_ChangeEpisodeStatus_Call

type TimeLineService_ChangeSubjectCollection_Call

+ func (_c *TimeLineService_ChangeSubjectCollection_Call) RunAndReturn(...) *TimeLineService_ChangeSubjectCollection_Call

type TimeLineService_ChangeSubjectProgress_Call

+ func (_c *TimeLineService_ChangeSubjectProgress_Call) RunAndReturn(run func(context.Context, uint32, model.Subject, uint32, uint32) error) *TimeLineService_ChangeSubjectProgress_Call

type UserRepo_CheckIsFriendToOthers_Call

+ func (_c *UserRepo_CheckIsFriendToOthers_Call) RunAndReturn(run func(context.Context, uint32, ...uint32) (bool, error)) *UserRepo_CheckIsFriendToOthers_Call

type UserRepo_GetByID_Call

+ func (_c *UserRepo_GetByID_Call) RunAndReturn(run func(context.Context, uint32) (user.User, error)) *UserRepo_GetByID_Call

type UserRepo_GetByIDs_Call

+ func (_c *UserRepo_GetByIDs_Call) RunAndReturn(run func(context.Context, []uint32) (map[uint32]user.User, error)) *UserRepo_GetByIDs_Call

type UserRepo_GetByName_Call

+ func (_c *UserRepo_GetByName_Call) RunAndReturn(run func(context.Context, string) (user.User, error)) *UserRepo_GetByName_Call

type UserRepo_GetFieldsByIDs_Call

+ func (_c *UserRepo_GetFieldsByIDs_Call) RunAndReturn(run func(context.Context, []uint32) (map[uint32]user.Fields, error)) *UserRepo_GetFieldsByIDs_Call

type UserRepo_GetFriends_Call

+ func (_c *UserRepo_GetFriends_Call) RunAndReturn(run func(context.Context, uint32) (map[uint32]user.FriendItem, error)) *UserRepo_GetFriends_Call

Jan 8, 2023

Changes in this version

type CollectionRepo_Expecter

+ func (_e *CollectionRepo_Expecter) UpdateSubjectCollection2(ctx interface{}, userID interface{}, subjectID interface{}, at interface{}, ...) *CollectionRepo_UpdateSubjectCollection2_Call

+ type CollectionRepo_UpdateSubjectCollection2_Call struct

+ func (_c *CollectionRepo_UpdateSubjectCollection2_Call) Return(_a0 error) *CollectionRepo_UpdateSubjectCollection2_Call

+ func (_c *CollectionRepo_UpdateSubjectCollection2_Call) Run(...) *CollectionRepo_UpdateSubjectCollection2_Call

+ type TimeLineService struct

+ func NewTimeLineService(t mockConstructorTestingTNewTimeLineService) *TimeLineService

+ func (_m *TimeLineService) ChangeEpisodeStatus(ctx context.Context, u auth.Auth, sbj model.Subject, _a3 episode.Episode) error

+ func (_m *TimeLineService) ChangeSubjectCollection(ctx context.Context, u uint32, sbj model.Subject, ...) error

+ func (_m *TimeLineService) ChangeSubjectProgress(ctx context.Context, u uint32, sbj model.Subject, epsUpdate uint32, ...) error

+ func (_m *TimeLineService) EXPECT() *TimeLineService_Expecter

+ type TimeLineService_ChangeEpisodeStatus_Call struct

+ func (_c *TimeLineService_ChangeEpisodeStatus_Call) Return(_a0 error) *TimeLineService_ChangeEpisodeStatus_Call

+ func (_c *TimeLineService_ChangeEpisodeStatus_Call) Run(...) *TimeLineService_ChangeEpisodeStatus_Call

+ type TimeLineService_ChangeSubjectCollection_Call struct

+ func (_c *TimeLineService_ChangeSubjectCollection_Call) Return(_a0 error) *TimeLineService_ChangeSubjectCollection_Call

+ func (_c *TimeLineService_ChangeSubjectCollection_Call) Run(run func(ctx context.Context, u uint32, sbj model.Subject, ...)) *TimeLineService_ChangeSubjectCollection_Call

+ type TimeLineService_ChangeSubjectProgress_Call struct

+ func (_c *TimeLineService_ChangeSubjectProgress_Call) Return(_a0 error) *TimeLineService_ChangeSubjectProgress_Call

+ func (_c *TimeLineService_ChangeSubjectProgress_Call) Run(...) *TimeLineService_ChangeSubjectProgress_Call

+ type TimeLineService_Expecter struct

+ func (_e *TimeLineService_Expecter) ChangeEpisodeStatus(ctx interface{}, u interface{}, sbj interface{}, _a3 interface{}) *TimeLineService_ChangeEpisodeStatus_Call

+ func (_e *TimeLineService_Expecter) ChangeSubjectCollection(ctx interface{}, u interface{}, sbj interface{}, collect interface{}, ...) *TimeLineService_ChangeSubjectCollection_Call

+ func (_e *TimeLineService_Expecter) ChangeSubjectProgress(ctx interface{}, u interface{}, sbj interface{}, epsUpdate interface{}, ...) *TimeLineService_ChangeSubjectProgress_Call

Jan 5, 2023

Changes in this version

+ type SubjectCachedRepo struct

+ func NewSubjectCachedRepo(t mockConstructorTestingTNewSubjectCachedRepo) *SubjectCachedRepo

+ func (_m *SubjectCachedRepo) EXPECT() *SubjectCachedRepo_Expecter

+ func (_m *SubjectCachedRepo) Get(ctx context.Context, id model.SubjectID, filter subject.Filter) (model.Subject, error)

+ func (_m *SubjectCachedRepo) GetActors(ctx context.Context, subjectID model.SubjectID, ...) (map[model.CharacterID][]model.PersonID, error)

+ func (_m *SubjectCachedRepo) GetByIDs(ctx context.Context, ids []model.SubjectID, filter subject.Filter) (map[model.SubjectID]model.Subject, error)

+ func (_m *SubjectCachedRepo) GetCharacterRelated(ctx context.Context, characterID model.CharacterID) ([]domain.SubjectCharacterRelation, error)

+ func (_m *SubjectCachedRepo) GetPersonRelated(ctx context.Context, personID model.PersonID) ([]domain.SubjectPersonRelation, error)

+ func (_m *SubjectCachedRepo) GetSubjectRelated(ctx context.Context, subjectID model.SubjectID) ([]domain.SubjectInternalRelation, error)

+ type SubjectCachedRepo_Expecter struct

+ func (_e *SubjectCachedRepo_Expecter) Get(ctx interface{}, id interface{}, filter interface{}) *SubjectCachedRepo_Get_Call

+ func (_e *SubjectCachedRepo_Expecter) GetActors(ctx interface{}, subjectID interface{}, characterIDs interface{}) *SubjectCachedRepo_GetActors_Call

+ func (_e *SubjectCachedRepo_Expecter) GetByIDs(ctx interface{}, ids interface{}, filter interface{}) *SubjectCachedRepo_GetByIDs_Call

+ func (_e *SubjectCachedRepo_Expecter) GetCharacterRelated(ctx interface{}, characterID interface{}) *SubjectCachedRepo_GetCharacterRelated_Call

+ func (_e *SubjectCachedRepo_Expecter) GetPersonRelated(ctx interface{}, personID interface{}) *SubjectCachedRepo_GetPersonRelated_Call

+ func (_e *SubjectCachedRepo_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *SubjectCachedRepo_GetSubjectRelated_Call

+ type SubjectCachedRepo_GetActors_Call struct

+ func (_c *SubjectCachedRepo_GetActors_Call) Return(_a0 map[model.CharacterID][]model.PersonID, _a1 error) *SubjectCachedRepo_GetActors_Call

+ func (_c *SubjectCachedRepo_GetActors_Call) Run(run func(ctx context.Context, subjectID model.SubjectID, ...)) *SubjectCachedRepo_GetActors_Call

+ type SubjectCachedRepo_GetByIDs_Call struct

+ func (_c *SubjectCachedRepo_GetByIDs_Call) Return(_a0 map[model.SubjectID]model.Subject, _a1 error) *SubjectCachedRepo_GetByIDs_Call

+ func (_c *SubjectCachedRepo_GetByIDs_Call) Run(run func(ctx context.Context, ids []model.SubjectID, filter subject.Filter)) *SubjectCachedRepo_GetByIDs_Call

+ type SubjectCachedRepo_GetCharacterRelated_Call struct

+ func (_c *SubjectCachedRepo_GetCharacterRelated_Call) Return(_a0 []domain.SubjectCharacterRelation, _a1 error) *SubjectCachedRepo_GetCharacterRelated_Call

+ func (_c *SubjectCachedRepo_GetCharacterRelated_Call) Run(run func(ctx context.Context, characterID model.CharacterID)) *SubjectCachedRepo_GetCharacterRelated_Call

+ type SubjectCachedRepo_GetPersonRelated_Call struct

+ func (_c *SubjectCachedRepo_GetPersonRelated_Call) Return(_a0 []domain.SubjectPersonRelation, _a1 error) *SubjectCachedRepo_GetPersonRelated_Call

+ func (_c *SubjectCachedRepo_GetPersonRelated_Call) Run(run func(ctx context.Context, personID model.PersonID)) *SubjectCachedRepo_GetPersonRelated_Call

+ type SubjectCachedRepo_GetSubjectRelated_Call struct

+ func (_c *SubjectCachedRepo_GetSubjectRelated_Call) Return(_a0 []domain.SubjectInternalRelation, _a1 error) *SubjectCachedRepo_GetSubjectRelated_Call

+ func (_c *SubjectCachedRepo_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID model.SubjectID)) *SubjectCachedRepo_GetSubjectRelated_Call

+ type SubjectCachedRepo_Get_Call struct

+ func (_c *SubjectCachedRepo_Get_Call) Return(_a0 model.Subject, _a1 error) *SubjectCachedRepo_Get_Call

+ func (_c *SubjectCachedRepo_Get_Call) Run(run func(ctx context.Context, id model.SubjectID, filter subject.Filter)) *SubjectCachedRepo_Get_Call

Dec 31, 2022

Changes in this version

type PersonService

+ func (_m *PersonService) GetByIDs(ctx context.Context, ids []model.PersonID) (map[model.PersonID]model.Person, error)

type PersonService_Expecter

+ func (_e *PersonService_Expecter) GetByIDs(ctx interface{}, ids interface{}) *PersonService_GetByIDs_Call

+ type PersonService_GetByIDs_Call struct

+ func (_c *PersonService_GetByIDs_Call) Return(_a0 map[model.PersonID]model.Person, _a1 error) *PersonService_GetByIDs_Call

+ func (_c *PersonService_GetByIDs_Call) Run(run func(ctx context.Context, ids []model.PersonID)) *PersonService_GetByIDs_Call

+ type Repo struct

+ func NewRepo(t mockConstructorTestingTNewRepo) *Repo

+ func (_m *Repo) Count(ctx context.Context, userID model.UserID) (int64, error)

+ func (_m *Repo) EXPECT() *Repo_Expecter

+ type Repo_Count_Call struct

+ func (_c *Repo_Count_Call) Return(_a0 int64, _a1 error) *Repo_Count_Call

+ func (_c *Repo_Count_Call) Run(run func(ctx context.Context, userID model.UserID)) *Repo_Count_Call

+ type Repo_Expecter struct

+ func (_e *Repo_Expecter) Count(ctx interface{}, userID interface{}) *Repo_Count_Call

type TimeLineRepo

+ func (_m *TimeLineRepo) ChangeEpisodeStatus(ctx context.Context, u auth.Auth, sbj model.Subject, _a3 episode.Episode) error

+ func (_m *TimeLineRepo) ChangeSubjectCollection(ctx context.Context, u auth.Auth, sbj model.Subject, ...) error

+ func (_m *TimeLineRepo) ChangeSubjectProgress(ctx context.Context, u auth.Auth, sbj model.Subject, epsUpdate uint32, ...) error

+ type TimeLineRepo_ChangeEpisodeStatus_Call struct

+ func (_c *TimeLineRepo_ChangeEpisodeStatus_Call) Return(_a0 error) *TimeLineRepo_ChangeEpisodeStatus_Call

+ func (_c *TimeLineRepo_ChangeEpisodeStatus_Call) Run(...) *TimeLineRepo_ChangeEpisodeStatus_Call

+ type TimeLineRepo_ChangeSubjectCollection_Call struct

+ func (_c *TimeLineRepo_ChangeSubjectCollection_Call) Return(_a0 error) *TimeLineRepo_ChangeSubjectCollection_Call

+ func (_c *TimeLineRepo_ChangeSubjectCollection_Call) Run(run func(ctx context.Context, u auth.Auth, sbj model.Subject, ...)) *TimeLineRepo_ChangeSubjectCollection_Call

+ type TimeLineRepo_ChangeSubjectProgress_Call struct

+ func (_c *TimeLineRepo_ChangeSubjectProgress_Call) Return(_a0 error) *TimeLineRepo_ChangeSubjectProgress_Call

+ func (_c *TimeLineRepo_ChangeSubjectProgress_Call) Run(...) *TimeLineRepo_ChangeSubjectProgress_Call

type TimeLineRepo_Expecter

+ func (_e *TimeLineRepo_Expecter) ChangeEpisodeStatus(ctx interface{}, u interface{}, sbj interface{}, _a3 interface{}) *TimeLineRepo_ChangeEpisodeStatus_Call

+ func (_e *TimeLineRepo_Expecter) ChangeSubjectCollection(ctx interface{}, u interface{}, sbj interface{}, collect interface{}, ...) *TimeLineRepo_ChangeSubjectCollection_Call

+ func (_e *TimeLineRepo_Expecter) ChangeSubjectProgress(ctx interface{}, u interface{}, sbj interface{}, epsUpdate interface{}, ...) *TimeLineRepo_ChangeSubjectProgress_Call

Dec 25, 2022

Changes in this version

type RevisionRepo

+ func (_m *RevisionRepo) CountEpisodeRelated(ctx context.Context, episodeID model.EpisodeID) (int64, error)

+ func (_m *RevisionRepo) GetEpisodeRelated(ctx context.Context, id uint32) (model.EpisodeRevision, error)

+ func (_m *RevisionRepo) ListEpisodeRelated(ctx context.Context, episodeID model.EpisodeID, limit int, offset int) ([]model.EpisodeRevision, error)

+ type RevisionRepo_CountEpisodeRelated_Call struct

+ func (_c *RevisionRepo_CountEpisodeRelated_Call) Return(_a0 int64, _a1 error) *RevisionRepo_CountEpisodeRelated_Call

+ func (_c *RevisionRepo_CountEpisodeRelated_Call) Run(run func(ctx context.Context, episodeID model.EpisodeID)) *RevisionRepo_CountEpisodeRelated_Call

type RevisionRepo_Expecter

+ func (_e *RevisionRepo_Expecter) CountEpisodeRelated(ctx interface{}, episodeID interface{}) *RevisionRepo_CountEpisodeRelated_Call

+ func (_e *RevisionRepo_Expecter) GetEpisodeRelated(ctx interface{}, id interface{}) *RevisionRepo_GetEpisodeRelated_Call

+ func (_e *RevisionRepo_Expecter) ListEpisodeRelated(ctx interface{}, episodeID interface{}, limit interface{}, offset interface{}) *RevisionRepo_ListEpisodeRelated_Call

+ type RevisionRepo_GetEpisodeRelated_Call struct

+ func (_c *RevisionRepo_GetEpisodeRelated_Call) Return(_a0 model.EpisodeRevision, _a1 error) *RevisionRepo_GetEpisodeRelated_Call

+ func (_c *RevisionRepo_GetEpisodeRelated_Call) Run(run func(ctx context.Context, id uint32)) *RevisionRepo_GetEpisodeRelated_Call

+ type RevisionRepo_ListEpisodeRelated_Call struct

+ func (_c *RevisionRepo_ListEpisodeRelated_Call) Return(_a0 []model.EpisodeRevision, _a1 error) *RevisionRepo_ListEpisodeRelated_Call

+ func (_c *RevisionRepo_ListEpisodeRelated_Call) Run(...) *RevisionRepo_ListEpisodeRelated_Call

Dec 24, 2022

Changes in this version

type SearchClient

+ func (_m *SearchClient) Close()

+ type SearchClient_Close_Call struct

+ func (_c *SearchClient_Close_Call) Return() *SearchClient_Close_Call

+ func (_c *SearchClient_Close_Call) Run(run func()) *SearchClient_Close_Call

type SearchClient_Expecter

+ func (_e *SearchClient_Expecter) Close() *SearchClient_Close_Call

Dec 20, 2022

Changes in this version

+ type NotificationRepo struct

+ func NewNotificationRepo(t mockConstructorTestingTNewNotificationRepo) *NotificationRepo

+ func (_m *NotificationRepo) Count(ctx context.Context, userID model.UserID) (int64, error)

+ func (_m *NotificationRepo) EXPECT() *NotificationRepo_Expecter

+ type NotificationRepo_Count_Call struct

+ func (_c *NotificationRepo_Count_Call) Return(_a0 int64, _a1 error) *NotificationRepo_Count_Call

+ func (_c *NotificationRepo_Count_Call) Run(run func(ctx context.Context, userID model.UserID)) *NotificationRepo_Count_Call

+ type NotificationRepo_Expecter struct

+ func (_e *NotificationRepo_Expecter) Count(ctx interface{}, userID interface{}) *NotificationRepo_Count_Call

+ type PrivateMessageRepo struct

+ func NewPrivateMessageRepo(t mockConstructorTestingTNewPrivateMessageRepo) *PrivateMessageRepo

+ func (_m *PrivateMessageRepo) CountByFolder(ctx context.Context, userID model.UserID, ...) (int64, error)

+ func (_m *PrivateMessageRepo) CountTypes(ctx context.Context, userID model.UserID) (model.PrivateMessageTypeCounts, error)

+ func (_m *PrivateMessageRepo) Create(ctx context.Context, senderID model.UserID, receiverIDs []model.UserID, ...) ([]model.PrivateMessage, error)

+ func (_m *PrivateMessageRepo) Delete(ctx context.Context, userID model.UserID, ids []model.PrivateMessageID) error

+ func (_m *PrivateMessageRepo) EXPECT() *PrivateMessageRepo_Expecter

+ func (_m *PrivateMessageRepo) List(ctx context.Context, userID model.UserID, ...) ([]model.PrivateMessageListItem, error)

+ func (_m *PrivateMessageRepo) ListRecentContact(ctx context.Context, userID model.UserID) ([]model.UserID, error)

+ func (_m *PrivateMessageRepo) ListRelated(ctx context.Context, userID model.UserID, id model.PrivateMessageID) ([]model.PrivateMessage, error)

+ func (_m *PrivateMessageRepo) MarkRead(ctx context.Context, userID model.UserID, relatedID model.PrivateMessageID) error

+ type PrivateMessageRepo_CountByFolder_Call struct

+ func (_c *PrivateMessageRepo_CountByFolder_Call) Return(_a0 int64, _a1 error) *PrivateMessageRepo_CountByFolder_Call

+ func (_c *PrivateMessageRepo_CountByFolder_Call) Run(run func(ctx context.Context, userID model.UserID, ...)) *PrivateMessageRepo_CountByFolder_Call

+ type PrivateMessageRepo_CountTypes_Call struct

+ func (_c *PrivateMessageRepo_CountTypes_Call) Return(_a0 model.PrivateMessageTypeCounts, _a1 error) *PrivateMessageRepo_CountTypes_Call

+ func (_c *PrivateMessageRepo_CountTypes_Call) Run(run func(ctx context.Context, userID model.UserID)) *PrivateMessageRepo_CountTypes_Call

+ type PrivateMessageRepo_Create_Call struct

+ func (_c *PrivateMessageRepo_Create_Call) Return(_a0 []model.PrivateMessage, _a1 error) *PrivateMessageRepo_Create_Call

+ func (_c *PrivateMessageRepo_Create_Call) Run(...) *PrivateMessageRepo_Create_Call

+ type PrivateMessageRepo_Delete_Call struct

+ func (_c *PrivateMessageRepo_Delete_Call) Return(_a0 error) *PrivateMessageRepo_Delete_Call

+ func (_c *PrivateMessageRepo_Delete_Call) Run(...) *PrivateMessageRepo_Delete_Call

+ type PrivateMessageRepo_Expecter struct

+ func (_e *PrivateMessageRepo_Expecter) CountByFolder(ctx interface{}, userID interface{}, folder interface{}) *PrivateMessageRepo_CountByFolder_Call

+ func (_e *PrivateMessageRepo_Expecter) CountTypes(ctx interface{}, userID interface{}) *PrivateMessageRepo_CountTypes_Call

+ func (_e *PrivateMessageRepo_Expecter) Create(ctx interface{}, senderID interface{}, receiverIDs interface{}, ...) *PrivateMessageRepo_Create_Call

+ func (_e *PrivateMessageRepo_Expecter) Delete(ctx interface{}, userID interface{}, ids interface{}) *PrivateMessageRepo_Delete_Call

+ func (_e *PrivateMessageRepo_Expecter) List(ctx interface{}, userID interface{}, folder interface{}, offset interface{}, ...) *PrivateMessageRepo_List_Call

+ func (_e *PrivateMessageRepo_Expecter) ListRecentContact(ctx interface{}, userID interface{}) *PrivateMessageRepo_ListRecentContact_Call

+ func (_e *PrivateMessageRepo_Expecter) ListRelated(ctx interface{}, userID interface{}, id interface{}) *PrivateMessageRepo_ListRelated_Call

+ func (_e *PrivateMessageRepo_Expecter) MarkRead(ctx interface{}, userID interface{}, relatedID interface{}) *PrivateMessageRepo_MarkRead_Call

+ type PrivateMessageRepo_ListRecentContact_Call struct

+ func (_c *PrivateMessageRepo_ListRecentContact_Call) Return(_a0 []model.UserID, _a1 error) *PrivateMessageRepo_ListRecentContact_Call

+ func (_c *PrivateMessageRepo_ListRecentContact_Call) Run(run func(ctx context.Context, userID model.UserID)) *PrivateMessageRepo_ListRecentContact_Call

+ type PrivateMessageRepo_ListRelated_Call struct

+ func (_c *PrivateMessageRepo_ListRelated_Call) Return(_a0 []model.PrivateMessage, _a1 error) *PrivateMessageRepo_ListRelated_Call

+ func (_c *PrivateMessageRepo_ListRelated_Call) Run(run func(ctx context.Context, userID model.UserID, id model.PrivateMessageID)) *PrivateMessageRepo_ListRelated_Call

+ type PrivateMessageRepo_List_Call struct

+ func (_c *PrivateMessageRepo_List_Call) Return(_a0 []model.PrivateMessageListItem, _a1 error) *PrivateMessageRepo_List_Call

+ func (_c *PrivateMessageRepo_List_Call) Run(run func(ctx context.Context, userID model.UserID, ...)) *PrivateMessageRepo_List_Call

+ type PrivateMessageRepo_MarkRead_Call struct

+ func (_c *PrivateMessageRepo_MarkRead_Call) Return(_a0 error) *PrivateMessageRepo_MarkRead_Call

+ func (_c *PrivateMessageRepo_MarkRead_Call) Run(...) *PrivateMessageRepo_MarkRead_Call

type UserRepo

+ func (_m *UserRepo) CheckIsFriendToOthers(ctx context.Context, selfID model.UserID, otherIDs ...model.UserID) (bool, error)

+ func (_m *UserRepo) GetFieldsByIDs(ctx context.Context, ids []model.UserID) (map[model.UserID]model.UserFields, error)

+ type UserRepo_CheckIsFriendToOthers_Call struct

+ func (_c *UserRepo_CheckIsFriendToOthers_Call) Return(_a0 bool, _a1 error) *UserRepo_CheckIsFriendToOthers_Call

+ func (_c *UserRepo_CheckIsFriendToOthers_Call) Run(run func(ctx context.Context, selfID model.UserID, otherIDs ...model.UserID)) *UserRepo_CheckIsFriendToOthers_Call

type UserRepo_Expecter

+ func (_e *UserRepo_Expecter) CheckIsFriendToOthers(ctx interface{}, selfID interface{}, otherIDs ...interface{}) *UserRepo_CheckIsFriendToOthers_Call

+ func (_e *UserRepo_Expecter) GetFieldsByIDs(ctx interface{}, ids interface{}) *UserRepo_GetFieldsByIDs_Call

+ type UserRepo_GetFieldsByIDs_Call struct

+ func (_c *UserRepo_GetFieldsByIDs_Call) Return(_a0 map[model.UserID]model.UserFields, _a1 error) *UserRepo_GetFieldsByIDs_Call

+ func (_c *UserRepo_GetFieldsByIDs_Call) Run(run func(ctx context.Context, ids []model.UserID)) *UserRepo_GetFieldsByIDs_Call

Oct 24, 2022

Changes in this version

type IndexRepo

+ func (_m *IndexRepo) AddOrUpdateIndexSubject(ctx context.Context, id uint32, subjectID model.SubjectID, sort uint32, ...) (*domain.IndexSubject, error)

+ func (_m *IndexRepo) Delete(ctx context.Context, id uint32) error

+ func (_m *IndexRepo) DeleteIndexSubject(ctx context.Context, id uint32, subjectID model.SubjectID) error

+ func (_m *IndexRepo) New(ctx context.Context, i *model.Index) error

+ func (_m *IndexRepo) Update(ctx context.Context, id uint32, title string, desc string) error

+ type IndexRepo_AddOrUpdateIndexSubject_Call struct

+ func (_c *IndexRepo_AddOrUpdateIndexSubject_Call) Return(_a0 *domain.IndexSubject, _a1 error) *IndexRepo_AddOrUpdateIndexSubject_Call

+ func (_c *IndexRepo_AddOrUpdateIndexSubject_Call) Run(...) *IndexRepo_AddOrUpdateIndexSubject_Call

+ type IndexRepo_DeleteIndexSubject_Call struct

+ func (_c *IndexRepo_DeleteIndexSubject_Call) Return(_a0 error) *IndexRepo_DeleteIndexSubject_Call

+ func (_c *IndexRepo_DeleteIndexSubject_Call) Run(run func(ctx context.Context, id uint32, subjectID model.SubjectID)) *IndexRepo_DeleteIndexSubject_Call

+ type IndexRepo_Delete_Call struct

+ func (_c *IndexRepo_Delete_Call) Return(_a0 error) *IndexRepo_Delete_Call

+ func (_c *IndexRepo_Delete_Call) Run(run func(ctx context.Context, id uint32)) *IndexRepo_Delete_Call

type IndexRepo_Expecter

+ func (_e *IndexRepo_Expecter) AddOrUpdateIndexSubject(ctx interface{}, id interface{}, subjectID interface{}, sort interface{}, ...) *IndexRepo_AddOrUpdateIndexSubject_Call

+ func (_e *IndexRepo_Expecter) Delete(ctx interface{}, id interface{}) *IndexRepo_Delete_Call

+ func (_e *IndexRepo_Expecter) DeleteIndexSubject(ctx interface{}, id interface{}, subjectID interface{}) *IndexRepo_DeleteIndexSubject_Call

+ func (_e *IndexRepo_Expecter) New(ctx interface{}, i interface{}) *IndexRepo_New_Call

+ func (_e *IndexRepo_Expecter) Update(ctx interface{}, id interface{}, title interface{}, desc interface{}) *IndexRepo_Update_Call

+ type IndexRepo_New_Call struct

+ func (_c *IndexRepo_New_Call) Return(_a0 error) *IndexRepo_New_Call

+ func (_c *IndexRepo_New_Call) Run(run func(ctx context.Context, i *model.Index)) *IndexRepo_New_Call

+ type IndexRepo_Update_Call struct

+ func (_c *IndexRepo_Update_Call) Return(_a0 error) *IndexRepo_Update_Call

+ func (_c *IndexRepo_Update_Call) Run(run func(ctx context.Context, id uint32, title string, desc string)) *IndexRepo_Update_Call

Sep 18, 2022

Changes in this version

type RedisCache

+ func (_m *RedisCache) GetMany(ctx context.Context, keys []string) cache.GetManyResult

+ func (_m *RedisCache) SetMany(ctx context.Context, data map[string]interface{}, ttl time.Duration) error

type RedisCache_Expecter

+ func (_e *RedisCache_Expecter) GetMany(ctx interface{}, keys interface{}) *RedisCache_GetMany_Call

+ func (_e *RedisCache_Expecter) SetMany(ctx interface{}, data interface{}, ttl interface{}) *RedisCache_SetMany_Call

+ type RedisCache_GetMany_Call struct

+ func (_c *RedisCache_GetMany_Call) Return(_a0 cache.GetManyResult) *RedisCache_GetMany_Call

+ func (_c *RedisCache_GetMany_Call) Run(run func(ctx context.Context, keys []string)) *RedisCache_GetMany_Call

+ type RedisCache_SetMany_Call struct

+ func (_c *RedisCache_SetMany_Call) Return(_a0 error) *RedisCache_SetMany_Call

+ func (_c *RedisCache_SetMany_Call) Run(run func(ctx context.Context, data map[string]interface{}, ttl time.Duration)) *RedisCache_SetMany_Call

Sep 7, 2022

Changes in this version

+ type RedisCache struct

+ func NewRedisCache(t mockConstructorTestingTNewRedisCache) *RedisCache

+ func (_m *RedisCache) Del(ctx context.Context, keys ...string) error

+ func (_m *RedisCache) EXPECT() *RedisCache_Expecter

+ func (_m *RedisCache) Get(ctx context.Context, key string, value interface{}) (bool, error)

+ func (_m *RedisCache) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error

+ type RedisCache_Del_Call struct

+ func (_c *RedisCache_Del_Call) Return(_a0 error) *RedisCache_Del_Call

+ func (_c *RedisCache_Del_Call) Run(run func(ctx context.Context, keys ...string)) *RedisCache_Del_Call

+ type RedisCache_Expecter struct

+ func (_e *RedisCache_Expecter) Del(ctx interface{}, keys ...interface{}) *RedisCache_Del_Call

+ func (_e *RedisCache_Expecter) Get(ctx interface{}, key interface{}, value interface{}) *RedisCache_Get_Call

+ func (_e *RedisCache_Expecter) Set(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *RedisCache_Set_Call

+ type RedisCache_Get_Call struct

+ func (_c *RedisCache_Get_Call) Return(_a0 bool, _a1 error) *RedisCache_Get_Call

+ func (_c *RedisCache_Get_Call) Run(run func(ctx context.Context, key string, value interface{})) *RedisCache_Get_Call

+ type RedisCache_Set_Call struct

+ func (_c *RedisCache_Set_Call) Return(_a0 error) *RedisCache_Set_Call

+ func (_c *RedisCache_Set_Call) Run(...) *RedisCache_Set_Call

Sep 1, 2022

Changes in this version

+ type TimeLineRepo struct

+ func NewTimeLineRepo(t mockConstructorTestingTNewTimeLineRepo) *TimeLineRepo

+ func (_m *TimeLineRepo) Create(ctx context.Context, tl *model.TimeLine) error

+ func (_m *TimeLineRepo) EXPECT() *TimeLineRepo_Expecter

+ func (_m *TimeLineRepo) GetByID(ctx context.Context, id model.TimeLineID) (*model.TimeLine, error)

+ func (_m *TimeLineRepo) ListByUID(ctx context.Context, uid model.UserID, limit int, since model.TimeLineID) ([]*model.TimeLine, error)

+ func (_m *TimeLineRepo) WithQuery(_a0 *query.Query) domain.TimeLineRepo

+ type TimeLineRepo_Create_Call struct

+ func (_c *TimeLineRepo_Create_Call) Return(_a0 error) *TimeLineRepo_Create_Call

+ func (_c *TimeLineRepo_Create_Call) Run(run func(ctx context.Context, tl *model.TimeLine)) *TimeLineRepo_Create_Call

+ type TimeLineRepo_Expecter struct

+ func (_e *TimeLineRepo_Expecter) Create(ctx interface{}, tl interface{}) *TimeLineRepo_Create_Call

+ func (_e *TimeLineRepo_Expecter) GetByID(ctx interface{}, id interface{}) *TimeLineRepo_GetByID_Call

+ func (_e *TimeLineRepo_Expecter) ListByUID(ctx interface{}, uid interface{}, limit interface{}, since interface{}) *TimeLineRepo_ListByUID_Call

+ func (_e *TimeLineRepo_Expecter) WithQuery(_a0 interface{}) *TimeLineRepo_WithQuery_Call

+ type TimeLineRepo_GetByID_Call struct

+ func (_c *TimeLineRepo_GetByID_Call) Return(_a0 *model.TimeLine, _a1 error) *TimeLineRepo_GetByID_Call

+ func (_c *TimeLineRepo_GetByID_Call) Run(run func(ctx context.Context, id model.TimeLineID)) *TimeLineRepo_GetByID_Call

+ type TimeLineRepo_ListByUID_Call struct

+ func (_c *TimeLineRepo_ListByUID_Call) Return(_a0 []*model.TimeLine, _a1 error) *TimeLineRepo_ListByUID_Call

+ func (_c *TimeLineRepo_ListByUID_Call) Run(...) *TimeLineRepo_ListByUID_Call

+ type TimeLineRepo_WithQuery_Call struct

+ func (_c *TimeLineRepo_WithQuery_Call) Return(_a0 domain.TimeLineRepo) *TimeLineRepo_WithQuery_Call

+ func (_c *TimeLineRepo_WithQuery_Call) Run(run func(_a0 *query.Query)) *TimeLineRepo_WithQuery_Call

Aug 28, 2022

Changes in this version

+ type SearchClient struct

+ func NewSearchClient(t mockConstructorTestingTNewSearchClient) *SearchClient

+ func (_m *SearchClient) EXPECT() *SearchClient_Expecter

+ func (_m *SearchClient) Handle(ctx *fiber.Ctx, auth *accessor.Accessor) error

+ func (_m *SearchClient) OnSubjectDelete(ctx context.Context, id model.SubjectID) error

+ func (_m *SearchClient) OnSubjectUpdate(ctx context.Context, id model.SubjectID) error

+ type SearchClient_Expecter struct

+ func (_e *SearchClient_Expecter) Handle(ctx interface{}, auth interface{}) *SearchClient_Handle_Call

+ func (_e *SearchClient_Expecter) OnSubjectDelete(ctx interface{}, id interface{}) *SearchClient_OnSubjectDelete_Call

+ func (_e *SearchClient_Expecter) OnSubjectUpdate(ctx interface{}, id interface{}) *SearchClient_OnSubjectUpdate_Call

+ type SearchClient_Handle_Call struct

+ func (_c *SearchClient_Handle_Call) Return(_a0 error) *SearchClient_Handle_Call

+ func (_c *SearchClient_Handle_Call) Run(run func(ctx *fiber.Ctx, auth *accessor.Accessor)) *SearchClient_Handle_Call

+ type SearchClient_OnSubjectDelete_Call struct

+ func (_c *SearchClient_OnSubjectDelete_Call) Return(_a0 error) *SearchClient_OnSubjectDelete_Call

+ func (_c *SearchClient_OnSubjectDelete_Call) Run(run func(ctx context.Context, id model.SubjectID)) *SearchClient_OnSubjectDelete_Call

+ type SearchClient_OnSubjectUpdate_Call struct

+ func (_c *SearchClient_OnSubjectUpdate_Call) Return(_a0 error) *SearchClient_OnSubjectUpdate_Call

+ func (_c *SearchClient_OnSubjectUpdate_Call) Run(run func(ctx context.Context, id model.SubjectID)) *SearchClient_OnSubjectUpdate_Call

Aug 23, 2022

Changes in this version

type GroupRepo

+ func (_m *GroupRepo) GetByID(ctx context.Context, id model.GroupID) (model.Group, error)

type GroupRepo_Expecter

+ func (_e *GroupRepo_Expecter) GetByID(ctx interface{}, id interface{}) *GroupRepo_GetByID_Call

+ type GroupRepo_GetByID_Call struct

+ func (_c *GroupRepo_GetByID_Call) Return(_a0 model.Group, _a1 error) *GroupRepo_GetByID_Call

+ func (_c *GroupRepo_GetByID_Call) Run(run func(ctx context.Context, id model.GroupID)) *GroupRepo_GetByID_Call

Aug 13, 2022

Changes in this version

type CollectionRepo

+ func (_m *CollectionRepo) UpdateEpisodeCollection(ctx context.Context, userID model.UserID, subjectID model.SubjectID, ...) (model.UserSubjectEpisodesCollection, error)

+ func (_m *CollectionRepo) UpdateSubjectCollection(ctx context.Context, userID model.UserID, subjectID model.SubjectID, ...) error

+ func (_m *CollectionRepo) WithQuery(_a0 *query.Query) domain.CollectionRepo

type CollectionRepo_Expecter

+ func (_e *CollectionRepo_Expecter) UpdateEpisodeCollection(ctx interface{}, userID interface{}, subjectID interface{}, ...) *CollectionRepo_UpdateEpisodeCollection_Call

+ func (_e *CollectionRepo_Expecter) UpdateSubjectCollection(ctx interface{}, userID interface{}, subjectID interface{}, data interface{}, ...) *CollectionRepo_UpdateSubjectCollection_Call

+ func (_e *CollectionRepo_Expecter) WithQuery(_a0 interface{}) *CollectionRepo_WithQuery_Call

+ type CollectionRepo_UpdateEpisodeCollection_Call struct

+ func (_c *CollectionRepo_UpdateEpisodeCollection_Call) Return(_a0 model.UserSubjectEpisodesCollection, _a1 error) *CollectionRepo_UpdateEpisodeCollection_Call

+ func (_c *CollectionRepo_UpdateEpisodeCollection_Call) Run(...) *CollectionRepo_UpdateEpisodeCollection_Call

+ type CollectionRepo_UpdateSubjectCollection_Call struct

+ func (_c *CollectionRepo_UpdateSubjectCollection_Call) Return(_a0 error) *CollectionRepo_UpdateSubjectCollection_Call

+ func (_c *CollectionRepo_UpdateSubjectCollection_Call) Run(...) *CollectionRepo_UpdateSubjectCollection_Call

+ type CollectionRepo_WithQuery_Call struct

+ func (_c *CollectionRepo_WithQuery_Call) Return(_a0 domain.CollectionRepo) *CollectionRepo_WithQuery_Call

+ func (_c *CollectionRepo_WithQuery_Call) Run(run func(_a0 *query.Query)) *CollectionRepo_WithQuery_Call

type EpisodeRepo

+ func (_m *EpisodeRepo) WithQuery(_a0 *query.Query) domain.EpisodeRepo

type EpisodeRepo_Expecter

+ func (_e *EpisodeRepo_Expecter) WithQuery(_a0 interface{}) *EpisodeRepo_WithQuery_Call

+ type EpisodeRepo_WithQuery_Call struct

+ func (_c *EpisodeRepo_WithQuery_Call) Return(_a0 domain.EpisodeRepo) *EpisodeRepo_WithQuery_Call

+ func (_c *EpisodeRepo_WithQuery_Call) Run(run func(_a0 *query.Query)) *EpisodeRepo_WithQuery_Call

Aug 8, 2022

Changes in this version

type RateLimiter

+ func (_m *RateLimiter) AllowAction(ctx context.Context, u model.UserID, _a2 action.Action, limit rate.Limit) (bool, int, error)

+ func (_m *RateLimiter) Login(ctx context.Context, ip string) (bool, int, error)

+ type RateLimiter_AllowAction_Call struct

+ func (_c *RateLimiter_AllowAction_Call) Return(allowed bool, remain int, err error) *RateLimiter_AllowAction_Call

+ func (_c *RateLimiter_AllowAction_Call) Run(...) *RateLimiter_AllowAction_Call

type RateLimiter_Expecter

+ func (_e *RateLimiter_Expecter) AllowAction(ctx interface{}, u interface{}, _a2 interface{}, limit interface{}) *RateLimiter_AllowAction_Call

+ func (_e *RateLimiter_Expecter) Login(ctx interface{}, ip interface{}) *RateLimiter_Login_Call

+ type RateLimiter_Login_Call struct

+ func (_c *RateLimiter_Login_Call) Return(allowed bool, remain int, err error) *RateLimiter_Login_Call

+ func (_c *RateLimiter_Login_Call) Run(run func(ctx context.Context, ip string)) *RateLimiter_Login_Call

Jul 23, 2022

Changes in this version

type CollectionRepo

+ func (_m *CollectionRepo) GetSubjectEpisodesCollection(ctx context.Context, userID model.UserID, subjectID model.SubjectID) (model.UserSubjectEpisodesCollection, error)

type CollectionRepo_Expecter

+ func (_e *CollectionRepo_Expecter) GetSubjectEpisodesCollection(ctx interface{}, userID interface{}, subjectID interface{}) *CollectionRepo_GetSubjectEpisodesCollection_Call

+ type CollectionRepo_GetSubjectEpisodesCollection_Call struct

+ func (_c *CollectionRepo_GetSubjectEpisodesCollection_Call) Return(_a0 model.UserSubjectEpisodesCollection, _a1 error) *CollectionRepo_GetSubjectEpisodesCollection_Call

+ func (_c *CollectionRepo_GetSubjectEpisodesCollection_Call) Run(run func(ctx context.Context, userID model.UserID, subjectID model.SubjectID)) *CollectionRepo_GetSubjectEpisodesCollection_Call

type TopicRepo

+ func (_m *TopicRepo) ListRepliesAll(ctx context.Context, commentType domain.CommentType, id model.TopicID) ([]model.Comment, error)

type TopicRepo_Expecter

+ func (_e *TopicRepo_Expecter) ListRepliesAll(ctx interface{}, commentType interface{}, id interface{}) *TopicRepo_ListRepliesAll_Call

+ type TopicRepo_ListRepliesAll_Call struct

+ func (_c *TopicRepo_ListRepliesAll_Call) Return(_a0 []model.Comment, _a1 error) *TopicRepo_ListRepliesAll_Call

+ func (_c *TopicRepo_ListRepliesAll_Call) Run(...) *TopicRepo_ListRepliesAll_Call

type UserRepo

+ func (_m *UserRepo) GetFriends(ctx context.Context, userID model.UserID) (map[model.UserID]domain.FriendItem, error)

type UserRepo_Expecter

+ func (_e *UserRepo_Expecter) GetFriends(ctx interface{}, userID interface{}) *UserRepo_GetFriends_Call

+ type UserRepo_GetFriends_Call struct

+ func (_c *UserRepo_GetFriends_Call) Return(_a0 map[model.UserID]domain.FriendItem, _a1 error) *UserRepo_GetFriends_Call

+ func (_c *UserRepo_GetFriends_Call) Run(run func(ctx context.Context, userID model.UserID)) *UserRepo_GetFriends_Call

Jul 17, 2022

Changes in this version

+ type TopicRepo struct

+ func NewTopicRepo(t mockConstructorTestingTNewTopicRepo) *TopicRepo

+ func (_m *TopicRepo) Count(ctx context.Context, topicType domain.TopicType, id uint32, ...) (int64, error)

+ func (_m *TopicRepo) CountReplies(ctx context.Context, commentType domain.CommentType, id model.TopicID) (int64, error)

+ func (_m *TopicRepo) EXPECT() *TopicRepo_Expecter

+ func (_m *TopicRepo) Get(ctx context.Context, topicType domain.TopicType, id model.TopicID) (model.Topic, error)

+ func (_m *TopicRepo) GetTopicContent(ctx context.Context, topicType domain.TopicType, id model.TopicID) (model.Comment, error)

+ func (_m *TopicRepo) List(ctx context.Context, topicType domain.TopicType, id uint32, ...) ([]model.Topic, error)

+ func (_m *TopicRepo) ListReplies(ctx context.Context, commentType domain.CommentType, id model.TopicID, ...) ([]model.Comment, error)

+ type TopicRepo_CountReplies_Call struct

+ func (_c *TopicRepo_CountReplies_Call) Return(_a0 int64, _a1 error) *TopicRepo_CountReplies_Call

+ func (_c *TopicRepo_CountReplies_Call) Run(...) *TopicRepo_CountReplies_Call

+ type TopicRepo_Count_Call struct

+ func (_c *TopicRepo_Count_Call) Return(_a0 int64, _a1 error) *TopicRepo_Count_Call

+ func (_c *TopicRepo_Count_Call) Run(run func(ctx context.Context, topicType domain.TopicType, id uint32, ...)) *TopicRepo_Count_Call

+ type TopicRepo_Expecter struct

+ func (_e *TopicRepo_Expecter) Count(ctx interface{}, topicType interface{}, id interface{}, statuses interface{}) *TopicRepo_Count_Call

+ func (_e *TopicRepo_Expecter) CountReplies(ctx interface{}, commentType interface{}, id interface{}) *TopicRepo_CountReplies_Call

+ func (_e *TopicRepo_Expecter) Get(ctx interface{}, topicType interface{}, id interface{}) *TopicRepo_Get_Call

+ func (_e *TopicRepo_Expecter) GetTopicContent(ctx interface{}, topicType interface{}, id interface{}) *TopicRepo_GetTopicContent_Call

+ func (_e *TopicRepo_Expecter) List(ctx interface{}, topicType interface{}, id interface{}, statuses interface{}, ...) *TopicRepo_List_Call

+ func (_e *TopicRepo_Expecter) ListReplies(ctx interface{}, commentType interface{}, id interface{}, limit interface{}, ...) *TopicRepo_ListReplies_Call

+ type TopicRepo_GetTopicContent_Call struct

+ func (_c *TopicRepo_GetTopicContent_Call) Return(_a0 model.Comment, _a1 error) *TopicRepo_GetTopicContent_Call

+ func (_c *TopicRepo_GetTopicContent_Call) Run(run func(ctx context.Context, topicType domain.TopicType, id model.TopicID)) *TopicRepo_GetTopicContent_Call

+ type TopicRepo_Get_Call struct

+ func (_c *TopicRepo_Get_Call) Return(_a0 model.Topic, _a1 error) *TopicRepo_Get_Call

+ func (_c *TopicRepo_Get_Call) Run(run func(ctx context.Context, topicType domain.TopicType, id model.TopicID)) *TopicRepo_Get_Call

+ type TopicRepo_ListReplies_Call struct

+ func (_c *TopicRepo_ListReplies_Call) Return(_a0 []model.Comment, _a1 error) *TopicRepo_ListReplies_Call

+ func (_c *TopicRepo_ListReplies_Call) Run(...) *TopicRepo_ListReplies_Call

+ type TopicRepo_List_Call struct

+ func (_c *TopicRepo_List_Call) Return(_a0 []model.Topic, _a1 error) *TopicRepo_List_Call

+ func (_c *TopicRepo_List_Call) Run(run func(ctx context.Context, topicType domain.TopicType, id uint32, ...)) *TopicRepo_List_Call

Jul 14, 2022

Changes in this version

type EpisodeRepo

+ func (_m *EpisodeRepo) CountsBySubjectID(ctx context.Context, subjectID ...model.SubjectID) (map[model.SubjectID]int64, error)

+ type EpisodeRepo_CountsBySubjectID_Call struct

+ func (_c *EpisodeRepo_CountsBySubjectID_Call) Return(_a0 map[model.SubjectID]int64, _a1 error) *EpisodeRepo_CountsBySubjectID_Call

+ func (_c *EpisodeRepo_CountsBySubjectID_Call) Run(run func(ctx context.Context, subjectID ...model.SubjectID)) *EpisodeRepo_CountsBySubjectID_Call

type EpisodeRepo_Expecter

+ func (_e *EpisodeRepo_Expecter) CountsBySubjectID(ctx interface{}, subjectID ...interface{}) *EpisodeRepo_CountsBySubjectID_Call

type SubjectService

+ func (_m *SubjectService) GetByIDs(ctx context.Context, ids ...model.SubjectID) (map[model.SubjectID]model.Subject, error)

type SubjectService_Expecter

+ func (_e *SubjectService_Expecter) GetByIDs(ctx interface{}, ids ...interface{}) *SubjectService_GetByIDs_Call

+ type SubjectService_GetByIDs_Call struct

+ func (_c *SubjectService_GetByIDs_Call) Return(_a0 map[model.SubjectID]model.Subject, _a1 error) *SubjectService_GetByIDs_Call

+ func (_c *SubjectService_GetByIDs_Call) Run(run func(ctx context.Context, ids ...model.SubjectID)) *SubjectService_GetByIDs_Call

Jul 8, 2022

Changes in this version

+ type SessionRepo struct

+ func NewSessionRepo(t mockConstructorTestingTNewSessionRepo) *SessionRepo

+ func (_m *SessionRepo) Create(ctx context.Context, userID model.UserID, regTime time.Time, ...) (string, session.Session, error)

+ func (_m *SessionRepo) EXPECT() *SessionRepo_Expecter

+ func (_m *SessionRepo) Get(ctx context.Context, key string) (session.Session, error)

+ func (_m *SessionRepo) Revoke(ctx context.Context, key string) error

+ func (_m *SessionRepo) RevokeUser(ctx context.Context, userID model.UserID) ([]string, error)

+ type SessionRepo_Create_Call struct

+ func (_c *SessionRepo_Create_Call) Return(key string, s session.Session, err error) *SessionRepo_Create_Call

+ func (_c *SessionRepo_Create_Call) Run(run func(ctx context.Context, userID model.UserID, regTime time.Time, ...)) *SessionRepo_Create_Call

+ type SessionRepo_Expecter struct

+ func (_e *SessionRepo_Expecter) Create(ctx interface{}, userID interface{}, regTime interface{}, keyGen interface{}) *SessionRepo_Create_Call

+ func (_e *SessionRepo_Expecter) Get(ctx interface{}, key interface{}) *SessionRepo_Get_Call

+ func (_e *SessionRepo_Expecter) Revoke(ctx interface{}, key interface{}) *SessionRepo_Revoke_Call

+ func (_e *SessionRepo_Expecter) RevokeUser(ctx interface{}, userID interface{}) *SessionRepo_RevokeUser_Call

+ type SessionRepo_Get_Call struct

+ func (_c *SessionRepo_Get_Call) Return(_a0 session.Session, _a1 error) *SessionRepo_Get_Call

+ func (_c *SessionRepo_Get_Call) Run(run func(ctx context.Context, key string)) *SessionRepo_Get_Call

+ type SessionRepo_RevokeUser_Call struct

+ func (_c *SessionRepo_RevokeUser_Call) Return(keys []string, err error) *SessionRepo_RevokeUser_Call

+ func (_c *SessionRepo_RevokeUser_Call) Run(run func(ctx context.Context, userID model.UserID)) *SessionRepo_RevokeUser_Call

+ type SessionRepo_Revoke_Call struct

+ func (_c *SessionRepo_Revoke_Call) Return(_a0 error) *SessionRepo_Revoke_Call

+ func (_c *SessionRepo_Revoke_Call) Run(run func(ctx context.Context, key string)) *SessionRepo_Revoke_Call

Jun 28, 2022

Changes in this version

+ type CollectionRepo struct

+ func NewCollectionRepo(t mockConstructorTestingTNewCollectionRepo) *CollectionRepo

+ func (_m *CollectionRepo) CountSubjectCollections(ctx context.Context, userID model.UserID, subjectType uint8, ...) (int64, error)

+ func (_m *CollectionRepo) EXPECT() *CollectionRepo_Expecter

+ func (_m *CollectionRepo) GetSubjectCollection(ctx context.Context, userID model.UserID, subjectID model.SubjectID) (model.SubjectCollection, error)

+ func (_m *CollectionRepo) ListSubjectCollection(ctx context.Context, userID model.UserID, subjectType uint8, ...) ([]model.SubjectCollection, error)

+ type CollectionRepo_CountSubjectCollections_Call struct

+ func (_c *CollectionRepo_CountSubjectCollections_Call) Return(_a0 int64, _a1 error) *CollectionRepo_CountSubjectCollections_Call

+ func (_c *CollectionRepo_CountSubjectCollections_Call) Run(run func(ctx context.Context, userID model.UserID, subjectType uint8, ...)) *CollectionRepo_CountSubjectCollections_Call

+ type CollectionRepo_Expecter struct

+ func (_e *CollectionRepo_Expecter) CountSubjectCollections(ctx interface{}, userID interface{}, subjectType interface{}, ...) *CollectionRepo_CountSubjectCollections_Call

+ func (_e *CollectionRepo_Expecter) GetSubjectCollection(ctx interface{}, userID interface{}, subjectID interface{}) *CollectionRepo_GetSubjectCollection_Call

+ func (_e *CollectionRepo_Expecter) ListSubjectCollection(ctx interface{}, userID interface{}, subjectType interface{}, ...) *CollectionRepo_ListSubjectCollection_Call

+ type CollectionRepo_GetSubjectCollection_Call struct

+ func (_c *CollectionRepo_GetSubjectCollection_Call) Return(_a0 model.SubjectCollection, _a1 error) *CollectionRepo_GetSubjectCollection_Call

+ func (_c *CollectionRepo_GetSubjectCollection_Call) Run(run func(ctx context.Context, userID model.UserID, subjectID model.SubjectID)) *CollectionRepo_GetSubjectCollection_Call

+ type CollectionRepo_ListSubjectCollection_Call struct

+ func (_c *CollectionRepo_ListSubjectCollection_Call) Return(_a0 []model.SubjectCollection, _a1 error) *CollectionRepo_ListSubjectCollection_Call

+ func (_c *CollectionRepo_ListSubjectCollection_Call) Run(run func(ctx context.Context, userID model.UserID, subjectType uint8, ...)) *CollectionRepo_ListSubjectCollection_Call

+ type GroupRepo struct

+ func NewGroupRepo(t mockConstructorTestingTNewGroupRepo) *GroupRepo

+ func (_m *GroupRepo) CountMembersByID(ctx context.Context, id model.GroupID, memberType domain.GroupMemberType) (int64, error)

+ func (_m *GroupRepo) EXPECT() *GroupRepo_Expecter

+ func (_m *GroupRepo) GetByName(ctx context.Context, name string) (model.Group, error)

+ func (_m *GroupRepo) ListMembersByID(ctx context.Context, id model.GroupID, memberType domain.GroupMemberType, ...) ([]model.GroupMember, error)

+ type GroupRepo_CountMembersByID_Call struct

+ func (_c *GroupRepo_CountMembersByID_Call) Return(_a0 int64, _a1 error) *GroupRepo_CountMembersByID_Call

+ func (_c *GroupRepo_CountMembersByID_Call) Run(...) *GroupRepo_CountMembersByID_Call

+ type GroupRepo_Expecter struct

+ func (_e *GroupRepo_Expecter) CountMembersByID(ctx interface{}, id interface{}, memberType interface{}) *GroupRepo_CountMembersByID_Call

+ func (_e *GroupRepo_Expecter) GetByName(ctx interface{}, name interface{}) *GroupRepo_GetByName_Call

+ func (_e *GroupRepo_Expecter) ListMembersByID(ctx interface{}, id interface{}, memberType interface{}, limit interface{}, ...) *GroupRepo_ListMembersByID_Call

+ type GroupRepo_GetByName_Call struct

+ func (_c *GroupRepo_GetByName_Call) Return(_a0 model.Group, _a1 error) *GroupRepo_GetByName_Call

+ func (_c *GroupRepo_GetByName_Call) Run(run func(ctx context.Context, name string)) *GroupRepo_GetByName_Call

+ type GroupRepo_ListMembersByID_Call struct

+ func (_c *GroupRepo_ListMembersByID_Call) Return(_a0 []model.GroupMember, _a1 error) *GroupRepo_ListMembersByID_Call

+ func (_c *GroupRepo_ListMembersByID_Call) Run(...) *GroupRepo_ListMembersByID_Call

Jun 24, 2022

Changes in this version

+ type Cache struct

+ func NewCache(t mockConstructorTestingTNewCache) *Cache

+ func (_m *Cache) Del(ctx context.Context, keys ...string) error

+ func (_m *Cache) EXPECT() *Cache_Expecter

+ func (_m *Cache) Get(ctx context.Context, key string, value interface{}) (bool, error)

+ func (_m *Cache) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error

+ type Cache_Del_Call struct

+ func (_c *Cache_Del_Call) Return(_a0 error) *Cache_Del_Call

+ func (_c *Cache_Del_Call) Run(run func(ctx context.Context, keys ...string)) *Cache_Del_Call

+ type Cache_Expecter struct

+ func (_e *Cache_Expecter) Del(ctx interface{}, keys ...interface{}) *Cache_Del_Call

+ func (_e *Cache_Expecter) Get(ctx interface{}, key interface{}, value interface{}) *Cache_Get_Call

+ func (_e *Cache_Expecter) Set(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *Cache_Set_Call

+ type Cache_Get_Call struct

+ func (_c *Cache_Get_Call) Return(_a0 bool, _a1 error) *Cache_Get_Call

+ func (_c *Cache_Get_Call) Run(run func(ctx context.Context, key string, value interface{})) *Cache_Get_Call

+ type Cache_Set_Call struct

+ func (_c *Cache_Set_Call) Return(_a0 error) *Cache_Set_Call

+ func (_c *Cache_Set_Call) Run(...) *Cache_Set_Call

Jun 4, 2022

Changes in this version

+ type NewOAuthMangerT interface

+ Cleanup func(func())

+ type OAuthManger struct

+ func NewOAuthManger(t NewOAuthMangerT) *OAuthManger

+ func (_m *OAuthManger) EXPECT() *OAuthManger_Expecter

+ func (_m *OAuthManger) GetClientByID(ctx context.Context, clientIDs ...string) (map[string]oauth.Client, error)

+ type OAuthManger_Expecter struct

+ func (_e *OAuthManger_Expecter) GetClientByID(ctx interface{}, clientIDs ...interface{}) *OAuthManger_GetClientByID_Call

+ type OAuthManger_GetClientByID_Call struct

+ func (_c *OAuthManger_GetClientByID_Call) Return(_a0 map[string]oauth.Client, _a1 error) *OAuthManger_GetClientByID_Call

+ func (_c *OAuthManger_GetClientByID_Call) Run(run func(ctx context.Context, clientIDs ...string)) *OAuthManger_GetClientByID_Call

Jun 4, 2022

Changes in this version

type AuthRepo

+ func (_m *AuthRepo) CreateAccessToken(ctx context.Context, userID uint32, name string, expiration time.Duration) (string, error)

+ func (_m *AuthRepo) DeleteAccessToken(ctx context.Context, tokenID uint32) (bool, error)

+ func (_m *AuthRepo) GetTokenByID(ctx context.Context, id uint32) (domain.AccessToken, error)

+ func (_m *AuthRepo) ListAccessToken(ctx context.Context, userID uint32) ([]domain.AccessToken, error)

+ type AuthRepo_CreateAccessToken_Call struct

+ func (_c *AuthRepo_CreateAccessToken_Call) Return(token string, err error) *AuthRepo_CreateAccessToken_Call

+ func (_c *AuthRepo_CreateAccessToken_Call) Run(...) *AuthRepo_CreateAccessToken_Call

+ type AuthRepo_DeleteAccessToken_Call struct

+ func (_c *AuthRepo_DeleteAccessToken_Call) Return(_a0 bool, _a1 error) *AuthRepo_DeleteAccessToken_Call

+ func (_c *AuthRepo_DeleteAccessToken_Call) Run(run func(ctx context.Context, tokenID uint32)) *AuthRepo_DeleteAccessToken_Call

type AuthRepo_Expecter

+ func (_e *AuthRepo_Expecter) CreateAccessToken(ctx interface{}, userID interface{}, name interface{}, expiration interface{}) *AuthRepo_CreateAccessToken_Call

+ func (_e *AuthRepo_Expecter) DeleteAccessToken(ctx interface{}, tokenID interface{}) *AuthRepo_DeleteAccessToken_Call

+ func (_e *AuthRepo_Expecter) GetTokenByID(ctx interface{}, id interface{}) *AuthRepo_GetTokenByID_Call

+ func (_e *AuthRepo_Expecter) ListAccessToken(ctx interface{}, userID interface{}) *AuthRepo_ListAccessToken_Call

+ type AuthRepo_GetTokenByID_Call struct

+ func (_c *AuthRepo_GetTokenByID_Call) Return(_a0 domain.AccessToken, _a1 error) *AuthRepo_GetTokenByID_Call

+ func (_c *AuthRepo_GetTokenByID_Call) Run(run func(ctx context.Context, id uint32)) *AuthRepo_GetTokenByID_Call

+ type AuthRepo_ListAccessToken_Call struct

+ func (_c *AuthRepo_ListAccessToken_Call) Return(_a0 []domain.AccessToken, _a1 error) *AuthRepo_ListAccessToken_Call

+ func (_c *AuthRepo_ListAccessToken_Call) Run(run func(ctx context.Context, userID uint32)) *AuthRepo_ListAccessToken_Call

type AuthService

+ func (_m *AuthService) CreateAccessToken(ctx context.Context, userID uint32, name string, expiration time.Duration) (string, error)

+ func (_m *AuthService) DeleteAccessToken(ctx context.Context, tokenID uint32) (bool, error)

+ func (_m *AuthService) GetTokenByID(ctx context.Context, tokenID uint32) (domain.AccessToken, error)

+ func (_m *AuthService) ListAccessToken(ctx context.Context, userID uint32) ([]domain.AccessToken, error)

+ type AuthService_CreateAccessToken_Call struct

+ func (_c *AuthService_CreateAccessToken_Call) Return(token string, err error) *AuthService_CreateAccessToken_Call

+ func (_c *AuthService_CreateAccessToken_Call) Run(...) *AuthService_CreateAccessToken_Call

+ type AuthService_DeleteAccessToken_Call struct

+ func (_c *AuthService_DeleteAccessToken_Call) Return(_a0 bool, _a1 error) *AuthService_DeleteAccessToken_Call

+ func (_c *AuthService_DeleteAccessToken_Call) Run(run func(ctx context.Context, tokenID uint32)) *AuthService_DeleteAccessToken_Call

type AuthService_Expecter

+ func (_e *AuthService_Expecter) CreateAccessToken(ctx interface{}, userID interface{}, name interface{}, expiration interface{}) *AuthService_CreateAccessToken_Call

+ func (_e *AuthService_Expecter) DeleteAccessToken(ctx interface{}, tokenID interface{}) *AuthService_DeleteAccessToken_Call

+ func (_e *AuthService_Expecter) GetTokenByID(ctx interface{}, tokenID interface{}) *AuthService_GetTokenByID_Call

+ func (_e *AuthService_Expecter) ListAccessToken(ctx interface{}, userID interface{}) *AuthService_ListAccessToken_Call

+ type AuthService_GetTokenByID_Call struct

+ func (_c *AuthService_GetTokenByID_Call) Return(_a0 domain.AccessToken, _a1 error) *AuthService_GetTokenByID_Call

+ func (_c *AuthService_GetTokenByID_Call) Run(run func(ctx context.Context, tokenID uint32)) *AuthService_GetTokenByID_Call

+ type AuthService_ListAccessToken_Call struct

+ func (_c *AuthService_ListAccessToken_Call) Return(_a0 []domain.AccessToken, _a1 error) *AuthService_ListAccessToken_Call

+ func (_c *AuthService_ListAccessToken_Call) Run(run func(ctx context.Context, userID uint32)) *AuthService_ListAccessToken_Call

May 30, 2022

Changes in this version

+ type NewAuthRepoT interface

+ Cleanup func(func())

+ type NewAuthServiceT interface

+ Cleanup func(func())

+ type NewCaptchaManagerT interface

+ Cleanup func(func())

+ type NewCharacterRepoT interface

+ Cleanup func(func())

+ type NewCharacterServiceT interface

+ Cleanup func(func())

+ type NewEpisodeRepoT interface

+ Cleanup func(func())

+ type NewGenericT interface

+ Cleanup func(func())

+ type NewIndexRepoT interface

+ Cleanup func(func())

+ type NewPersonRepoT interface

+ Cleanup func(func())

+ type NewPersonServiceT interface

+ Cleanup func(func())

+ type NewRateLimiterT interface

+ Cleanup func(func())

+ type NewRevisionRepoT interface

+ Cleanup func(func())

+ type NewSessionManagerT interface

+ Cleanup func(func())

+ type NewSubjectRepoT interface

+ Cleanup func(func())

+ type NewSubjectServiceT interface

+ Cleanup func(func())

+ type NewUserRepoT interface

+ Cleanup func(func())

May 22, 2022

Changes in this version

+ type AuthRepo struct

+ func NewAuthRepo(t testing.TB) *AuthRepo

+ func (_m *AuthRepo) EXPECT() *AuthRepo_Expecter

+ func (_m *AuthRepo) GetByEmail(ctx context.Context, email string) (domain.Auth, []byte, error)

+ func (_m *AuthRepo) GetByToken(ctx context.Context, token string) (domain.Auth, error)

+ func (_m *AuthRepo) GetPermission(ctx context.Context, groupID uint8) (domain.Permission, error)

+ type AuthRepo_Expecter struct

+ func (_e *AuthRepo_Expecter) GetByEmail(ctx interface{}, email interface{}) *AuthRepo_GetByEmail_Call

+ func (_e *AuthRepo_Expecter) GetByToken(ctx interface{}, token interface{}) *AuthRepo_GetByToken_Call

+ func (_e *AuthRepo_Expecter) GetPermission(ctx interface{}, groupID interface{}) *AuthRepo_GetPermission_Call

+ type AuthRepo_GetByEmail_Call struct

+ func (_c *AuthRepo_GetByEmail_Call) Return(_a0 domain.Auth, _a1 []byte, _a2 error) *AuthRepo_GetByEmail_Call

+ func (_c *AuthRepo_GetByEmail_Call) Run(run func(ctx context.Context, email string)) *AuthRepo_GetByEmail_Call

+ type AuthRepo_GetByToken_Call struct

+ func (_c *AuthRepo_GetByToken_Call) Return(_a0 domain.Auth, _a1 error) *AuthRepo_GetByToken_Call

+ func (_c *AuthRepo_GetByToken_Call) Run(run func(ctx context.Context, token string)) *AuthRepo_GetByToken_Call

+ type AuthRepo_GetPermission_Call struct

+ func (_c *AuthRepo_GetPermission_Call) Return(_a0 domain.Permission, _a1 error) *AuthRepo_GetPermission_Call

+ func (_c *AuthRepo_GetPermission_Call) Run(run func(ctx context.Context, groupID uint8)) *AuthRepo_GetPermission_Call

+ type AuthService struct

+ func NewAuthService(t testing.TB) *AuthService

+ func (_m *AuthService) ComparePassword(hashed []byte, password string) (bool, error)

+ func (_m *AuthService) EXPECT() *AuthService_Expecter

+ func (_m *AuthService) GetByID(ctx context.Context, userID uint32) (domain.Auth, error)

+ func (_m *AuthService) GetByIDWithCache(ctx context.Context, userID uint32) (domain.Auth, error)

+ func (_m *AuthService) GetByToken(ctx context.Context, token string) (domain.Auth, error)

+ func (_m *AuthService) GetByTokenWithCache(ctx context.Context, token string) (domain.Auth, error)

+ func (_m *AuthService) GetPermission(ctx context.Context, id uint8) (domain.Permission, error)

+ func (_m *AuthService) Login(ctx context.Context, email string, password string) (domain.Auth, bool, error)

+ type AuthService_ComparePassword_Call struct

+ func (_c *AuthService_ComparePassword_Call) Return(_a0 bool, _a1 error) *AuthService_ComparePassword_Call

+ func (_c *AuthService_ComparePassword_Call) Run(run func(hashed []byte, password string)) *AuthService_ComparePassword_Call

+ type AuthService_Expecter struct

+ func (_e *AuthService_Expecter) ComparePassword(hashed interface{}, password interface{}) *AuthService_ComparePassword_Call

+ func (_e *AuthService_Expecter) GetByID(ctx interface{}, userID interface{}) *AuthService_GetByID_Call

+ func (_e *AuthService_Expecter) GetByIDWithCache(ctx interface{}, userID interface{}) *AuthService_GetByIDWithCache_Call

+ func (_e *AuthService_Expecter) GetByToken(ctx interface{}, token interface{}) *AuthService_GetByToken_Call

+ func (_e *AuthService_Expecter) GetByTokenWithCache(ctx interface{}, token interface{}) *AuthService_GetByTokenWithCache_Call

+ func (_e *AuthService_Expecter) GetPermission(ctx interface{}, id interface{}) *AuthService_GetPermission_Call

+ func (_e *AuthService_Expecter) Login(ctx interface{}, email interface{}, password interface{}) *AuthService_Login_Call

+ type AuthService_GetByIDWithCache_Call struct

+ func (_c *AuthService_GetByIDWithCache_Call) Return(_a0 domain.Auth, _a1 error) *AuthService_GetByIDWithCache_Call

+ func (_c *AuthService_GetByIDWithCache_Call) Run(run func(ctx context.Context, userID uint32)) *AuthService_GetByIDWithCache_Call

+ type AuthService_GetByID_Call struct

+ func (_c *AuthService_GetByID_Call) Return(_a0 domain.Auth, _a1 error) *AuthService_GetByID_Call

+ func (_c *AuthService_GetByID_Call) Run(run func(ctx context.Context, userID uint32)) *AuthService_GetByID_Call

+ type AuthService_GetByTokenWithCache_Call struct

+ func (_c *AuthService_GetByTokenWithCache_Call) Return(_a0 domain.Auth, _a1 error) *AuthService_GetByTokenWithCache_Call

+ func (_c *AuthService_GetByTokenWithCache_Call) Run(run func(ctx context.Context, token string)) *AuthService_GetByTokenWithCache_Call

+ type AuthService_GetByToken_Call struct

+ func (_c *AuthService_GetByToken_Call) Return(_a0 domain.Auth, _a1 error) *AuthService_GetByToken_Call

+ func (_c *AuthService_GetByToken_Call) Run(run func(ctx context.Context, token string)) *AuthService_GetByToken_Call

+ type AuthService_GetPermission_Call struct

+ func (_c *AuthService_GetPermission_Call) Return(_a0 domain.Permission, _a1 error) *AuthService_GetPermission_Call

+ func (_c *AuthService_GetPermission_Call) Run(run func(ctx context.Context, id uint8)) *AuthService_GetPermission_Call

+ type AuthService_Login_Call struct

+ func (_c *AuthService_Login_Call) Return(_a0 domain.Auth, _a1 bool, _a2 error) *AuthService_Login_Call

+ func (_c *AuthService_Login_Call) Run(run func(ctx context.Context, email string, password string)) *AuthService_Login_Call

+ type CaptchaManager struct

+ func NewCaptchaManager(t testing.TB) *CaptchaManager

+ func (_m *CaptchaManager) EXPECT() *CaptchaManager_Expecter

+ func (_m *CaptchaManager) Verify(ctx context.Context, response string) (bool, error)

+ type CaptchaManager_Expecter struct

+ func (_e *CaptchaManager_Expecter) Verify(ctx interface{}, response interface{}) *CaptchaManager_Verify_Call

+ type CaptchaManager_Verify_Call struct

+ func (_c *CaptchaManager_Verify_Call) Return(_a0 bool, _a1 error) *CaptchaManager_Verify_Call

+ func (_c *CaptchaManager_Verify_Call) Run(run func(ctx context.Context, response string)) *CaptchaManager_Verify_Call

+ type CharacterRepo struct

+ func NewCharacterRepo(t testing.TB) *CharacterRepo

+ func (_m *CharacterRepo) EXPECT() *CharacterRepo_Expecter

+ func (_m *CharacterRepo) Get(ctx context.Context, id uint32) (model.Character, error)

+ func (_m *CharacterRepo) GetByIDs(ctx context.Context, ids ...uint32) (map[uint32]model.Character, error)

+ func (_m *CharacterRepo) GetPersonRelated(ctx context.Context, personID uint32) ([]domain.PersonCharacterRelation, error)

+ func (_m *CharacterRepo) GetSubjectRelated(ctx context.Context, subjectID uint32) ([]domain.SubjectCharacterRelation, error)

+ type CharacterRepo_Expecter struct

+ func (_e *CharacterRepo_Expecter) Get(ctx interface{}, id interface{}) *CharacterRepo_Get_Call

+ func (_e *CharacterRepo_Expecter) GetByIDs(ctx interface{}, ids ...interface{}) *CharacterRepo_GetByIDs_Call

+ func (_e *CharacterRepo_Expecter) GetPersonRelated(ctx interface{}, personID interface{}) *CharacterRepo_GetPersonRelated_Call

+ func (_e *CharacterRepo_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *CharacterRepo_GetSubjectRelated_Call

+ type CharacterRepo_GetByIDs_Call struct

+ func (_c *CharacterRepo_GetByIDs_Call) Return(_a0 map[uint32]model.Character, _a1 error) *CharacterRepo_GetByIDs_Call

+ func (_c *CharacterRepo_GetByIDs_Call) Run(run func(ctx context.Context, ids ...uint32)) *CharacterRepo_GetByIDs_Call

+ type CharacterRepo_GetPersonRelated_Call struct

+ func (_c *CharacterRepo_GetPersonRelated_Call) Return(_a0 []domain.PersonCharacterRelation, _a1 error) *CharacterRepo_GetPersonRelated_Call

+ func (_c *CharacterRepo_GetPersonRelated_Call) Run(run func(ctx context.Context, personID uint32)) *CharacterRepo_GetPersonRelated_Call

+ type CharacterRepo_GetSubjectRelated_Call struct

+ func (_c *CharacterRepo_GetSubjectRelated_Call) Return(_a0 []domain.SubjectCharacterRelation, _a1 error) *CharacterRepo_GetSubjectRelated_Call

+ func (_c *CharacterRepo_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *CharacterRepo_GetSubjectRelated_Call

+ type CharacterRepo_Get_Call struct

+ func (_c *CharacterRepo_Get_Call) Return(_a0 model.Character, _a1 error) *CharacterRepo_Get_Call

+ func (_c *CharacterRepo_Get_Call) Run(run func(ctx context.Context, id uint32)) *CharacterRepo_Get_Call

+ type CharacterService struct

+ func NewCharacterService(t testing.TB) *CharacterService

+ func (_m *CharacterService) EXPECT() *CharacterService_Expecter

+ func (_m *CharacterService) Get(ctx context.Context, id uint32) (model.Character, error)

+ func (_m *CharacterService) GetPersonRelated(ctx context.Context, personID uint32) ([]model.PersonCharacterRelation, error)

+ func (_m *CharacterService) GetSubjectRelated(ctx context.Context, subjectID uint32) ([]model.SubjectCharacterRelation, error)

+ type CharacterService_Expecter struct

+ func (_e *CharacterService_Expecter) Get(ctx interface{}, id interface{}) *CharacterService_Get_Call

+ func (_e *CharacterService_Expecter) GetPersonRelated(ctx interface{}, personID interface{}) *CharacterService_GetPersonRelated_Call

+ func (_e *CharacterService_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *CharacterService_GetSubjectRelated_Call

+ type CharacterService_GetPersonRelated_Call struct

+ func (_c *CharacterService_GetPersonRelated_Call) Return(_a0 []model.PersonCharacterRelation, _a1 error) *CharacterService_GetPersonRelated_Call

+ func (_c *CharacterService_GetPersonRelated_Call) Run(run func(ctx context.Context, personID uint32)) *CharacterService_GetPersonRelated_Call

+ type CharacterService_GetSubjectRelated_Call struct

+ func (_c *CharacterService_GetSubjectRelated_Call) Return(_a0 []model.SubjectCharacterRelation, _a1 error) *CharacterService_GetSubjectRelated_Call

+ func (_c *CharacterService_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *CharacterService_GetSubjectRelated_Call

+ type CharacterService_Get_Call struct

+ func (_c *CharacterService_Get_Call) Return(_a0 model.Character, _a1 error) *CharacterService_Get_Call

+ func (_c *CharacterService_Get_Call) Run(run func(ctx context.Context, id uint32)) *CharacterService_Get_Call

+ type EpisodeRepo struct

+ func NewEpisodeRepo(t testing.TB) *EpisodeRepo

+ func (_m *EpisodeRepo) Count(ctx context.Context, subjectID uint32) (int64, error)

+ func (_m *EpisodeRepo) CountByType(ctx context.Context, subjectID uint32, epType int8) (int64, error)

+ func (_m *EpisodeRepo) EXPECT() *EpisodeRepo_Expecter

+ func (_m *EpisodeRepo) Get(ctx context.Context, episodeID uint32) (model.Episode, error)

+ func (_m *EpisodeRepo) List(ctx context.Context, subjectID uint32, limit int, offset int) ([]model.Episode, error)

+ func (_m *EpisodeRepo) ListByType(ctx context.Context, subjectID uint32, epType int8, limit int, offset int) ([]model.Episode, error)

+ type EpisodeRepo_CountByType_Call struct

+ func (_c *EpisodeRepo_CountByType_Call) Return(_a0 int64, _a1 error) *EpisodeRepo_CountByType_Call

+ func (_c *EpisodeRepo_CountByType_Call) Run(run func(ctx context.Context, subjectID uint32, epType int8)) *EpisodeRepo_CountByType_Call

+ type EpisodeRepo_Count_Call struct

+ func (_c *EpisodeRepo_Count_Call) Return(_a0 int64, _a1 error) *EpisodeRepo_Count_Call

+ func (_c *EpisodeRepo_Count_Call) Run(run func(ctx context.Context, subjectID uint32)) *EpisodeRepo_Count_Call

+ type EpisodeRepo_Expecter struct

+ func (_e *EpisodeRepo_Expecter) Count(ctx interface{}, subjectID interface{}) *EpisodeRepo_Count_Call

+ func (_e *EpisodeRepo_Expecter) CountByType(ctx interface{}, subjectID interface{}, epType interface{}) *EpisodeRepo_CountByType_Call

+ func (_e *EpisodeRepo_Expecter) Get(ctx interface{}, episodeID interface{}) *EpisodeRepo_Get_Call

+ func (_e *EpisodeRepo_Expecter) List(ctx interface{}, subjectID interface{}, limit interface{}, offset interface{}) *EpisodeRepo_List_Call

+ func (_e *EpisodeRepo_Expecter) ListByType(ctx interface{}, subjectID interface{}, epType interface{}, limit interface{}, ...) *EpisodeRepo_ListByType_Call

+ type EpisodeRepo_Get_Call struct

+ func (_c *EpisodeRepo_Get_Call) Return(_a0 model.Episode, _a1 error) *EpisodeRepo_Get_Call

+ func (_c *EpisodeRepo_Get_Call) Run(run func(ctx context.Context, episodeID uint32)) *EpisodeRepo_Get_Call

+ type EpisodeRepo_ListByType_Call struct

+ func (_c *EpisodeRepo_ListByType_Call) Return(_a0 []model.Episode, _a1 error) *EpisodeRepo_ListByType_Call

+ func (_c *EpisodeRepo_ListByType_Call) Run(...) *EpisodeRepo_ListByType_Call

+ type EpisodeRepo_List_Call struct

+ func (_c *EpisodeRepo_List_Call) Return(_a0 []model.Episode, _a1 error) *EpisodeRepo_List_Call

+ func (_c *EpisodeRepo_List_Call) Run(run func(ctx context.Context, subjectID uint32, limit int, offset int)) *EpisodeRepo_List_Call

+ type Generic struct

+ func NewGeneric(t testing.TB) *Generic

+ func (_m *Generic) Del(ctx context.Context, keys ...string) error

+ func (_m *Generic) EXPECT() *Generic_Expecter

+ func (_m *Generic) Get(ctx context.Context, key string, value interface{}) (bool, error)

+ func (_m *Generic) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error

+ type Generic_Del_Call struct

+ func (_c *Generic_Del_Call) Return(_a0 error) *Generic_Del_Call

+ func (_c *Generic_Del_Call) Run(run func(ctx context.Context, keys ...string)) *Generic_Del_Call

+ type Generic_Expecter struct

+ func (_e *Generic_Expecter) Del(ctx interface{}, keys ...interface{}) *Generic_Del_Call

+ func (_e *Generic_Expecter) Get(ctx interface{}, key interface{}, value interface{}) *Generic_Get_Call

+ func (_e *Generic_Expecter) Set(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *Generic_Set_Call

+ type Generic_Get_Call struct

+ func (_c *Generic_Get_Call) Return(_a0 bool, _a1 error) *Generic_Get_Call

+ func (_c *Generic_Get_Call) Run(run func(ctx context.Context, key string, value interface{})) *Generic_Get_Call

+ type Generic_Set_Call struct

+ func (_c *Generic_Set_Call) Return(_a0 error) *Generic_Set_Call

+ func (_c *Generic_Set_Call) Run(...) *Generic_Set_Call

+ type IndexRepo struct

+ func NewIndexRepo(t testing.TB) *IndexRepo

+ func (_m *IndexRepo) CountSubjects(ctx context.Context, id uint32, subjectType uint8) (int64, error)

+ func (_m *IndexRepo) EXPECT() *IndexRepo_Expecter

+ func (_m *IndexRepo) Get(ctx context.Context, id uint32) (model.Index, error)

+ func (_m *IndexRepo) ListSubjects(ctx context.Context, id uint32, subjectType uint8, limit int, offset int) ([]domain.IndexSubject, error)

+ type IndexRepo_CountSubjects_Call struct

+ func (_c *IndexRepo_CountSubjects_Call) Return(_a0 int64, _a1 error) *IndexRepo_CountSubjects_Call

+ func (_c *IndexRepo_CountSubjects_Call) Run(run func(ctx context.Context, id uint32, subjectType uint8)) *IndexRepo_CountSubjects_Call

+ type IndexRepo_Expecter struct

+ func (_e *IndexRepo_Expecter) CountSubjects(ctx interface{}, id interface{}, subjectType interface{}) *IndexRepo_CountSubjects_Call

+ func (_e *IndexRepo_Expecter) Get(ctx interface{}, id interface{}) *IndexRepo_Get_Call

+ func (_e *IndexRepo_Expecter) ListSubjects(ctx interface{}, id interface{}, subjectType interface{}, limit interface{}, ...) *IndexRepo_ListSubjects_Call

+ type IndexRepo_Get_Call struct

+ func (_c *IndexRepo_Get_Call) Return(_a0 model.Index, _a1 error) *IndexRepo_Get_Call

+ func (_c *IndexRepo_Get_Call) Run(run func(ctx context.Context, id uint32)) *IndexRepo_Get_Call

+ type IndexRepo_ListSubjects_Call struct

+ func (_c *IndexRepo_ListSubjects_Call) Return(_a0 []domain.IndexSubject, _a1 error) *IndexRepo_ListSubjects_Call

+ func (_c *IndexRepo_ListSubjects_Call) Run(...) *IndexRepo_ListSubjects_Call

+ type PersonRepo struct

+ func NewPersonRepo(t testing.TB) *PersonRepo

+ func (_m *PersonRepo) EXPECT() *PersonRepo_Expecter

+ func (_m *PersonRepo) Get(ctx context.Context, id uint32) (model.Person, error)

+ func (_m *PersonRepo) GetByIDs(ctx context.Context, ids ...uint32) (map[uint32]model.Person, error)

+ func (_m *PersonRepo) GetCharacterRelated(ctx context.Context, subjectID uint32) ([]domain.PersonCharacterRelation, error)

+ func (_m *PersonRepo) GetSubjectRelated(ctx context.Context, subjectID uint32) ([]domain.SubjectPersonRelation, error)

+ type PersonRepo_Expecter struct

+ func (_e *PersonRepo_Expecter) Get(ctx interface{}, id interface{}) *PersonRepo_Get_Call

+ func (_e *PersonRepo_Expecter) GetByIDs(ctx interface{}, ids ...interface{}) *PersonRepo_GetByIDs_Call

+ func (_e *PersonRepo_Expecter) GetCharacterRelated(ctx interface{}, subjectID interface{}) *PersonRepo_GetCharacterRelated_Call

+ func (_e *PersonRepo_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *PersonRepo_GetSubjectRelated_Call

+ type PersonRepo_GetByIDs_Call struct

+ func (_c *PersonRepo_GetByIDs_Call) Return(_a0 map[uint32]model.Person, _a1 error) *PersonRepo_GetByIDs_Call

+ func (_c *PersonRepo_GetByIDs_Call) Run(run func(ctx context.Context, ids ...uint32)) *PersonRepo_GetByIDs_Call

+ type PersonRepo_GetCharacterRelated_Call struct

+ func (_c *PersonRepo_GetCharacterRelated_Call) Return(_a0 []domain.PersonCharacterRelation, _a1 error) *PersonRepo_GetCharacterRelated_Call

+ func (_c *PersonRepo_GetCharacterRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *PersonRepo_GetCharacterRelated_Call

+ type PersonRepo_GetSubjectRelated_Call struct

+ func (_c *PersonRepo_GetSubjectRelated_Call) Return(_a0 []domain.SubjectPersonRelation, _a1 error) *PersonRepo_GetSubjectRelated_Call

+ func (_c *PersonRepo_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *PersonRepo_GetSubjectRelated_Call

+ type PersonRepo_Get_Call struct

+ func (_c *PersonRepo_Get_Call) Return(_a0 model.Person, _a1 error) *PersonRepo_Get_Call

+ func (_c *PersonRepo_Get_Call) Run(run func(ctx context.Context, id uint32)) *PersonRepo_Get_Call

+ type PersonService struct

+ func NewPersonService(t testing.TB) *PersonService

+ func (_m *PersonService) EXPECT() *PersonService_Expecter

+ func (_m *PersonService) Get(ctx context.Context, id uint32) (model.Person, error)

+ func (_m *PersonService) GetCharacterRelated(ctx context.Context, characterID uint32) ([]model.PersonCharacterRelation, error)

+ func (_m *PersonService) GetSubjectRelated(ctx context.Context, subjectID uint32) ([]model.SubjectPersonRelation, error)

+ type PersonService_Expecter struct

+ func (_e *PersonService_Expecter) Get(ctx interface{}, id interface{}) *PersonService_Get_Call

+ func (_e *PersonService_Expecter) GetCharacterRelated(ctx interface{}, characterID interface{}) *PersonService_GetCharacterRelated_Call

+ func (_e *PersonService_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *PersonService_GetSubjectRelated_Call

+ type PersonService_GetCharacterRelated_Call struct

+ func (_c *PersonService_GetCharacterRelated_Call) Return(_a0 []model.PersonCharacterRelation, _a1 error) *PersonService_GetCharacterRelated_Call

+ func (_c *PersonService_GetCharacterRelated_Call) Run(run func(ctx context.Context, characterID uint32)) *PersonService_GetCharacterRelated_Call

+ type PersonService_GetSubjectRelated_Call struct

+ func (_c *PersonService_GetSubjectRelated_Call) Return(_a0 []model.SubjectPersonRelation, _a1 error) *PersonService_GetSubjectRelated_Call

+ func (_c *PersonService_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *PersonService_GetSubjectRelated_Call

+ type PersonService_Get_Call struct

+ func (_c *PersonService_Get_Call) Return(_a0 model.Person, _a1 error) *PersonService_Get_Call

+ func (_c *PersonService_Get_Call) Run(run func(ctx context.Context, id uint32)) *PersonService_Get_Call

+ type RateLimiter struct

+ func NewRateLimiter(t testing.TB) *RateLimiter

+ func (_m *RateLimiter) Allowed(ctx context.Context, ip string) (bool, int, error)

+ func (_m *RateLimiter) EXPECT() *RateLimiter_Expecter

+ func (_m *RateLimiter) Reset(ctx context.Context, ip string) error

+ type RateLimiter_Allowed_Call struct

+ func (_c *RateLimiter_Allowed_Call) Return(allowed bool, remain int, err error) *RateLimiter_Allowed_Call

+ func (_c *RateLimiter_Allowed_Call) Run(run func(ctx context.Context, ip string)) *RateLimiter_Allowed_Call

+ type RateLimiter_Expecter struct

+ func (_e *RateLimiter_Expecter) Allowed(ctx interface{}, ip interface{}) *RateLimiter_Allowed_Call

+ func (_e *RateLimiter_Expecter) Reset(ctx interface{}, ip interface{}) *RateLimiter_Reset_Call

+ type RateLimiter_Reset_Call struct

+ func (_c *RateLimiter_Reset_Call) Return(_a0 error) *RateLimiter_Reset_Call

+ func (_c *RateLimiter_Reset_Call) Run(run func(ctx context.Context, ip string)) *RateLimiter_Reset_Call

+ type RevisionRepo struct

+ func NewRevisionRepo(t testing.TB) *RevisionRepo

+ func (_m *RevisionRepo) CountCharacterRelated(ctx context.Context, characterID uint32) (int64, error)

+ func (_m *RevisionRepo) CountPersonRelated(ctx context.Context, personID uint32) (int64, error)

+ func (_m *RevisionRepo) CountSubjectRelated(ctx context.Context, id uint32) (int64, error)

+ func (_m *RevisionRepo) EXPECT() *RevisionRepo_Expecter

+ func (_m *RevisionRepo) GetCharacterRelated(ctx context.Context, id uint32) (model.CharacterRevision, error)

+ func (_m *RevisionRepo) GetPersonRelated(ctx context.Context, id uint32) (model.Revision, error)

+ func (_m *RevisionRepo) GetSubjectRelated(ctx context.Context, id uint32) (model.Revision, error)

+ func (_m *RevisionRepo) ListCharacterRelated(ctx context.Context, characterID uint32, limit int, offset int) ([]model.CharacterRevision, error)

+ func (_m *RevisionRepo) ListPersonRelated(ctx context.Context, personID uint32, limit int, offset int) ([]model.Revision, error)

+ func (_m *RevisionRepo) ListSubjectRelated(ctx context.Context, id uint32, limit int, offset int) ([]model.Revision, error)

+ type RevisionRepo_CountCharacterRelated_Call struct

+ func (_c *RevisionRepo_CountCharacterRelated_Call) Return(_a0 int64, _a1 error) *RevisionRepo_CountCharacterRelated_Call

+ func (_c *RevisionRepo_CountCharacterRelated_Call) Run(run func(ctx context.Context, characterID uint32)) *RevisionRepo_CountCharacterRelated_Call

+ type RevisionRepo_CountPersonRelated_Call struct

+ func (_c *RevisionRepo_CountPersonRelated_Call) Return(_a0 int64, _a1 error) *RevisionRepo_CountPersonRelated_Call

+ func (_c *RevisionRepo_CountPersonRelated_Call) Run(run func(ctx context.Context, personID uint32)) *RevisionRepo_CountPersonRelated_Call

+ type RevisionRepo_CountSubjectRelated_Call struct

+ func (_c *RevisionRepo_CountSubjectRelated_Call) Return(_a0 int64, _a1 error) *RevisionRepo_CountSubjectRelated_Call

+ func (_c *RevisionRepo_CountSubjectRelated_Call) Run(run func(ctx context.Context, id uint32)) *RevisionRepo_CountSubjectRelated_Call

+ type RevisionRepo_Expecter struct

+ func (_e *RevisionRepo_Expecter) CountCharacterRelated(ctx interface{}, characterID interface{}) *RevisionRepo_CountCharacterRelated_Call

+ func (_e *RevisionRepo_Expecter) CountPersonRelated(ctx interface{}, personID interface{}) *RevisionRepo_CountPersonRelated_Call

+ func (_e *RevisionRepo_Expecter) CountSubjectRelated(ctx interface{}, id interface{}) *RevisionRepo_CountSubjectRelated_Call

+ func (_e *RevisionRepo_Expecter) GetCharacterRelated(ctx interface{}, id interface{}) *RevisionRepo_GetCharacterRelated_Call

+ func (_e *RevisionRepo_Expecter) GetPersonRelated(ctx interface{}, id interface{}) *RevisionRepo_GetPersonRelated_Call

+ func (_e *RevisionRepo_Expecter) GetSubjectRelated(ctx interface{}, id interface{}) *RevisionRepo_GetSubjectRelated_Call

+ func (_e *RevisionRepo_Expecter) ListCharacterRelated(ctx interface{}, characterID interface{}, limit interface{}, ...) *RevisionRepo_ListCharacterRelated_Call

+ func (_e *RevisionRepo_Expecter) ListPersonRelated(ctx interface{}, personID interface{}, limit interface{}, offset interface{}) *RevisionRepo_ListPersonRelated_Call

+ func (_e *RevisionRepo_Expecter) ListSubjectRelated(ctx interface{}, id interface{}, limit interface{}, offset interface{}) *RevisionRepo_ListSubjectRelated_Call

+ type RevisionRepo_GetCharacterRelated_Call struct

+ func (_c *RevisionRepo_GetCharacterRelated_Call) Return(_a0 model.CharacterRevision, _a1 error) *RevisionRepo_GetCharacterRelated_Call

+ func (_c *RevisionRepo_GetCharacterRelated_Call) Run(run func(ctx context.Context, id uint32)) *RevisionRepo_GetCharacterRelated_Call

+ type RevisionRepo_GetPersonRelated_Call struct

+ func (_c *RevisionRepo_GetPersonRelated_Call) Return(_a0 model.Revision, _a1 error) *RevisionRepo_GetPersonRelated_Call

+ func (_c *RevisionRepo_GetPersonRelated_Call) Run(run func(ctx context.Context, id uint32)) *RevisionRepo_GetPersonRelated_Call

+ type RevisionRepo_GetSubjectRelated_Call struct

+ func (_c *RevisionRepo_GetSubjectRelated_Call) Return(_a0 model.Revision, _a1 error) *RevisionRepo_GetSubjectRelated_Call

+ func (_c *RevisionRepo_GetSubjectRelated_Call) Run(run func(ctx context.Context, id uint32)) *RevisionRepo_GetSubjectRelated_Call

+ type RevisionRepo_ListCharacterRelated_Call struct

+ func (_c *RevisionRepo_ListCharacterRelated_Call) Return(_a0 []model.CharacterRevision, _a1 error) *RevisionRepo_ListCharacterRelated_Call

+ func (_c *RevisionRepo_ListCharacterRelated_Call) Run(run func(ctx context.Context, characterID uint32, limit int, offset int)) *RevisionRepo_ListCharacterRelated_Call

+ type RevisionRepo_ListPersonRelated_Call struct

+ func (_c *RevisionRepo_ListPersonRelated_Call) Return(_a0 []model.Revision, _a1 error) *RevisionRepo_ListPersonRelated_Call

+ func (_c *RevisionRepo_ListPersonRelated_Call) Run(run func(ctx context.Context, personID uint32, limit int, offset int)) *RevisionRepo_ListPersonRelated_Call

+ type RevisionRepo_ListSubjectRelated_Call struct

+ func (_c *RevisionRepo_ListSubjectRelated_Call) Return(_a0 []model.Revision, _a1 error) *RevisionRepo_ListSubjectRelated_Call

+ func (_c *RevisionRepo_ListSubjectRelated_Call) Run(run func(ctx context.Context, id uint32, limit int, offset int)) *RevisionRepo_ListSubjectRelated_Call

+ type SessionManager struct

+ func NewSessionManager(t testing.TB) *SessionManager

+ func (_m *SessionManager) Create(ctx context.Context, a domain.Auth) (string, session.Session, error)

+ func (_m *SessionManager) EXPECT() *SessionManager_Expecter

+ func (_m *SessionManager) Get(ctx context.Context, key string) (session.Session, error)

+ func (_m *SessionManager) Revoke(ctx context.Context, key string) error

+ func (_m *SessionManager) RevokeUser(ctx context.Context, id uint32) error

+ type SessionManager_Create_Call struct

+ func (_c *SessionManager_Create_Call) Return(_a0 string, _a1 session.Session, _a2 error) *SessionManager_Create_Call

+ func (_c *SessionManager_Create_Call) Run(run func(ctx context.Context, a domain.Auth)) *SessionManager_Create_Call

+ type SessionManager_Expecter struct

+ func (_e *SessionManager_Expecter) Create(ctx interface{}, a interface{}) *SessionManager_Create_Call

+ func (_e *SessionManager_Expecter) Get(ctx interface{}, key interface{}) *SessionManager_Get_Call

+ func (_e *SessionManager_Expecter) Revoke(ctx interface{}, key interface{}) *SessionManager_Revoke_Call

+ func (_e *SessionManager_Expecter) RevokeUser(ctx interface{}, id interface{}) *SessionManager_RevokeUser_Call

+ type SessionManager_Get_Call struct

+ func (_c *SessionManager_Get_Call) Return(_a0 session.Session, _a1 error) *SessionManager_Get_Call

+ func (_c *SessionManager_Get_Call) Run(run func(ctx context.Context, key string)) *SessionManager_Get_Call

+ type SessionManager_RevokeUser_Call struct

+ func (_c *SessionManager_RevokeUser_Call) Return(_a0 error) *SessionManager_RevokeUser_Call

+ func (_c *SessionManager_RevokeUser_Call) Run(run func(ctx context.Context, id uint32)) *SessionManager_RevokeUser_Call

+ type SessionManager_Revoke_Call struct

+ func (_c *SessionManager_Revoke_Call) Return(_a0 error) *SessionManager_Revoke_Call

+ func (_c *SessionManager_Revoke_Call) Run(run func(ctx context.Context, key string)) *SessionManager_Revoke_Call

+ type SubjectRepo struct

+ func NewSubjectRepo(t testing.TB) *SubjectRepo

+ func (_m *SubjectRepo) EXPECT() *SubjectRepo_Expecter

+ func (_m *SubjectRepo) Get(ctx context.Context, id uint32) (model.Subject, error)

+ func (_m *SubjectRepo) GetActors(ctx context.Context, subjectID uint32, characterIDs ...uint32) (map[uint32][]model.Person, error)

+ func (_m *SubjectRepo) GetByIDs(ctx context.Context, ids ...uint32) (map[uint32]model.Subject, error)

+ func (_m *SubjectRepo) GetCharacterRelated(ctx context.Context, characterID uint32) ([]domain.SubjectCharacterRelation, error)

+ func (_m *SubjectRepo) GetPersonRelated(ctx context.Context, personID uint32) ([]domain.SubjectPersonRelation, error)

+ func (_m *SubjectRepo) GetSubjectRelated(ctx context.Context, subjectID uint32) ([]domain.SubjectInternalRelation, error)

+ type SubjectRepo_Expecter struct

+ func (_e *SubjectRepo_Expecter) Get(ctx interface{}, id interface{}) *SubjectRepo_Get_Call

+ func (_e *SubjectRepo_Expecter) GetActors(ctx interface{}, subjectID interface{}, characterIDs ...interface{}) *SubjectRepo_GetActors_Call

+ func (_e *SubjectRepo_Expecter) GetByIDs(ctx interface{}, ids ...interface{}) *SubjectRepo_GetByIDs_Call

+ func (_e *SubjectRepo_Expecter) GetCharacterRelated(ctx interface{}, characterID interface{}) *SubjectRepo_GetCharacterRelated_Call

+ func (_e *SubjectRepo_Expecter) GetPersonRelated(ctx interface{}, personID interface{}) *SubjectRepo_GetPersonRelated_Call

+ func (_e *SubjectRepo_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *SubjectRepo_GetSubjectRelated_Call

+ type SubjectRepo_GetActors_Call struct

+ func (_c *SubjectRepo_GetActors_Call) Return(_a0 map[uint32][]model.Person, _a1 error) *SubjectRepo_GetActors_Call

+ func (_c *SubjectRepo_GetActors_Call) Run(run func(ctx context.Context, subjectID uint32, characterIDs ...uint32)) *SubjectRepo_GetActors_Call

+ type SubjectRepo_GetByIDs_Call struct

+ func (_c *SubjectRepo_GetByIDs_Call) Return(_a0 map[uint32]model.Subject, _a1 error) *SubjectRepo_GetByIDs_Call

+ func (_c *SubjectRepo_GetByIDs_Call) Run(run func(ctx context.Context, ids ...uint32)) *SubjectRepo_GetByIDs_Call

+ type SubjectRepo_GetCharacterRelated_Call struct

+ func (_c *SubjectRepo_GetCharacterRelated_Call) Return(_a0 []domain.SubjectCharacterRelation, _a1 error) *SubjectRepo_GetCharacterRelated_Call

+ func (_c *SubjectRepo_GetCharacterRelated_Call) Run(run func(ctx context.Context, characterID uint32)) *SubjectRepo_GetCharacterRelated_Call

+ type SubjectRepo_GetPersonRelated_Call struct

+ func (_c *SubjectRepo_GetPersonRelated_Call) Return(_a0 []domain.SubjectPersonRelation, _a1 error) *SubjectRepo_GetPersonRelated_Call

+ func (_c *SubjectRepo_GetPersonRelated_Call) Run(run func(ctx context.Context, personID uint32)) *SubjectRepo_GetPersonRelated_Call

+ type SubjectRepo_GetSubjectRelated_Call struct

+ func (_c *SubjectRepo_GetSubjectRelated_Call) Return(_a0 []domain.SubjectInternalRelation, _a1 error) *SubjectRepo_GetSubjectRelated_Call

+ func (_c *SubjectRepo_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *SubjectRepo_GetSubjectRelated_Call

+ type SubjectRepo_Get_Call struct

+ func (_c *SubjectRepo_Get_Call) Return(_a0 model.Subject, _a1 error) *SubjectRepo_Get_Call

+ func (_c *SubjectRepo_Get_Call) Run(run func(ctx context.Context, id uint32)) *SubjectRepo_Get_Call

+ type SubjectService struct

+ func NewSubjectService(t testing.TB) *SubjectService

+ func (_m *SubjectService) EXPECT() *SubjectService_Expecter

+ func (_m *SubjectService) Get(ctx context.Context, id uint32) (model.Subject, error)

+ func (_m *SubjectService) GetActors(ctx context.Context, subjectID uint32, characterIDs ...uint32) (map[uint32][]model.Person, error)

+ func (_m *SubjectService) GetCharacterRelated(ctx context.Context, characterID uint32) ([]model.SubjectCharacterRelation, error)

+ func (_m *SubjectService) GetPersonRelated(ctx context.Context, personID uint32) ([]model.SubjectPersonRelation, error)

+ func (_m *SubjectService) GetSubjectRelated(ctx context.Context, subjectID uint32) ([]model.SubjectInternalRelation, error)

+ type SubjectService_Expecter struct

+ func (_e *SubjectService_Expecter) Get(ctx interface{}, id interface{}) *SubjectService_Get_Call

+ func (_e *SubjectService_Expecter) GetActors(ctx interface{}, subjectID interface{}, characterIDs ...interface{}) *SubjectService_GetActors_Call

+ func (_e *SubjectService_Expecter) GetCharacterRelated(ctx interface{}, characterID interface{}) *SubjectService_GetCharacterRelated_Call

+ func (_e *SubjectService_Expecter) GetPersonRelated(ctx interface{}, personID interface{}) *SubjectService_GetPersonRelated_Call

+ func (_e *SubjectService_Expecter) GetSubjectRelated(ctx interface{}, subjectID interface{}) *SubjectService_GetSubjectRelated_Call

+ type SubjectService_GetActors_Call struct

+ func (_c *SubjectService_GetActors_Call) Return(_a0 map[uint32][]model.Person, _a1 error) *SubjectService_GetActors_Call

+ func (_c *SubjectService_GetActors_Call) Run(run func(ctx context.Context, subjectID uint32, characterIDs ...uint32)) *SubjectService_GetActors_Call

+ type SubjectService_GetCharacterRelated_Call struct

+ func (_c *SubjectService_GetCharacterRelated_Call) Return(_a0 []model.SubjectCharacterRelation, _a1 error) *SubjectService_GetCharacterRelated_Call

+ func (_c *SubjectService_GetCharacterRelated_Call) Run(run func(ctx context.Context, characterID uint32)) *SubjectService_GetCharacterRelated_Call

+ type SubjectService_GetPersonRelated_Call struct

+ func (_c *SubjectService_GetPersonRelated_Call) Return(_a0 []model.SubjectPersonRelation, _a1 error) *SubjectService_GetPersonRelated_Call

+ func (_c *SubjectService_GetPersonRelated_Call) Run(run func(ctx context.Context, personID uint32)) *SubjectService_GetPersonRelated_Call

+ type SubjectService_GetSubjectRelated_Call struct

+ func (_c *SubjectService_GetSubjectRelated_Call) Return(_a0 []model.SubjectInternalRelation, _a1 error) *SubjectService_GetSubjectRelated_Call

+ func (_c *SubjectService_GetSubjectRelated_Call) Run(run func(ctx context.Context, subjectID uint32)) *SubjectService_GetSubjectRelated_Call

+ type SubjectService_Get_Call struct

+ func (_c *SubjectService_Get_Call) Return(_a0 model.Subject, _a1 error) *SubjectService_Get_Call

+ func (_c *SubjectService_Get_Call) Run(run func(ctx context.Context, id uint32)) *SubjectService_Get_Call

+ type UserRepo struct

+ func NewUserRepo(t testing.TB) *UserRepo

+ func (_m *UserRepo) CountCollections(ctx context.Context, userID uint32, subjectType uint8, collectionType uint8, ...) (int64, error)

+ func (_m *UserRepo) EXPECT() *UserRepo_Expecter

+ func (_m *UserRepo) GetByID(ctx context.Context, userID uint32) (model.User, error)

+ func (_m *UserRepo) GetByIDs(ctx context.Context, ids ...uint32) (map[uint32]model.User, error)

+ func (_m *UserRepo) GetByName(ctx context.Context, username string) (model.User, error)

+ func (_m *UserRepo) GetCollection(ctx context.Context, userID uint32, subjectID uint32) (model.Collection, error)

+ func (_m *UserRepo) ListCollections(ctx context.Context, userID uint32, subjectType uint8, collectionType uint8, ...) ([]model.Collection, error)

+ type UserRepo_CountCollections_Call struct

+ func (_c *UserRepo_CountCollections_Call) Return(_a0 int64, _a1 error) *UserRepo_CountCollections_Call

+ func (_c *UserRepo_CountCollections_Call) Run(...) *UserRepo_CountCollections_Call

+ type UserRepo_Expecter struct

+ func (_e *UserRepo_Expecter) CountCollections(ctx interface{}, userID interface{}, subjectType interface{}, ...) *UserRepo_CountCollections_Call

+ func (_e *UserRepo_Expecter) GetByID(ctx interface{}, userID interface{}) *UserRepo_GetByID_Call

+ func (_e *UserRepo_Expecter) GetByIDs(ctx interface{}, ids ...interface{}) *UserRepo_GetByIDs_Call

+ func (_e *UserRepo_Expecter) GetByName(ctx interface{}, username interface{}) *UserRepo_GetByName_Call

+ func (_e *UserRepo_Expecter) GetCollection(ctx interface{}, userID interface{}, subjectID interface{}) *UserRepo_GetCollection_Call

+ func (_e *UserRepo_Expecter) ListCollections(ctx interface{}, userID interface{}, subjectType interface{}, ...) *UserRepo_ListCollections_Call

+ type UserRepo_GetByID_Call struct

+ func (_c *UserRepo_GetByID_Call) Return(_a0 model.User, _a1 error) *UserRepo_GetByID_Call

+ func (_c *UserRepo_GetByID_Call) Run(run func(ctx context.Context, userID uint32)) *UserRepo_GetByID_Call

+ type UserRepo_GetByIDs_Call struct

+ func (_c *UserRepo_GetByIDs_Call) Return(_a0 map[uint32]model.User, _a1 error) *UserRepo_GetByIDs_Call

+ func (_c *UserRepo_GetByIDs_Call) Run(run func(ctx context.Context, ids ...uint32)) *UserRepo_GetByIDs_Call

+ type UserRepo_GetByName_Call struct

+ func (_c *UserRepo_GetByName_Call) Return(_a0 model.User, _a1 error) *UserRepo_GetByName_Call

+ func (_c *UserRepo_GetByName_Call) Run(run func(ctx context.Context, username string)) *UserRepo_GetByName_Call

+ type UserRepo_GetCollection_Call struct

+ func (_c *UserRepo_GetCollection_Call) Return(_a0 model.Collection, _a1 error) *UserRepo_GetCollection_Call

+ func (_c *UserRepo_GetCollection_Call) Run(run func(ctx context.Context, userID uint32, subjectID uint32)) *UserRepo_GetCollection_Call

+ type UserRepo_ListCollections_Call struct

+ func (_c *UserRepo_ListCollections_Call) Return(_a0 []model.Collection, _a1 error) *UserRepo_ListCollections_Call

+ func (_c *UserRepo_ListCollections_Call) Run(...) *UserRepo_ListCollections_Call