mockhttp

package module
v0.0.3 Latest Latest
Warning

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

 Go to latest Published: Oct 4, 2025 License: Apache-2.0 Imports: 18 Imported by: 0

README

Mockhttp Go API Library

Go Reference

The Mockhttp Go library provides convenient access to the Mockhttp REST API from applications written in Go.

It is generated with Stainless.

Installation

import (
	"github.com/rtfmtom/mockHttp-stainless" // imported as mockhttp
)

Or to pin the version:

go get -u 'github.com/rtfmtom/mockHttp-stainless@v0.0.3'

Requirements

This library requires Go 1.22+.

Usage

The full API of this library can be found in api.md.

package main

import (
	"context"
	"fmt"

	"github.com/rtfmtom/mockHttp-stainless"
	"github.com/rtfmtom/mockHttp-stainless/option"
)

func main() {
	client := mockhttp.NewClient(
		option.WithAPIKey("My API Key"), // defaults to os.LookupEnv("MOCKHTTP_API_KEY")
	)
	response, err := client.Get.RequestInfo(context.TODO())
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response.Headers)
}
Request fields

The mockhttp library uses the omitzero semantics from the Go 1.24+ encoding/json release for request fields.

Required primitive fields (int64, string, etc.) feature the tag `json:"...,required"`. These fields are always serialized, even their zero values.

Optional primitive types are wrapped in a param.Opt[T]. These fields can be set with the provided constructors, mockhttp.String(string), mockhttp.Int(int64), etc.

Any param.Opt[T], map, slice, struct or string enum uses the tag `json:"...,omitzero"`. Its zero value is considered omitted.

The param.IsOmitted(any) function can confirm the presence of any omitzero field.

p := mockhttp.ExampleParams{
	ID:   "id_xxx",               // required property
	Name: mockhttp.String("..."), // optional property

	Point: mockhttp.Point{
		X: 0,               // required field will serialize as 0
		Y: mockhttp.Int(1), // optional field will serialize as 1
		// ... omitted non-required fields will not be serialized
	},

	Origin: mockhttp.Origin{}, // the zero value of [Origin] is considered omitted
}

To send null instead of a param.Opt[T], use param.Null[T](). To send null instead of a struct T, use param.NullStruct[T]().

p.Name = param.Null[string]()       // 'null' instead of string
p.Point = param.NullStruct[Point]() // 'null' instead of struct

param.IsNull(p.Name)  // true
param.IsNull(p.Point) // true

Request structs contain a .SetExtraFields(map[string]any) method which can send non-conforming fields in the request body. Extra fields overwrite any struct fields with a matching key. For security reasons, only use SetExtraFields with trusted data.

To send a custom value instead of a struct, use param.Override[T](value).

// In cases where the API specifies a given type,
// but you want to send something else, use [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Send a number instead of an object
custom := param.Override[mockhttp.FooParams](12)
Request unions

Unions are represented as a struct with fields prefixed by "Of" for each of it's variants, only one field can be non-zero. The non-zero field will be serialized.

Sub-properties of the union can be accessed via methods on the union struct. These methods return a mutable pointer to the underlying data, if present.

// Only one field can be non-zero, use param.IsOmitted() to check if a field is set
type AnimalUnionParam struct {
	OfCat *Cat `json:",omitzero,inline`
	OfDog *Dog `json:",omitzero,inline`
}

animal := AnimalUnionParam{
	OfCat: &Cat{
		Name: "Whiskers",
		Owner: PersonParam{
			Address: AddressParam{Street: "3333 Coyote Hill Rd", Zip: 0},
		},
	},
}

// Mutating a field
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}
Response objects

All fields in response structs are ordinary value types (not pointers or wrappers). Response structs also include a special JSON field containing metadata about each property.

type Animal struct {
	Name   string `json:"name,nullable"`
	Owners int    `json:"owners"`
	Age    int    `json:"age"`
	JSON   struct {
		Name        respjson.Field
		Owner       respjson.Field
		Age         respjson.Field
		ExtraFields map[string]respjson.Field
	} `json:"-"`
}

To handle optional data, use the .Valid() method on the JSON field. .Valid() returns true if a field is not null, not present, or couldn't be marshaled.

If .Valid() is false, the corresponding field will simply be its zero value.

raw := `{"owners": 1, "name": null}`

var res Animal
json.Unmarshal([]byte(raw), &res)

// Accessing regular fields

res.Owners // 1
res.Name   // ""
res.Age    // 0

// Optional field checks

res.JSON.Owners.Valid() // true
res.JSON.Name.Valid()   // false
res.JSON.Age.Valid()    // false

// Raw JSON values

res.JSON.Owners.Raw()                  // "1"
res.JSON.Name.Raw() == "null"          // true
res.JSON.Name.Raw() == respjson.Null   // true
res.JSON.Age.Raw() == ""               // true
res.JSON.Age.Raw() == respjson.Omitted // true

These .JSON structs also include an ExtraFields map containing any properties in the json response that were not specified in the struct. This can be useful for API features not yet present in the SDK.

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()
Response Unions

In responses, unions are represented by a flattened struct containing all possible fields from each of the object variants. To convert it to a variant use the .AsFooVariant() method or the .AsAny() method if present.

If a response value union contains primitive values, primitive fields will be alongside the properties but prefixed with Of and feature the tag json:"...,inline".

type AnimalUnion struct {
	// From variants [Dog], [Cat]
	Owner Person `json:"owner"`
	// From variant [Dog]
	DogBreed string `json:"dog_breed"`
	// From variant [Cat]
	CatBreed string `json:"cat_breed"`
	// ...

	JSON struct {
		Owner respjson.Field
		// ...
	} `json:"-"`
}

// If animal variant
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Switch on the variant
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}
RequestOptions

This library uses the functional options pattern. Functions defined in the option package return a RequestOption, which is a closure that mutates a RequestConfig. These options can be supplied to the client or at individual requests. For example:

