mocks

Documentation

Index

• type AuditService
  • func NewAuditService(t mockConstructorTestingTNewAuditService) *AuditService
  • func (_m *AuditService) Create(ctx context.Context, log *audit.Log) error
  • func (_m *AuditService) EXPECT() *AuditService_Expecter
  • func (_m *AuditService) GetByID(ctx context.Context, id string) (audit.Log, error)
  • func (_m *AuditService) List(ctx context.Context, filter audit.Filter) ([]audit.Log, error)
• type AuditService_Create_Call
  • func (_c *AuditService_Create_Call) Return(_a0 error) *AuditService_Create_Call
  • func (_c *AuditService_Create_Call) Run(run func(ctx context.Context, log *audit.Log)) *AuditService_Create_Call
  • func (_c *AuditService_Create_Call) RunAndReturn(run func(context.Context, *audit.Log) error) *AuditService_Create_Call
• type AuditService_Expecter
  • func (_e *AuditService_Expecter) Create(ctx interface{}, log interface{}) *AuditService_Create_Call
  • func (_e *AuditService_Expecter) GetByID(ctx interface{}, id interface{}) *AuditService_GetByID_Call
  • func (_e *AuditService_Expecter) List(ctx interface{}, filter interface{}) *AuditService_List_Call
• type AuditService_GetByID_Call
  • func (_c *AuditService_GetByID_Call) Return(_a0 audit.Log, _a1 error) *AuditService_GetByID_Call
  • func (_c *AuditService_GetByID_Call) Run(run func(ctx context.Context, id string)) *AuditService_GetByID_Call
  • func (_c *AuditService_GetByID_Call) RunAndReturn(run func(context.Context, string) (audit.Log, error)) *AuditService_GetByID_Call
• type AuditService_List_Call
  • func (_c *AuditService_List_Call) Return(_a0 []audit.Log, _a1 error) *AuditService_List_Call
  • func (_c *AuditService_List_Call) Run(run func(ctx context.Context, filter audit.Filter)) *AuditService_List_Call
  • func (_c *AuditService_List_Call) RunAndReturn(run func(context.Context, audit.Filter) ([]audit.Log, error)) *AuditService_List_Call
• type AuthnService
  • func NewAuthnService(t mockConstructorTestingTNewAuthnService) *AuthnService
  • func (_m *AuthnService) BuildToken(ctx context.Context, principalID string, metadata map[string]string) ([]byte, error)
  • func (_m *AuthnService) Close()
  • func (_m *AuthnService) EXPECT() *AuthnService_Expecter
  • func (_m *AuthnService) FinishFlow(ctx context.Context, request authenticate.RegistrationFinishRequest) (*authenticate.RegistrationFinishResponse, error)
  • func (_m *AuthnService) GetPrincipal(ctx context.Context, via ...authenticate.ClientAssertion) (authenticate.Principal, error)
  • func (_m *AuthnService) InitFlows(ctx context.Context) error
  • func (_m *AuthnService) JWKs(ctx context.Context) jwk.Set
  • func (_m *AuthnService) StartFlow(ctx context.Context, request authenticate.RegistrationStartRequest) (*authenticate.RegistrationStartResponse, error)
  • func (_m *AuthnService) SupportedStrategies() []string
• type AuthnService_BuildToken_Call
  • func (_c *AuthnService_BuildToken_Call) Return(_a0 []byte, _a1 error) *AuthnService_BuildToken_Call
  • func (_c *AuthnService_BuildToken_Call) Run(run func(ctx context.Context, principalID string, metadata map[string]string)) *AuthnService_BuildToken_Call
  • func (_c *AuthnService_BuildToken_Call) RunAndReturn(run func(context.Context, string, map[string]string) ([]byte, error)) *AuthnService_BuildToken_Call
• type AuthnService_Close_Call
  • func (_c *AuthnService_Close_Call) Return() *AuthnService_Close_Call
  • func (_c *AuthnService_Close_Call) Run(run func()) *AuthnService_Close_Call
  • func (_c *AuthnService_Close_Call) RunAndReturn(run func()) *AuthnService_Close_Call
• type AuthnService_Expecter
  • func (_e *AuthnService_Expecter) BuildToken(ctx interface{}, principalID interface{}, metadata interface{}) *AuthnService_BuildToken_Call
  • func (_e *AuthnService_Expecter) Close() *AuthnService_Close_Call
  • func (_e *AuthnService_Expecter) FinishFlow(ctx interface{}, request interface{}) *AuthnService_FinishFlow_Call
  • func (_e *AuthnService_Expecter) GetPrincipal(ctx interface{}, via ...interface{}) *AuthnService_GetPrincipal_Call
  • func (_e *AuthnService_Expecter) InitFlows(ctx interface{}) *AuthnService_InitFlows_Call
  • func (_e *AuthnService_Expecter) JWKs(ctx interface{}) *AuthnService_JWKs_Call
  • func (_e *AuthnService_Expecter) StartFlow(ctx interface{}, request interface{}) *AuthnService_StartFlow_Call
  • func (_e *AuthnService_Expecter) SupportedStrategies() *AuthnService_SupportedStrategies_Call
• type AuthnService_FinishFlow_Call
  • func (_c *AuthnService_FinishFlow_Call) Return(_a0 *authenticate.RegistrationFinishResponse, _a1 error) *AuthnService_FinishFlow_Call
  • func (_c *AuthnService_FinishFlow_Call) Run(run func(ctx context.Context, request authenticate.RegistrationFinishRequest)) *AuthnService_FinishFlow_Call
  • func (_c *AuthnService_FinishFlow_Call) RunAndReturn(...) *AuthnService_FinishFlow_Call
• type AuthnService_GetPrincipal_Call
  • func (_c *AuthnService_GetPrincipal_Call) Return(_a0 authenticate.Principal, _a1 error) *AuthnService_GetPrincipal_Call
  • func (_c *AuthnService_GetPrincipal_Call) Run(run func(ctx context.Context, via ...authenticate.ClientAssertion)) *AuthnService_GetPrincipal_Call
  • func (_c *AuthnService_GetPrincipal_Call) RunAndReturn(...) *AuthnService_GetPrincipal_Call
• type AuthnService_InitFlows_Call
  • func (_c *AuthnService_InitFlows_Call) Return(_a0 error) *AuthnService_InitFlows_Call
  • func (_c *AuthnService_InitFlows_Call) Run(run func(ctx context.Context)) *AuthnService_InitFlows_Call
  • func (_c *AuthnService_InitFlows_Call) RunAndReturn(run func(context.Context) error) *AuthnService_InitFlows_Call
• type AuthnService_JWKs_Call
  • func (_c *AuthnService_JWKs_Call) Return(_a0 jwk.Set) *AuthnService_JWKs_Call
  • func (_c *AuthnService_JWKs_Call) Run(run func(ctx context.Context)) *AuthnService_JWKs_Call
  • func (_c *AuthnService_JWKs_Call) RunAndReturn(run func(context.Context) jwk.Set) *AuthnService_JWKs_Call
• type AuthnService_StartFlow_Call
  • func (_c *AuthnService_StartFlow_Call) Return(_a0 *authenticate.RegistrationStartResponse, _a1 error) *AuthnService_StartFlow_Call
  • func (_c *AuthnService_StartFlow_Call) Run(run func(ctx context.Context, request authenticate.RegistrationStartRequest)) *AuthnService_StartFlow_Call
  • func (_c *AuthnService_StartFlow_Call) RunAndReturn(...) *AuthnService_StartFlow_Call
• type AuthnService_SupportedStrategies_Call
  • func (_c *AuthnService_SupportedStrategies_Call) Return(_a0 []string) *AuthnService_SupportedStrategies_Call
  • func (_c *AuthnService_SupportedStrategies_Call) Run(run func()) *AuthnService_SupportedStrategies_Call
  • func (_c *AuthnService_SupportedStrategies_Call) RunAndReturn(run func() []string) *AuthnService_SupportedStrategies_Call
• type BootstrapService
  • func NewBootstrapService(t mockConstructorTestingTNewBootstrapService) *BootstrapService
  • func (_m *BootstrapService) AppendSchema(ctx context.Context, definition schema.ServiceDefinition) error
  • func (_m *BootstrapService) EXPECT() *BootstrapService_Expecter
• type BootstrapService_AppendSchema_Call
  • func (_c *BootstrapService_AppendSchema_Call) Return(_a0 error) *BootstrapService_AppendSchema_Call
  • func (_c *BootstrapService_AppendSchema_Call) Run(run func(ctx context.Context, definition schema.ServiceDefinition)) *BootstrapService_AppendSchema_Call
  • func (_c *BootstrapService_AppendSchema_Call) RunAndReturn(run func(context.Context, schema.ServiceDefinition) error) *BootstrapService_AppendSchema_Call
• type BootstrapService_Expecter
  • func (_e *BootstrapService_Expecter) AppendSchema(ctx interface{}, definition interface{}) *BootstrapService_AppendSchema_Call
• type CascadeDeleter
  • func NewCascadeDeleter(t mockConstructorTestingTNewCascadeDeleter) *CascadeDeleter
  • func (_m *CascadeDeleter) DeleteOrganization(ctx context.Context, id string) error
  • func (_m *CascadeDeleter) DeleteProject(ctx context.Context, id string) error
  • func (_m *CascadeDeleter) EXPECT() *CascadeDeleter_Expecter
• type CascadeDeleter_DeleteOrganization_Call
  • func (_c *CascadeDeleter_DeleteOrganization_Call) Return(_a0 error) *CascadeDeleter_DeleteOrganization_Call
  • func (_c *CascadeDeleter_DeleteOrganization_Call) Run(run func(ctx context.Context, id string)) *CascadeDeleter_DeleteOrganization_Call
  • func (_c *CascadeDeleter_DeleteOrganization_Call) RunAndReturn(run func(context.Context, string) error) *CascadeDeleter_DeleteOrganization_Call
• type CascadeDeleter_DeleteProject_Call
  • func (_c *CascadeDeleter_DeleteProject_Call) Return(_a0 error) *CascadeDeleter_DeleteProject_Call
  • func (_c *CascadeDeleter_DeleteProject_Call) Run(run func(ctx context.Context, id string)) *CascadeDeleter_DeleteProject_Call
  • func (_c *CascadeDeleter_DeleteProject_Call) RunAndReturn(run func(context.Context, string) error) *CascadeDeleter_DeleteProject_Call
• type CascadeDeleter_Expecter
  • func (_e *CascadeDeleter_Expecter) DeleteOrganization(ctx interface{}, id interface{}) *CascadeDeleter_DeleteOrganization_Call
  • func (_e *CascadeDeleter_Expecter) DeleteProject(ctx interface{}, id interface{}) *CascadeDeleter_DeleteProject_Call
• type GroupService
  • func NewGroupService(t mockConstructorTestingTNewGroupService) *GroupService
  • func (_m *GroupService) AddUsers(ctx context.Context, groupID string, userID []string) error
  • func (_m *GroupService) Create(ctx context.Context, grp group.Group) (group.Group, error)
  • func (_m *GroupService) Delete(ctx context.Context, id string) error
  • func (_m *GroupService) Disable(ctx context.Context, id string) error
  • func (_m *GroupService) EXPECT() *GroupService_Expecter
  • func (_m *GroupService) Enable(ctx context.Context, id string) error
  • func (_m *GroupService) Get(ctx context.Context, id string) (group.Group, error)
  • func (_m *GroupService) List(ctx context.Context, flt group.Filter) ([]group.Group, error)
  • func (_m *GroupService) ListByUser(ctx context.Context, userId string, flt group.Filter) ([]group.Group, error)
  • func (_m *GroupService) RemoveUsers(ctx context.Context, groupID string, userID []string) error
  • func (_m *GroupService) Update(ctx context.Context, grp group.Group) (group.Group, error)
• type GroupService_AddUsers_Call
  • func (_c *GroupService_AddUsers_Call) Return(_a0 error) *GroupService_AddUsers_Call
  • func (_c *GroupService_AddUsers_Call) Run(run func(ctx context.Context, groupID string, userID []string)) *GroupService_AddUsers_Call
  • func (_c *GroupService_AddUsers_Call) RunAndReturn(run func(context.Context, string, []string) error) *GroupService_AddUsers_Call
• type GroupService_Create_Call
  • func (_c *GroupService_Create_Call) Return(_a0 group.Group, _a1 error) *GroupService_Create_Call
  • func (_c *GroupService_Create_Call) Run(run func(ctx context.Context, grp group.Group)) *GroupService_Create_Call
  • func (_c *GroupService_Create_Call) RunAndReturn(run func(context.Context, group.Group) (group.Group, error)) *GroupService_Create_Call
