settings

package

Go to main page

Versions in this module

v0

v0.56.1

Jan 23, 2025

v0.56.0

Jan 22, 2025

v0.55.0

Jan 13, 2025

v0.54.0

Dec 17, 2024

v0.53.0

Dec 5, 2024

Changes in this version

type MockAibiDashboardEmbeddingAccessPolicyInterface

+ func (_m *MockAibiDashboardEmbeddingAccessPolicyInterface) Delete(ctx context.Context, ...) (*settings.DeleteAibiDashboardEmbeddingAccessPolicySettingResponse, error)

+ type MockAibiDashboardEmbeddingAccessPolicyInterface_Delete_Call struct

+ func (_c *MockAibiDashboardEmbeddingAccessPolicyInterface_Delete_Call) Return(_a0 *settings.DeleteAibiDashboardEmbeddingAccessPolicySettingResponse, ...) *MockAibiDashboardEmbeddingAccessPolicyInterface_Delete_Call

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

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

type MockAibiDashboardEmbeddingAccessPolicyInterface_Expecter

+ func (_e *MockAibiDashboardEmbeddingAccessPolicyInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockAibiDashboardEmbeddingAccessPolicyInterface_Delete_Call

type MockAibiDashboardEmbeddingApprovedDomainsInterface

+ func (_m *MockAibiDashboardEmbeddingApprovedDomainsInterface) Delete(ctx context.Context, ...) (*settings.DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse, error)

+ type MockAibiDashboardEmbeddingApprovedDomainsInterface_Delete_Call struct

+ func (_c *MockAibiDashboardEmbeddingApprovedDomainsInterface_Delete_Call) Return(_a0 *settings.DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse, ...) *MockAibiDashboardEmbeddingApprovedDomainsInterface_Delete_Call

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

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

type MockAibiDashboardEmbeddingApprovedDomainsInterface_Expecter

+ func (_e *MockAibiDashboardEmbeddingApprovedDomainsInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockAibiDashboardEmbeddingApprovedDomainsInterface_Delete_Call

v0.52.0

Nov 19, 2024

v0.51.0

Nov 7, 2024

v0.50.0

Oct 31, 2024

Changes in this version

+ type MockAibiDashboardEmbeddingAccessPolicyInterface struct

+ func NewMockAibiDashboardEmbeddingAccessPolicyInterface(t interface{ ... }) *MockAibiDashboardEmbeddingAccessPolicyInterface

+ func (_m *MockAibiDashboardEmbeddingAccessPolicyInterface) EXPECT() *MockAibiDashboardEmbeddingAccessPolicyInterface_Expecter

+ func (_m *MockAibiDashboardEmbeddingAccessPolicyInterface) Get(ctx context.Context, ...) (*settings.AibiDashboardEmbeddingAccessPolicySetting, error)

+ func (_m *MockAibiDashboardEmbeddingAccessPolicyInterface) Update(ctx context.Context, ...) (*settings.AibiDashboardEmbeddingAccessPolicySetting, error)

+ type MockAibiDashboardEmbeddingAccessPolicyInterface_Expecter struct

+ func (_e *MockAibiDashboardEmbeddingAccessPolicyInterface_Expecter) Get(ctx interface{}, request interface{}) *MockAibiDashboardEmbeddingAccessPolicyInterface_Get_Call

+ func (_e *MockAibiDashboardEmbeddingAccessPolicyInterface_Expecter) Update(ctx interface{}, request interface{}) *MockAibiDashboardEmbeddingAccessPolicyInterface_Update_Call

+ type MockAibiDashboardEmbeddingAccessPolicyInterface_Get_Call struct

+ func (_c *MockAibiDashboardEmbeddingAccessPolicyInterface_Get_Call) Return(_a0 *settings.AibiDashboardEmbeddingAccessPolicySetting, _a1 error) *MockAibiDashboardEmbeddingAccessPolicyInterface_Get_Call

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

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

+ type MockAibiDashboardEmbeddingAccessPolicyInterface_Update_Call struct

+ func (_c *MockAibiDashboardEmbeddingAccessPolicyInterface_Update_Call) Return(_a0 *settings.AibiDashboardEmbeddingAccessPolicySetting, _a1 error) *MockAibiDashboardEmbeddingAccessPolicyInterface_Update_Call

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

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

+ type MockAibiDashboardEmbeddingApprovedDomainsInterface struct

+ func NewMockAibiDashboardEmbeddingApprovedDomainsInterface(t interface{ ... }) *MockAibiDashboardEmbeddingApprovedDomainsInterface

+ func (_m *MockAibiDashboardEmbeddingApprovedDomainsInterface) EXPECT() *MockAibiDashboardEmbeddingApprovedDomainsInterface_Expecter

+ func (_m *MockAibiDashboardEmbeddingApprovedDomainsInterface) Get(ctx context.Context, ...) (*settings.AibiDashboardEmbeddingApprovedDomainsSetting, error)

+ func (_m *MockAibiDashboardEmbeddingApprovedDomainsInterface) Update(ctx context.Context, ...) (*settings.AibiDashboardEmbeddingApprovedDomainsSetting, error)

+ type MockAibiDashboardEmbeddingApprovedDomainsInterface_Expecter struct

+ func (_e *MockAibiDashboardEmbeddingApprovedDomainsInterface_Expecter) Get(ctx interface{}, request interface{}) *MockAibiDashboardEmbeddingApprovedDomainsInterface_Get_Call

+ func (_e *MockAibiDashboardEmbeddingApprovedDomainsInterface_Expecter) Update(ctx interface{}, request interface{}) *MockAibiDashboardEmbeddingApprovedDomainsInterface_Update_Call

+ type MockAibiDashboardEmbeddingApprovedDomainsInterface_Get_Call struct

+ func (_c *MockAibiDashboardEmbeddingApprovedDomainsInterface_Get_Call) Return(_a0 *settings.AibiDashboardEmbeddingApprovedDomainsSetting, _a1 error) *MockAibiDashboardEmbeddingApprovedDomainsInterface_Get_Call

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

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

+ type MockAibiDashboardEmbeddingApprovedDomainsInterface_Update_Call struct

+ func (_c *MockAibiDashboardEmbeddingApprovedDomainsInterface_Update_Call) Return(_a0 *settings.AibiDashboardEmbeddingApprovedDomainsSetting, _a1 error) *MockAibiDashboardEmbeddingApprovedDomainsInterface_Update_Call

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

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

type MockSettingsInterface

+ func (_m *MockSettingsInterface) AibiDashboardEmbeddingAccessPolicy() settings.AibiDashboardEmbeddingAccessPolicyInterface

+ func (_m *MockSettingsInterface) AibiDashboardEmbeddingApprovedDomains() settings.AibiDashboardEmbeddingApprovedDomainsInterface

+ type MockSettingsInterface_AibiDashboardEmbeddingAccessPolicy_Call struct

+ func (_c *MockSettingsInterface_AibiDashboardEmbeddingAccessPolicy_Call) Return(_a0 settings.AibiDashboardEmbeddingAccessPolicyInterface) *MockSettingsInterface_AibiDashboardEmbeddingAccessPolicy_Call

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

+ func (_c *MockSettingsInterface_AibiDashboardEmbeddingAccessPolicy_Call) RunAndReturn(run func() settings.AibiDashboardEmbeddingAccessPolicyInterface) *MockSettingsInterface_AibiDashboardEmbeddingAccessPolicy_Call

+ type MockSettingsInterface_AibiDashboardEmbeddingApprovedDomains_Call struct

+ func (_c *MockSettingsInterface_AibiDashboardEmbeddingApprovedDomains_Call) Return(_a0 settings.AibiDashboardEmbeddingApprovedDomainsInterface) *MockSettingsInterface_AibiDashboardEmbeddingApprovedDomains_Call

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

+ func (_c *MockSettingsInterface_AibiDashboardEmbeddingApprovedDomains_Call) RunAndReturn(run func() settings.AibiDashboardEmbeddingApprovedDomainsInterface) *MockSettingsInterface_AibiDashboardEmbeddingApprovedDomains_Call

type MockSettingsInterface_Expecter

+ func (_e *MockSettingsInterface_Expecter) AibiDashboardEmbeddingAccessPolicy() *MockSettingsInterface_AibiDashboardEmbeddingAccessPolicy_Call

+ func (_e *MockSettingsInterface_Expecter) AibiDashboardEmbeddingApprovedDomains() *MockSettingsInterface_AibiDashboardEmbeddingApprovedDomains_Call

v0.49.0

Oct 14, 2024

Changes in this version

+ type MockDisableLegacyDbfsInterface struct

+ func NewMockDisableLegacyDbfsInterface(t interface{ ... }) *MockDisableLegacyDbfsInterface

+ func (_m *MockDisableLegacyDbfsInterface) Delete(ctx context.Context, request settings.DeleteDisableLegacyDbfsRequest) (*settings.DeleteDisableLegacyDbfsResponse, error)

+ func (_m *MockDisableLegacyDbfsInterface) EXPECT() *MockDisableLegacyDbfsInterface_Expecter

+ func (_m *MockDisableLegacyDbfsInterface) Get(ctx context.Context, request settings.GetDisableLegacyDbfsRequest) (*settings.DisableLegacyDbfs, error)

+ func (_m *MockDisableLegacyDbfsInterface) Update(ctx context.Context, request settings.UpdateDisableLegacyDbfsRequest) (*settings.DisableLegacyDbfs, error)

+ type MockDisableLegacyDbfsInterface_Delete_Call struct

+ func (_c *MockDisableLegacyDbfsInterface_Delete_Call) Return(_a0 *settings.DeleteDisableLegacyDbfsResponse, _a1 error) *MockDisableLegacyDbfsInterface_Delete_Call

+ func (_c *MockDisableLegacyDbfsInterface_Delete_Call) Run(run func(ctx context.Context, request settings.DeleteDisableLegacyDbfsRequest)) *MockDisableLegacyDbfsInterface_Delete_Call

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

+ type MockDisableLegacyDbfsInterface_Expecter struct

+ func (_e *MockDisableLegacyDbfsInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockDisableLegacyDbfsInterface_Delete_Call

+ func (_e *MockDisableLegacyDbfsInterface_Expecter) Get(ctx interface{}, request interface{}) *MockDisableLegacyDbfsInterface_Get_Call

+ func (_e *MockDisableLegacyDbfsInterface_Expecter) Update(ctx interface{}, request interface{}) *MockDisableLegacyDbfsInterface_Update_Call

+ type MockDisableLegacyDbfsInterface_Get_Call struct

+ func (_c *MockDisableLegacyDbfsInterface_Get_Call) Return(_a0 *settings.DisableLegacyDbfs, _a1 error) *MockDisableLegacyDbfsInterface_Get_Call

+ func (_c *MockDisableLegacyDbfsInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetDisableLegacyDbfsRequest)) *MockDisableLegacyDbfsInterface_Get_Call

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

+ type MockDisableLegacyDbfsInterface_Update_Call struct

+ func (_c *MockDisableLegacyDbfsInterface_Update_Call) Return(_a0 *settings.DisableLegacyDbfs, _a1 error) *MockDisableLegacyDbfsInterface_Update_Call

+ func (_c *MockDisableLegacyDbfsInterface_Update_Call) Run(run func(ctx context.Context, request settings.UpdateDisableLegacyDbfsRequest)) *MockDisableLegacyDbfsInterface_Update_Call

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

type MockSettingsInterface

+ func (_m *MockSettingsInterface) DisableLegacyDbfs() settings.DisableLegacyDbfsInterface

+ type MockSettingsInterface_DisableLegacyDbfs_Call struct

+ func (_c *MockSettingsInterface_DisableLegacyDbfs_Call) Return(_a0 settings.DisableLegacyDbfsInterface) *MockSettingsInterface_DisableLegacyDbfs_Call

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

+ func (_c *MockSettingsInterface_DisableLegacyDbfs_Call) RunAndReturn(run func() settings.DisableLegacyDbfsInterface) *MockSettingsInterface_DisableLegacyDbfs_Call

type MockSettingsInterface_Expecter

+ func (_e *MockSettingsInterface_Expecter) DisableLegacyDbfs() *MockSettingsInterface_DisableLegacyDbfs_Call

v0.48.0

Oct 3, 2024

v0.47.0

Oct 1, 2024

Changes in this version

type MockAccountSettingsInterface

+ func (_m *MockAccountSettingsInterface) DisableLegacyFeatures() settings.DisableLegacyFeaturesInterface

+ type MockAccountSettingsInterface_DisableLegacyFeatures_Call struct

+ func (_c *MockAccountSettingsInterface_DisableLegacyFeatures_Call) Return(_a0 settings.DisableLegacyFeaturesInterface) *MockAccountSettingsInterface_DisableLegacyFeatures_Call

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

+ func (_c *MockAccountSettingsInterface_DisableLegacyFeatures_Call) RunAndReturn(run func() settings.DisableLegacyFeaturesInterface) *MockAccountSettingsInterface_DisableLegacyFeatures_Call

type MockAccountSettingsInterface_Expecter

+ func (_e *MockAccountSettingsInterface_Expecter) DisableLegacyFeatures() *MockAccountSettingsInterface_DisableLegacyFeatures_Call

+ type MockDisableLegacyAccessInterface struct

+ func NewMockDisableLegacyAccessInterface(t interface{ ... }) *MockDisableLegacyAccessInterface

+ func (_m *MockDisableLegacyAccessInterface) Delete(ctx context.Context, request settings.DeleteDisableLegacyAccessRequest) (*settings.DeleteDisableLegacyAccessResponse, error)

+ func (_m *MockDisableLegacyAccessInterface) EXPECT() *MockDisableLegacyAccessInterface_Expecter

+ func (_m *MockDisableLegacyAccessInterface) Get(ctx context.Context, request settings.GetDisableLegacyAccessRequest) (*settings.DisableLegacyAccess, error)

+ func (_m *MockDisableLegacyAccessInterface) Update(ctx context.Context, request settings.UpdateDisableLegacyAccessRequest) (*settings.DisableLegacyAccess, error)

+ type MockDisableLegacyAccessInterface_Delete_Call struct

+ func (_c *MockDisableLegacyAccessInterface_Delete_Call) Return(_a0 *settings.DeleteDisableLegacyAccessResponse, _a1 error) *MockDisableLegacyAccessInterface_Delete_Call

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

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

+ type MockDisableLegacyAccessInterface_Expecter struct

+ func (_e *MockDisableLegacyAccessInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockDisableLegacyAccessInterface_Delete_Call

+ func (_e *MockDisableLegacyAccessInterface_Expecter) Get(ctx interface{}, request interface{}) *MockDisableLegacyAccessInterface_Get_Call

+ func (_e *MockDisableLegacyAccessInterface_Expecter) Update(ctx interface{}, request interface{}) *MockDisableLegacyAccessInterface_Update_Call

+ type MockDisableLegacyAccessInterface_Get_Call struct

+ func (_c *MockDisableLegacyAccessInterface_Get_Call) Return(_a0 *settings.DisableLegacyAccess, _a1 error) *MockDisableLegacyAccessInterface_Get_Call

+ func (_c *MockDisableLegacyAccessInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetDisableLegacyAccessRequest)) *MockDisableLegacyAccessInterface_Get_Call

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

+ type MockDisableLegacyAccessInterface_Update_Call struct

+ func (_c *MockDisableLegacyAccessInterface_Update_Call) Return(_a0 *settings.DisableLegacyAccess, _a1 error) *MockDisableLegacyAccessInterface_Update_Call

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

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

+ type MockDisableLegacyFeaturesInterface struct

+ func NewMockDisableLegacyFeaturesInterface(t interface{ ... }) *MockDisableLegacyFeaturesInterface

+ func (_m *MockDisableLegacyFeaturesInterface) Delete(ctx context.Context, request settings.DeleteDisableLegacyFeaturesRequest) (*settings.DeleteDisableLegacyFeaturesResponse, error)

+ func (_m *MockDisableLegacyFeaturesInterface) EXPECT() *MockDisableLegacyFeaturesInterface_Expecter

+ func (_m *MockDisableLegacyFeaturesInterface) Get(ctx context.Context, request settings.GetDisableLegacyFeaturesRequest) (*settings.DisableLegacyFeatures, error)

+ func (_m *MockDisableLegacyFeaturesInterface) Update(ctx context.Context, request settings.UpdateDisableLegacyFeaturesRequest) (*settings.DisableLegacyFeatures, error)

+ type MockDisableLegacyFeaturesInterface_Delete_Call struct

+ func (_c *MockDisableLegacyFeaturesInterface_Delete_Call) Return(_a0 *settings.DeleteDisableLegacyFeaturesResponse, _a1 error) *MockDisableLegacyFeaturesInterface_Delete_Call

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

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

+ type MockDisableLegacyFeaturesInterface_Expecter struct

+ func (_e *MockDisableLegacyFeaturesInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockDisableLegacyFeaturesInterface_Delete_Call

+ func (_e *MockDisableLegacyFeaturesInterface_Expecter) Get(ctx interface{}, request interface{}) *MockDisableLegacyFeaturesInterface_Get_Call

+ func (_e *MockDisableLegacyFeaturesInterface_Expecter) Update(ctx interface{}, request interface{}) *MockDisableLegacyFeaturesInterface_Update_Call

+ type MockDisableLegacyFeaturesInterface_Get_Call struct

+ func (_c *MockDisableLegacyFeaturesInterface_Get_Call) Return(_a0 *settings.DisableLegacyFeatures, _a1 error) *MockDisableLegacyFeaturesInterface_Get_Call

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

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

+ type MockDisableLegacyFeaturesInterface_Update_Call struct

+ func (_c *MockDisableLegacyFeaturesInterface_Update_Call) Return(_a0 *settings.DisableLegacyFeatures, _a1 error) *MockDisableLegacyFeaturesInterface_Update_Call

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

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

type MockSettingsInterface

+ func (_m *MockSettingsInterface) DisableLegacyAccess() settings.DisableLegacyAccessInterface

+ type MockSettingsInterface_DisableLegacyAccess_Call struct

+ func (_c *MockSettingsInterface_DisableLegacyAccess_Call) Return(_a0 settings.DisableLegacyAccessInterface) *MockSettingsInterface_DisableLegacyAccess_Call

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

+ func (_c *MockSettingsInterface_DisableLegacyAccess_Call) RunAndReturn(run func() settings.DisableLegacyAccessInterface) *MockSettingsInterface_DisableLegacyAccess_Call

type MockSettingsInterface_Expecter

+ func (_e *MockSettingsInterface_Expecter) DisableLegacyAccess() *MockSettingsInterface_DisableLegacyAccess_Call

v0.46.0

Sep 4, 2024

v0.45.0

Aug 21, 2024

v0.44.0

Aug 13, 2024

Changes in this version

+ type MockNotificationDestinationsInterface struct

+ func NewMockNotificationDestinationsInterface(t interface{ ... }) *MockNotificationDestinationsInterface

+ func (_m *MockNotificationDestinationsInterface) Create(ctx context.Context, request settings.CreateNotificationDestinationRequest) (*settings.NotificationDestination, error)

+ func (_m *MockNotificationDestinationsInterface) Delete(ctx context.Context, request settings.DeleteNotificationDestinationRequest) error

+ func (_m *MockNotificationDestinationsInterface) DeleteById(ctx context.Context, id string) error

+ func (_m *MockNotificationDestinationsInterface) EXPECT() *MockNotificationDestinationsInterface_Expecter

+ func (_m *MockNotificationDestinationsInterface) Get(ctx context.Context, request settings.GetNotificationDestinationRequest) (*settings.NotificationDestination, error)

+ func (_m *MockNotificationDestinationsInterface) GetById(ctx context.Context, id string) (*settings.NotificationDestination, error)

+ func (_m *MockNotificationDestinationsInterface) List(ctx context.Context, request settings.ListNotificationDestinationsRequest) listing.Iterator[settings.ListNotificationDestinationsResult]

+ func (_m *MockNotificationDestinationsInterface) ListAll(ctx context.Context, request settings.ListNotificationDestinationsRequest) ([]settings.ListNotificationDestinationsResult, error)

+ func (_m *MockNotificationDestinationsInterface) Update(ctx context.Context, request settings.UpdateNotificationDestinationRequest) (*settings.NotificationDestination, error)

+ type MockNotificationDestinationsInterface_Create_Call struct

+ func (_c *MockNotificationDestinationsInterface_Create_Call) Return(_a0 *settings.NotificationDestination, _a1 error) *MockNotificationDestinationsInterface_Create_Call

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

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

+ type MockNotificationDestinationsInterface_DeleteById_Call struct

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

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

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

+ type MockNotificationDestinationsInterface_Delete_Call struct

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

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

+ func (_c *MockNotificationDestinationsInterface_Delete_Call) RunAndReturn(run func(context.Context, settings.DeleteNotificationDestinationRequest) error) *MockNotificationDestinationsInterface_Delete_Call

+ type MockNotificationDestinationsInterface_Expecter struct

+ func (_e *MockNotificationDestinationsInterface_Expecter) Create(ctx interface{}, request interface{}) *MockNotificationDestinationsInterface_Create_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockNotificationDestinationsInterface_Delete_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) DeleteById(ctx interface{}, id interface{}) *MockNotificationDestinationsInterface_DeleteById_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) Get(ctx interface{}, request interface{}) *MockNotificationDestinationsInterface_Get_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) GetById(ctx interface{}, id interface{}) *MockNotificationDestinationsInterface_GetById_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) List(ctx interface{}, request interface{}) *MockNotificationDestinationsInterface_List_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) ListAll(ctx interface{}, request interface{}) *MockNotificationDestinationsInterface_ListAll_Call

