fake

package
v2.1.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AvailableWorkloadProfilesServer 

type AvailableWorkloadProfilesServer struct {
	// NewGetPager is the fake for method AvailableWorkloadProfilesClient.NewGetPager
	// HTTP status codes to indicate success: http.StatusOK
	NewGetPager func(location string, options *armappcontainers.AvailableWorkloadProfilesClientGetOptions) (resp azfake.PagerResponder[armappcontainers.AvailableWorkloadProfilesClientGetResponse])
}

AvailableWorkloadProfilesServer is a fake server for instances of the armappcontainers.AvailableWorkloadProfilesClient type.

type AvailableWorkloadProfilesServerTransport 

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

AvailableWorkloadProfilesServerTransport connects instances of armappcontainers.AvailableWorkloadProfilesClient to instances of AvailableWorkloadProfilesServer. Don't use this type directly, use NewAvailableWorkloadProfilesServerTransport instead.

func NewAvailableWorkloadProfilesServerTransport 

func NewAvailableWorkloadProfilesServerTransport(srv *AvailableWorkloadProfilesServer) *AvailableWorkloadProfilesServerTransport

NewAvailableWorkloadProfilesServerTransport creates a new instance of AvailableWorkloadProfilesServerTransport with the provided implementation. The returned AvailableWorkloadProfilesServerTransport instance is connected to an instance of armappcontainers.AvailableWorkloadProfilesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AvailableWorkloadProfilesServerTransport) Do 

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

Do implements the policy.Transporter interface for AvailableWorkloadProfilesServerTransport.

type BillingMetersServer 

type BillingMetersServer struct {
	// Get is the fake for method BillingMetersClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, location string, options *armappcontainers.BillingMetersClientGetOptions) (resp azfake.Responder[armappcontainers.BillingMetersClientGetResponse], errResp azfake.ErrorResponder)
}

BillingMetersServer is a fake server for instances of the armappcontainers.BillingMetersClient type.

type BillingMetersServerTransport 

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

BillingMetersServerTransport connects instances of armappcontainers.BillingMetersClient to instances of BillingMetersServer. Don't use this type directly, use NewBillingMetersServerTransport instead.

func NewBillingMetersServerTransport 

func NewBillingMetersServerTransport(srv *BillingMetersServer) *BillingMetersServerTransport

NewBillingMetersServerTransport creates a new instance of BillingMetersServerTransport with the provided implementation. The returned BillingMetersServerTransport instance is connected to an instance of armappcontainers.BillingMetersClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*BillingMetersServerTransport) Do 

func (b *BillingMetersServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for BillingMetersServerTransport.

type CertificatesServer 

type CertificatesServer struct {
	// CreateOrUpdate is the fake for method CertificatesClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, certificateName string, options *armappcontainers.CertificatesClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.CertificatesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method CertificatesClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, environmentName string, certificateName string, options *armappcontainers.CertificatesClientDeleteOptions) (resp azfake.Responder[armappcontainers.CertificatesClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method CertificatesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, environmentName string, certificateName string, options *armappcontainers.CertificatesClientGetOptions) (resp azfake.Responder[armappcontainers.CertificatesClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method CertificatesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, environmentName string, options *armappcontainers.CertificatesClientListOptions) (resp azfake.PagerResponder[armappcontainers.CertificatesClientListResponse])

	// Update is the fake for method CertificatesClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, resourceGroupName string, environmentName string, certificateName string, certificateEnvelope armappcontainers.CertificatePatch, options *armappcontainers.CertificatesClientUpdateOptions) (resp azfake.Responder[armappcontainers.CertificatesClientUpdateResponse], errResp azfake.ErrorResponder)
}

CertificatesServer is a fake server for instances of the armappcontainers.CertificatesClient type.

type CertificatesServerTransport 

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

CertificatesServerTransport connects instances of armappcontainers.CertificatesClient to instances of CertificatesServer. Don't use this type directly, use NewCertificatesServerTransport instead.

func NewCertificatesServerTransport 

func NewCertificatesServerTransport(srv *CertificatesServer) *CertificatesServerTransport

NewCertificatesServerTransport creates a new instance of CertificatesServerTransport with the provided implementation. The returned CertificatesServerTransport instance is connected to an instance of armappcontainers.CertificatesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*CertificatesServerTransport) Do 

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

Do implements the policy.Transporter interface for CertificatesServerTransport.

type ConnectedEnvironmentsCertificatesServer 

type ConnectedEnvironmentsCertificatesServer struct {
	// CreateOrUpdate is the fake for method ConnectedEnvironmentsCertificatesClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, certificateName string, options *armappcontainers.ConnectedEnvironmentsCertificatesClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsCertificatesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method ConnectedEnvironmentsCertificatesClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, certificateName string, options *armappcontainers.ConnectedEnvironmentsCertificatesClientDeleteOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsCertificatesClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ConnectedEnvironmentsCertificatesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, certificateName string, options *armappcontainers.ConnectedEnvironmentsCertificatesClientGetOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsCertificatesClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ConnectedEnvironmentsCertificatesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, connectedEnvironmentName string, options *armappcontainers.ConnectedEnvironmentsCertificatesClientListOptions) (resp azfake.PagerResponder[armappcontainers.ConnectedEnvironmentsCertificatesClientListResponse])

	// Update is the fake for method ConnectedEnvironmentsCertificatesClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, certificateName string, certificateEnvelope armappcontainers.CertificatePatch, options *armappcontainers.ConnectedEnvironmentsCertificatesClientUpdateOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsCertificatesClientUpdateResponse], errResp azfake.ErrorResponder)
}

ConnectedEnvironmentsCertificatesServer is a fake server for instances of the armappcontainers.ConnectedEnvironmentsCertificatesClient type.

type ConnectedEnvironmentsCertificatesServerTransport 

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

ConnectedEnvironmentsCertificatesServerTransport connects instances of armappcontainers.ConnectedEnvironmentsCertificatesClient to instances of ConnectedEnvironmentsCertificatesServer. Don't use this type directly, use NewConnectedEnvironmentsCertificatesServerTransport instead.

func NewConnectedEnvironmentsCertificatesServerTransport 

func NewConnectedEnvironmentsCertificatesServerTransport(srv *ConnectedEnvironmentsCertificatesServer) *ConnectedEnvironmentsCertificatesServerTransport

NewConnectedEnvironmentsCertificatesServerTransport creates a new instance of ConnectedEnvironmentsCertificatesServerTransport with the provided implementation. The returned ConnectedEnvironmentsCertificatesServerTransport instance is connected to an instance of armappcontainers.ConnectedEnvironmentsCertificatesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ConnectedEnvironmentsCertificatesServerTransport) Do 

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

