fake

package
v3.0.0-...-45adee8 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2024 License: MIT Imports: 18 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AzureReservationAPIServer 

type AzureReservationAPIServer struct {
	// GetAppliedReservationList is the fake for method AzureReservationAPIClient.GetAppliedReservationList
	// HTTP status codes to indicate success: http.StatusOK
	GetAppliedReservationList func(ctx context.Context, subscriptionID string, options *armreservations.AzureReservationAPIClientGetAppliedReservationListOptions) (resp azfake.Responder[armreservations.AzureReservationAPIClientGetAppliedReservationListResponse], errResp azfake.ErrorResponder)

	// NewGetCatalogPager is the fake for method AzureReservationAPIClient.NewGetCatalogPager
	// HTTP status codes to indicate success: http.StatusOK
	NewGetCatalogPager func(subscriptionID string, options *armreservations.AzureReservationAPIClientGetCatalogOptions) (resp azfake.PagerResponder[armreservations.AzureReservationAPIClientGetCatalogResponse])
}

AzureReservationAPIServer is a fake server for instances of the armreservations.AzureReservationAPIClient type.

type AzureReservationAPIServerTransport 

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

AzureReservationAPIServerTransport connects instances of armreservations.AzureReservationAPIClient to instances of AzureReservationAPIServer. Don't use this type directly, use NewAzureReservationAPIServerTransport instead.

func NewAzureReservationAPIServerTransport 

func NewAzureReservationAPIServerTransport(srv *AzureReservationAPIServer) *AzureReservationAPIServerTransport

NewAzureReservationAPIServerTransport creates a new instance of AzureReservationAPIServerTransport with the provided implementation. The returned AzureReservationAPIServerTransport instance is connected to an instance of armreservations.AzureReservationAPIClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AzureReservationAPIServerTransport) Do 

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

Do implements the policy.Transporter interface for AzureReservationAPIServerTransport.

type CalculateExchangeServer 

type CalculateExchangeServer struct {
	// BeginPost is the fake for method CalculateExchangeClient.BeginPost
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginPost func(ctx context.Context, body armreservations.CalculateExchangeRequest, options *armreservations.CalculateExchangeClientBeginPostOptions) (resp azfake.PollerResponder[armreservations.CalculateExchangeClientPostResponse], errResp azfake.ErrorResponder)
}

CalculateExchangeServer is a fake server for instances of the armreservations.CalculateExchangeClient type.

type CalculateExchangeServerTransport 

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

CalculateExchangeServerTransport connects instances of armreservations.CalculateExchangeClient to instances of CalculateExchangeServer. Don't use this type directly, use NewCalculateExchangeServerTransport instead.

func NewCalculateExchangeServerTransport 

func NewCalculateExchangeServerTransport(srv *CalculateExchangeServer) *CalculateExchangeServerTransport

NewCalculateExchangeServerTransport creates a new instance of CalculateExchangeServerTransport with the provided implementation. The returned CalculateExchangeServerTransport instance is connected to an instance of armreservations.CalculateExchangeClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*CalculateExchangeServerTransport) Do 

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

Do implements the policy.Transporter interface for CalculateExchangeServerTransport.

type CalculateRefundServer 

type CalculateRefundServer struct {
	// Post is the fake for method CalculateRefundClient.Post
	// HTTP status codes to indicate success: http.StatusOK
	Post func(ctx context.Context, reservationOrderID string, body armreservations.CalculateRefundRequest, options *armreservations.CalculateRefundClientPostOptions) (resp azfake.Responder[armreservations.CalculateRefundClientPostResponse], errResp azfake.ErrorResponder)
}

CalculateRefundServer is a fake server for instances of the armreservations.CalculateRefundClient type.

type CalculateRefundServerTransport 

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

CalculateRefundServerTransport connects instances of armreservations.CalculateRefundClient to instances of CalculateRefundServer. Don't use this type directly, use NewCalculateRefundServerTransport instead.

func NewCalculateRefundServerTransport 

func NewCalculateRefundServerTransport(srv *CalculateRefundServer) *CalculateRefundServerTransport

NewCalculateRefundServerTransport creates a new instance of CalculateRefundServerTransport with the provided implementation. The returned CalculateRefundServerTransport instance is connected to an instance of armreservations.CalculateRefundClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*CalculateRefundServerTransport) Do 

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

Do implements the policy.Transporter interface for CalculateRefundServerTransport.