+ func (_e *MockNotificationDestinationsInterface_Expecter) Update(ctx interface{}, request interface{}) *MockNotificationDestinationsInterface_Update_Call

+ type MockNotificationDestinationsInterface_GetById_Call struct

+ func (_c *MockNotificationDestinationsInterface_GetById_Call) Return(_a0 *settings.NotificationDestination, _a1 error) *MockNotificationDestinationsInterface_GetById_Call

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

+ func (_c *MockNotificationDestinationsInterface_GetById_Call) RunAndReturn(run func(context.Context, string) (*settings.NotificationDestination, error)) *MockNotificationDestinationsInterface_GetById_Call

+ type MockNotificationDestinationsInterface_Get_Call struct

+ func (_c *MockNotificationDestinationsInterface_Get_Call) Return(_a0 *settings.NotificationDestination, _a1 error) *MockNotificationDestinationsInterface_Get_Call

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

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

+ type MockNotificationDestinationsInterface_ListAll_Call struct

+ func (_c *MockNotificationDestinationsInterface_ListAll_Call) Return(_a0 []settings.ListNotificationDestinationsResult, _a1 error) *MockNotificationDestinationsInterface_ListAll_Call

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

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

+ type MockNotificationDestinationsInterface_List_Call struct

+ func (_c *MockNotificationDestinationsInterface_List_Call) Return(_a0 listing.Iterator[settings.ListNotificationDestinationsResult]) *MockNotificationDestinationsInterface_List_Call

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

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

+ type MockNotificationDestinationsInterface_Update_Call struct

+ func (_c *MockNotificationDestinationsInterface_Update_Call) Return(_a0 *settings.NotificationDestination, _a1 error) *MockNotificationDestinationsInterface_Update_Call

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

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

v0.43.2

Jul 9, 2024

v0.43.1

Jul 8, 2024

v0.43.0

Jun 24, 2024

v0.42.0

Jun 3, 2024

v0.41.0

May 21, 2024

v0.40.1

May 14, 2024

v0.40.0

May 2, 2024

Changes in this version

+ type MockComplianceSecurityProfileInterface struct

+ func NewMockComplianceSecurityProfileInterface(t interface{ ... }) *MockComplianceSecurityProfileInterface

+ func (_m *MockComplianceSecurityProfileInterface) EXPECT() *MockComplianceSecurityProfileInterface_Expecter

+ func (_m *MockComplianceSecurityProfileInterface) Get(ctx context.Context, ...) (*settings.ComplianceSecurityProfileSetting, error)

+ func (_m *MockComplianceSecurityProfileInterface) Impl() settings.ComplianceSecurityProfileService

+ func (_m *MockComplianceSecurityProfileInterface) Update(ctx context.Context, ...) (*settings.ComplianceSecurityProfileSetting, error)

+ func (_m *MockComplianceSecurityProfileInterface) WithImpl(impl settings.ComplianceSecurityProfileService) settings.ComplianceSecurityProfileInterface

+ type MockComplianceSecurityProfileInterface_Expecter struct

+ func (_e *MockComplianceSecurityProfileInterface_Expecter) Get(ctx interface{}, request interface{}) *MockComplianceSecurityProfileInterface_Get_Call

+ func (_e *MockComplianceSecurityProfileInterface_Expecter) Impl() *MockComplianceSecurityProfileInterface_Impl_Call

+ func (_e *MockComplianceSecurityProfileInterface_Expecter) Update(ctx interface{}, request interface{}) *MockComplianceSecurityProfileInterface_Update_Call

+ func (_e *MockComplianceSecurityProfileInterface_Expecter) WithImpl(impl interface{}) *MockComplianceSecurityProfileInterface_WithImpl_Call

+ type MockComplianceSecurityProfileInterface_Get_Call struct

+ func (_c *MockComplianceSecurityProfileInterface_Get_Call) Return(_a0 *settings.ComplianceSecurityProfileSetting, _a1 error) *MockComplianceSecurityProfileInterface_Get_Call

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

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

+ type MockComplianceSecurityProfileInterface_Impl_Call struct

+ func (_c *MockComplianceSecurityProfileInterface_Impl_Call) Return(_a0 settings.ComplianceSecurityProfileService) *MockComplianceSecurityProfileInterface_Impl_Call

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

+ func (_c *MockComplianceSecurityProfileInterface_Impl_Call) RunAndReturn(run func() settings.ComplianceSecurityProfileService) *MockComplianceSecurityProfileInterface_Impl_Call

+ type MockComplianceSecurityProfileInterface_Update_Call struct

+ func (_c *MockComplianceSecurityProfileInterface_Update_Call) Return(_a0 *settings.ComplianceSecurityProfileSetting, _a1 error) *MockComplianceSecurityProfileInterface_Update_Call

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

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

+ type MockComplianceSecurityProfileInterface_WithImpl_Call struct

+ func (_c *MockComplianceSecurityProfileInterface_WithImpl_Call) Return(_a0 settings.ComplianceSecurityProfileInterface) *MockComplianceSecurityProfileInterface_WithImpl_Call

+ func (_c *MockComplianceSecurityProfileInterface_WithImpl_Call) Run(run func(impl settings.ComplianceSecurityProfileService)) *MockComplianceSecurityProfileInterface_WithImpl_Call

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

+ type MockEnhancedSecurityMonitoringInterface struct

+ func NewMockEnhancedSecurityMonitoringInterface(t interface{ ... }) *MockEnhancedSecurityMonitoringInterface

+ func (_m *MockEnhancedSecurityMonitoringInterface) EXPECT() *MockEnhancedSecurityMonitoringInterface_Expecter

+ func (_m *MockEnhancedSecurityMonitoringInterface) Get(ctx context.Context, ...) (*settings.EnhancedSecurityMonitoringSetting, error)

+ func (_m *MockEnhancedSecurityMonitoringInterface) Impl() settings.EnhancedSecurityMonitoringService

+ func (_m *MockEnhancedSecurityMonitoringInterface) Update(ctx context.Context, ...) (*settings.EnhancedSecurityMonitoringSetting, error)

+ func (_m *MockEnhancedSecurityMonitoringInterface) WithImpl(impl settings.EnhancedSecurityMonitoringService) settings.EnhancedSecurityMonitoringInterface

+ type MockEnhancedSecurityMonitoringInterface_Expecter struct

+ func (_e *MockEnhancedSecurityMonitoringInterface_Expecter) Get(ctx interface{}, request interface{}) *MockEnhancedSecurityMonitoringInterface_Get_Call

+ func (_e *MockEnhancedSecurityMonitoringInterface_Expecter) Impl() *MockEnhancedSecurityMonitoringInterface_Impl_Call

+ func (_e *MockEnhancedSecurityMonitoringInterface_Expecter) Update(ctx interface{}, request interface{}) *MockEnhancedSecurityMonitoringInterface_Update_Call

+ func (_e *MockEnhancedSecurityMonitoringInterface_Expecter) WithImpl(impl interface{}) *MockEnhancedSecurityMonitoringInterface_WithImpl_Call

+ type MockEnhancedSecurityMonitoringInterface_Get_Call struct

+ func (_c *MockEnhancedSecurityMonitoringInterface_Get_Call) Return(_a0 *settings.EnhancedSecurityMonitoringSetting, _a1 error) *MockEnhancedSecurityMonitoringInterface_Get_Call

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

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

+ type MockEnhancedSecurityMonitoringInterface_Impl_Call struct

+ func (_c *MockEnhancedSecurityMonitoringInterface_Impl_Call) Return(_a0 settings.EnhancedSecurityMonitoringService) *MockEnhancedSecurityMonitoringInterface_Impl_Call

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

+ func (_c *MockEnhancedSecurityMonitoringInterface_Impl_Call) RunAndReturn(run func() settings.EnhancedSecurityMonitoringService) *MockEnhancedSecurityMonitoringInterface_Impl_Call

+ type MockEnhancedSecurityMonitoringInterface_Update_Call struct

+ func (_c *MockEnhancedSecurityMonitoringInterface_Update_Call) Return(_a0 *settings.EnhancedSecurityMonitoringSetting, _a1 error) *MockEnhancedSecurityMonitoringInterface_Update_Call

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

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

+ type MockEnhancedSecurityMonitoringInterface_WithImpl_Call struct

+ func (_c *MockEnhancedSecurityMonitoringInterface_WithImpl_Call) Return(_a0 settings.EnhancedSecurityMonitoringInterface) *MockEnhancedSecurityMonitoringInterface_WithImpl_Call

+ func (_c *MockEnhancedSecurityMonitoringInterface_WithImpl_Call) Run(run func(impl settings.EnhancedSecurityMonitoringService)) *MockEnhancedSecurityMonitoringInterface_WithImpl_Call

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

type MockSettingsInterface

+ func (_m *MockSettingsInterface) ComplianceSecurityProfile() settings.ComplianceSecurityProfileInterface

+ func (_m *MockSettingsInterface) EnhancedSecurityMonitoring() settings.EnhancedSecurityMonitoringInterface

+ type MockSettingsInterface_ComplianceSecurityProfile_Call struct

+ func (_c *MockSettingsInterface_ComplianceSecurityProfile_Call) Return(_a0 settings.ComplianceSecurityProfileInterface) *MockSettingsInterface_ComplianceSecurityProfile_Call

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

+ func (_c *MockSettingsInterface_ComplianceSecurityProfile_Call) RunAndReturn(run func() settings.ComplianceSecurityProfileInterface) *MockSettingsInterface_ComplianceSecurityProfile_Call

+ type MockSettingsInterface_EnhancedSecurityMonitoring_Call struct

+ func (_c *MockSettingsInterface_EnhancedSecurityMonitoring_Call) Return(_a0 settings.EnhancedSecurityMonitoringInterface) *MockSettingsInterface_EnhancedSecurityMonitoring_Call

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

+ func (_c *MockSettingsInterface_EnhancedSecurityMonitoring_Call) RunAndReturn(run func() settings.EnhancedSecurityMonitoringInterface) *MockSettingsInterface_EnhancedSecurityMonitoring_Call

type MockSettingsInterface_Expecter

+ func (_e *MockSettingsInterface_Expecter) ComplianceSecurityProfile() *MockSettingsInterface_ComplianceSecurityProfile_Call

+ func (_e *MockSettingsInterface_Expecter) EnhancedSecurityMonitoring() *MockSettingsInterface_EnhancedSecurityMonitoring_Call

v0.39.0

Apr 24, 2024

v0.38.0

Apr 11, 2024

v0.37.0

Mar 28, 2024

v0.36.0

Mar 20, 2024

v0.35.0

Mar 20, 2024

v0.34.0

Mar 5, 2024

Changes in this version

type MockAccountSettingsInterface

+ func (_m *MockAccountSettingsInterface) CspEnablementAccount() settings.CspEnablementAccountInterface

+ func (_m *MockAccountSettingsInterface) EsmEnablementAccount() settings.EsmEnablementAccountInterface

+ func (_m *MockAccountSettingsInterface) PersonalCompute() settings.PersonalComputeInterface

+ type MockAccountSettingsInterface_CspEnablementAccount_Call struct

+ func (_c *MockAccountSettingsInterface_CspEnablementAccount_Call) Return(_a0 settings.CspEnablementAccountInterface) *MockAccountSettingsInterface_CspEnablementAccount_Call

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

+ func (_c *MockAccountSettingsInterface_CspEnablementAccount_Call) RunAndReturn(run func() settings.CspEnablementAccountInterface) *MockAccountSettingsInterface_CspEnablementAccount_Call

+ type MockAccountSettingsInterface_EsmEnablementAccount_Call struct

+ func (_c *MockAccountSettingsInterface_EsmEnablementAccount_Call) Return(_a0 settings.EsmEnablementAccountInterface) *MockAccountSettingsInterface_EsmEnablementAccount_Call

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

+ func (_c *MockAccountSettingsInterface_EsmEnablementAccount_Call) RunAndReturn(run func() settings.EsmEnablementAccountInterface) *MockAccountSettingsInterface_EsmEnablementAccount_Call

type MockAccountSettingsInterface_Expecter

+ func (_e *MockAccountSettingsInterface_Expecter) CspEnablementAccount() *MockAccountSettingsInterface_CspEnablementAccount_Call