Do implements the policy.Transporter interface for ConnectedEnvironmentsCertificatesServerTransport.

type ConnectedEnvironmentsDaprComponentsServer 

type ConnectedEnvironmentsDaprComponentsServer struct {
	// CreateOrUpdate is the fake for method ConnectedEnvironmentsDaprComponentsClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, componentName string, daprComponentEnvelope armappcontainers.DaprComponent, options *armappcontainers.ConnectedEnvironmentsDaprComponentsClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsDaprComponentsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method ConnectedEnvironmentsDaprComponentsClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, componentName string, options *armappcontainers.ConnectedEnvironmentsDaprComponentsClientDeleteOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsDaprComponentsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ConnectedEnvironmentsDaprComponentsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, componentName string, options *armappcontainers.ConnectedEnvironmentsDaprComponentsClientGetOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsDaprComponentsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ConnectedEnvironmentsDaprComponentsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, connectedEnvironmentName string, options *armappcontainers.ConnectedEnvironmentsDaprComponentsClientListOptions) (resp azfake.PagerResponder[armappcontainers.ConnectedEnvironmentsDaprComponentsClientListResponse])

	// ListSecrets is the fake for method ConnectedEnvironmentsDaprComponentsClient.ListSecrets
	// HTTP status codes to indicate success: http.StatusOK
	ListSecrets func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, componentName string, options *armappcontainers.ConnectedEnvironmentsDaprComponentsClientListSecretsOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsDaprComponentsClientListSecretsResponse], errResp azfake.ErrorResponder)
}

ConnectedEnvironmentsDaprComponentsServer is a fake server for instances of the armappcontainers.ConnectedEnvironmentsDaprComponentsClient type.

type ConnectedEnvironmentsDaprComponentsServerTransport 

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

ConnectedEnvironmentsDaprComponentsServerTransport connects instances of armappcontainers.ConnectedEnvironmentsDaprComponentsClient to instances of ConnectedEnvironmentsDaprComponentsServer. Don't use this type directly, use NewConnectedEnvironmentsDaprComponentsServerTransport instead.

func NewConnectedEnvironmentsDaprComponentsServerTransport 

func NewConnectedEnvironmentsDaprComponentsServerTransport(srv *ConnectedEnvironmentsDaprComponentsServer) *ConnectedEnvironmentsDaprComponentsServerTransport

NewConnectedEnvironmentsDaprComponentsServerTransport creates a new instance of ConnectedEnvironmentsDaprComponentsServerTransport with the provided implementation. The returned ConnectedEnvironmentsDaprComponentsServerTransport instance is connected to an instance of armappcontainers.ConnectedEnvironmentsDaprComponentsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ConnectedEnvironmentsDaprComponentsServerTransport) Do 

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

Do implements the policy.Transporter interface for ConnectedEnvironmentsDaprComponentsServerTransport.

type ConnectedEnvironmentsServer 

type ConnectedEnvironmentsServer struct {
	// CheckNameAvailability is the fake for method ConnectedEnvironmentsClient.CheckNameAvailability
	// HTTP status codes to indicate success: http.StatusOK
	CheckNameAvailability func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, checkNameAvailabilityRequest armappcontainers.CheckNameAvailabilityRequest, options *armappcontainers.ConnectedEnvironmentsClientCheckNameAvailabilityOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsClientCheckNameAvailabilityResponse], errResp azfake.ErrorResponder)

	// BeginCreateOrUpdate is the fake for method ConnectedEnvironmentsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, environmentEnvelope armappcontainers.ConnectedEnvironment, options *armappcontainers.ConnectedEnvironmentsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ConnectedEnvironmentsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method ConnectedEnvironmentsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, options *armappcontainers.ConnectedEnvironmentsClientBeginDeleteOptions) (resp azfake.PollerResponder[armappcontainers.ConnectedEnvironmentsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ConnectedEnvironmentsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, options *armappcontainers.ConnectedEnvironmentsClientGetOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByResourceGroupPager is the fake for method ConnectedEnvironmentsClient.NewListByResourceGroupPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByResourceGroupPager func(resourceGroupName string, options *armappcontainers.ConnectedEnvironmentsClientListByResourceGroupOptions) (resp azfake.PagerResponder[armappcontainers.ConnectedEnvironmentsClientListByResourceGroupResponse])

	// NewListBySubscriptionPager is the fake for method ConnectedEnvironmentsClient.NewListBySubscriptionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListBySubscriptionPager func(options *armappcontainers.ConnectedEnvironmentsClientListBySubscriptionOptions) (resp azfake.PagerResponder[armappcontainers.ConnectedEnvironmentsClientListBySubscriptionResponse])

	// Update is the fake for method ConnectedEnvironmentsClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, options *armappcontainers.ConnectedEnvironmentsClientUpdateOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsClientUpdateResponse], errResp azfake.ErrorResponder)
}

ConnectedEnvironmentsServer is a fake server for instances of the armappcontainers.ConnectedEnvironmentsClient type.

type ConnectedEnvironmentsServerTransport 

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

ConnectedEnvironmentsServerTransport connects instances of armappcontainers.ConnectedEnvironmentsClient to instances of ConnectedEnvironmentsServer. Don't use this type directly, use NewConnectedEnvironmentsServerTransport instead.

func NewConnectedEnvironmentsServerTransport 

func NewConnectedEnvironmentsServerTransport(srv *ConnectedEnvironmentsServer) *ConnectedEnvironmentsServerTransport

NewConnectedEnvironmentsServerTransport creates a new instance of ConnectedEnvironmentsServerTransport with the provided implementation. The returned ConnectedEnvironmentsServerTransport instance is connected to an instance of armappcontainers.ConnectedEnvironmentsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ConnectedEnvironmentsServerTransport) Do 

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

Do implements the policy.Transporter interface for ConnectedEnvironmentsServerTransport.

type ConnectedEnvironmentsStoragesServer 

type ConnectedEnvironmentsStoragesServer struct {
	// CreateOrUpdate is the fake for method ConnectedEnvironmentsStoragesClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, storageName string, storageEnvelope armappcontainers.ConnectedEnvironmentStorage, options *armappcontainers.ConnectedEnvironmentsStoragesClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsStoragesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method ConnectedEnvironmentsStoragesClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, storageName string, options *armappcontainers.ConnectedEnvironmentsStoragesClientDeleteOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsStoragesClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ConnectedEnvironmentsStoragesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, storageName string, options *armappcontainers.ConnectedEnvironmentsStoragesClientGetOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsStoragesClientGetResponse], errResp azfake.ErrorResponder)

	// List is the fake for method ConnectedEnvironmentsStoragesClient.List
	// HTTP status codes to indicate success: http.StatusOK
	List func(ctx context.Context, resourceGroupName string, connectedEnvironmentName string, options *armappcontainers.ConnectedEnvironmentsStoragesClientListOptions) (resp azfake.Responder[armappcontainers.ConnectedEnvironmentsStoragesClientListResponse], errResp azfake.ErrorResponder)
}

