mocks

package

Go to main page

Versions in this module

v0

v0.7.1-rc

Dec 16, 2024

v0.7.0

Oct 8, 2024

v0.6.35

Oct 8, 2024

Changes in this version

type UserService

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

+ type UserService_Delete_Call struct

+ 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_Expecter

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

v0.6.34

Oct 7, 2024

Changes in this version

type ResourceService

+ func (_m *ResourceService) UpsertConfig(ctx context.Context, name string, config string) (schema.Config, error)

type ResourceService_Expecter

+ func (_e *ResourceService_Expecter) UpsertConfig(ctx interface{}, name interface{}, config interface{}) *ResourceService_UpsertConfig_Call

+ type ResourceService_UpsertConfig_Call struct

+ func (_c *ResourceService_UpsertConfig_Call) Return(_a0 schema.Config, _a1 error) *ResourceService_UpsertConfig_Call

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

+ func (_c *ResourceService_UpsertConfig_Call) RunAndReturn(run func(context.Context, string, string) (schema.Config, error)) *ResourceService_UpsertConfig_Call

type RuleService

+ func (_m *RuleService) UpsertRulesConfigs(ctx context.Context, name string, config string) (rule.Config, error)

type RuleService_Expecter

+ func (_e *RuleService_Expecter) UpsertRulesConfigs(ctx interface{}, name interface{}, config interface{}) *RuleService_UpsertRulesConfigs_Call

+ type RuleService_UpsertRulesConfigs_Call struct

+ func (_c *RuleService_UpsertRulesConfigs_Call) Return(_a0 rule.Config, _a1 error) *RuleService_UpsertRulesConfigs_Call

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

+ func (_c *RuleService_UpsertRulesConfigs_Call) RunAndReturn(run func(context.Context, string, string) (rule.Config, error)) *RuleService_UpsertRulesConfigs_Call

v0.6.34-beta

Sep 23, 2024

v0.6.33

Sep 17, 2024

Changes in this version

type ResourceService

+ func (_m *ResourceService) ListAllUserResources(ctx context.Context, userID string, resourceType []string) (map[string]map[string][]string, error)

+ func (_m *ResourceService) ListUserResourcesByType(ctx context.Context, userID string, resourceType string) (map[string][]string, error)

type ResourceService_Expecter

+ func (_e *ResourceService_Expecter) ListAllUserResources(ctx interface{}, userID interface{}, resourceType interface{}) *ResourceService_ListAllUserResources_Call

+ func (_e *ResourceService_Expecter) ListUserResourcesByType(ctx interface{}, userID interface{}, resourceType interface{}) *ResourceService_ListUserResourcesByType_Call

+ type ResourceService_ListAllUserResources_Call struct

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

+ func (_c *ResourceService_ListAllUserResources_Call) Run(run func(ctx context.Context, userID string, resourceType []string)) *ResourceService_ListAllUserResources_Call

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

+ type ResourceService_ListUserResourcesByType_Call struct

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

+ func (_c *ResourceService_ListUserResourcesByType_Call) Run(run func(ctx context.Context, userID string, resourceType string)) *ResourceService_ListUserResourcesByType_Call

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

v0.6.33-beta

Sep 20, 2024

v0.6.32

Aug 21, 2024

v0.6.31

Jul 29, 2024

Changes in this version

type RelationService

+ func (_m *RelationService) CheckIsPublic(ctx context.Context, resourceNS namespace.Namespace, resourceIdxa string, ...) (bool, error)

+ type RelationService_CheckIsPublic_Call struct

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

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

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

type RelationService_Expecter

+ func (_e *RelationService_Expecter) CheckIsPublic(ctx interface{}, resourceNS interface{}, resourceIdxa interface{}, ...) *RelationService_CheckIsPublic_Call

v0.6.30

Jul 29, 2024

Changes in this version

type ResourceService

+ func (_m *ResourceService) BulkCheckAuthz(ctx context.Context, resources []resource.Resource, actions []action.Action) ([]relation.Permission, error)

