fake

package
v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 17, 2023 License: MIT Imports: 19 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AgentPoolsServer 

type AgentPoolsServer struct {
	// BeginCreate is the fake for method AgentPoolsClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, agentPoolName string, agentPool armcontainerregistry.AgentPool, options *armcontainerregistry.AgentPoolsClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.AgentPoolsClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method AgentPoolsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, agentPoolName string, options *armcontainerregistry.AgentPoolsClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.AgentPoolsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method AgentPoolsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, agentPoolName string, options *armcontainerregistry.AgentPoolsClientGetOptions) (resp azfake.Responder[armcontainerregistry.AgentPoolsClientGetResponse], errResp azfake.ErrorResponder)

	// GetQueueStatus is the fake for method AgentPoolsClient.GetQueueStatus
	// HTTP status codes to indicate success: http.StatusOK
	GetQueueStatus func(ctx context.Context, resourceGroupName string, registryName string, agentPoolName string, options *armcontainerregistry.AgentPoolsClientGetQueueStatusOptions) (resp azfake.Responder[armcontainerregistry.AgentPoolsClientGetQueueStatusResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method AgentPoolsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.AgentPoolsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.AgentPoolsClientListResponse])

	// BeginUpdate is the fake for method AgentPoolsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, agentPoolName string, updateParameters armcontainerregistry.AgentPoolUpdateParameters, options *armcontainerregistry.AgentPoolsClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.AgentPoolsClientUpdateResponse], errResp azfake.ErrorResponder)
}

AgentPoolsServer is a fake server for instances of the armcontainerregistry.AgentPoolsClient type.

type AgentPoolsServerTransport 

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

AgentPoolsServerTransport connects instances of armcontainerregistry.AgentPoolsClient to instances of AgentPoolsServer. Don't use this type directly, use NewAgentPoolsServerTransport instead.

func NewAgentPoolsServerTransport 

func NewAgentPoolsServerTransport(srv *AgentPoolsServer) *AgentPoolsServerTransport

NewAgentPoolsServerTransport creates a new instance of AgentPoolsServerTransport with the provided implementation. The returned AgentPoolsServerTransport instance is connected to an instance of armcontainerregistry.AgentPoolsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AgentPoolsServerTransport) Do 

func (a *AgentPoolsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for AgentPoolsServerTransport.

type CacheRulesServer 

type CacheRulesServer struct {
	// BeginCreate is the fake for method CacheRulesClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, cacheRuleName string, cacheRuleCreateParameters armcontainerregistry.CacheRule, options *armcontainerregistry.CacheRulesClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.CacheRulesClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method CacheRulesClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, cacheRuleName string, options *armcontainerregistry.CacheRulesClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.CacheRulesClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method CacheRulesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, cacheRuleName string, options *armcontainerregistry.CacheRulesClientGetOptions) (resp azfake.Responder[armcontainerregistry.CacheRulesClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method CacheRulesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.CacheRulesClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.CacheRulesClientListResponse])

	// BeginUpdate is the fake for method CacheRulesClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, cacheRuleName string, cacheRuleUpdateParameters armcontainerregistry.CacheRuleUpdateParameters, options *armcontainerregistry.CacheRulesClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.CacheRulesClientUpdateResponse], errResp azfake.ErrorResponder)
}

CacheRulesServer is a fake server for instances of the armcontainerregistry.CacheRulesClient type.

type CacheRulesServerTransport 

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

CacheRulesServerTransport connects instances of armcontainerregistry.CacheRulesClient to instances of CacheRulesServer. Don't use this type directly, use NewCacheRulesServerTransport instead.

func NewCacheRulesServerTransport 

func NewCacheRulesServerTransport(srv *CacheRulesServer) *CacheRulesServerTransport

NewCacheRulesServerTransport creates a new instance of CacheRulesServerTransport with the provided implementation. The returned CacheRulesServerTransport instance is connected to an instance of armcontainerregistry.CacheRulesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*CacheRulesServerTransport) Do 