+ func (_e *MockAccountSettingsInterface_Expecter) EsmEnablementAccount() *MockAccountSettingsInterface_EsmEnablementAccount_Call

+ func (_e *MockAccountSettingsInterface_Expecter) PersonalCompute() *MockAccountSettingsInterface_PersonalCompute_Call

+ type MockAccountSettingsInterface_PersonalCompute_Call struct

+ func (_c *MockAccountSettingsInterface_PersonalCompute_Call) Return(_a0 settings.PersonalComputeInterface) *MockAccountSettingsInterface_PersonalCompute_Call

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

+ func (_c *MockAccountSettingsInterface_PersonalCompute_Call) RunAndReturn(run func() settings.PersonalComputeInterface) *MockAccountSettingsInterface_PersonalCompute_Call

+ type MockAutomaticClusterUpdateInterface struct

+ func NewMockAutomaticClusterUpdateInterface(t interface{ ... }) *MockAutomaticClusterUpdateInterface

+ func (_m *MockAutomaticClusterUpdateInterface) EXPECT() *MockAutomaticClusterUpdateInterface_Expecter

+ func (_m *MockAutomaticClusterUpdateInterface) Get(ctx context.Context, request settings.GetAutomaticClusterUpdateRequest) (*settings.AutomaticClusterUpdateSetting, error)

+ func (_m *MockAutomaticClusterUpdateInterface) Impl() settings.AutomaticClusterUpdateService

+ func (_m *MockAutomaticClusterUpdateInterface) Update(ctx context.Context, ...) (*settings.AutomaticClusterUpdateSetting, error)

+ func (_m *MockAutomaticClusterUpdateInterface) WithImpl(impl settings.AutomaticClusterUpdateService) settings.AutomaticClusterUpdateInterface

+ type MockAutomaticClusterUpdateInterface_Expecter struct

+ func (_e *MockAutomaticClusterUpdateInterface_Expecter) Get(ctx interface{}, request interface{}) *MockAutomaticClusterUpdateInterface_Get_Call

+ func (_e *MockAutomaticClusterUpdateInterface_Expecter) Impl() *MockAutomaticClusterUpdateInterface_Impl_Call

+ func (_e *MockAutomaticClusterUpdateInterface_Expecter) Update(ctx interface{}, request interface{}) *MockAutomaticClusterUpdateInterface_Update_Call

+ func (_e *MockAutomaticClusterUpdateInterface_Expecter) WithImpl(impl interface{}) *MockAutomaticClusterUpdateInterface_WithImpl_Call

+ type MockAutomaticClusterUpdateInterface_Get_Call struct

+ func (_c *MockAutomaticClusterUpdateInterface_Get_Call) Return(_a0 *settings.AutomaticClusterUpdateSetting, _a1 error) *MockAutomaticClusterUpdateInterface_Get_Call

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

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

+ type MockAutomaticClusterUpdateInterface_Impl_Call struct

+ func (_c *MockAutomaticClusterUpdateInterface_Impl_Call) Return(_a0 settings.AutomaticClusterUpdateService) *MockAutomaticClusterUpdateInterface_Impl_Call

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

+ func (_c *MockAutomaticClusterUpdateInterface_Impl_Call) RunAndReturn(run func() settings.AutomaticClusterUpdateService) *MockAutomaticClusterUpdateInterface_Impl_Call

+ type MockAutomaticClusterUpdateInterface_Update_Call struct

+ func (_c *MockAutomaticClusterUpdateInterface_Update_Call) Return(_a0 *settings.AutomaticClusterUpdateSetting, _a1 error) *MockAutomaticClusterUpdateInterface_Update_Call

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

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

+ type MockAutomaticClusterUpdateInterface_WithImpl_Call struct

+ func (_c *MockAutomaticClusterUpdateInterface_WithImpl_Call) Return(_a0 settings.AutomaticClusterUpdateInterface) *MockAutomaticClusterUpdateInterface_WithImpl_Call

+ func (_c *MockAutomaticClusterUpdateInterface_WithImpl_Call) Run(run func(impl settings.AutomaticClusterUpdateService)) *MockAutomaticClusterUpdateInterface_WithImpl_Call

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

+ type MockCspEnablementAccountInterface struct

+ func NewMockCspEnablementAccountInterface(t interface{ ... }) *MockCspEnablementAccountInterface

+ func (_m *MockCspEnablementAccountInterface) EXPECT() *MockCspEnablementAccountInterface_Expecter

+ func (_m *MockCspEnablementAccountInterface) Get(ctx context.Context, request settings.GetCspEnablementAccountRequest) (*settings.CspEnablementAccountSetting, error)

+ func (_m *MockCspEnablementAccountInterface) Impl() settings.CspEnablementAccountService

+ func (_m *MockCspEnablementAccountInterface) Update(ctx context.Context, request settings.UpdateCspEnablementAccountSettingRequest) (*settings.CspEnablementAccountSetting, error)

+ func (_m *MockCspEnablementAccountInterface) WithImpl(impl settings.CspEnablementAccountService) settings.CspEnablementAccountInterface

+ type MockCspEnablementAccountInterface_Expecter struct

+ func (_e *MockCspEnablementAccountInterface_Expecter) Get(ctx interface{}, request interface{}) *MockCspEnablementAccountInterface_Get_Call

+ func (_e *MockCspEnablementAccountInterface_Expecter) Impl() *MockCspEnablementAccountInterface_Impl_Call

+ func (_e *MockCspEnablementAccountInterface_Expecter) Update(ctx interface{}, request interface{}) *MockCspEnablementAccountInterface_Update_Call

+ func (_e *MockCspEnablementAccountInterface_Expecter) WithImpl(impl interface{}) *MockCspEnablementAccountInterface_WithImpl_Call

+ type MockCspEnablementAccountInterface_Get_Call struct

+ func (_c *MockCspEnablementAccountInterface_Get_Call) Return(_a0 *settings.CspEnablementAccountSetting, _a1 error) *MockCspEnablementAccountInterface_Get_Call

+ func (_c *MockCspEnablementAccountInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetCspEnablementAccountRequest)) *MockCspEnablementAccountInterface_Get_Call

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

+ type MockCspEnablementAccountInterface_Impl_Call struct

+ func (_c *MockCspEnablementAccountInterface_Impl_Call) Return(_a0 settings.CspEnablementAccountService) *MockCspEnablementAccountInterface_Impl_Call

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

+ func (_c *MockCspEnablementAccountInterface_Impl_Call) RunAndReturn(run func() settings.CspEnablementAccountService) *MockCspEnablementAccountInterface_Impl_Call

+ type MockCspEnablementAccountInterface_Update_Call struct

+ func (_c *MockCspEnablementAccountInterface_Update_Call) Return(_a0 *settings.CspEnablementAccountSetting, _a1 error) *MockCspEnablementAccountInterface_Update_Call

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

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

+ type MockCspEnablementAccountInterface_WithImpl_Call struct

+ func (_c *MockCspEnablementAccountInterface_WithImpl_Call) Return(_a0 settings.CspEnablementAccountInterface) *MockCspEnablementAccountInterface_WithImpl_Call

+ func (_c *MockCspEnablementAccountInterface_WithImpl_Call) Run(run func(impl settings.CspEnablementAccountService)) *MockCspEnablementAccountInterface_WithImpl_Call

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

+ type MockCspEnablementInterface struct

+ func NewMockCspEnablementInterface(t interface{ ... }) *MockCspEnablementInterface

+ func (_m *MockCspEnablementInterface) EXPECT() *MockCspEnablementInterface_Expecter

+ func (_m *MockCspEnablementInterface) Get(ctx context.Context, request settings.GetCspEnablementRequest) (*settings.CspEnablementSetting, error)

+ func (_m *MockCspEnablementInterface) Impl() settings.CspEnablementService

+ func (_m *MockCspEnablementInterface) Update(ctx context.Context, request settings.UpdateCspEnablementSettingRequest) (*settings.CspEnablementSetting, error)

+ func (_m *MockCspEnablementInterface) WithImpl(impl settings.CspEnablementService) settings.CspEnablementInterface

+ type MockCspEnablementInterface_Expecter struct

+ func (_e *MockCspEnablementInterface_Expecter) Get(ctx interface{}, request interface{}) *MockCspEnablementInterface_Get_Call

+ func (_e *MockCspEnablementInterface_Expecter) Impl() *MockCspEnablementInterface_Impl_Call

+ func (_e *MockCspEnablementInterface_Expecter) Update(ctx interface{}, request interface{}) *MockCspEnablementInterface_Update_Call

+ func (_e *MockCspEnablementInterface_Expecter) WithImpl(impl interface{}) *MockCspEnablementInterface_WithImpl_Call

+ type MockCspEnablementInterface_Get_Call struct

+ func (_c *MockCspEnablementInterface_Get_Call) Return(_a0 *settings.CspEnablementSetting, _a1 error) *MockCspEnablementInterface_Get_Call

+ func (_c *MockCspEnablementInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetCspEnablementRequest)) *MockCspEnablementInterface_Get_Call

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

+ type MockCspEnablementInterface_Impl_Call struct

+ func (_c *MockCspEnablementInterface_Impl_Call) Return(_a0 settings.CspEnablementService) *MockCspEnablementInterface_Impl_Call

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

+ func (_c *MockCspEnablementInterface_Impl_Call) RunAndReturn(run func() settings.CspEnablementService) *MockCspEnablementInterface_Impl_Call

+ type MockCspEnablementInterface_Update_Call struct

+ func (_c *MockCspEnablementInterface_Update_Call) Return(_a0 *settings.CspEnablementSetting, _a1 error) *MockCspEnablementInterface_Update_Call

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

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

+ type MockCspEnablementInterface_WithImpl_Call struct

+ func (_c *MockCspEnablementInterface_WithImpl_Call) Return(_a0 settings.CspEnablementInterface) *MockCspEnablementInterface_WithImpl_Call

+ func (_c *MockCspEnablementInterface_WithImpl_Call) Run(run func(impl settings.CspEnablementService)) *MockCspEnablementInterface_WithImpl_Call

+ func (_c *MockCspEnablementInterface_WithImpl_Call) RunAndReturn(run func(settings.CspEnablementService) settings.CspEnablementInterface) *MockCspEnablementInterface_WithImpl_Call

+ type MockDefaultNamespaceInterface struct

+ func NewMockDefaultNamespaceInterface(t interface{ ... }) *MockDefaultNamespaceInterface

+ func (_m *MockDefaultNamespaceInterface) Delete(ctx context.Context, request settings.DeleteDefaultNamespaceRequest) (*settings.DeleteDefaultNamespaceSettingResponse, error)

+ func (_m *MockDefaultNamespaceInterface) EXPECT() *MockDefaultNamespaceInterface_Expecter

+ func (_m *MockDefaultNamespaceInterface) Get(ctx context.Context, request settings.GetDefaultNamespaceRequest) (*settings.DefaultNamespaceSetting, error)

+ func (_m *MockDefaultNamespaceInterface) Impl() settings.DefaultNamespaceService

+ func (_m *MockDefaultNamespaceInterface) Update(ctx context.Context, request settings.UpdateDefaultNamespaceSettingRequest) (*settings.DefaultNamespaceSetting, error)

+ func (_m *MockDefaultNamespaceInterface) WithImpl(impl settings.DefaultNamespaceService) settings.DefaultNamespaceInterface

+ type MockDefaultNamespaceInterface_Delete_Call struct

+ func (_c *MockDefaultNamespaceInterface_Delete_Call) Return(_a0 *settings.DeleteDefaultNamespaceSettingResponse, _a1 error) *MockDefaultNamespaceInterface_Delete_Call

+ func (_c *MockDefaultNamespaceInterface_Delete_Call) Run(run func(ctx context.Context, request settings.DeleteDefaultNamespaceRequest)) *MockDefaultNamespaceInterface_Delete_Call

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

+ type MockDefaultNamespaceInterface_Expecter struct

+ func (_e *MockDefaultNamespaceInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockDefaultNamespaceInterface_Delete_Call

+ func (_e *MockDefaultNamespaceInterface_Expecter) Get(ctx interface{}, request interface{}) *MockDefaultNamespaceInterface_Get_Call

+ func (_e *MockDefaultNamespaceInterface_Expecter) Impl() *MockDefaultNamespaceInterface_Impl_Call

+ func (_e *MockDefaultNamespaceInterface_Expecter) Update(ctx interface{}, request interface{}) *MockDefaultNamespaceInterface_Update_Call

+ func (_e *MockDefaultNamespaceInterface_Expecter) WithImpl(impl interface{}) *MockDefaultNamespaceInterface_WithImpl_Call

+ type MockDefaultNamespaceInterface_Get_Call struct

+ func (_c *MockDefaultNamespaceInterface_Get_Call) Return(_a0 *settings.DefaultNamespaceSetting, _a1 error) *MockDefaultNamespaceInterface_Get_Call

+ func (_c *MockDefaultNamespaceInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetDefaultNamespaceRequest)) *MockDefaultNamespaceInterface_Get_Call

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

+ type MockDefaultNamespaceInterface_Impl_Call struct

+ func (_c *MockDefaultNamespaceInterface_Impl_Call) Return(_a0 settings.DefaultNamespaceService) *MockDefaultNamespaceInterface_Impl_Call

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

+ func (_c *MockDefaultNamespaceInterface_Impl_Call) RunAndReturn(run func() settings.DefaultNamespaceService) *MockDefaultNamespaceInterface_Impl_Call

+ type MockDefaultNamespaceInterface_Update_Call struct

+ func (_c *MockDefaultNamespaceInterface_Update_Call) Return(_a0 *settings.DefaultNamespaceSetting, _a1 error) *MockDefaultNamespaceInterface_Update_Call

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

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

+ type MockDefaultNamespaceInterface_WithImpl_Call struct

+ func (_c *MockDefaultNamespaceInterface_WithImpl_Call) Return(_a0 settings.DefaultNamespaceInterface) *MockDefaultNamespaceInterface_WithImpl_Call

+ func (_c *MockDefaultNamespaceInterface_WithImpl_Call) Run(run func(impl settings.DefaultNamespaceService)) *MockDefaultNamespaceInterface_WithImpl_Call

+ func (_c *MockDefaultNamespaceInterface_WithImpl_Call) RunAndReturn(run func(settings.DefaultNamespaceService) settings.DefaultNamespaceInterface) *MockDefaultNamespaceInterface_WithImpl_Call

+ type MockEsmEnablementAccountInterface struct

+ func NewMockEsmEnablementAccountInterface(t interface{ ... }) *MockEsmEnablementAccountInterface

+ func (_m *MockEsmEnablementAccountInterface) EXPECT() *MockEsmEnablementAccountInterface_Expecter

+ func (_m *MockEsmEnablementAccountInterface) Get(ctx context.Context, request settings.GetEsmEnablementAccountRequest) (*settings.EsmEnablementAccountSetting, error)

+ func (_m *MockEsmEnablementAccountInterface) Impl() settings.EsmEnablementAccountService

+ func (_m *MockEsmEnablementAccountInterface) Update(ctx context.Context, request settings.UpdateEsmEnablementAccountSettingRequest) (*settings.EsmEnablementAccountSetting, error)

+ func (_m *MockEsmEnablementAccountInterface) WithImpl(impl settings.EsmEnablementAccountService) settings.EsmEnablementAccountInterface

+ type MockEsmEnablementAccountInterface_Expecter struct

+ func (_e *MockEsmEnablementAccountInterface_Expecter) Get(ctx interface{}, request interface{}) *MockEsmEnablementAccountInterface_Get_Call

+ func (_e *MockEsmEnablementAccountInterface_Expecter) Impl() *MockEsmEnablementAccountInterface_Impl_Call

+ func (_e *MockEsmEnablementAccountInterface_Expecter) Update(ctx interface{}, request interface{}) *MockEsmEnablementAccountInterface_Update_Call

+ func (_e *MockEsmEnablementAccountInterface_Expecter) WithImpl(impl interface{}) *MockEsmEnablementAccountInterface_WithImpl_Call

+ type MockEsmEnablementAccountInterface_Get_Call struct

+ func (_c *MockEsmEnablementAccountInterface_Get_Call) Return(_a0 *settings.EsmEnablementAccountSetting, _a1 error) *MockEsmEnablementAccountInterface_Get_Call

+ func (_c *MockEsmEnablementAccountInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetEsmEnablementAccountRequest)) *MockEsmEnablementAccountInterface_Get_Call

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

+ type MockEsmEnablementAccountInterface_Impl_Call struct

+ func (_c *MockEsmEnablementAccountInterface_Impl_Call) Return(_a0 settings.EsmEnablementAccountService) *MockEsmEnablementAccountInterface_Impl_Call

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

+ func (_c *MockEsmEnablementAccountInterface_Impl_Call) RunAndReturn(run func() settings.EsmEnablementAccountService) *MockEsmEnablementAccountInterface_Impl_Call