ConnectedEnvironmentsStoragesServer is a fake server for instances of the armappcontainers.ConnectedEnvironmentsStoragesClient type.

type ConnectedEnvironmentsStoragesServerTransport 

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

ConnectedEnvironmentsStoragesServerTransport connects instances of armappcontainers.ConnectedEnvironmentsStoragesClient to instances of ConnectedEnvironmentsStoragesServer. Don't use this type directly, use NewConnectedEnvironmentsStoragesServerTransport instead.

func NewConnectedEnvironmentsStoragesServerTransport 

func NewConnectedEnvironmentsStoragesServerTransport(srv *ConnectedEnvironmentsStoragesServer) *ConnectedEnvironmentsStoragesServerTransport

NewConnectedEnvironmentsStoragesServerTransport creates a new instance of ConnectedEnvironmentsStoragesServerTransport with the provided implementation. The returned ConnectedEnvironmentsStoragesServerTransport instance is connected to an instance of armappcontainers.ConnectedEnvironmentsStoragesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ConnectedEnvironmentsStoragesServerTransport) Do 

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

Do implements the policy.Transporter interface for ConnectedEnvironmentsStoragesServerTransport.

type ContainerAppsAPIServer 

type ContainerAppsAPIServer struct {
	// JobExecution is the fake for method ContainerAppsAPIClient.JobExecution
	// HTTP status codes to indicate success: http.StatusOK
	JobExecution func(ctx context.Context, resourceGroupName string, jobName string, jobExecutionName string, options *armappcontainers.ContainerAppsAPIClientJobExecutionOptions) (resp azfake.Responder[armappcontainers.ContainerAppsAPIClientJobExecutionResponse], errResp azfake.ErrorResponder)
}

ContainerAppsAPIServer is a fake server for instances of the armappcontainers.ContainerAppsAPIClient type.

type ContainerAppsAPIServerTransport 

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

ContainerAppsAPIServerTransport connects instances of armappcontainers.ContainerAppsAPIClient to instances of ContainerAppsAPIServer. Don't use this type directly, use NewContainerAppsAPIServerTransport instead.

func NewContainerAppsAPIServerTransport 

func NewContainerAppsAPIServerTransport(srv *ContainerAppsAPIServer) *ContainerAppsAPIServerTransport

NewContainerAppsAPIServerTransport creates a new instance of ContainerAppsAPIServerTransport with the provided implementation. The returned ContainerAppsAPIServerTransport instance is connected to an instance of armappcontainers.ContainerAppsAPIClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsAPIServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsAPIServerTransport.

type ContainerAppsAuthConfigsServer 

type ContainerAppsAuthConfigsServer struct {
	// CreateOrUpdate is the fake for method ContainerAppsAuthConfigsClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, containerAppName string, authConfigName string, authConfigEnvelope armappcontainers.AuthConfig, options *armappcontainers.ContainerAppsAuthConfigsClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.ContainerAppsAuthConfigsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method ContainerAppsAuthConfigsClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, containerAppName string, authConfigName string, options *armappcontainers.ContainerAppsAuthConfigsClientDeleteOptions) (resp azfake.Responder[armappcontainers.ContainerAppsAuthConfigsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ContainerAppsAuthConfigsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, containerAppName string, authConfigName string, options *armappcontainers.ContainerAppsAuthConfigsClientGetOptions) (resp azfake.Responder[armappcontainers.ContainerAppsAuthConfigsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByContainerAppPager is the fake for method ContainerAppsAuthConfigsClient.NewListByContainerAppPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByContainerAppPager func(resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsAuthConfigsClientListByContainerAppOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsAuthConfigsClientListByContainerAppResponse])
}

ContainerAppsAuthConfigsServer is a fake server for instances of the armappcontainers.ContainerAppsAuthConfigsClient type.

type ContainerAppsAuthConfigsServerTransport 

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

ContainerAppsAuthConfigsServerTransport connects instances of armappcontainers.ContainerAppsAuthConfigsClient to instances of ContainerAppsAuthConfigsServer. Don't use this type directly, use NewContainerAppsAuthConfigsServerTransport instead.

func NewContainerAppsAuthConfigsServerTransport 

func NewContainerAppsAuthConfigsServerTransport(srv *ContainerAppsAuthConfigsServer) *ContainerAppsAuthConfigsServerTransport

NewContainerAppsAuthConfigsServerTransport creates a new instance of ContainerAppsAuthConfigsServerTransport with the provided implementation. The returned ContainerAppsAuthConfigsServerTransport instance is connected to an instance of armappcontainers.ContainerAppsAuthConfigsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsAuthConfigsServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsAuthConfigsServerTransport.

type ContainerAppsDiagnosticsServer 

type ContainerAppsDiagnosticsServer struct {
	// GetDetector is the fake for method ContainerAppsDiagnosticsClient.GetDetector
	// HTTP status codes to indicate success: http.StatusOK
	GetDetector func(ctx context.Context, resourceGroupName string, containerAppName string, detectorName string, options *armappcontainers.ContainerAppsDiagnosticsClientGetDetectorOptions) (resp azfake.Responder[armappcontainers.ContainerAppsDiagnosticsClientGetDetectorResponse], errResp azfake.ErrorResponder)

	// GetRevision is the fake for method ContainerAppsDiagnosticsClient.GetRevision
	// HTTP status codes to indicate success: http.StatusOK
	GetRevision func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, options *armappcontainers.ContainerAppsDiagnosticsClientGetRevisionOptions) (resp azfake.Responder[armappcontainers.ContainerAppsDiagnosticsClientGetRevisionResponse], errResp azfake.ErrorResponder)

	// GetRoot is the fake for method ContainerAppsDiagnosticsClient.GetRoot
	// HTTP status codes to indicate success: http.StatusOK
	GetRoot func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsDiagnosticsClientGetRootOptions) (resp azfake.Responder[armappcontainers.ContainerAppsDiagnosticsClientGetRootResponse], errResp azfake.ErrorResponder)

	// NewListDetectorsPager is the fake for method ContainerAppsDiagnosticsClient.NewListDetectorsPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListDetectorsPager func(resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsDiagnosticsClientListDetectorsOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsDiagnosticsClientListDetectorsResponse])

	// NewListRevisionsPager is the fake for method ContainerAppsDiagnosticsClient.NewListRevisionsPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListRevisionsPager func(resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsDiagnosticsClientListRevisionsOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsDiagnosticsClientListRevisionsResponse])
}