• type GroupService_Delete_Call
  • func (_c *GroupService_Delete_Call) Return(_a0 error) *GroupService_Delete_Call
  • func (_c *GroupService_Delete_Call) Run(run func(ctx context.Context, id string)) *GroupService_Delete_Call
  • func (_c *GroupService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *GroupService_Delete_Call
• type GroupService_Disable_Call
  • func (_c *GroupService_Disable_Call) Return(_a0 error) *GroupService_Disable_Call
  • func (_c *GroupService_Disable_Call) Run(run func(ctx context.Context, id string)) *GroupService_Disable_Call
  • func (_c *GroupService_Disable_Call) RunAndReturn(run func(context.Context, string) error) *GroupService_Disable_Call
• type GroupService_Enable_Call
  • func (_c *GroupService_Enable_Call) Return(_a0 error) *GroupService_Enable_Call
  • func (_c *GroupService_Enable_Call) Run(run func(ctx context.Context, id string)) *GroupService_Enable_Call
  • func (_c *GroupService_Enable_Call) RunAndReturn(run func(context.Context, string) error) *GroupService_Enable_Call
• type GroupService_Expecter
  • func (_e *GroupService_Expecter) AddUsers(ctx interface{}, groupID interface{}, userID interface{}) *GroupService_AddUsers_Call
  • func (_e *GroupService_Expecter) Create(ctx interface{}, grp interface{}) *GroupService_Create_Call
  • func (_e *GroupService_Expecter) Delete(ctx interface{}, id interface{}) *GroupService_Delete_Call
  • func (_e *GroupService_Expecter) Disable(ctx interface{}, id interface{}) *GroupService_Disable_Call
  • func (_e *GroupService_Expecter) Enable(ctx interface{}, id interface{}) *GroupService_Enable_Call
  • func (_e *GroupService_Expecter) Get(ctx interface{}, id interface{}) *GroupService_Get_Call
  • func (_e *GroupService_Expecter) List(ctx interface{}, flt interface{}) *GroupService_List_Call
  • func (_e *GroupService_Expecter) ListByUser(ctx interface{}, userId interface{}, flt interface{}) *GroupService_ListByUser_Call
  • func (_e *GroupService_Expecter) RemoveUsers(ctx interface{}, groupID interface{}, userID interface{}) *GroupService_RemoveUsers_Call
  • func (_e *GroupService_Expecter) Update(ctx interface{}, grp interface{}) *GroupService_Update_Call
• type GroupService_Get_Call
  • func (_c *GroupService_Get_Call) Return(_a0 group.Group, _a1 error) *GroupService_Get_Call
  • func (_c *GroupService_Get_Call) Run(run func(ctx context.Context, id string)) *GroupService_Get_Call
  • func (_c *GroupService_Get_Call) RunAndReturn(run func(context.Context, string) (group.Group, error)) *GroupService_Get_Call
• type GroupService_ListByUser_Call
  • func (_c *GroupService_ListByUser_Call) Return(_a0 []group.Group, _a1 error) *GroupService_ListByUser_Call
  • func (_c *GroupService_ListByUser_Call) Run(run func(ctx context.Context, userId string, flt group.Filter)) *GroupService_ListByUser_Call
  • func (_c *GroupService_ListByUser_Call) RunAndReturn(run func(context.Context, string, group.Filter) ([]group.Group, error)) *GroupService_ListByUser_Call
• type GroupService_List_Call
  • func (_c *GroupService_List_Call) Return(_a0 []group.Group, _a1 error) *GroupService_List_Call
  • func (_c *GroupService_List_Call) Run(run func(ctx context.Context, flt group.Filter)) *GroupService_List_Call
  • func (_c *GroupService_List_Call) RunAndReturn(run func(context.Context, group.Filter) ([]group.Group, error)) *GroupService_List_Call
• type GroupService_RemoveUsers_Call
  • func (_c *GroupService_RemoveUsers_Call) Return(_a0 error) *GroupService_RemoveUsers_Call
  • func (_c *GroupService_RemoveUsers_Call) Run(run func(ctx context.Context, groupID string, userID []string)) *GroupService_RemoveUsers_Call
  • func (_c *GroupService_RemoveUsers_Call) RunAndReturn(run func(context.Context, string, []string) error) *GroupService_RemoveUsers_Call
• type GroupService_Update_Call
  • func (_c *GroupService_Update_Call) Return(_a0 group.Group, _a1 error) *GroupService_Update_Call
  • func (_c *GroupService_Update_Call) Run(run func(ctx context.Context, grp group.Group)) *GroupService_Update_Call
  • func (_c *GroupService_Update_Call) RunAndReturn(run func(context.Context, group.Group) (group.Group, error)) *GroupService_Update_Call
• type InvitationService
  • func NewInvitationService(t mockConstructorTestingTNewInvitationService) *InvitationService
  • func (_m *InvitationService) Accept(ctx context.Context, id uuid.UUID) error
  • func (_m *InvitationService) Create(ctx context.Context, inv invitation.Invitation) (invitation.Invitation, error)
  • func (_m *InvitationService) Delete(ctx context.Context, id uuid.UUID) error
  • func (_m *InvitationService) EXPECT() *InvitationService_Expecter
  • func (_m *InvitationService) Get(ctx context.Context, id uuid.UUID) (invitation.Invitation, error)
  • func (_m *InvitationService) List(ctx context.Context, filter invitation.Filter) ([]invitation.Invitation, error)
  • func (_m *InvitationService) ListByUser(ctx context.Context, userID string) ([]invitation.Invitation, error)
• type InvitationService_Accept_Call
  • func (_c *InvitationService_Accept_Call) Return(_a0 error) *InvitationService_Accept_Call
  • func (_c *InvitationService_Accept_Call) Run(run func(ctx context.Context, id uuid.UUID)) *InvitationService_Accept_Call
  • func (_c *InvitationService_Accept_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *InvitationService_Accept_Call
• type InvitationService_Create_Call
  • func (_c *InvitationService_Create_Call) Return(_a0 invitation.Invitation, _a1 error) *InvitationService_Create_Call
  • func (_c *InvitationService_Create_Call) Run(run func(ctx context.Context, inv invitation.Invitation)) *InvitationService_Create_Call
  • func (_c *InvitationService_Create_Call) RunAndReturn(...) *InvitationService_Create_Call
• type InvitationService_Delete_Call
  • func (_c *InvitationService_Delete_Call) Return(_a0 error) *InvitationService_Delete_Call
  • func (_c *InvitationService_Delete_Call) Run(run func(ctx context.Context, id uuid.UUID)) *InvitationService_Delete_Call
  • func (_c *InvitationService_Delete_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *InvitationService_Delete_Call
• type InvitationService_Expecter
  • func (_e *InvitationService_Expecter) Accept(ctx interface{}, id interface{}) *InvitationService_Accept_Call
  • func (_e *InvitationService_Expecter) Create(ctx interface{}, inv interface{}) *InvitationService_Create_Call
  • func (_e *InvitationService_Expecter) Delete(ctx interface{}, id interface{}) *InvitationService_Delete_Call
  • func (_e *InvitationService_Expecter) Get(ctx interface{}, id interface{}) *InvitationService_Get_Call
  • func (_e *InvitationService_Expecter) List(ctx interface{}, filter interface{}) *InvitationService_List_Call
  • func (_e *InvitationService_Expecter) ListByUser(ctx interface{}, userID interface{}) *InvitationService_ListByUser_Call
• type InvitationService_Get_Call
  • func (_c *InvitationService_Get_Call) Return(_a0 invitation.Invitation, _a1 error) *InvitationService_Get_Call
  • func (_c *InvitationService_Get_Call) Run(run func(ctx context.Context, id uuid.UUID)) *InvitationService_Get_Call
  • func (_c *InvitationService_Get_Call) RunAndReturn(run func(context.Context, uuid.UUID) (invitation.Invitation, error)) *InvitationService_Get_Call
• type InvitationService_ListByUser_Call
  • func (_c *InvitationService_ListByUser_Call) Return(_a0 []invitation.Invitation, _a1 error) *InvitationService_ListByUser_Call
  • func (_c *InvitationService_ListByUser_Call) Run(run func(ctx context.Context, userID string)) *InvitationService_ListByUser_Call
  • func (_c *InvitationService_ListByUser_Call) RunAndReturn(run func(context.Context, string) ([]invitation.Invitation, error)) *InvitationService_ListByUser_Call
• type InvitationService_List_Call
  • func (_c *InvitationService_List_Call) Return(_a0 []invitation.Invitation, _a1 error) *InvitationService_List_Call
  • func (_c *InvitationService_List_Call) Run(run func(ctx context.Context, filter invitation.Filter)) *InvitationService_List_Call
  • func (_c *InvitationService_List_Call) RunAndReturn(run func(context.Context, invitation.Filter) ([]invitation.Invitation, error)) *InvitationService_List_Call
• type MetaSchemaService
  • func NewMetaSchemaService(t mockConstructorTestingTNewMetaSchemaService) *MetaSchemaService
  • func (_m *MetaSchemaService) Create(ctx context.Context, toCreate metaschema.MetaSchema) (metaschema.MetaSchema, error)
  • func (_m *MetaSchemaService) Delete(ctx context.Context, id string) error
  • func (_m *MetaSchemaService) EXPECT() *MetaSchemaService_Expecter
  • func (_m *MetaSchemaService) Get(ctx context.Context, id string) (metaschema.MetaSchema, error)
  • func (_m *MetaSchemaService) List(ctx context.Context) ([]metaschema.MetaSchema, error)
  • func (_m *MetaSchemaService) Update(ctx context.Context, id string, toUpdate metaschema.MetaSchema) (metaschema.MetaSchema, error)
  • func (_m *MetaSchemaService) Validate(schema metadata.Metadata, data string) error
• type MetaSchemaService_Create_Call
  • func (_c *MetaSchemaService_Create_Call) Return(_a0 metaschema.MetaSchema, _a1 error) *MetaSchemaService_Create_Call
  • func (_c *MetaSchemaService_Create_Call) Run(run func(ctx context.Context, toCreate metaschema.MetaSchema)) *MetaSchemaService_Create_Call
  • func (_c *MetaSchemaService_Create_Call) RunAndReturn(...) *MetaSchemaService_Create_Call
• type MetaSchemaService_Delete_Call
  • func (_c *MetaSchemaService_Delete_Call) Return(_a0 error) *MetaSchemaService_Delete_Call
  • func (_c *MetaSchemaService_Delete_Call) Run(run func(ctx context.Context, id string)) *MetaSchemaService_Delete_Call
  • func (_c *MetaSchemaService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *MetaSchemaService_Delete_Call
• type MetaSchemaService_Expecter
  • func (_e *MetaSchemaService_Expecter) Create(ctx interface{}, toCreate interface{}) *MetaSchemaService_Create_Call
  • func (_e *MetaSchemaService_Expecter) Delete(ctx interface{}, id interface{}) *MetaSchemaService_Delete_Call
  • func (_e *MetaSchemaService_Expecter) Get(ctx interface{}, id interface{}) *MetaSchemaService_Get_Call
  • func (_e *MetaSchemaService_Expecter) List(ctx interface{}) *MetaSchemaService_List_Call
  • func (_e *MetaSchemaService_Expecter) Update(ctx interface{}, id interface{}, toUpdate interface{}) *MetaSchemaService_Update_Call
  • func (_e *MetaSchemaService_Expecter) Validate(schema interface{}, data interface{}) *MetaSchemaService_Validate_Call
• type MetaSchemaService_Get_Call
  • func (_c *MetaSchemaService_Get_Call) Return(_a0 metaschema.MetaSchema, _a1 error) *MetaSchemaService_Get_Call
  • func (_c *MetaSchemaService_Get_Call) Run(run func(ctx context.Context, id string)) *MetaSchemaService_Get_Call
  • func (_c *MetaSchemaService_Get_Call) RunAndReturn(run func(context.Context, string) (metaschema.MetaSchema, error)) *MetaSchemaService_Get_Call
• type MetaSchemaService_List_Call
  • func (_c *MetaSchemaService_List_Call) Return(_a0 []metaschema.MetaSchema, _a1 error) *MetaSchemaService_List_Call
  • func (_c *MetaSchemaService_List_Call) Run(run func(ctx context.Context)) *MetaSchemaService_List_Call
  • func (_c *MetaSchemaService_List_Call) RunAndReturn(run func(context.Context) ([]metaschema.MetaSchema, error)) *MetaSchemaService_List_Call
• type MetaSchemaService_Update_Call
  • func (_c *MetaSchemaService_Update_Call) Return(_a0 metaschema.MetaSchema, _a1 error) *MetaSchemaService_Update_Call
  • func (_c *MetaSchemaService_Update_Call) Run(run func(ctx context.Context, id string, toUpdate metaschema.MetaSchema)) *MetaSchemaService_Update_Call
  • func (_c *MetaSchemaService_Update_Call) RunAndReturn(...) *MetaSchemaService_Update_Call
• type MetaSchemaService_Validate_Call
  • func (_c *MetaSchemaService_Validate_Call) Return(_a0 error) *MetaSchemaService_Validate_Call
  • func (_c *MetaSchemaService_Validate_Call) Run(run func(schema metadata.Metadata, data string)) *MetaSchemaService_Validate_Call
  • func (_c *MetaSchemaService_Validate_Call) RunAndReturn(run func(metadata.Metadata, string) error) *MetaSchemaService_Validate_Call
• type NamespaceService
  • func NewNamespaceService(t mockConstructorTestingTNewNamespaceService) *NamespaceService
  • func (_m *NamespaceService) EXPECT() *NamespaceService_Expecter
  • func (_m *NamespaceService) Get(ctx context.Context, id string) (namespace.Namespace, error)
  • func (_m *NamespaceService) List(ctx context.Context) ([]namespace.Namespace, error)
  • func (_m *NamespaceService) Update(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error)
  • func (_m *NamespaceService) Upsert(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error)
• type NamespaceService_Expecter
  • func (_e *NamespaceService_Expecter) Get(ctx interface{}, id interface{}) *NamespaceService_Get_Call
  • func (_e *NamespaceService_Expecter) List(ctx interface{}) *NamespaceService_List_Call
  • func (_e *NamespaceService_Expecter) Update(ctx interface{}, ns interface{}) *NamespaceService_Update_Call
  • func (_e *NamespaceService_Expecter) Upsert(ctx interface{}, ns interface{}) *NamespaceService_Upsert_Call
• type NamespaceService_Get_Call
  • func (_c *NamespaceService_Get_Call) Return(_a0 namespace.Namespace, _a1 error) *NamespaceService_Get_Call
  • func (_c *NamespaceService_Get_Call) Run(run func(ctx context.Context, id string)) *NamespaceService_Get_Call
  • func (_c *NamespaceService_Get_Call) RunAndReturn(run func(context.Context, string) (namespace.Namespace, error)) *NamespaceService_Get_Call
• type NamespaceService_List_Call
  • func (_c *NamespaceService_List_Call) Return(_a0 []namespace.Namespace, _a1 error) *NamespaceService_List_Call
  • func (_c *NamespaceService_List_Call) Run(run func(ctx context.Context)) *NamespaceService_List_Call
  • func (_c *NamespaceService_List_Call) RunAndReturn(run func(context.Context) ([]namespace.Namespace, error)) *NamespaceService_List_Call
• type NamespaceService_Update_Call
  • func (_c *NamespaceService_Update_Call) Return(_a0 namespace.Namespace, _a1 error) *NamespaceService_Update_Call
  • func (_c *NamespaceService_Update_Call) Run(run func(ctx context.Context, ns namespace.Namespace)) *NamespaceService_Update_Call
  • func (_c *NamespaceService_Update_Call) RunAndReturn(run func(context.Context, namespace.Namespace) (namespace.Namespace, error)) *NamespaceService_Update_Call
• type NamespaceService_Upsert_Call
  • func (_c *NamespaceService_Upsert_Call) Return(_a0 namespace.Namespace, _a1 error) *NamespaceService_Upsert_Call
  • func (_c *NamespaceService_Upsert_Call) Run(run func(ctx context.Context, ns namespace.Namespace)) *NamespaceService_Upsert_Call
  • func (_c *NamespaceService_Upsert_Call) RunAndReturn(run func(context.Context, namespace.Namespace) (namespace.Namespace, error)) *NamespaceService_Upsert_Call
• type OrganizationService
  • func NewOrganizationService(t mockConstructorTestingTNewOrganizationService) *OrganizationService
  • func (_m *OrganizationService) AddUsers(ctx context.Context, orgID string, userID []string) error
  • func (_m *OrganizationService) Create(ctx context.Context, org organization.Organization) (organization.Organization, error)
  • func (_m *OrganizationService) Disable(ctx context.Context, id string) error
  • func (_m *OrganizationService) EXPECT() *OrganizationService_Expecter
  • func (_m *OrganizationService) Enable(ctx context.Context, id string) error
  • func (_m *OrganizationService) Get(ctx context.Context, idOrSlug string) (organization.Organization, error)
  • func (_m *OrganizationService) List(ctx context.Context, f organization.Filter) ([]organization.Organization, error)
  • func (_m *OrganizationService) ListByUser(ctx context.Context, userID string) ([]organization.Organization, error)
  • func (_m *OrganizationService) RemoveUsers(ctx context.Context, orgID string, userID []string) error
  • func (_m *OrganizationService) Update(ctx context.Context, toUpdate organization.Organization) (organization.Organization, error)
• type OrganizationService_AddUsers_Call
  • func (_c *OrganizationService_AddUsers_Call) Return(_a0 error) *OrganizationService_AddUsers_Call
  • func (_c *OrganizationService_AddUsers_Call) Run(run func(ctx context.Context, orgID string, userID []string)) *OrganizationService_AddUsers_Call
  • func (_c *OrganizationService_AddUsers_Call) RunAndReturn(run func(context.Context, string, []string) error) *OrganizationService_AddUsers_Call
• type OrganizationService_Create_Call
  • func (_c *OrganizationService_Create_Call) Return(_a0 organization.Organization, _a1 error) *OrganizationService_Create_Call
  • func (_c *OrganizationService_Create_Call) Run(run func(ctx context.Context, org organization.Organization)) *OrganizationService_Create_Call
  • func (_c *OrganizationService_Create_Call) RunAndReturn(...) *OrganizationService_Create_Call
• type OrganizationService_Disable_Call
  • func (_c *OrganizationService_Disable_Call) Return(_a0 error) *OrganizationService_Disable_Call
  • func (_c *OrganizationService_Disable_Call) Run(run func(ctx context.Context, id string)) *OrganizationService_Disable_Call
  • func (_c *OrganizationService_Disable_Call) RunAndReturn(run func(context.Context, string) error) *OrganizationService_Disable_Call
• type OrganizationService_Enable_Call
  • func (_c *OrganizationService_Enable_Call) Return(_a0 error) *OrganizationService_Enable_Call
  • func (_c *OrganizationService_Enable_Call) Run(run func(ctx context.Context, id string)) *OrganizationService_Enable_Call
  • func (_c *OrganizationService_Enable_Call) RunAndReturn(run func(context.Context, string) error) *OrganizationService_Enable_Call
• type OrganizationService_Expecter
  • func (_e *OrganizationService_Expecter) AddUsers(ctx interface{}, orgID interface{}, userID interface{}) *OrganizationService_AddUsers_Call
  • func (_e *OrganizationService_Expecter) Create(ctx interface{}, org interface{}) *OrganizationService_Create_Call
  • func (_e *OrganizationService_Expecter) Disable(ctx interface{}, id interface{}) *OrganizationService_Disable_Call
  • func (_e *OrganizationService_Expecter) Enable(ctx interface{}, id interface{}) *OrganizationService_Enable_Call
  • func (_e *OrganizationService_Expecter) Get(ctx interface{}, idOrSlug interface{}) *OrganizationService_Get_Call
  • func (_e *OrganizationService_Expecter) List(ctx interface{}, f interface{}) *OrganizationService_List_Call
  • func (_e *OrganizationService_Expecter) ListByUser(ctx interface{}, userID interface{}) *OrganizationService_ListByUser_Call
  • func (_e *OrganizationService_Expecter) RemoveUsers(ctx interface{}, orgID interface{}, userID interface{}) *OrganizationService_RemoveUsers_Call
  • func (_e *OrganizationService_Expecter) Update(ctx interface{}, toUpdate interface{}) *OrganizationService_Update_Call
• type OrganizationService_Get_Call
  • func (_c *OrganizationService_Get_Call) Return(_a0 organization.Organization, _a1 error) *OrganizationService_Get_Call
  • func (_c *OrganizationService_Get_Call) Run(run func(ctx context.Context, idOrSlug string)) *OrganizationService_Get_Call
  • func (_c *OrganizationService_Get_Call) RunAndReturn(run func(context.Context, string) (organization.Organization, error)) *OrganizationService_Get_Call
• type OrganizationService_ListByUser_Call
  • func (_c *OrganizationService_ListByUser_Call) Return(_a0 []organization.Organization, _a1 error) *OrganizationService_ListByUser_Call
  • func (_c *OrganizationService_ListByUser_Call) Run(run func(ctx context.Context, userID string)) *OrganizationService_ListByUser_Call
  • func (_c *OrganizationService_ListByUser_Call) RunAndReturn(run func(context.Context, string) ([]organization.Organization, error)) *OrganizationService_ListByUser_Call
• type OrganizationService_List_Call
  • func (_c *OrganizationService_List_Call) Return(_a0 []organization.Organization, _a1 error) *OrganizationService_List_Call
  • func (_c *OrganizationService_List_Call) Run(run func(ctx context.Context, f organization.Filter)) *OrganizationService_List_Call
  • func (_c *OrganizationService_List_Call) RunAndReturn(...) *OrganizationService_List_Call
• type OrganizationService_RemoveUsers_Call
  • func (_c *OrganizationService_RemoveUsers_Call) Return(_a0 error) *OrganizationService_RemoveUsers_Call
  • func (_c *OrganizationService_RemoveUsers_Call) Run(run func(ctx context.Context, orgID string, userID []string)) *OrganizationService_RemoveUsers_Call
  • func (_c *OrganizationService_RemoveUsers_Call) RunAndReturn(run func(context.Context, string, []string) error) *OrganizationService_RemoveUsers_Call
• type OrganizationService_Update_Call
  • func (_c *OrganizationService_Update_Call) Return(_a0 organization.Organization, _a1 error) *OrganizationService_Update_Call
  • func (_c *OrganizationService_Update_Call) Run(run func(ctx context.Context, toUpdate organization.Organization)) *OrganizationService_Update_Call
  • func (_c *OrganizationService_Update_Call) RunAndReturn(...) *OrganizationService_Update_Call
• type PermissionService
  • func NewPermissionService(t mockConstructorTestingTNewPermissionService) *PermissionService
  • func (_m *PermissionService) EXPECT() *PermissionService_Expecter
  • func (_m *PermissionService) Get(ctx context.Context, id string) (permission.Permission, error)
  • func (_m *PermissionService) List(ctx context.Context, filter permission.Filter) ([]permission.Permission, error)
  • func (_m *PermissionService) Update(ctx context.Context, perm permission.Permission) (permission.Permission, error)
  • func (_m *PermissionService) Upsert(ctx context.Context, perm permission.Permission) (permission.Permission, error)
• type PermissionService_Expecter
  • func (_e *PermissionService_Expecter) Get(ctx interface{}, id interface{}) *PermissionService_Get_Call
  • func (_e *PermissionService_Expecter) List(ctx interface{}, filter interface{}) *PermissionService_List_Call
  • func (_e *PermissionService_Expecter) Update(ctx interface{}, perm interface{}) *PermissionService_Update_Call
  • func (_e *PermissionService_Expecter) Upsert(ctx interface{}, perm interface{}) *PermissionService_Upsert_Call
• type PermissionService_Get_Call
  • func (_c *PermissionService_Get_Call) Return(_a0 permission.Permission, _a1 error) *PermissionService_Get_Call
  • func (_c *PermissionService_Get_Call) Run(run func(ctx context.Context, id string)) *PermissionService_Get_Call
  • func (_c *PermissionService_Get_Call) RunAndReturn(run func(context.Context, string) (permission.Permission, error)) *PermissionService_Get_Call
• type PermissionService_List_Call
  • func (_c *PermissionService_List_Call) Return(_a0 []permission.Permission, _a1 error) *PermissionService_List_Call
  • func (_c *PermissionService_List_Call) Run(run func(ctx context.Context, filter permission.Filter)) *PermissionService_List_Call
  • func (_c *PermissionService_List_Call) RunAndReturn(run func(context.Context, permission.Filter) ([]permission.Permission, error)) *PermissionService_List_Call
• type PermissionService_Update_Call
  • func (_c *PermissionService_Update_Call) Return(_a0 permission.Permission, _a1 error) *PermissionService_Update_Call
  • func (_c *PermissionService_Update_Call) Run(run func(ctx context.Context, perm permission.Permission)) *PermissionService_Update_Call
  • func (_c *PermissionService_Update_Call) RunAndReturn(...) *PermissionService_Update_Call
• type PermissionService_Upsert_Call
  • func (_c *PermissionService_Upsert_Call) Return(_a0 permission.Permission, _a1 error) *PermissionService_Upsert_Call
  • func (_c *PermissionService_Upsert_Call) Run(run func(ctx context.Context, perm permission.Permission)) *PermissionService_Upsert_Call
  • func (_c *PermissionService_Upsert_Call) RunAndReturn(...) *PermissionService_Upsert_Call
• type PolicyService
  • func NewPolicyService(t mockConstructorTestingTNewPolicyService) *PolicyService
  • func (_m *PolicyService) Create(ctx context.Context, pol policy.Policy) (policy.Policy, error)
  • func (_m *PolicyService) Delete(ctx context.Context, id string) error
  • func (_m *PolicyService) EXPECT() *PolicyService_Expecter
  • func (_m *PolicyService) Get(ctx context.Context, id string) (policy.Policy, error)
  • func (_m *PolicyService) List(ctx context.Context, f policy.Filter) ([]policy.Policy, error)
• type PolicyService_Create_Call
  • func (_c *PolicyService_Create_Call) Return(_a0 policy.Policy, _a1 error) *PolicyService_Create_Call
  • func (_c *PolicyService_Create_Call) Run(run func(ctx context.Context, pol policy.Policy)) *PolicyService_Create_Call
  • func (_c *PolicyService_Create_Call) RunAndReturn(run func(context.Context, policy.Policy) (policy.Policy, error)) *PolicyService_Create_Call
• type PolicyService_Delete_Call
  • func (_c *PolicyService_Delete_Call) Return(_a0 error) *PolicyService_Delete_Call
  • func (_c *PolicyService_Delete_Call) Run(run func(ctx context.Context, id string)) *PolicyService_Delete_Call
  • func (_c *PolicyService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *PolicyService_Delete_Call
• type PolicyService_Expecter
  • func (_e *PolicyService_Expecter) Create(ctx interface{}, pol interface{}) *PolicyService_Create_Call
  • func (_e *PolicyService_Expecter) Delete(ctx interface{}, id interface{}) *PolicyService_Delete_Call
  • func (_e *PolicyService_Expecter) Get(ctx interface{}, id interface{}) *PolicyService_Get_Call
  • func (_e *PolicyService_Expecter) List(ctx interface{}, f interface{}) *PolicyService_List_Call
• type PolicyService_Get_Call
  • func (_c *PolicyService_Get_Call) Return(_a0 policy.Policy, _a1 error) *PolicyService_Get_Call
  • func (_c *PolicyService_Get_Call) Run(run func(ctx context.Context, id string)) *PolicyService_Get_Call
  • func (_c *PolicyService_Get_Call) RunAndReturn(run func(context.Context, string) (policy.Policy, error)) *PolicyService_Get_Call
• type PolicyService_List_Call
  • func (_c *PolicyService_List_Call) Return(_a0 []policy.Policy, _a1 error) *PolicyService_List_Call
  • func (_c *PolicyService_List_Call) Run(run func(ctx context.Context, f policy.Filter)) *PolicyService_List_Call
  • func (_c *PolicyService_List_Call) RunAndReturn(run func(context.Context, policy.Filter) ([]policy.Policy, error)) *PolicyService_List_Call
• type ProjectService
  • func NewProjectService(t mockConstructorTestingTNewProjectService) *ProjectService
  • func (_m *ProjectService) Create(ctx context.Context, prj project.Project) (project.Project, error)
  • func (_m *ProjectService) Disable(ctx context.Context, id string) error
  • func (_m *ProjectService) EXPECT() *ProjectService_Expecter
  • func (_m *ProjectService) Enable(ctx context.Context, id string) error
  • func (_m *ProjectService) Get(ctx context.Context, idOrName string) (project.Project, error)
  • func (_m *ProjectService) List(ctx context.Context, f project.Filter) ([]project.Project, error)
  • func (_m *ProjectService) ListByUser(ctx context.Context, userID string) ([]project.Project, error)
  • func (_m *ProjectService) ListUsers(ctx context.Context, id string, permissionFilter string) ([]user.User, error)
  • func (_m *ProjectService) Update(ctx context.Context, toUpdate project.Project) (project.Project, error)
• type ProjectService_Create_Call
  • func (_c *ProjectService_Create_Call) Return(_a0 project.Project, _a1 error) *ProjectService_Create_Call
  • func (_c *ProjectService_Create_Call) Run(run func(ctx context.Context, prj project.Project)) *ProjectService_Create_Call
  • func (_c *ProjectService_Create_Call) RunAndReturn(run func(context.Context, project.Project) (project.Project, error)) *ProjectService_Create_Call
• type ProjectService_Disable_Call
  • func (_c *ProjectService_Disable_Call) Return(_a0 error) *ProjectService_Disable_Call
  • func (_c *ProjectService_Disable_Call) Run(run func(ctx context.Context, id string)) *ProjectService_Disable_Call
  • func (_c *ProjectService_Disable_Call) RunAndReturn(run func(context.Context, string) error) *ProjectService_Disable_Call
• type ProjectService_Enable_Call
  • func (_c *ProjectService_Enable_Call) Return(_a0 error) *ProjectService_Enable_Call
  • func (_c *ProjectService_Enable_Call) Run(run func(ctx context.Context, id string)) *ProjectService_Enable_Call
  • func (_c *ProjectService_Enable_Call) RunAndReturn(run func(context.Context, string) error) *ProjectService_Enable_Call
• type ProjectService_Expecter
  • func (_e *ProjectService_Expecter) Create(ctx interface{}, prj interface{}) *ProjectService_Create_Call
  • func (_e *ProjectService_Expecter) Disable(ctx interface{}, id interface{}) *ProjectService_Disable_Call
  • func (_e *ProjectService_Expecter) Enable(ctx interface{}, id interface{}) *ProjectService_Enable_Call
  • func (_e *ProjectService_Expecter) Get(ctx interface{}, idOrName interface{}) *ProjectService_Get_Call
  • func (_e *ProjectService_Expecter) List(ctx interface{}, f interface{}) *ProjectService_List_Call
  • func (_e *ProjectService_Expecter) ListByUser(ctx interface{}, userID interface{}) *ProjectService_ListByUser_Call
  • func (_e *ProjectService_Expecter) ListUsers(ctx interface{}, id interface{}, permissionFilter interface{}) *ProjectService_ListUsers_Call
  • func (_e *ProjectService_Expecter) Update(ctx interface{}, toUpdate interface{}) *ProjectService_Update_Call
• type ProjectService_Get_Call
  • func (_c *ProjectService_Get_Call) Return(_a0 project.Project, _a1 error) *ProjectService_Get_Call
  • func (_c *ProjectService_Get_Call) Run(run func(ctx context.Context, idOrName string)) *ProjectService_Get_Call
  • func (_c *ProjectService_Get_Call) RunAndReturn(run func(context.Context, string) (project.Project, error)) *ProjectService_Get_Call
• type ProjectService_ListByUser_Call
  • func (_c *ProjectService_ListByUser_Call) Return(_a0 []project.Project, _a1 error) *ProjectService_ListByUser_Call
  • func (_c *ProjectService_ListByUser_Call) Run(run func(ctx context.Context, userID string)) *ProjectService_ListByUser_Call
  • func (_c *ProjectService_ListByUser_Call) RunAndReturn(run func(context.Context, string) ([]project.Project, error)) *ProjectService_ListByUser_Call
• type ProjectService_ListUsers_Call
  • func (_c *ProjectService_ListUsers_Call) Return(_a0 []user.User, _a1 error) *ProjectService_ListUsers_Call
  • func (_c *ProjectService_ListUsers_Call) Run(run func(ctx context.Context, id string, permissionFilter string)) *ProjectService_ListUsers_Call
  • func (_c *ProjectService_ListUsers_Call) RunAndReturn(run func(context.Context, string, string) ([]user.User, error)) *ProjectService_ListUsers_Call
• type ProjectService_List_Call
  • func (_c *ProjectService_List_Call) Return(_a0 []project.Project, _a1 error) *ProjectService_List_Call
  • func (_c *ProjectService_List_Call) Run(run func(ctx context.Context, f project.Filter)) *ProjectService_List_Call
  • func (_c *ProjectService_List_Call) RunAndReturn(run func(context.Context, project.Filter) ([]project.Project, error)) *ProjectService_List_Call
• type ProjectService_Update_Call
  • func (_c *ProjectService_Update_Call) Return(_a0 project.Project, _a1 error) *ProjectService_Update_Call
  • func (_c *ProjectService_Update_Call) Run(run func(ctx context.Context, toUpdate project.Project)) *ProjectService_Update_Call
  • func (_c *ProjectService_Update_Call) RunAndReturn(run func(context.Context, project.Project) (project.Project, error)) *ProjectService_Update_Call
• type RelationService
  • func NewRelationService(t mockConstructorTestingTNewRelationService) *RelationService
  • 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) Get(ctx context.Context, id string) (relation.Relation, error)
  • func (_m *RelationService) List(ctx context.Context) ([]relation.Relation, error)
• type RelationService_Create_Call
  • 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
  • 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
  • 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) Get(ctx interface{}, id interface{}) *RelationService_Get_Call
  • func (_e *RelationService_Expecter) List(ctx interface{}) *RelationService_List_Call
• type RelationService_Get_Call
  • func (_c *RelationService_Get_Call) Return(_a0 relation.Relation, _a1 error) *RelationService_Get_Call
  • func (_c *RelationService_Get_Call) Run(run func(ctx context.Context, id string)) *RelationService_Get_Call
  • func (_c *RelationService_Get_Call) RunAndReturn(run func(context.Context, string) (relation.Relation, error)) *RelationService_Get_Call
• type RelationService_List_Call
  • func (_c *RelationService_List_Call) Return(_a0 []relation.Relation, _a1 error) *RelationService_List_Call
  • func (_c *RelationService_List_Call) Run(run func(ctx context.Context)) *RelationService_List_Call
  • func (_c *RelationService_List_Call) RunAndReturn(run func(context.Context) ([]relation.Relation, error)) *RelationService_List_Call
• type ResourceService
  • func NewResourceService(t mockConstructorTestingTNewResourceService) *ResourceService
  • func (_m *ResourceService) CheckAuthz(ctx context.Context, rel relation.Object, permissionName string) (bool, error)
  • func (_m *ResourceService) Create(ctx context.Context, _a1 resource.Resource) (resource.Resource, error)
  • func (_m *ResourceService) EXPECT() *ResourceService_Expecter
  • func (_m *ResourceService) Get(ctx context.Context, id string) (resource.Resource, error)
  • func (_m *ResourceService) List(ctx context.Context, flt resource.Filter) ([]resource.Resource, error)
  • func (_m *ResourceService) Update(ctx context.Context, _a1 resource.Resource) (resource.Resource, error)
• type ResourceService_CheckAuthz_Call
  • func (_c *ResourceService_CheckAuthz_Call) Return(_a0 bool, _a1 error) *ResourceService_CheckAuthz_Call
  • func (_c *ResourceService_CheckAuthz_Call) Run(run func(ctx context.Context, rel relation.Object, permissionName string)) *ResourceService_CheckAuthz_Call
  • func (_c *ResourceService_CheckAuthz_Call) RunAndReturn(run func(context.Context, relation.Object, string) (bool, error)) *ResourceService_CheckAuthz_Call
• type ResourceService_Create_Call
  • func (_c *ResourceService_Create_Call) Return(_a0 resource.Resource, _a1 error) *ResourceService_Create_Call
  • func (_c *ResourceService_Create_Call) Run(run func(ctx context.Context, _a1 resource.Resource)) *ResourceService_Create_Call
  • func (_c *ResourceService_Create_Call) RunAndReturn(run func(context.Context, resource.Resource) (resource.Resource, error)) *ResourceService_Create_Call
• type ResourceService_Expecter
  • func (_e *ResourceService_Expecter) CheckAuthz(ctx interface{}, rel interface{}, permissionName interface{}) *ResourceService_CheckAuthz_Call
  • func (_e *ResourceService_Expecter) Create(ctx interface{}, _a1 interface{}) *ResourceService_Create_Call
  • func (_e *ResourceService_Expecter) Get(ctx interface{}, id interface{}) *ResourceService_Get_Call
  • func (_e *ResourceService_Expecter) List(ctx interface{}, flt interface{}) *ResourceService_List_Call
  • func (_e *ResourceService_Expecter) Update(ctx interface{}, _a1 interface{}) *ResourceService_Update_Call
• type ResourceService_Get_Call
  • func (_c *ResourceService_Get_Call) Return(_a0 resource.Resource, _a1 error) *ResourceService_Get_Call
  • func (_c *ResourceService_Get_Call) Run(run func(ctx context.Context, id string)) *ResourceService_Get_Call
  • func (_c *ResourceService_Get_Call) RunAndReturn(run func(context.Context, string) (resource.Resource, error)) *ResourceService_Get_Call
• type ResourceService_List_Call
  • func (_c *ResourceService_List_Call) Return(_a0 []resource.Resource, _a1 error) *ResourceService_List_Call
  • func (_c *ResourceService_List_Call) Run(run func(ctx context.Context, flt resource.Filter)) *ResourceService_List_Call
  • func (_c *ResourceService_List_Call) RunAndReturn(run func(context.Context, resource.Filter) ([]resource.Resource, error)) *ResourceService_List_Call
• type ResourceService_Update_Call
  • func (_c *ResourceService_Update_Call) Return(_a0 resource.Resource, _a1 error) *ResourceService_Update_Call
  • func (_c *ResourceService_Update_Call) Run(run func(ctx context.Context, _a1 resource.Resource)) *ResourceService_Update_Call
  • func (_c *ResourceService_Update_Call) RunAndReturn(run func(context.Context, resource.Resource) (resource.Resource, error)) *ResourceService_Update_Call
• type RoleService
  • func NewRoleService(t mockConstructorTestingTNewRoleService) *RoleService
  • func (_m *RoleService) Delete(ctx context.Context, id string) error
  • func (_m *RoleService) EXPECT() *RoleService_Expecter
  • func (_m *RoleService) Get(ctx context.Context, id string) (role.Role, error)
  • func (_m *RoleService) List(ctx context.Context, f role.Filter) ([]role.Role, error)
  • func (_m *RoleService) Update(ctx context.Context, toUpdate role.Role) (role.Role, error)
  • func (_m *RoleService) Upsert(ctx context.Context, toCreate role.Role) (role.Role, error)
• type RoleService_Delete_Call
  • func (_c *RoleService_Delete_Call) Return(_a0 error) *RoleService_Delete_Call
  • func (_c *RoleService_Delete_Call) Run(run func(ctx context.Context, id string)) *RoleService_Delete_Call
  • func (_c *RoleService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *RoleService_Delete_Call
• type RoleService_Expecter
  • func (_e *RoleService_Expecter) Delete(ctx interface{}, id interface{}) *RoleService_Delete_Call
  • func (_e *RoleService_Expecter) Get(ctx interface{}, id interface{}) *RoleService_Get_Call
  • func (_e *RoleService_Expecter) List(ctx interface{}, f interface{}) *RoleService_List_Call
  • func (_e *RoleService_Expecter) Update(ctx interface{}, toUpdate interface{}) *RoleService_Update_Call
  • func (_e *RoleService_Expecter) Upsert(ctx interface{}, toCreate interface{}) *RoleService_Upsert_Call
• type RoleService_Get_Call
  • func (_c *RoleService_Get_Call) Return(_a0 role.Role, _a1 error) *RoleService_Get_Call
  • func (_c *RoleService_Get_Call) Run(run func(ctx context.Context, id string)) *RoleService_Get_Call
  • func (_c *RoleService_Get_Call) RunAndReturn(run func(context.Context, string) (role.Role, error)) *RoleService_Get_Call
• type RoleService_List_Call
  • func (_c *RoleService_List_Call) Return(_a0 []role.Role, _a1 error) *RoleService_List_Call
  • func (_c *RoleService_List_Call) Run(run func(ctx context.Context, f role.Filter)) *RoleService_List_Call
  • func (_c *RoleService_List_Call) RunAndReturn(run func(context.Context, role.Filter) ([]role.Role, error)) *RoleService_List_Call
• type RoleService_Update_Call
  • func (_c *RoleService_Update_Call) Return(_a0 role.Role, _a1 error) *RoleService_Update_Call
  • func (_c *RoleService_Update_Call) Run(run func(ctx context.Context, toUpdate role.Role)) *RoleService_Update_Call
  • func (_c *RoleService_Update_Call) RunAndReturn(run func(context.Context, role.Role) (role.Role, error)) *RoleService_Update_Call
• type RoleService_Upsert_Call
  • func (_c *RoleService_Upsert_Call) Return(_a0 role.Role, _a1 error) *RoleService_Upsert_Call
  • func (_c *RoleService_Upsert_Call) Run(run func(ctx context.Context, toCreate role.Role)) *RoleService_Upsert_Call
  • func (_c *RoleService_Upsert_Call) RunAndReturn(run func(context.Context, role.Role) (role.Role, error)) *RoleService_Upsert_Call
• type RuleService
  • func NewRuleService(t mockConstructorTestingTNewRuleService) *RuleService
  • func (_m *RuleService) EXPECT() *RuleService_Expecter
  • func (_m *RuleService) GetAllConfigs(ctx context.Context) ([]rule.Ruleset, error)
• type RuleService_Expecter
  • func (_e *RuleService_Expecter) GetAllConfigs(ctx interface{}) *RuleService_GetAllConfigs_Call
• type RuleService_GetAllConfigs_Call
  • func (_c *RuleService_GetAllConfigs_Call) Return(_a0 []rule.Ruleset, _a1 error) *RuleService_GetAllConfigs_Call
  • func (_c *RuleService_GetAllConfigs_Call) Run(run func(ctx context.Context)) *RuleService_GetAllConfigs_Call
  • func (_c *RuleService_GetAllConfigs_Call) RunAndReturn(run func(context.Context) ([]rule.Ruleset, error)) *RuleService_GetAllConfigs_Call
• type ServiceUserService
  • func NewServiceUserService(t mockConstructorTestingTNewServiceUserService) *ServiceUserService
  • func (_m *ServiceUserService) Create(ctx context.Context, serviceUser serviceuser.ServiceUser) (serviceuser.ServiceUser, error)
  • func (_m *ServiceUserService) CreateKey(ctx context.Context, cred serviceuser.Credential) (serviceuser.Credential, error)
  • func (_m *ServiceUserService) CreateSecret(ctx context.Context, credential serviceuser.Credential) (serviceuser.Secret, error)
  • func (_m *ServiceUserService) Delete(ctx context.Context, id string) error
  • func (_m *ServiceUserService) DeleteKey(ctx context.Context, credID string) error
  • func (_m *ServiceUserService) DeleteSecret(ctx context.Context, credID string) error
  • func (_m *ServiceUserService) EXPECT() *ServiceUserService_Expecter
  • func (_m *ServiceUserService) Get(ctx context.Context, id string) (serviceuser.ServiceUser, error)
  • func (_m *ServiceUserService) GetKey(ctx context.Context, credID string) (serviceuser.Credential, error)
  • func (_m *ServiceUserService) List(ctx context.Context, flt serviceuser.Filter) ([]serviceuser.ServiceUser, error)
  • func (_m *ServiceUserService) ListByOrg(ctx context.Context, orgID string) ([]serviceuser.ServiceUser, error)
  • func (_m *ServiceUserService) ListKeys(ctx context.Context, serviceUserID string) ([]serviceuser.Credential, error)
  • func (_m *ServiceUserService) ListSecret(ctx context.Context, serviceUserID string) ([]serviceuser.Credential, error)
• type ServiceUserService_CreateKey_Call
  • func (_c *ServiceUserService_CreateKey_Call) Return(_a0 serviceuser.Credential, _a1 error) *ServiceUserService_CreateKey_Call
  • func (_c *ServiceUserService_CreateKey_Call) Run(run func(ctx context.Context, cred serviceuser.Credential)) *ServiceUserService_CreateKey_Call
  • func (_c *ServiceUserService_CreateKey_Call) RunAndReturn(...) *ServiceUserService_CreateKey_Call
• type ServiceUserService_CreateSecret_Call
  • func (_c *ServiceUserService_CreateSecret_Call) Return(_a0 serviceuser.Secret, _a1 error) *ServiceUserService_CreateSecret_Call
  • func (_c *ServiceUserService_CreateSecret_Call) Run(run func(ctx context.Context, credential serviceuser.Credential)) *ServiceUserService_CreateSecret_Call
  • func (_c *ServiceUserService_CreateSecret_Call) RunAndReturn(run func(context.Context, serviceuser.Credential) (serviceuser.Secret, error)) *ServiceUserService_CreateSecret_Call
• type ServiceUserService_Create_Call
  • func (_c *ServiceUserService_Create_Call) Return(_a0 serviceuser.ServiceUser, _a1 error) *ServiceUserService_Create_Call
  • func (_c *ServiceUserService_Create_Call) Run(run func(ctx context.Context, serviceUser serviceuser.ServiceUser)) *ServiceUserService_Create_Call
  • func (_c *ServiceUserService_Create_Call) RunAndReturn(...) *ServiceUserService_Create_Call
• type ServiceUserService_DeleteKey_Call
  • func (_c *ServiceUserService_DeleteKey_Call) Return(_a0 error) *ServiceUserService_DeleteKey_Call
  • func (_c *ServiceUserService_DeleteKey_Call) Run(run func(ctx context.Context, credID string)) *ServiceUserService_DeleteKey_Call
  • func (_c *ServiceUserService_DeleteKey_Call) RunAndReturn(run func(context.Context, string) error) *ServiceUserService_DeleteKey_Call
• type ServiceUserService_DeleteSecret_Call
  • func (_c *ServiceUserService_DeleteSecret_Call) Return(_a0 error) *ServiceUserService_DeleteSecret_Call
  • func (_c *ServiceUserService_DeleteSecret_Call) Run(run func(ctx context.Context, credID string)) *ServiceUserService_DeleteSecret_Call
  • func (_c *ServiceUserService_DeleteSecret_Call) RunAndReturn(run func(context.Context, string) error) *ServiceUserService_DeleteSecret_Call
• type ServiceUserService_Delete_Call
  • func (_c *ServiceUserService_Delete_Call) Return(_a0 error) *ServiceUserService_Delete_Call
  • func (_c *ServiceUserService_Delete_Call) Run(run func(ctx context.Context, id string)) *ServiceUserService_Delete_Call
  • func (_c *ServiceUserService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *ServiceUserService_Delete_Call
• type ServiceUserService_Expecter
  • func (_e *ServiceUserService_Expecter) Create(ctx interface{}, serviceUser interface{}) *ServiceUserService_Create_Call
  • func (_e *ServiceUserService_Expecter) CreateKey(ctx interface{}, cred interface{}) *ServiceUserService_CreateKey_Call
  • func (_e *ServiceUserService_Expecter) CreateSecret(ctx interface{}, credential interface{}) *ServiceUserService_CreateSecret_Call
  • func (_e *ServiceUserService_Expecter) Delete(ctx interface{}, id interface{}) *ServiceUserService_Delete_Call
  • func (_e *ServiceUserService_Expecter) DeleteKey(ctx interface{}, credID interface{}) *ServiceUserService_DeleteKey_Call
  • func (_e *ServiceUserService_Expecter) DeleteSecret(ctx interface{}, credID interface{}) *ServiceUserService_DeleteSecret_Call
  • func (_e *ServiceUserService_Expecter) Get(ctx interface{}, id interface{}) *ServiceUserService_Get_Call
  • func (_e *ServiceUserService_Expecter) GetKey(ctx interface{}, credID interface{}) *ServiceUserService_GetKey_Call
  • func (_e *ServiceUserService_Expecter) List(ctx interface{}, flt interface{}) *ServiceUserService_List_Call
  • func (_e *ServiceUserService_Expecter) ListByOrg(ctx interface{}, orgID interface{}) *ServiceUserService_ListByOrg_Call
  • func (_e *ServiceUserService_Expecter) ListKeys(ctx interface{}, serviceUserID interface{}) *ServiceUserService_ListKeys_Call
  • func (_e *ServiceUserService_Expecter) ListSecret(ctx interface{}, serviceUserID interface{}) *ServiceUserService_ListSecret_Call
• type ServiceUserService_GetKey_Call
  • func (_c *ServiceUserService_GetKey_Call) Return(_a0 serviceuser.Credential, _a1 error) *ServiceUserService_GetKey_Call
  • func (_c *ServiceUserService_GetKey_Call) Run(run func(ctx context.Context, credID string)) *ServiceUserService_GetKey_Call
  • func (_c *ServiceUserService_GetKey_Call) RunAndReturn(run func(context.Context, string) (serviceuser.Credential, error)) *ServiceUserService_GetKey_Call
• type ServiceUserService_Get_Call
  • func (_c *ServiceUserService_Get_Call) Return(_a0 serviceuser.ServiceUser, _a1 error) *ServiceUserService_Get_Call
  • func (_c *ServiceUserService_Get_Call) Run(run func(ctx context.Context, id string)) *ServiceUserService_Get_Call
  • func (_c *ServiceUserService_Get_Call) RunAndReturn(run func(context.Context, string) (serviceuser.ServiceUser, error)) *ServiceUserService_Get_Call
• type ServiceUserService_ListByOrg_Call
  • func (_c *ServiceUserService_ListByOrg_Call) Return(_a0 []serviceuser.ServiceUser, _a1 error) *ServiceUserService_ListByOrg_Call
  • func (_c *ServiceUserService_ListByOrg_Call) Run(run func(ctx context.Context, orgID string)) *ServiceUserService_ListByOrg_Call
  • func (_c *ServiceUserService_ListByOrg_Call) RunAndReturn(run func(context.Context, string) ([]serviceuser.ServiceUser, error)) *ServiceUserService_ListByOrg_Call
• type ServiceUserService_ListKeys_Call
  • func (_c *ServiceUserService_ListKeys_Call) Return(_a0 []serviceuser.Credential, _a1 error) *ServiceUserService_ListKeys_Call
  • func (_c *ServiceUserService_ListKeys_Call) Run(run func(ctx context.Context, serviceUserID string)) *ServiceUserService_ListKeys_Call
  • func (_c *ServiceUserService_ListKeys_Call) RunAndReturn(run func(context.Context, string) ([]serviceuser.Credential, error)) *ServiceUserService_ListKeys_Call
• type ServiceUserService_ListSecret_Call
  • func (_c *ServiceUserService_ListSecret_Call) Return(_a0 []serviceuser.Credential, _a1 error) *ServiceUserService_ListSecret_Call
  • func (_c *ServiceUserService_ListSecret_Call) Run(run func(ctx context.Context, serviceUserID string)) *ServiceUserService_ListSecret_Call
  • func (_c *ServiceUserService_ListSecret_Call) RunAndReturn(run func(context.Context, string) ([]serviceuser.Credential, error)) *ServiceUserService_ListSecret_Call
• type ServiceUserService_List_Call
  • func (_c *ServiceUserService_List_Call) Return(_a0 []serviceuser.ServiceUser, _a1 error) *ServiceUserService_List_Call
  • func (_c *ServiceUserService_List_Call) Run(run func(ctx context.Context, flt serviceuser.Filter)) *ServiceUserService_List_Call
  • func (_c *ServiceUserService_List_Call) RunAndReturn(...) *ServiceUserService_List_Call
• type SessionService
  • func NewSessionService(t mockConstructorTestingTNewSessionService) *SessionService
  • func (_m *SessionService) Close()
  • func (_m *SessionService) Create(ctx context.Context, userID string) (*session.Session, error)
  • func (_m *SessionService) Delete(ctx context.Context, sessionID uuid.UUID) error
  • func (_m *SessionService) EXPECT() *SessionService_Expecter
  • func (_m *SessionService) ExtractFromContext(ctx context.Context) (*session.Session, error)
  • func (_m *SessionService) InitSessions(ctx context.Context) error
  • func (_m *SessionService) Refresh(ctx context.Context, sessionID uuid.UUID) error
• type SessionService_Close_Call
  • func (_c *SessionService_Close_Call) Return() *SessionService_Close_Call
  • func (_c *SessionService_Close_Call) Run(run func()) *SessionService_Close_Call
  • func (_c *SessionService_Close_Call) RunAndReturn(run func()) *SessionService_Close_Call
• type SessionService_Create_Call
  • func (_c *SessionService_Create_Call) Return(_a0 *session.Session, _a1 error) *SessionService_Create_Call
  • func (_c *SessionService_Create_Call) Run(run func(ctx context.Context, userID string)) *SessionService_Create_Call
  • func (_c *SessionService_Create_Call) RunAndReturn(run func(context.Context, string) (*session.Session, error)) *SessionService_Create_Call
• type SessionService_Delete_Call
  • func (_c *SessionService_Delete_Call) Return(_a0 error) *SessionService_Delete_Call
  • func (_c *SessionService_Delete_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *SessionService_Delete_Call
  • func (_c *SessionService_Delete_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *SessionService_Delete_Call
• type SessionService_Expecter
  • func (_e *SessionService_Expecter) Close() *SessionService_Close_Call
  • func (_e *SessionService_Expecter) Create(ctx interface{}, userID interface{}) *SessionService_Create_Call
  • func (_e *SessionService_Expecter) Delete(ctx interface{}, sessionID interface{}) *SessionService_Delete_Call
  • func (_e *SessionService_Expecter) ExtractFromContext(ctx interface{}) *SessionService_ExtractFromContext_Call
  • func (_e *SessionService_Expecter) InitSessions(ctx interface{}) *SessionService_InitSessions_Call
  • func (_e *SessionService_Expecter) Refresh(ctx interface{}, sessionID interface{}) *SessionService_Refresh_Call
• type SessionService_ExtractFromContext_Call
  • func (_c *SessionService_ExtractFromContext_Call) Return(_a0 *session.Session, _a1 error) *SessionService_ExtractFromContext_Call
  • func (_c *SessionService_ExtractFromContext_Call) Run(run func(ctx context.Context)) *SessionService_ExtractFromContext_Call
  • func (_c *SessionService_ExtractFromContext_Call) RunAndReturn(run func(context.Context) (*session.Session, error)) *SessionService_ExtractFromContext_Call
• type SessionService_InitSessions_Call
  • func (_c *SessionService_InitSessions_Call) Return(_a0 error) *SessionService_InitSessions_Call
  • func (_c *SessionService_InitSessions_Call) Run(run func(ctx context.Context)) *SessionService_InitSessions_Call
  • func (_c *SessionService_InitSessions_Call) RunAndReturn(run func(context.Context) error) *SessionService_InitSessions_Call
• type SessionService_Refresh_Call
  • func (_c *SessionService_Refresh_Call) Return(_a0 error) *SessionService_Refresh_Call
  • func (_c *SessionService_Refresh_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *SessionService_Refresh_Call
  • func (_c *SessionService_Refresh_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *SessionService_Refresh_Call
• type UserService
  • func NewUserService(t mockConstructorTestingTNewUserService) *UserService
  • func (_m *UserService) Create(ctx context.Context, _a1 user.User) (user.User, error)
  • func (_m *UserService) Delete(ctx context.Context, id string) error
  • func (_m *UserService) Disable(ctx context.Context, id string) error
  • func (_m *UserService) EXPECT() *UserService_Expecter
  • func (_m *UserService) Enable(ctx context.Context, id string) error
  • func (_m *UserService) GetByEmail(ctx context.Context, email string) (user.User, error)
  • func (_m *UserService) GetByID(ctx context.Context, id string) (user.User, error)
  • func (_m *UserService) GetByIDs(ctx context.Context, userIDs []string) ([]user.User, error)
  • func (_m *UserService) IsSudo(ctx context.Context, id string) (bool, error)
  • func (_m *UserService) List(ctx context.Context, flt user.Filter) ([]user.User, error)
  • func (_m *UserService) ListByGroup(ctx context.Context, groupID string, permissionFilter string) ([]user.User, error)
  • func (_m *UserService) ListByOrg(ctx context.Context, orgID string, permissionFilter string) ([]user.User, error)
  • func (_m *UserService) Update(ctx context.Context, toUpdate user.User) (user.User, error)
• type UserService_Create_Call
  • func (_c *UserService_Create_Call) Return(_a0 user.User, _a1 error) *UserService_Create_Call
  • func (_c *UserService_Create_Call) Run(run func(ctx context.Context, _a1 user.User)) *UserService_Create_Call
  • func (_c *UserService_Create_Call) RunAndReturn(run func(context.Context, user.User) (user.User, error)) *UserService_Create_Call
• type UserService_Delete_Call
  • func (_c *UserService_Delete_Call) Return(_a0 error) *UserService_Delete_Call
  • func (_c *UserService_Delete_Call) Run(run func(ctx context.Context, id string)) *UserService_Delete_Call
  • func (_c *UserService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *UserService_Delete_Call
• type UserService_Disable_Call
  • func (_c *UserService_Disable_Call) Return(_a0 error) *UserService_Disable_Call
  • func (_c *UserService_Disable_Call) Run(run func(ctx context.Context, id string)) *UserService_Disable_Call
  • func (_c *UserService_Disable_Call) RunAndReturn(run func(context.Context, string) error) *UserService_Disable_Call
• type UserService_Enable_Call
  • func (_c *UserService_Enable_Call) Return(_a0 error) *UserService_Enable_Call
  • func (_c *UserService_Enable_Call) Run(run func(ctx context.Context, id string)) *UserService_Enable_Call
  • func (_c *UserService_Enable_Call) RunAndReturn(run func(context.Context, string) error) *UserService_Enable_Call
• type UserService_Expecter
  • func (_e *UserService_Expecter) Create(ctx interface{}, _a1 interface{}) *UserService_Create_Call
  • func (_e *UserService_Expecter) Delete(ctx interface{}, id interface{}) *UserService_Delete_Call
  • func (_e *UserService_Expecter) Disable(ctx interface{}, id interface{}) *UserService_Disable_Call
  • func (_e *UserService_Expecter) Enable(ctx interface{}, id interface{}) *UserService_Enable_Call
  • func (_e *UserService_Expecter) GetByEmail(ctx interface{}, email interface{}) *UserService_GetByEmail_Call
  • func (_e *UserService_Expecter) GetByID(ctx interface{}, id interface{}) *UserService_GetByID_Call
  • func (_e *UserService_Expecter) GetByIDs(ctx interface{}, userIDs interface{}) *UserService_GetByIDs_Call
  • func (_e *UserService_Expecter) IsSudo(ctx interface{}, id interface{}) *UserService_IsSudo_Call
  • func (_e *UserService_Expecter) List(ctx interface{}, flt interface{}) *UserService_List_Call
  • func (_e *UserService_Expecter) ListByGroup(ctx interface{}, groupID interface{}, permissionFilter interface{}) *UserService_ListByGroup_Call
  • func (_e *UserService_Expecter) ListByOrg(ctx interface{}, orgID interface{}, permissionFilter interface{}) *UserService_ListByOrg_Call
  • func (_e *UserService_Expecter) Update(ctx interface{}, toUpdate interface{}) *UserService_Update_Call
• type UserService_GetByEmail_Call
  • func (_c *UserService_GetByEmail_Call) Return(_a0 user.User, _a1 error) *UserService_GetByEmail_Call
  • func (_c *UserService_GetByEmail_Call) Run(run func(ctx context.Context, email string)) *UserService_GetByEmail_Call
  • func (_c *UserService_GetByEmail_Call) RunAndReturn(run func(context.Context, string) (user.User, error)) *UserService_GetByEmail_Call
• type UserService_GetByID_Call
  • func (_c *UserService_GetByID_Call) Return(_a0 user.User, _a1 error) *UserService_GetByID_Call
  • func (_c *UserService_GetByID_Call) Run(run func(ctx context.Context, id string)) *UserService_GetByID_Call
  • func (_c *UserService_GetByID_Call) RunAndReturn(run func(context.Context, string) (user.User, error)) *UserService_GetByID_Call
• type UserService_GetByIDs_Call
  • func (_c *UserService_GetByIDs_Call) Return(_a0 []user.User, _a1 error) *UserService_GetByIDs_Call
  • func (_c *UserService_GetByIDs_Call) Run(run func(ctx context.Context, userIDs []string)) *UserService_GetByIDs_Call
  • func (_c *UserService_GetByIDs_Call) RunAndReturn(run func(context.Context, []string) ([]user.User, error)) *UserService_GetByIDs_Call
• type UserService_IsSudo_Call
  • func (_c *UserService_IsSudo_Call) Return(_a0 bool, _a1 error) *UserService_IsSudo_Call
  • func (_c *UserService_IsSudo_Call) Run(run func(ctx context.Context, id string)) *UserService_IsSudo_Call
  • func (_c *UserService_IsSudo_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *UserService_IsSudo_Call
• type UserService_ListByGroup_Call
  • func (_c *UserService_ListByGroup_Call) Return(_a0 []user.User, _a1 error) *UserService_ListByGroup_Call
  • func (_c *UserService_ListByGroup_Call) Run(run func(ctx context.Context, groupID string, permissionFilter string)) *UserService_ListByGroup_Call
  • func (_c *UserService_ListByGroup_Call) RunAndReturn(run func(context.Context, string, string) ([]user.User, error)) *UserService_ListByGroup_Call
• type UserService_ListByOrg_Call
  • func (_c *UserService_ListByOrg_Call) Return(_a0 []user.User, _a1 error) *UserService_ListByOrg_Call
  • func (_c *UserService_ListByOrg_Call) Run(run func(ctx context.Context, orgID string, permissionFilter string)) *UserService_ListByOrg_Call
  • func (_c *UserService_ListByOrg_Call) RunAndReturn(run func(context.Context, string, string) ([]user.User, error)) *UserService_ListByOrg_Call
• type UserService_List_Call
  • func (_c *UserService_List_Call) Return(_a0 []user.User, _a1 error) *UserService_List_Call
  • func (_c *UserService_List_Call) Run(run func(ctx context.Context, flt user.Filter)) *UserService_List_Call
  • func (_c *UserService_List_Call) RunAndReturn(run func(context.Context, user.Filter) ([]user.User, error)) *UserService_List_Call
• type UserService_Update_Call
  • func (_c *UserService_Update_Call) Return(_a0 user.User, _a1 error) *UserService_Update_Call
  • func (_c *UserService_Update_Call) Run(run func(ctx context.Context, toUpdate user.User)) *UserService_Update_Call
  • func (_c *UserService_Update_Call) RunAndReturn(run func(context.Context, user.User) (user.User, error)) *UserService_Update_Call

Types

type AuditService

type AuditService struct {
	mock.Mock
}

AuditService is an autogenerated mock type for the AuditService type

func NewAuditService

func NewAuditService(t mockConstructorTestingTNewAuditService) *AuditService

NewAuditService creates a new instance of AuditService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*AuditService) Create

func (_m *AuditService) Create(ctx context.Context, log *audit.Log) error

Create provides a mock function with given fields: ctx, log

func (*AuditService) EXPECT

func (_m *AuditService) EXPECT() *AuditService_Expecter

func (*AuditService) GetByID

func (_m *AuditService) GetByID(ctx context.Context, id string) (audit.Log, error)

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

func (*AuditService) List

func (_m *AuditService) List(ctx context.Context, filter audit.Filter) ([]audit.Log, error)

List provides a mock function with given fields: ctx, filter

type AuditService_Create_Call

type AuditService_Create_Call struct {
	*mock.Call
}

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

func (*AuditService_Create_Call) Return

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

func (*AuditService_Create_Call) Run

func (_c *AuditService_Create_Call) Run(run func(ctx context.Context, log *audit.Log)) *AuditService_Create_Call

func (*AuditService_Create_Call) RunAndReturn

func (_c *AuditService_Create_Call) RunAndReturn(run func(context.Context, *audit.Log) error) *AuditService_Create_Call

type AuditService_Expecter

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

func (*AuditService_Expecter) Create

func (_e *AuditService_Expecter) Create(ctx interface{}, log interface{}) *AuditService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• log *audit.Log

func (*AuditService_Expecter) GetByID

func (_e *AuditService_Expecter) GetByID(ctx interface{}, id interface{}) *AuditService_GetByID_Call

GetByID is a helper method to define mock.On call

• ctx context.Context
• id string

func (*AuditService_Expecter) List

func (_e *AuditService_Expecter) List(ctx interface{}, filter interface{}) *AuditService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• filter audit.Filter

type AuditService_GetByID_Call

type AuditService_GetByID_Call struct {
	*mock.Call
}

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

func (*AuditService_GetByID_Call) Return

func (_c *AuditService_GetByID_Call) Return(_a0 audit.Log, _a1 error) *AuditService_GetByID_Call

func (*AuditService_GetByID_Call) Run

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

func (*AuditService_GetByID_Call) RunAndReturn

func (_c *AuditService_GetByID_Call) RunAndReturn(run func(context.Context, string) (audit.Log, error)) *AuditService_GetByID_Call

type AuditService_List_Call

type AuditService_List_Call struct {
	*mock.Call
}

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

func (*AuditService_List_Call) Return

func (_c *AuditService_List_Call) Return(_a0 []audit.Log, _a1 error) *AuditService_List_Call

func (*AuditService_List_Call) Run

func (_c *AuditService_List_Call) Run(run func(ctx context.Context, filter audit.Filter)) *AuditService_List_Call

func (*AuditService_List_Call) RunAndReturn

func (_c *AuditService_List_Call) RunAndReturn(run func(context.Context, audit.Filter) ([]audit.Log, error)) *AuditService_List_Call

type AuthnService

type AuthnService struct {
	mock.Mock
}

AuthnService is an autogenerated mock type for the AuthnService type

func NewAuthnService

func NewAuthnService(t mockConstructorTestingTNewAuthnService) *AuthnService

NewAuthnService creates a new instance of AuthnService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*AuthnService) BuildToken

func (_m *AuthnService) BuildToken(ctx context.Context, principalID string, metadata map[string]string) ([]byte, error)

BuildToken provides a mock function with given fields: ctx, principalID, metadata

func (*AuthnService) Close

func (_m *AuthnService) Close()

Close provides a mock function with given fields:

func (*AuthnService) EXPECT

func (_m *AuthnService) EXPECT() *AuthnService_Expecter

func (*AuthnService) FinishFlow

func (_m *AuthnService) FinishFlow(ctx context.Context, request authenticate.RegistrationFinishRequest) (*authenticate.RegistrationFinishResponse, error)

FinishFlow provides a mock function with given fields: ctx, request

func (*AuthnService) GetPrincipal

func (_m *AuthnService) GetPrincipal(ctx context.Context, via ...authenticate.ClientAssertion) (authenticate.Principal, error)

GetPrincipal provides a mock function with given fields: ctx, via

func (*AuthnService) InitFlows

func (_m *AuthnService) InitFlows(ctx context.Context) error

InitFlows provides a mock function with given fields: ctx

func (*AuthnService) JWKs

func (_m *AuthnService) JWKs(ctx context.Context) jwk.Set

JWKs provides a mock function with given fields: ctx

func (*AuthnService) StartFlow

func (_m *AuthnService) StartFlow(ctx context.Context, request authenticate.RegistrationStartRequest) (*authenticate.RegistrationStartResponse, error)

StartFlow provides a mock function with given fields: ctx, request

func (*AuthnService) SupportedStrategies

func (_m *AuthnService) SupportedStrategies() []string

SupportedStrategies provides a mock function with given fields:

type AuthnService_BuildToken_Call

type AuthnService_BuildToken_Call struct {
	*mock.Call
}

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

func (*AuthnService_BuildToken_Call) Return

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

func (*AuthnService_BuildToken_Call) Run

func (_c *AuthnService_BuildToken_Call) Run(run func(ctx context.Context, principalID string, metadata map[string]string)) *AuthnService_BuildToken_Call

func (*AuthnService_BuildToken_Call) RunAndReturn

func (_c *AuthnService_BuildToken_Call) RunAndReturn(run func(context.Context, string, map[string]string) ([]byte, error)) *AuthnService_BuildToken_Call

type AuthnService_Close_Call

type AuthnService_Close_Call struct {
	*mock.Call
}

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

func (*AuthnService_Close_Call) Return

func (_c *AuthnService_Close_Call) Return() *AuthnService_Close_Call

func (*AuthnService_Close_Call) Run

func (_c *AuthnService_Close_Call) Run(run func()) *AuthnService_Close_Call

func (*AuthnService_Close_Call) RunAndReturn

func (_c *AuthnService_Close_Call) RunAndReturn(run func()) *AuthnService_Close_Call

type AuthnService_Expecter

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

func (*AuthnService_Expecter) BuildToken

func (_e *AuthnService_Expecter) BuildToken(ctx interface{}, principalID interface{}, metadata interface{}) *AuthnService_BuildToken_Call

BuildToken is a helper method to define mock.On call

• ctx context.Context
• principalID string
• metadata map[string]string

func (*AuthnService_Expecter) Close

func (_e *AuthnService_Expecter) Close() *AuthnService_Close_Call

Close is a helper method to define mock.On call

func (*AuthnService_Expecter) FinishFlow

func (_e *AuthnService_Expecter) FinishFlow(ctx interface{}, request interface{}) *AuthnService_FinishFlow_Call

FinishFlow is a helper method to define mock.On call

• ctx context.Context
• request authenticate.RegistrationFinishRequest

func (*AuthnService_Expecter) GetPrincipal

func (_e *AuthnService_Expecter) GetPrincipal(ctx interface{}, via ...interface{}) *AuthnService_GetPrincipal_Call

GetPrincipal is a helper method to define mock.On call

• ctx context.Context
• via ...authenticate.ClientAssertion

func (*AuthnService_Expecter) InitFlows

func (_e *AuthnService_Expecter) InitFlows(ctx interface{}) *AuthnService_InitFlows_Call

InitFlows is a helper method to define mock.On call

• ctx context.Context

func (*AuthnService_Expecter) JWKs

func (_e *AuthnService_Expecter) JWKs(ctx interface{}) *AuthnService_JWKs_Call

JWKs is a helper method to define mock.On call

• ctx context.Context

func (*AuthnService_Expecter) StartFlow

func (_e *AuthnService_Expecter) StartFlow(ctx interface{}, request interface{}) *AuthnService_StartFlow_Call

StartFlow is a helper method to define mock.On call

• ctx context.Context
• request authenticate.RegistrationStartRequest

func (*AuthnService_Expecter) SupportedStrategies

func (_e *AuthnService_Expecter) SupportedStrategies() *AuthnService_SupportedStrategies_Call

SupportedStrategies is a helper method to define mock.On call

type AuthnService_FinishFlow_Call

type AuthnService_FinishFlow_Call struct {
	*mock.Call
}

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

func (*AuthnService_FinishFlow_Call) Return

func (_c *AuthnService_FinishFlow_Call) Return(_a0 *authenticate.RegistrationFinishResponse, _a1 error) *AuthnService_FinishFlow_Call

func (*AuthnService_FinishFlow_Call) Run

func (_c *AuthnService_FinishFlow_Call) Run(run func(ctx context.Context, request authenticate.RegistrationFinishRequest)) *AuthnService_FinishFlow_Call

func (*AuthnService_FinishFlow_Call) RunAndReturn

func (_c *AuthnService_FinishFlow_Call) RunAndReturn(run func(context.Context, authenticate.RegistrationFinishRequest) (*authenticate.RegistrationFinishResponse, error)) *AuthnService_FinishFlow_Call

type AuthnService_GetPrincipal_Call

type AuthnService_GetPrincipal_Call struct {
	*mock.Call
}

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

func (*AuthnService_GetPrincipal_Call) Return

func (_c *AuthnService_GetPrincipal_Call) Return(_a0 authenticate.Principal, _a1 error) *AuthnService_GetPrincipal_Call

func (*AuthnService_GetPrincipal_Call) Run

func (_c *AuthnService_GetPrincipal_Call) Run(run func(ctx context.Context, via ...authenticate.ClientAssertion)) *AuthnService_GetPrincipal_Call

func (*AuthnService_GetPrincipal_Call) RunAndReturn

func (_c *AuthnService_GetPrincipal_Call) RunAndReturn(run func(context.Context, ...authenticate.ClientAssertion) (authenticate.Principal, error)) *AuthnService_GetPrincipal_Call

type AuthnService_InitFlows_Call

type AuthnService_InitFlows_Call struct {
	*mock.Call
}

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

func (*AuthnService_InitFlows_Call) Return

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

func (*AuthnService_InitFlows_Call) Run

func (_c *AuthnService_InitFlows_Call) Run(run func(ctx context.Context)) *AuthnService_InitFlows_Call

func (*AuthnService_InitFlows_Call) RunAndReturn

func (_c *AuthnService_InitFlows_Call) RunAndReturn(run func(context.Context) error) *AuthnService_InitFlows_Call

type AuthnService_JWKs_Call

type AuthnService_JWKs_Call struct {
	*mock.Call
}

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

func (*AuthnService_JWKs_Call) Return

func (_c *AuthnService_JWKs_Call) Return(_a0 jwk.Set) *AuthnService_JWKs_Call

func (*AuthnService_JWKs_Call) Run

func (_c *AuthnService_JWKs_Call) Run(run func(ctx context.Context)) *AuthnService_JWKs_Call

func (*AuthnService_JWKs_Call) RunAndReturn

func (_c *AuthnService_JWKs_Call) RunAndReturn(run func(context.Context) jwk.Set) *AuthnService_JWKs_Call

type AuthnService_StartFlow_Call

type AuthnService_StartFlow_Call struct {
	*mock.Call
}

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

func (*AuthnService_StartFlow_Call) Return

func (_c *AuthnService_StartFlow_Call) Return(_a0 *authenticate.RegistrationStartResponse, _a1 error) *AuthnService_StartFlow_Call

func (*AuthnService_StartFlow_Call) Run

func (_c *AuthnService_StartFlow_Call) Run(run func(ctx context.Context, request authenticate.RegistrationStartRequest)) *AuthnService_StartFlow_Call

func (*AuthnService_StartFlow_Call) RunAndReturn

func (_c *AuthnService_StartFlow_Call) RunAndReturn(run func(context.Context, authenticate.RegistrationStartRequest) (*authenticate.RegistrationStartResponse, error)) *AuthnService_StartFlow_Call

type AuthnService_SupportedStrategies_Call

type AuthnService_SupportedStrategies_Call struct {
	*mock.Call
}

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

func (*AuthnService_SupportedStrategies_Call) Return

func (_c *AuthnService_SupportedStrategies_Call) Return(_a0 []string) *AuthnService_SupportedStrategies_Call

func (*AuthnService_SupportedStrategies_Call) Run

func (_c *AuthnService_SupportedStrategies_Call) Run(run func()) *AuthnService_SupportedStrategies_Call

func (*AuthnService_SupportedStrategies_Call) RunAndReturn

func (_c *AuthnService_SupportedStrategies_Call) RunAndReturn(run func() []string) *AuthnService_SupportedStrategies_Call

type BootstrapService

type BootstrapService struct {
	mock.Mock
}

BootstrapService is an autogenerated mock type for the BootstrapService type

func NewBootstrapService

func NewBootstrapService(t mockConstructorTestingTNewBootstrapService) *BootstrapService

NewBootstrapService creates a new instance of BootstrapService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*BootstrapService) AppendSchema

func (_m *BootstrapService) AppendSchema(ctx context.Context, definition schema.ServiceDefinition) error

AppendSchema provides a mock function with given fields: ctx, definition

func (*BootstrapService) EXPECT

func (_m *BootstrapService) EXPECT() *BootstrapService_Expecter

type BootstrapService_AppendSchema_Call

type BootstrapService_AppendSchema_Call struct {
	*mock.Call
}

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

func (*BootstrapService_AppendSchema_Call) Return

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

func (*BootstrapService_AppendSchema_Call) Run

func (_c *BootstrapService_AppendSchema_Call) Run(run func(ctx context.Context, definition schema.ServiceDefinition)) *BootstrapService_AppendSchema_Call

func (*BootstrapService_AppendSchema_Call) RunAndReturn

func (_c *BootstrapService_AppendSchema_Call) RunAndReturn(run func(context.Context, schema.ServiceDefinition) error) *BootstrapService_AppendSchema_Call

type BootstrapService_Expecter

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

func (*BootstrapService_Expecter) AppendSchema

func (_e *BootstrapService_Expecter) AppendSchema(ctx interface{}, definition interface{}) *BootstrapService_AppendSchema_Call

AppendSchema is a helper method to define mock.On call

• ctx context.Context
• definition schema.ServiceDefinition

type CascadeDeleter

type CascadeDeleter struct {
	mock.Mock
}

CascadeDeleter is an autogenerated mock type for the CascadeDeleter type

func NewCascadeDeleter

func NewCascadeDeleter(t mockConstructorTestingTNewCascadeDeleter) *CascadeDeleter

NewCascadeDeleter creates a new instance of CascadeDeleter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*CascadeDeleter) DeleteOrganization

func (_m *CascadeDeleter) DeleteOrganization(ctx context.Context, id string) error

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

func (*CascadeDeleter) DeleteProject

func (_m *CascadeDeleter) DeleteProject(ctx context.Context, id string) error

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

func (*CascadeDeleter) EXPECT

func (_m *CascadeDeleter) EXPECT() *CascadeDeleter_Expecter

type CascadeDeleter_DeleteOrganization_Call

type CascadeDeleter_DeleteOrganization_Call struct {
	*mock.Call
}

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

func (*CascadeDeleter_DeleteOrganization_Call) Return

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

func (*CascadeDeleter_DeleteOrganization_Call) Run

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

func (*CascadeDeleter_DeleteOrganization_Call) RunAndReturn

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

type CascadeDeleter_DeleteProject_Call

type CascadeDeleter_DeleteProject_Call struct {
	*mock.Call
}

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

func (*CascadeDeleter_DeleteProject_Call) Return

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

func (*CascadeDeleter_DeleteProject_Call) Run

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

func (*CascadeDeleter_DeleteProject_Call) RunAndReturn

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

type CascadeDeleter_Expecter

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

func (*CascadeDeleter_Expecter) DeleteOrganization

func (_e *CascadeDeleter_Expecter) DeleteOrganization(ctx interface{}, id interface{}) *CascadeDeleter_DeleteOrganization_Call

DeleteOrganization is a helper method to define mock.On call

• ctx context.Context
• id string

func (*CascadeDeleter_Expecter) DeleteProject

func (_e *CascadeDeleter_Expecter) DeleteProject(ctx interface{}, id interface{}) *CascadeDeleter_DeleteProject_Call

DeleteProject is a helper method to define mock.On call

• ctx context.Context
• id string

type GroupService

type GroupService struct {
	mock.Mock
}

GroupService is an autogenerated mock type for the GroupService type

func NewGroupService

func NewGroupService(t mockConstructorTestingTNewGroupService) *GroupService

NewGroupService creates a new instance of GroupService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*GroupService) AddUsers

func (_m *GroupService) AddUsers(ctx context.Context, groupID string, userID []string) error

AddUsers provides a mock function with given fields: ctx, groupID, userID

func (*GroupService) Create

func (_m *GroupService) Create(ctx context.Context, grp group.Group) (group.Group, error)

Create provides a mock function with given fields: ctx, grp

func (*GroupService) Delete

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

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

func (*GroupService) Disable

func (_m *GroupService) Disable(ctx context.Context, id string) error

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

func (*GroupService) EXPECT

func (_m *GroupService) EXPECT() *GroupService_Expecter

func (*GroupService) Enable

func (_m *GroupService) Enable(ctx context.Context, id string) error

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

func (*GroupService) Get

func (_m *GroupService) Get(ctx context.Context, id string) (group.Group, error)

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

func (*GroupService) List

func (_m *GroupService) List(ctx context.Context, flt group.Filter) ([]group.Group, error)

List provides a mock function with given fields: ctx, flt

func (*GroupService) ListByUser

func (_m *GroupService) ListByUser(ctx context.Context, userId string, flt group.Filter) ([]group.Group, error)

ListByUser provides a mock function with given fields: ctx, userId, flt

func (*GroupService) RemoveUsers

func (_m *GroupService) RemoveUsers(ctx context.Context, groupID string, userID []string) error

RemoveUsers provides a mock function with given fields: ctx, groupID, userID

func (*GroupService) Update

func (_m *GroupService) Update(ctx context.Context, grp group.Group) (group.Group, error)

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

type GroupService_AddUsers_Call

type GroupService_AddUsers_Call struct {
	*mock.Call
}

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

func (*GroupService_AddUsers_Call) Return

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

func (*GroupService_AddUsers_Call) Run

func (_c *GroupService_AddUsers_Call) Run(run func(ctx context.Context, groupID string, userID []string)) *GroupService_AddUsers_Call

func (*GroupService_AddUsers_Call) RunAndReturn

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

type GroupService_Create_Call

type GroupService_Create_Call struct {
	*mock.Call
}

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

func (*GroupService_Create_Call) Return

func (_c *GroupService_Create_Call) Return(_a0 group.Group, _a1 error) *GroupService_Create_Call

func (*GroupService_Create_Call) Run

func (_c *GroupService_Create_Call) Run(run func(ctx context.Context, grp group.Group)) *GroupService_Create_Call

func (*GroupService_Create_Call) RunAndReturn

func (_c *GroupService_Create_Call) RunAndReturn(run func(context.Context, group.Group) (group.Group, error)) *GroupService_Create_Call

type GroupService_Delete_Call

type GroupService_Delete_Call struct {
	*mock.Call
}

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

func (*GroupService_Delete_Call) Return

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

func (*GroupService_Delete_Call) Run

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

func (*GroupService_Delete_Call) RunAndReturn

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

type GroupService_Disable_Call

type GroupService_Disable_Call struct {
	*mock.Call
}

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

func (*GroupService_Disable_Call) Return

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

func (*GroupService_Disable_Call) Run

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

func (*GroupService_Disable_Call) RunAndReturn

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

type GroupService_Enable_Call

type GroupService_Enable_Call struct {
	*mock.Call
}

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

func (*GroupService_Enable_Call) Return

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

func (*GroupService_Enable_Call) Run

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

func (*GroupService_Enable_Call) RunAndReturn

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

type GroupService_Expecter

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

func (*GroupService_Expecter) AddUsers

func (_e *GroupService_Expecter) AddUsers(ctx interface{}, groupID interface{}, userID interface{}) *GroupService_AddUsers_Call

AddUsers is a helper method to define mock.On call

• ctx context.Context
• groupID string
• userID []string

func (*GroupService_Expecter) Create

func (_e *GroupService_Expecter) Create(ctx interface{}, grp interface{}) *GroupService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• grp group.Group

func (*GroupService_Expecter) Delete

func (_e *GroupService_Expecter) Delete(ctx interface{}, id interface{}) *GroupService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id string

func (*GroupService_Expecter) Disable

func (_e *GroupService_Expecter) Disable(ctx interface{}, id interface{}) *GroupService_Disable_Call

Disable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*GroupService_Expecter) Enable

func (_e *GroupService_Expecter) Enable(ctx interface{}, id interface{}) *GroupService_Enable_Call

Enable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*GroupService_Expecter) Get

func (_e *GroupService_Expecter) Get(ctx interface{}, id interface{}) *GroupService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*GroupService_Expecter) List

func (_e *GroupService_Expecter) List(ctx interface{}, flt interface{}) *GroupService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• flt group.Filter

func (*GroupService_Expecter) ListByUser

func (_e *GroupService_Expecter) ListByUser(ctx interface{}, userId interface{}, flt interface{}) *GroupService_ListByUser_Call

ListByUser is a helper method to define mock.On call

• ctx context.Context
• userId string
• flt group.Filter

func (*GroupService_Expecter) RemoveUsers

func (_e *GroupService_Expecter) RemoveUsers(ctx interface{}, groupID interface{}, userID interface{}) *GroupService_RemoveUsers_Call

RemoveUsers is a helper method to define mock.On call

• ctx context.Context
• groupID string
• userID []string

func (*GroupService_Expecter) Update

func (_e *GroupService_Expecter) Update(ctx interface{}, grp interface{}) *GroupService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• grp group.Group

type GroupService_Get_Call

type GroupService_Get_Call struct {
	*mock.Call
}

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

func (*GroupService_Get_Call) Return

func (_c *GroupService_Get_Call) Return(_a0 group.Group, _a1 error) *GroupService_Get_Call

func (*GroupService_Get_Call) Run

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

func (*GroupService_Get_Call) RunAndReturn

func (_c *GroupService_Get_Call) RunAndReturn(run func(context.Context, string) (group.Group, error)) *GroupService_Get_Call

type GroupService_ListByUser_Call

type GroupService_ListByUser_Call struct {
	*mock.Call
}

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

func (*GroupService_ListByUser_Call) Return

func (_c *GroupService_ListByUser_Call) Return(_a0 []group.Group, _a1 error) *GroupService_ListByUser_Call

func (*GroupService_ListByUser_Call) Run

func (_c *GroupService_ListByUser_Call) Run(run func(ctx context.Context, userId string, flt group.Filter)) *GroupService_ListByUser_Call

func (*GroupService_ListByUser_Call) RunAndReturn

func (_c *GroupService_ListByUser_Call) RunAndReturn(run func(context.Context, string, group.Filter) ([]group.Group, error)) *GroupService_ListByUser_Call

type GroupService_List_Call

type GroupService_List_Call struct {
	*mock.Call
}

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

func (*GroupService_List_Call) Return

func (_c *GroupService_List_Call) Return(_a0 []group.Group, _a1 error) *GroupService_List_Call

func (*GroupService_List_Call) Run

func (_c *GroupService_List_Call) Run(run func(ctx context.Context, flt group.Filter)) *GroupService_List_Call

func (*GroupService_List_Call) RunAndReturn

func (_c *GroupService_List_Call) RunAndReturn(run func(context.Context, group.Filter) ([]group.Group, error)) *GroupService_List_Call

type GroupService_RemoveUsers_Call

type GroupService_RemoveUsers_Call struct {
	*mock.Call
}

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

func (*GroupService_RemoveUsers_Call) Return

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

func (*GroupService_RemoveUsers_Call) Run

func (_c *GroupService_RemoveUsers_Call) Run(run func(ctx context.Context, groupID string, userID []string)) *GroupService_RemoveUsers_Call

func (*GroupService_RemoveUsers_Call) RunAndReturn

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

type GroupService_Update_Call

type GroupService_Update_Call struct {
	*mock.Call
}

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

func (*GroupService_Update_Call) Return

func (_c *GroupService_Update_Call) Return(_a0 group.Group, _a1 error) *GroupService_Update_Call

func (*GroupService_Update_Call) Run

func (_c *GroupService_Update_Call) Run(run func(ctx context.Context, grp group.Group)) *GroupService_Update_Call

func (*GroupService_Update_Call) RunAndReturn

func (_c *GroupService_Update_Call) RunAndReturn(run func(context.Context, group.Group) (group.Group, error)) *GroupService_Update_Call

type InvitationService

type InvitationService struct {
	mock.Mock
}

InvitationService is an autogenerated mock type for the InvitationService type

func NewInvitationService

func NewInvitationService(t mockConstructorTestingTNewInvitationService) *InvitationService

NewInvitationService creates a new instance of InvitationService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*InvitationService) Accept

func (_m *InvitationService) Accept(ctx context.Context, id uuid.UUID) error

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

func (*InvitationService) Create

func (_m *InvitationService) Create(ctx context.Context, inv invitation.Invitation) (invitation.Invitation, error)

Create provides a mock function with given fields: ctx, inv

func (*InvitationService) Delete

func (_m *InvitationService) Delete(ctx context.Context, id uuid.UUID) error

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

func (*InvitationService) EXPECT

func (_m *InvitationService) EXPECT() *InvitationService_Expecter

func (*InvitationService) Get

func (_m *InvitationService) Get(ctx context.Context, id uuid.UUID) (invitation.Invitation, error)

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

func (*InvitationService) List

func (_m *InvitationService) List(ctx context.Context, filter invitation.Filter) ([]invitation.Invitation, error)

List provides a mock function with given fields: ctx, filter

func (*InvitationService) ListByUser

func (_m *InvitationService) ListByUser(ctx context.Context, userID string) ([]invitation.Invitation, error)

ListByUser provides a mock function with given fields: ctx, userID

type InvitationService_Accept_Call

type InvitationService_Accept_Call struct {
	*mock.Call
}

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

func (*InvitationService_Accept_Call) Return

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

func (*InvitationService_Accept_Call) Run

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

func (*InvitationService_Accept_Call) RunAndReturn

func (_c *InvitationService_Accept_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *InvitationService_Accept_Call

type InvitationService_Create_Call

type InvitationService_Create_Call struct {
	*mock.Call
}

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

func (*InvitationService_Create_Call) Return

func (_c *InvitationService_Create_Call) Return(_a0 invitation.Invitation, _a1 error) *InvitationService_Create_Call

func (*InvitationService_Create_Call) Run

func (_c *InvitationService_Create_Call) Run(run func(ctx context.Context, inv invitation.Invitation)) *InvitationService_Create_Call

func (*InvitationService_Create_Call) RunAndReturn

func (_c *InvitationService_Create_Call) RunAndReturn(run func(context.Context, invitation.Invitation) (invitation.Invitation, error)) *InvitationService_Create_Call

type InvitationService_Delete_Call

type InvitationService_Delete_Call struct {
	*mock.Call
}

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

func (*InvitationService_Delete_Call) Return

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

func (*InvitationService_Delete_Call) Run

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

func (*InvitationService_Delete_Call) RunAndReturn

func (_c *InvitationService_Delete_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *InvitationService_Delete_Call

type InvitationService_Expecter

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

func (*InvitationService_Expecter) Accept

func (_e *InvitationService_Expecter) Accept(ctx interface{}, id interface{}) *InvitationService_Accept_Call

Accept is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*InvitationService_Expecter) Create

func (_e *InvitationService_Expecter) Create(ctx interface{}, inv interface{}) *InvitationService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• inv invitation.Invitation

func (*InvitationService_Expecter) Delete

func (_e *InvitationService_Expecter) Delete(ctx interface{}, id interface{}) *InvitationService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*InvitationService_Expecter) Get

func (_e *InvitationService_Expecter) Get(ctx interface{}, id interface{}) *InvitationService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id uuid.UUID

func (*InvitationService_Expecter) List

func (_e *InvitationService_Expecter) List(ctx interface{}, filter interface{}) *InvitationService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• filter invitation.Filter

func (*InvitationService_Expecter) ListByUser

func (_e *InvitationService_Expecter) ListByUser(ctx interface{}, userID interface{}) *InvitationService_ListByUser_Call

ListByUser is a helper method to define mock.On call

• ctx context.Context
• userID string

type InvitationService_Get_Call

type InvitationService_Get_Call struct {
	*mock.Call
}

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

func (*InvitationService_Get_Call) Return

func (_c *InvitationService_Get_Call) Return(_a0 invitation.Invitation, _a1 error) *InvitationService_Get_Call

func (*InvitationService_Get_Call) Run

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

func (*InvitationService_Get_Call) RunAndReturn

func (_c *InvitationService_Get_Call) RunAndReturn(run func(context.Context, uuid.UUID) (invitation.Invitation, error)) *InvitationService_Get_Call

type InvitationService_ListByUser_Call

type InvitationService_ListByUser_Call struct {
	*mock.Call
}

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

func (*InvitationService_ListByUser_Call) Return

func (_c *InvitationService_ListByUser_Call) Return(_a0 []invitation.Invitation, _a1 error) *InvitationService_ListByUser_Call

func (*InvitationService_ListByUser_Call) Run

func (_c *InvitationService_ListByUser_Call) Run(run func(ctx context.Context, userID string)) *InvitationService_ListByUser_Call

func (*InvitationService_ListByUser_Call) RunAndReturn

func (_c *InvitationService_ListByUser_Call) RunAndReturn(run func(context.Context, string) ([]invitation.Invitation, error)) *InvitationService_ListByUser_Call

type InvitationService_List_Call

type InvitationService_List_Call struct {
	*mock.Call
}

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

func (*InvitationService_List_Call) Return

func (_c *InvitationService_List_Call) Return(_a0 []invitation.Invitation, _a1 error) *InvitationService_List_Call

func (*InvitationService_List_Call) Run

func (_c *InvitationService_List_Call) Run(run func(ctx context.Context, filter invitation.Filter)) *InvitationService_List_Call

func (*InvitationService_List_Call) RunAndReturn

func (_c *InvitationService_List_Call) RunAndReturn(run func(context.Context, invitation.Filter) ([]invitation.Invitation, error)) *InvitationService_List_Call

type MetaSchemaService

type MetaSchemaService struct {
	mock.Mock
}

MetaSchemaService is an autogenerated mock type for the MetaSchemaService type

func NewMetaSchemaService

func NewMetaSchemaService(t mockConstructorTestingTNewMetaSchemaService) *MetaSchemaService

NewMetaSchemaService creates a new instance of MetaSchemaService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*MetaSchemaService) Create

func (_m *MetaSchemaService) Create(ctx context.Context, toCreate metaschema.MetaSchema) (metaschema.MetaSchema, error)

Create provides a mock function with given fields: ctx, toCreate

func (*MetaSchemaService) Delete

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

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

func (*MetaSchemaService) EXPECT

func (_m *MetaSchemaService) EXPECT() *MetaSchemaService_Expecter

func (*MetaSchemaService) Get

func (_m *MetaSchemaService) Get(ctx context.Context, id string) (metaschema.MetaSchema, error)

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

func (*MetaSchemaService) List

func (_m *MetaSchemaService) List(ctx context.Context) ([]metaschema.MetaSchema, error)

List provides a mock function with given fields: ctx

func (*MetaSchemaService) Update

func (_m *MetaSchemaService) Update(ctx context.Context, id string, toUpdate metaschema.MetaSchema) (metaschema.MetaSchema, error)

Update provides a mock function with given fields: ctx, id, toUpdate

func (*MetaSchemaService) Validate

func (_m *MetaSchemaService) Validate(schema metadata.Metadata, data string) error

Validate provides a mock function with given fields: schema, data

type MetaSchemaService_Create_Call

type MetaSchemaService_Create_Call struct {
	*mock.Call
}

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

func (*MetaSchemaService_Create_Call) Return

func (_c *MetaSchemaService_Create_Call) Return(_a0 metaschema.MetaSchema, _a1 error) *MetaSchemaService_Create_Call

func (*MetaSchemaService_Create_Call) Run

func (_c *MetaSchemaService_Create_Call) Run(run func(ctx context.Context, toCreate metaschema.MetaSchema)) *MetaSchemaService_Create_Call

func (*MetaSchemaService_Create_Call) RunAndReturn

func (_c *MetaSchemaService_Create_Call) RunAndReturn(run func(context.Context, metaschema.MetaSchema) (metaschema.MetaSchema, error)) *MetaSchemaService_Create_Call

type MetaSchemaService_Delete_Call

type MetaSchemaService_Delete_Call struct {
	*mock.Call
}

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

func (*MetaSchemaService_Delete_Call) Return

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

func (*MetaSchemaService_Delete_Call) Run

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

func (*MetaSchemaService_Delete_Call) RunAndReturn

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

type MetaSchemaService_Expecter

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

func (*MetaSchemaService_Expecter) Create

func (_e *MetaSchemaService_Expecter) Create(ctx interface{}, toCreate interface{}) *MetaSchemaService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• toCreate metaschema.MetaSchema

func (*MetaSchemaService_Expecter) Delete

func (_e *MetaSchemaService_Expecter) Delete(ctx interface{}, id interface{}) *MetaSchemaService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id string

func (*MetaSchemaService_Expecter) Get

func (_e *MetaSchemaService_Expecter) Get(ctx interface{}, id interface{}) *MetaSchemaService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*MetaSchemaService_Expecter) List