+ type MockEsmEnablementAccountInterface_Update_Call struct

+ func (_c *MockEsmEnablementAccountInterface_Update_Call) Return(_a0 *settings.EsmEnablementAccountSetting, _a1 error) *MockEsmEnablementAccountInterface_Update_Call

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

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

+ type MockEsmEnablementAccountInterface_WithImpl_Call struct

+ func (_c *MockEsmEnablementAccountInterface_WithImpl_Call) Return(_a0 settings.EsmEnablementAccountInterface) *MockEsmEnablementAccountInterface_WithImpl_Call

+ func (_c *MockEsmEnablementAccountInterface_WithImpl_Call) Run(run func(impl settings.EsmEnablementAccountService)) *MockEsmEnablementAccountInterface_WithImpl_Call

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

+ type MockEsmEnablementInterface struct

+ func NewMockEsmEnablementInterface(t interface{ ... }) *MockEsmEnablementInterface

+ func (_m *MockEsmEnablementInterface) EXPECT() *MockEsmEnablementInterface_Expecter

+ func (_m *MockEsmEnablementInterface) Get(ctx context.Context, request settings.GetEsmEnablementRequest) (*settings.EsmEnablementSetting, error)

+ func (_m *MockEsmEnablementInterface) Impl() settings.EsmEnablementService

+ func (_m *MockEsmEnablementInterface) Update(ctx context.Context, request settings.UpdateEsmEnablementSettingRequest) (*settings.EsmEnablementSetting, error)

+ func (_m *MockEsmEnablementInterface) WithImpl(impl settings.EsmEnablementService) settings.EsmEnablementInterface

+ type MockEsmEnablementInterface_Expecter struct

+ func (_e *MockEsmEnablementInterface_Expecter) Get(ctx interface{}, request interface{}) *MockEsmEnablementInterface_Get_Call

+ func (_e *MockEsmEnablementInterface_Expecter) Impl() *MockEsmEnablementInterface_Impl_Call

+ func (_e *MockEsmEnablementInterface_Expecter) Update(ctx interface{}, request interface{}) *MockEsmEnablementInterface_Update_Call

+ func (_e *MockEsmEnablementInterface_Expecter) WithImpl(impl interface{}) *MockEsmEnablementInterface_WithImpl_Call

+ type MockEsmEnablementInterface_Get_Call struct

+ func (_c *MockEsmEnablementInterface_Get_Call) Return(_a0 *settings.EsmEnablementSetting, _a1 error) *MockEsmEnablementInterface_Get_Call

+ func (_c *MockEsmEnablementInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetEsmEnablementRequest)) *MockEsmEnablementInterface_Get_Call

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

+ type MockEsmEnablementInterface_Impl_Call struct

+ func (_c *MockEsmEnablementInterface_Impl_Call) Return(_a0 settings.EsmEnablementService) *MockEsmEnablementInterface_Impl_Call

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

+ func (_c *MockEsmEnablementInterface_Impl_Call) RunAndReturn(run func() settings.EsmEnablementService) *MockEsmEnablementInterface_Impl_Call

+ type MockEsmEnablementInterface_Update_Call struct

+ func (_c *MockEsmEnablementInterface_Update_Call) Return(_a0 *settings.EsmEnablementSetting, _a1 error) *MockEsmEnablementInterface_Update_Call

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

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

+ type MockEsmEnablementInterface_WithImpl_Call struct

+ func (_c *MockEsmEnablementInterface_WithImpl_Call) Return(_a0 settings.EsmEnablementInterface) *MockEsmEnablementInterface_WithImpl_Call

+ func (_c *MockEsmEnablementInterface_WithImpl_Call) Run(run func(impl settings.EsmEnablementService)) *MockEsmEnablementInterface_WithImpl_Call

+ func (_c *MockEsmEnablementInterface_WithImpl_Call) RunAndReturn(run func(settings.EsmEnablementService) settings.EsmEnablementInterface) *MockEsmEnablementInterface_WithImpl_Call

+ type MockPersonalComputeInterface struct

+ func NewMockPersonalComputeInterface(t interface{ ... }) *MockPersonalComputeInterface

+ func (_m *MockPersonalComputeInterface) Delete(ctx context.Context, request settings.DeletePersonalComputeRequest) (*settings.DeletePersonalComputeSettingResponse, error)

+ func (_m *MockPersonalComputeInterface) EXPECT() *MockPersonalComputeInterface_Expecter

+ func (_m *MockPersonalComputeInterface) Get(ctx context.Context, request settings.GetPersonalComputeRequest) (*settings.PersonalComputeSetting, error)

+ func (_m *MockPersonalComputeInterface) Impl() settings.PersonalComputeService

+ func (_m *MockPersonalComputeInterface) Update(ctx context.Context, request settings.UpdatePersonalComputeSettingRequest) (*settings.PersonalComputeSetting, error)

+ func (_m *MockPersonalComputeInterface) WithImpl(impl settings.PersonalComputeService) settings.PersonalComputeInterface

+ type MockPersonalComputeInterface_Delete_Call struct

+ func (_c *MockPersonalComputeInterface_Delete_Call) Return(_a0 *settings.DeletePersonalComputeSettingResponse, _a1 error) *MockPersonalComputeInterface_Delete_Call

+ func (_c *MockPersonalComputeInterface_Delete_Call) Run(run func(ctx context.Context, request settings.DeletePersonalComputeRequest)) *MockPersonalComputeInterface_Delete_Call

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

+ type MockPersonalComputeInterface_Expecter struct

+ func (_e *MockPersonalComputeInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockPersonalComputeInterface_Delete_Call

+ func (_e *MockPersonalComputeInterface_Expecter) Get(ctx interface{}, request interface{}) *MockPersonalComputeInterface_Get_Call

+ func (_e *MockPersonalComputeInterface_Expecter) Impl() *MockPersonalComputeInterface_Impl_Call

+ func (_e *MockPersonalComputeInterface_Expecter) Update(ctx interface{}, request interface{}) *MockPersonalComputeInterface_Update_Call

+ func (_e *MockPersonalComputeInterface_Expecter) WithImpl(impl interface{}) *MockPersonalComputeInterface_WithImpl_Call

+ type MockPersonalComputeInterface_Get_Call struct

+ func (_c *MockPersonalComputeInterface_Get_Call) Return(_a0 *settings.PersonalComputeSetting, _a1 error) *MockPersonalComputeInterface_Get_Call

+ func (_c *MockPersonalComputeInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetPersonalComputeRequest)) *MockPersonalComputeInterface_Get_Call

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

+ type MockPersonalComputeInterface_Impl_Call struct

+ func (_c *MockPersonalComputeInterface_Impl_Call) Return(_a0 settings.PersonalComputeService) *MockPersonalComputeInterface_Impl_Call

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

+ func (_c *MockPersonalComputeInterface_Impl_Call) RunAndReturn(run func() settings.PersonalComputeService) *MockPersonalComputeInterface_Impl_Call

+ type MockPersonalComputeInterface_Update_Call struct

+ func (_c *MockPersonalComputeInterface_Update_Call) Return(_a0 *settings.PersonalComputeSetting, _a1 error) *MockPersonalComputeInterface_Update_Call

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

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

+ type MockPersonalComputeInterface_WithImpl_Call struct

+ func (_c *MockPersonalComputeInterface_WithImpl_Call) Return(_a0 settings.PersonalComputeInterface) *MockPersonalComputeInterface_WithImpl_Call

+ func (_c *MockPersonalComputeInterface_WithImpl_Call) Run(run func(impl settings.PersonalComputeService)) *MockPersonalComputeInterface_WithImpl_Call

+ func (_c *MockPersonalComputeInterface_WithImpl_Call) RunAndReturn(run func(settings.PersonalComputeService) settings.PersonalComputeInterface) *MockPersonalComputeInterface_WithImpl_Call

+ type MockRestrictWorkspaceAdminsInterface struct

+ func NewMockRestrictWorkspaceAdminsInterface(t interface{ ... }) *MockRestrictWorkspaceAdminsInterface

+ func (_m *MockRestrictWorkspaceAdminsInterface) Delete(ctx context.Context, request settings.DeleteRestrictWorkspaceAdminRequest) (*settings.DeleteRestrictWorkspaceAdminsSettingResponse, error)

+ func (_m *MockRestrictWorkspaceAdminsInterface) EXPECT() *MockRestrictWorkspaceAdminsInterface_Expecter

+ func (_m *MockRestrictWorkspaceAdminsInterface) Get(ctx context.Context, request settings.GetRestrictWorkspaceAdminRequest) (*settings.RestrictWorkspaceAdminsSetting, error)

+ func (_m *MockRestrictWorkspaceAdminsInterface) Impl() settings.RestrictWorkspaceAdminsService

+ func (_m *MockRestrictWorkspaceAdminsInterface) Update(ctx context.Context, ...) (*settings.RestrictWorkspaceAdminsSetting, error)

+ func (_m *MockRestrictWorkspaceAdminsInterface) WithImpl(impl settings.RestrictWorkspaceAdminsService) settings.RestrictWorkspaceAdminsInterface

+ type MockRestrictWorkspaceAdminsInterface_Delete_Call struct

+ func (_c *MockRestrictWorkspaceAdminsInterface_Delete_Call) Return(_a0 *settings.DeleteRestrictWorkspaceAdminsSettingResponse, _a1 error) *MockRestrictWorkspaceAdminsInterface_Delete_Call

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

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

+ type MockRestrictWorkspaceAdminsInterface_Expecter struct