ContainerAppsDiagnosticsServer is a fake server for instances of the armappcontainers.ContainerAppsDiagnosticsClient type.

type ContainerAppsDiagnosticsServerTransport 

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

ContainerAppsDiagnosticsServerTransport connects instances of armappcontainers.ContainerAppsDiagnosticsClient to instances of ContainerAppsDiagnosticsServer. Don't use this type directly, use NewContainerAppsDiagnosticsServerTransport instead.

func NewContainerAppsDiagnosticsServerTransport 

func NewContainerAppsDiagnosticsServerTransport(srv *ContainerAppsDiagnosticsServer) *ContainerAppsDiagnosticsServerTransport

NewContainerAppsDiagnosticsServerTransport creates a new instance of ContainerAppsDiagnosticsServerTransport with the provided implementation. The returned ContainerAppsDiagnosticsServerTransport instance is connected to an instance of armappcontainers.ContainerAppsDiagnosticsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsDiagnosticsServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsDiagnosticsServerTransport.

type ContainerAppsRevisionReplicasServer 

type ContainerAppsRevisionReplicasServer struct {
	// GetReplica is the fake for method ContainerAppsRevisionReplicasClient.GetReplica
	// HTTP status codes to indicate success: http.StatusOK
	GetReplica func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, replicaName string, options *armappcontainers.ContainerAppsRevisionReplicasClientGetReplicaOptions) (resp azfake.Responder[armappcontainers.ContainerAppsRevisionReplicasClientGetReplicaResponse], errResp azfake.ErrorResponder)

	// ListReplicas is the fake for method ContainerAppsRevisionReplicasClient.ListReplicas
	// HTTP status codes to indicate success: http.StatusOK
	ListReplicas func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, options *armappcontainers.ContainerAppsRevisionReplicasClientListReplicasOptions) (resp azfake.Responder[armappcontainers.ContainerAppsRevisionReplicasClientListReplicasResponse], errResp azfake.ErrorResponder)
}

ContainerAppsRevisionReplicasServer is a fake server for instances of the armappcontainers.ContainerAppsRevisionReplicasClient type.

type ContainerAppsRevisionReplicasServerTransport 

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

ContainerAppsRevisionReplicasServerTransport connects instances of armappcontainers.ContainerAppsRevisionReplicasClient to instances of ContainerAppsRevisionReplicasServer. Don't use this type directly, use NewContainerAppsRevisionReplicasServerTransport instead.

func NewContainerAppsRevisionReplicasServerTransport 

func NewContainerAppsRevisionReplicasServerTransport(srv *ContainerAppsRevisionReplicasServer) *ContainerAppsRevisionReplicasServerTransport

NewContainerAppsRevisionReplicasServerTransport creates a new instance of ContainerAppsRevisionReplicasServerTransport with the provided implementation. The returned ContainerAppsRevisionReplicasServerTransport instance is connected to an instance of armappcontainers.ContainerAppsRevisionReplicasClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsRevisionReplicasServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsRevisionReplicasServerTransport.

type ContainerAppsRevisionsServer 

type ContainerAppsRevisionsServer struct {
	// ActivateRevision is the fake for method ContainerAppsRevisionsClient.ActivateRevision
	// HTTP status codes to indicate success: http.StatusOK
	ActivateRevision func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, options *armappcontainers.ContainerAppsRevisionsClientActivateRevisionOptions) (resp azfake.Responder[armappcontainers.ContainerAppsRevisionsClientActivateRevisionResponse], errResp azfake.ErrorResponder)

	// DeactivateRevision is the fake for method ContainerAppsRevisionsClient.DeactivateRevision
	// HTTP status codes to indicate success: http.StatusOK
	DeactivateRevision func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, options *armappcontainers.ContainerAppsRevisionsClientDeactivateRevisionOptions) (resp azfake.Responder[armappcontainers.ContainerAppsRevisionsClientDeactivateRevisionResponse], errResp azfake.ErrorResponder)

	// GetRevision is the fake for method ContainerAppsRevisionsClient.GetRevision
	// HTTP status codes to indicate success: http.StatusOK
	GetRevision func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, options *armappcontainers.ContainerAppsRevisionsClientGetRevisionOptions) (resp azfake.Responder[armappcontainers.ContainerAppsRevisionsClientGetRevisionResponse], errResp azfake.ErrorResponder)

	// NewListRevisionsPager is the fake for method ContainerAppsRevisionsClient.NewListRevisionsPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListRevisionsPager func(resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsRevisionsClientListRevisionsOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsRevisionsClientListRevisionsResponse])

	// RestartRevision is the fake for method ContainerAppsRevisionsClient.RestartRevision
	// HTTP status codes to indicate success: http.StatusOK
	RestartRevision func(ctx context.Context, resourceGroupName string, containerAppName string, revisionName string, options *armappcontainers.ContainerAppsRevisionsClientRestartRevisionOptions) (resp azfake.Responder[armappcontainers.ContainerAppsRevisionsClientRestartRevisionResponse], errResp azfake.ErrorResponder)
}

ContainerAppsRevisionsServer is a fake server for instances of the armappcontainers.ContainerAppsRevisionsClient type.

type ContainerAppsRevisionsServerTransport 

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

ContainerAppsRevisionsServerTransport connects instances of armappcontainers.ContainerAppsRevisionsClient to instances of ContainerAppsRevisionsServer. Don't use this type directly, use NewContainerAppsRevisionsServerTransport instead.

func NewContainerAppsRevisionsServerTransport 

func NewContainerAppsRevisionsServerTransport(srv *ContainerAppsRevisionsServer) *ContainerAppsRevisionsServerTransport

NewContainerAppsRevisionsServerTransport creates a new instance of ContainerAppsRevisionsServerTransport with the provided implementation. The returned ContainerAppsRevisionsServerTransport instance is connected to an instance of armappcontainers.ContainerAppsRevisionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsRevisionsServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsRevisionsServerTransport.

type ContainerAppsServer 