func (_e *MetaSchemaService_Expecter) List(ctx interface{}) *MetaSchemaService_List_Call

List is a helper method to define mock.On call

• ctx context.Context

func (*MetaSchemaService_Expecter) Update

func (_e *MetaSchemaService_Expecter) Update(ctx interface{}, id interface{}, toUpdate interface{}) *MetaSchemaService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• id string
• toUpdate metaschema.MetaSchema

func (*MetaSchemaService_Expecter) Validate

func (_e *MetaSchemaService_Expecter) Validate(schema interface{}, data interface{}) *MetaSchemaService_Validate_Call

Validate is a helper method to define mock.On call

• schema metadata.Metadata
• data string

type MetaSchemaService_Get_Call

type MetaSchemaService_Get_Call struct {
	*mock.Call
}

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

func (*MetaSchemaService_Get_Call) Return

func (_c *MetaSchemaService_Get_Call) Return(_a0 metaschema.MetaSchema, _a1 error) *MetaSchemaService_Get_Call

func (*MetaSchemaService_Get_Call) Run

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

func (*MetaSchemaService_Get_Call) RunAndReturn

func (_c *MetaSchemaService_Get_Call) RunAndReturn(run func(context.Context, string) (metaschema.MetaSchema, error)) *MetaSchemaService_Get_Call