func (c *CacheRulesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for CacheRulesServerTransport.

type CredentialSetsServer 

type CredentialSetsServer struct {
	// BeginCreate is the fake for method CredentialSetsClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, credentialSetName string, credentialSetCreateParameters armcontainerregistry.CredentialSet, options *armcontainerregistry.CredentialSetsClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.CredentialSetsClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method CredentialSetsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, credentialSetName string, options *armcontainerregistry.CredentialSetsClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.CredentialSetsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method CredentialSetsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, credentialSetName string, options *armcontainerregistry.CredentialSetsClientGetOptions) (resp azfake.Responder[armcontainerregistry.CredentialSetsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method CredentialSetsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.CredentialSetsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.CredentialSetsClientListResponse])

	// BeginUpdate is the fake for method CredentialSetsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, credentialSetName string, credentialSetUpdateParameters armcontainerregistry.CredentialSetUpdateParameters, options *armcontainerregistry.CredentialSetsClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.CredentialSetsClientUpdateResponse], errResp azfake.ErrorResponder)
}

CredentialSetsServer is a fake server for instances of the armcontainerregistry.CredentialSetsClient type.

type CredentialSetsServerTransport 

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

CredentialSetsServerTransport connects instances of armcontainerregistry.CredentialSetsClient to instances of CredentialSetsServer. Don't use this type directly, use NewCredentialSetsServerTransport instead.

func NewCredentialSetsServerTransport 

func NewCredentialSetsServerTransport(srv *CredentialSetsServer) *CredentialSetsServerTransport

NewCredentialSetsServerTransport creates a new instance of CredentialSetsServerTransport with the provided implementation. The returned CredentialSetsServerTransport instance is connected to an instance of armcontainerregistry.CredentialSetsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*CredentialSetsServerTransport) Do 

func (c *CredentialSetsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for CredentialSetsServerTransport.

type OperationsServer 

type OperationsServer struct {
	// NewListPager is the fake for method OperationsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armcontainerregistry.OperationsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.OperationsClientListResponse])
}

OperationsServer is a fake server for instances of the armcontainerregistry.OperationsClient type.

type OperationsServerTransport 

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

OperationsServerTransport connects instances of armcontainerregistry.OperationsClient to instances of OperationsServer. Don't use this type directly, use NewOperationsServerTransport instead.

func NewOperationsServerTransport 

func NewOperationsServerTransport(srv *OperationsServer) *OperationsServerTransport

NewOperationsServerTransport creates a new instance of OperationsServerTransport with the provided implementation. The returned OperationsServerTransport instance is connected to an instance of armcontainerregistry.OperationsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*OperationsServerTransport) Do 

func (o *OperationsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for OperationsServerTransport.

type PrivateEndpointConnectionsServer 

type PrivateEndpointConnectionsServer struct {
	// BeginCreateOrUpdate is the fake for method PrivateEndpointConnectionsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, registryName string, privateEndpointConnectionName string, privateEndpointConnection armcontainerregistry.PrivateEndpointConnection, options *armcontainerregistry.PrivateEndpointConnectionsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.PrivateEndpointConnectionsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method PrivateEndpointConnectionsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, privateEndpointConnectionName string, options *armcontainerregistry.PrivateEndpointConnectionsClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.PrivateEndpointConnectionsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method PrivateEndpointConnectionsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, privateEndpointConnectionName string, options *armcontainerregistry.PrivateEndpointConnectionsClientGetOptions) (resp azfake.Responder[armcontainerregistry.PrivateEndpointConnectionsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method PrivateEndpointConnectionsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.PrivateEndpointConnectionsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.PrivateEndpointConnectionsClientListResponse])
}

PrivateEndpointConnectionsServer is a fake server for instances of the armcontainerregistry.PrivateEndpointConnectionsClient type.

type PrivateEndpointConnectionsServerTransport 

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

PrivateEndpointConnectionsServerTransport connects instances of armcontainerregistry.PrivateEndpointConnectionsClient to instances of PrivateEndpointConnectionsServer. Don't use this type directly, use NewPrivateEndpointConnectionsServerTransport instead.

func NewPrivateEndpointConnectionsServerTransport 

func NewPrivateEndpointConnectionsServerTransport(srv *PrivateEndpointConnectionsServer) *PrivateEndpointConnectionsServerTransport

NewPrivateEndpointConnectionsServerTransport creates a new instance of PrivateEndpointConnectionsServerTransport with the provided implementation. The returned PrivateEndpointConnectionsServerTransport instance is connected to an instance of armcontainerregistry.PrivateEndpointConnectionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*PrivateEndpointConnectionsServerTransport) Do 