type ContainerAppsServer struct {
	// BeginCreateOrUpdate is the fake for method ContainerAppsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, containerAppName string, containerAppEnvelope armappcontainers.ContainerApp, options *armappcontainers.ContainerAppsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method ContainerAppsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientBeginDeleteOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ContainerAppsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientGetOptions) (resp azfake.Responder[armappcontainers.ContainerAppsClientGetResponse], errResp azfake.ErrorResponder)

	// GetAuthToken is the fake for method ContainerAppsClient.GetAuthToken
	// HTTP status codes to indicate success: http.StatusOK
	GetAuthToken func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientGetAuthTokenOptions) (resp azfake.Responder[armappcontainers.ContainerAppsClientGetAuthTokenResponse], errResp azfake.ErrorResponder)

	// NewListByResourceGroupPager is the fake for method ContainerAppsClient.NewListByResourceGroupPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByResourceGroupPager func(resourceGroupName string, options *armappcontainers.ContainerAppsClientListByResourceGroupOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsClientListByResourceGroupResponse])

	// NewListBySubscriptionPager is the fake for method ContainerAppsClient.NewListBySubscriptionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListBySubscriptionPager func(options *armappcontainers.ContainerAppsClientListBySubscriptionOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsClientListBySubscriptionResponse])

	// ListCustomHostNameAnalysis is the fake for method ContainerAppsClient.ListCustomHostNameAnalysis
	// HTTP status codes to indicate success: http.StatusOK
	ListCustomHostNameAnalysis func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientListCustomHostNameAnalysisOptions) (resp azfake.Responder[armappcontainers.ContainerAppsClientListCustomHostNameAnalysisResponse], errResp azfake.ErrorResponder)

	// ListSecrets is the fake for method ContainerAppsClient.ListSecrets
	// HTTP status codes to indicate success: http.StatusOK
	ListSecrets func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientListSecretsOptions) (resp azfake.Responder[armappcontainers.ContainerAppsClientListSecretsResponse], errResp azfake.ErrorResponder)

	// BeginStart is the fake for method ContainerAppsClient.BeginStart
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginStart func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientBeginStartOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsClientStartResponse], errResp azfake.ErrorResponder)

	// BeginStop is the fake for method ContainerAppsClient.BeginStop
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginStop func(ctx context.Context, resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsClientBeginStopOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsClientStopResponse], errResp azfake.ErrorResponder)

	// BeginUpdate is the fake for method ContainerAppsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, resourceGroupName string, containerAppName string, containerAppEnvelope armappcontainers.ContainerApp, options *armappcontainers.ContainerAppsClientBeginUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsClientUpdateResponse], errResp azfake.ErrorResponder)
}

ContainerAppsServer is a fake server for instances of the armappcontainers.ContainerAppsClient type.

type ContainerAppsServerTransport 

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

ContainerAppsServerTransport connects instances of armappcontainers.ContainerAppsClient to instances of ContainerAppsServer. Don't use this type directly, use NewContainerAppsServerTransport instead.

func NewContainerAppsServerTransport 

func NewContainerAppsServerTransport(srv *ContainerAppsServer) *ContainerAppsServerTransport

NewContainerAppsServerTransport creates a new instance of ContainerAppsServerTransport with the provided implementation. The returned ContainerAppsServerTransport instance is connected to an instance of armappcontainers.ContainerAppsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsServerTransport.

type ContainerAppsSourceControlsServer 

type ContainerAppsSourceControlsServer struct {
	// BeginCreateOrUpdate is the fake for method ContainerAppsSourceControlsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, containerAppName string, sourceControlName string, sourceControlEnvelope armappcontainers.SourceControl, options *armappcontainers.ContainerAppsSourceControlsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsSourceControlsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method ContainerAppsSourceControlsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, containerAppName string, sourceControlName string, options *armappcontainers.ContainerAppsSourceControlsClientBeginDeleteOptions) (resp azfake.PollerResponder[armappcontainers.ContainerAppsSourceControlsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ContainerAppsSourceControlsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, containerAppName string, sourceControlName string, options *armappcontainers.ContainerAppsSourceControlsClientGetOptions) (resp azfake.Responder[armappcontainers.ContainerAppsSourceControlsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByContainerAppPager is the fake for method ContainerAppsSourceControlsClient.NewListByContainerAppPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByContainerAppPager func(resourceGroupName string, containerAppName string, options *armappcontainers.ContainerAppsSourceControlsClientListByContainerAppOptions) (resp azfake.PagerResponder[armappcontainers.ContainerAppsSourceControlsClientListByContainerAppResponse])
}

ContainerAppsSourceControlsServer is a fake server for instances of the armappcontainers.ContainerAppsSourceControlsClient type.

type ContainerAppsSourceControlsServerTransport 

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

ContainerAppsSourceControlsServerTransport connects instances of armappcontainers.ContainerAppsSourceControlsClient to instances of ContainerAppsSourceControlsServer. Don't use this type directly, use NewContainerAppsSourceControlsServerTransport instead.

func NewContainerAppsSourceControlsServerTransport 

func NewContainerAppsSourceControlsServerTransport(srv *ContainerAppsSourceControlsServer) *ContainerAppsSourceControlsServerTransport

NewContainerAppsSourceControlsServerTransport creates a new instance of ContainerAppsSourceControlsServerTransport with the provided implementation. The returned ContainerAppsSourceControlsServerTransport instance is connected to an instance of armappcontainers.ContainerAppsSourceControlsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ContainerAppsSourceControlsServerTransport) Do 

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

Do implements the policy.Transporter interface for ContainerAppsSourceControlsServerTransport.

type DaprComponentsServer 

type DaprComponentsServer struct {
	// CreateOrUpdate is the fake for method DaprComponentsClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, componentName string, daprComponentEnvelope armappcontainers.DaprComponent, options *armappcontainers.DaprComponentsClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.DaprComponentsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method DaprComponentsClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, environmentName string, componentName string, options *armappcontainers.DaprComponentsClientDeleteOptions) (resp azfake.Responder[armappcontainers.DaprComponentsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method DaprComponentsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, environmentName string, componentName string, options *armappcontainers.DaprComponentsClientGetOptions) (resp azfake.Responder[armappcontainers.DaprComponentsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method DaprComponentsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, environmentName string, options *armappcontainers.DaprComponentsClientListOptions) (resp azfake.PagerResponder[armappcontainers.DaprComponentsClientListResponse])

	// ListSecrets is the fake for method DaprComponentsClient.ListSecrets
	// HTTP status codes to indicate success: http.StatusOK
	ListSecrets func(ctx context.Context, resourceGroupName string, environmentName string, componentName string, options *armappcontainers.DaprComponentsClientListSecretsOptions) (resp azfake.Responder[armappcontainers.DaprComponentsClientListSecretsResponse], errResp azfake.ErrorResponder)
}

DaprComponentsServer is a fake server for instances of the armappcontainers.DaprComponentsClient type.

type DaprComponentsServerTransport 

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

DaprComponentsServerTransport connects instances of armappcontainers.DaprComponentsClient to instances of DaprComponentsServer. Don't use this type directly, use NewDaprComponentsServerTransport instead.

func NewDaprComponentsServerTransport 

func NewDaprComponentsServerTransport(srv *DaprComponentsServer) *DaprComponentsServerTransport

NewDaprComponentsServerTransport creates a new instance of DaprComponentsServerTransport with the provided implementation. The returned DaprComponentsServerTransport instance is connected to an instance of armappcontainers.DaprComponentsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*DaprComponentsServerTransport) Do 

func (d *DaprComponentsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for DaprComponentsServerTransport.

type JobsExecutionsServer 

type JobsExecutionsServer struct {
	// NewListPager is the fake for method JobsExecutionsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, jobName string, options *armappcontainers.JobsExecutionsClientListOptions) (resp azfake.PagerResponder[armappcontainers.JobsExecutionsClientListResponse])
}

JobsExecutionsServer is a fake server for instances of the armappcontainers.JobsExecutionsClient type.

type JobsExecutionsServerTransport 

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

JobsExecutionsServerTransport connects instances of armappcontainers.JobsExecutionsClient to instances of JobsExecutionsServer. Don't use this type directly, use NewJobsExecutionsServerTransport instead.

func NewJobsExecutionsServerTransport 

func NewJobsExecutionsServerTransport(srv *JobsExecutionsServer) *JobsExecutionsServerTransport

NewJobsExecutionsServerTransport creates a new instance of JobsExecutionsServerTransport with the provided implementation. The returned JobsExecutionsServerTransport instance is connected to an instance of armappcontainers.JobsExecutionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*JobsExecutionsServerTransport) Do 

func (j *JobsExecutionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for JobsExecutionsServerTransport.

type JobsServer 

type JobsServer struct {
	// BeginCreateOrUpdate is the fake for method JobsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, jobName string, jobEnvelope armappcontainers.Job, options *armappcontainers.JobsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.JobsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method JobsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, jobName string, options *armappcontainers.JobsClientBeginDeleteOptions) (resp azfake.PollerResponder[armappcontainers.JobsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method JobsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, jobName string, options *armappcontainers.JobsClientGetOptions) (resp azfake.Responder[armappcontainers.JobsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByResourceGroupPager is the fake for method JobsClient.NewListByResourceGroupPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByResourceGroupPager func(resourceGroupName string, options *armappcontainers.JobsClientListByResourceGroupOptions) (resp azfake.PagerResponder[armappcontainers.JobsClientListByResourceGroupResponse])

	// NewListBySubscriptionPager is the fake for method JobsClient.NewListBySubscriptionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListBySubscriptionPager func(options *armappcontainers.JobsClientListBySubscriptionOptions) (resp azfake.PagerResponder[armappcontainers.JobsClientListBySubscriptionResponse])

	// ListSecrets is the fake for method JobsClient.ListSecrets
	// HTTP status codes to indicate success: http.StatusOK
	ListSecrets func(ctx context.Context, resourceGroupName string, jobName string, options *armappcontainers.JobsClientListSecretsOptions) (resp azfake.Responder[armappcontainers.JobsClientListSecretsResponse], errResp azfake.ErrorResponder)

	// BeginStart is the fake for method JobsClient.BeginStart
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginStart func(ctx context.Context, resourceGroupName string, jobName string, options *armappcontainers.JobsClientBeginStartOptions) (resp azfake.PollerResponder[armappcontainers.JobsClientStartResponse], errResp azfake.ErrorResponder)

	// BeginStopExecution is the fake for method JobsClient.BeginStopExecution
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginStopExecution func(ctx context.Context, resourceGroupName string, jobName string, jobExecutionName string, options *armappcontainers.JobsClientBeginStopExecutionOptions) (resp azfake.PollerResponder[armappcontainers.JobsClientStopExecutionResponse], errResp azfake.ErrorResponder)

	// BeginStopMultipleExecutions is the fake for method JobsClient.BeginStopMultipleExecutions
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginStopMultipleExecutions func(ctx context.Context, resourceGroupName string, jobName string, options *armappcontainers.JobsClientBeginStopMultipleExecutionsOptions) (resp azfake.PollerResponder[armappcontainers.JobsClientStopMultipleExecutionsResponse], errResp azfake.ErrorResponder)

	// BeginUpdate is the fake for method JobsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, resourceGroupName string, jobName string, jobEnvelope armappcontainers.JobPatchProperties, options *armappcontainers.JobsClientBeginUpdateOptions) (resp azfake.PollerResponder[armappcontainers.JobsClientUpdateResponse], errResp azfake.ErrorResponder)
}

JobsServer is a fake server for instances of the armappcontainers.JobsClient type.

type JobsServerTransport 

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

JobsServerTransport connects instances of armappcontainers.JobsClient to instances of JobsServer. Don't use this type directly, use NewJobsServerTransport instead.

func NewJobsServerTransport 

func NewJobsServerTransport(srv *JobsServer) *JobsServerTransport

NewJobsServerTransport creates a new instance of JobsServerTransport with the provided implementation. The returned JobsServerTransport instance is connected to an instance of armappcontainers.JobsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*JobsServerTransport) Do 

func (j *JobsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for JobsServerTransport.

type ManagedCertificatesServer 

type ManagedCertificatesServer struct {
	// BeginCreateOrUpdate is the fake for method ManagedCertificatesClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, managedCertificateName string, options *armappcontainers.ManagedCertificatesClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ManagedCertificatesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method ManagedCertificatesClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, environmentName string, managedCertificateName string, options *armappcontainers.ManagedCertificatesClientDeleteOptions) (resp azfake.Responder[armappcontainers.ManagedCertificatesClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ManagedCertificatesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, environmentName string, managedCertificateName string, options *armappcontainers.ManagedCertificatesClientGetOptions) (resp azfake.Responder[armappcontainers.ManagedCertificatesClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ManagedCertificatesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, environmentName string, options *armappcontainers.ManagedCertificatesClientListOptions) (resp azfake.PagerResponder[armappcontainers.ManagedCertificatesClientListResponse])

	// Update is the fake for method ManagedCertificatesClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, resourceGroupName string, environmentName string, managedCertificateName string, managedCertificateEnvelope armappcontainers.ManagedCertificatePatch, options *armappcontainers.ManagedCertificatesClientUpdateOptions) (resp azfake.Responder[armappcontainers.ManagedCertificatesClientUpdateResponse], errResp azfake.ErrorResponder)
}

ManagedCertificatesServer is a fake server for instances of the armappcontainers.ManagedCertificatesClient type.

type ManagedCertificatesServerTransport 

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

ManagedCertificatesServerTransport connects instances of armappcontainers.ManagedCertificatesClient to instances of ManagedCertificatesServer. Don't use this type directly, use NewManagedCertificatesServerTransport instead.

func NewManagedCertificatesServerTransport 

func NewManagedCertificatesServerTransport(srv *ManagedCertificatesServer) *ManagedCertificatesServerTransport

NewManagedCertificatesServerTransport creates a new instance of ManagedCertificatesServerTransport with the provided implementation. The returned ManagedCertificatesServerTransport instance is connected to an instance of armappcontainers.ManagedCertificatesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ManagedCertificatesServerTransport) Do 

func (m *ManagedCertificatesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ManagedCertificatesServerTransport.

type ManagedEnvironmentDiagnosticsServer 

type ManagedEnvironmentDiagnosticsServer struct {
	// GetDetector is the fake for method ManagedEnvironmentDiagnosticsClient.GetDetector
	// HTTP status codes to indicate success: http.StatusOK
	GetDetector func(ctx context.Context, resourceGroupName string, environmentName string, detectorName string, options *armappcontainers.ManagedEnvironmentDiagnosticsClientGetDetectorOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentDiagnosticsClientGetDetectorResponse], errResp azfake.ErrorResponder)

	// ListDetectors is the fake for method ManagedEnvironmentDiagnosticsClient.ListDetectors
	// HTTP status codes to indicate success: http.StatusOK
	ListDetectors func(ctx context.Context, resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentDiagnosticsClientListDetectorsOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentDiagnosticsClientListDetectorsResponse], errResp azfake.ErrorResponder)
}

ManagedEnvironmentDiagnosticsServer is a fake server for instances of the armappcontainers.ManagedEnvironmentDiagnosticsClient type.

type ManagedEnvironmentDiagnosticsServerTransport 

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

ManagedEnvironmentDiagnosticsServerTransport connects instances of armappcontainers.ManagedEnvironmentDiagnosticsClient to instances of ManagedEnvironmentDiagnosticsServer. Don't use this type directly, use NewManagedEnvironmentDiagnosticsServerTransport instead.

func NewManagedEnvironmentDiagnosticsServerTransport 

func NewManagedEnvironmentDiagnosticsServerTransport(srv *ManagedEnvironmentDiagnosticsServer) *ManagedEnvironmentDiagnosticsServerTransport

NewManagedEnvironmentDiagnosticsServerTransport creates a new instance of ManagedEnvironmentDiagnosticsServerTransport with the provided implementation. The returned ManagedEnvironmentDiagnosticsServerTransport instance is connected to an instance of armappcontainers.ManagedEnvironmentDiagnosticsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ManagedEnvironmentDiagnosticsServerTransport) Do 

func (m *ManagedEnvironmentDiagnosticsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ManagedEnvironmentDiagnosticsServerTransport.

type ManagedEnvironmentsDiagnosticsServer 

type ManagedEnvironmentsDiagnosticsServer struct {
	// GetRoot is the fake for method ManagedEnvironmentsDiagnosticsClient.GetRoot
	// HTTP status codes to indicate success: http.StatusOK
	GetRoot func(ctx context.Context, resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentsDiagnosticsClientGetRootOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsDiagnosticsClientGetRootResponse], errResp azfake.ErrorResponder)
}

ManagedEnvironmentsDiagnosticsServer is a fake server for instances of the armappcontainers.ManagedEnvironmentsDiagnosticsClient type.

type ManagedEnvironmentsDiagnosticsServerTransport 

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

ManagedEnvironmentsDiagnosticsServerTransport connects instances of armappcontainers.ManagedEnvironmentsDiagnosticsClient to instances of ManagedEnvironmentsDiagnosticsServer. Don't use this type directly, use NewManagedEnvironmentsDiagnosticsServerTransport instead.

func NewManagedEnvironmentsDiagnosticsServerTransport 

func NewManagedEnvironmentsDiagnosticsServerTransport(srv *ManagedEnvironmentsDiagnosticsServer) *ManagedEnvironmentsDiagnosticsServerTransport

NewManagedEnvironmentsDiagnosticsServerTransport creates a new instance of ManagedEnvironmentsDiagnosticsServerTransport with the provided implementation. The returned ManagedEnvironmentsDiagnosticsServerTransport instance is connected to an instance of armappcontainers.ManagedEnvironmentsDiagnosticsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ManagedEnvironmentsDiagnosticsServerTransport) Do 

func (m *ManagedEnvironmentsDiagnosticsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ManagedEnvironmentsDiagnosticsServerTransport.

type ManagedEnvironmentsServer 

type ManagedEnvironmentsServer struct {
	// BeginCreateOrUpdate is the fake for method ManagedEnvironmentsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, environmentEnvelope armappcontainers.ManagedEnvironment, options *armappcontainers.ManagedEnvironmentsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ManagedEnvironmentsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method ManagedEnvironmentsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentsClientBeginDeleteOptions) (resp azfake.PollerResponder[armappcontainers.ManagedEnvironmentsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ManagedEnvironmentsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentsClientGetOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsClientGetResponse], errResp azfake.ErrorResponder)

	// GetAuthToken is the fake for method ManagedEnvironmentsClient.GetAuthToken
	// HTTP status codes to indicate success: http.StatusOK
	GetAuthToken func(ctx context.Context, resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentsClientGetAuthTokenOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsClientGetAuthTokenResponse], errResp azfake.ErrorResponder)

	// NewListByResourceGroupPager is the fake for method ManagedEnvironmentsClient.NewListByResourceGroupPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByResourceGroupPager func(resourceGroupName string, options *armappcontainers.ManagedEnvironmentsClientListByResourceGroupOptions) (resp azfake.PagerResponder[armappcontainers.ManagedEnvironmentsClientListByResourceGroupResponse])

	// NewListBySubscriptionPager is the fake for method ManagedEnvironmentsClient.NewListBySubscriptionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListBySubscriptionPager func(options *armappcontainers.ManagedEnvironmentsClientListBySubscriptionOptions) (resp azfake.PagerResponder[armappcontainers.ManagedEnvironmentsClientListBySubscriptionResponse])

	// NewListWorkloadProfileStatesPager is the fake for method ManagedEnvironmentsClient.NewListWorkloadProfileStatesPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListWorkloadProfileStatesPager func(resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentsClientListWorkloadProfileStatesOptions) (resp azfake.PagerResponder[armappcontainers.ManagedEnvironmentsClientListWorkloadProfileStatesResponse])

	// BeginUpdate is the fake for method ManagedEnvironmentsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, resourceGroupName string, environmentName string, environmentEnvelope armappcontainers.ManagedEnvironment, options *armappcontainers.ManagedEnvironmentsClientBeginUpdateOptions) (resp azfake.PollerResponder[armappcontainers.ManagedEnvironmentsClientUpdateResponse], errResp azfake.ErrorResponder)
}

ManagedEnvironmentsServer is a fake server for instances of the armappcontainers.ManagedEnvironmentsClient type.

type ManagedEnvironmentsServerTransport 

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

ManagedEnvironmentsServerTransport connects instances of armappcontainers.ManagedEnvironmentsClient to instances of ManagedEnvironmentsServer. Don't use this type directly, use NewManagedEnvironmentsServerTransport instead.

func NewManagedEnvironmentsServerTransport 

func NewManagedEnvironmentsServerTransport(srv *ManagedEnvironmentsServer) *ManagedEnvironmentsServerTransport

NewManagedEnvironmentsServerTransport creates a new instance of ManagedEnvironmentsServerTransport with the provided implementation. The returned ManagedEnvironmentsServerTransport instance is connected to an instance of armappcontainers.ManagedEnvironmentsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ManagedEnvironmentsServerTransport) Do 

func (m *ManagedEnvironmentsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ManagedEnvironmentsServerTransport.

type ManagedEnvironmentsStoragesServer 

type ManagedEnvironmentsStoragesServer struct {
	// CreateOrUpdate is the fake for method ManagedEnvironmentsStoragesClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, storageName string, storageEnvelope armappcontainers.ManagedEnvironmentStorage, options *armappcontainers.ManagedEnvironmentsStoragesClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsStoragesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method ManagedEnvironmentsStoragesClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, environmentName string, storageName string, options *armappcontainers.ManagedEnvironmentsStoragesClientDeleteOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsStoragesClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ManagedEnvironmentsStoragesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, environmentName string, storageName string, options *armappcontainers.ManagedEnvironmentsStoragesClientGetOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsStoragesClientGetResponse], errResp azfake.ErrorResponder)

	// List is the fake for method ManagedEnvironmentsStoragesClient.List
	// HTTP status codes to indicate success: http.StatusOK
	List func(ctx context.Context, resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentsStoragesClientListOptions) (resp azfake.Responder[armappcontainers.ManagedEnvironmentsStoragesClientListResponse], errResp azfake.ErrorResponder)
}

ManagedEnvironmentsStoragesServer is a fake server for instances of the armappcontainers.ManagedEnvironmentsStoragesClient type.

type ManagedEnvironmentsStoragesServerTransport 

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

ManagedEnvironmentsStoragesServerTransport connects instances of armappcontainers.ManagedEnvironmentsStoragesClient to instances of ManagedEnvironmentsStoragesServer. Don't use this type directly, use NewManagedEnvironmentsStoragesServerTransport instead.

func NewManagedEnvironmentsStoragesServerTransport 

func NewManagedEnvironmentsStoragesServerTransport(srv *ManagedEnvironmentsStoragesServer) *ManagedEnvironmentsStoragesServerTransport

NewManagedEnvironmentsStoragesServerTransport creates a new instance of ManagedEnvironmentsStoragesServerTransport with the provided implementation. The returned ManagedEnvironmentsStoragesServerTransport instance is connected to an instance of armappcontainers.ManagedEnvironmentsStoragesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ManagedEnvironmentsStoragesServerTransport) Do 

func (m *ManagedEnvironmentsStoragesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ManagedEnvironmentsStoragesServerTransport.

type NamespacesServer 

type NamespacesServer struct {
	// CheckNameAvailability is the fake for method NamespacesClient.CheckNameAvailability
	// HTTP status codes to indicate success: http.StatusOK
	CheckNameAvailability func(ctx context.Context, resourceGroupName string, environmentName string, checkNameAvailabilityRequest armappcontainers.CheckNameAvailabilityRequest, options *armappcontainers.NamespacesClientCheckNameAvailabilityOptions) (resp azfake.Responder[armappcontainers.NamespacesClientCheckNameAvailabilityResponse], errResp azfake.ErrorResponder)
}

NamespacesServer is a fake server for instances of the armappcontainers.NamespacesClient type.

type NamespacesServerTransport 

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

NamespacesServerTransport connects instances of armappcontainers.NamespacesClient to instances of NamespacesServer. Don't use this type directly, use NewNamespacesServerTransport instead.

func NewNamespacesServerTransport 

func NewNamespacesServerTransport(srv *NamespacesServer) *NamespacesServerTransport

NewNamespacesServerTransport creates a new instance of NamespacesServerTransport with the provided implementation. The returned NamespacesServerTransport instance is connected to an instance of armappcontainers.NamespacesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*NamespacesServerTransport) Do 

func (n *NamespacesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for NamespacesServerTransport.

type OperationsServer 

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

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

type OperationsServerTransport 

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

OperationsServerTransport connects instances of armappcontainers.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 armappcontainers.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 ServerFactory 

type ServerFactory struct {
	AvailableWorkloadProfilesServer           AvailableWorkloadProfilesServer
	BillingMetersServer                       BillingMetersServer
	CertificatesServer                        CertificatesServer
	ConnectedEnvironmentsCertificatesServer   ConnectedEnvironmentsCertificatesServer
	ConnectedEnvironmentsServer               ConnectedEnvironmentsServer
	ConnectedEnvironmentsDaprComponentsServer ConnectedEnvironmentsDaprComponentsServer
	ConnectedEnvironmentsStoragesServer       ConnectedEnvironmentsStoragesServer
	ContainerAppsAPIServer                    ContainerAppsAPIServer
	ContainerAppsAuthConfigsServer            ContainerAppsAuthConfigsServer
	ContainerAppsServer                       ContainerAppsServer
	ContainerAppsDiagnosticsServer            ContainerAppsDiagnosticsServer
	ContainerAppsRevisionReplicasServer       ContainerAppsRevisionReplicasServer
	ContainerAppsRevisionsServer              ContainerAppsRevisionsServer
	ContainerAppsSourceControlsServer         ContainerAppsSourceControlsServer
	DaprComponentsServer                      DaprComponentsServer
	JobsServer                                JobsServer
	JobsExecutionsServer                      JobsExecutionsServer
	ManagedCertificatesServer                 ManagedCertificatesServer
	ManagedEnvironmentDiagnosticsServer       ManagedEnvironmentDiagnosticsServer
	ManagedEnvironmentsServer                 ManagedEnvironmentsServer
	ManagedEnvironmentsDiagnosticsServer      ManagedEnvironmentsDiagnosticsServer
	ManagedEnvironmentsStoragesServer         ManagedEnvironmentsStoragesServer
	NamespacesServer                          NamespacesServer
	OperationsServer                          OperationsServer
}

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

type ServerFactoryTransport 

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

ServerFactoryTransport connects instances of armappcontainers.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 armappcontainers.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.

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.