+ type ResourceService_BulkCheckAuthz_Call struct

+ func (_c *ResourceService_BulkCheckAuthz_Call) Return(_a0 []relation.Permission, _a1 error) *ResourceService_BulkCheckAuthz_Call

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

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

type ResourceService_Expecter

+ func (_e *ResourceService_Expecter) BulkCheckAuthz(ctx interface{}, resources interface{}, actions interface{}) *ResourceService_BulkCheckAuthz_Call

v0.6.30-beta-3

Jul 23, 2024

v0.6.30-beta-2

Jul 23, 2024

v0.6.30-beta

Jul 22, 2024

v0.6.29

Jul 18, 2024

Changes in this version

type RelationService

+ func (_m *RelationService) CheckPermission(ctx context.Context, usr user.User, resourceNS namespace.Namespace, ...) (bool, error)

+ func (_m *RelationService) LookupResources(ctx context.Context, resourceType string, permission string, ...) ([]string, error)

+ type RelationService_CheckPermission_Call struct

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

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

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

type RelationService_Expecter

+ func (_e *RelationService_Expecter) CheckPermission(ctx interface{}, usr interface{}, resourceNS interface{}, ...) *RelationService_CheckPermission_Call

+ func (_e *RelationService_Expecter) LookupResources(ctx interface{}, resourceType interface{}, permission interface{}, ...) *RelationService_LookupResources_Call

+ type RelationService_LookupResources_Call struct

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

+ func (_c *RelationService_LookupResources_Call) Run(run func(ctx context.Context, resourceType string, permission string, ...)) *RelationService_LookupResources_Call

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

type ServiceDataService

+ func (_m *ServiceDataService) GetKeyByURN(ctx context.Context, urn string) (servicedata.Key, error)

type ServiceDataService_Expecter

+ func (_e *ServiceDataService_Expecter) GetKeyByURN(ctx interface{}, urn interface{}) *ServiceDataService_GetKeyByURN_Call

+ type ServiceDataService_GetKeyByURN_Call struct

+ func (_c *ServiceDataService_GetKeyByURN_Call) Return(_a0 servicedata.Key, _a1 error) *ServiceDataService_GetKeyByURN_Call

+ func (_c *ServiceDataService_GetKeyByURN_Call) Run(run func(ctx context.Context, urn string)) *ServiceDataService_GetKeyByURN_Call

+ func (_c *ServiceDataService_GetKeyByURN_Call) RunAndReturn(run func(context.Context, string) (servicedata.Key, error)) *ServiceDataService_GetKeyByURN_Call

v0.6.29-beta-2

Jul 10, 2024

v0.6.29-beta

Jul 9, 2024

v0.6.28

Jul 9, 2024

v0.6.28-beta-2

Jun 24, 2024

v0.6.28-beta

Jun 21, 2024

v0.6.27

Jun 18, 2024

v0.6.27-beta

Jun 18, 2024

v0.6.26

Jun 14, 2024

v0.6.26-beta

Jun 13, 2024

v0.6.25

Jun 11, 2024

Changes in this version

type ActionService

+ func (_m *ActionService) Upsert(ctx context.Context, _a1 action.Action) (action.Action, error)

type ActionService_Expecter

+ func (_e *ActionService_Expecter) Upsert(ctx interface{}, _a1 interface{}) *ActionService_Upsert_Call

+ type ActionService_Upsert_Call struct

+ func (_c *ActionService_Upsert_Call) Return(_a0 action.Action, _a1 error) *ActionService_Upsert_Call

+ func (_c *ActionService_Upsert_Call) Run(run func(ctx context.Context, _a1 action.Action)) *ActionService_Upsert_Call

+ func (_c *ActionService_Upsert_Call) RunAndReturn(run func(context.Context, action.Action) (action.Action, error)) *ActionService_Upsert_Call

type NamespaceService

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