+ func (_e *MockRestrictWorkspaceAdminsInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockRestrictWorkspaceAdminsInterface_Delete_Call

+ func (_e *MockRestrictWorkspaceAdminsInterface_Expecter) Get(ctx interface{}, request interface{}) *MockRestrictWorkspaceAdminsInterface_Get_Call

+ func (_e *MockRestrictWorkspaceAdminsInterface_Expecter) Impl() *MockRestrictWorkspaceAdminsInterface_Impl_Call

+ func (_e *MockRestrictWorkspaceAdminsInterface_Expecter) Update(ctx interface{}, request interface{}) *MockRestrictWorkspaceAdminsInterface_Update_Call

+ func (_e *MockRestrictWorkspaceAdminsInterface_Expecter) WithImpl(impl interface{}) *MockRestrictWorkspaceAdminsInterface_WithImpl_Call

+ type MockRestrictWorkspaceAdminsInterface_Get_Call struct

+ func (_c *MockRestrictWorkspaceAdminsInterface_Get_Call) Return(_a0 *settings.RestrictWorkspaceAdminsSetting, _a1 error) *MockRestrictWorkspaceAdminsInterface_Get_Call

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

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

+ type MockRestrictWorkspaceAdminsInterface_Impl_Call struct

+ func (_c *MockRestrictWorkspaceAdminsInterface_Impl_Call) Return(_a0 settings.RestrictWorkspaceAdminsService) *MockRestrictWorkspaceAdminsInterface_Impl_Call

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

+ func (_c *MockRestrictWorkspaceAdminsInterface_Impl_Call) RunAndReturn(run func() settings.RestrictWorkspaceAdminsService) *MockRestrictWorkspaceAdminsInterface_Impl_Call

+ type MockRestrictWorkspaceAdminsInterface_Update_Call struct

+ func (_c *MockRestrictWorkspaceAdminsInterface_Update_Call) Return(_a0 *settings.RestrictWorkspaceAdminsSetting, _a1 error) *MockRestrictWorkspaceAdminsInterface_Update_Call

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

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

+ type MockRestrictWorkspaceAdminsInterface_WithImpl_Call struct

+ func (_c *MockRestrictWorkspaceAdminsInterface_WithImpl_Call) Return(_a0 settings.RestrictWorkspaceAdminsInterface) *MockRestrictWorkspaceAdminsInterface_WithImpl_Call

+ func (_c *MockRestrictWorkspaceAdminsInterface_WithImpl_Call) Run(run func(impl settings.RestrictWorkspaceAdminsService)) *MockRestrictWorkspaceAdminsInterface_WithImpl_Call

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

type MockSettingsInterface

+ func (_m *MockSettingsInterface) AutomaticClusterUpdate() settings.AutomaticClusterUpdateInterface

+ func (_m *MockSettingsInterface) CspEnablement() settings.CspEnablementInterface

+ func (_m *MockSettingsInterface) DefaultNamespace() settings.DefaultNamespaceInterface

+ func (_m *MockSettingsInterface) EsmEnablement() settings.EsmEnablementInterface

+ func (_m *MockSettingsInterface) RestrictWorkspaceAdmins() settings.RestrictWorkspaceAdminsInterface

+ type MockSettingsInterface_AutomaticClusterUpdate_Call struct

+ func (_c *MockSettingsInterface_AutomaticClusterUpdate_Call) Return(_a0 settings.AutomaticClusterUpdateInterface) *MockSettingsInterface_AutomaticClusterUpdate_Call

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

+ func (_c *MockSettingsInterface_AutomaticClusterUpdate_Call) RunAndReturn(run func() settings.AutomaticClusterUpdateInterface) *MockSettingsInterface_AutomaticClusterUpdate_Call

+ type MockSettingsInterface_CspEnablement_Call struct

+ func (_c *MockSettingsInterface_CspEnablement_Call) Return(_a0 settings.CspEnablementInterface) *MockSettingsInterface_CspEnablement_Call

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

+ func (_c *MockSettingsInterface_CspEnablement_Call) RunAndReturn(run func() settings.CspEnablementInterface) *MockSettingsInterface_CspEnablement_Call

+ type MockSettingsInterface_DefaultNamespace_Call struct

+ func (_c *MockSettingsInterface_DefaultNamespace_Call) Return(_a0 settings.DefaultNamespaceInterface) *MockSettingsInterface_DefaultNamespace_Call

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

+ func (_c *MockSettingsInterface_DefaultNamespace_Call) RunAndReturn(run func() settings.DefaultNamespaceInterface) *MockSettingsInterface_DefaultNamespace_Call

+ type MockSettingsInterface_EsmEnablement_Call struct

+ func (_c *MockSettingsInterface_EsmEnablement_Call) Return(_a0 settings.EsmEnablementInterface) *MockSettingsInterface_EsmEnablement_Call

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

+ func (_c *MockSettingsInterface_EsmEnablement_Call) RunAndReturn(run func() settings.EsmEnablementInterface) *MockSettingsInterface_EsmEnablement_Call

type MockSettingsInterface_Expecter

+ func (_e *MockSettingsInterface_Expecter) AutomaticClusterUpdate() *MockSettingsInterface_AutomaticClusterUpdate_Call

+ func (_e *MockSettingsInterface_Expecter) CspEnablement() *MockSettingsInterface_CspEnablement_Call

+ func (_e *MockSettingsInterface_Expecter) DefaultNamespace() *MockSettingsInterface_DefaultNamespace_Call

+ func (_e *MockSettingsInterface_Expecter) EsmEnablement() *MockSettingsInterface_EsmEnablement_Call

+ func (_e *MockSettingsInterface_Expecter) RestrictWorkspaceAdmins() *MockSettingsInterface_RestrictWorkspaceAdmins_Call

+ type MockSettingsInterface_RestrictWorkspaceAdmins_Call struct

+ func (_c *MockSettingsInterface_RestrictWorkspaceAdmins_Call) Return(_a0 settings.RestrictWorkspaceAdminsInterface) *MockSettingsInterface_RestrictWorkspaceAdmins_Call

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

+ func (_c *MockSettingsInterface_RestrictWorkspaceAdmins_Call) RunAndReturn(run func() settings.RestrictWorkspaceAdminsInterface) *MockSettingsInterface_RestrictWorkspaceAdmins_Call

v0.33.0

Feb 19, 2024

v0.32.0

Feb 14, 2024

v0.31.0

Feb 8, 2024

Changes in this version

type MockAccountSettingsInterface

+ func (_m *MockAccountSettingsInterface) GetPersonalComputeSetting(ctx context.Context, request settings.GetPersonalComputeSettingRequest) (*settings.PersonalComputeSetting, error)

type MockAccountSettingsInterface_Expecter

+ func (_e *MockAccountSettingsInterface_Expecter) GetPersonalComputeSetting(ctx interface{}, request interface{}) *MockAccountSettingsInterface_GetPersonalComputeSetting_Call

+ type MockAccountSettingsInterface_GetPersonalComputeSetting_Call struct

+ func (_c *MockAccountSettingsInterface_GetPersonalComputeSetting_Call) Return(_a0 *settings.PersonalComputeSetting, _a1 error) *MockAccountSettingsInterface_GetPersonalComputeSetting_Call

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

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

type MockSettingsInterface

+ func (_m *MockSettingsInterface) DeleteDefaultNamespaceSetting(ctx context.Context, request settings.DeleteDefaultNamespaceSettingRequest) (*settings.DeleteDefaultNamespaceSettingResponse, error)

+ func (_m *MockSettingsInterface) DeleteRestrictWorkspaceAdminsSetting(ctx context.Context, ...) (*settings.DeleteRestrictWorkspaceAdminsSettingResponse, error)

+ func (_m *MockSettingsInterface) GetDefaultNamespaceSetting(ctx context.Context, request settings.GetDefaultNamespaceSettingRequest) (*settings.DefaultNamespaceSetting, error)

+ func (_m *MockSettingsInterface) GetRestrictWorkspaceAdminsSetting(ctx context.Context, request settings.GetRestrictWorkspaceAdminsSettingRequest) (*settings.RestrictWorkspaceAdminsSetting, error)

+ func (_m *MockSettingsInterface) UpdateDefaultNamespaceSetting(ctx context.Context, request settings.UpdateDefaultNamespaceSettingRequest) (*settings.DefaultNamespaceSetting, error)

+ func (_m *MockSettingsInterface) UpdateRestrictWorkspaceAdminsSetting(ctx context.Context, ...) (*settings.RestrictWorkspaceAdminsSetting, error)

+ type MockSettingsInterface_DeleteDefaultNamespaceSetting_Call struct

+ func (_c *MockSettingsInterface_DeleteDefaultNamespaceSetting_Call) Return(_a0 *settings.DeleteDefaultNamespaceSettingResponse, _a1 error) *MockSettingsInterface_DeleteDefaultNamespaceSetting_Call

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

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

+ type MockSettingsInterface_DeleteRestrictWorkspaceAdminsSetting_Call struct

+ func (_c *MockSettingsInterface_DeleteRestrictWorkspaceAdminsSetting_Call) Return(_a0 *settings.DeleteRestrictWorkspaceAdminsSettingResponse, _a1 error) *MockSettingsInterface_DeleteRestrictWorkspaceAdminsSetting_Call

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

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

type MockSettingsInterface_Expecter

+ func (_e *MockSettingsInterface_Expecter) DeleteDefaultNamespaceSetting(ctx interface{}, request interface{}) *MockSettingsInterface_DeleteDefaultNamespaceSetting_Call

+ func (_e *MockSettingsInterface_Expecter) DeleteRestrictWorkspaceAdminsSetting(ctx interface{}, request interface{}) *MockSettingsInterface_DeleteRestrictWorkspaceAdminsSetting_Call

+ func (_e *MockSettingsInterface_Expecter) GetDefaultNamespaceSetting(ctx interface{}, request interface{}) *MockSettingsInterface_GetDefaultNamespaceSetting_Call

+ func (_e *MockSettingsInterface_Expecter) GetRestrictWorkspaceAdminsSetting(ctx interface{}, request interface{}) *MockSettingsInterface_GetRestrictWorkspaceAdminsSetting_Call

+ func (_e *MockSettingsInterface_Expecter) UpdateDefaultNamespaceSetting(ctx interface{}, request interface{}) *MockSettingsInterface_UpdateDefaultNamespaceSetting_Call

+ func (_e *MockSettingsInterface_Expecter) UpdateRestrictWorkspaceAdminsSetting(ctx interface{}, request interface{}) *MockSettingsInterface_UpdateRestrictWorkspaceAdminsSetting_Call

+ type MockSettingsInterface_GetDefaultNamespaceSetting_Call struct

+ func (_c *MockSettingsInterface_GetDefaultNamespaceSetting_Call) Return(_a0 *settings.DefaultNamespaceSetting, _a1 error) *MockSettingsInterface_GetDefaultNamespaceSetting_Call

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

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

+ type MockSettingsInterface_GetRestrictWorkspaceAdminsSetting_Call struct

+ func (_c *MockSettingsInterface_GetRestrictWorkspaceAdminsSetting_Call) Return(_a0 *settings.RestrictWorkspaceAdminsSetting, _a1 error) *MockSettingsInterface_GetRestrictWorkspaceAdminsSetting_Call

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

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

+ type MockSettingsInterface_UpdateDefaultNamespaceSetting_Call struct

+ func (_c *MockSettingsInterface_UpdateDefaultNamespaceSetting_Call) Return(_a0 *settings.DefaultNamespaceSetting, _a1 error) *MockSettingsInterface_UpdateDefaultNamespaceSetting_Call

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

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

+ type MockSettingsInterface_UpdateRestrictWorkspaceAdminsSetting_Call struct

+ func (_c *MockSettingsInterface_UpdateRestrictWorkspaceAdminsSetting_Call) Return(_a0 *settings.RestrictWorkspaceAdminsSetting, _a1 error) *MockSettingsInterface_UpdateRestrictWorkspaceAdminsSetting_Call

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

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

v0.30.1

Jan 25, 2024

v0.30.0

Jan 24, 2024

v0.29.1

Jan 16, 2024

v0.29.0

Jan 10, 2024

Changes in this version

+ type MockAccountIpAccessListsInterface struct

+ func NewMockAccountIpAccessListsInterface(t interface{ ... }) *MockAccountIpAccessListsInterface

+ func (_m *MockAccountIpAccessListsInterface) Create(ctx context.Context, request settings.CreateIpAccessList) (*settings.CreateIpAccessListResponse, error)

+ func (_m *MockAccountIpAccessListsInterface) Delete(ctx context.Context, request settings.DeleteAccountIpAccessListRequest) error

+ func (_m *MockAccountIpAccessListsInterface) DeleteByIpAccessListId(ctx context.Context, ipAccessListId string) error

+ func (_m *MockAccountIpAccessListsInterface) EXPECT() *MockAccountIpAccessListsInterface_Expecter

+ func (_m *MockAccountIpAccessListsInterface) Get(ctx context.Context, request settings.GetAccountIpAccessListRequest) (*settings.GetIpAccessListResponse, error)

+ func (_m *MockAccountIpAccessListsInterface) GetByIpAccessListId(ctx context.Context, ipAccessListId string) (*settings.GetIpAccessListResponse, error)

+ func (_m *MockAccountIpAccessListsInterface) GetByLabel(ctx context.Context, name string) (*settings.IpAccessListInfo, error)

+ func (_m *MockAccountIpAccessListsInterface) Impl() settings.AccountIpAccessListsService

+ func (_m *MockAccountIpAccessListsInterface) IpAccessListInfoLabelToListIdMap(ctx context.Context) (map[string]string, error)

+ func (_m *MockAccountIpAccessListsInterface) List(ctx context.Context) ...

+ func (_m *MockAccountIpAccessListsInterface) ListAll(ctx context.Context) ([]settings.IpAccessListInfo, error)

+ func (_m *MockAccountIpAccessListsInterface) Replace(ctx context.Context, request settings.ReplaceIpAccessList) error

+ func (_m *MockAccountIpAccessListsInterface) Update(ctx context.Context, request settings.UpdateIpAccessList) error

+ func (_m *MockAccountIpAccessListsInterface) WithImpl(impl settings.AccountIpAccessListsService) settings.AccountIpAccessListsInterface

+ type MockAccountIpAccessListsInterface_Create_Call struct

+ func (_c *MockAccountIpAccessListsInterface_Create_Call) Return(_a0 *settings.CreateIpAccessListResponse, _a1 error) *MockAccountIpAccessListsInterface_Create_Call

+ func (_c *MockAccountIpAccessListsInterface_Create_Call) Run(run func(ctx context.Context, request settings.CreateIpAccessList)) *MockAccountIpAccessListsInterface_Create_Call

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

+ type MockAccountIpAccessListsInterface_DeleteByIpAccessListId_Call struct

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

+ func (_c *MockAccountIpAccessListsInterface_DeleteByIpAccessListId_Call) Run(run func(ctx context.Context, ipAccessListId string)) *MockAccountIpAccessListsInterface_DeleteByIpAccessListId_Call

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

+ type MockAccountIpAccessListsInterface_Delete_Call struct

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

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

+ func (_c *MockAccountIpAccessListsInterface_Delete_Call) RunAndReturn(run func(context.Context, settings.DeleteAccountIpAccessListRequest) error) *MockAccountIpAccessListsInterface_Delete_Call

+ type MockAccountIpAccessListsInterface_Expecter struct

+ func (_e *MockAccountIpAccessListsInterface_Expecter) Create(ctx interface{}, request interface{}) *MockAccountIpAccessListsInterface_Create_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockAccountIpAccessListsInterface_Delete_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) DeleteByIpAccessListId(ctx interface{}, ipAccessListId interface{}) *MockAccountIpAccessListsInterface_DeleteByIpAccessListId_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) Get(ctx interface{}, request interface{}) *MockAccountIpAccessListsInterface_Get_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) GetByIpAccessListId(ctx interface{}, ipAccessListId interface{}) *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) GetByLabel(ctx interface{}, name interface{}) *MockAccountIpAccessListsInterface_GetByLabel_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) Impl() *MockAccountIpAccessListsInterface_Impl_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) IpAccessListInfoLabelToListIdMap(ctx interface{}) *MockAccountIpAccessListsInterface_IpAccessListInfoLabelToListIdMap_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) List(ctx interface{}) *MockAccountIpAccessListsInterface_List_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) ListAll(ctx interface{}) *MockAccountIpAccessListsInterface_ListAll_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) Replace(ctx interface{}, request interface{}) *MockAccountIpAccessListsInterface_Replace_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) Update(ctx interface{}, request interface{}) *MockAccountIpAccessListsInterface_Update_Call

+ func (_e *MockAccountIpAccessListsInterface_Expecter) WithImpl(impl interface{}) *MockAccountIpAccessListsInterface_WithImpl_Call

+ type MockAccountIpAccessListsInterface_GetByIpAccessListId_Call struct

+ func (_c *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call) Return(_a0 *settings.GetIpAccessListResponse, _a1 error) *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call

+ func (_c *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call) Run(run func(ctx context.Context, ipAccessListId string)) *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call

+ func (_c *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call) RunAndReturn(run func(context.Context, string) (*settings.GetIpAccessListResponse, error)) *MockAccountIpAccessListsInterface_GetByIpAccessListId_Call

+ type MockAccountIpAccessListsInterface_GetByLabel_Call struct

+ func (_c *MockAccountIpAccessListsInterface_GetByLabel_Call) Return(_a0 *settings.IpAccessListInfo, _a1 error) *MockAccountIpAccessListsInterface_GetByLabel_Call

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

+ func (_c *MockAccountIpAccessListsInterface_GetByLabel_Call) RunAndReturn(run func(context.Context, string) (*settings.IpAccessListInfo, error)) *MockAccountIpAccessListsInterface_GetByLabel_Call

+ type MockAccountIpAccessListsInterface_Get_Call struct

+ func (_c *MockAccountIpAccessListsInterface_Get_Call) Return(_a0 *settings.GetIpAccessListResponse, _a1 error) *MockAccountIpAccessListsInterface_Get_Call

+ func (_c *MockAccountIpAccessListsInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetAccountIpAccessListRequest)) *MockAccountIpAccessListsInterface_Get_Call

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

+ type MockAccountIpAccessListsInterface_Impl_Call struct

+ func (_c *MockAccountIpAccessListsInterface_Impl_Call) Return(_a0 settings.AccountIpAccessListsService) *MockAccountIpAccessListsInterface_Impl_Call

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

+ func (_c *MockAccountIpAccessListsInterface_Impl_Call) RunAndReturn(run func() settings.AccountIpAccessListsService) *MockAccountIpAccessListsInterface_Impl_Call

+ type MockAccountIpAccessListsInterface_IpAccessListInfoLabelToListIdMap_Call struct

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

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

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

+ type MockAccountIpAccessListsInterface_ListAll_Call struct

+ func (_c *MockAccountIpAccessListsInterface_ListAll_Call) Return(_a0 []settings.IpAccessListInfo, _a1 error) *MockAccountIpAccessListsInterface_ListAll_Call

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

+ func (_c *MockAccountIpAccessListsInterface_ListAll_Call) RunAndReturn(run func(context.Context) ([]settings.IpAccessListInfo, error)) *MockAccountIpAccessListsInterface_ListAll_Call

+ type MockAccountIpAccessListsInterface_List_Call struct

+ func (_c *MockAccountIpAccessListsInterface_List_Call) Return(...) *MockAccountIpAccessListsInterface_List_Call

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

+ func (_c *MockAccountIpAccessListsInterface_List_Call) RunAndReturn(run func(context.Context) ...) *MockAccountIpAccessListsInterface_List_Call

+ type MockAccountIpAccessListsInterface_Replace_Call struct

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

+ func (_c *MockAccountIpAccessListsInterface_Replace_Call) Run(run func(ctx context.Context, request settings.ReplaceIpAccessList)) *MockAccountIpAccessListsInterface_Replace_Call

+ func (_c *MockAccountIpAccessListsInterface_Replace_Call) RunAndReturn(run func(context.Context, settings.ReplaceIpAccessList) error) *MockAccountIpAccessListsInterface_Replace_Call

+ type MockAccountIpAccessListsInterface_Update_Call struct

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

+ func (_c *MockAccountIpAccessListsInterface_Update_Call) Run(run func(ctx context.Context, request settings.UpdateIpAccessList)) *MockAccountIpAccessListsInterface_Update_Call

+ func (_c *MockAccountIpAccessListsInterface_Update_Call) RunAndReturn(run func(context.Context, settings.UpdateIpAccessList) error) *MockAccountIpAccessListsInterface_Update_Call

+ type MockAccountIpAccessListsInterface_WithImpl_Call struct

+ func (_c *MockAccountIpAccessListsInterface_WithImpl_Call) Return(_a0 settings.AccountIpAccessListsInterface) *MockAccountIpAccessListsInterface_WithImpl_Call

+ func (_c *MockAccountIpAccessListsInterface_WithImpl_Call) Run(run func(impl settings.AccountIpAccessListsService)) *MockAccountIpAccessListsInterface_WithImpl_Call

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

+ type MockAccountSettingsInterface struct

+ func NewMockAccountSettingsInterface(t interface{ ... }) *MockAccountSettingsInterface

+ func (_m *MockAccountSettingsInterface) DeletePersonalComputeSetting(ctx context.Context, request settings.DeletePersonalComputeSettingRequest) (*settings.DeletePersonalComputeSettingResponse, error)

+ func (_m *MockAccountSettingsInterface) EXPECT() *MockAccountSettingsInterface_Expecter

+ func (_m *MockAccountSettingsInterface) Impl() settings.AccountSettingsService

+ func (_m *MockAccountSettingsInterface) ReadPersonalComputeSetting(ctx context.Context, request settings.ReadPersonalComputeSettingRequest) (*settings.PersonalComputeSetting, error)

+ func (_m *MockAccountSettingsInterface) UpdatePersonalComputeSetting(ctx context.Context, request settings.UpdatePersonalComputeSettingRequest) (*settings.PersonalComputeSetting, error)

+ func (_m *MockAccountSettingsInterface) WithImpl(impl settings.AccountSettingsService) settings.AccountSettingsInterface

+ type MockAccountSettingsInterface_DeletePersonalComputeSetting_Call struct

+ func (_c *MockAccountSettingsInterface_DeletePersonalComputeSetting_Call) Return(_a0 *settings.DeletePersonalComputeSettingResponse, _a1 error) *MockAccountSettingsInterface_DeletePersonalComputeSetting_Call

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

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

+ type MockAccountSettingsInterface_Expecter struct

+ func (_e *MockAccountSettingsInterface_Expecter) DeletePersonalComputeSetting(ctx interface{}, request interface{}) *MockAccountSettingsInterface_DeletePersonalComputeSetting_Call

+ func (_e *MockAccountSettingsInterface_Expecter) Impl() *MockAccountSettingsInterface_Impl_Call

+ func (_e *MockAccountSettingsInterface_Expecter) ReadPersonalComputeSetting(ctx interface{}, request interface{}) *MockAccountSettingsInterface_ReadPersonalComputeSetting_Call

+ func (_e *MockAccountSettingsInterface_Expecter) UpdatePersonalComputeSetting(ctx interface{}, request interface{}) *MockAccountSettingsInterface_UpdatePersonalComputeSetting_Call

+ func (_e *MockAccountSettingsInterface_Expecter) WithImpl(impl interface{}) *MockAccountSettingsInterface_WithImpl_Call

+ type MockAccountSettingsInterface_Impl_Call struct

+ func (_c *MockAccountSettingsInterface_Impl_Call) Return(_a0 settings.AccountSettingsService) *MockAccountSettingsInterface_Impl_Call

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

+ func (_c *MockAccountSettingsInterface_Impl_Call) RunAndReturn(run func() settings.AccountSettingsService) *MockAccountSettingsInterface_Impl_Call

+ type MockAccountSettingsInterface_ReadPersonalComputeSetting_Call struct

+ func (_c *MockAccountSettingsInterface_ReadPersonalComputeSetting_Call) Return(_a0 *settings.PersonalComputeSetting, _a1 error) *MockAccountSettingsInterface_ReadPersonalComputeSetting_Call

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

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

+ type MockAccountSettingsInterface_UpdatePersonalComputeSetting_Call struct