type MetaSchemaService_List_Call

type MetaSchemaService_List_Call struct {
	*mock.Call
}

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

func (*MetaSchemaService_List_Call) Return

func (_c *MetaSchemaService_List_Call) Return(_a0 []metaschema.MetaSchema, _a1 error) *MetaSchemaService_List_Call

func (*MetaSchemaService_List_Call) Run

func (_c *MetaSchemaService_List_Call) Run(run func(ctx context.Context)) *MetaSchemaService_List_Call

func (*MetaSchemaService_List_Call) RunAndReturn

func (_c *MetaSchemaService_List_Call) RunAndReturn(run func(context.Context) ([]metaschema.MetaSchema, error)) *MetaSchemaService_List_Call

type MetaSchemaService_Update_Call

type MetaSchemaService_Update_Call struct {
	*mock.Call
}

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

func (*MetaSchemaService_Update_Call) Return

func (_c *MetaSchemaService_Update_Call) Return(_a0 metaschema.MetaSchema, _a1 error) *MetaSchemaService_Update_Call

func (*MetaSchemaService_Update_Call) Run

func (_c *MetaSchemaService_Update_Call) Run(run func(ctx context.Context, id string, toUpdate metaschema.MetaSchema)) *MetaSchemaService_Update_Call

func (*MetaSchemaService_Update_Call) RunAndReturn

