fake

package
v3.0.0-beta.1 Latest Latest
Warning

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

 Go to latest Published: Mar 20, 2024 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 AppResiliencyServer 

type AppResiliencyServer struct {
	// CreateOrUpdate is the fake for method AppResiliencyClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, appName string, name string, resiliencyEnvelope armappcontainers.AppResiliency, options *armappcontainers.AppResiliencyClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.AppResiliencyClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Delete is the fake for method AppResiliencyClient.Delete
	// HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent
	Delete func(ctx context.Context, resourceGroupName string, appName string, name string, options *armappcontainers.AppResiliencyClientDeleteOptions) (resp azfake.Responder[armappcontainers.AppResiliencyClientDeleteResponse], errResp azfake.ErrorResponder)

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

	// NewListPager is the fake for method AppResiliencyClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, appName string, options *armappcontainers.AppResiliencyClientListOptions) (resp azfake.PagerResponder[armappcontainers.AppResiliencyClientListResponse])

	// Update is the fake for method AppResiliencyClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, resourceGroupName string, appName string, name string, resiliencyEnvelope armappcontainers.AppResiliency, options *armappcontainers.AppResiliencyClientUpdateOptions) (resp azfake.Responder[armappcontainers.AppResiliencyClientUpdateResponse], errResp azfake.ErrorResponder)
}

AppResiliencyServer is a fake server for instances of the armappcontainers.AppResiliencyClient type.

type AppResiliencyServerTransport 

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

AppResiliencyServerTransport connects instances of armappcontainers.AppResiliencyClient to instances of AppResiliencyServer. Don't use this type directly, use NewAppResiliencyServerTransport instead.

func NewAppResiliencyServerTransport 

func NewAppResiliencyServerTransport(srv *AppResiliencyServer) *AppResiliencyServerTransport

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

func (*AppResiliencyServerTransport) Do 

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

Do implements the policy.Transporter interface for AppResiliencyServerTransport.

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 BuildAuthTokenServer 

type BuildAuthTokenServer struct {
	// List is the fake for method BuildAuthTokenClient.List
	// HTTP status codes to indicate success: http.StatusOK
	List func(ctx context.Context, resourceGroupName string, builderName string, buildName string, options *armappcontainers.BuildAuthTokenClientListOptions) (resp azfake.Responder[armappcontainers.BuildAuthTokenClientListResponse], errResp azfake.ErrorResponder)
}

BuildAuthTokenServer is a fake server for instances of the armappcontainers.BuildAuthTokenClient type.

type BuildAuthTokenServerTransport 

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

BuildAuthTokenServerTransport connects instances of armappcontainers.BuildAuthTokenClient to instances of BuildAuthTokenServer. Don't use this type directly, use NewBuildAuthTokenServerTransport instead.

func NewBuildAuthTokenServerTransport 

func NewBuildAuthTokenServerTransport(srv *BuildAuthTokenServer) *BuildAuthTokenServerTransport

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

func (*BuildAuthTokenServerTransport) Do 

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

Do implements the policy.Transporter interface for BuildAuthTokenServerTransport.

type BuildersServer 

type BuildersServer struct {
	// BeginCreateOrUpdate is the fake for method BuildersClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, builderName string, builderEnvelope armappcontainers.BuilderResource, options *armappcontainers.BuildersClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.BuildersClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

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

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

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

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

	// BeginUpdate is the fake for method BuildersClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, resourceGroupName string, builderName string, builderEnvelope armappcontainers.BuilderResourceUpdate, options *armappcontainers.BuildersClientBeginUpdateOptions) (resp azfake.PollerResponder[armappcontainers.BuildersClientUpdateResponse], errResp azfake.ErrorResponder)
}

BuildersServer is a fake server for instances of the armappcontainers.BuildersClient type.

type BuildersServerTransport 

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

BuildersServerTransport connects instances of armappcontainers.BuildersClient to instances of BuildersServer. Don't use this type directly, use NewBuildersServerTransport instead.

func NewBuildersServerTransport 

func NewBuildersServerTransport(srv *BuildersServer) *BuildersServerTransport

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

func (*BuildersServerTransport) Do 

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

Do implements the policy.Transporter interface for BuildersServerTransport.

type BuildsByBuilderResourceServer 