+ func (_c *MockAccountSettingsInterface_UpdatePersonalComputeSetting_Call) Return(_a0 *settings.PersonalComputeSetting, _a1 error) *MockAccountSettingsInterface_UpdatePersonalComputeSetting_Call

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

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

+ type MockAccountSettingsInterface_WithImpl_Call struct

+ func (_c *MockAccountSettingsInterface_WithImpl_Call) Return(_a0 settings.AccountSettingsInterface) *MockAccountSettingsInterface_WithImpl_Call

+ func (_c *MockAccountSettingsInterface_WithImpl_Call) Run(run func(impl settings.AccountSettingsService)) *MockAccountSettingsInterface_WithImpl_Call

+ func (_c *MockAccountSettingsInterface_WithImpl_Call) RunAndReturn(run func(settings.AccountSettingsService) settings.AccountSettingsInterface) *MockAccountSettingsInterface_WithImpl_Call

+ type MockCredentialsManagerInterface struct

+ func NewMockCredentialsManagerInterface(t interface{ ... }) *MockCredentialsManagerInterface

+ func (_m *MockCredentialsManagerInterface) EXPECT() *MockCredentialsManagerInterface_Expecter

+ func (_m *MockCredentialsManagerInterface) ExchangeToken(ctx context.Context, request settings.ExchangeTokenRequest) (*settings.ExchangeTokenResponse, error)

+ func (_m *MockCredentialsManagerInterface) Impl() settings.CredentialsManagerService

+ func (_m *MockCredentialsManagerInterface) WithImpl(impl settings.CredentialsManagerService) settings.CredentialsManagerInterface

+ type MockCredentialsManagerInterface_ExchangeToken_Call struct

+ func (_c *MockCredentialsManagerInterface_ExchangeToken_Call) Return(_a0 *settings.ExchangeTokenResponse, _a1 error) *MockCredentialsManagerInterface_ExchangeToken_Call

+ func (_c *MockCredentialsManagerInterface_ExchangeToken_Call) Run(run func(ctx context.Context, request settings.ExchangeTokenRequest)) *MockCredentialsManagerInterface_ExchangeToken_Call

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

+ type MockCredentialsManagerInterface_Expecter struct

+ func (_e *MockCredentialsManagerInterface_Expecter) ExchangeToken(ctx interface{}, request interface{}) *MockCredentialsManagerInterface_ExchangeToken_Call

+ func (_e *MockCredentialsManagerInterface_Expecter) Impl() *MockCredentialsManagerInterface_Impl_Call

+ func (_e *MockCredentialsManagerInterface_Expecter) WithImpl(impl interface{}) *MockCredentialsManagerInterface_WithImpl_Call

+ type MockCredentialsManagerInterface_Impl_Call struct

+ func (_c *MockCredentialsManagerInterface_Impl_Call) Return(_a0 settings.CredentialsManagerService) *MockCredentialsManagerInterface_Impl_Call

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

+ func (_c *MockCredentialsManagerInterface_Impl_Call) RunAndReturn(run func() settings.CredentialsManagerService) *MockCredentialsManagerInterface_Impl_Call

+ type MockCredentialsManagerInterface_WithImpl_Call struct

+ func (_c *MockCredentialsManagerInterface_WithImpl_Call) Return(_a0 settings.CredentialsManagerInterface) *MockCredentialsManagerInterface_WithImpl_Call

+ func (_c *MockCredentialsManagerInterface_WithImpl_Call) Run(run func(impl settings.CredentialsManagerService)) *MockCredentialsManagerInterface_WithImpl_Call

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

+ type MockIpAccessListsInterface struct

+ func NewMockIpAccessListsInterface(t interface{ ... }) *MockIpAccessListsInterface

+ func (_m *MockIpAccessListsInterface) Create(ctx context.Context, request settings.CreateIpAccessList) (*settings.CreateIpAccessListResponse, error)

+ func (_m *MockIpAccessListsInterface) Delete(ctx context.Context, request settings.DeleteIpAccessListRequest) error

+ func (_m *MockIpAccessListsInterface) DeleteByIpAccessListId(ctx context.Context, ipAccessListId string) error

+ func (_m *MockIpAccessListsInterface) EXPECT() *MockIpAccessListsInterface_Expecter

+ func (_m *MockIpAccessListsInterface) Get(ctx context.Context, request settings.GetIpAccessListRequest) (*settings.FetchIpAccessListResponse, error)

+ func (_m *MockIpAccessListsInterface) GetByIpAccessListId(ctx context.Context, ipAccessListId string) (*settings.FetchIpAccessListResponse, error)

+ func (_m *MockIpAccessListsInterface) GetByLabel(ctx context.Context, name string) (*settings.IpAccessListInfo, error)

+ func (_m *MockIpAccessListsInterface) Impl() settings.IpAccessListsService

+ func (_m *MockIpAccessListsInterface) IpAccessListInfoLabelToListIdMap(ctx context.Context) (map[string]string, error)

+ func (_m *MockIpAccessListsInterface) List(ctx context.Context) ...

+ func (_m *MockIpAccessListsInterface) ListAll(ctx context.Context) ([]settings.IpAccessListInfo, error)

+ func (_m *MockIpAccessListsInterface) Replace(ctx context.Context, request settings.ReplaceIpAccessList) error

+ func (_m *MockIpAccessListsInterface) Update(ctx context.Context, request settings.UpdateIpAccessList) error

+ func (_m *MockIpAccessListsInterface) WithImpl(impl settings.IpAccessListsService) settings.IpAccessListsInterface

+ type MockIpAccessListsInterface_Create_Call struct

+ func (_c *MockIpAccessListsInterface_Create_Call) Return(_a0 *settings.CreateIpAccessListResponse, _a1 error) *MockIpAccessListsInterface_Create_Call

+ func (_c *MockIpAccessListsInterface_Create_Call) Run(run func(ctx context.Context, request settings.CreateIpAccessList)) *MockIpAccessListsInterface_Create_Call

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

+ type MockIpAccessListsInterface_DeleteByIpAccessListId_Call struct

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

+ func (_c *MockIpAccessListsInterface_DeleteByIpAccessListId_Call) Run(run func(ctx context.Context, ipAccessListId string)) *MockIpAccessListsInterface_DeleteByIpAccessListId_Call

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

+ type MockIpAccessListsInterface_Delete_Call struct

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

+ func (_c *MockIpAccessListsInterface_Delete_Call) Run(run func(ctx context.Context, request settings.DeleteIpAccessListRequest)) *MockIpAccessListsInterface_Delete_Call

+ func (_c *MockIpAccessListsInterface_Delete_Call) RunAndReturn(run func(context.Context, settings.DeleteIpAccessListRequest) error) *MockIpAccessListsInterface_Delete_Call

+ type MockIpAccessListsInterface_Expecter struct

+ func (_e *MockIpAccessListsInterface_Expecter) Create(ctx interface{}, request interface{}) *MockIpAccessListsInterface_Create_Call

+ func (_e *MockIpAccessListsInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockIpAccessListsInterface_Delete_Call

+ func (_e *MockIpAccessListsInterface_Expecter) DeleteByIpAccessListId(ctx interface{}, ipAccessListId interface{}) *MockIpAccessListsInterface_DeleteByIpAccessListId_Call

+ func (_e *MockIpAccessListsInterface_Expecter) Get(ctx interface{}, request interface{}) *MockIpAccessListsInterface_Get_Call

+ func (_e *MockIpAccessListsInterface_Expecter) GetByIpAccessListId(ctx interface{}, ipAccessListId interface{}) *MockIpAccessListsInterface_GetByIpAccessListId_Call

+ func (_e *MockIpAccessListsInterface_Expecter) GetByLabel(ctx interface{}, name interface{}) *MockIpAccessListsInterface_GetByLabel_Call

+ func (_e *MockIpAccessListsInterface_Expecter) Impl() *MockIpAccessListsInterface_Impl_Call

+ func (_e *MockIpAccessListsInterface_Expecter) IpAccessListInfoLabelToListIdMap(ctx interface{}) *MockIpAccessListsInterface_IpAccessListInfoLabelToListIdMap_Call

+ func (_e *MockIpAccessListsInterface_Expecter) List(ctx interface{}) *MockIpAccessListsInterface_List_Call

+ func (_e *MockIpAccessListsInterface_Expecter) ListAll(ctx interface{}) *MockIpAccessListsInterface_ListAll_Call

+ func (_e *MockIpAccessListsInterface_Expecter) Replace(ctx interface{}, request interface{}) *MockIpAccessListsInterface_Replace_Call

+ func (_e *MockIpAccessListsInterface_Expecter) Update(ctx interface{}, request interface{}) *MockIpAccessListsInterface_Update_Call

+ func (_e *MockIpAccessListsInterface_Expecter) WithImpl(impl interface{}) *MockIpAccessListsInterface_WithImpl_Call

+ type MockIpAccessListsInterface_GetByIpAccessListId_Call struct

+ func (_c *MockIpAccessListsInterface_GetByIpAccessListId_Call) Return(_a0 *settings.FetchIpAccessListResponse, _a1 error) *MockIpAccessListsInterface_GetByIpAccessListId_Call

+ func (_c *MockIpAccessListsInterface_GetByIpAccessListId_Call) Run(run func(ctx context.Context, ipAccessListId string)) *MockIpAccessListsInterface_GetByIpAccessListId_Call

+ func (_c *MockIpAccessListsInterface_GetByIpAccessListId_Call) RunAndReturn(run func(context.Context, string) (*settings.FetchIpAccessListResponse, error)) *MockIpAccessListsInterface_GetByIpAccessListId_Call

+ type MockIpAccessListsInterface_GetByLabel_Call struct

+ func (_c *MockIpAccessListsInterface_GetByLabel_Call) Return(_a0 *settings.IpAccessListInfo, _a1 error) *MockIpAccessListsInterface_GetByLabel_Call

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

+ func (_c *MockIpAccessListsInterface_GetByLabel_Call) RunAndReturn(run func(context.Context, string) (*settings.IpAccessListInfo, error)) *MockIpAccessListsInterface_GetByLabel_Call

+ type MockIpAccessListsInterface_Get_Call struct

+ func (_c *MockIpAccessListsInterface_Get_Call) Return(_a0 *settings.FetchIpAccessListResponse, _a1 error) *MockIpAccessListsInterface_Get_Call

+ func (_c *MockIpAccessListsInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetIpAccessListRequest)) *MockIpAccessListsInterface_Get_Call

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

+ type MockIpAccessListsInterface_Impl_Call struct

+ func (_c *MockIpAccessListsInterface_Impl_Call) Return(_a0 settings.IpAccessListsService) *MockIpAccessListsInterface_Impl_Call

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

+ func (_c *MockIpAccessListsInterface_Impl_Call) RunAndReturn(run func() settings.IpAccessListsService) *MockIpAccessListsInterface_Impl_Call

+ type MockIpAccessListsInterface_IpAccessListInfoLabelToListIdMap_Call struct

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

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

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

+ type MockIpAccessListsInterface_ListAll_Call struct

+ func (_c *MockIpAccessListsInterface_ListAll_Call) Return(_a0 []settings.IpAccessListInfo, _a1 error) *MockIpAccessListsInterface_ListAll_Call

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

+ func (_c *MockIpAccessListsInterface_ListAll_Call) RunAndReturn(run func(context.Context) ([]settings.IpAccessListInfo, error)) *MockIpAccessListsInterface_ListAll_Call

+ type MockIpAccessListsInterface_List_Call struct

+ func (_c *MockIpAccessListsInterface_List_Call) Return(...) *MockIpAccessListsInterface_List_Call

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

+ func (_c *MockIpAccessListsInterface_List_Call) RunAndReturn(run func(context.Context) ...) *MockIpAccessListsInterface_List_Call

+ type MockIpAccessListsInterface_Replace_Call struct

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

+ func (_c *MockIpAccessListsInterface_Replace_Call) Run(run func(ctx context.Context, request settings.ReplaceIpAccessList)) *MockIpAccessListsInterface_Replace_Call

+ func (_c *MockIpAccessListsInterface_Replace_Call) RunAndReturn(run func(context.Context, settings.ReplaceIpAccessList) error) *MockIpAccessListsInterface_Replace_Call

+ type MockIpAccessListsInterface_Update_Call struct

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

+ func (_c *MockIpAccessListsInterface_Update_Call) Run(run func(ctx context.Context, request settings.UpdateIpAccessList)) *MockIpAccessListsInterface_Update_Call

+ func (_c *MockIpAccessListsInterface_Update_Call) RunAndReturn(run func(context.Context, settings.UpdateIpAccessList) error) *MockIpAccessListsInterface_Update_Call

+ type MockIpAccessListsInterface_WithImpl_Call struct

+ func (_c *MockIpAccessListsInterface_WithImpl_Call) Return(_a0 settings.IpAccessListsInterface) *MockIpAccessListsInterface_WithImpl_Call

+ func (_c *MockIpAccessListsInterface_WithImpl_Call) Run(run func(impl settings.IpAccessListsService)) *MockIpAccessListsInterface_WithImpl_Call

+ func (_c *MockIpAccessListsInterface_WithImpl_Call) RunAndReturn(run func(settings.IpAccessListsService) settings.IpAccessListsInterface) *MockIpAccessListsInterface_WithImpl_Call

+ type MockNetworkConnectivityInterface struct

+ func NewMockNetworkConnectivityInterface(t interface{ ... }) *MockNetworkConnectivityInterface

+ func (_m *MockNetworkConnectivityInterface) CreateNetworkConnectivityConfiguration(ctx context.Context, request settings.CreateNetworkConnectivityConfigRequest) (*settings.NetworkConnectivityConfiguration, error)

+ func (_m *MockNetworkConnectivityInterface) CreatePrivateEndpointRule(ctx context.Context, request settings.CreatePrivateEndpointRuleRequest) (*settings.NccAzurePrivateEndpointRule, error)

+ func (_m *MockNetworkConnectivityInterface) DeleteNetworkConnectivityConfiguration(ctx context.Context, ...) error

+ func (_m *MockNetworkConnectivityInterface) DeleteNetworkConnectivityConfigurationByNetworkConnectivityConfigId(ctx context.Context, networkConnectivityConfigId string) error

+ func (_m *MockNetworkConnectivityInterface) DeletePrivateEndpointRule(ctx context.Context, request settings.DeletePrivateEndpointRuleRequest) (*settings.NccAzurePrivateEndpointRule, error)

+ func (_m *MockNetworkConnectivityInterface) DeletePrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId(ctx context.Context, networkConnectivityConfigId string, ...) (*settings.NccAzurePrivateEndpointRule, error)

+ func (_m *MockNetworkConnectivityInterface) EXPECT() *MockNetworkConnectivityInterface_Expecter

+ func (_m *MockNetworkConnectivityInterface) GetNetworkConnectivityConfiguration(ctx context.Context, ...) (*settings.NetworkConnectivityConfiguration, error)

+ func (_m *MockNetworkConnectivityInterface) GetNetworkConnectivityConfigurationByNetworkConnectivityConfigId(ctx context.Context, networkConnectivityConfigId string) (*settings.NetworkConnectivityConfiguration, error)

+ func (_m *MockNetworkConnectivityInterface) GetPrivateEndpointRule(ctx context.Context, request settings.GetPrivateEndpointRuleRequest) (*settings.NccAzurePrivateEndpointRule, error)

+ func (_m *MockNetworkConnectivityInterface) GetPrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId(ctx context.Context, networkConnectivityConfigId string, ...) (*settings.NccAzurePrivateEndpointRule, error)

+ func (_m *MockNetworkConnectivityInterface) Impl() settings.NetworkConnectivityService

+ func (_m *MockNetworkConnectivityInterface) ListNetworkConnectivityConfigurations(ctx context.Context, ...) ...

+ func (_m *MockNetworkConnectivityInterface) ListNetworkConnectivityConfigurationsAll(ctx context.Context, ...) ([]settings.NetworkConnectivityConfiguration, error)

+ func (_m *MockNetworkConnectivityInterface) ListPrivateEndpointRules(ctx context.Context, request settings.ListPrivateEndpointRulesRequest) ...

+ func (_m *MockNetworkConnectivityInterface) ListPrivateEndpointRulesAll(ctx context.Context, request settings.ListPrivateEndpointRulesRequest) ([]settings.NccAzurePrivateEndpointRule, error)

+ func (_m *MockNetworkConnectivityInterface) ListPrivateEndpointRulesByNetworkConnectivityConfigId(ctx context.Context, networkConnectivityConfigId string) (*settings.ListNccAzurePrivateEndpointRulesResponse, error)

+ func (_m *MockNetworkConnectivityInterface) WithImpl(impl settings.NetworkConnectivityService) settings.NetworkConnectivityInterface

+ type MockNetworkConnectivityInterface_CreateNetworkConnectivityConfiguration_Call struct

+ func (_c *MockNetworkConnectivityInterface_CreateNetworkConnectivityConfiguration_Call) Return(_a0 *settings.NetworkConnectivityConfiguration, _a1 error) *MockNetworkConnectivityInterface_CreateNetworkConnectivityConfiguration_Call

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

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