type NamespaceService_Expecter

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

+ type NamespaceService_Upsert_Call struct

+ 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 PolicyService

+ func (_m *PolicyService) Upsert(ctx context.Context, pol *policy.Policy) ([]policy.Policy, error)

type PolicyService_Expecter

+ func (_e *PolicyService_Expecter) Upsert(ctx interface{}, pol interface{}) *PolicyService_Upsert_Call

+ type PolicyService_Upsert_Call struct

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

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

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

type RoleService

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

type RoleService_Expecter

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

+ type RoleService_Upsert_Call struct

+ 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, toUpsert role.Role)) *RoleService_Upsert_Call

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

v0.6.25-beta

Jun 11, 2024

v0.6.24

Jun 10, 2024

v0.6.24-beta

Jun 6, 2024

v0.6.23

Jun 5, 2024

v0.6.23-beta

Jun 4, 2024

v0.6.23-alpha

Jun 5, 2024

v0.6.22

Jun 4, 2024

Changes in this version

type ServiceDataService

+ func (_m *ServiceDataService) Get(ctx context.Context, filter servicedata.Filter) ([]servicedata.ServiceData, error)

+ func (_m *ServiceDataService) Upsert(ctx context.Context, serviceData servicedata.ServiceData) (servicedata.ServiceData, error)

type ServiceDataService_Expecter

+ func (_e *ServiceDataService_Expecter) Get(ctx interface{}, filter interface{}) *ServiceDataService_Get_Call

+ func (_e *ServiceDataService_Expecter) Upsert(ctx interface{}, serviceData interface{}) *ServiceDataService_Upsert_Call

+ type ServiceDataService_Get_Call struct

+ func (_c *ServiceDataService_Get_Call) Return(_a0 []servicedata.ServiceData, _a1 error) *ServiceDataService_Get_Call

+ func (_c *ServiceDataService_Get_Call) Run(run func(ctx context.Context, filter servicedata.Filter)) *ServiceDataService_Get_Call

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

+ type ServiceDataService_Upsert_Call struct

+ func (_c *ServiceDataService_Upsert_Call) Return(_a0 servicedata.ServiceData, _a1 error) *ServiceDataService_Upsert_Call

+ func (_c *ServiceDataService_Upsert_Call) Run(run func(ctx context.Context, serviceData servicedata.ServiceData)) *ServiceDataService_Upsert_Call

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

v0.6.21

May 27, 2024

Changes in this version

type ResourceService

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

type ResourceService_Expecter

+ func (_e *ResourceService_Expecter) Upsert(ctx interface{}, _a1 interface{}) *ResourceService_Upsert_Call

+ type ResourceService_Upsert_Call struct

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

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

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

v0.6.20

May 22, 2024

Changes in this version

+ type ServiceDataService struct

+ func NewServiceDataService(t interface{ ... }) *ServiceDataService

+ func (_m *ServiceDataService) CreateKey(ctx context.Context, key servicedata.Key) (servicedata.Key, error)

+ func (_m *ServiceDataService) EXPECT() *ServiceDataService_Expecter

+ type ServiceDataService_CreateKey_Call struct

+ func (_c *ServiceDataService_CreateKey_Call) Return(_a0 servicedata.Key, _a1 error) *ServiceDataService_CreateKey_Call

+ func (_c *ServiceDataService_CreateKey_Call) Run(run func(ctx context.Context, key servicedata.Key)) *ServiceDataService_CreateKey_Call

+ func (_c *ServiceDataService_CreateKey_Call) RunAndReturn(run func(context.Context, servicedata.Key) (servicedata.Key, error)) *ServiceDataService_CreateKey_Call

+ type ServiceDataService_Expecter struct

+ func (_e *ServiceDataService_Expecter) CreateKey(ctx interface{}, key interface{}) *ServiceDataService_CreateKey_Call

v0.6.19

May 17, 2024

v0.6.19-alpha

May 20, 2024

v0.6.18

May 3, 2024