func (p *PrivateEndpointConnectionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for PrivateEndpointConnectionsServerTransport.

type RegistriesServer 

type RegistriesServer struct {
	// CheckNameAvailability is the fake for method RegistriesClient.CheckNameAvailability
	// HTTP status codes to indicate success: http.StatusOK
	CheckNameAvailability func(ctx context.Context, registryNameCheckRequest armcontainerregistry.RegistryNameCheckRequest, options *armcontainerregistry.RegistriesClientCheckNameAvailabilityOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientCheckNameAvailabilityResponse], errResp azfake.ErrorResponder)

	// BeginCreate is the fake for method RegistriesClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, registry armcontainerregistry.Registry, options *armcontainerregistry.RegistriesClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.RegistriesClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method RegistriesClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, options *armcontainerregistry.RegistriesClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.RegistriesClientDeleteResponse], errResp azfake.ErrorResponder)

	// BeginGenerateCredentials is the fake for method RegistriesClient.BeginGenerateCredentials
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginGenerateCredentials func(ctx context.Context, resourceGroupName string, registryName string, generateCredentialsParameters armcontainerregistry.GenerateCredentialsParameters, options *armcontainerregistry.RegistriesClientBeginGenerateCredentialsOptions) (resp azfake.PollerResponder[armcontainerregistry.RegistriesClientGenerateCredentialsResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method RegistriesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, options *armcontainerregistry.RegistriesClientGetOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientGetResponse], errResp azfake.ErrorResponder)

	// GetBuildSourceUploadURL is the fake for method RegistriesClient.GetBuildSourceUploadURL
	// HTTP status codes to indicate success: http.StatusOK
	GetBuildSourceUploadURL func(ctx context.Context, resourceGroupName string, registryName string, options *armcontainerregistry.RegistriesClientGetBuildSourceUploadURLOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientGetBuildSourceUploadURLResponse], errResp azfake.ErrorResponder)

	// GetPrivateLinkResource is the fake for method RegistriesClient.GetPrivateLinkResource
	// HTTP status codes to indicate success: http.StatusOK
	GetPrivateLinkResource func(ctx context.Context, resourceGroupName string, registryName string, groupName string, options *armcontainerregistry.RegistriesClientGetPrivateLinkResourceOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientGetPrivateLinkResourceResponse], errResp azfake.ErrorResponder)

	// BeginImportImage is the fake for method RegistriesClient.BeginImportImage
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginImportImage func(ctx context.Context, resourceGroupName string, registryName string, parameters armcontainerregistry.ImportImageParameters, options *armcontainerregistry.RegistriesClientBeginImportImageOptions) (resp azfake.PollerResponder[armcontainerregistry.RegistriesClientImportImageResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method RegistriesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armcontainerregistry.RegistriesClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.RegistriesClientListResponse])

	// NewListByResourceGroupPager is the fake for method RegistriesClient.NewListByResourceGroupPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByResourceGroupPager func(resourceGroupName string, options *armcontainerregistry.RegistriesClientListByResourceGroupOptions) (resp azfake.PagerResponder[armcontainerregistry.RegistriesClientListByResourceGroupResponse])

	// ListCredentials is the fake for method RegistriesClient.ListCredentials
	// HTTP status codes to indicate success: http.StatusOK
	ListCredentials func(ctx context.Context, resourceGroupName string, registryName string, options *armcontainerregistry.RegistriesClientListCredentialsOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientListCredentialsResponse], errResp azfake.ErrorResponder)

	// NewListPrivateLinkResourcesPager is the fake for method RegistriesClient.NewListPrivateLinkResourcesPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPrivateLinkResourcesPager func(resourceGroupName string, registryName string, options *armcontainerregistry.RegistriesClientListPrivateLinkResourcesOptions) (resp azfake.PagerResponder[armcontainerregistry.RegistriesClientListPrivateLinkResourcesResponse])

	// ListUsages is the fake for method RegistriesClient.ListUsages
	// HTTP status codes to indicate success: http.StatusOK
	ListUsages func(ctx context.Context, resourceGroupName string, registryName string, options *armcontainerregistry.RegistriesClientListUsagesOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientListUsagesResponse], errResp azfake.ErrorResponder)

	// RegenerateCredential is the fake for method RegistriesClient.RegenerateCredential
	// HTTP status codes to indicate success: http.StatusOK
	RegenerateCredential func(ctx context.Context, resourceGroupName string, registryName string, regenerateCredentialParameters armcontainerregistry.RegenerateCredentialParameters, options *armcontainerregistry.RegistriesClientRegenerateCredentialOptions) (resp azfake.Responder[armcontainerregistry.RegistriesClientRegenerateCredentialResponse], errResp azfake.ErrorResponder)

	// BeginScheduleRun is the fake for method RegistriesClient.BeginScheduleRun
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginScheduleRun func(ctx context.Context, resourceGroupName string, registryName string, runRequest armcontainerregistry.RunRequestClassification, options *armcontainerregistry.RegistriesClientBeginScheduleRunOptions) (resp azfake.PollerResponder[armcontainerregistry.RegistriesClientScheduleRunResponse], errResp azfake.ErrorResponder)

	// BeginUpdate is the fake for method RegistriesClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, registryUpdateParameters armcontainerregistry.RegistryUpdateParameters, options *armcontainerregistry.RegistriesClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.RegistriesClientUpdateResponse], errResp azfake.ErrorResponder)
}