client := mockhttp.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Get.RequestInfo(context.TODO(), ...,
	// Override the header
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Add an undocumented field to the request body, using sjson syntax
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

The request option option.WithDebugLog(nil) may be helpful while debugging.

See the full list of request options.

Pagination

This library provides some conveniences for working with paginated list endpoints.

You can use .ListAutoPaging() methods to iterate through items across all pages:

Or you can use simple .List() methods to fetch a single page and receive a standard response object with additional helper methods like .GetNextPage(), e.g.:

Errors

When the API returns a non-success status code, we return an error with type *mockhttp.Error. This contains the StatusCode, *http.Request, and *http.Response values of the request, as well as the JSON of the error body (much like other response objects in the SDK).

To handle errors, we recommend that you use the errors.As pattern:

_, err := client.Get.RequestInfo(context.TODO())
if err != nil {
	var apierr *mockhttp.Error
	if errors.As(err, &apierr) {
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // GET "/get": 400 Bad Request { ... }
}

When other errors occur, they are returned unwrapped; for example, if HTTP transport fails, you might receive *url.Error wrapping *net.OpError.

Timeouts

Requests do not time out by default; use context to configure a timeout for a request lifecycle.

Note that if a request is retried, the context timeout does not start over. To set a per-retry timeout, use option.WithRequestTimeout().

// This sets the timeout for the request, including all the retries.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
client.Get.RequestInfo(
	ctx,
	// This sets the per-retry timeout
	option.WithRequestTimeout(20*time.Second),
)
File uploads

Request parameters that correspond to file uploads in multipart requests are typed as io.Reader. The contents of the io.Reader will by default be sent as a multipart form part with the file name of "anonymous_file" and content-type of "application/octet-stream".

The file name and content-type can be customized by implementing Name() string or ContentType() string on the run-time type of io.Reader. Note that os.File implements Name() string, so a file returned by os.Open will be sent with the file name on disk.

We also provide a helper mockhttp.File(reader io.Reader, filename string, contentType string) which can be used to wrap any io.Reader with the appropriate file name and content type.

Retries

Certain errors will be automatically retried 2 times by default, with a short exponential backoff. We retry by default all connection errors, 408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors.

You can use the WithMaxRetries option to configure or disable this:

// Configure the default for all requests:
client := mockhttp.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Get.RequestInfo(context.TODO(), option.WithMaxRetries(5))
Accessing raw response data (e.g. response headers)

You can access the raw HTTP response data by using the option.WithResponseInto() request option. This is useful when you need to examine response headers, status codes, or other details.

// Create a variable to store the HTTP response
var response *http.Response
response, err := client.Get.RequestInfo(context.TODO(), option.WithResponseInto(&response))
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", response)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)
Making custom/undocumented requests

This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, params, or response properties, the library can still be used.

Undocumented endpoints

To make requests to undocumented endpoints, you can use client.Get, client.Post, and other HTTP verbs. RequestOptions on the client, such as retries, will be respected when making these requests.

var (
    // params can be an io.Reader, a []byte, an encoding/json serializable object,
    // or a "…Params" struct defined in this library.
    params map[string]any

    // result can be an []byte, *http.Response, a encoding/json deserializable object,
    // or a model defined in this library.
    result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
    …
}
Undocumented request params

To make requests using undocumented parameters, you may use either the option.WithQuerySet() or the option.WithJSONSet() methods.

params := FooNewParams{
    ID:   "id_xxxx",
    Data: FooNewParamsData{
        FirstName: mockhttp.String("John"),
    },
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))
Undocumented response properties

To access undocumented response properties, you may either access the raw JSON of the response as a string with result.JSON.RawJSON(), or get the raw JSON of a particular field on the result with result.JSON.Foo.Raw().

Any fields that are not present on the response struct will be saved and can be accessed by result.JSON.ExtraFields() which returns the extra fields as a map[string]Field.

Middleware

We provide option.WithMiddleware which applies the given middleware to requests.

func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
	// Before the request
	start := time.Now()
	LogReq(req)

	// Forward the request to the next handler
	res, err = next(req)

	// Handle stuff after the request
	end := time.Now()
	LogRes(res, err, start - end)

    return res, err
}

client := mockhttp.NewClient(
	option.WithMiddleware(Logger),
)

When multiple middlewares are provided as variadic arguments, the middlewares are applied left to right. If option.WithMiddleware is given multiple times, for example first in the client then the method, the middleware in the client will run first and the middleware given in the method will run next.

You may also replace the default http.Client with option.WithHTTPClient(client). Only one http client is accepted (this overwrites any previous client) and receives requests after any middleware has been applied.

Semantic versioning

This package generally follows SemVer conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes to library internals which are technically public but not intended or documented for external use. (Please open a GitHub issue to let us know if you are relying on such internals.)
  2. Changes that we do not expect to impact the vast majority of users in practice.

We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

We are keen for your feedback; please open an issue with questions, bugs, or suggestions.

Contributing

See the contributing documentation.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Bool 

func Bool(b bool) param.Opt[bool]

func BoolPtr 

func BoolPtr(v bool) *bool

func DefaultClientOptions 

func DefaultClientOptions() []option.RequestOption

DefaultClientOptions read from the environment (MOCKHTTP_API_KEY, MOCKHTTP_BASE_URL). This should be used to initialize new clients.

func File 

func File(rdr io.Reader, filename string, contentType string) file

func Float 

func Float(f float64) param.Opt[float64]

func FloatPtr 

func FloatPtr(v float64) *float64

func Int 

func Int(i int64) param.Opt[int64]

func IntPtr 

func IntPtr(v int64) *int64

func Opt 

func Opt[T comparable](v T) param.Opt[T]

func Ptr 

func Ptr[T any](v T) *T

func String 

func String(s string) param.Opt[string]

func StringPtr 

func StringPtr(v string) *string

func Time 

func Time(t time.Time) param.Opt[time.Time]

func TimePtr 

func TimePtr(v time.Time) *time.Time

Types

type AbsoluteRedirectGetParams 

type AbsoluteRedirectGetParams struct {
	Host string `header:"host,required" json:"-"`
	// contains filtered or unexported fields
}

type AbsoluteRedirectService 

type AbsoluteRedirectService struct {
	Options []option.RequestOption
}

AbsoluteRedirectService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAbsoluteRedirectService method instead.

func NewAbsoluteRedirectService 

func NewAbsoluteRedirectService(opts ...option.RequestOption) (r AbsoluteRedirectService)

NewAbsoluteRedirectService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AbsoluteRedirectService) Get 

