mocks

Jul 2, 2026

Changes in this version

+ type AuditRecordRepository struct

+ func NewAuditRecordRepository(t interface{ ... }) *AuditRecordRepository

+ func (_m *AuditRecordRepository) Create(ctx context.Context, auditRecord models.AuditRecord) (models.AuditRecord, error)

+ func (_m *AuditRecordRepository) EXPECT() *AuditRecordRepository_Expecter

+ type AuditRecordRepository_Create_Call struct

+ func (_c *AuditRecordRepository_Create_Call) Return(_a0 models.AuditRecord, _a1 error) *AuditRecordRepository_Create_Call

+ func (_c *AuditRecordRepository_Create_Call) Run(run func(ctx context.Context, auditRecord models.AuditRecord)) *AuditRecordRepository_Create_Call

+ func (_c *AuditRecordRepository_Create_Call) RunAndReturn(run func(context.Context, models.AuditRecord) (models.AuditRecord, error)) *AuditRecordRepository_Create_Call

+ type AuditRecordRepository_Expecter struct

+ func (_e *AuditRecordRepository_Expecter) Create(ctx interface{}, auditRecord interface{}) *AuditRecordRepository_Create_Call

Jun 18, 2026

Changes in this version

type MembershipService

+ func (_m *MembershipService) ListPrincipalIDsByResource(ctx context.Context, resourceID string, resourceType string, ...) ([]string, error)

type MembershipService_Expecter

+ func (_e *MembershipService_Expecter) ListPrincipalIDsByResource(ctx interface{}, resourceID interface{}, resourceType interface{}, ...) *MembershipService_ListPrincipalIDsByResource_Call

+ type MembershipService_ListPrincipalIDsByResource_Call struct

+ func (_c *MembershipService_ListPrincipalIDsByResource_Call) Return(_a0 []string, _a1 error) *MembershipService_ListPrincipalIDsByResource_Call

+ func (_c *MembershipService_ListPrincipalIDsByResource_Call) Run(run func(ctx context.Context, resourceID string, resourceType string, ...)) *MembershipService_ListPrincipalIDsByResource_Call

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

May 20, 2026

Changes in this version

+ type CredentialRepository struct

+ func NewCredentialRepository(t interface{ ... }) *CredentialRepository

+ func (_m *CredentialRepository) Create(ctx context.Context, credential serviceuser.Credential) (serviceuser.Credential, error)

+ func (_m *CredentialRepository) Delete(ctx context.Context, id string) error

+ func (_m *CredentialRepository) EXPECT() *CredentialRepository_Expecter

+ func (_m *CredentialRepository) Get(ctx context.Context, id string) (serviceuser.Credential, error)

+ func (_m *CredentialRepository) List(ctx context.Context, flt serviceuser.Filter) ([]serviceuser.Credential, error)

+ type CredentialRepository_Create_Call struct

+ func (_c *CredentialRepository_Create_Call) Return(_a0 serviceuser.Credential, _a1 error) *CredentialRepository_Create_Call

+ func (_c *CredentialRepository_Create_Call) Run(run func(ctx context.Context, credential serviceuser.Credential)) *CredentialRepository_Create_Call

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

+ type CredentialRepository_Delete_Call struct

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

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

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

+ type CredentialRepository_Expecter struct

+ func (_e *CredentialRepository_Expecter) Create(ctx interface{}, credential interface{}) *CredentialRepository_Create_Call

+ func (_e *CredentialRepository_Expecter) Delete(ctx interface{}, id interface{}) *CredentialRepository_Delete_Call

+ func (_e *CredentialRepository_Expecter) Get(ctx interface{}, id interface{}) *CredentialRepository_Get_Call

+ func (_e *CredentialRepository_Expecter) List(ctx interface{}, flt interface{}) *CredentialRepository_List_Call

+ type CredentialRepository_Get_Call struct

+ func (_c *CredentialRepository_Get_Call) Return(_a0 serviceuser.Credential, _a1 error) *CredentialRepository_Get_Call

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