RegistriesServer is a fake server for instances of the armcontainerregistry.RegistriesClient type.

type RegistriesServerTransport 

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

RegistriesServerTransport connects instances of armcontainerregistry.RegistriesClient to instances of RegistriesServer. Don't use this type directly, use NewRegistriesServerTransport instead.

func NewRegistriesServerTransport 

func NewRegistriesServerTransport(srv *RegistriesServer) *RegistriesServerTransport

NewRegistriesServerTransport creates a new instance of RegistriesServerTransport with the provided implementation. The returned RegistriesServerTransport instance is connected to an instance of armcontainerregistry.RegistriesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*RegistriesServerTransport) Do 

func (r *RegistriesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for RegistriesServerTransport.

type ReplicationsServer 

type ReplicationsServer struct {
	// BeginCreate is the fake for method ReplicationsClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, replicationName string, replication armcontainerregistry.Replication, options *armcontainerregistry.ReplicationsClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.ReplicationsClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method ReplicationsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, replicationName string, options *armcontainerregistry.ReplicationsClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.ReplicationsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ReplicationsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, replicationName string, options *armcontainerregistry.ReplicationsClientGetOptions) (resp azfake.Responder[armcontainerregistry.ReplicationsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ReplicationsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.ReplicationsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.ReplicationsClientListResponse])

	// BeginUpdate is the fake for method ReplicationsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, replicationName string, replicationUpdateParameters armcontainerregistry.ReplicationUpdateParameters, options *armcontainerregistry.ReplicationsClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.ReplicationsClientUpdateResponse], errResp azfake.ErrorResponder)
}

ReplicationsServer is a fake server for instances of the armcontainerregistry.ReplicationsClient type.

type ReplicationsServerTransport 

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

ReplicationsServerTransport connects instances of armcontainerregistry.ReplicationsClient to instances of ReplicationsServer. Don't use this type directly, use NewReplicationsServerTransport instead.

func NewReplicationsServerTransport 

func NewReplicationsServerTransport(srv *ReplicationsServer) *ReplicationsServerTransport

NewReplicationsServerTransport creates a new instance of ReplicationsServerTransport with the provided implementation. The returned ReplicationsServerTransport instance is connected to an instance of armcontainerregistry.ReplicationsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ReplicationsServerTransport) Do 