+ type MockNetworkConnectivityInterface_CreatePrivateEndpointRule_Call struct

+ func (_c *MockNetworkConnectivityInterface_CreatePrivateEndpointRule_Call) Return(_a0 *settings.NccAzurePrivateEndpointRule, _a1 error) *MockNetworkConnectivityInterface_CreatePrivateEndpointRule_Call

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

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

+ type MockNetworkConnectivityInterface_DeleteNetworkConnectivityConfigurationByNetworkConnectivityConfigId_Call struct

+ func (_c *MockNetworkConnectivityInterface_DeleteNetworkConnectivityConfigurationByNetworkConnectivityConfigId_Call) Return(_a0 error) ...

+ func (_c *MockNetworkConnectivityInterface_DeleteNetworkConnectivityConfigurationByNetworkConnectivityConfigId_Call) Run(run func(ctx context.Context, networkConnectivityConfigId string)) ...

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

+ type MockNetworkConnectivityInterface_DeleteNetworkConnectivityConfiguration_Call struct

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

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

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

+ type MockNetworkConnectivityInterface_DeletePrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId_Call struct

+ func (_c *MockNetworkConnectivityInterface_DeletePrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId_Call) Return(_a0 *settings.NccAzurePrivateEndpointRule, _a1 error) ...

+ func (_c *MockNetworkConnectivityInterface_DeletePrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId_Call) Run(run func(ctx context.Context, networkConnectivityConfigId string, ...)) ...

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

+ type MockNetworkConnectivityInterface_DeletePrivateEndpointRule_Call struct

+ func (_c *MockNetworkConnectivityInterface_DeletePrivateEndpointRule_Call) Return(_a0 *settings.NccAzurePrivateEndpointRule, _a1 error) *MockNetworkConnectivityInterface_DeletePrivateEndpointRule_Call

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

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

+ type MockNetworkConnectivityInterface_Expecter struct

+ func (_e *MockNetworkConnectivityInterface_Expecter) CreateNetworkConnectivityConfiguration(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_CreateNetworkConnectivityConfiguration_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) CreatePrivateEndpointRule(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_CreatePrivateEndpointRule_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) DeleteNetworkConnectivityConfiguration(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_DeleteNetworkConnectivityConfiguration_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) DeleteNetworkConnectivityConfigurationByNetworkConnectivityConfigId(ctx interface{}, networkConnectivityConfigId interface{}) ...

+ func (_e *MockNetworkConnectivityInterface_Expecter) DeletePrivateEndpointRule(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_DeletePrivateEndpointRule_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) DeletePrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId(ctx interface{}, networkConnectivityConfigId interface{}, ...) ...

+ func (_e *MockNetworkConnectivityInterface_Expecter) GetNetworkConnectivityConfiguration(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_GetNetworkConnectivityConfiguration_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) GetNetworkConnectivityConfigurationByNetworkConnectivityConfigId(ctx interface{}, networkConnectivityConfigId interface{}) ...

+ func (_e *MockNetworkConnectivityInterface_Expecter) GetPrivateEndpointRule(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_GetPrivateEndpointRule_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) GetPrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId(ctx interface{}, networkConnectivityConfigId interface{}, ...) ...

+ func (_e *MockNetworkConnectivityInterface_Expecter) Impl() *MockNetworkConnectivityInterface_Impl_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) ListNetworkConnectivityConfigurations(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_ListNetworkConnectivityConfigurations_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) ListNetworkConnectivityConfigurationsAll(ctx interface{}, request interface{}) ...

+ func (_e *MockNetworkConnectivityInterface_Expecter) ListPrivateEndpointRules(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_ListPrivateEndpointRules_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) ListPrivateEndpointRulesAll(ctx interface{}, request interface{}) *MockNetworkConnectivityInterface_ListPrivateEndpointRulesAll_Call

+ func (_e *MockNetworkConnectivityInterface_Expecter) ListPrivateEndpointRulesByNetworkConnectivityConfigId(ctx interface{}, networkConnectivityConfigId interface{}) ...

+ func (_e *MockNetworkConnectivityInterface_Expecter) WithImpl(impl interface{}) *MockNetworkConnectivityInterface_WithImpl_Call

+ type MockNetworkConnectivityInterface_GetNetworkConnectivityConfigurationByNetworkConnectivityConfigId_Call struct

+ func (_c *MockNetworkConnectivityInterface_GetNetworkConnectivityConfigurationByNetworkConnectivityConfigId_Call) Return(_a0 *settings.NetworkConnectivityConfiguration, _a1 error) ...

+ func (_c *MockNetworkConnectivityInterface_GetNetworkConnectivityConfigurationByNetworkConnectivityConfigId_Call) Run(run func(ctx context.Context, networkConnectivityConfigId string)) ...

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

+ type MockNetworkConnectivityInterface_GetNetworkConnectivityConfiguration_Call struct

+ func (_c *MockNetworkConnectivityInterface_GetNetworkConnectivityConfiguration_Call) Return(_a0 *settings.NetworkConnectivityConfiguration, _a1 error) *MockNetworkConnectivityInterface_GetNetworkConnectivityConfiguration_Call

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

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

+ type MockNetworkConnectivityInterface_GetPrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId_Call struct

+ func (_c *MockNetworkConnectivityInterface_GetPrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId_Call) Return(_a0 *settings.NccAzurePrivateEndpointRule, _a1 error) ...

+ func (_c *MockNetworkConnectivityInterface_GetPrivateEndpointRuleByNetworkConnectivityConfigIdAndPrivateEndpointRuleId_Call) Run(run func(ctx context.Context, networkConnectivityConfigId string, ...)) ...

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

+ type MockNetworkConnectivityInterface_GetPrivateEndpointRule_Call struct

+ func (_c *MockNetworkConnectivityInterface_GetPrivateEndpointRule_Call) Return(_a0 *settings.NccAzurePrivateEndpointRule, _a1 error) *MockNetworkConnectivityInterface_GetPrivateEndpointRule_Call

+ func (_c *MockNetworkConnectivityInterface_GetPrivateEndpointRule_Call) Run(run func(ctx context.Context, request settings.GetPrivateEndpointRuleRequest)) *MockNetworkConnectivityInterface_GetPrivateEndpointRule_Call

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

+ type MockNetworkConnectivityInterface_Impl_Call struct

+ func (_c *MockNetworkConnectivityInterface_Impl_Call) Return(_a0 settings.NetworkConnectivityService) *MockNetworkConnectivityInterface_Impl_Call

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

+ func (_c *MockNetworkConnectivityInterface_Impl_Call) RunAndReturn(run func() settings.NetworkConnectivityService) *MockNetworkConnectivityInterface_Impl_Call

+ type MockNetworkConnectivityInterface_ListNetworkConnectivityConfigurationsAll_Call struct

+ func (_c *MockNetworkConnectivityInterface_ListNetworkConnectivityConfigurationsAll_Call) Return(_a0 []settings.NetworkConnectivityConfiguration, _a1 error) ...

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

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

+ type MockNetworkConnectivityInterface_ListNetworkConnectivityConfigurations_Call struct

+ func (_c *MockNetworkConnectivityInterface_ListNetworkConnectivityConfigurations_Call) Return(...) *MockNetworkConnectivityInterface_ListNetworkConnectivityConfigurations_Call

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

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

+ type MockNetworkConnectivityInterface_ListPrivateEndpointRulesAll_Call struct

+ func (_c *MockNetworkConnectivityInterface_ListPrivateEndpointRulesAll_Call) Return(_a0 []settings.NccAzurePrivateEndpointRule, _a1 error) *MockNetworkConnectivityInterface_ListPrivateEndpointRulesAll_Call

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

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

+ type MockNetworkConnectivityInterface_ListPrivateEndpointRulesByNetworkConnectivityConfigId_Call struct

+ func (_c *MockNetworkConnectivityInterface_ListPrivateEndpointRulesByNetworkConnectivityConfigId_Call) Return(_a0 *settings.ListNccAzurePrivateEndpointRulesResponse, _a1 error) ...

+ func (_c *MockNetworkConnectivityInterface_ListPrivateEndpointRulesByNetworkConnectivityConfigId_Call) Run(run func(ctx context.Context, networkConnectivityConfigId string)) ...

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

+ type MockNetworkConnectivityInterface_ListPrivateEndpointRules_Call struct

+ func (_c *MockNetworkConnectivityInterface_ListPrivateEndpointRules_Call) Return(...) *MockNetworkConnectivityInterface_ListPrivateEndpointRules_Call

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

+ func (_c *MockNetworkConnectivityInterface_ListPrivateEndpointRules_Call) RunAndReturn(run func(context.Context, settings.ListPrivateEndpointRulesRequest) ...) *MockNetworkConnectivityInterface_ListPrivateEndpointRules_Call

+ type MockNetworkConnectivityInterface_WithImpl_Call struct

+ func (_c *MockNetworkConnectivityInterface_WithImpl_Call) Return(_a0 settings.NetworkConnectivityInterface) *MockNetworkConnectivityInterface_WithImpl_Call

+ func (_c *MockNetworkConnectivityInterface_WithImpl_Call) Run(run func(impl settings.NetworkConnectivityService)) *MockNetworkConnectivityInterface_WithImpl_Call

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

+ type MockSettingsInterface struct

+ func NewMockSettingsInterface(t interface{ ... }) *MockSettingsInterface

+ func (_m *MockSettingsInterface) DeleteDefaultWorkspaceNamespace(ctx context.Context, request settings.DeleteDefaultWorkspaceNamespaceRequest) (*settings.DeleteDefaultWorkspaceNamespaceResponse, error)

+ func (_m *MockSettingsInterface) EXPECT() *MockSettingsInterface_Expecter

+ func (_m *MockSettingsInterface) Impl() settings.SettingsService

+ func (_m *MockSettingsInterface) ReadDefaultWorkspaceNamespace(ctx context.Context, request settings.ReadDefaultWorkspaceNamespaceRequest) (*settings.DefaultNamespaceSetting, error)

+ func (_m *MockSettingsInterface) UpdateDefaultWorkspaceNamespace(ctx context.Context, request settings.UpdateDefaultWorkspaceNamespaceRequest) (*settings.DefaultNamespaceSetting, error)

+ func (_m *MockSettingsInterface) WithImpl(impl settings.SettingsService) settings.SettingsInterface

+ type MockSettingsInterface_DeleteDefaultWorkspaceNamespace_Call struct

+ func (_c *MockSettingsInterface_DeleteDefaultWorkspaceNamespace_Call) Return(_a0 *settings.DeleteDefaultWorkspaceNamespaceResponse, _a1 error) *MockSettingsInterface_DeleteDefaultWorkspaceNamespace_Call

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

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

+ type MockSettingsInterface_Expecter struct

+ func (_e *MockSettingsInterface_Expecter) DeleteDefaultWorkspaceNamespace(ctx interface{}, request interface{}) *MockSettingsInterface_DeleteDefaultWorkspaceNamespace_Call

+ func (_e *MockSettingsInterface_Expecter) Impl() *MockSettingsInterface_Impl_Call

+ func (_e *MockSettingsInterface_Expecter) ReadDefaultWorkspaceNamespace(ctx interface{}, request interface{}) *MockSettingsInterface_ReadDefaultWorkspaceNamespace_Call

+ func (_e *MockSettingsInterface_Expecter) UpdateDefaultWorkspaceNamespace(ctx interface{}, request interface{}) *MockSettingsInterface_UpdateDefaultWorkspaceNamespace_Call

+ func (_e *MockSettingsInterface_Expecter) WithImpl(impl interface{}) *MockSettingsInterface_WithImpl_Call

+ type MockSettingsInterface_Impl_Call struct

+ func (_c *MockSettingsInterface_Impl_Call) Return(_a0 settings.SettingsService) *MockSettingsInterface_Impl_Call

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

+ func (_c *MockSettingsInterface_Impl_Call) RunAndReturn(run func() settings.SettingsService) *MockSettingsInterface_Impl_Call

+ type MockSettingsInterface_ReadDefaultWorkspaceNamespace_Call struct

+ func (_c *MockSettingsInterface_ReadDefaultWorkspaceNamespace_Call) Return(_a0 *settings.DefaultNamespaceSetting, _a1 error) *MockSettingsInterface_ReadDefaultWorkspaceNamespace_Call

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

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

+ type MockSettingsInterface_UpdateDefaultWorkspaceNamespace_Call struct

+ func (_c *MockSettingsInterface_UpdateDefaultWorkspaceNamespace_Call) Return(_a0 *settings.DefaultNamespaceSetting, _a1 error) *MockSettingsInterface_UpdateDefaultWorkspaceNamespace_Call

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

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

+ type MockSettingsInterface_WithImpl_Call struct

+ func (_c *MockSettingsInterface_WithImpl_Call) Return(_a0 settings.SettingsInterface) *MockSettingsInterface_WithImpl_Call

+ func (_c *MockSettingsInterface_WithImpl_Call) Run(run func(impl settings.SettingsService)) *MockSettingsInterface_WithImpl_Call

+ func (_c *MockSettingsInterface_WithImpl_Call) RunAndReturn(run func(settings.SettingsService) settings.SettingsInterface) *MockSettingsInterface_WithImpl_Call

+ type MockTokenManagementInterface struct

+ func NewMockTokenManagementInterface(t interface{ ... }) *MockTokenManagementInterface

+ func (_m *MockTokenManagementInterface) CreateOboToken(ctx context.Context, request settings.CreateOboTokenRequest) (*settings.CreateOboTokenResponse, error)

+ func (_m *MockTokenManagementInterface) Delete(ctx context.Context, request settings.DeleteTokenManagementRequest) error

+ func (_m *MockTokenManagementInterface) DeleteByTokenId(ctx context.Context, tokenId string) error

+ func (_m *MockTokenManagementInterface) EXPECT() *MockTokenManagementInterface_Expecter

+ func (_m *MockTokenManagementInterface) Get(ctx context.Context, request settings.GetTokenManagementRequest) (*settings.TokenInfo, error)

+ func (_m *MockTokenManagementInterface) GetByComment(ctx context.Context, name string) (*settings.TokenInfo, error)

+ func (_m *MockTokenManagementInterface) GetByTokenId(ctx context.Context, tokenId string) (*settings.TokenInfo, error)

+ func (_m *MockTokenManagementInterface) GetPermissionLevels(ctx context.Context) (*settings.GetTokenPermissionLevelsResponse, error)

+ func (_m *MockTokenManagementInterface) GetPermissions(ctx context.Context) (*settings.TokenPermissions, error)

+ func (_m *MockTokenManagementInterface) Impl() settings.TokenManagementService

+ func (_m *MockTokenManagementInterface) List(ctx context.Context, request settings.ListTokenManagementRequest) ...

+ func (_m *MockTokenManagementInterface) ListAll(ctx context.Context, request settings.ListTokenManagementRequest) ([]settings.TokenInfo, error)

+ func (_m *MockTokenManagementInterface) SetPermissions(ctx context.Context, request settings.TokenPermissionsRequest) (*settings.TokenPermissions, error)

+ func (_m *MockTokenManagementInterface) TokenInfoCommentToTokenIdMap(ctx context.Context, request settings.ListTokenManagementRequest) (map[string]string, error)

+ func (_m *MockTokenManagementInterface) UpdatePermissions(ctx context.Context, request settings.TokenPermissionsRequest) (*settings.TokenPermissions, error)

+ func (_m *MockTokenManagementInterface) WithImpl(impl settings.TokenManagementService) settings.TokenManagementInterface

+ type MockTokenManagementInterface_CreateOboToken_Call struct

+ func (_c *MockTokenManagementInterface_CreateOboToken_Call) Return(_a0 *settings.CreateOboTokenResponse, _a1 error) *MockTokenManagementInterface_CreateOboToken_Call

+ func (_c *MockTokenManagementInterface_CreateOboToken_Call) Run(run func(ctx context.Context, request settings.CreateOboTokenRequest)) *MockTokenManagementInterface_CreateOboToken_Call

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

+ type MockTokenManagementInterface_DeleteByTokenId_Call struct

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

+ func (_c *MockTokenManagementInterface_DeleteByTokenId_Call) Run(run func(ctx context.Context, tokenId string)) *MockTokenManagementInterface_DeleteByTokenId_Call

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

+ type MockTokenManagementInterface_Delete_Call struct

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

+ func (_c *MockTokenManagementInterface_Delete_Call) Run(run func(ctx context.Context, request settings.DeleteTokenManagementRequest)) *MockTokenManagementInterface_Delete_Call

+ func (_c *MockTokenManagementInterface_Delete_Call) RunAndReturn(run func(context.Context, settings.DeleteTokenManagementRequest) error) *MockTokenManagementInterface_Delete_Call

+ type MockTokenManagementInterface_Expecter struct