func (_c *MetaSchemaService_Update_Call) RunAndReturn(run func(context.Context, string, metaschema.MetaSchema) (metaschema.MetaSchema, error)) *MetaSchemaService_Update_Call

type MetaSchemaService_Validate_Call

type MetaSchemaService_Validate_Call struct {
	*mock.Call
}

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

func (*MetaSchemaService_Validate_Call) Return

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

func (*MetaSchemaService_Validate_Call) Run

func (_c *MetaSchemaService_Validate_Call) Run(run func(schema metadata.Metadata, data string)) *MetaSchemaService_Validate_Call

func (*MetaSchemaService_Validate_Call) RunAndReturn

func (_c *MetaSchemaService_Validate_Call) RunAndReturn(run func(metadata.Metadata, string) error) *MetaSchemaService_Validate_Call

type NamespaceService

type NamespaceService struct {
	mock.Mock
}

NamespaceService is an autogenerated mock type for the NamespaceService type

func NewNamespaceService

func NewNamespaceService(t mockConstructorTestingTNewNamespaceService) *NamespaceService

NewNamespaceService creates a new instance of NamespaceService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*NamespaceService) EXPECT

func (_m *NamespaceService) EXPECT() *NamespaceService_Expecter

func (*NamespaceService) Get

func (_m *NamespaceService) Get(ctx context.Context, id string) (namespace.Namespace, error)

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

func (*NamespaceService) List

func (_m *NamespaceService) List(ctx context.Context) ([]namespace.Namespace, error)

List provides a mock function with given fields: ctx

func (*NamespaceService) Update

func (_m *NamespaceService) Update(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error)

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

func (*NamespaceService) Upsert

func (_m *NamespaceService) Upsert(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error)

Upsert provides a mock function with given fields: ctx, ns

type NamespaceService_Expecter

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

func (*NamespaceService_Expecter) Get

func (_e *NamespaceService_Expecter) Get(ctx interface{}, id interface{}) *NamespaceService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*NamespaceService_Expecter) List