v0.6.17

Apr 23, 2024

Changes in this version

+ type ActivityService struct

+ func NewActivityService(t interface{ ... }) *ActivityService

+ func (_m *ActivityService) EXPECT() *ActivityService_Expecter

+ func (_m *ActivityService) List(ctx context.Context, filter activity.Filter) (activity.PagedActivity, error)

+ type ActivityService_Expecter struct

+ func (_e *ActivityService_Expecter) List(ctx interface{}, filter interface{}) *ActivityService_List_Call

+ type ActivityService_List_Call struct

+ func (_c *ActivityService_List_Call) Return(_a0 activity.PagedActivity, _a1 error) *ActivityService_List_Call

+ func (_c *ActivityService_List_Call) Run(run func(ctx context.Context, filter activity.Filter)) *ActivityService_List_Call

+ func (_c *ActivityService_List_Call) RunAndReturn(run func(context.Context, activity.Filter) (activity.PagedActivity, error)) *ActivityService_List_Call

v0.6.16

Apr 22, 2024

v0.6.15

Apr 19, 2024

v0.6.14

Apr 1, 2024

v0.6.13

Mar 13, 2024

v0.6.12

Mar 13, 2024

v0.6.11

Mar 7, 2024

v0.6.10

Mar 7, 2024

v0.6.9

Feb 12, 2024

v0.6.8

Jan 23, 2024

Changes in this version

type UserService

+ func (_m *UserService) Get(ctx context.Context, idOrEmail string) (user.User, error)

type UserService_Expecter

+ func (_e *UserService_Expecter) Get(ctx interface{}, idOrEmail interface{}) *UserService_Get_Call

+ type UserService_Get_Call struct

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

+ func (_c *UserService_Get_Call) Run(run func(ctx context.Context, idOrEmail string)) *UserService_Get_Call

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

v0.6.7

Oct 10, 2023

v0.6.6

Oct 5, 2023

v0.6.5

Aug 21, 2023

Changes in this version

type ActionService_Create_Call

+ func (_c *ActionService_Create_Call) RunAndReturn(run func(context.Context, action.Action) (action.Action, error)) *ActionService_Create_Call

type ActionService_Get_Call

+ func (_c *ActionService_Get_Call) RunAndReturn(run func(context.Context, string) (action.Action, error)) *ActionService_Get_Call

type ActionService_List_Call

+ func (_c *ActionService_List_Call) RunAndReturn(run func(context.Context) ([]action.Action, error)) *ActionService_List_Call

type ActionService_Update_Call

+ func (_c *ActionService_Update_Call) RunAndReturn(run func(context.Context, string, action.Action) (action.Action, error)) *ActionService_Update_Call

type GroupService_Create_Call

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

type GroupService_Get_Call

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

type GroupService_ListGroupRelations_Call

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

type GroupService_ListUserGroups_Call

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

type GroupService_List_Call

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

type GroupService_Update_Call

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

type NamespaceService_Create_Call

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

type 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) RunAndReturn(run func(context.Context) ([]namespace.Namespace, error)) *NamespaceService_List_Call

type NamespaceService_Update_Call

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

type OrganizationService_Create_Call

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

type OrganizationService_Get_Call

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

type OrganizationService_ListAdmins_Call

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

type OrganizationService_List_Call

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

type OrganizationService_Update_Call

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

type PolicyService_Create_Call

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

type 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) RunAndReturn(run func(context.Context) ([]policy.Policy, error)) *PolicyService_List_Call

type PolicyService_Update_Call

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

type ProjectService_Create_Call

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

type ProjectService_Get_Call

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

type ProjectService_ListAdmins_Call

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

type ProjectService_List_Call

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

type ProjectService_Update_Call

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

type RelationService_Create_Call

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

type RelationService_DeleteV2_Call

+ func (_c *RelationService_DeleteV2_Call) RunAndReturn(run func(context.Context, relation.RelationV2) error) *RelationService_DeleteV2_Call

