mocks

Mar 23, 2026

Changes in this version

type MockClientUseCase

+ func (_mock *MockClientUseCase) RotateSecret(ctx context.Context, clientID uuid.UUID) (*domain.CreateClientOutput, error)

type MockClientUseCase_Expecter

+ func (_e *MockClientUseCase_Expecter) RotateSecret(ctx interface{}, clientID interface{}) *MockClientUseCase_RotateSecret_Call

+ type MockClientUseCase_RotateSecret_Call struct

+ func (_c *MockClientUseCase_RotateSecret_Call) Return(createClientOutput *domain.CreateClientOutput, err error) *MockClientUseCase_RotateSecret_Call

+ func (_c *MockClientUseCase_RotateSecret_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockClientUseCase_RotateSecret_Call

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

Mar 6, 2026

Changes in this version

type MockClientUseCase

+ func (_mock *MockClientUseCase) RevokeTokens(ctx context.Context, clientID uuid.UUID) error

type MockClientUseCase_Expecter

+ func (_e *MockClientUseCase_Expecter) RevokeTokens(ctx interface{}, clientID interface{}) *MockClientUseCase_RevokeTokens_Call

+ type MockClientUseCase_RevokeTokens_Call struct

+ func (_c *MockClientUseCase_RevokeTokens_Call) Return(err error) *MockClientUseCase_RevokeTokens_Call

+ func (_c *MockClientUseCase_RevokeTokens_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockClientUseCase_RevokeTokens_Call

+ func (_c *MockClientUseCase_RevokeTokens_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID) error) *MockClientUseCase_RevokeTokens_Call

type MockTokenRepository

+ func (_mock *MockTokenRepository) PurgeExpiredAndRevoked(ctx context.Context, olderThan time.Time) (int64, error)

+ func (_mock *MockTokenRepository) RevokeByClientID(ctx context.Context, clientID uuid.UUID) error

+ func (_mock *MockTokenRepository) RevokeByTokenID(ctx context.Context, tokenID uuid.UUID) error

type MockTokenRepository_Expecter

+ func (_e *MockTokenRepository_Expecter) PurgeExpiredAndRevoked(ctx interface{}, olderThan interface{}) *MockTokenRepository_PurgeExpiredAndRevoked_Call

+ func (_e *MockTokenRepository_Expecter) RevokeByClientID(ctx interface{}, clientID interface{}) *MockTokenRepository_RevokeByClientID_Call

+ func (_e *MockTokenRepository_Expecter) RevokeByTokenID(ctx interface{}, tokenID interface{}) *MockTokenRepository_RevokeByTokenID_Call

+ type MockTokenRepository_PurgeExpiredAndRevoked_Call struct

+ func (_c *MockTokenRepository_PurgeExpiredAndRevoked_Call) Return(n int64, err error) *MockTokenRepository_PurgeExpiredAndRevoked_Call

+ func (_c *MockTokenRepository_PurgeExpiredAndRevoked_Call) Run(run func(ctx context.Context, olderThan time.Time)) *MockTokenRepository_PurgeExpiredAndRevoked_Call

+ func (_c *MockTokenRepository_PurgeExpiredAndRevoked_Call) RunAndReturn(run func(ctx context.Context, olderThan time.Time) (int64, error)) *MockTokenRepository_PurgeExpiredAndRevoked_Call

+ type MockTokenRepository_RevokeByClientID_Call struct

+ func (_c *MockTokenRepository_RevokeByClientID_Call) Return(err error) *MockTokenRepository_RevokeByClientID_Call

+ func (_c *MockTokenRepository_RevokeByClientID_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockTokenRepository_RevokeByClientID_Call

+ func (_c *MockTokenRepository_RevokeByClientID_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID) error) *MockTokenRepository_RevokeByClientID_Call

+ type MockTokenRepository_RevokeByTokenID_Call struct

+ func (_c *MockTokenRepository_RevokeByTokenID_Call) Return(err error) *MockTokenRepository_RevokeByTokenID_Call

+ func (_c *MockTokenRepository_RevokeByTokenID_Call) Run(run func(ctx context.Context, tokenID uuid.UUID)) *MockTokenRepository_RevokeByTokenID_Call

+ func (_c *MockTokenRepository_RevokeByTokenID_Call) RunAndReturn(run func(ctx context.Context, tokenID uuid.UUID) error) *MockTokenRepository_RevokeByTokenID_Call

type MockTokenUseCase

+ func (_mock *MockTokenUseCase) PurgeExpiredAndRevoked(ctx context.Context, days int) (int64, error)

+ func (_mock *MockTokenUseCase) Revoke(ctx context.Context, tokenHash string) error

type MockTokenUseCase_Expecter

+ func (_e *MockTokenUseCase_Expecter) PurgeExpiredAndRevoked(ctx interface{}, days interface{}) *MockTokenUseCase_PurgeExpiredAndRevoked_Call

+ func (_e *MockTokenUseCase_Expecter) Revoke(ctx interface{}, tokenHash interface{}) *MockTokenUseCase_Revoke_Call

+ type MockTokenUseCase_PurgeExpiredAndRevoked_Call struct

+ func (_c *MockTokenUseCase_PurgeExpiredAndRevoked_Call) Return(n int64, err error) *MockTokenUseCase_PurgeExpiredAndRevoked_Call

+ func (_c *MockTokenUseCase_PurgeExpiredAndRevoked_Call) Run(run func(ctx context.Context, days int)) *MockTokenUseCase_PurgeExpiredAndRevoked_Call

+ func (_c *MockTokenUseCase_PurgeExpiredAndRevoked_Call) RunAndReturn(run func(ctx context.Context, days int) (int64, error)) *MockTokenUseCase_PurgeExpiredAndRevoked_Call

+ type MockTokenUseCase_Revoke_Call struct

+ func (_c *MockTokenUseCase_Revoke_Call) Return(err error) *MockTokenUseCase_Revoke_Call

+ func (_c *MockTokenUseCase_Revoke_Call) Run(run func(ctx context.Context, tokenHash string)) *MockTokenUseCase_Revoke_Call

+ func (_c *MockTokenUseCase_Revoke_Call) RunAndReturn(run func(ctx context.Context, tokenHash string) error) *MockTokenUseCase_Revoke_Call

Mar 4, 2026

Changes in this version

type MockAuditLogRepository

+ func (_mock *MockAuditLogRepository) ListCursor(ctx context.Context, afterID *uuid.UUID, limit int, createdAtFrom *time.Time, ...) ([]*domain.AuditLog, error)

type MockAuditLogRepository_Expecter

+ func (_e *MockAuditLogRepository_Expecter) ListCursor(ctx interface{}, afterID interface{}, limit interface{}, ...) *MockAuditLogRepository_ListCursor_Call

+ type MockAuditLogRepository_ListCursor_Call struct

+ func (_c *MockAuditLogRepository_ListCursor_Call) Return(auditLogs []*domain.AuditLog, err error) *MockAuditLogRepository_ListCursor_Call

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

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

type MockAuditLogUseCase

+ func (_mock *MockAuditLogUseCase) ListCursor(ctx context.Context, afterID *uuid.UUID, limit int, createdAtFrom *time.Time, ...) ([]*domain.AuditLog, error)

type MockAuditLogUseCase_Expecter

+ func (_e *MockAuditLogUseCase_Expecter) ListCursor(ctx interface{}, afterID interface{}, limit interface{}, ...) *MockAuditLogUseCase_ListCursor_Call

+ type MockAuditLogUseCase_ListCursor_Call struct

+ func (_c *MockAuditLogUseCase_ListCursor_Call) Return(auditLogs []*domain.AuditLog, err error) *MockAuditLogUseCase_ListCursor_Call

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

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

type MockClientRepository

+ func (_mock *MockClientRepository) ListCursor(ctx context.Context, afterID *uuid.UUID, limit int) ([]*domain.Client, error)

type MockClientRepository_Expecter

+ func (_e *MockClientRepository_Expecter) ListCursor(ctx interface{}, afterID interface{}, limit interface{}) *MockClientRepository_ListCursor_Call

+ type MockClientRepository_ListCursor_Call struct

+ func (_c *MockClientRepository_ListCursor_Call) Return(clients []*domain.Client, err error) *MockClientRepository_ListCursor_Call

+ func (_c *MockClientRepository_ListCursor_Call) Run(run func(ctx context.Context, afterID *uuid.UUID, limit int)) *MockClientRepository_ListCursor_Call

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

type MockClientUseCase

+ func (_mock *MockClientUseCase) ListCursor(ctx context.Context, afterID *uuid.UUID, limit int) ([]*domain.Client, error)

type MockClientUseCase_Expecter

+ func (_e *MockClientUseCase_Expecter) ListCursor(ctx interface{}, afterID interface{}, limit interface{}) *MockClientUseCase_ListCursor_Call

+ type MockClientUseCase_ListCursor_Call struct

+ func (_c *MockClientUseCase_ListCursor_Call) Return(clients []*domain.Client, err error) *MockClientUseCase_ListCursor_Call

+ func (_c *MockClientUseCase_ListCursor_Call) Run(run func(ctx context.Context, afterID *uuid.UUID, limit int)) *MockClientUseCase_ListCursor_Call

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

Feb 25, 2026

Changes in this version

type MockAuditLogRepository

+ func (_mock *MockAuditLogRepository) Get(ctx context.Context, id uuid.UUID) (*domain.AuditLog, error)

type MockAuditLogRepository_Expecter

+ func (_e *MockAuditLogRepository_Expecter) Get(ctx interface{}, id interface{}) *MockAuditLogRepository_Get_Call

+ type MockAuditLogRepository_Get_Call struct

+ func (_c *MockAuditLogRepository_Get_Call) Return(auditLog *domain.AuditLog, err error) *MockAuditLogRepository_Get_Call

+ func (_c *MockAuditLogRepository_Get_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockAuditLogRepository_Get_Call

+ func (_c *MockAuditLogRepository_Get_Call) RunAndReturn(run func(ctx context.Context, id uuid.UUID) (*domain.AuditLog, error)) *MockAuditLogRepository_Get_Call

type MockAuditLogUseCase_Expecter

+ func (_e *MockAuditLogUseCase_Expecter) VerifyBatch(ctx interface{}, startTime interface{}, endTime interface{}) *MockAuditLogUseCase_VerifyBatch_Call

+ func (_e *MockAuditLogUseCase_Expecter) VerifyIntegrity(ctx interface{}, id interface{}) *MockAuditLogUseCase_VerifyIntegrity_Call

+ type MockAuditLogUseCase_VerifyBatch_Call struct

+ func (_c *MockAuditLogUseCase_VerifyBatch_Call) Return(verificationReport *usecase.VerificationReport, err error) *MockAuditLogUseCase_VerifyBatch_Call

+ func (_c *MockAuditLogUseCase_VerifyBatch_Call) Run(run func(ctx context.Context, startTime time.Time, endTime time.Time)) *MockAuditLogUseCase_VerifyBatch_Call

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

+ type MockAuditLogUseCase_VerifyIntegrity_Call struct

+ func (_c *MockAuditLogUseCase_VerifyIntegrity_Call) Return(err error) *MockAuditLogUseCase_VerifyIntegrity_Call

+ func (_c *MockAuditLogUseCase_VerifyIntegrity_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockAuditLogUseCase_VerifyIntegrity_Call

+ func (_c *MockAuditLogUseCase_VerifyIntegrity_Call) RunAndReturn(run func(ctx context.Context, id uuid.UUID) error) *MockAuditLogUseCase_VerifyIntegrity_Call

Feb 23, 2026

Changes in this version

type MockClientRepository

+ func (_mock *MockClientRepository) UpdateLockState(ctx context.Context, clientID uuid.UUID, failedAttempts int, ...) error

type MockClientRepository_Expecter

+ func (_e *MockClientRepository_Expecter) UpdateLockState(ctx interface{}, clientID interface{}, failedAttempts interface{}, ...) *MockClientRepository_UpdateLockState_Call

+ type MockClientRepository_UpdateLockState_Call struct

+ func (_c *MockClientRepository_UpdateLockState_Call) Return(err error) *MockClientRepository_UpdateLockState_Call

+ func (_c *MockClientRepository_UpdateLockState_Call) Run(run func(ctx context.Context, clientID uuid.UUID, failedAttempts int, ...)) *MockClientRepository_UpdateLockState_Call

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

type MockClientUseCase

+ func (_mock *MockClientUseCase) Unlock(ctx context.Context, clientID uuid.UUID) error

type MockClientUseCase_Expecter

+ func (_e *MockClientUseCase_Expecter) Unlock(ctx interface{}, clientID interface{}) *MockClientUseCase_Unlock_Call

+ type MockClientUseCase_Unlock_Call struct

+ func (_c *MockClientUseCase_Unlock_Call) Return(err error) *MockClientUseCase_Unlock_Call

+ func (_c *MockClientUseCase_Unlock_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockClientUseCase_Unlock_Call

+ func (_c *MockClientUseCase_Unlock_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID) error) *MockClientUseCase_Unlock_Call

Feb 21, 2026

Changes in this version

type MockAuditLogUseCase

+ func (_m *MockAuditLogUseCase) VerifyBatch(ctx context.Context, startTime time.Time, endTime time.Time) (*usecase.VerificationReport, error)

+ func (_m *MockAuditLogUseCase) VerifyIntegrity(ctx context.Context, id uuid.UUID) error

Feb 14, 2026

Changes in this version

type MockAuditLogRepository

+ func (_mock *MockAuditLogRepository) DeleteOlderThan(ctx context.Context, olderThan time.Time, dryRun bool) (int64, error)

+ type MockAuditLogRepository_DeleteOlderThan_Call struct

+ func (_c *MockAuditLogRepository_DeleteOlderThan_Call) Return(n int64, err error) *MockAuditLogRepository_DeleteOlderThan_Call

+ func (_c *MockAuditLogRepository_DeleteOlderThan_Call) Run(run func(ctx context.Context, olderThan time.Time, dryRun bool)) *MockAuditLogRepository_DeleteOlderThan_Call

+ func (_c *MockAuditLogRepository_DeleteOlderThan_Call) RunAndReturn(run func(ctx context.Context, olderThan time.Time, dryRun bool) (int64, error)) *MockAuditLogRepository_DeleteOlderThan_Call

type MockAuditLogRepository_Expecter

+ func (_e *MockAuditLogRepository_Expecter) DeleteOlderThan(ctx interface{}, olderThan interface{}, dryRun interface{}) *MockAuditLogRepository_DeleteOlderThan_Call

type MockAuditLogUseCase

+ func (_mock *MockAuditLogUseCase) DeleteOlderThan(ctx context.Context, days int, dryRun bool) (int64, error)

+ type MockAuditLogUseCase_DeleteOlderThan_Call struct

+ func (_c *MockAuditLogUseCase_DeleteOlderThan_Call) Return(n int64, err error) *MockAuditLogUseCase_DeleteOlderThan_Call

+ func (_c *MockAuditLogUseCase_DeleteOlderThan_Call) Run(run func(ctx context.Context, days int, dryRun bool)) *MockAuditLogUseCase_DeleteOlderThan_Call

+ func (_c *MockAuditLogUseCase_DeleteOlderThan_Call) RunAndReturn(run func(ctx context.Context, days int, dryRun bool) (int64, error)) *MockAuditLogUseCase_DeleteOlderThan_Call

type MockAuditLogUseCase_Expecter

+ func (_e *MockAuditLogUseCase_Expecter) DeleteOlderThan(ctx interface{}, days interface{}, dryRun interface{}) *MockAuditLogUseCase_DeleteOlderThan_Call

Feb 14, 2026

Changes in this version

+ type MockAuditLogRepository struct

+ func NewMockAuditLogRepository(t interface{ ... }) *MockAuditLogRepository

+ func (_m *MockAuditLogRepository) EXPECT() *MockAuditLogRepository_Expecter

+ func (_mock *MockAuditLogRepository) Create(ctx context.Context, auditLog *domain.AuditLog) error

+ func (_mock *MockAuditLogRepository) List(ctx context.Context, offset int, limit int, createdAtFrom *time.Time, ...) ([]*domain.AuditLog, error)

+ type MockAuditLogRepository_Create_Call struct

+ func (_c *MockAuditLogRepository_Create_Call) Return(err error) *MockAuditLogRepository_Create_Call

+ func (_c *MockAuditLogRepository_Create_Call) Run(run func(ctx context.Context, auditLog *domain.AuditLog)) *MockAuditLogRepository_Create_Call

+ func (_c *MockAuditLogRepository_Create_Call) RunAndReturn(run func(ctx context.Context, auditLog *domain.AuditLog) error) *MockAuditLogRepository_Create_Call

+ type MockAuditLogRepository_Expecter struct

+ func (_e *MockAuditLogRepository_Expecter) Create(ctx interface{}, auditLog interface{}) *MockAuditLogRepository_Create_Call

+ func (_e *MockAuditLogRepository_Expecter) List(ctx interface{}, offset interface{}, limit interface{}, ...) *MockAuditLogRepository_List_Call

+ type MockAuditLogRepository_List_Call struct

+ func (_c *MockAuditLogRepository_List_Call) Return(auditLogs []*domain.AuditLog, err error) *MockAuditLogRepository_List_Call

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

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

+ type MockAuditLogUseCase struct

+ func NewMockAuditLogUseCase(t interface{ ... }) *MockAuditLogUseCase

+ func (_m *MockAuditLogUseCase) EXPECT() *MockAuditLogUseCase_Expecter

+ func (_mock *MockAuditLogUseCase) Create(ctx context.Context, requestID uuid.UUID, clientID uuid.UUID, ...) error

+ func (_mock *MockAuditLogUseCase) List(ctx context.Context, offset int, limit int, createdAtFrom *time.Time, ...) ([]*domain.AuditLog, error)

+ type MockAuditLogUseCase_Create_Call struct

+ func (_c *MockAuditLogUseCase_Create_Call) Return(err error) *MockAuditLogUseCase_Create_Call

+ func (_c *MockAuditLogUseCase_Create_Call) Run(run func(ctx context.Context, requestID uuid.UUID, clientID uuid.UUID, ...)) *MockAuditLogUseCase_Create_Call

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

+ type MockAuditLogUseCase_Expecter struct

+ func (_e *MockAuditLogUseCase_Expecter) Create(ctx interface{}, requestID interface{}, clientID interface{}, ...) *MockAuditLogUseCase_Create_Call

+ func (_e *MockAuditLogUseCase_Expecter) List(ctx interface{}, offset interface{}, limit interface{}, ...) *MockAuditLogUseCase_List_Call

+ type MockAuditLogUseCase_List_Call struct

+ func (_c *MockAuditLogUseCase_List_Call) Return(auditLogs []*domain.AuditLog, err error) *MockAuditLogUseCase_List_Call

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

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

+ type MockClientRepository struct

+ func NewMockClientRepository(t interface{ ... }) *MockClientRepository

+ func (_m *MockClientRepository) EXPECT() *MockClientRepository_Expecter

+ func (_mock *MockClientRepository) Create(ctx context.Context, client *domain.Client) error

+ func (_mock *MockClientRepository) Get(ctx context.Context, clientID uuid.UUID) (*domain.Client, error)

+ func (_mock *MockClientRepository) List(ctx context.Context, offset int, limit int) ([]*domain.Client, error)

+ func (_mock *MockClientRepository) Update(ctx context.Context, client *domain.Client) error

+ type MockClientRepository_Create_Call struct

+ func (_c *MockClientRepository_Create_Call) Return(err error) *MockClientRepository_Create_Call

+ func (_c *MockClientRepository_Create_Call) Run(run func(ctx context.Context, client *domain.Client)) *MockClientRepository_Create_Call

+ func (_c *MockClientRepository_Create_Call) RunAndReturn(run func(ctx context.Context, client *domain.Client) error) *MockClientRepository_Create_Call

+ type MockClientRepository_Expecter struct

+ func (_e *MockClientRepository_Expecter) Create(ctx interface{}, client interface{}) *MockClientRepository_Create_Call

+ func (_e *MockClientRepository_Expecter) Get(ctx interface{}, clientID interface{}) *MockClientRepository_Get_Call

+ func (_e *MockClientRepository_Expecter) List(ctx interface{}, offset interface{}, limit interface{}) *MockClientRepository_List_Call

+ func (_e *MockClientRepository_Expecter) Update(ctx interface{}, client interface{}) *MockClientRepository_Update_Call

+ type MockClientRepository_Get_Call struct

+ func (_c *MockClientRepository_Get_Call) Return(client *domain.Client, err error) *MockClientRepository_Get_Call

+ func (_c *MockClientRepository_Get_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockClientRepository_Get_Call

+ func (_c *MockClientRepository_Get_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID) (*domain.Client, error)) *MockClientRepository_Get_Call

+ type MockClientRepository_List_Call struct

+ func (_c *MockClientRepository_List_Call) Return(clients []*domain.Client, err error) *MockClientRepository_List_Call

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

+ func (_c *MockClientRepository_List_Call) RunAndReturn(run func(ctx context.Context, offset int, limit int) ([]*domain.Client, error)) *MockClientRepository_List_Call

+ type MockClientRepository_Update_Call struct

+ func (_c *MockClientRepository_Update_Call) Return(err error) *MockClientRepository_Update_Call

+ func (_c *MockClientRepository_Update_Call) Run(run func(ctx context.Context, client *domain.Client)) *MockClientRepository_Update_Call

+ func (_c *MockClientRepository_Update_Call) RunAndReturn(run func(ctx context.Context, client *domain.Client) error) *MockClientRepository_Update_Call

+ type MockClientUseCase struct

+ func NewMockClientUseCase(t interface{ ... }) *MockClientUseCase

+ func (_m *MockClientUseCase) EXPECT() *MockClientUseCase_Expecter

+ func (_mock *MockClientUseCase) Create(ctx context.Context, createClientInput *domain.CreateClientInput) (*domain.CreateClientOutput, error)

+ func (_mock *MockClientUseCase) Delete(ctx context.Context, clientID uuid.UUID) error

+ func (_mock *MockClientUseCase) Get(ctx context.Context, clientID uuid.UUID) (*domain.Client, error)

+ func (_mock *MockClientUseCase) List(ctx context.Context, offset int, limit int) ([]*domain.Client, error)

+ func (_mock *MockClientUseCase) Update(ctx context.Context, clientID uuid.UUID, ...) error

+ type MockClientUseCase_Create_Call struct

+ func (_c *MockClientUseCase_Create_Call) Return(createClientOutput *domain.CreateClientOutput, err error) *MockClientUseCase_Create_Call

+ func (_c *MockClientUseCase_Create_Call) Run(run func(ctx context.Context, createClientInput *domain.CreateClientInput)) *MockClientUseCase_Create_Call

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

+ type MockClientUseCase_Delete_Call struct

+ func (_c *MockClientUseCase_Delete_Call) Return(err error) *MockClientUseCase_Delete_Call

+ func (_c *MockClientUseCase_Delete_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockClientUseCase_Delete_Call

+ func (_c *MockClientUseCase_Delete_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID) error) *MockClientUseCase_Delete_Call

+ type MockClientUseCase_Expecter struct

+ func (_e *MockClientUseCase_Expecter) Create(ctx interface{}, createClientInput interface{}) *MockClientUseCase_Create_Call

+ func (_e *MockClientUseCase_Expecter) Delete(ctx interface{}, clientID interface{}) *MockClientUseCase_Delete_Call

+ func (_e *MockClientUseCase_Expecter) Get(ctx interface{}, clientID interface{}) *MockClientUseCase_Get_Call

+ func (_e *MockClientUseCase_Expecter) List(ctx interface{}, offset interface{}, limit interface{}) *MockClientUseCase_List_Call

+ func (_e *MockClientUseCase_Expecter) Update(ctx interface{}, clientID interface{}, updateClientInput interface{}) *MockClientUseCase_Update_Call

+ type MockClientUseCase_Get_Call struct

+ func (_c *MockClientUseCase_Get_Call) Return(client *domain.Client, err error) *MockClientUseCase_Get_Call

+ func (_c *MockClientUseCase_Get_Call) Run(run func(ctx context.Context, clientID uuid.UUID)) *MockClientUseCase_Get_Call

+ func (_c *MockClientUseCase_Get_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID) (*domain.Client, error)) *MockClientUseCase_Get_Call

+ type MockClientUseCase_List_Call struct

+ func (_c *MockClientUseCase_List_Call) Return(clients []*domain.Client, err error) *MockClientUseCase_List_Call

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

+ func (_c *MockClientUseCase_List_Call) RunAndReturn(run func(ctx context.Context, offset int, limit int) ([]*domain.Client, error)) *MockClientUseCase_List_Call

+ type MockClientUseCase_Update_Call struct

+ func (_c *MockClientUseCase_Update_Call) Return(err error) *MockClientUseCase_Update_Call

+ func (_c *MockClientUseCase_Update_Call) Run(run func(ctx context.Context, clientID uuid.UUID, ...)) *MockClientUseCase_Update_Call

+ func (_c *MockClientUseCase_Update_Call) RunAndReturn(run func(ctx context.Context, clientID uuid.UUID, ...) error) *MockClientUseCase_Update_Call

+ type MockTokenRepository struct

+ func NewMockTokenRepository(t interface{ ... }) *MockTokenRepository

+ func (_m *MockTokenRepository) EXPECT() *MockTokenRepository_Expecter

+ func (_mock *MockTokenRepository) Create(ctx context.Context, token *domain.Token) error

+ func (_mock *MockTokenRepository) Get(ctx context.Context, tokenID uuid.UUID) (*domain.Token, error)

+ func (_mock *MockTokenRepository) GetByTokenHash(ctx context.Context, tokenHash string) (*domain.Token, error)

+ func (_mock *MockTokenRepository) Update(ctx context.Context, token *domain.Token) error

+ type MockTokenRepository_Create_Call struct

+ func (_c *MockTokenRepository_Create_Call) Return(err error) *MockTokenRepository_Create_Call

+ func (_c *MockTokenRepository_Create_Call) Run(run func(ctx context.Context, token *domain.Token)) *MockTokenRepository_Create_Call

+ func (_c *MockTokenRepository_Create_Call) RunAndReturn(run func(ctx context.Context, token *domain.Token) error) *MockTokenRepository_Create_Call

+ type MockTokenRepository_Expecter struct

+ func (_e *MockTokenRepository_Expecter) Create(ctx interface{}, token interface{}) *MockTokenRepository_Create_Call

+ func (_e *MockTokenRepository_Expecter) Get(ctx interface{}, tokenID interface{}) *MockTokenRepository_Get_Call

+ func (_e *MockTokenRepository_Expecter) GetByTokenHash(ctx interface{}, tokenHash interface{}) *MockTokenRepository_GetByTokenHash_Call

+ func (_e *MockTokenRepository_Expecter) Update(ctx interface{}, token interface{}) *MockTokenRepository_Update_Call

+ type MockTokenRepository_GetByTokenHash_Call struct

+ func (_c *MockTokenRepository_GetByTokenHash_Call) Return(token *domain.Token, err error) *MockTokenRepository_GetByTokenHash_Call

+ func (_c *MockTokenRepository_GetByTokenHash_Call) Run(run func(ctx context.Context, tokenHash string)) *MockTokenRepository_GetByTokenHash_Call

+ func (_c *MockTokenRepository_GetByTokenHash_Call) RunAndReturn(run func(ctx context.Context, tokenHash string) (*domain.Token, error)) *MockTokenRepository_GetByTokenHash_Call

+ type MockTokenRepository_Get_Call struct

+ func (_c *MockTokenRepository_Get_Call) Return(token *domain.Token, err error) *MockTokenRepository_Get_Call

+ func (_c *MockTokenRepository_Get_Call) Run(run func(ctx context.Context, tokenID uuid.UUID)) *MockTokenRepository_Get_Call

+ func (_c *MockTokenRepository_Get_Call) RunAndReturn(run func(ctx context.Context, tokenID uuid.UUID) (*domain.Token, error)) *MockTokenRepository_Get_Call

+ type MockTokenRepository_Update_Call struct

+ func (_c *MockTokenRepository_Update_Call) Return(err error) *MockTokenRepository_Update_Call

+ func (_c *MockTokenRepository_Update_Call) Run(run func(ctx context.Context, token *domain.Token)) *MockTokenRepository_Update_Call

+ func (_c *MockTokenRepository_Update_Call) RunAndReturn(run func(ctx context.Context, token *domain.Token) error) *MockTokenRepository_Update_Call

+ type MockTokenUseCase struct

+ func NewMockTokenUseCase(t interface{ ... }) *MockTokenUseCase

+ func (_m *MockTokenUseCase) EXPECT() *MockTokenUseCase_Expecter

+ func (_mock *MockTokenUseCase) Authenticate(ctx context.Context, tokenHash string) (*domain.Client, error)

+ func (_mock *MockTokenUseCase) Issue(ctx context.Context, issueTokenInput *domain.IssueTokenInput) (*domain.IssueTokenOutput, error)

+ type MockTokenUseCase_Authenticate_Call struct

+ func (_c *MockTokenUseCase_Authenticate_Call) Return(client *domain.Client, err error) *MockTokenUseCase_Authenticate_Call

+ func (_c *MockTokenUseCase_Authenticate_Call) Run(run func(ctx context.Context, tokenHash string)) *MockTokenUseCase_Authenticate_Call

+ func (_c *MockTokenUseCase_Authenticate_Call) RunAndReturn(run func(ctx context.Context, tokenHash string) (*domain.Client, error)) *MockTokenUseCase_Authenticate_Call

+ type MockTokenUseCase_Expecter struct

+ func (_e *MockTokenUseCase_Expecter) Authenticate(ctx interface{}, tokenHash interface{}) *MockTokenUseCase_Authenticate_Call

+ func (_e *MockTokenUseCase_Expecter) Issue(ctx interface{}, issueTokenInput interface{}) *MockTokenUseCase_Issue_Call

+ type MockTokenUseCase_Issue_Call struct

+ func (_c *MockTokenUseCase_Issue_Call) Return(issueTokenOutput *domain.IssueTokenOutput, err error) *MockTokenUseCase_Issue_Call

+ func (_c *MockTokenUseCase_Issue_Call) Run(run func(ctx context.Context, issueTokenInput *domain.IssueTokenInput)) *MockTokenUseCase_Issue_Call

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