func (r *ReplicationsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ReplicationsServerTransport.

type RunsServer 

type RunsServer struct {
	// BeginCancel is the fake for method RunsClient.BeginCancel
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginCancel func(ctx context.Context, resourceGroupName string, registryName string, runID string, options *armcontainerregistry.RunsClientBeginCancelOptions) (resp azfake.PollerResponder[armcontainerregistry.RunsClientCancelResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method RunsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, runID string, options *armcontainerregistry.RunsClientGetOptions) (resp azfake.Responder[armcontainerregistry.RunsClientGetResponse], errResp azfake.ErrorResponder)

	// GetLogSasURL is the fake for method RunsClient.GetLogSasURL
	// HTTP status codes to indicate success: http.StatusOK
	GetLogSasURL func(ctx context.Context, resourceGroupName string, registryName string, runID string, options *armcontainerregistry.RunsClientGetLogSasURLOptions) (resp azfake.Responder[armcontainerregistry.RunsClientGetLogSasURLResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method RunsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.RunsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.RunsClientListResponse])

	// BeginUpdate is the fake for method RunsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, runID string, runUpdateParameters armcontainerregistry.RunUpdateParameters, options *armcontainerregistry.RunsClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.RunsClientUpdateResponse], errResp azfake.ErrorResponder)
}

RunsServer is a fake server for instances of the armcontainerregistry.RunsClient type.

type RunsServerTransport 

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

RunsServerTransport connects instances of armcontainerregistry.RunsClient to instances of RunsServer. Don't use this type directly, use NewRunsServerTransport instead.

func NewRunsServerTransport 

func NewRunsServerTransport(srv *RunsServer) *RunsServerTransport

NewRunsServerTransport creates a new instance of RunsServerTransport with the provided implementation. The returned RunsServerTransport instance is connected to an instance of armcontainerregistry.RunsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*RunsServerTransport) Do 

func (r *RunsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for RunsServerTransport.

type ScopeMapsServer 

type ScopeMapsServer struct {
	// BeginCreate is the fake for method ScopeMapsClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, scopeMapName string, scopeMapCreateParameters armcontainerregistry.ScopeMap, options *armcontainerregistry.ScopeMapsClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.ScopeMapsClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method ScopeMapsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, scopeMapName string, options *armcontainerregistry.ScopeMapsClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.ScopeMapsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ScopeMapsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, scopeMapName string, options *armcontainerregistry.ScopeMapsClientGetOptions) (resp azfake.Responder[armcontainerregistry.ScopeMapsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ScopeMapsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.ScopeMapsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.ScopeMapsClientListResponse])

	// BeginUpdate is the fake for method ScopeMapsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, scopeMapName string, scopeMapUpdateParameters armcontainerregistry.ScopeMapUpdateParameters, options *armcontainerregistry.ScopeMapsClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.ScopeMapsClientUpdateResponse], errResp azfake.ErrorResponder)
}

ScopeMapsServer is a fake server for instances of the armcontainerregistry.ScopeMapsClient type.

type ScopeMapsServerTransport 

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

ScopeMapsServerTransport connects instances of armcontainerregistry.ScopeMapsClient to instances of ScopeMapsServer. Don't use this type directly, use NewScopeMapsServerTransport instead.

func NewScopeMapsServerTransport 

func NewScopeMapsServerTransport(srv *ScopeMapsServer) *ScopeMapsServerTransport

NewScopeMapsServerTransport creates a new instance of ScopeMapsServerTransport with the provided implementation. The returned ScopeMapsServerTransport instance is connected to an instance of armcontainerregistry.ScopeMapsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ScopeMapsServerTransport) Do 

func (s *ScopeMapsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ScopeMapsServerTransport.

type ServerFactory 

type ServerFactory struct {
	AgentPoolsServer                 AgentPoolsServer
	CacheRulesServer                 CacheRulesServer
	CredentialSetsServer             CredentialSetsServer
	OperationsServer                 OperationsServer
	PrivateEndpointConnectionsServer PrivateEndpointConnectionsServer
	RegistriesServer                 RegistriesServer
	ReplicationsServer               ReplicationsServer
	RunsServer                       RunsServer
	ScopeMapsServer                  ScopeMapsServer
	TaskRunsServer                   TaskRunsServer
	TasksServer                      TasksServer
	TokensServer                     TokensServer
	WebhooksServer                   WebhooksServer
}

ServerFactory is a fake server for instances of the armcontainerregistry.ClientFactory type.

type ServerFactoryTransport 

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

ServerFactoryTransport connects instances of armcontainerregistry.ClientFactory to instances of ServerFactory. Don't use this type directly, use NewServerFactoryTransport instead.

func NewServerFactoryTransport 

func NewServerFactoryTransport(srv *ServerFactory) *ServerFactoryTransport

NewServerFactoryTransport creates a new instance of ServerFactoryTransport with the provided implementation. The returned ServerFactoryTransport instance is connected to an instance of armcontainerregistry.ClientFactory via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ServerFactoryTransport) Do 

func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ServerFactoryTransport.

type TaskRunsServer 

type TaskRunsServer struct {
	// BeginCreate is the fake for method TaskRunsClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, taskRun armcontainerregistry.TaskRun, options *armcontainerregistry.TaskRunsClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.TaskRunsClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method TaskRunsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *armcontainerregistry.TaskRunsClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.TaskRunsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method TaskRunsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *armcontainerregistry.TaskRunsClientGetOptions) (resp azfake.Responder[armcontainerregistry.TaskRunsClientGetResponse], errResp azfake.ErrorResponder)

	// GetDetails is the fake for method TaskRunsClient.GetDetails
	// HTTP status codes to indicate success: http.StatusOK
	GetDetails func(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *armcontainerregistry.TaskRunsClientGetDetailsOptions) (resp azfake.Responder[armcontainerregistry.TaskRunsClientGetDetailsResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method TaskRunsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.TaskRunsClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.TaskRunsClientListResponse])

	// BeginUpdate is the fake for method TaskRunsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, updateParameters armcontainerregistry.TaskRunUpdateParameters, options *armcontainerregistry.TaskRunsClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.TaskRunsClientUpdateResponse], errResp azfake.ErrorResponder)
}

TaskRunsServer is a fake server for instances of the armcontainerregistry.TaskRunsClient type.

type TaskRunsServerTransport 

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

TaskRunsServerTransport connects instances of armcontainerregistry.TaskRunsClient to instances of TaskRunsServer. Don't use this type directly, use NewTaskRunsServerTransport instead.

func NewTaskRunsServerTransport 

func NewTaskRunsServerTransport(srv *TaskRunsServer) *TaskRunsServerTransport

NewTaskRunsServerTransport creates a new instance of TaskRunsServerTransport with the provided implementation. The returned TaskRunsServerTransport instance is connected to an instance of armcontainerregistry.TaskRunsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*TaskRunsServerTransport) Do 