+ func (_c *CredentialRepository_Get_Call) RunAndReturn(run func(context.Context, string) (serviceuser.Credential, error)) *CredentialRepository_Get_Call

+ type CredentialRepository_List_Call struct

+ func (_c *CredentialRepository_List_Call) Return(_a0 []serviceuser.Credential, _a1 error) *CredentialRepository_List_Call

+ func (_c *CredentialRepository_List_Call) Run(run func(ctx context.Context, flt serviceuser.Filter)) *CredentialRepository_List_Call

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

+ type MembershipService struct

+ func NewMembershipService(t interface{ ... }) *MembershipService

+ func (_m *MembershipService) AddOrganizationMember(ctx context.Context, orgID string, principalID string, principalType string, ...) error

+ func (_m *MembershipService) EXPECT() *MembershipService_Expecter

+ func (_m *MembershipService) RemoveOrganizationMember(ctx context.Context, orgID string, principalID string, principalType string) error

+ type MembershipService_AddOrganizationMember_Call struct

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

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

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

+ type MembershipService_Expecter struct

+ func (_e *MembershipService_Expecter) AddOrganizationMember(ctx interface{}, orgID interface{}, principalID interface{}, ...) *MembershipService_AddOrganizationMember_Call

+ func (_e *MembershipService_Expecter) RemoveOrganizationMember(ctx interface{}, orgID interface{}, principalID interface{}, ...) *MembershipService_RemoveOrganizationMember_Call

+ type MembershipService_RemoveOrganizationMember_Call struct

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

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

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

+ type RelationService struct

+ func NewRelationService(t interface{ ... }) *RelationService

+ func (_m *RelationService) BatchCheckPermission(ctx context.Context, rel []relation.Relation) ([]relation.CheckPair, error)

+ func (_m *RelationService) CheckPermission(ctx context.Context, rel relation.Relation) (bool, error)

+ func (_m *RelationService) Create(ctx context.Context, rel relation.Relation) (relation.Relation, error)

+ func (_m *RelationService) Delete(ctx context.Context, rel relation.Relation) error

+ func (_m *RelationService) EXPECT() *RelationService_Expecter

+ func (_m *RelationService) LookupSubjects(ctx context.Context, rel relation.Relation) ([]string, error)

+ type RelationService_BatchCheckPermission_Call struct

+ func (_c *RelationService_BatchCheckPermission_Call) Return(_a0 []relation.CheckPair, _a1 error) *RelationService_BatchCheckPermission_Call

+ func (_c *RelationService_BatchCheckPermission_Call) Run(run func(ctx context.Context, rel []relation.Relation)) *RelationService_BatchCheckPermission_Call

+ func (_c *RelationService_BatchCheckPermission_Call) RunAndReturn(run func(context.Context, []relation.Relation) ([]relation.CheckPair, error)) *RelationService_BatchCheckPermission_Call

+ type RelationService_CheckPermission_Call struct

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

+ func (_c *RelationService_CheckPermission_Call) Run(run func(ctx context.Context, rel relation.Relation)) *RelationService_CheckPermission_Call

+ func (_c *RelationService_CheckPermission_Call) RunAndReturn(run func(context.Context, relation.Relation) (bool, error)) *RelationService_CheckPermission_Call

+ type RelationService_Create_Call struct

+ func (_c *RelationService_Create_Call) Return(_a0 relation.Relation, _a1 error) *RelationService_Create_Call

+ func (_c *RelationService_Create_Call) Run(run func(ctx context.Context, rel relation.Relation)) *RelationService_Create_Call

+ func (_c *RelationService_Create_Call) RunAndReturn(run func(context.Context, relation.Relation) (relation.Relation, error)) *RelationService_Create_Call

+ type RelationService_Delete_Call struct

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

+ func (_c *RelationService_Delete_Call) Run(run func(ctx context.Context, rel relation.Relation)) *RelationService_Delete_Call

+ func (_c *RelationService_Delete_Call) RunAndReturn(run func(context.Context, relation.Relation) error) *RelationService_Delete_Call

+ type RelationService_Expecter struct