type RelationService_GetRelationByFields_Call

+ func (_c *RelationService_GetRelationByFields_Call) RunAndReturn(run func(context.Context, relation.RelationV2) (relation.RelationV2, error)) *RelationService_GetRelationByFields_Call

type RelationService_Get_Call

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

type RelationService_List_Call

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

+ type RelationTransformer struct

+ func NewRelationTransformer(t interface{ ... }) *RelationTransformer

+ func (_m *RelationTransformer) EXPECT() *RelationTransformer_Expecter

+ func (_m *RelationTransformer) TransformRelation(ctx context.Context, rlt relation.RelationV2) (relation.RelationV2, error)

+ type RelationTransformer_Expecter struct

+ func (_e *RelationTransformer_Expecter) TransformRelation(ctx interface{}, rlt interface{}) *RelationTransformer_TransformRelation_Call

+ type RelationTransformer_TransformRelation_Call struct

+ func (_c *RelationTransformer_TransformRelation_Call) Return(_a0 relation.RelationV2, _a1 error) *RelationTransformer_TransformRelation_Call

+ func (_c *RelationTransformer_TransformRelation_Call) Run(run func(ctx context.Context, rlt relation.RelationV2)) *RelationTransformer_TransformRelation_Call

+ func (_c *RelationTransformer_TransformRelation_Call) RunAndReturn(run func(context.Context, relation.RelationV2) (relation.RelationV2, error)) *RelationTransformer_TransformRelation_Call

type ResourceService_CheckAuthz_Call

+ func (_c *ResourceService_CheckAuthz_Call) RunAndReturn(run func(context.Context, resource.Resource, action.Action) (bool, error)) *ResourceService_CheckAuthz_Call

type ResourceService_Create_Call

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

type 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) RunAndReturn(run func(context.Context, resource.Filter) ([]resource.Resource, error)) *ResourceService_List_Call

type ResourceService_Update_Call

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

type RoleService_Create_Call

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

type 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) RunAndReturn(run func(context.Context) ([]role.Role, error)) *RoleService_List_Call

type RoleService_Update_Call

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

type RuleService_GetAllConfigs_Call

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

type UserService_CreateMetadataKey_Call

+ func (_c *UserService_CreateMetadataKey_Call) RunAndReturn(run func(context.Context, user.UserMetadataKey) (user.UserMetadataKey, error)) *UserService_CreateMetadataKey_Call

type UserService_Create_Call

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

type UserService_FetchCurrentUser_Call

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

type 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) RunAndReturn(run func(context.Context, string) (user.User, error)) *UserService_GetByID_Call

type UserService_GetByIDs_Call

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

type UserService_List_Call

+ func (_c *UserService_List_Call) RunAndReturn(run func(context.Context, user.Filter) (user.PagedUsers, error)) *UserService_List_Call

type UserService_UpdateByEmail_Call

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

type UserService_UpdateByID_Call

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

v0.6.4

May 30, 2023

v0.6.3

May 2, 2023

v0.6.2

Apr 17, 2023

v0.6.1

Apr 4, 2023

v0.6.0

Mar 16, 2023

Changes in this version

+ type ActionService struct

+ func NewActionService(t mockConstructorTestingTNewActionService) *ActionService

+ func (_m *ActionService) Create(ctx context.Context, _a1 action.Action) (action.Action, error)

+ func (_m *ActionService) EXPECT() *ActionService_Expecter

+ func (_m *ActionService) Get(ctx context.Context, id string) (action.Action, error)

+ func (_m *ActionService) List(ctx context.Context) ([]action.Action, error)

+ func (_m *ActionService) Update(ctx context.Context, id string, _a2 action.Action) (action.Action, error)

+ type ActionService_Create_Call struct

+ func (_c *ActionService_Create_Call) Return(_a0 action.Action, _a1 error) *ActionService_Create_Call