type ExchangeServer 

type ExchangeServer struct {
	// BeginPost is the fake for method ExchangeClient.BeginPost
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginPost func(ctx context.Context, body armreservations.ExchangeRequest, options *armreservations.ExchangeClientBeginPostOptions) (resp azfake.PollerResponder[armreservations.ExchangeClientPostResponse], errResp azfake.ErrorResponder)
}

ExchangeServer is a fake server for instances of the armreservations.ExchangeClient type.

type ExchangeServerTransport 

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

ExchangeServerTransport connects instances of armreservations.ExchangeClient to instances of ExchangeServer. Don't use this type directly, use NewExchangeServerTransport instead.

func NewExchangeServerTransport 

func NewExchangeServerTransport(srv *ExchangeServer) *ExchangeServerTransport

NewExchangeServerTransport creates a new instance of ExchangeServerTransport with the provided implementation. The returned ExchangeServerTransport instance is connected to an instance of armreservations.ExchangeClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ExchangeServerTransport) Do 

func (e *ExchangeServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ExchangeServerTransport.

type OperationServer 

type OperationServer struct {
	// NewListPager is the fake for method OperationClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armreservations.OperationClientListOptions) (resp azfake.PagerResponder[armreservations.OperationClientListResponse])
}

OperationServer is a fake server for instances of the armreservations.OperationClient type.

type OperationServerTransport 

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

OperationServerTransport connects instances of armreservations.OperationClient to instances of OperationServer. Don't use this type directly, use NewOperationServerTransport instead.

func NewOperationServerTransport 

func NewOperationServerTransport(srv *OperationServer) *OperationServerTransport

NewOperationServerTransport creates a new instance of OperationServerTransport with the provided implementation. The returned OperationServerTransport instance is connected to an instance of armreservations.OperationClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*OperationServerTransport) Do 

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

Do implements the policy.Transporter interface for OperationServerTransport.

type QuotaRequestStatusServer 

type QuotaRequestStatusServer struct {
	// Get is the fake for method QuotaRequestStatusClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, subscriptionID string, providerID string, location string, id string, options *armreservations.QuotaRequestStatusClientGetOptions) (resp azfake.Responder[armreservations.QuotaRequestStatusClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method QuotaRequestStatusClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(subscriptionID string, providerID string, location string, options *armreservations.QuotaRequestStatusClientListOptions) (resp azfake.PagerResponder[armreservations.QuotaRequestStatusClientListResponse])
}

QuotaRequestStatusServer is a fake server for instances of the armreservations.QuotaRequestStatusClient type.

type QuotaRequestStatusServerTransport 

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

QuotaRequestStatusServerTransport connects instances of armreservations.QuotaRequestStatusClient to instances of QuotaRequestStatusServer. Don't use this type directly, use NewQuotaRequestStatusServerTransport instead.

func NewQuotaRequestStatusServerTransport 

func NewQuotaRequestStatusServerTransport(srv *QuotaRequestStatusServer) *QuotaRequestStatusServerTransport

NewQuotaRequestStatusServerTransport creates a new instance of QuotaRequestStatusServerTransport with the provided implementation. The returned QuotaRequestStatusServerTransport instance is connected to an instance of armreservations.QuotaRequestStatusClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*QuotaRequestStatusServerTransport) Do 

func (q *QuotaRequestStatusServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for QuotaRequestStatusServerTransport.

type QuotaServer 

type QuotaServer struct {
	// BeginCreateOrUpdate is the fake for method QuotaClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginCreateOrUpdate func(ctx context.Context, subscriptionID string, providerID string, location string, resourceName string, createQuotaRequest armreservations.CurrentQuotaLimitBase, options *armreservations.QuotaClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armreservations.QuotaClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method QuotaClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, subscriptionID string, providerID string, location string, resourceName string, options *armreservations.QuotaClientGetOptions) (resp azfake.Responder[armreservations.QuotaClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method QuotaClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(subscriptionID string, providerID string, location string, options *armreservations.QuotaClientListOptions) (resp azfake.PagerResponder[armreservations.QuotaClientListResponse])

	// BeginUpdate is the fake for method QuotaClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusCreated
	BeginUpdate func(ctx context.Context, subscriptionID string, providerID string, location string, resourceName string, createQuotaRequest armreservations.CurrentQuotaLimitBase, options *armreservations.QuotaClientBeginUpdateOptions) (resp azfake.PollerResponder[armreservations.QuotaClientUpdateResponse], errResp azfake.ErrorResponder)
}

QuotaServer is a fake server for instances of the armreservations.QuotaClient type.

type QuotaServerTransport 

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

QuotaServerTransport connects instances of armreservations.QuotaClient to instances of QuotaServer. Don't use this type directly, use NewQuotaServerTransport instead.

func NewQuotaServerTransport 

func NewQuotaServerTransport(srv *QuotaServer) *QuotaServerTransport

NewQuotaServerTransport creates a new instance of QuotaServerTransport with the provided implementation. The returned QuotaServerTransport instance is connected to an instance of armreservations.QuotaClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*QuotaServerTransport) Do 