func (r *AbsoluteRedirectService) Get(ctx context.Context, value int64, query AbsoluteRedirectGetParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL using an absolute URL

type AnythingDeleteResponse 

type AnythingDeleteResponse struct {
	// Route parameters
	Args map[string]any `json:"args"`
	// Request body data
	Data map[string]any `json:"data"`
	// Uploaded files
	Files map[string]any `json:"files"`
	// Form data
	Form map[string]any `json:"form"`
	// Request headers
	Headers map[string]any `json:"headers"`
	// Parsed JSON body
	Json map[string]any `json:"json"`
	// HTTP method used
	Method string `json:"method"`
	// Origin of the request
	Origin string `json:"origin"`
	// Request URL
	URL string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Args        respjson.Field
		Data        respjson.Field
		Files       respjson.Field
		Form        respjson.Field
		Headers     respjson.Field
		Json        respjson.Field
		Method      respjson.Field
		Origin      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AnythingDeleteResponse) RawJSON 

func (r AnythingDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*AnythingDeleteResponse) UnmarshalJSON 

func (r *AnythingDeleteResponse) UnmarshalJSON(data []byte) error

type AnythingListResponse 

type AnythingListResponse struct {
	// Route parameters
	Args map[string]any `json:"args"`
	// Request body data
	Data map[string]any `json:"data"`
	// Uploaded files
	Files map[string]any `json:"files"`
	// Form data
	Form map[string]any `json:"form"`
	// Request headers
	Headers map[string]any `json:"headers"`
	// Parsed JSON body
	Json map[string]any `json:"json"`
	// HTTP method used
	Method string `json:"method"`
	// Origin of the request
	Origin string `json:"origin"`
	// Request URL
	URL string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Args        respjson.Field
		Data        respjson.Field
		Files       respjson.Field
		Form        respjson.Field
		Headers     respjson.Field
		Json        respjson.Field
		Method      respjson.Field
		Origin      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AnythingListResponse) RawJSON 

func (r AnythingListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*AnythingListResponse) UnmarshalJSON 

func (r *AnythingListResponse) UnmarshalJSON(data []byte) error

type AnythingNewResponse 

type AnythingNewResponse struct {
	// Route parameters
	Args map[string]any `json:"args"`
	// Request body data
	Data map[string]any `json:"data"`
	// Uploaded files
	Files map[string]any `json:"files"`
	// Form data
	Form map[string]any `json:"form"`
	// Request headers
	Headers map[string]any `json:"headers"`
	// Parsed JSON body
	Json map[string]any `json:"json"`
	// HTTP method used
	Method string `json:"method"`
	// Origin of the request
	Origin string `json:"origin"`
	// Request URL
	URL string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Args        respjson.Field
		Data        respjson.Field
		Files       respjson.Field
		Form        respjson.Field
		Headers     respjson.Field
		Json        respjson.Field
		Method      respjson.Field
		Origin      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AnythingNewResponse) RawJSON 

func (r AnythingNewResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*AnythingNewResponse) UnmarshalJSON 

func (r *AnythingNewResponse) UnmarshalJSON(data []byte) error

type AnythingPatchResponse 

type AnythingPatchResponse struct {
	// Route parameters
	Args map[string]any `json:"args"`
	// Request body data
	Data map[string]any `json:"data"`
	// Uploaded files
	Files map[string]any `json:"files"`
	// Form data
	Form map[string]any `json:"form"`
	// Request headers
	Headers map[string]any `json:"headers"`
	// Parsed JSON body
	Json map[string]any `json:"json"`
	// HTTP method used
	Method string `json:"method"`
	// Origin of the request
	Origin string `json:"origin"`
	// Request URL
	URL string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Args        respjson.Field
		Data        respjson.Field
		Files       respjson.Field
		Form        respjson.Field
		Headers     respjson.Field
		Json        respjson.Field
		Method      respjson.Field
		Origin      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AnythingPatchResponse) RawJSON 

func (r AnythingPatchResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*AnythingPatchResponse) UnmarshalJSON 

func (r *AnythingPatchResponse) UnmarshalJSON(data []byte) error

type AnythingService 

type AnythingService struct {
	Options []option.RequestOption
}

AnythingService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewAnythingService method instead.

func NewAnythingService 

func NewAnythingService(opts ...option.RequestOption) (r AnythingService)

NewAnythingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*AnythingService) Delete 

func (r *AnythingService) Delete(ctx context.Context, opts ...option.RequestOption) (res *AnythingDeleteResponse, err error)

Will return anything that you send it

func (*AnythingService) List 

func (r *AnythingService) List(ctx context.Context, opts ...option.RequestOption) (res *AnythingListResponse, err error)

Will return anything that you send it

func (*AnythingService) New 

func (r *AnythingService) New(ctx context.Context, opts ...option.RequestOption) (res *AnythingNewResponse, err error)

Will return anything that you send it

func (*AnythingService) Patch 

func (r *AnythingService) Patch(ctx context.Context, opts ...option.RequestOption) (res *AnythingPatchResponse, err error)

Will return anything that you send it

func (*AnythingService) Update 

func (r *AnythingService) Update(ctx context.Context, opts ...option.RequestOption) (res *AnythingUpdateResponse, err error)

Will return anything that you send it

type AnythingUpdateResponse 

type AnythingUpdateResponse struct {
	// Route parameters
	Args map[string]any `json:"args"`
	// Request body data
	Data map[string]any `json:"data"`
	// Uploaded files
	Files map[string]any `json:"files"`
	// Form data
	Form map[string]any `json:"form"`
	// Request headers
	Headers map[string]any `json:"headers"`
	// Parsed JSON body
	Json map[string]any `json:"json"`
	// HTTP method used
	Method string `json:"method"`
	// Origin of the request
	Origin string `json:"origin"`
	// Request URL
	URL string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Args        respjson.Field
		Data        respjson.Field
		Files       respjson.Field
		Form        respjson.Field
		Headers     respjson.Field
		Json        respjson.Field
		Method      respjson.Field
		Origin      respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AnythingUpdateResponse) RawJSON 

func (r AnythingUpdateResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*AnythingUpdateResponse) UnmarshalJSON 

func (r *AnythingUpdateResponse) UnmarshalJSON(data []byte) error

type BasicAuthAuthenticateParams 

type BasicAuthAuthenticateParams struct {
	User string `path:"user,required" json:"-"`
	// contains filtered or unexported fields
}

type BasicAuthAuthenticateResponse 

type BasicAuthAuthenticateResponse struct {
	Authenticated bool   `json:"authenticated,required"`
	User          string `json:"user,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Authenticated respjson.Field
		User          respjson.Field
		ExtraFields   map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (BasicAuthAuthenticateResponse) RawJSON 

func (r BasicAuthAuthenticateResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*BasicAuthAuthenticateResponse) UnmarshalJSON 

func (r *BasicAuthAuthenticateResponse) UnmarshalJSON(data []byte) error

type BasicAuthService 

type BasicAuthService struct {
	Options []option.RequestOption
}

BasicAuthService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewBasicAuthService method instead.

func NewBasicAuthService 

func NewBasicAuthService(opts ...option.RequestOption) (r BasicAuthService)

NewBasicAuthService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*BasicAuthService) Authenticate 

func (r *BasicAuthService) Authenticate(ctx context.Context, passwd string, query BasicAuthAuthenticateParams, opts ...option.RequestOption) (res *BasicAuthAuthenticateResponse, err error)

HTTP Basic authentication. Succeeds only if the user/pass provided in the path matches the Basic Authorization header.

type BearerGetParams 

type BearerGetParams struct {
	Required param.Opt[bool] `query:"required,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (BearerGetParams) URLQuery 

func (r BearerGetParams) URLQuery() (v url.Values, err error)

URLQuery serializes BearerGetParams's query parameters as `url.Values`.

type BearerGetResponse 

type BearerGetResponse struct {
	Token         string `json:"token,required"`
	Authenticated bool   `json:"authenticated,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Token         respjson.Field
		Authenticated respjson.Field
		ExtraFields   map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (BearerGetResponse) RawJSON 

func (r BearerGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*BearerGetResponse) UnmarshalJSON 

func (r *BearerGetResponse) UnmarshalJSON(data []byte) error

type BearerService 

type BearerService struct {
	Options []option.RequestOption
}

BearerService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewBearerService method instead.

func NewBearerService 

func NewBearerService(opts ...option.RequestOption) (r BearerService)

NewBearerService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*BearerService) Get 

func (r *BearerService) Get(ctx context.Context, query BearerGetParams, opts ...option.RequestOption) (res *BearerGetResponse, err error)

HTTP Bearer authentication. Succeeds if any Bearer token is present unless ?required=true is provided.

type BrotliService 

type BrotliService struct {
	Options []option.RequestOption
}

BrotliService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewBrotliService method instead.

func NewBrotliService 

func NewBrotliService(opts ...option.RequestOption) (r BrotliService)

NewBrotliService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*BrotliService) Delete 

func (r *BrotliService) Delete(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Brotli-encoded data

func (*BrotliService) Get 

func (r *BrotliService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Brotli-encoded data

func (*BrotliService) Modify 

func (r *BrotliService) Modify(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Brotli-encoded data

func (*BrotliService) New 

func (r *BrotliService) New(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Brotli-encoded data

func (*BrotliService) Update 

func (r *BrotliService) Update(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Brotli-encoded data

type CacheService 

type CacheService struct {
	Options []option.RequestOption
}

CacheService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCacheService method instead.

func NewCacheService 

func NewCacheService(opts ...option.RequestOption) (r CacheService)

NewCacheService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CacheService) Get 

func (r *CacheService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Handles cache validation and retrieval.

func (*CacheService) SetCacheControl 

func (r *CacheService) SetCacheControl(ctx context.Context, value int64, opts ...option.RequestOption) (res *string, err error)

Sets a Cache-Control header for n seconds.

type Client 

type Client struct {
	Options          []option.RequestOption
	Get              GetService
	Post             PostService
	Delete           DeleteService
	Put              PutService
	Patch            PatchService
	Status           StatusService
	IP               IPService
	Headers          HeaderService
	UserAgent        UserAgentService
	Cache            CacheService
	Etag             EtagService
	ResponseHeaders  ResponseHeaderService
	Plain            PlainService
	Text             TextService
	HTML             HTMLService
	Xml              XmlService
	Json             JsonService
	Deny             DenyService
	Gzip             GzipService
	Deflate          DeflateService
	Brotli           BrotliService
	AbsoluteRedirect AbsoluteRedirectService
	RelativeRedirect RelativeRedirectService
	RedirectTo       RedirectToService
	Cookies          CookieService
	Anything         AnythingService
	BasicAuth        BasicAuthService
	Bearer           BearerService
	DigestAuth       DigestAuthService
}

Client creates a struct with services and top level methods that help with interacting with the mockhttp API. You should not instantiate this client directly, and instead use the NewClient method instead.

func NewClient 

func NewClient(opts ...option.RequestOption) (r Client)

NewClient generates a new client with the default option read from the environment (MOCKHTTP_API_KEY, MOCKHTTP_BASE_URL). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) DeleteRequest 

func (r *Client) DeleteRequest(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Delete makes a DELETE request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Execute 

func (r *Client) Execute(ctx context.Context, method string, path string, params any, res any, opts ...option.RequestOption) error

Execute makes a request with the given context, method, URL, request params, response, and request options. This is useful for hitting undocumented endpoints while retaining the base URL, auth, retries, and other options from the client.

If a byte slice or an io.Reader is supplied to params, it will be used as-is for the request body.

The params is by default serialized into the body using encoding/json. If your type implements a MarshalJSON function, it will be used instead to serialize the request. If a URLQuery method is implemented, the returned url.Values will be used as query strings to the url.

If your params struct uses param.Field, you must provide either [MarshalJSON], [URLQuery], and/or [MarshalForm] functions. It is undefined behavior to use a struct uses param.Field without specifying how it is serialized.

Any "…Params" object defined in this library can be used as the request argument. Note that 'path' arguments will not be forwarded into the url.

The response body will be deserialized into the res variable, depending on its type:

  • A pointer to a *http.Response is populated by the raw response.
  • A pointer to a byte array will be populated with the contents of the request body.
  • A pointer to any other type uses this library's default JSON decoding, which respects UnmarshalJSON if it is defined on the type.
  • A nil value will not read the response body.

For even greater flexibility, see option.WithResponseInto and option.WithResponseBodyInto.

func (*Client) GetRequest 

func (r *Client) GetRequest(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Get makes a GET request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) PatchRequest 

func (r *Client) PatchRequest(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Patch makes a PATCH request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) PostRequest 

func (r *Client) PostRequest(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Post makes a POST request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) PutRequest 

func (r *Client) PutRequest(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Put makes a PUT request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

type CookieDeleteParams 

type CookieDeleteParams struct {
	Name string `query:"name,required" json:"-"`
	// contains filtered or unexported fields
}

func (CookieDeleteParams) URLQuery 

func (r CookieDeleteParams) URLQuery() (v url.Values, err error)

URLQuery serializes CookieDeleteParams's query parameters as `url.Values`.

type CookieListResponse 

type CookieListResponse struct {
	Cookies map[string]string `json:"cookies,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cookies     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (CookieListResponse) RawJSON 

func (r CookieListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*CookieListResponse) UnmarshalJSON 

func (r *CookieListResponse) UnmarshalJSON(data []byte) error

type CookieNewParams 

type CookieNewParams struct {
	Name    string               `json:"name,required"`
	Value   string               `json:"value,required"`
	Expires param.Opt[time.Time] `json:"expires,omitzero" format:"date-time"`
	// contains filtered or unexported fields
}

func (CookieNewParams) MarshalJSON 

func (r CookieNewParams) MarshalJSON() (data []byte, err error)

func (*CookieNewParams) UnmarshalJSON 

func (r *CookieNewParams) UnmarshalJSON(data []byte) error

type CookieNewResponse 

type CookieNewResponse struct {
	Cookies map[string]string `json:"cookies,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cookies     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (CookieNewResponse) RawJSON 

func (r CookieNewResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*CookieNewResponse) UnmarshalJSON 

func (r *CookieNewResponse) UnmarshalJSON(data []byte) error

type CookieService 

type CookieService struct {
	Options []option.RequestOption
}

CookieService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCookieService method instead.

func NewCookieService 

func NewCookieService(opts ...option.RequestOption) (r CookieService)

NewCookieService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CookieService) Delete 

func (r *CookieService) Delete(ctx context.Context, body CookieDeleteParams, opts ...option.RequestOption) (err error)

Delete a cookie

func (*CookieService) List 

func (r *CookieService) List(ctx context.Context, opts ...option.RequestOption) (res *CookieListResponse, err error)

Return cookies from the request

func (*CookieService) New 

func (r *CookieService) New(ctx context.Context, body CookieNewParams, opts ...option.RequestOption) (res *CookieNewResponse, err error)

Set a cookie

type DeflateService 

type DeflateService struct {
	Options []option.RequestOption
}

DeflateService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeflateService method instead.

func NewDeflateService 

func NewDeflateService(opts ...option.RequestOption) (r DeflateService)

NewDeflateService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeflateService) Delete 

func (r *DeflateService) Delete(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Deflate-encoded data

func (*DeflateService) Get 

func (r *DeflateService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Deflate-encoded data

func (*DeflateService) Modify 

func (r *DeflateService) Modify(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Deflate-encoded data

func (*DeflateService) New 

func (r *DeflateService) New(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Deflate-encoded data

func (*DeflateService) Update 

func (r *DeflateService) Update(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns Deflate-encoded data

type DeletePerformParams 

type DeletePerformParams struct {
	// The body of the DELETE request
	Body map[string]any
	// contains filtered or unexported fields
}

func (DeletePerformParams) MarshalJSON 

func (r DeletePerformParams) MarshalJSON() (data []byte, err error)

func (*DeletePerformParams) UnmarshalJSON 

func (r *DeletePerformParams) UnmarshalJSON(data []byte) error

type DeletePerformResponse 

type DeletePerformResponse struct {
	Body    map[string]any    `json:"body,required"`
	Headers map[string]string `json:"headers,required"`
	Method  string            `json:"method,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Body        respjson.Field
		Headers     respjson.Field
		Method      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (DeletePerformResponse) RawJSON 

func (r DeletePerformResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeletePerformResponse) UnmarshalJSON 

func (r *DeletePerformResponse) UnmarshalJSON(data []byte) error

type DeleteService 

type DeleteService struct {
	Options []option.RequestOption
}

DeleteService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeleteService method instead.

func NewDeleteService 

func NewDeleteService(opts ...option.RequestOption) (r DeleteService)

NewDeleteService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeleteService) Perform 

func (r *DeleteService) Perform(ctx context.Context, body DeletePerformParams, opts ...option.RequestOption) (res *DeletePerformResponse, err error)

Handles a DELETE request and returns request information

type DenyService 

type DenyService struct {
	Options []option.RequestOption
}

DenyService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDenyService method instead.

func NewDenyService 

func NewDenyService(opts ...option.RequestOption) (r DenyService)

NewDenyService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DenyService) Delete 

func (r *DenyService) Delete(ctx context.Context, opts ...option.RequestOption) (err error)

Returns page denied by robots.txt rules

func (*DenyService) Get 

func (r *DenyService) Get(ctx context.Context, opts ...option.RequestOption) (err error)

Returns page denied by robots.txt rules

func (*DenyService) Modify 

func (r *DenyService) Modify(ctx context.Context, opts ...option.RequestOption) (err error)

Returns page denied by robots.txt rules

func (*DenyService) New 

func (r *DenyService) New(ctx context.Context, opts ...option.RequestOption) (err error)

Returns page denied by robots.txt rules

func (*DenyService) Update 

func (r *DenyService) Update(ctx context.Context, opts ...option.RequestOption) (err error)

Returns page denied by robots.txt rules

type DigestAuthGetParams 

type DigestAuthGetParams struct {
	Qop  string `path:"qop,required" json:"-"`
	User string `path:"user,required" json:"-"`
	// contains filtered or unexported fields
}

type DigestAuthGetWithAlgorithmParams 

type DigestAuthGetWithAlgorithmParams struct {
	Qop    string `path:"qop,required" json:"-"`
	User   string `path:"user,required" json:"-"`
	Passwd string `path:"passwd,required" json:"-"`
	// contains filtered or unexported fields
}

type DigestAuthGetWithAlgorithmStaleAfterParams 

type DigestAuthGetWithAlgorithmStaleAfterParams struct {
	Qop       string `path:"qop,required" json:"-"`
	User      string `path:"user,required" json:"-"`
	Passwd    string `path:"passwd,required" json:"-"`
	Algorithm string `path:"algorithm,required" json:"-"`
	// contains filtered or unexported fields
}

type DigestAuthService 

type DigestAuthService struct {
	Options []option.RequestOption
}

DigestAuthService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDigestAuthService method instead.

func NewDigestAuthService 

func NewDigestAuthService(opts ...option.RequestOption) (r DigestAuthService)

NewDigestAuthService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DigestAuthService) Get 

func (r *DigestAuthService) Get(ctx context.Context, passwd string, query DigestAuthGetParams, opts ...option.RequestOption) (err error)

HTTP Digest authentication. Mirrors httpbin behavior for testing clients.

func (*DigestAuthService) GetWithAlgorithm 

func (r *DigestAuthService) GetWithAlgorithm(ctx context.Context, algorithm string, query DigestAuthGetWithAlgorithmParams, opts ...option.RequestOption) (err error)

HTTP Digest authentication. Mirrors httpbin behavior for testing clients.

func (*DigestAuthService) GetWithAlgorithmStaleAfter 

func (r *DigestAuthService) GetWithAlgorithmStaleAfter(ctx context.Context, staleAfter string, query DigestAuthGetWithAlgorithmStaleAfterParams, opts ...option.RequestOption) (err error)

HTTP Digest authentication. Mirrors httpbin behavior for testing clients.

type Error 

type Error = apierror.Error

type EtagService 

type EtagService struct {
	Options []option.RequestOption
}

EtagService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEtagService method instead.

func NewEtagService 

func NewEtagService(opts ...option.RequestOption) (r EtagService)

NewEtagService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EtagService) Get 

func (r *EtagService) Get(ctx context.Context, etag string, opts ...option.RequestOption) (res *string, err error)

Handles ETag-based conditional requests.

type GetRequestInfoResponse 

type GetRequestInfoResponse struct {
	Headers     map[string]string `json:"headers,required"`
	Method      string            `json:"method,required"`
	QueryParams map[string]string `json:"queryParams,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Headers     respjson.Field
		Method      respjson.Field
		QueryParams respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GetRequestInfoResponse) RawJSON 

func (r GetRequestInfoResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*GetRequestInfoResponse) UnmarshalJSON 

func (r *GetRequestInfoResponse) UnmarshalJSON(data []byte) error

type GetService 

type GetService struct {
	Options []option.RequestOption
}

GetService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewGetService method instead.

func NewGetService 

func NewGetService(opts ...option.RequestOption) (r GetService)

NewGetService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*GetService) RequestInfo 

func (r *GetService) RequestInfo(ctx context.Context, opts ...option.RequestOption) (res *GetRequestInfoResponse, err error)

Returns request information for GET requests

type GzipService 

type GzipService struct {
	Options []option.RequestOption
}

GzipService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewGzipService method instead.

func NewGzipService 

func NewGzipService(opts ...option.RequestOption) (r GzipService)

NewGzipService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*GzipService) Delete 

func (r *GzipService) Delete(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns GZip-encoded data

func (*GzipService) Get 

func (r *GzipService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns GZip-encoded data

func (*GzipService) Modify 

func (r *GzipService) Modify(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns GZip-encoded data

func (*GzipService) New 

func (r *GzipService) New(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns GZip-encoded data

func (*GzipService) Update 

func (r *GzipService) Update(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns GZip-encoded data

type HTMLService 

type HTMLService struct {
	Options []option.RequestOption
}

HTMLService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewHTMLService method instead.

func NewHTMLService 

func NewHTMLService(opts ...option.RequestOption) (r HTMLService)

NewHTMLService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*HTMLService) Delete 

func (r *HTMLService) Delete(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random HTML content

func (*HTMLService) Get 

func (r *HTMLService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random HTML content

func (*HTMLService) Modify 

func (r *HTMLService) Modify(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random HTML content

func (*HTMLService) New 

func (r *HTMLService) New(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random HTML content

func (*HTMLService) Update 

func (r *HTMLService) Update(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random HTML content

type HeaderListResponse 

type HeaderListResponse struct {
	// All headers of the client request
	Headers map[string]string `json:"headers,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Headers     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (HeaderListResponse) RawJSON 

func (r HeaderListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*HeaderListResponse) UnmarshalJSON 

func (r *HeaderListResponse) UnmarshalJSON(data []byte) error

type HeaderService 

type HeaderService struct {
	Options []option.RequestOption
}

HeaderService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewHeaderService method instead.

func NewHeaderService 

func NewHeaderService(opts ...option.RequestOption) (r HeaderService)

NewHeaderService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*HeaderService) List 

func (r *HeaderService) List(ctx context.Context, opts ...option.RequestOption) (res *HeaderListResponse, err error)

Returns all headers of the client request

type IPGetResponse 

type IPGetResponse struct {
	// The IP address of the client
	IP string `json:"ip,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		IP          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (IPGetResponse) RawJSON 

func (r IPGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*IPGetResponse) UnmarshalJSON 

func (r *IPGetResponse) UnmarshalJSON(data []byte) error

type IPService 

type IPService struct {
	Options []option.RequestOption
}

IPService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewIPService method instead.

func NewIPService 

func NewIPService(opts ...option.RequestOption) (r IPService)

NewIPService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*IPService) Get 

func (r *IPService) Get(ctx context.Context, opts ...option.RequestOption) (res *IPGetResponse, err error)

Returns the IP address of the client

type JsonDeleteResponse 

type JsonDeleteResponse map[string]any

type JsonGetResponse 

type JsonGetResponse map[string]any

type JsonModifyResponse 

type JsonModifyResponse map[string]any

type JsonNewResponse 

type JsonNewResponse map[string]any

type JsonService 

type JsonService struct {
	Options []option.RequestOption
}

JsonService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewJsonService method instead.

func NewJsonService 

func NewJsonService(opts ...option.RequestOption) (r JsonService)

NewJsonService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*JsonService) Delete 

func (r *JsonService) Delete(ctx context.Context, opts ...option.RequestOption) (res *JsonDeleteResponse, err error)

Returns random JSON content

func (*JsonService) Get 

func (r *JsonService) Get(ctx context.Context, opts ...option.RequestOption) (res *JsonGetResponse, err error)

Returns random JSON content

func (*JsonService) Modify 

func (r *JsonService) Modify(ctx context.Context, opts ...option.RequestOption) (res *JsonModifyResponse, err error)

Returns random JSON content

func (*JsonService) New 

func (r *JsonService) New(ctx context.Context, opts ...option.RequestOption) (res *JsonNewResponse, err error)

Returns random JSON content

func (*JsonService) Update 

func (r *JsonService) Update(ctx context.Context, opts ...option.RequestOption) (res *JsonUpdateResponse, err error)

Returns random JSON content

type JsonUpdateResponse 

type JsonUpdateResponse map[string]any

type PatchHandleParams 

type PatchHandleParams struct {
	// The body of the PATCH request
	Body map[string]any
	// contains filtered or unexported fields
}

func (PatchHandleParams) MarshalJSON 

func (r PatchHandleParams) MarshalJSON() (data []byte, err error)

func (*PatchHandleParams) UnmarshalJSON 

func (r *PatchHandleParams) UnmarshalJSON(data []byte) error

type PatchHandleResponse 

type PatchHandleResponse struct {
	Body    map[string]any    `json:"body,required"`
	Headers map[string]string `json:"headers,required"`
	Method  string            `json:"method,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Body        respjson.Field
		Headers     respjson.Field
		Method      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PatchHandleResponse) RawJSON 

func (r PatchHandleResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PatchHandleResponse) UnmarshalJSON 

func (r *PatchHandleResponse) UnmarshalJSON(data []byte) error

type PatchService 

type PatchService struct {
	Options []option.RequestOption
}

PatchService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPatchService method instead.

func NewPatchService 

func NewPatchService(opts ...option.RequestOption) (r PatchService)

NewPatchService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PatchService) Handle 

func (r *PatchService) Handle(ctx context.Context, body PatchHandleParams, opts ...option.RequestOption) (res *PatchHandleResponse, err error)

Handles a PATCH request and returns request information

type PlainService 

type PlainService struct {
	Options []option.RequestOption
}

PlainService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPlainService method instead.

func NewPlainService 

func NewPlainService(opts ...option.RequestOption) (r PlainService)

NewPlainService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PlainService) Delete 

func (r *PlainService) Delete(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random plain text content

func (*PlainService) Get 

func (r *PlainService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random plain text content

func (*PlainService) Modify 

func (r *PlainService) Modify(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random plain text content

func (*PlainService) New 

func (r *PlainService) New(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random plain text content

func (*PlainService) Update 

func (r *PlainService) Update(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random plain text content

type PostNewParams 

type PostNewParams struct {
	// The body of the POST request
	Body map[string]any
	// contains filtered or unexported fields
}

func (PostNewParams) MarshalJSON 

func (r PostNewParams) MarshalJSON() (data []byte, err error)

func (*PostNewParams) UnmarshalJSON 

func (r *PostNewParams) UnmarshalJSON(data []byte) error

type PostNewResponse 

type PostNewResponse struct {
	Body    map[string]any    `json:"body,required"`
	Headers map[string]string `json:"headers,required"`
	Method  string            `json:"method,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Body        respjson.Field
		Headers     respjson.Field
		Method      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PostNewResponse) RawJSON 

func (r PostNewResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PostNewResponse) UnmarshalJSON 

func (r *PostNewResponse) UnmarshalJSON(data []byte) error

type PostService 

type PostService struct {
	Options []option.RequestOption
}

PostService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPostService method instead.

func NewPostService 

func NewPostService(opts ...option.RequestOption) (r PostService)

NewPostService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PostService) New 

func (r *PostService) New(ctx context.Context, body PostNewParams, opts ...option.RequestOption) (res *PostNewResponse, err error)

Handles a POST request and returns request information

type PutHandleParams 

type PutHandleParams struct {
	// The body of the PUT request
	Body map[string]any
	// contains filtered or unexported fields
}

func (PutHandleParams) MarshalJSON 

func (r PutHandleParams) MarshalJSON() (data []byte, err error)

func (*PutHandleParams) UnmarshalJSON 

func (r *PutHandleParams) UnmarshalJSON(data []byte) error

type PutHandleResponse 

type PutHandleResponse struct {
	Body    map[string]any    `json:"body,required"`
	Headers map[string]string `json:"headers,required"`
	Method  string            `json:"method,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Body        respjson.Field
		Headers     respjson.Field
		Method      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PutHandleResponse) RawJSON 

func (r PutHandleResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PutHandleResponse) UnmarshalJSON 

func (r *PutHandleResponse) UnmarshalJSON(data []byte) error

type PutService 

type PutService struct {
	Options []option.RequestOption
}

PutService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPutService method instead.

func NewPutService 

func NewPutService(opts ...option.RequestOption) (r PutService)

NewPutService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PutService) Handle 

func (r *PutService) Handle(ctx context.Context, body PutHandleParams, opts ...option.RequestOption) (res *PutHandleResponse, err error)

Handles a PUT request and returns request information

type RedirectToDeleteParams 

type RedirectToDeleteParams struct {
	// The URL to redirect to
	URL string `query:"url,required" format:"uri" json:"-"`
	// The HTTP status code to use for redirection
	StatusCode param.Opt[string] `query:"status_code,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (RedirectToDeleteParams) URLQuery 

func (r RedirectToDeleteParams) URLQuery() (v url.Values, err error)

URLQuery serializes RedirectToDeleteParams's query parameters as `url.Values`.

type RedirectToGetParams 

type RedirectToGetParams struct {
	// The URL to redirect to
	URL string `query:"url,required" format:"uri" json:"-"`
	// The HTTP status code to use for redirection
	StatusCode param.Opt[string] `query:"status_code,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (RedirectToGetParams) URLQuery 

func (r RedirectToGetParams) URLQuery() (v url.Values, err error)

URLQuery serializes RedirectToGetParams's query parameters as `url.Values`.

type RedirectToModifyParams 

type RedirectToModifyParams struct {
	// The URL to redirect to
	URL string `query:"url,required" format:"uri" json:"-"`
	// The HTTP status code to use for redirection
	StatusCode param.Opt[string] `query:"status_code,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (RedirectToModifyParams) URLQuery 

func (r RedirectToModifyParams) URLQuery() (v url.Values, err error)

URLQuery serializes RedirectToModifyParams's query parameters as `url.Values`.

type RedirectToNewParams 

type RedirectToNewParams struct {
	// The URL to redirect to
	URL string `query:"url,required" format:"uri" json:"-"`
	// The HTTP status code to use for redirection
	StatusCode param.Opt[string] `query:"status_code,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (RedirectToNewParams) URLQuery 

func (r RedirectToNewParams) URLQuery() (v url.Values, err error)

URLQuery serializes RedirectToNewParams's query parameters as `url.Values`.

type RedirectToService 

type RedirectToService struct {
	Options []option.RequestOption
}

RedirectToService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRedirectToService method instead.

func NewRedirectToService 

func NewRedirectToService(opts ...option.RequestOption) (r RedirectToService)

NewRedirectToService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RedirectToService) Delete 

func (r *RedirectToService) Delete(ctx context.Context, body RedirectToDeleteParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL

func (*RedirectToService) Get 

func (r *RedirectToService) Get(ctx context.Context, query RedirectToGetParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL

func (*RedirectToService) Modify 

func (r *RedirectToService) Modify(ctx context.Context, body RedirectToModifyParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL

func (*RedirectToService) New 

func (r *RedirectToService) New(ctx context.Context, body RedirectToNewParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL

func (*RedirectToService) Update 

func (r *RedirectToService) Update(ctx context.Context, body RedirectToUpdateParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL

type RedirectToUpdateParams 

type RedirectToUpdateParams struct {
	// The URL to redirect to
	URL string `query:"url,required" format:"uri" json:"-"`
	// The HTTP status code to use for redirection
	StatusCode param.Opt[string] `query:"status_code,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (RedirectToUpdateParams) URLQuery 

func (r RedirectToUpdateParams) URLQuery() (v url.Values, err error)

URLQuery serializes RedirectToUpdateParams's query parameters as `url.Values`.

type RelativeRedirectGetParams 

type RelativeRedirectGetParams struct {
	Host string `header:"host,required" json:"-"`
	// contains filtered or unexported fields
}

type RelativeRedirectService 

type RelativeRedirectService struct {
	Options []option.RequestOption
}

RelativeRedirectService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRelativeRedirectService method instead.

func NewRelativeRedirectService 

func NewRelativeRedirectService(opts ...option.RequestOption) (r RelativeRedirectService)

NewRelativeRedirectService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RelativeRedirectService) Get 

func (r *RelativeRedirectService) Get(ctx context.Context, value int64, query RelativeRedirectGetParams, opts ...option.RequestOption) (err error)

Redirects the request to the target URL using an relative URL

type ResponseHeaderGetParams 

type ResponseHeaderGetParams struct {
	// Enable additional properties
	AdditionalProperties param.Opt[bool] `query:"additionalProperties,omitzero" json:"-"`
	// Freeform query string parameters to be added as response headers
	Description param.Opt[string] `query:"description,omitzero" json:"-"`
	// Type parameter for response headers
	Type param.Opt[string] `query:"type,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ResponseHeaderGetParams) URLQuery 

func (r ResponseHeaderGetParams) URLQuery() (v url.Values, err error)

URLQuery serializes ResponseHeaderGetParams's query parameters as `url.Values`.

type ResponseHeaderGetResponse 

type ResponseHeaderGetResponse map[string]any

type ResponseHeaderNewParams 

type ResponseHeaderNewParams struct {
	// Enable additional properties
	AdditionalProperties param.Opt[bool] `query:"additionalProperties,omitzero" json:"-"`
	// Freeform query string parameters to be added as response headers
	Description param.Opt[string] `query:"description,omitzero" json:"-"`
	// Type parameter for response headers
	Type param.Opt[string] `query:"type,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ResponseHeaderNewParams) URLQuery 

func (r ResponseHeaderNewParams) URLQuery() (v url.Values, err error)

URLQuery serializes ResponseHeaderNewParams's query parameters as `url.Values`.

type ResponseHeaderNewResponse 

type ResponseHeaderNewResponse map[string]any

type ResponseHeaderService 

type ResponseHeaderService struct {
	Options []option.RequestOption
}

ResponseHeaderService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewResponseHeaderService method instead.

func NewResponseHeaderService 

func NewResponseHeaderService(opts ...option.RequestOption) (r ResponseHeaderService)

NewResponseHeaderService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ResponseHeaderService) Get 

func (r *ResponseHeaderService) Get(ctx context.Context, query ResponseHeaderGetParams, opts ...option.RequestOption) (res *ResponseHeaderGetResponse, err error)

Returns a set of response headers based on the query string.

func (*ResponseHeaderService) New 

func (r *ResponseHeaderService) New(ctx context.Context, body ResponseHeaderNewParams, opts ...option.RequestOption) (res *ResponseHeaderNewResponse, err error)

Returns a set of response headers based on the query string.

type StatusDeleteResponse 

type StatusDeleteResponse struct {
	Status string `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StatusDeleteResponse) RawJSON 

func (r StatusDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*StatusDeleteResponse) UnmarshalJSON 

func (r *StatusDeleteResponse) UnmarshalJSON(data []byte) error

type StatusGetResponse 

type StatusGetResponse struct {
	Status string `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StatusGetResponse) RawJSON 

func (r StatusGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*StatusGetResponse) UnmarshalJSON 

func (r *StatusGetResponse) UnmarshalJSON(data []byte) error

type StatusNewResponse 

type StatusNewResponse struct {
	Status string `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StatusNewResponse) RawJSON 

func (r StatusNewResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*StatusNewResponse) UnmarshalJSON 

func (r *StatusNewResponse) UnmarshalJSON(data []byte) error

type StatusPatchResponse 

type StatusPatchResponse struct {
	Status string `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StatusPatchResponse) RawJSON 

func (r StatusPatchResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*StatusPatchResponse) UnmarshalJSON 

func (r *StatusPatchResponse) UnmarshalJSON(data []byte) error

type StatusService 

type StatusService struct {
	Options []option.RequestOption
}

StatusService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewStatusService method instead.

func NewStatusService 

func NewStatusService(opts ...option.RequestOption) (r StatusService)

NewStatusService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*StatusService) Delete 

func (r *StatusService) Delete(ctx context.Context, code string, opts ...option.RequestOption) (res *StatusDeleteResponse, err error)

Return status code or random status code if more than one are given

func (*StatusService) Get 

func (r *StatusService) Get(ctx context.Context, code string, opts ...option.RequestOption) (res *StatusGetResponse, err error)

Return status code or random status code if more than one are given

func (*StatusService) New 

func (r *StatusService) New(ctx context.Context, code string, opts ...option.RequestOption) (res *StatusNewResponse, err error)

Return status code or random status code if more than one are given

func (*StatusService) Patch 

func (r *StatusService) Patch(ctx context.Context, code string, opts ...option.RequestOption) (res *StatusPatchResponse, err error)

Return status code or random status code if more than one are given

func (*StatusService) Update 

func (r *StatusService) Update(ctx context.Context, code string, opts ...option.RequestOption) (res *StatusUpdateResponse, err error)

Return status code or random status code if more than one are given

type StatusUpdateResponse 

type StatusUpdateResponse struct {
	Status string `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StatusUpdateResponse) RawJSON 

func (r StatusUpdateResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*StatusUpdateResponse) UnmarshalJSON 

func (r *StatusUpdateResponse) UnmarshalJSON(data []byte) error

type TextService 

type TextService struct {
	Options []option.RequestOption
}

TextService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTextService method instead.

func NewTextService 

func NewTextService(opts ...option.RequestOption) (r TextService)

NewTextService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TextService) DeleteRandom 

func (r *TextService) DeleteRandom(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random text content

func (*TextService) GetRandom 

func (r *TextService) GetRandom(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random text content

func (*TextService) ModifyRandom 

func (r *TextService) ModifyRandom(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random text content

func (*TextService) NewRandom 

func (r *TextService) NewRandom(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random text content

func (*TextService) UpdateRandom 

func (r *TextService) UpdateRandom(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random text content

type UserAgentGetResponse 

type UserAgentGetResponse struct {
	// The User-Agent header of the client request
	UserAgent string `json:"userAgent,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		UserAgent   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (UserAgentGetResponse) RawJSON 

func (r UserAgentGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*UserAgentGetResponse) UnmarshalJSON 

func (r *UserAgentGetResponse) UnmarshalJSON(data []byte) error

type UserAgentService 

type UserAgentService struct {
	Options []option.RequestOption
}

UserAgentService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewUserAgentService method instead.

func NewUserAgentService 

func NewUserAgentService(opts ...option.RequestOption) (r UserAgentService)

NewUserAgentService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*UserAgentService) Get 

func (r *UserAgentService) Get(ctx context.Context, opts ...option.RequestOption) (res *UserAgentGetResponse, err error)

Returns the User-Agent header of the client request

type XmlService 

type XmlService struct {
	Options []option.RequestOption
}

XmlService contains methods and other services that help with interacting with the mockhttp API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewXmlService method instead.

func NewXmlService 

func NewXmlService(opts ...option.RequestOption) (r XmlService)

NewXmlService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*XmlService) Delete 

func (r *XmlService) Delete(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random XML content

func (*XmlService) Get 

func (r *XmlService) Get(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random XML content

func (*XmlService) Modify 

func (r *XmlService) Modify(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random XML content

func (*XmlService) New 

func (r *XmlService) New(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random XML content

func (*XmlService) Update 

func (r *XmlService) Update(ctx context.Context, opts ...option.RequestOption) (res *string, err error)

Returns random XML content

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
encoding/json
Package json implements encoding and decoding of JSON as defined in RFC 7159.
 Package json implements encoding and decoding of JSON as defined in RFC 7159.
encoding/json/sentinel
encoding/json/shims
This package provides shims over Go 1.2{2,3} APIs which are missing from Go 1.22, and used by the Go 1.24 encoding/json package.
 This package provides shims over Go 1.2{2,3} APIs which are missing from Go 1.22, and used by the Go 1.24 encoding/json package.
paramutil
requestconfig
testutil
packages
param
respjson
shared
constant

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.