+ func (_e *RelationService_Expecter) BatchCheckPermission(ctx interface{}, rel interface{}) *RelationService_BatchCheckPermission_Call

+ func (_e *RelationService_Expecter) CheckPermission(ctx interface{}, rel interface{}) *RelationService_CheckPermission_Call

+ func (_e *RelationService_Expecter) Create(ctx interface{}, rel interface{}) *RelationService_Create_Call

+ func (_e *RelationService_Expecter) Delete(ctx interface{}, rel interface{}) *RelationService_Delete_Call

+ func (_e *RelationService_Expecter) LookupSubjects(ctx interface{}, rel interface{}) *RelationService_LookupSubjects_Call

+ type RelationService_LookupSubjects_Call struct

+ func (_c *RelationService_LookupSubjects_Call) Return(_a0 []string, _a1 error) *RelationService_LookupSubjects_Call

+ func (_c *RelationService_LookupSubjects_Call) Run(run func(ctx context.Context, rel relation.Relation)) *RelationService_LookupSubjects_Call

+ func (_c *RelationService_LookupSubjects_Call) RunAndReturn(run func(context.Context, relation.Relation) ([]string, error)) *RelationService_LookupSubjects_Call

+ type Repository struct

+ func NewRepository(t interface{ ... }) *Repository

+ func (_m *Repository) Create(ctx context.Context, serviceUser serviceuser.ServiceUser) (serviceuser.ServiceUser, error)

+ func (_m *Repository) Delete(ctx context.Context, id string) error

+ func (_m *Repository) EXPECT() *Repository_Expecter

+ func (_m *Repository) GetByID(ctx context.Context, id string) (serviceuser.ServiceUser, error)

+ func (_m *Repository) GetByIDs(ctx context.Context, id []string) ([]serviceuser.ServiceUser, error)

+ func (_m *Repository) List(ctx context.Context, flt serviceuser.Filter) ([]serviceuser.ServiceUser, error)

+ type Repository_Create_Call struct

+ func (_c *Repository_Create_Call) Return(_a0 serviceuser.ServiceUser, _a1 error) *Repository_Create_Call

+ func (_c *Repository_Create_Call) Run(run func(ctx context.Context, serviceUser serviceuser.ServiceUser)) *Repository_Create_Call

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

+ type Repository_Delete_Call struct

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

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

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

+ type Repository_Expecter struct

+ func (_e *Repository_Expecter) Create(ctx interface{}, serviceUser interface{}) *Repository_Create_Call

+ func (_e *Repository_Expecter) Delete(ctx interface{}, id interface{}) *Repository_Delete_Call

+ func (_e *Repository_Expecter) GetByID(ctx interface{}, id interface{}) *Repository_GetByID_Call

+ func (_e *Repository_Expecter) GetByIDs(ctx interface{}, id interface{}) *Repository_GetByIDs_Call

+ func (_e *Repository_Expecter) List(ctx interface{}, flt interface{}) *Repository_List_Call

+ type Repository_GetByID_Call struct

+ func (_c *Repository_GetByID_Call) Return(_a0 serviceuser.ServiceUser, _a1 error) *Repository_GetByID_Call

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

+ func (_c *Repository_GetByID_Call) RunAndReturn(run func(context.Context, string) (serviceuser.ServiceUser, error)) *Repository_GetByID_Call

+ type Repository_GetByIDs_Call struct

+ func (_c *Repository_GetByIDs_Call) Return(_a0 []serviceuser.ServiceUser, _a1 error) *Repository_GetByIDs_Call

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

+ func (_c *Repository_GetByIDs_Call) RunAndReturn(run func(context.Context, []string) ([]serviceuser.ServiceUser, error)) *Repository_GetByIDs_Call

+ type Repository_List_Call struct

+ func (_c *Repository_List_Call) Return(_a0 []serviceuser.ServiceUser, _a1 error) *Repository_List_Call

+ func (_c *Repository_List_Call) Run(run func(ctx context.Context, flt serviceuser.Filter)) *Repository_List_Call

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