+ func (_e *MockTokenManagementInterface_Expecter) CreateOboToken(ctx interface{}, request interface{}) *MockTokenManagementInterface_CreateOboToken_Call

+ func (_e *MockTokenManagementInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockTokenManagementInterface_Delete_Call

+ func (_e *MockTokenManagementInterface_Expecter) DeleteByTokenId(ctx interface{}, tokenId interface{}) *MockTokenManagementInterface_DeleteByTokenId_Call

+ func (_e *MockTokenManagementInterface_Expecter) Get(ctx interface{}, request interface{}) *MockTokenManagementInterface_Get_Call

+ func (_e *MockTokenManagementInterface_Expecter) GetByComment(ctx interface{}, name interface{}) *MockTokenManagementInterface_GetByComment_Call

+ func (_e *MockTokenManagementInterface_Expecter) GetByTokenId(ctx interface{}, tokenId interface{}) *MockTokenManagementInterface_GetByTokenId_Call

+ func (_e *MockTokenManagementInterface_Expecter) GetPermissionLevels(ctx interface{}) *MockTokenManagementInterface_GetPermissionLevels_Call

+ func (_e *MockTokenManagementInterface_Expecter) GetPermissions(ctx interface{}) *MockTokenManagementInterface_GetPermissions_Call

+ func (_e *MockTokenManagementInterface_Expecter) Impl() *MockTokenManagementInterface_Impl_Call

+ func (_e *MockTokenManagementInterface_Expecter) List(ctx interface{}, request interface{}) *MockTokenManagementInterface_List_Call

+ func (_e *MockTokenManagementInterface_Expecter) ListAll(ctx interface{}, request interface{}) *MockTokenManagementInterface_ListAll_Call

+ func (_e *MockTokenManagementInterface_Expecter) SetPermissions(ctx interface{}, request interface{}) *MockTokenManagementInterface_SetPermissions_Call

+ func (_e *MockTokenManagementInterface_Expecter) TokenInfoCommentToTokenIdMap(ctx interface{}, request interface{}) *MockTokenManagementInterface_TokenInfoCommentToTokenIdMap_Call

+ func (_e *MockTokenManagementInterface_Expecter) UpdatePermissions(ctx interface{}, request interface{}) *MockTokenManagementInterface_UpdatePermissions_Call

+ func (_e *MockTokenManagementInterface_Expecter) WithImpl(impl interface{}) *MockTokenManagementInterface_WithImpl_Call

+ type MockTokenManagementInterface_GetByComment_Call struct

+ func (_c *MockTokenManagementInterface_GetByComment_Call) Return(_a0 *settings.TokenInfo, _a1 error) *MockTokenManagementInterface_GetByComment_Call

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

+ func (_c *MockTokenManagementInterface_GetByComment_Call) RunAndReturn(run func(context.Context, string) (*settings.TokenInfo, error)) *MockTokenManagementInterface_GetByComment_Call

+ type MockTokenManagementInterface_GetByTokenId_Call struct

+ func (_c *MockTokenManagementInterface_GetByTokenId_Call) Return(_a0 *settings.TokenInfo, _a1 error) *MockTokenManagementInterface_GetByTokenId_Call

+ func (_c *MockTokenManagementInterface_GetByTokenId_Call) Run(run func(ctx context.Context, tokenId string)) *MockTokenManagementInterface_GetByTokenId_Call

+ func (_c *MockTokenManagementInterface_GetByTokenId_Call) RunAndReturn(run func(context.Context, string) (*settings.TokenInfo, error)) *MockTokenManagementInterface_GetByTokenId_Call

+ type MockTokenManagementInterface_GetPermissionLevels_Call struct

+ func (_c *MockTokenManagementInterface_GetPermissionLevels_Call) Return(_a0 *settings.GetTokenPermissionLevelsResponse, _a1 error) *MockTokenManagementInterface_GetPermissionLevels_Call

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

+ func (_c *MockTokenManagementInterface_GetPermissionLevels_Call) RunAndReturn(run func(context.Context) (*settings.GetTokenPermissionLevelsResponse, error)) *MockTokenManagementInterface_GetPermissionLevels_Call

+ type MockTokenManagementInterface_GetPermissions_Call struct

+ func (_c *MockTokenManagementInterface_GetPermissions_Call) Return(_a0 *settings.TokenPermissions, _a1 error) *MockTokenManagementInterface_GetPermissions_Call

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

+ func (_c *MockTokenManagementInterface_GetPermissions_Call) RunAndReturn(run func(context.Context) (*settings.TokenPermissions, error)) *MockTokenManagementInterface_GetPermissions_Call

+ type MockTokenManagementInterface_Get_Call struct

+ func (_c *MockTokenManagementInterface_Get_Call) Return(_a0 *settings.TokenInfo, _a1 error) *MockTokenManagementInterface_Get_Call

+ func (_c *MockTokenManagementInterface_Get_Call) Run(run func(ctx context.Context, request settings.GetTokenManagementRequest)) *MockTokenManagementInterface_Get_Call

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

+ type MockTokenManagementInterface_Impl_Call struct

+ func (_c *MockTokenManagementInterface_Impl_Call) Return(_a0 settings.TokenManagementService) *MockTokenManagementInterface_Impl_Call

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

+ func (_c *MockTokenManagementInterface_Impl_Call) RunAndReturn(run func() settings.TokenManagementService) *MockTokenManagementInterface_Impl_Call

+ type MockTokenManagementInterface_ListAll_Call struct

+ func (_c *MockTokenManagementInterface_ListAll_Call) Return(_a0 []settings.TokenInfo, _a1 error) *MockTokenManagementInterface_ListAll_Call

+ func (_c *MockTokenManagementInterface_ListAll_Call) Run(run func(ctx context.Context, request settings.ListTokenManagementRequest)) *MockTokenManagementInterface_ListAll_Call

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

+ type MockTokenManagementInterface_List_Call struct

+ func (_c *MockTokenManagementInterface_List_Call) Return(...) *MockTokenManagementInterface_List_Call

+ func (_c *MockTokenManagementInterface_List_Call) Run(run func(ctx context.Context, request settings.ListTokenManagementRequest)) *MockTokenManagementInterface_List_Call

+ func (_c *MockTokenManagementInterface_List_Call) RunAndReturn(run func(context.Context, settings.ListTokenManagementRequest) ...) *MockTokenManagementInterface_List_Call

+ type MockTokenManagementInterface_SetPermissions_Call struct

+ func (_c *MockTokenManagementInterface_SetPermissions_Call) Return(_a0 *settings.TokenPermissions, _a1 error) *MockTokenManagementInterface_SetPermissions_Call

+ func (_c *MockTokenManagementInterface_SetPermissions_Call) Run(run func(ctx context.Context, request settings.TokenPermissionsRequest)) *MockTokenManagementInterface_SetPermissions_Call

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

+ type MockTokenManagementInterface_TokenInfoCommentToTokenIdMap_Call struct

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

+ func (_c *MockTokenManagementInterface_TokenInfoCommentToTokenIdMap_Call) Run(run func(ctx context.Context, request settings.ListTokenManagementRequest)) *MockTokenManagementInterface_TokenInfoCommentToTokenIdMap_Call

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

+ type MockTokenManagementInterface_UpdatePermissions_Call struct

+ func (_c *MockTokenManagementInterface_UpdatePermissions_Call) Return(_a0 *settings.TokenPermissions, _a1 error) *MockTokenManagementInterface_UpdatePermissions_Call

+ func (_c *MockTokenManagementInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request settings.TokenPermissionsRequest)) *MockTokenManagementInterface_UpdatePermissions_Call

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

+ type MockTokenManagementInterface_WithImpl_Call struct

+ func (_c *MockTokenManagementInterface_WithImpl_Call) Return(_a0 settings.TokenManagementInterface) *MockTokenManagementInterface_WithImpl_Call

+ func (_c *MockTokenManagementInterface_WithImpl_Call) Run(run func(impl settings.TokenManagementService)) *MockTokenManagementInterface_WithImpl_Call

+ func (_c *MockTokenManagementInterface_WithImpl_Call) RunAndReturn(run func(settings.TokenManagementService) settings.TokenManagementInterface) *MockTokenManagementInterface_WithImpl_Call

+ type MockTokensInterface struct

+ func NewMockTokensInterface(t interface{ ... }) *MockTokensInterface

+ func (_m *MockTokensInterface) Create(ctx context.Context, request settings.CreateTokenRequest) (*settings.CreateTokenResponse, error)

+ func (_m *MockTokensInterface) Delete(ctx context.Context, request settings.RevokeTokenRequest) error

+ func (_m *MockTokensInterface) DeleteByTokenId(ctx context.Context, tokenId string) error

+ func (_m *MockTokensInterface) EXPECT() *MockTokensInterface_Expecter

+ func (_m *MockTokensInterface) GetByComment(ctx context.Context, name string) (*settings.PublicTokenInfo, error)

+ func (_m *MockTokensInterface) Impl() settings.TokensService

+ func (_m *MockTokensInterface) List(ctx context.Context) ...

+ func (_m *MockTokensInterface) ListAll(ctx context.Context) ([]settings.PublicTokenInfo, error)

+ func (_m *MockTokensInterface) PublicTokenInfoCommentToTokenIdMap(ctx context.Context) (map[string]string, error)

+ func (_m *MockTokensInterface) WithImpl(impl settings.TokensService) settings.TokensInterface

+ type MockTokensInterface_Create_Call struct

+ func (_c *MockTokensInterface_Create_Call) Return(_a0 *settings.CreateTokenResponse, _a1 error) *MockTokensInterface_Create_Call

+ func (_c *MockTokensInterface_Create_Call) Run(run func(ctx context.Context, request settings.CreateTokenRequest)) *MockTokensInterface_Create_Call

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

+ type MockTokensInterface_DeleteByTokenId_Call struct

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

+ func (_c *MockTokensInterface_DeleteByTokenId_Call) Run(run func(ctx context.Context, tokenId string)) *MockTokensInterface_DeleteByTokenId_Call

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

+ type MockTokensInterface_Delete_Call struct

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

+ func (_c *MockTokensInterface_Delete_Call) Run(run func(ctx context.Context, request settings.RevokeTokenRequest)) *MockTokensInterface_Delete_Call

+ func (_c *MockTokensInterface_Delete_Call) RunAndReturn(run func(context.Context, settings.RevokeTokenRequest) error) *MockTokensInterface_Delete_Call

+ type MockTokensInterface_Expecter struct

+ func (_e *MockTokensInterface_Expecter) Create(ctx interface{}, request interface{}) *MockTokensInterface_Create_Call

+ func (_e *MockTokensInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockTokensInterface_Delete_Call

+ func (_e *MockTokensInterface_Expecter) DeleteByTokenId(ctx interface{}, tokenId interface{}) *MockTokensInterface_DeleteByTokenId_Call

+ func (_e *MockTokensInterface_Expecter) GetByComment(ctx interface{}, name interface{}) *MockTokensInterface_GetByComment_Call

+ func (_e *MockTokensInterface_Expecter) Impl() *MockTokensInterface_Impl_Call

+ func (_e *MockTokensInterface_Expecter) List(ctx interface{}) *MockTokensInterface_List_Call

+ func (_e *MockTokensInterface_Expecter) ListAll(ctx interface{}) *MockTokensInterface_ListAll_Call

+ func (_e *MockTokensInterface_Expecter) PublicTokenInfoCommentToTokenIdMap(ctx interface{}) *MockTokensInterface_PublicTokenInfoCommentToTokenIdMap_Call

+ func (_e *MockTokensInterface_Expecter) WithImpl(impl interface{}) *MockTokensInterface_WithImpl_Call

+ type MockTokensInterface_GetByComment_Call struct

+ func (_c *MockTokensInterface_GetByComment_Call) Return(_a0 *settings.PublicTokenInfo, _a1 error) *MockTokensInterface_GetByComment_Call

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

+ func (_c *MockTokensInterface_GetByComment_Call) RunAndReturn(run func(context.Context, string) (*settings.PublicTokenInfo, error)) *MockTokensInterface_GetByComment_Call

+ type MockTokensInterface_Impl_Call struct

+ func (_c *MockTokensInterface_Impl_Call) Return(_a0 settings.TokensService) *MockTokensInterface_Impl_Call

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

+ func (_c *MockTokensInterface_Impl_Call) RunAndReturn(run func() settings.TokensService) *MockTokensInterface_Impl_Call

+ type MockTokensInterface_ListAll_Call struct

+ func (_c *MockTokensInterface_ListAll_Call) Return(_a0 []settings.PublicTokenInfo, _a1 error) *MockTokensInterface_ListAll_Call

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

+ func (_c *MockTokensInterface_ListAll_Call) RunAndReturn(run func(context.Context) ([]settings.PublicTokenInfo, error)) *MockTokensInterface_ListAll_Call

+ type MockTokensInterface_List_Call struct

+ func (_c *MockTokensInterface_List_Call) Return(...) *MockTokensInterface_List_Call

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

+ func (_c *MockTokensInterface_List_Call) RunAndReturn(run func(context.Context) ...) *MockTokensInterface_List_Call

+ type MockTokensInterface_PublicTokenInfoCommentToTokenIdMap_Call struct

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

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

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

+ type MockTokensInterface_WithImpl_Call struct

+ func (_c *MockTokensInterface_WithImpl_Call) Return(_a0 settings.TokensInterface) *MockTokensInterface_WithImpl_Call

+ func (_c *MockTokensInterface_WithImpl_Call) Run(run func(impl settings.TokensService)) *MockTokensInterface_WithImpl_Call

+ func (_c *MockTokensInterface_WithImpl_Call) RunAndReturn(run func(settings.TokensService) settings.TokensInterface) *MockTokensInterface_WithImpl_Call

+ type MockWorkspaceConfInterface struct

+ func NewMockWorkspaceConfInterface(t interface{ ... }) *MockWorkspaceConfInterface

+ func (_m *MockWorkspaceConfInterface) EXPECT() *MockWorkspaceConfInterface_Expecter

+ func (_m *MockWorkspaceConfInterface) GetStatus(ctx context.Context, request settings.GetStatusRequest) (*map[string]string, error)

+ func (_m *MockWorkspaceConfInterface) Impl() settings.WorkspaceConfService

+ func (_m *MockWorkspaceConfInterface) SetStatus(ctx context.Context, request settings.WorkspaceConf) error

+ func (_m *MockWorkspaceConfInterface) WithImpl(impl settings.WorkspaceConfService) settings.WorkspaceConfInterface

+ type MockWorkspaceConfInterface_Expecter struct

+ func (_e *MockWorkspaceConfInterface_Expecter) GetStatus(ctx interface{}, request interface{}) *MockWorkspaceConfInterface_GetStatus_Call

+ func (_e *MockWorkspaceConfInterface_Expecter) Impl() *MockWorkspaceConfInterface_Impl_Call

+ func (_e *MockWorkspaceConfInterface_Expecter) SetStatus(ctx interface{}, request interface{}) *MockWorkspaceConfInterface_SetStatus_Call

+ func (_e *MockWorkspaceConfInterface_Expecter) WithImpl(impl interface{}) *MockWorkspaceConfInterface_WithImpl_Call

+ type MockWorkspaceConfInterface_GetStatus_Call struct

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

+ func (_c *MockWorkspaceConfInterface_GetStatus_Call) Run(run func(ctx context.Context, request settings.GetStatusRequest)) *MockWorkspaceConfInterface_GetStatus_Call

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

+ type MockWorkspaceConfInterface_Impl_Call struct

+ func (_c *MockWorkspaceConfInterface_Impl_Call) Return(_a0 settings.WorkspaceConfService) *MockWorkspaceConfInterface_Impl_Call

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

+ func (_c *MockWorkspaceConfInterface_Impl_Call) RunAndReturn(run func() settings.WorkspaceConfService) *MockWorkspaceConfInterface_Impl_Call

+ type MockWorkspaceConfInterface_SetStatus_Call struct

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

+ func (_c *MockWorkspaceConfInterface_SetStatus_Call) Run(run func(ctx context.Context, request settings.WorkspaceConf)) *MockWorkspaceConfInterface_SetStatus_Call

+ func (_c *MockWorkspaceConfInterface_SetStatus_Call) RunAndReturn(run func(context.Context, settings.WorkspaceConf) error) *MockWorkspaceConfInterface_SetStatus_Call

+ type MockWorkspaceConfInterface_WithImpl_Call struct

+ func (_c *MockWorkspaceConfInterface_WithImpl_Call) Return(_a0 settings.WorkspaceConfInterface) *MockWorkspaceConfInterface_WithImpl_Call

+ func (_c *MockWorkspaceConfInterface_WithImpl_Call) Run(run func(impl settings.WorkspaceConfService)) *MockWorkspaceConfInterface_WithImpl_Call

+ func (_c *MockWorkspaceConfInterface_WithImpl_Call) RunAndReturn(run func(settings.WorkspaceConfService) settings.WorkspaceConfInterface) *MockWorkspaceConfInterface_WithImpl_Call

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