func (t *TaskRunsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for TaskRunsServerTransport.

type TasksServer 

type TasksServer struct {
	// BeginCreate is the fake for method TasksClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, taskName string, taskCreateParameters armcontainerregistry.Task, options *armcontainerregistry.TasksClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.TasksClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method TasksClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, taskName string, options *armcontainerregistry.TasksClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.TasksClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method TasksClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, taskName string, options *armcontainerregistry.TasksClientGetOptions) (resp azfake.Responder[armcontainerregistry.TasksClientGetResponse], errResp azfake.ErrorResponder)

	// GetDetails is the fake for method TasksClient.GetDetails
	// HTTP status codes to indicate success: http.StatusOK
	GetDetails func(ctx context.Context, resourceGroupName string, registryName string, taskName string, options *armcontainerregistry.TasksClientGetDetailsOptions) (resp azfake.Responder[armcontainerregistry.TasksClientGetDetailsResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method TasksClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.TasksClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.TasksClientListResponse])

	// BeginUpdate is the fake for method TasksClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, taskName string, taskUpdateParameters armcontainerregistry.TaskUpdateParameters, options *armcontainerregistry.TasksClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.TasksClientUpdateResponse], errResp azfake.ErrorResponder)
}

TasksServer is a fake server for instances of the armcontainerregistry.TasksClient type.

type TasksServerTransport 

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

TasksServerTransport connects instances of armcontainerregistry.TasksClient to instances of TasksServer. Don't use this type directly, use NewTasksServerTransport instead.

func NewTasksServerTransport 

func NewTasksServerTransport(srv *TasksServer) *TasksServerTransport

NewTasksServerTransport creates a new instance of TasksServerTransport with the provided implementation. The returned TasksServerTransport instance is connected to an instance of armcontainerregistry.TasksClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*TasksServerTransport) Do 