func (q *QuotaServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for QuotaServerTransport.

type ReservationOrderServer 

type ReservationOrderServer struct {
	// Calculate is the fake for method ReservationOrderClient.Calculate
	// HTTP status codes to indicate success: http.StatusOK
	Calculate func(ctx context.Context, body armreservations.PurchaseRequest, options *armreservations.ReservationOrderClientCalculateOptions) (resp azfake.Responder[armreservations.ReservationOrderClientCalculateResponse], errResp azfake.ErrorResponder)

	// ChangeDirectory is the fake for method ReservationOrderClient.ChangeDirectory
	// HTTP status codes to indicate success: http.StatusOK
	ChangeDirectory func(ctx context.Context, reservationOrderID string, body armreservations.ChangeDirectoryRequest, options *armreservations.ReservationOrderClientChangeDirectoryOptions) (resp azfake.Responder[armreservations.ReservationOrderClientChangeDirectoryResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ReservationOrderClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, reservationOrderID string, options *armreservations.ReservationOrderClientGetOptions) (resp azfake.Responder[armreservations.ReservationOrderClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ReservationOrderClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armreservations.ReservationOrderClientListOptions) (resp azfake.PagerResponder[armreservations.ReservationOrderClientListResponse])

	// BeginPurchase is the fake for method ReservationOrderClient.BeginPurchase
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginPurchase func(ctx context.Context, reservationOrderID string, body armreservations.PurchaseRequest, options *armreservations.ReservationOrderClientBeginPurchaseOptions) (resp azfake.PollerResponder[armreservations.ReservationOrderClientPurchaseResponse], errResp azfake.ErrorResponder)
}

ReservationOrderServer is a fake server for instances of the armreservations.ReservationOrderClient type.

type ReservationOrderServerTransport 

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

ReservationOrderServerTransport connects instances of armreservations.ReservationOrderClient to instances of ReservationOrderServer. Don't use this type directly, use NewReservationOrderServerTransport instead.

func NewReservationOrderServerTransport 

func NewReservationOrderServerTransport(srv *ReservationOrderServer) *ReservationOrderServerTransport

NewReservationOrderServerTransport creates a new instance of ReservationOrderServerTransport with the provided implementation. The returned ReservationOrderServerTransport instance is connected to an instance of armreservations.ReservationOrderClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ReservationOrderServerTransport) Do 

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

Do implements the policy.Transporter interface for ReservationOrderServerTransport.

type ReservationServer 

type ReservationServer struct {
	// Archive is the fake for method ReservationClient.Archive
	// HTTP status codes to indicate success: http.StatusOK
	Archive func(ctx context.Context, reservationOrderID string, reservationID string, options *armreservations.ReservationClientArchiveOptions) (resp azfake.Responder[armreservations.ReservationClientArchiveResponse], errResp azfake.ErrorResponder)

	// BeginAvailableScopes is the fake for method ReservationClient.BeginAvailableScopes
	// HTTP status codes to indicate success: http.StatusOK
	BeginAvailableScopes func(ctx context.Context, reservationOrderID string, reservationID string, body armreservations.AvailableScopeRequest, options *armreservations.ReservationClientBeginAvailableScopesOptions) (resp azfake.PollerResponder[armreservations.ReservationClientAvailableScopesResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ReservationClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, reservationOrderID string, reservationID string, options *armreservations.ReservationClientGetOptions) (resp azfake.Responder[armreservations.ReservationClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method ReservationClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(reservationOrderID string, options *armreservations.ReservationClientListOptions) (resp azfake.PagerResponder[armreservations.ReservationClientListResponse])

	// NewListAllPager is the fake for method ReservationClient.NewListAllPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListAllPager func(options *armreservations.ReservationClientListAllOptions) (resp azfake.PagerResponder[armreservations.ReservationClientListAllResponse])

	// NewListRevisionsPager is the fake for method ReservationClient.NewListRevisionsPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListRevisionsPager func(reservationOrderID string, reservationID string, options *armreservations.ReservationClientListRevisionsOptions) (resp azfake.PagerResponder[armreservations.ReservationClientListRevisionsResponse])

	// BeginMerge is the fake for method ReservationClient.BeginMerge
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginMerge func(ctx context.Context, reservationOrderID string, body armreservations.MergeRequest, options *armreservations.ReservationClientBeginMergeOptions) (resp azfake.PollerResponder[armreservations.ReservationClientMergeResponse], errResp azfake.ErrorResponder)

	// BeginSplit is the fake for method ReservationClient.BeginSplit
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginSplit func(ctx context.Context, reservationOrderID string, body armreservations.SplitRequest, options *armreservations.ReservationClientBeginSplitOptions) (resp azfake.PollerResponder[armreservations.ReservationClientSplitResponse], errResp azfake.ErrorResponder)

	// Unarchive is the fake for method ReservationClient.Unarchive
	// HTTP status codes to indicate success: http.StatusOK
	Unarchive func(ctx context.Context, reservationOrderID string, reservationID string, options *armreservations.ReservationClientUnarchiveOptions) (resp azfake.Responder[armreservations.ReservationClientUnarchiveResponse], errResp azfake.ErrorResponder)

	// BeginUpdate is the fake for method ReservationClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, reservationOrderID string, reservationID string, parameters armreservations.Patch, options *armreservations.ReservationClientBeginUpdateOptions) (resp azfake.PollerResponder[armreservations.ReservationClientUpdateResponse], errResp azfake.ErrorResponder)
}

ReservationServer is a fake server for instances of the armreservations.ReservationClient type.

type ReservationServerTransport 

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

ReservationServerTransport connects instances of armreservations.ReservationClient to instances of ReservationServer. Don't use this type directly, use NewReservationServerTransport instead.

func NewReservationServerTransport 

func NewReservationServerTransport(srv *ReservationServer) *ReservationServerTransport

NewReservationServerTransport creates a new instance of ReservationServerTransport with the provided implementation. The returned ReservationServerTransport instance is connected to an instance of armreservations.ReservationClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ReservationServerTransport) Do 

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

Do implements the policy.Transporter interface for ReservationServerTransport.

type ReturnServer 

type ReturnServer struct {
	// BeginPost is the fake for method ReturnClient.BeginPost
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginPost func(ctx context.Context, reservationOrderID string, body armreservations.RefundRequest, options *armreservations.ReturnClientBeginPostOptions) (resp azfake.PollerResponder[armreservations.ReturnClientPostResponse], errResp azfake.ErrorResponder)
}

ReturnServer is a fake server for instances of the armreservations.ReturnClient type.

type ReturnServerTransport 

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

ReturnServerTransport connects instances of armreservations.ReturnClient to instances of ReturnServer. Don't use this type directly, use NewReturnServerTransport instead.

func NewReturnServerTransport 

func NewReturnServerTransport(srv *ReturnServer) *ReturnServerTransport

NewReturnServerTransport creates a new instance of ReturnServerTransport with the provided implementation. The returned ReturnServerTransport instance is connected to an instance of armreservations.ReturnClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ReturnServerTransport) Do 

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

Do implements the policy.Transporter interface for ReturnServerTransport.

type ServerFactory 

type ServerFactory struct {
	AzureReservationAPIServer AzureReservationAPIServer
	CalculateExchangeServer   CalculateExchangeServer
	CalculateRefundServer     CalculateRefundServer
	ExchangeServer            ExchangeServer
	OperationServer           OperationServer
	QuotaServer               QuotaServer
	QuotaRequestStatusServer  QuotaRequestStatusServer
	ReservationServer         ReservationServer
	ReservationOrderServer    ReservationOrderServer
	ReturnServer              ReturnServer
}

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

type ServerFactoryTransport 

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

ServerFactoryTransport connects instances of armreservations.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 armreservations.ClientFactory via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ServerFactoryTransport) Do 

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

Do implements the policy.Transporter interface for ServerFactoryTransport.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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