+ func (_c *ActionService_Create_Call) Run(run func(ctx context.Context, _a1 action.Action)) *ActionService_Create_Call

+ type ActionService_Expecter struct

+ func (_e *ActionService_Expecter) Create(ctx interface{}, _a1 interface{}) *ActionService_Create_Call

+ func (_e *ActionService_Expecter) Get(ctx interface{}, id interface{}) *ActionService_Get_Call

+ func (_e *ActionService_Expecter) List(ctx interface{}) *ActionService_List_Call

+ func (_e *ActionService_Expecter) Update(ctx interface{}, id interface{}, _a2 interface{}) *ActionService_Update_Call

+ type ActionService_Get_Call struct

+ func (_c *ActionService_Get_Call) Return(_a0 action.Action, _a1 error) *ActionService_Get_Call

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

+ type ActionService_List_Call struct

+ func (_c *ActionService_List_Call) Return(_a0 []action.Action, _a1 error) *ActionService_List_Call

+ func (_c *ActionService_List_Call) Run(run func(ctx context.Context)) *ActionService_List_Call

+ type ActionService_Update_Call struct

+ func (_c *ActionService_Update_Call) Return(_a0 action.Action, _a1 error) *ActionService_Update_Call

+ func (_c *ActionService_Update_Call) Run(run func(ctx context.Context, id string, _a2 action.Action)) *ActionService_Update_Call

+ type GroupService struct

+ func NewGroupService(t mockConstructorTestingTNewGroupService) *GroupService

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

+ func (_m *GroupService) EXPECT() *GroupService_Expecter

+ 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) ListGroupRelations(ctx context.Context, objectId string, subjectType string, role string) ([]user.User, []group.Group, map[string][]string, map[string][]string, error)

+ func (_m *GroupService) ListUserGroups(ctx context.Context, userId string, roleId string) ([]group.Group, error)

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

+ type GroupService_Create_Call struct

+ 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

+ type GroupService_Expecter struct

+ func (_e *GroupService_Expecter) Create(ctx interface{}, grp interface{}) *GroupService_Create_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) ListGroupRelations(ctx interface{}, objectId interface{}, subjectType interface{}, ...) *GroupService_ListGroupRelations_Call

+ func (_e *GroupService_Expecter) ListUserGroups(ctx interface{}, userId interface{}, roleId interface{}) *GroupService_ListUserGroups_Call

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

+ type GroupService_Get_Call struct

+ 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

+ type GroupService_ListGroupRelations_Call struct

+ func (_c *GroupService_ListGroupRelations_Call) Return(_a0 []user.User, _a1 []group.Group, _a2 map[string][]string, ...) *GroupService_ListGroupRelations_Call

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

+ type GroupService_ListUserGroups_Call struct

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

+ func (_c *GroupService_ListUserGroups_Call) Run(run func(ctx context.Context, userId string, roleId string)) *GroupService_ListUserGroups_Call

+ type GroupService_List_Call struct

+ 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

+ type GroupService_Update_Call struct

+ 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

+ type NamespaceService struct

+ func NewNamespaceService(t mockConstructorTestingTNewNamespaceService) *NamespaceService

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

+ 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)

+ type NamespaceService_Create_Call struct

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

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

+ type NamespaceService_Expecter struct

+ func (_e *NamespaceService_Expecter) Create(ctx interface{}, ns interface{}) *NamespaceService_Create_Call

+ 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

+ type NamespaceService_Get_Call struct

+ 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

+ type NamespaceService_List_Call struct

+ 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

+ type NamespaceService_Update_Call struct

+ 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

+ type OrganizationService struct

+ func NewOrganizationService(t mockConstructorTestingTNewOrganizationService) *OrganizationService

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

+ func (_m *OrganizationService) EXPECT() *OrganizationService_Expecter

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

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

+ func (_m *OrganizationService) ListAdmins(ctx context.Context, id string) ([]user.User, error)

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

+ type OrganizationService_Create_Call struct

+ 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