func (t *TasksServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for TasksServerTransport.

type TokensServer 

type TokensServer struct {
	// BeginCreate is the fake for method TokensClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, tokenName string, tokenCreateParameters armcontainerregistry.Token, options *armcontainerregistry.TokensClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.TokensClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method TokensClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, tokenName string, options *armcontainerregistry.TokensClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.TokensClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method TokensClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, tokenName string, options *armcontainerregistry.TokensClientGetOptions) (resp azfake.Responder[armcontainerregistry.TokensClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method TokensClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.TokensClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.TokensClientListResponse])

	// BeginUpdate is the fake for method TokensClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, tokenName string, tokenUpdateParameters armcontainerregistry.TokenUpdateParameters, options *armcontainerregistry.TokensClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.TokensClientUpdateResponse], errResp azfake.ErrorResponder)
}

TokensServer is a fake server for instances of the armcontainerregistry.TokensClient type.

type TokensServerTransport 

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

TokensServerTransport connects instances of armcontainerregistry.TokensClient to instances of TokensServer. Don't use this type directly, use NewTokensServerTransport instead.

func NewTokensServerTransport 

func NewTokensServerTransport(srv *TokensServer) *TokensServerTransport

NewTokensServerTransport creates a new instance of TokensServerTransport with the provided implementation. The returned TokensServerTransport instance is connected to an instance of armcontainerregistry.TokensClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*TokensServerTransport) Do 

func (t *TokensServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for TokensServerTransport.

type WebhooksServer 

type WebhooksServer struct {
	// BeginCreate is the fake for method WebhooksClient.BeginCreate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreate func(ctx context.Context, resourceGroupName string, registryName string, webhookName string, webhookCreateParameters armcontainerregistry.WebhookCreateParameters, options *armcontainerregistry.WebhooksClientBeginCreateOptions) (resp azfake.PollerResponder[armcontainerregistry.WebhooksClientCreateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method WebhooksClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, registryName string, webhookName string, options *armcontainerregistry.WebhooksClientBeginDeleteOptions) (resp azfake.PollerResponder[armcontainerregistry.WebhooksClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method WebhooksClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, registryName string, webhookName string, options *armcontainerregistry.WebhooksClientGetOptions) (resp azfake.Responder[armcontainerregistry.WebhooksClientGetResponse], errResp azfake.ErrorResponder)

	// GetCallbackConfig is the fake for method WebhooksClient.GetCallbackConfig
	// HTTP status codes to indicate success: http.StatusOK
	GetCallbackConfig func(ctx context.Context, resourceGroupName string, registryName string, webhookName string, options *armcontainerregistry.WebhooksClientGetCallbackConfigOptions) (resp azfake.Responder[armcontainerregistry.WebhooksClientGetCallbackConfigResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method WebhooksClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, registryName string, options *armcontainerregistry.WebhooksClientListOptions) (resp azfake.PagerResponder[armcontainerregistry.WebhooksClientListResponse])

	// NewListEventsPager is the fake for method WebhooksClient.NewListEventsPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListEventsPager func(resourceGroupName string, registryName string, webhookName string, options *armcontainerregistry.WebhooksClientListEventsOptions) (resp azfake.PagerResponder[armcontainerregistry.WebhooksClientListEventsResponse])

	// Ping is the fake for method WebhooksClient.Ping
	// HTTP status codes to indicate success: http.StatusOK
	Ping func(ctx context.Context, resourceGroupName string, registryName string, webhookName string, options *armcontainerregistry.WebhooksClientPingOptions) (resp azfake.Responder[armcontainerregistry.WebhooksClientPingResponse], errResp azfake.ErrorResponder)

	// BeginUpdate is the fake for method WebhooksClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, resourceGroupName string, registryName string, webhookName string, webhookUpdateParameters armcontainerregistry.WebhookUpdateParameters, options *armcontainerregistry.WebhooksClientBeginUpdateOptions) (resp azfake.PollerResponder[armcontainerregistry.WebhooksClientUpdateResponse], errResp azfake.ErrorResponder)
}

WebhooksServer is a fake server for instances of the armcontainerregistry.WebhooksClient type.

type WebhooksServerTransport 

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

WebhooksServerTransport connects instances of armcontainerregistry.WebhooksClient to instances of WebhooksServer. Don't use this type directly, use NewWebhooksServerTransport instead.

func NewWebhooksServerTransport 

func NewWebhooksServerTransport(srv *WebhooksServer) *WebhooksServerTransport

NewWebhooksServerTransport creates a new instance of WebhooksServerTransport with the provided implementation. The returned WebhooksServerTransport instance is connected to an instance of armcontainerregistry.WebhooksClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*WebhooksServerTransport) Do 

func (w *WebhooksServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for WebhooksServerTransport.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.