func (_e *NamespaceService_Expecter) List(ctx interface{}) *NamespaceService_List_Call

List is a helper method to define mock.On call

• ctx context.Context

func (*NamespaceService_Expecter) Update

func (_e *NamespaceService_Expecter) Update(ctx interface{}, ns interface{}) *NamespaceService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• ns namespace.Namespace

func (*NamespaceService_Expecter) Upsert

func (_e *NamespaceService_Expecter) Upsert(ctx interface{}, ns interface{}) *NamespaceService_Upsert_Call

Upsert is a helper method to define mock.On call

• ctx context.Context
• ns namespace.Namespace

type NamespaceService_Get_Call

type NamespaceService_Get_Call struct {
	*mock.Call
}

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

func (*NamespaceService_Get_Call) Return

func (_c *NamespaceService_Get_Call) Return(_a0 namespace.Namespace, _a1 error) *NamespaceService_Get_Call

func (*NamespaceService_Get_Call) Run

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

func (*NamespaceService_Get_Call) RunAndReturn

func (_c *NamespaceService_Get_Call) RunAndReturn(run func(context.Context, string) (namespace.Namespace, error)) *NamespaceService_Get_Call

type NamespaceService_List_Call

type NamespaceService_List_Call struct {
	*mock.Call
}

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

func (*NamespaceService_List_Call) Return

func (_c *NamespaceService_List_Call) Return(_a0 []namespace.Namespace, _a1 error) *NamespaceService_List_Call

func (*NamespaceService_List_Call) Run

func (_c *NamespaceService_List_Call) Run(run func(ctx context.Context)) *NamespaceService_List_Call

func (*NamespaceService_List_Call) RunAndReturn

func (_c *NamespaceService_List_Call) RunAndReturn(run func(context.Context) ([]namespace.Namespace, error)) *NamespaceService_List_Call

type NamespaceService_Update_Call

type NamespaceService_Update_Call struct {
	*mock.Call
}

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

func (*NamespaceService_Update_Call) Return

func (_c *NamespaceService_Update_Call) Return(_a0 namespace.Namespace, _a1 error) *NamespaceService_Update_Call

func (*NamespaceService_Update_Call) Run

func (_c *NamespaceService_Update_Call) Run(run func(ctx context.Context, ns namespace.Namespace)) *NamespaceService_Update_Call

func (*NamespaceService_Update_Call) RunAndReturn

func (_c *NamespaceService_Update_Call) RunAndReturn(run func(context.Context, namespace.Namespace) (namespace.Namespace, error)) *NamespaceService_Update_Call

type NamespaceService_Upsert_Call

type NamespaceService_Upsert_Call struct {
	*mock.Call
}

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

func (*NamespaceService_Upsert_Call) Return

func (_c *NamespaceService_Upsert_Call) Return(_a0 namespace.Namespace, _a1 error) *NamespaceService_Upsert_Call

func (*NamespaceService_Upsert_Call) Run

func (_c *NamespaceService_Upsert_Call) Run(run func(ctx context.Context, ns namespace.Namespace)) *NamespaceService_Upsert_Call

func (*NamespaceService_Upsert_Call) RunAndReturn

func (_c *NamespaceService_Upsert_Call) RunAndReturn(run func(context.Context, namespace.Namespace) (namespace.Namespace, error)) *NamespaceService_Upsert_Call

type OrganizationService

type OrganizationService struct {
	mock.Mock
}

OrganizationService is an autogenerated mock type for the OrganizationService type

func NewOrganizationService

func NewOrganizationService(t mockConstructorTestingTNewOrganizationService) *OrganizationService

NewOrganizationService creates a new instance of OrganizationService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*OrganizationService) AddUsers

func (_m *OrganizationService) AddUsers(ctx context.Context, orgID string, userID []string) error

AddUsers provides a mock function with given fields: ctx, orgID, userID

func (*OrganizationService) Create

func (_m *OrganizationService) Create(ctx context.Context, org organization.Organization) (organization.Organization, error)

Create provides a mock function with given fields: ctx, org

func (*OrganizationService) Disable

func (_m *OrganizationService) Disable(ctx context.Context, id string) error

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

func (*OrganizationService) EXPECT

func (_m *OrganizationService) EXPECT() *OrganizationService_Expecter

func (*OrganizationService) Enable

func (_m *OrganizationService) Enable(ctx context.Context, id string) error

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

func (*OrganizationService) Get

func (_m *OrganizationService) Get(ctx context.Context, idOrSlug string) (organization.Organization, error)

Get provides a mock function with given fields: ctx, idOrSlug

func (*OrganizationService) List

func (_m *OrganizationService) List(ctx context.Context, f organization.Filter) ([]organization.Organization, error)

List provides a mock function with given fields: ctx, f

func (*OrganizationService) ListByUser

func (_m *OrganizationService) ListByUser(ctx context.Context, userID string) ([]organization.Organization, error)

ListByUser provides a mock function with given fields: ctx, userID

func (*OrganizationService) RemoveUsers

func (_m *OrganizationService) RemoveUsers(ctx context.Context, orgID string, userID []string) error

RemoveUsers provides a mock function with given fields: ctx, orgID, userID

func (*OrganizationService) Update

func (_m *OrganizationService) Update(ctx context.Context, toUpdate organization.Organization) (organization.Organization, error)

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

type OrganizationService_AddUsers_Call

type OrganizationService_AddUsers_Call struct {
	*mock.Call
}

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

func (*OrganizationService_AddUsers_Call) Return

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

func (*OrganizationService_AddUsers_Call) Run

func (_c *OrganizationService_AddUsers_Call) Run(run func(ctx context.Context, orgID string, userID []string)) *OrganizationService_AddUsers_Call

func (*OrganizationService_AddUsers_Call) RunAndReturn

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

type OrganizationService_Create_Call

type OrganizationService_Create_Call struct {
	*mock.Call
}

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

func (*OrganizationService_Create_Call) Return

func (_c *OrganizationService_Create_Call) Return(_a0 organization.Organization, _a1 error) *OrganizationService_Create_Call

func (*OrganizationService_Create_Call) Run

func (_c *OrganizationService_Create_Call) Run(run func(ctx context.Context, org organization.Organization)) *OrganizationService_Create_Call

func (*OrganizationService_Create_Call) RunAndReturn

func (_c *OrganizationService_Create_Call) RunAndReturn(run func(context.Context, organization.Organization) (organization.Organization, error)) *OrganizationService_Create_Call

type OrganizationService_Disable_Call

type OrganizationService_Disable_Call struct {
	*mock.Call
}

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

func (*OrganizationService_Disable_Call) Return

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

func (*OrganizationService_Disable_Call) Run

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

func (*OrganizationService_Disable_Call) RunAndReturn

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

type OrganizationService_Enable_Call

type OrganizationService_Enable_Call struct {
	*mock.Call
}

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

func (*OrganizationService_Enable_Call) Return

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

func (*OrganizationService_Enable_Call) Run

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

func (*OrganizationService_Enable_Call) RunAndReturn

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

type OrganizationService_Expecter

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

func (*OrganizationService_Expecter) AddUsers

func (_e *OrganizationService_Expecter) AddUsers(ctx interface{}, orgID interface{}, userID interface{}) *OrganizationService_AddUsers_Call

AddUsers is a helper method to define mock.On call

• ctx context.Context
• orgID string
• userID []string

func (*OrganizationService_Expecter) Create

func (_e *OrganizationService_Expecter) Create(ctx interface{}, org interface{}) *OrganizationService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• org organization.Organization

func (*OrganizationService_Expecter) Disable

func (_e *OrganizationService_Expecter) Disable(ctx interface{}, id interface{}) *OrganizationService_Disable_Call

Disable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*OrganizationService_Expecter) Enable

func (_e *OrganizationService_Expecter) Enable(ctx interface{}, id interface{}) *OrganizationService_Enable_Call

Enable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*OrganizationService_Expecter) Get

func (_e *OrganizationService_Expecter) Get(ctx interface{}, idOrSlug interface{}) *OrganizationService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• idOrSlug string

func (*OrganizationService_Expecter) List

func (_e *OrganizationService_Expecter) List(ctx interface{}, f interface{}) *OrganizationService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• f organization.Filter

func (*OrganizationService_Expecter) ListByUser

func (_e *OrganizationService_Expecter) ListByUser(ctx interface{}, userID interface{}) *OrganizationService_ListByUser_Call

ListByUser is a helper method to define mock.On call

• ctx context.Context
• userID string

func (*OrganizationService_Expecter) RemoveUsers

func (_e *OrganizationService_Expecter) RemoveUsers(ctx interface{}, orgID interface{}, userID interface{}) *OrganizationService_RemoveUsers_Call

RemoveUsers is a helper method to define mock.On call

• ctx context.Context
• orgID string
• userID []string

func (*OrganizationService_Expecter) Update

func (_e *OrganizationService_Expecter) Update(ctx interface{}, toUpdate interface{}) *OrganizationService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• toUpdate organization.Organization

type OrganizationService_Get_Call

type OrganizationService_Get_Call struct {
	*mock.Call
}

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

func (*OrganizationService_Get_Call) Return

func (_c *OrganizationService_Get_Call) Return(_a0 organization.Organization, _a1 error) *OrganizationService_Get_Call

func (*OrganizationService_Get_Call) Run

func (_c *OrganizationService_Get_Call) Run(run func(ctx context.Context, idOrSlug string)) *OrganizationService_Get_Call

func (*OrganizationService_Get_Call) RunAndReturn

func (_c *OrganizationService_Get_Call) RunAndReturn(run func(context.Context, string) (organization.Organization, error)) *OrganizationService_Get_Call

type OrganizationService_ListByUser_Call

type OrganizationService_ListByUser_Call struct {
	*mock.Call
}

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

func (*OrganizationService_ListByUser_Call) Return

func (_c *OrganizationService_ListByUser_Call) Return(_a0 []organization.Organization, _a1 error) *OrganizationService_ListByUser_Call

func (*OrganizationService_ListByUser_Call) Run

func (_c *OrganizationService_ListByUser_Call) Run(run func(ctx context.Context, userID string)) *OrganizationService_ListByUser_Call

func (*OrganizationService_ListByUser_Call) RunAndReturn

func (_c *OrganizationService_ListByUser_Call) RunAndReturn(run func(context.Context, string) ([]organization.Organization, error)) *OrganizationService_ListByUser_Call

type OrganizationService_List_Call

type OrganizationService_List_Call struct {
	*mock.Call
}

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

func (*OrganizationService_List_Call) Return

func (_c *OrganizationService_List_Call) Return(_a0 []organization.Organization, _a1 error) *OrganizationService_List_Call

func (*OrganizationService_List_Call) Run

func (_c *OrganizationService_List_Call) Run(run func(ctx context.Context, f organization.Filter)) *OrganizationService_List_Call

func (*OrganizationService_List_Call) RunAndReturn

func (_c *OrganizationService_List_Call) RunAndReturn(run func(context.Context, organization.Filter) ([]organization.Organization, error)) *OrganizationService_List_Call

type OrganizationService_RemoveUsers_Call

type OrganizationService_RemoveUsers_Call struct {
	*mock.Call
}

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

func (*OrganizationService_RemoveUsers_Call) Return

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

func (*OrganizationService_RemoveUsers_Call) Run

func (_c *OrganizationService_RemoveUsers_Call) Run(run func(ctx context.Context, orgID string, userID []string)) *OrganizationService_RemoveUsers_Call

func (*OrganizationService_RemoveUsers_Call) RunAndReturn

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

type OrganizationService_Update_Call

type OrganizationService_Update_Call struct {
	*mock.Call
}

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

func (*OrganizationService_Update_Call) Return

func (_c *OrganizationService_Update_Call) Return(_a0 organization.Organization, _a1 error) *OrganizationService_Update_Call

func (*OrganizationService_Update_Call) Run

func (_c *OrganizationService_Update_Call) Run(run func(ctx context.Context, toUpdate organization.Organization)) *OrganizationService_Update_Call

func (*OrganizationService_Update_Call) RunAndReturn

func (_c *OrganizationService_Update_Call) RunAndReturn(run func(context.Context, organization.Organization) (organization.Organization, error)) *OrganizationService_Update_Call

type PermissionService

type PermissionService struct {
	mock.Mock
}

PermissionService is an autogenerated mock type for the PermissionService type

func NewPermissionService

func NewPermissionService(t mockConstructorTestingTNewPermissionService) *PermissionService

NewPermissionService creates a new instance of PermissionService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*PermissionService) EXPECT

func (_m *PermissionService) EXPECT() *PermissionService_Expecter

func (*PermissionService) Get

func (_m *PermissionService) Get(ctx context.Context, id string) (permission.Permission, error)

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

func (*PermissionService) List

func (_m *PermissionService) List(ctx context.Context, filter permission.Filter) ([]permission.Permission, error)

List provides a mock function with given fields: ctx, filter

func (*PermissionService) Update

func (_m *PermissionService) Update(ctx context.Context, perm permission.Permission) (permission.Permission, error)

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

func (*PermissionService) Upsert

func (_m *PermissionService) Upsert(ctx context.Context, perm permission.Permission) (permission.Permission, error)

Upsert provides a mock function with given fields: ctx, perm

type PermissionService_Expecter

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

func (*PermissionService_Expecter) Get

func (_e *PermissionService_Expecter) Get(ctx interface{}, id interface{}) *PermissionService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*PermissionService_Expecter) List

func (_e *PermissionService_Expecter) List(ctx interface{}, filter interface{}) *PermissionService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• filter permission.Filter

func (*PermissionService_Expecter) Update

func (_e *PermissionService_Expecter) Update(ctx interface{}, perm interface{}) *PermissionService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• perm permission.Permission

func (*PermissionService_Expecter) Upsert

func (_e *PermissionService_Expecter) Upsert(ctx interface{}, perm interface{}) *PermissionService_Upsert_Call

Upsert is a helper method to define mock.On call

• ctx context.Context
• perm permission.Permission

type PermissionService_Get_Call

type PermissionService_Get_Call struct {
	*mock.Call
}

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

func (*PermissionService_Get_Call) Return

func (_c *PermissionService_Get_Call) Return(_a0 permission.Permission, _a1 error) *PermissionService_Get_Call

func (*PermissionService_Get_Call) Run

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

func (*PermissionService_Get_Call) RunAndReturn

func (_c *PermissionService_Get_Call) RunAndReturn(run func(context.Context, string) (permission.Permission, error)) *PermissionService_Get_Call

type PermissionService_List_Call

type PermissionService_List_Call struct {
	*mock.Call
}

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

func (*PermissionService_List_Call) Return

func (_c *PermissionService_List_Call) Return(_a0 []permission.Permission, _a1 error) *PermissionService_List_Call

func (*PermissionService_List_Call) Run

func (_c *PermissionService_List_Call) Run(run func(ctx context.Context, filter permission.Filter)) *PermissionService_List_Call

func (*PermissionService_List_Call) RunAndReturn

func (_c *PermissionService_List_Call) RunAndReturn(run func(context.Context, permission.Filter) ([]permission.Permission, error)) *PermissionService_List_Call

type PermissionService_Update_Call

type PermissionService_Update_Call struct {
	*mock.Call
}

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

func (*PermissionService_Update_Call) Return

func (_c *PermissionService_Update_Call) Return(_a0 permission.Permission, _a1 error) *PermissionService_Update_Call

func (*PermissionService_Update_Call) Run

func (_c *PermissionService_Update_Call) Run(run func(ctx context.Context, perm permission.Permission)) *PermissionService_Update_Call

func (*PermissionService_Update_Call) RunAndReturn

func (_c *PermissionService_Update_Call) RunAndReturn(run func(context.Context, permission.Permission) (permission.Permission, error)) *PermissionService_Update_Call

type PermissionService_Upsert_Call

type PermissionService_Upsert_Call struct {
	*mock.Call
}

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

func (*PermissionService_Upsert_Call) Return

func (_c *PermissionService_Upsert_Call) Return(_a0 permission.Permission, _a1 error) *PermissionService_Upsert_Call

func (*PermissionService_Upsert_Call) Run

func (_c *PermissionService_Upsert_Call) Run(run func(ctx context.Context, perm permission.Permission)) *PermissionService_Upsert_Call

func (*PermissionService_Upsert_Call) RunAndReturn

func (_c *PermissionService_Upsert_Call) RunAndReturn(run func(context.Context, permission.Permission) (permission.Permission, error)) *PermissionService_Upsert_Call

type PolicyService

type PolicyService struct {
	mock.Mock
}

PolicyService is an autogenerated mock type for the PolicyService type

func NewPolicyService

func NewPolicyService(t mockConstructorTestingTNewPolicyService) *PolicyService

NewPolicyService creates a new instance of PolicyService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*PolicyService) Create

func (_m *PolicyService) Create(ctx context.Context, pol policy.Policy) (policy.Policy, error)

Create provides a mock function with given fields: ctx, pol

func (*PolicyService) Delete

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

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

func (*PolicyService) EXPECT

func (_m *PolicyService) EXPECT() *PolicyService_Expecter

func (*PolicyService) Get

func (_m *PolicyService) Get(ctx context.Context, id string) (policy.Policy, error)

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

func (*PolicyService) List

func (_m *PolicyService) List(ctx context.Context, f policy.Filter) ([]policy.Policy, error)

List provides a mock function with given fields: ctx, f

type PolicyService_Create_Call

type PolicyService_Create_Call struct {
	*mock.Call
}

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

func (*PolicyService_Create_Call) Return

func (_c *PolicyService_Create_Call) Return(_a0 policy.Policy, _a1 error) *PolicyService_Create_Call

func (*PolicyService_Create_Call) Run

func (_c *PolicyService_Create_Call) Run(run func(ctx context.Context, pol policy.Policy)) *PolicyService_Create_Call

func (*PolicyService_Create_Call) RunAndReturn

func (_c *PolicyService_Create_Call) RunAndReturn(run func(context.Context, policy.Policy) (policy.Policy, error)) *PolicyService_Create_Call

type PolicyService_Delete_Call

type PolicyService_Delete_Call struct {
	*mock.Call
}

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

func (*PolicyService_Delete_Call) Return

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

func (*PolicyService_Delete_Call) Run

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

func (*PolicyService_Delete_Call) RunAndReturn

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

type PolicyService_Expecter

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

func (*PolicyService_Expecter) Create

func (_e *PolicyService_Expecter) Create(ctx interface{}, pol interface{}) *PolicyService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• pol policy.Policy

func (*PolicyService_Expecter) Delete

func (_e *PolicyService_Expecter) Delete(ctx interface{}, id interface{}) *PolicyService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id string

func (*PolicyService_Expecter) Get

func (_e *PolicyService_Expecter) Get(ctx interface{}, id interface{}) *PolicyService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*PolicyService_Expecter) List

func (_e *PolicyService_Expecter) List(ctx interface{}, f interface{}) *PolicyService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• f policy.Filter

type PolicyService_Get_Call

type PolicyService_Get_Call struct {
	*mock.Call
}

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

func (*PolicyService_Get_Call) Return

func (_c *PolicyService_Get_Call) Return(_a0 policy.Policy, _a1 error) *PolicyService_Get_Call

func (*PolicyService_Get_Call) Run

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

func (*PolicyService_Get_Call) RunAndReturn

func (_c *PolicyService_Get_Call) RunAndReturn(run func(context.Context, string) (policy.Policy, error)) *PolicyService_Get_Call

type PolicyService_List_Call

type PolicyService_List_Call struct {
	*mock.Call
}

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

func (*PolicyService_List_Call) Return

func (_c *PolicyService_List_Call) Return(_a0 []policy.Policy, _a1 error) *PolicyService_List_Call

func (*PolicyService_List_Call) Run

func (_c *PolicyService_List_Call) Run(run func(ctx context.Context, f policy.Filter)) *PolicyService_List_Call

func (*PolicyService_List_Call) RunAndReturn

func (_c *PolicyService_List_Call) RunAndReturn(run func(context.Context, policy.Filter) ([]policy.Policy, error)) *PolicyService_List_Call

type ProjectService

type ProjectService struct {
	mock.Mock
}

ProjectService is an autogenerated mock type for the ProjectService type

func NewProjectService

func NewProjectService(t mockConstructorTestingTNewProjectService) *ProjectService

NewProjectService creates a new instance of ProjectService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*ProjectService) Create

func (_m *ProjectService) Create(ctx context.Context, prj project.Project) (project.Project, error)

Create provides a mock function with given fields: ctx, prj

func (*ProjectService) Disable

func (_m *ProjectService) Disable(ctx context.Context, id string) error

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

func (*ProjectService) EXPECT

func (_m *ProjectService) EXPECT() *ProjectService_Expecter

func (*ProjectService) Enable

func (_m *ProjectService) Enable(ctx context.Context, id string) error

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

func (*ProjectService) Get

func (_m *ProjectService) Get(ctx context.Context, idOrName string) (project.Project, error)

Get provides a mock function with given fields: ctx, idOrName

func (*ProjectService) List

func (_m *ProjectService) List(ctx context.Context, f project.Filter) ([]project.Project, error)

List provides a mock function with given fields: ctx, f

func (*ProjectService) ListByUser

func (_m *ProjectService) ListByUser(ctx context.Context, userID string) ([]project.Project, error)

ListByUser provides a mock function with given fields: ctx, userID

func (*ProjectService) ListUsers

func (_m *ProjectService) ListUsers(ctx context.Context, id string, permissionFilter string) ([]user.User, error)

ListUsers provides a mock function with given fields: ctx, id, permissionFilter

func (*ProjectService) Update

func (_m *ProjectService) Update(ctx context.Context, toUpdate project.Project) (project.Project, error)

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

type ProjectService_Create_Call

type ProjectService_Create_Call struct {
	*mock.Call
}

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

func (*ProjectService_Create_Call) Return

func (_c *ProjectService_Create_Call) Return(_a0 project.Project, _a1 error) *ProjectService_Create_Call

func (*ProjectService_Create_Call) Run

func (_c *ProjectService_Create_Call) Run(run func(ctx context.Context, prj project.Project)) *ProjectService_Create_Call

func (*ProjectService_Create_Call) RunAndReturn

func (_c *ProjectService_Create_Call) RunAndReturn(run func(context.Context, project.Project) (project.Project, error)) *ProjectService_Create_Call

type ProjectService_Disable_Call

type ProjectService_Disable_Call struct {
	*mock.Call
}

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

func (*ProjectService_Disable_Call) Return

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

func (*ProjectService_Disable_Call) Run

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

func (*ProjectService_Disable_Call) RunAndReturn

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

type ProjectService_Enable_Call

type ProjectService_Enable_Call struct {
	*mock.Call
}

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

func (*ProjectService_Enable_Call) Return

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

func (*ProjectService_Enable_Call) Run

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

func (*ProjectService_Enable_Call) RunAndReturn

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

type ProjectService_Expecter

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