+ type OrganizationService_Expecter struct

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

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

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

+ func (_e *OrganizationService_Expecter) ListAdmins(ctx interface{}, id interface{}) *OrganizationService_ListAdmins_Call

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

+ type OrganizationService_Get_Call struct

+ 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

+ type OrganizationService_ListAdmins_Call struct

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

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

+ type OrganizationService_List_Call struct

+ 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)) *OrganizationService_List_Call

+ type OrganizationService_Update_Call struct

+ 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

+ type PolicyService struct

+ func NewPolicyService(t mockConstructorTestingTNewPolicyService) *PolicyService

+ func (_m *PolicyService) Create(ctx context.Context, pol policy.Policy) ([]policy.Policy, 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) ([]policy.Policy, error)

+ func (_m *PolicyService) Update(ctx context.Context, pol policy.Policy) ([]policy.Policy, error)

+ type PolicyService_Create_Call struct

+ 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

+ type PolicyService_Expecter struct

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

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

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

+ func (_e *PolicyService_Expecter) Update(ctx interface{}, pol interface{}) *PolicyService_Update_Call

+ type PolicyService_Get_Call struct

+ 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

+ type PolicyService_List_Call struct

+ 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)) *PolicyService_List_Call

+ type PolicyService_Update_Call struct

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

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

+ type ProjectService struct

+ func NewProjectService(t mockConstructorTestingTNewProjectService) *ProjectService

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

+ func (_m *ProjectService) EXPECT() *ProjectService_Expecter

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

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

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

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

+ type ProjectService_Create_Call struct

+ 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

+ type ProjectService_Expecter struct

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

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

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

+ func (_e *ProjectService_Expecter) ListAdmins(ctx interface{}, id interface{}) *ProjectService_ListAdmins_Call

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

+ type ProjectService_Get_Call struct

+ 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, idOrSlugd string)) *ProjectService_Get_Call

+ type ProjectService_ListAdmins_Call struct

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

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

+ type ProjectService_List_Call struct

+ 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)) *ProjectService_List_Call

+ type ProjectService_Update_Call struct

+ 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

+ type RelationService struct

+ func NewRelationService(t mockConstructorTestingTNewRelationService) *RelationService

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

+ func (_m *RelationService) DeleteV2(ctx context.Context, rel relation.RelationV2) error

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

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

+ func (_m *RelationService) GetRelationByFields(ctx context.Context, rel relation.RelationV2) (relation.RelationV2, error)

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

+ type RelationService_Create_Call struct

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

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

+ type RelationService_DeleteV2_Call struct

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

+ func (_c *RelationService_DeleteV2_Call) Run(run func(ctx context.Context, rel relation.RelationV2)) *RelationService_DeleteV2_Call

+ type RelationService_Expecter struct

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

+ func (_e *RelationService_Expecter) DeleteV2(ctx interface{}, rel interface{}) *RelationService_DeleteV2_Call

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

+ func (_e *RelationService_Expecter) GetRelationByFields(ctx interface{}, rel interface{}) *RelationService_GetRelationByFields_Call

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

+ type RelationService_GetRelationByFields_Call struct

+ func (_c *RelationService_GetRelationByFields_Call) Return(_a0 relation.RelationV2, _a1 error) *RelationService_GetRelationByFields_Call

+ func (_c *RelationService_GetRelationByFields_Call) Run(run func(ctx context.Context, rel relation.RelationV2)) *RelationService_GetRelationByFields_Call

+ type RelationService_Get_Call struct

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

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

+ type RelationService_List_Call struct

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

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

+ type ResourceService struct

+ func NewResourceService(t mockConstructorTestingTNewResourceService) *ResourceService

+ func (_m *ResourceService) CheckAuthz(ctx context.Context, _a1 resource.Resource, _a2 action.Action) (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, id string, _a2 resource.Resource) (resource.Resource, error)

+ type ResourceService_CheckAuthz_Call struct

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