type BuildsByBuilderResourceServer struct {
	// NewListPager is the fake for method BuildsByBuilderResourceClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, builderName string, options *armappcontainers.BuildsByBuilderResourceClientListOptions) (resp azfake.PagerResponder[armappcontainers.BuildsByBuilderResourceClientListResponse])
}

BuildsByBuilderResourceServer is a fake server for instances of the armappcontainers.BuildsByBuilderResourceClient type.

type BuildsByBuilderResourceServerTransport 

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

BuildsByBuilderResourceServerTransport connects instances of armappcontainers.BuildsByBuilderResourceClient to instances of BuildsByBuilderResourceServer. Don't use this type directly, use NewBuildsByBuilderResourceServerTransport instead.

func NewBuildsByBuilderResourceServerTransport 

func NewBuildsByBuilderResourceServerTransport(srv *BuildsByBuilderResourceServer) *BuildsByBuilderResourceServerTransport

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

func (*BuildsByBuilderResourceServerTransport) Do 

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

Do implements the policy.Transporter interface for BuildsByBuilderResourceServerTransport.

type BuildsServer 

type BuildsServer struct {
	// BeginCreateOrUpdate is the fake for method BuildsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, builderName string, buildName string, buildEnvelope armappcontainers.BuildResource, options *armappcontainers.BuildsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.BuildsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// BeginDelete is the fake for method BuildsClient.BeginDelete
	// HTTP status codes to indicate success: http.StatusAccepted, http.StatusNoContent
	BeginDelete func(ctx context.Context, resourceGroupName string, builderName string, buildName string, options *armappcontainers.BuildsClientBeginDeleteOptions) (resp azfake.PollerResponder[armappcontainers.BuildsClientDeleteResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method BuildsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, resourceGroupName string, builderName string, buildName string, options *armappcontainers.BuildsClientGetOptions) (resp azfake.Responder[armappcontainers.BuildsClientGetResponse], errResp azfake.ErrorResponder)
}

BuildsServer is a fake server for instances of the armappcontainers.BuildsClient type.

type BuildsServerTransport 

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

BuildsServerTransport connects instances of armappcontainers.BuildsClient to instances of BuildsServer. Don't use this type directly, use NewBuildsServerTransport instead.

func NewBuildsServerTransport 

func NewBuildsServerTransport(srv *BuildsServer) *BuildsServerTransport

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

func (*BuildsServerTransport) Do 

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

Do implements the policy.Transporter interface for BuildsServerTransport.

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 {
	// GetCustomDomainVerificationID is the fake for method ContainerAppsAPIClient.GetCustomDomainVerificationID
	// HTTP status codes to indicate success: http.StatusOK
	GetCustomDomainVerificationID func(ctx context.Context, options *armappcontainers.ContainerAppsAPIClientGetCustomDomainVerificationIDOptions) (resp azfake.Responder[armappcontainers.ContainerAppsAPIClientGetCustomDomainVerificationIDResponse], errResp azfake.ErrorResponder)

	// 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 DaprComponentResiliencyPoliciesServer 

type DaprComponentResiliencyPoliciesServer struct {
	// CreateOrUpdate is the fake for method DaprComponentResiliencyPoliciesClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, componentName string, name string, daprComponentResiliencyPolicyEnvelope armappcontainers.DaprComponentResiliencyPolicy, options *armappcontainers.DaprComponentResiliencyPoliciesClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.DaprComponentResiliencyPoliciesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

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

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

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

DaprComponentResiliencyPoliciesServer is a fake server for instances of the armappcontainers.DaprComponentResiliencyPoliciesClient type.

type DaprComponentResiliencyPoliciesServerTransport 

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

DaprComponentResiliencyPoliciesServerTransport connects instances of armappcontainers.DaprComponentResiliencyPoliciesClient to instances of DaprComponentResiliencyPoliciesServer. Don't use this type directly, use NewDaprComponentResiliencyPoliciesServerTransport instead.

func NewDaprComponentResiliencyPoliciesServerTransport 

func NewDaprComponentResiliencyPoliciesServerTransport(srv *DaprComponentResiliencyPoliciesServer) *DaprComponentResiliencyPoliciesServerTransport

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

func (*DaprComponentResiliencyPoliciesServerTransport) Do 

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

Do implements the policy.Transporter interface for DaprComponentResiliencyPoliciesServerTransport.

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 DaprSubscriptionsServer 

type DaprSubscriptionsServer struct {
	// CreateOrUpdate is the fake for method DaprSubscriptionsClient.CreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	CreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, name string, daprSubscriptionEnvelope armappcontainers.DaprSubscription, options *armappcontainers.DaprSubscriptionsClientCreateOrUpdateOptions) (resp azfake.Responder[armappcontainers.DaprSubscriptionsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

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

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

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

DaprSubscriptionsServer is a fake server for instances of the armappcontainers.DaprSubscriptionsClient type.

type DaprSubscriptionsServerTransport 

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

DaprSubscriptionsServerTransport connects instances of armappcontainers.DaprSubscriptionsClient to instances of DaprSubscriptionsServer. Don't use this type directly, use NewDaprSubscriptionsServerTransport instead.

func NewDaprSubscriptionsServerTransport 

func NewDaprSubscriptionsServerTransport(srv *DaprSubscriptionsServer) *DaprSubscriptionsServerTransport

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

func (*DaprSubscriptionsServerTransport) Do 

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

Do implements the policy.Transporter interface for DaprSubscriptionsServerTransport.

type DotNetComponentsServer 

type DotNetComponentsServer struct {
	// BeginCreateOrUpdate is the fake for method DotNetComponentsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, name string, dotNetComponentEnvelope armappcontainers.DotNetComponent, options *armappcontainers.DotNetComponentsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.DotNetComponentsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

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

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

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

	// BeginUpdate is the fake for method DotNetComponentsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, resourceGroupName string, environmentName string, name string, dotNetComponentEnvelope armappcontainers.DotNetComponent, options *armappcontainers.DotNetComponentsClientBeginUpdateOptions) (resp azfake.PollerResponder[armappcontainers.DotNetComponentsClientUpdateResponse], errResp azfake.ErrorResponder)
}

DotNetComponentsServer is a fake server for instances of the armappcontainers.DotNetComponentsClient type.

type DotNetComponentsServerTransport 

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

DotNetComponentsServerTransport connects instances of armappcontainers.DotNetComponentsClient to instances of DotNetComponentsServer. Don't use this type directly, use NewDotNetComponentsServerTransport instead.

func NewDotNetComponentsServerTransport 

func NewDotNetComponentsServerTransport(srv *DotNetComponentsServer) *DotNetComponentsServerTransport

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

func (*DotNetComponentsServerTransport) Do 

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

Do implements the policy.Transporter interface for DotNetComponentsServerTransport.

type JavaComponentsServer 

type JavaComponentsServer struct {
	// BeginCreateOrUpdate is the fake for method JavaComponentsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, environmentName string, name string, javaComponentEnvelope armappcontainers.JavaComponent, options *armappcontainers.JavaComponentsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappcontainers.JavaComponentsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

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

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

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

	// BeginUpdate is the fake for method JavaComponentsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, resourceGroupName string, environmentName string, name string, javaComponentEnvelope armappcontainers.JavaComponent, options *armappcontainers.JavaComponentsClientBeginUpdateOptions) (resp azfake.PollerResponder[armappcontainers.JavaComponentsClientUpdateResponse], errResp azfake.ErrorResponder)
}

JavaComponentsServer is a fake server for instances of the armappcontainers.JavaComponentsClient type.

type JavaComponentsServerTransport 

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

JavaComponentsServerTransport connects instances of armappcontainers.JavaComponentsClient to instances of JavaComponentsServer. Don't use this type directly, use NewJavaComponentsServerTransport instead.

func NewJavaComponentsServerTransport 

func NewJavaComponentsServerTransport(srv *JavaComponentsServer) *JavaComponentsServerTransport

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

func (*JavaComponentsServerTransport) Do 

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

Do implements the policy.Transporter interface for JavaComponentsServerTransport.

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)

	// GetDetector is the fake for method JobsClient.GetDetector
	// HTTP status codes to indicate success: http.StatusOK
	GetDetector func(ctx context.Context, resourceGroupName string, jobName string, detectorName string, options *armappcontainers.JobsClientGetDetectorOptions) (resp azfake.Responder[armappcontainers.JobsClientGetDetectorResponse], 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])

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

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

	// ProxyGet is the fake for method JobsClient.ProxyGet
	// HTTP status codes to indicate success: http.StatusOK
	ProxyGet func(ctx context.Context, resourceGroupName string, jobName string, options *armappcontainers.JobsClientProxyGetOptions) (resp azfake.Responder[armappcontainers.JobsClientProxyGetResponse], 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 ManagedEnvironmentUsagesServer 

type ManagedEnvironmentUsagesServer struct {
	// NewListPager is the fake for method ManagedEnvironmentUsagesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(resourceGroupName string, environmentName string, options *armappcontainers.ManagedEnvironmentUsagesClientListOptions) (resp azfake.PagerResponder[armappcontainers.ManagedEnvironmentUsagesClientListResponse])
}

ManagedEnvironmentUsagesServer is a fake server for instances of the armappcontainers.ManagedEnvironmentUsagesClient type.

type ManagedEnvironmentUsagesServerTransport 

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

ManagedEnvironmentUsagesServerTransport connects instances of armappcontainers.ManagedEnvironmentUsagesClient to instances of ManagedEnvironmentUsagesServer. Don't use this type directly, use NewManagedEnvironmentUsagesServerTransport instead.

func NewManagedEnvironmentUsagesServerTransport 

func NewManagedEnvironmentUsagesServerTransport(srv *ManagedEnvironmentUsagesServer) *ManagedEnvironmentUsagesServerTransport

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

func (*ManagedEnvironmentUsagesServerTransport) Do 

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

Do implements the policy.Transporter interface for ManagedEnvironmentUsagesServerTransport.

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 {
	AppResiliencyServer                       AppResiliencyServer
	AvailableWorkloadProfilesServer           AvailableWorkloadProfilesServer
	BillingMetersServer                       BillingMetersServer
	BuildAuthTokenServer                      BuildAuthTokenServer
	BuildersServer                            BuildersServer
	BuildsByBuilderResourceServer             BuildsByBuilderResourceServer
	BuildsServer                              BuildsServer
	CertificatesServer                        CertificatesServer
	ConnectedEnvironmentsCertificatesServer   ConnectedEnvironmentsCertificatesServer
	ConnectedEnvironmentsServer               ConnectedEnvironmentsServer
	ConnectedEnvironmentsDaprComponentsServer ConnectedEnvironmentsDaprComponentsServer
	ConnectedEnvironmentsStoragesServer       ConnectedEnvironmentsStoragesServer
	ContainerAppsAPIServer                    ContainerAppsAPIServer
	ContainerAppsAuthConfigsServer            ContainerAppsAuthConfigsServer
	ContainerAppsServer                       ContainerAppsServer
	ContainerAppsDiagnosticsServer            ContainerAppsDiagnosticsServer
	ContainerAppsRevisionReplicasServer       ContainerAppsRevisionReplicasServer
	ContainerAppsRevisionsServer              ContainerAppsRevisionsServer
	ContainerAppsSourceControlsServer         ContainerAppsSourceControlsServer
	DaprComponentResiliencyPoliciesServer     DaprComponentResiliencyPoliciesServer
	DaprComponentsServer                      DaprComponentsServer
	DaprSubscriptionsServer                   DaprSubscriptionsServer
	DotNetComponentsServer                    DotNetComponentsServer
	JavaComponentsServer                      JavaComponentsServer
	JobsServer                                JobsServer
	JobsExecutionsServer                      JobsExecutionsServer
	ManagedCertificatesServer                 ManagedCertificatesServer
	ManagedEnvironmentDiagnosticsServer       ManagedEnvironmentDiagnosticsServer
	ManagedEnvironmentUsagesServer            ManagedEnvironmentUsagesServer
	ManagedEnvironmentsServer                 ManagedEnvironmentsServer
	ManagedEnvironmentsDiagnosticsServer      ManagedEnvironmentsDiagnosticsServer
	ManagedEnvironmentsStoragesServer         ManagedEnvironmentsStoragesServer
	NamespacesServer                          NamespacesServer
	OperationsServer                          OperationsServer
	UsagesServer                              UsagesServer
}

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.

type UsagesServer 

type UsagesServer struct {
	// NewListPager is the fake for method UsagesClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(location string, options *armappcontainers.UsagesClientListOptions) (resp azfake.PagerResponder[armappcontainers.UsagesClientListResponse])
}

UsagesServer is a fake server for instances of the armappcontainers.UsagesClient type.

type UsagesServerTransport 

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

UsagesServerTransport connects instances of armappcontainers.UsagesClient to instances of UsagesServer. Don't use this type directly, use NewUsagesServerTransport instead.

func NewUsagesServerTransport 

func NewUsagesServerTransport(srv *UsagesServer) *UsagesServerTransport

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

func (*UsagesServerTransport) Do 

func (u *UsagesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for UsagesServerTransport.

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.