func (*ProjectService_Expecter) Create

func (_e *ProjectService_Expecter) Create(ctx interface{}, prj interface{}) *ProjectService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• prj project.Project

func (*ProjectService_Expecter) Disable

func (_e *ProjectService_Expecter) Disable(ctx interface{}, id interface{}) *ProjectService_Disable_Call

Disable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*ProjectService_Expecter) Enable

func (_e *ProjectService_Expecter) Enable(ctx interface{}, id interface{}) *ProjectService_Enable_Call

Enable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*ProjectService_Expecter) Get

func (_e *ProjectService_Expecter) Get(ctx interface{}, idOrName interface{}) *ProjectService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• idOrName string

func (*ProjectService_Expecter) List

func (_e *ProjectService_Expecter) List(ctx interface{}, f interface{}) *ProjectService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• f project.Filter

func (*ProjectService_Expecter) ListByUser

func (_e *ProjectService_Expecter) ListByUser(ctx interface{}, userID interface{}) *ProjectService_ListByUser_Call

ListByUser is a helper method to define mock.On call

• ctx context.Context
• userID string

func (*ProjectService_Expecter) ListUsers

func (_e *ProjectService_Expecter) ListUsers(ctx interface{}, id interface{}, permissionFilter interface{}) *ProjectService_ListUsers_Call

ListUsers is a helper method to define mock.On call

• ctx context.Context
• id string
• permissionFilter string

func (*ProjectService_Expecter) Update

func (_e *ProjectService_Expecter) Update(ctx interface{}, toUpdate interface{}) *ProjectService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• toUpdate project.Project

type ProjectService_Get_Call

type ProjectService_Get_Call struct {
	*mock.Call
}

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

func (*ProjectService_Get_Call) Return

func (_c *ProjectService_Get_Call) Return(_a0 project.Project, _a1 error) *ProjectService_Get_Call

func (*ProjectService_Get_Call) Run

func (_c *ProjectService_Get_Call) Run(run func(ctx context.Context, idOrName string)) *ProjectService_Get_Call

func (*ProjectService_Get_Call) RunAndReturn

func (_c *ProjectService_Get_Call) RunAndReturn(run func(context.Context, string) (project.Project, error)) *ProjectService_Get_Call

type ProjectService_ListByUser_Call

type ProjectService_ListByUser_Call struct {
	*mock.Call
}

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

func (*ProjectService_ListByUser_Call) Return

func (_c *ProjectService_ListByUser_Call) Return(_a0 []project.Project, _a1 error) *ProjectService_ListByUser_Call

func (*ProjectService_ListByUser_Call) Run

func (_c *ProjectService_ListByUser_Call) Run(run func(ctx context.Context, userID string)) *ProjectService_ListByUser_Call

func (*ProjectService_ListByUser_Call) RunAndReturn

func (_c *ProjectService_ListByUser_Call) RunAndReturn(run func(context.Context, string) ([]project.Project, error)) *ProjectService_ListByUser_Call

type ProjectService_ListUsers_Call

type ProjectService_ListUsers_Call struct {
	*mock.Call
}

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

func (*ProjectService_ListUsers_Call) Return

func (_c *ProjectService_ListUsers_Call) Return(_a0 []user.User, _a1 error) *ProjectService_ListUsers_Call

func (*ProjectService_ListUsers_Call) Run

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

func (*ProjectService_ListUsers_Call) RunAndReturn

func (_c *ProjectService_ListUsers_Call) RunAndReturn(run func(context.Context, string, string) ([]user.User, error)) *ProjectService_ListUsers_Call

type ProjectService_List_Call

type ProjectService_List_Call struct {
	*mock.Call
}

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

func (*ProjectService_List_Call) Return

func (_c *ProjectService_List_Call) Return(_a0 []project.Project, _a1 error) *ProjectService_List_Call

func (*ProjectService_List_Call) Run

func (_c *ProjectService_List_Call) Run(run func(ctx context.Context, f project.Filter)) *ProjectService_List_Call

func (*ProjectService_List_Call) RunAndReturn

func (_c *ProjectService_List_Call) RunAndReturn(run func(context.Context, project.Filter) ([]project.Project, error)) *ProjectService_List_Call

type ProjectService_Update_Call

type ProjectService_Update_Call struct {
	*mock.Call
}

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

func (*ProjectService_Update_Call) Return

func (_c *ProjectService_Update_Call) Return(_a0 project.Project, _a1 error) *ProjectService_Update_Call

func (*ProjectService_Update_Call) Run

func (_c *ProjectService_Update_Call) Run(run func(ctx context.Context, toUpdate project.Project)) *ProjectService_Update_Call

func (*ProjectService_Update_Call) RunAndReturn

func (_c *ProjectService_Update_Call) RunAndReturn(run func(context.Context, project.Project) (project.Project, error)) *ProjectService_Update_Call

type RelationService

type RelationService struct {
	mock.Mock
}

RelationService is an autogenerated mock type for the RelationService type

func NewRelationService

func NewRelationService(t mockConstructorTestingTNewRelationService) *RelationService

NewRelationService creates a new instance of RelationService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*RelationService) Create

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

Create provides a mock function with given fields: ctx, rel

func (*RelationService) Delete

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

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

func (*RelationService) EXPECT

func (_m *RelationService) EXPECT() *RelationService_Expecter

func (*RelationService) Get

func (_m *RelationService) Get(ctx context.Context, id string) (relation.Relation, error)

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

func (*RelationService) List

func (_m *RelationService) List(ctx context.Context) ([]relation.Relation, error)

List provides a mock function with given fields: ctx

type RelationService_Create_Call

type RelationService_Create_Call struct {
	*mock.Call
}

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

func (*RelationService_Create_Call) Return

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

func (*RelationService_Create_Call) Run

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

func (*RelationService_Create_Call) RunAndReturn

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

type RelationService_Delete_Call

type RelationService_Delete_Call struct {
	*mock.Call
}

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

func (*RelationService_Delete_Call) Return

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

func (*RelationService_Delete_Call) Run

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

func (*RelationService_Delete_Call) RunAndReturn

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

type RelationService_Expecter

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

func (*RelationService_Expecter) Create

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

Create is a helper method to define mock.On call

• ctx context.Context
• rel relation.Relation

func (*RelationService_Expecter) Delete

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

Delete is a helper method to define mock.On call

• ctx context.Context
• rel relation.Relation

func (*RelationService_Expecter) Get

func (_e *RelationService_Expecter) Get(ctx interface{}, id interface{}) *RelationService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*RelationService_Expecter) List

func (_e *RelationService_Expecter) List(ctx interface{}) *RelationService_List_Call

List is a helper method to define mock.On call

• ctx context.Context

type RelationService_Get_Call

type RelationService_Get_Call struct {
	*mock.Call
}

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

func (*RelationService_Get_Call) Return

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

func (*RelationService_Get_Call) Run

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

func (*RelationService_Get_Call) RunAndReturn

func (_c *RelationService_Get_Call) RunAndReturn(run func(context.Context, string) (relation.Relation, error)) *RelationService_Get_Call

type RelationService_List_Call

type RelationService_List_Call struct {
	*mock.Call
}

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

func (*RelationService_List_Call) Return

func (_c *RelationService_List_Call) Return(_a0 []relation.Relation, _a1 error) *RelationService_List_Call

func (*RelationService_List_Call) Run

func (_c *RelationService_List_Call) Run(run func(ctx context.Context)) *RelationService_List_Call

func (*RelationService_List_Call) RunAndReturn

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

type ResourceService

type ResourceService struct {
	mock.Mock
}

ResourceService is an autogenerated mock type for the ResourceService type

func NewResourceService

func NewResourceService(t mockConstructorTestingTNewResourceService) *ResourceService

NewResourceService creates a new instance of ResourceService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*ResourceService) CheckAuthz

func (_m *ResourceService) CheckAuthz(ctx context.Context, rel relation.Object, permissionName string) (bool, error)

CheckAuthz provides a mock function with given fields: ctx, rel, permissionName

func (*ResourceService) Create

func (_m *ResourceService) Create(ctx context.Context, _a1 resource.Resource) (resource.Resource, error)

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

func (*ResourceService) EXPECT

func (_m *ResourceService) EXPECT() *ResourceService_Expecter

func (*ResourceService) Get

func (_m *ResourceService) Get(ctx context.Context, id string) (resource.Resource, error)

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

func (*ResourceService) List

func (_m *ResourceService) List(ctx context.Context, flt resource.Filter) ([]resource.Resource, error)

List provides a mock function with given fields: ctx, flt

func (*ResourceService) Update

func (_m *ResourceService) Update(ctx context.Context, _a1 resource.Resource) (resource.Resource, error)

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

type ResourceService_CheckAuthz_Call

type ResourceService_CheckAuthz_Call struct {
	*mock.Call
}

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

func (*ResourceService_CheckAuthz_Call) Return

func (_c *ResourceService_CheckAuthz_Call) Return(_a0 bool, _a1 error) *ResourceService_CheckAuthz_Call

func (*ResourceService_CheckAuthz_Call) Run

func (_c *ResourceService_CheckAuthz_Call) Run(run func(ctx context.Context, rel relation.Object, permissionName string)) *ResourceService_CheckAuthz_Call

func (*ResourceService_CheckAuthz_Call) RunAndReturn

func (_c *ResourceService_CheckAuthz_Call) RunAndReturn(run func(context.Context, relation.Object, string) (bool, error)) *ResourceService_CheckAuthz_Call

type ResourceService_Create_Call

type ResourceService_Create_Call struct {
	*mock.Call
}

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

func (*ResourceService_Create_Call) Return

func (_c *ResourceService_Create_Call) Return(_a0 resource.Resource, _a1 error) *ResourceService_Create_Call

func (*ResourceService_Create_Call) Run

func (_c *ResourceService_Create_Call) Run(run func(ctx context.Context, _a1 resource.Resource)) *ResourceService_Create_Call

func (*ResourceService_Create_Call) RunAndReturn

func (_c *ResourceService_Create_Call) RunAndReturn(run func(context.Context, resource.Resource) (resource.Resource, error)) *ResourceService_Create_Call

type ResourceService_Expecter

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

func (*ResourceService_Expecter) CheckAuthz

func (_e *ResourceService_Expecter) CheckAuthz(ctx interface{}, rel interface{}, permissionName interface{}) *ResourceService_CheckAuthz_Call

CheckAuthz is a helper method to define mock.On call

• ctx context.Context
• rel relation.Object
• permissionName string

func (*ResourceService_Expecter) Create

func (_e *ResourceService_Expecter) Create(ctx interface{}, _a1 interface{}) *ResourceService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• _a1 resource.Resource

func (*ResourceService_Expecter) Get

func (_e *ResourceService_Expecter) Get(ctx interface{}, id interface{}) *ResourceService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*ResourceService_Expecter) List

func (_e *ResourceService_Expecter) List(ctx interface{}, flt interface{}) *ResourceService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• flt resource.Filter

func (*ResourceService_Expecter) Update

func (_e *ResourceService_Expecter) Update(ctx interface{}, _a1 interface{}) *ResourceService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• _a1 resource.Resource

type ResourceService_Get_Call

type ResourceService_Get_Call struct {
	*mock.Call
}

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

func (*ResourceService_Get_Call) Return

func (_c *ResourceService_Get_Call) Return(_a0 resource.Resource, _a1 error) *ResourceService_Get_Call

func (*ResourceService_Get_Call) Run

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

func (*ResourceService_Get_Call) RunAndReturn

func (_c *ResourceService_Get_Call) RunAndReturn(run func(context.Context, string) (resource.Resource, error)) *ResourceService_Get_Call

type ResourceService_List_Call

type ResourceService_List_Call struct {
	*mock.Call
}

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

func (*ResourceService_List_Call) Return

func (_c *ResourceService_List_Call) Return(_a0 []resource.Resource, _a1 error) *ResourceService_List_Call

func (*ResourceService_List_Call) Run

func (_c *ResourceService_List_Call) Run(run func(ctx context.Context, flt resource.Filter)) *ResourceService_List_Call

func (*ResourceService_List_Call) RunAndReturn

func (_c *ResourceService_List_Call) RunAndReturn(run func(context.Context, resource.Filter) ([]resource.Resource, error)) *ResourceService_List_Call

type ResourceService_Update_Call

type ResourceService_Update_Call struct {
	*mock.Call
}

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

func (*ResourceService_Update_Call) Return

func (_c *ResourceService_Update_Call) Return(_a0 resource.Resource, _a1 error) *ResourceService_Update_Call

func (*ResourceService_Update_Call) Run

func (_c *ResourceService_Update_Call) Run(run func(ctx context.Context, _a1 resource.Resource)) *ResourceService_Update_Call

func (*ResourceService_Update_Call) RunAndReturn

func (_c *ResourceService_Update_Call) RunAndReturn(run func(context.Context, resource.Resource) (resource.Resource, error)) *ResourceService_Update_Call

type RoleService

type RoleService struct {
	mock.Mock
}

RoleService is an autogenerated mock type for the RoleService type

func NewRoleService

func NewRoleService(t mockConstructorTestingTNewRoleService) *RoleService

NewRoleService creates a new instance of RoleService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*RoleService) Delete

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

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

func (*RoleService) EXPECT

func (_m *RoleService) EXPECT() *RoleService_Expecter

func (*RoleService) Get

func (_m *RoleService) Get(ctx context.Context, id string) (role.Role, error)

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

func (*RoleService) List

func (_m *RoleService) List(ctx context.Context, f role.Filter) ([]role.Role, error)

List provides a mock function with given fields: ctx, f

func (*RoleService) Update

func (_m *RoleService) Update(ctx context.Context, toUpdate role.Role) (role.Role, error)

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

func (*RoleService) Upsert

func (_m *RoleService) Upsert(ctx context.Context, toCreate role.Role) (role.Role, error)

Upsert provides a mock function with given fields: ctx, toCreate

type RoleService_Delete_Call

type RoleService_Delete_Call struct {
	*mock.Call
}

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

func (*RoleService_Delete_Call) Return

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

func (*RoleService_Delete_Call) Run

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

func (*RoleService_Delete_Call) RunAndReturn

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

type RoleService_Expecter

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

func (*RoleService_Expecter) Delete

func (_e *RoleService_Expecter) Delete(ctx interface{}, id interface{}) *RoleService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id string

func (*RoleService_Expecter) Get

func (_e *RoleService_Expecter) Get(ctx interface{}, id interface{}) *RoleService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*RoleService_Expecter) List

func (_e *RoleService_Expecter) List(ctx interface{}, f interface{}) *RoleService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• f role.Filter

func (*RoleService_Expecter) Update

func (_e *RoleService_Expecter) Update(ctx interface{}, toUpdate interface{}) *RoleService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• toUpdate role.Role

func (*RoleService_Expecter) Upsert

func (_e *RoleService_Expecter) Upsert(ctx interface{}, toCreate interface{}) *RoleService_Upsert_Call

Upsert is a helper method to define mock.On call

• ctx context.Context
• toCreate role.Role

type RoleService_Get_Call

type RoleService_Get_Call struct {
	*mock.Call
}

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

func (*RoleService_Get_Call) Return

func (_c *RoleService_Get_Call) Return(_a0 role.Role, _a1 error) *RoleService_Get_Call

func (*RoleService_Get_Call) Run

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

func (*RoleService_Get_Call) RunAndReturn

func (_c *RoleService_Get_Call) RunAndReturn(run func(context.Context, string) (role.Role, error)) *RoleService_Get_Call

type RoleService_List_Call

type RoleService_List_Call struct {
	*mock.Call
}

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

func (*RoleService_List_Call) Return

func (_c *RoleService_List_Call) Return(_a0 []role.Role, _a1 error) *RoleService_List_Call

func (*RoleService_List_Call) Run

func (_c *RoleService_List_Call) Run(run func(ctx context.Context, f role.Filter)) *RoleService_List_Call

func (*RoleService_List_Call) RunAndReturn

func (_c *RoleService_List_Call) RunAndReturn(run func(context.Context, role.Filter) ([]role.Role, error)) *RoleService_List_Call

type RoleService_Update_Call

type RoleService_Update_Call struct {
	*mock.Call
}

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

func (*RoleService_Update_Call) Return

func (_c *RoleService_Update_Call) Return(_a0 role.Role, _a1 error) *RoleService_Update_Call

func (*RoleService_Update_Call) Run

func (_c *RoleService_Update_Call) Run(run func(ctx context.Context, toUpdate role.Role)) *RoleService_Update_Call

func (*RoleService_Update_Call) RunAndReturn

func (_c *RoleService_Update_Call) RunAndReturn(run func(context.Context, role.Role) (role.Role, error)) *RoleService_Update_Call

type RoleService_Upsert_Call

type RoleService_Upsert_Call struct {
	*mock.Call
}

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

func (*RoleService_Upsert_Call) Return

func (_c *RoleService_Upsert_Call) Return(_a0 role.Role, _a1 error) *RoleService_Upsert_Call

func (*RoleService_Upsert_Call) Run

func (_c *RoleService_Upsert_Call) Run(run func(ctx context.Context, toCreate role.Role)) *RoleService_Upsert_Call

func (*RoleService_Upsert_Call) RunAndReturn

func (_c *RoleService_Upsert_Call) RunAndReturn(run func(context.Context, role.Role) (role.Role, error)) *RoleService_Upsert_Call

type RuleService

type RuleService struct {
	mock.Mock
}

RuleService is an autogenerated mock type for the RuleService type

func NewRuleService

func NewRuleService(t mockConstructorTestingTNewRuleService) *RuleService

NewRuleService creates a new instance of RuleService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*RuleService) EXPECT

func (_m *RuleService) EXPECT() *RuleService_Expecter

func (*RuleService) GetAllConfigs

func (_m *RuleService) GetAllConfigs(ctx context.Context) ([]rule.Ruleset, error)

GetAllConfigs provides a mock function with given fields: ctx

type RuleService_Expecter

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

func (*RuleService_Expecter) GetAllConfigs

func (_e *RuleService_Expecter) GetAllConfigs(ctx interface{}) *RuleService_GetAllConfigs_Call

GetAllConfigs is a helper method to define mock.On call

• ctx context.Context

type RuleService_GetAllConfigs_Call

type RuleService_GetAllConfigs_Call struct {
	*mock.Call
}

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

func (*RuleService_GetAllConfigs_Call) Return

func (_c *RuleService_GetAllConfigs_Call) Return(_a0 []rule.Ruleset, _a1 error) *RuleService_GetAllConfigs_Call

func (*RuleService_GetAllConfigs_Call) Run

func (_c *RuleService_GetAllConfigs_Call) Run(run func(ctx context.Context)) *RuleService_GetAllConfigs_Call

func (*RuleService_GetAllConfigs_Call) RunAndReturn

func (_c *RuleService_GetAllConfigs_Call) RunAndReturn(run func(context.Context) ([]rule.Ruleset, error)) *RuleService_GetAllConfigs_Call

type ServiceUserService

type ServiceUserService struct {
	mock.Mock
}

ServiceUserService is an autogenerated mock type for the ServiceUserService type

func NewServiceUserService

func NewServiceUserService(t mockConstructorTestingTNewServiceUserService) *ServiceUserService

NewServiceUserService creates a new instance of ServiceUserService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*ServiceUserService) Create

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

Create provides a mock function with given fields: ctx, serviceUser

func (*ServiceUserService) CreateKey

func (_m *ServiceUserService) CreateKey(ctx context.Context, cred serviceuser.Credential) (serviceuser.Credential, error)

CreateKey provides a mock function with given fields: ctx, cred

func (*ServiceUserService) CreateSecret

func (_m *ServiceUserService) CreateSecret(ctx context.Context, credential serviceuser.Credential) (serviceuser.Secret, error)

CreateSecret provides a mock function with given fields: ctx, credential

func (*ServiceUserService) Delete

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

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

func (*ServiceUserService) DeleteKey

func (_m *ServiceUserService) DeleteKey(ctx context.Context, credID string) error

DeleteKey provides a mock function with given fields: ctx, credID

func (*ServiceUserService) DeleteSecret

func (_m *ServiceUserService) DeleteSecret(ctx context.Context, credID string) error

DeleteSecret provides a mock function with given fields: ctx, credID

func (*ServiceUserService) EXPECT

func (_m *ServiceUserService) EXPECT() *ServiceUserService_Expecter

func (*ServiceUserService) Get

func (_m *ServiceUserService) Get(ctx context.Context, id string) (serviceuser.ServiceUser, error)

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

func (*ServiceUserService) GetKey

func (_m *ServiceUserService) GetKey(ctx context.Context, credID string) (serviceuser.Credential, error)

GetKey provides a mock function with given fields: ctx, credID

func (*ServiceUserService) List

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

List provides a mock function with given fields: ctx, flt

func (*ServiceUserService) ListByOrg

func (_m *ServiceUserService) ListByOrg(ctx context.Context, orgID string) ([]serviceuser.ServiceUser, error)

ListByOrg provides a mock function with given fields: ctx, orgID

func (*ServiceUserService) ListKeys

func (_m *ServiceUserService) ListKeys(ctx context.Context, serviceUserID string) ([]serviceuser.Credential, error)

ListKeys provides a mock function with given fields: ctx, serviceUserID

func (*ServiceUserService) ListSecret

func (_m *ServiceUserService) ListSecret(ctx context.Context, serviceUserID string) ([]serviceuser.Credential, error)

ListSecret provides a mock function with given fields: ctx, serviceUserID

type ServiceUserService_CreateKey_Call

type ServiceUserService_CreateKey_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_CreateKey_Call) Return

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

func (*ServiceUserService_CreateKey_Call) Run

func (_c *ServiceUserService_CreateKey_Call) Run(run func(ctx context.Context, cred serviceuser.Credential)) *ServiceUserService_CreateKey_Call

func (*ServiceUserService_CreateKey_Call) RunAndReturn

func (_c *ServiceUserService_CreateKey_Call) RunAndReturn(run func(context.Context, serviceuser.Credential) (serviceuser.Credential, error)) *ServiceUserService_CreateKey_Call

type ServiceUserService_CreateSecret_Call

type ServiceUserService_CreateSecret_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_CreateSecret_Call) Return

func (_c *ServiceUserService_CreateSecret_Call) Return(_a0 serviceuser.Secret, _a1 error) *ServiceUserService_CreateSecret_Call

func (*ServiceUserService_CreateSecret_Call) Run

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

func (*ServiceUserService_CreateSecret_Call) RunAndReturn

func (_c *ServiceUserService_CreateSecret_Call) RunAndReturn(run func(context.Context, serviceuser.Credential) (serviceuser.Secret, error)) *ServiceUserService_CreateSecret_Call

type ServiceUserService_Create_Call

type ServiceUserService_Create_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_Create_Call) Return

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

func (*ServiceUserService_Create_Call) Run

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

func (*ServiceUserService_Create_Call) RunAndReturn

func (_c *ServiceUserService_Create_Call) RunAndReturn(run func(context.Context, serviceuser.ServiceUser) (serviceuser.ServiceUser, error)) *ServiceUserService_Create_Call

type ServiceUserService_DeleteKey_Call

type ServiceUserService_DeleteKey_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_DeleteKey_Call) Return

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

func (*ServiceUserService_DeleteKey_Call) Run

func (_c *ServiceUserService_DeleteKey_Call) Run(run func(ctx context.Context, credID string)) *ServiceUserService_DeleteKey_Call

func (*ServiceUserService_DeleteKey_Call) RunAndReturn

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

type ServiceUserService_DeleteSecret_Call

type ServiceUserService_DeleteSecret_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_DeleteSecret_Call) Return

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

func (*ServiceUserService_DeleteSecret_Call) Run

func (_c *ServiceUserService_DeleteSecret_Call) Run(run func(ctx context.Context, credID string)) *ServiceUserService_DeleteSecret_Call

func (*ServiceUserService_DeleteSecret_Call) RunAndReturn

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

type ServiceUserService_Delete_Call

type ServiceUserService_Delete_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_Delete_Call) Return

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

func (*ServiceUserService_Delete_Call) Run

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

func (*ServiceUserService_Delete_Call) RunAndReturn

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

type ServiceUserService_Expecter

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

func (*ServiceUserService_Expecter) Create

func (_e *ServiceUserService_Expecter) Create(ctx interface{}, serviceUser interface{}) *ServiceUserService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• serviceUser serviceuser.ServiceUser

func (*ServiceUserService_Expecter) CreateKey

func (_e *ServiceUserService_Expecter) CreateKey(ctx interface{}, cred interface{}) *ServiceUserService_CreateKey_Call

CreateKey is a helper method to define mock.On call

• ctx context.Context
• cred serviceuser.Credential

func (*ServiceUserService_Expecter) CreateSecret

func (_e *ServiceUserService_Expecter) CreateSecret(ctx interface{}, credential interface{}) *ServiceUserService_CreateSecret_Call

CreateSecret is a helper method to define mock.On call

• ctx context.Context
• credential serviceuser.Credential

func (*ServiceUserService_Expecter) Delete

func (_e *ServiceUserService_Expecter) Delete(ctx interface{}, id interface{}) *ServiceUserService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id string

func (*ServiceUserService_Expecter) DeleteKey

func (_e *ServiceUserService_Expecter) DeleteKey(ctx interface{}, credID interface{}) *ServiceUserService_DeleteKey_Call

DeleteKey is a helper method to define mock.On call

• ctx context.Context
• credID string

func (*ServiceUserService_Expecter) DeleteSecret

func (_e *ServiceUserService_Expecter) DeleteSecret(ctx interface{}, credID interface{}) *ServiceUserService_DeleteSecret_Call

DeleteSecret is a helper method to define mock.On call

• ctx context.Context
• credID string

func (*ServiceUserService_Expecter) Get

func (_e *ServiceUserService_Expecter) Get(ctx interface{}, id interface{}) *ServiceUserService_Get_Call

Get is a helper method to define mock.On call

• ctx context.Context
• id string

func (*ServiceUserService_Expecter) GetKey

func (_e *ServiceUserService_Expecter) GetKey(ctx interface{}, credID interface{}) *ServiceUserService_GetKey_Call

GetKey is a helper method to define mock.On call

• ctx context.Context
• credID string

func (*ServiceUserService_Expecter) List

func (_e *ServiceUserService_Expecter) List(ctx interface{}, flt interface{}) *ServiceUserService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• flt serviceuser.Filter

func (*ServiceUserService_Expecter) ListByOrg

func (_e *ServiceUserService_Expecter) ListByOrg(ctx interface{}, orgID interface{}) *ServiceUserService_ListByOrg_Call

ListByOrg is a helper method to define mock.On call

• ctx context.Context
• orgID string

func (*ServiceUserService_Expecter) ListKeys

func (_e *ServiceUserService_Expecter) ListKeys(ctx interface{}, serviceUserID interface{}) *ServiceUserService_ListKeys_Call

ListKeys is a helper method to define mock.On call

• ctx context.Context
• serviceUserID string

func (*ServiceUserService_Expecter) ListSecret

func (_e *ServiceUserService_Expecter) ListSecret(ctx interface{}, serviceUserID interface{}) *ServiceUserService_ListSecret_Call

ListSecret is a helper method to define mock.On call

• ctx context.Context
• serviceUserID string

type ServiceUserService_GetKey_Call

type ServiceUserService_GetKey_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_GetKey_Call) Return

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

func (*ServiceUserService_GetKey_Call) Run

func (_c *ServiceUserService_GetKey_Call) Run(run func(ctx context.Context, credID string)) *ServiceUserService_GetKey_Call

func (*ServiceUserService_GetKey_Call) RunAndReturn

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

type ServiceUserService_Get_Call

type ServiceUserService_Get_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_Get_Call) Return

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

func (*ServiceUserService_Get_Call) Run

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

func (*ServiceUserService_Get_Call) RunAndReturn

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

type ServiceUserService_ListByOrg_Call

type ServiceUserService_ListByOrg_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_ListByOrg_Call) Return

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

func (*ServiceUserService_ListByOrg_Call) Run

func (_c *ServiceUserService_ListByOrg_Call) Run(run func(ctx context.Context, orgID string)) *ServiceUserService_ListByOrg_Call

func (*ServiceUserService_ListByOrg_Call) RunAndReturn

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

type ServiceUserService_ListKeys_Call

type ServiceUserService_ListKeys_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_ListKeys_Call) Return

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

func (*ServiceUserService_ListKeys_Call) Run

func (_c *ServiceUserService_ListKeys_Call) Run(run func(ctx context.Context, serviceUserID string)) *ServiceUserService_ListKeys_Call

func (*ServiceUserService_ListKeys_Call) RunAndReturn

func (_c *ServiceUserService_ListKeys_Call) RunAndReturn(run func(context.Context, string) ([]serviceuser.Credential, error)) *ServiceUserService_ListKeys_Call

type ServiceUserService_ListSecret_Call

type ServiceUserService_ListSecret_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_ListSecret_Call) Return

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

func (*ServiceUserService_ListSecret_Call) Run

func (_c *ServiceUserService_ListSecret_Call) Run(run func(ctx context.Context, serviceUserID string)) *ServiceUserService_ListSecret_Call

func (*ServiceUserService_ListSecret_Call) RunAndReturn

func (_c *ServiceUserService_ListSecret_Call) RunAndReturn(run func(context.Context, string) ([]serviceuser.Credential, error)) *ServiceUserService_ListSecret_Call

type ServiceUserService_List_Call

type ServiceUserService_List_Call struct {
	*mock.Call
}

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

func (*ServiceUserService_List_Call) Return

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

func (*ServiceUserService_List_Call) Run

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

func (*ServiceUserService_List_Call) RunAndReturn

func (_c *ServiceUserService_List_Call) RunAndReturn(run func(context.Context, serviceuser.Filter) ([]serviceuser.ServiceUser, error)) *ServiceUserService_List_Call

type SessionService

type SessionService struct {
	mock.Mock
}

SessionService is an autogenerated mock type for the SessionService type

func NewSessionService

func NewSessionService(t mockConstructorTestingTNewSessionService) *SessionService

NewSessionService creates a new instance of SessionService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*SessionService) Close

func (_m *SessionService) Close()

Close provides a mock function with given fields:

func (*SessionService) Create

func (_m *SessionService) Create(ctx context.Context, userID string) (*session.Session, error)

Create provides a mock function with given fields: ctx, userID

func (*SessionService) Delete

func (_m *SessionService) Delete(ctx context.Context, sessionID uuid.UUID) error

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

func (*SessionService) EXPECT

func (_m *SessionService) EXPECT() *SessionService_Expecter

func (*SessionService) ExtractFromContext

func (_m *SessionService) ExtractFromContext(ctx context.Context) (*session.Session, error)

ExtractFromContext provides a mock function with given fields: ctx

func (*SessionService) InitSessions

func (_m *SessionService) InitSessions(ctx context.Context) error

InitSessions provides a mock function with given fields: ctx

func (*SessionService) Refresh

func (_m *SessionService) Refresh(ctx context.Context, sessionID uuid.UUID) error

Refresh provides a mock function with given fields: ctx, sessionID

type SessionService_Close_Call

type SessionService_Close_Call struct {
	*mock.Call
}

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

func (*SessionService_Close_Call) Return

func (_c *SessionService_Close_Call) Return() *SessionService_Close_Call

func (*SessionService_Close_Call) Run

func (_c *SessionService_Close_Call) Run(run func()) *SessionService_Close_Call

func (*SessionService_Close_Call) RunAndReturn

func (_c *SessionService_Close_Call) RunAndReturn(run func()) *SessionService_Close_Call

type SessionService_Create_Call

type SessionService_Create_Call struct {
	*mock.Call
}

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

func (*SessionService_Create_Call) Return

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

func (*SessionService_Create_Call) Run

func (_c *SessionService_Create_Call) Run(run func(ctx context.Context, userID string)) *SessionService_Create_Call

func (*SessionService_Create_Call) RunAndReturn

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

type SessionService_Delete_Call

type SessionService_Delete_Call struct {
	*mock.Call
}

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

func (*SessionService_Delete_Call) Return

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

func (*SessionService_Delete_Call) Run

func (_c *SessionService_Delete_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *SessionService_Delete_Call

func (*SessionService_Delete_Call) RunAndReturn

func (_c *SessionService_Delete_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *SessionService_Delete_Call

type SessionService_Expecter

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

func (*SessionService_Expecter) Close

func (_e *SessionService_Expecter) Close() *SessionService_Close_Call

Close is a helper method to define mock.On call

func (*SessionService_Expecter) Create

func (_e *SessionService_Expecter) Create(ctx interface{}, userID interface{}) *SessionService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• userID string

func (*SessionService_Expecter) Delete

func (_e *SessionService_Expecter) Delete(ctx interface{}, sessionID interface{}) *SessionService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• sessionID uuid.UUID

func (*SessionService_Expecter) ExtractFromContext

func (_e *SessionService_Expecter) ExtractFromContext(ctx interface{}) *SessionService_ExtractFromContext_Call

ExtractFromContext is a helper method to define mock.On call

• ctx context.Context

func (*SessionService_Expecter) InitSessions

func (_e *SessionService_Expecter) InitSessions(ctx interface{}) *SessionService_InitSessions_Call

InitSessions is a helper method to define mock.On call

• ctx context.Context

func (*SessionService_Expecter) Refresh

func (_e *SessionService_Expecter) Refresh(ctx interface{}, sessionID interface{}) *SessionService_Refresh_Call

Refresh is a helper method to define mock.On call

• ctx context.Context
• sessionID uuid.UUID

type SessionService_ExtractFromContext_Call

type SessionService_ExtractFromContext_Call struct {
	*mock.Call
}

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

func (*SessionService_ExtractFromContext_Call) Return

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

func (*SessionService_ExtractFromContext_Call) Run

func (_c *SessionService_ExtractFromContext_Call) Run(run func(ctx context.Context)) *SessionService_ExtractFromContext_Call

func (*SessionService_ExtractFromContext_Call) RunAndReturn

func (_c *SessionService_ExtractFromContext_Call) RunAndReturn(run func(context.Context) (*session.Session, error)) *SessionService_ExtractFromContext_Call

type SessionService_InitSessions_Call

type SessionService_InitSessions_Call struct {
	*mock.Call
}

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

func (*SessionService_InitSessions_Call) Return

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

func (*SessionService_InitSessions_Call) Run

func (_c *SessionService_InitSessions_Call) Run(run func(ctx context.Context)) *SessionService_InitSessions_Call

func (*SessionService_InitSessions_Call) RunAndReturn

func (_c *SessionService_InitSessions_Call) RunAndReturn(run func(context.Context) error) *SessionService_InitSessions_Call

type SessionService_Refresh_Call

type SessionService_Refresh_Call struct {
	*mock.Call
}

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

func (*SessionService_Refresh_Call) Return

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

func (*SessionService_Refresh_Call) Run

func (_c *SessionService_Refresh_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *SessionService_Refresh_Call

func (*SessionService_Refresh_Call) RunAndReturn

func (_c *SessionService_Refresh_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *SessionService_Refresh_Call

type UserService

type UserService struct {
	mock.Mock
}

UserService is an autogenerated mock type for the UserService type

func NewUserService

func NewUserService(t mockConstructorTestingTNewUserService) *UserService

NewUserService creates a new instance of UserService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*UserService) Create

func (_m *UserService) Create(ctx context.Context, _a1 user.User) (user.User, error)

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

func (*UserService) Delete

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

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

func (*UserService) Disable

func (_m *UserService) Disable(ctx context.Context, id string) error

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

func (*UserService) EXPECT

func (_m *UserService) EXPECT() *UserService_Expecter

func (*UserService) Enable

func (_m *UserService) Enable(ctx context.Context, id string) error

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

func (*UserService) GetByEmail

func (_m *UserService) GetByEmail(ctx context.Context, email string) (user.User, error)

GetByEmail provides a mock function with given fields: ctx, email

func (*UserService) GetByID

func (_m *UserService) GetByID(ctx context.Context, id string) (user.User, error)

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

func (*UserService) GetByIDs

func (_m *UserService) GetByIDs(ctx context.Context, userIDs []string) ([]user.User, error)

GetByIDs provides a mock function with given fields: ctx, userIDs

func (*UserService) IsSudo

func (_m *UserService) IsSudo(ctx context.Context, id string) (bool, error)

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

func (*UserService) List

func (_m *UserService) List(ctx context.Context, flt user.Filter) ([]user.User, error)

List provides a mock function with given fields: ctx, flt

func (*UserService) ListByGroup

func (_m *UserService) ListByGroup(ctx context.Context, groupID string, permissionFilter string) ([]user.User, error)

ListByGroup provides a mock function with given fields: ctx, groupID, permissionFilter

func (*UserService) ListByOrg

func (_m *UserService) ListByOrg(ctx context.Context, orgID string, permissionFilter string) ([]user.User, error)

ListByOrg provides a mock function with given fields: ctx, orgID, permissionFilter

func (*UserService) Update

func (_m *UserService) Update(ctx context.Context, toUpdate user.User) (user.User, error)

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

type UserService_Create_Call

type UserService_Create_Call struct {
	*mock.Call
}

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

func (*UserService_Create_Call) Return

func (_c *UserService_Create_Call) Return(_a0 user.User, _a1 error) *UserService_Create_Call

func (*UserService_Create_Call) Run

func (_c *UserService_Create_Call) Run(run func(ctx context.Context, _a1 user.User)) *UserService_Create_Call

func (*UserService_Create_Call) RunAndReturn

func (_c *UserService_Create_Call) RunAndReturn(run func(context.Context, user.User) (user.User, error)) *UserService_Create_Call

type UserService_Delete_Call

type UserService_Delete_Call struct {
	*mock.Call
}

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

func (*UserService_Delete_Call) Return

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

func (*UserService_Delete_Call) Run

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

func (*UserService_Delete_Call) RunAndReturn

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

type UserService_Disable_Call

type UserService_Disable_Call struct {
	*mock.Call
}

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

func (*UserService_Disable_Call) Return

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

func (*UserService_Disable_Call) Run

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

func (*UserService_Disable_Call) RunAndReturn

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

type UserService_Enable_Call

type UserService_Enable_Call struct {
	*mock.Call
}

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

func (*UserService_Enable_Call) Return

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

func (*UserService_Enable_Call) Run

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

func (*UserService_Enable_Call) RunAndReturn

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

type UserService_Expecter

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

func (*UserService_Expecter) Create

func (_e *UserService_Expecter) Create(ctx interface{}, _a1 interface{}) *UserService_Create_Call

Create is a helper method to define mock.On call

• ctx context.Context
• _a1 user.User

func (*UserService_Expecter) Delete

func (_e *UserService_Expecter) Delete(ctx interface{}, id interface{}) *UserService_Delete_Call

Delete is a helper method to define mock.On call

• ctx context.Context
• id string

func (*UserService_Expecter) Disable

func (_e *UserService_Expecter) Disable(ctx interface{}, id interface{}) *UserService_Disable_Call

Disable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*UserService_Expecter) Enable

func (_e *UserService_Expecter) Enable(ctx interface{}, id interface{}) *UserService_Enable_Call

Enable is a helper method to define mock.On call

• ctx context.Context
• id string

func (*UserService_Expecter) GetByEmail

func (_e *UserService_Expecter) GetByEmail(ctx interface{}, email interface{}) *UserService_GetByEmail_Call

GetByEmail is a helper method to define mock.On call

• ctx context.Context
• email string

func (*UserService_Expecter) GetByID

func (_e *UserService_Expecter) GetByID(ctx interface{}, id interface{}) *UserService_GetByID_Call

GetByID is a helper method to define mock.On call

• ctx context.Context
• id string

func (*UserService_Expecter) GetByIDs

func (_e *UserService_Expecter) GetByIDs(ctx interface{}, userIDs interface{}) *UserService_GetByIDs_Call

GetByIDs is a helper method to define mock.On call

• ctx context.Context
• userIDs []string

func (*UserService_Expecter) IsSudo

func (_e *UserService_Expecter) IsSudo(ctx interface{}, id interface{}) *UserService_IsSudo_Call

IsSudo is a helper method to define mock.On call

• ctx context.Context
• id string

func (*UserService_Expecter) List

func (_e *UserService_Expecter) List(ctx interface{}, flt interface{}) *UserService_List_Call

List is a helper method to define mock.On call

• ctx context.Context
• flt user.Filter

func (*UserService_Expecter) ListByGroup

func (_e *UserService_Expecter) ListByGroup(ctx interface{}, groupID interface{}, permissionFilter interface{}) *UserService_ListByGroup_Call

ListByGroup is a helper method to define mock.On call

• ctx context.Context
• groupID string
• permissionFilter string

func (*UserService_Expecter) ListByOrg

func (_e *UserService_Expecter) ListByOrg(ctx interface{}, orgID interface{}, permissionFilter interface{}) *UserService_ListByOrg_Call

ListByOrg is a helper method to define mock.On call

• ctx context.Context
• orgID string
• permissionFilter string

func (*UserService_Expecter) Update

func (_e *UserService_Expecter) Update(ctx interface{}, toUpdate interface{}) *UserService_Update_Call

Update is a helper method to define mock.On call

• ctx context.Context
• toUpdate user.User

type UserService_GetByEmail_Call

type UserService_GetByEmail_Call struct {
	*mock.Call
}

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

func (*UserService_GetByEmail_Call) Return

func (_c *UserService_GetByEmail_Call) Return(_a0 user.User, _a1 error) *UserService_GetByEmail_Call

func (*UserService_GetByEmail_Call) Run

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

func (*UserService_GetByEmail_Call) RunAndReturn

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

type UserService_GetByID_Call

type UserService_GetByID_Call struct {
	*mock.Call
}

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

func (*UserService_GetByID_Call) Return

func (_c *UserService_GetByID_Call) Return(_a0 user.User, _a1 error) *UserService_GetByID_Call

func (*UserService_GetByID_Call) Run

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

func (*UserService_GetByID_Call) RunAndReturn

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

type UserService_GetByIDs_Call

type UserService_GetByIDs_Call struct {
	*mock.Call
}

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

func (*UserService_GetByIDs_Call) Return

func (_c *UserService_GetByIDs_Call) Return(_a0 []user.User, _a1 error) *UserService_GetByIDs_Call

func (*UserService_GetByIDs_Call) Run

func (_c *UserService_GetByIDs_Call) Run(run func(ctx context.Context, userIDs []string)) *UserService_GetByIDs_Call

func (*UserService_GetByIDs_Call) RunAndReturn

func (_c *UserService_GetByIDs_Call) RunAndReturn(run func(context.Context, []string) ([]user.User, error)) *UserService_GetByIDs_Call

type UserService_IsSudo_Call

type UserService_IsSudo_Call struct {
	*mock.Call
}

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

func (*UserService_IsSudo_Call) Return

func (_c *UserService_IsSudo_Call) Return(_a0 bool, _a1 error) *UserService_IsSudo_Call

func (*UserService_IsSudo_Call) Run

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

func (*UserService_IsSudo_Call) RunAndReturn

func (_c *UserService_IsSudo_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *UserService_IsSudo_Call

type UserService_ListByGroup_Call

type UserService_ListByGroup_Call struct {
	*mock.Call
}

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

func (*UserService_ListByGroup_Call) Return

func (_c *UserService_ListByGroup_Call) Return(_a0 []user.User, _a1 error) *UserService_ListByGroup_Call

func (*UserService_ListByGroup_Call) Run

func (_c *UserService_ListByGroup_Call) Run(run func(ctx context.Context, groupID string, permissionFilter string)) *UserService_ListByGroup_Call

func (*UserService_ListByGroup_Call) RunAndReturn

func (_c *UserService_ListByGroup_Call) RunAndReturn(run func(context.Context, string, string) ([]user.User, error)) *UserService_ListByGroup_Call

type UserService_ListByOrg_Call

type UserService_ListByOrg_Call struct {
	*mock.Call
}

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

func (*UserService_ListByOrg_Call) Return

func (_c *UserService_ListByOrg_Call) Return(_a0 []user.User, _a1 error) *UserService_ListByOrg_Call

func (*UserService_ListByOrg_Call) Run

func (_c *UserService_ListByOrg_Call) Run(run func(ctx context.Context, orgID string, permissionFilter string)) *UserService_ListByOrg_Call

func (*UserService_ListByOrg_Call) RunAndReturn

func (_c *UserService_ListByOrg_Call) RunAndReturn(run func(context.Context, string, string) ([]user.User, error)) *UserService_ListByOrg_Call

type UserService_List_Call

type UserService_List_Call struct {
	*mock.Call
}

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

func (*UserService_List_Call) Return

func (_c *UserService_List_Call) Return(_a0 []user.User, _a1 error) *UserService_List_Call

func (*UserService_List_Call) Run

func (_c *UserService_List_Call) Run(run func(ctx context.Context, flt user.Filter)) *UserService_List_Call

func (*UserService_List_Call) RunAndReturn

func (_c *UserService_List_Call) RunAndReturn(run func(context.Context, user.Filter) ([]user.User, error)) *UserService_List_Call

type UserService_Update_Call

type UserService_Update_Call struct {
	*mock.Call
}

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

func (*UserService_Update_Call) Return

func (_c *UserService_Update_Call) Return(_a0 user.User, _a1 error) *UserService_Update_Call

func (*UserService_Update_Call) Run

func (_c *UserService_Update_Call) Run(run func(ctx context.Context, toUpdate user.User)) *UserService_Update_Call

func (*UserService_Update_Call) RunAndReturn

func (_c *UserService_Update_Call) RunAndReturn(run func(context.Context, user.User) (user.User, error)) *UserService_Update_Call