+ func (_c *ResourceService_CheckAuthz_Call) Run(run func(ctx context.Context, _a1 resource.Resource, _a2 action.Action)) *ResourceService_CheckAuthz_Call

+ type ResourceService_Create_Call struct

+ 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

+ type ResourceService_Expecter struct

+ func (_e *ResourceService_Expecter) CheckAuthz(ctx interface{}, _a1 interface{}, _a2 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{}, id interface{}, _a2 interface{}) *ResourceService_Update_Call

+ type ResourceService_Get_Call struct

+ 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

+ type ResourceService_List_Call struct

+ 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

+ type ResourceService_Update_Call struct

+ 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, id string, _a2 resource.Resource)) *ResourceService_Update_Call

+ type RoleService struct

+ func NewRoleService(t mockConstructorTestingTNewRoleService) *RoleService

+ func (_m *RoleService) Create(ctx context.Context, toCreate role.Role) (role.Role, 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) ([]role.Role, error)

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

+ type RoleService_Create_Call struct

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

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

+ type RoleService_Expecter struct

+ func (_e *RoleService_Expecter) Create(ctx interface{}, toCreate interface{}) *RoleService_Create_Call

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

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

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

+ type RoleService_Get_Call struct

+ 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

+ type RoleService_List_Call struct

+ 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)) *RoleService_List_Call

+ type RoleService_Update_Call struct

+ 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

+ type RuleService struct

+ func NewRuleService(t mockConstructorTestingTNewRuleService) *RuleService

+ func (_m *RuleService) EXPECT() *RuleService_Expecter

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

+ type RuleService_Expecter struct

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

+ type RuleService_GetAllConfigs_Call struct

+ 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

+ type UserService struct

+ func NewUserService(t mockConstructorTestingTNewUserService) *UserService

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

+ func (_m *UserService) CreateMetadataKey(ctx context.Context, key user.UserMetadataKey) (user.UserMetadataKey, error)

+ func (_m *UserService) EXPECT() *UserService_Expecter

+ func (_m *UserService) FetchCurrentUser(ctx context.Context) (user.User, 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) List(ctx context.Context, flt user.Filter) (user.PagedUsers, error)

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

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

+ type UserService_CreateMetadataKey_Call struct

+ func (_c *UserService_CreateMetadataKey_Call) Return(_a0 user.UserMetadataKey, _a1 error) *UserService_CreateMetadataKey_Call

+ func (_c *UserService_CreateMetadataKey_Call) Run(run func(ctx context.Context, key user.UserMetadataKey)) *UserService_CreateMetadataKey_Call

+ type UserService_Create_Call struct

+ 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

+ type UserService_Expecter struct

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

+ func (_e *UserService_Expecter) CreateMetadataKey(ctx interface{}, key interface{}) *UserService_CreateMetadataKey_Call

+ func (_e *UserService_Expecter) FetchCurrentUser(ctx interface{}) *UserService_FetchCurrentUser_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) List(ctx interface{}, flt interface{}) *UserService_List_Call

+ func (_e *UserService_Expecter) UpdateByEmail(ctx interface{}, toUpdate interface{}) *UserService_UpdateByEmail_Call

+ func (_e *UserService_Expecter) UpdateByID(ctx interface{}, toUpdate interface{}) *UserService_UpdateByID_Call

+ type UserService_FetchCurrentUser_Call struct

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

+ func (_c *UserService_FetchCurrentUser_Call) Run(run func(ctx context.Context)) *UserService_FetchCurrentUser_Call

+ type UserService_GetByEmail_Call struct

+ 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

+ type UserService_GetByID_Call struct

+ 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

+ type UserService_GetByIDs_Call struct

+ 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

+ type UserService_List_Call struct

+ func (_c *UserService_List_Call) Return(_a0 user.PagedUsers, _a1 error) *UserService_List_Call

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

+ type UserService_UpdateByEmail_Call struct

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

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

+ type UserService_UpdateByID_Call struct

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

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

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL