mocker

Documentation

Index

• func GenerateRoutes(path string, r *gin.Engine) error
• type All
• type DeleteEndpoint
  • func (e DeleteEndpoint) Generate(path string, r *gin.Engine)
• type Endpoint
  • func (e *Endpoint) Compute()
• type EndpointGenerator
• type GetEndpoint
  • func (e GetEndpoint) Generate(path string, r *gin.Engine)
• type HeadEndpoint
  • func (e HeadEndpoint) Generate(path string, r *gin.Engine)
• type Header
• type MethodEndpoint
  • func (e *MethodEndpoint) CalcRatios()
  • func (e MethodEndpoint) Info(last bool) string
  • func (e MethodEndpoint) PickResponse() *Response
  • func (e MethodEndpoint) ToHandler() func(c *gin.Context)
• type OptionsEndpoint
  • func (e OptionsEndpoint) Generate(path string, r *gin.Engine)
• type PatchEndpoint
  • func (e PatchEndpoint) Generate(path string, r *gin.Engine)
• type PostEndpoint
  • func (e PostEndpoint) Generate(path string, r *gin.Engine)
• type PutEndpoint
  • func (e PutEndpoint) Generate(path string, r *gin.Engine)
• type Response
  • func (r Response) Info(prefix string, last bool) string

Functions

func GenerateRoutes

func GenerateRoutes(path string, r *gin.Engine) error

GenerateRoutes generates the routes and applies them to the r gin.Engine

Types

type All

type All struct {
	Endpoints []Endpoint `yaml:"endpoints"`
}

All stores all the information of the configuration file

type DeleteEndpoint

type DeleteEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

DeleteEndpoint implements the EndpointGenerator interface

func (DeleteEndpoint) Generate

func (e DeleteEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type Endpoint

type Endpoint struct {
	Path    string           `yaml:"path"`
	Get     *GetEndpoint     `yaml:"get"`
	Post    *PostEndpoint    `yaml:"post"`
	Put     *PutEndpoint     `yaml:"put"`
	Patch   *PatchEndpoint   `yaml:"patch"`
	Delete  *DeleteEndpoint  `yaml:"delete"`
	Head    *HeadEndpoint    `yaml:"head"`
	Options *OptionsEndpoint `yaml:"options"`

	All []EndpointGenerator `yaml:"-"`
}

Endpoint is a simple endpoint struct used to parse the configuration file

func (*Endpoint) Compute

func (e *Endpoint) Compute()

Compute checks every possible endpoint to generate a slice of EndpointGenerator

type EndpointGenerator

type EndpointGenerator interface {
	Generate(string, *gin.Engine)
}

EndpointGenerator is an interface that allows to generate endpoints

type GetEndpoint

type GetEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

GetEndpoint implements the EndpointGenerator interface

func (GetEndpoint) Generate

func (e GetEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type HeadEndpoint

type HeadEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

HeadEndpoint implements the EndpointGenerator interface

func (HeadEndpoint) Generate

func (e HeadEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type Header

type Header struct {
	Name  string `yaml:"name"`
	Value string `yaml:"value"`
}

Header is a simple header struct used to parse the configuration file

type MethodEndpoint

type MethodEndpoint struct {
	Preset    string      `yaml:"preset"` // random, ratio
	Responses []*Response `yaml:"responses"`
	Headers   []string    `yaml:"headers"`
}

MethodEndpoint represents a single endpoint

func (*MethodEndpoint) CalcRatios

func (e *MethodEndpoint) CalcRatios()

CalcRatios computes the ratios for every response that doesn't have one

func (MethodEndpoint) Info

func (e MethodEndpoint) Info(last bool) string

Info returns the string representing the info

func (MethodEndpoint) PickResponse

func (e MethodEndpoint) PickResponse() *Response

PickResponse picks a random response according to the ratio defined in the responses

func (MethodEndpoint) ToHandler

func (e MethodEndpoint) ToHandler() func(c *gin.Context)

ToHandler generates a handler to apply on the router

type OptionsEndpoint

type OptionsEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

OptionsEndpoint implements the EndpointGenerator interface

func (OptionsEndpoint) Generate

func (e OptionsEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type PatchEndpoint

type PatchEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

PatchEndpoint implements the EndpointGenerator interface

func (PatchEndpoint) Generate

func (e PatchEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type PostEndpoint

type PostEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

PostEndpoint implements the EndpointGenerator interface

func (PostEndpoint) Generate

func (e PostEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type PutEndpoint

type PutEndpoint struct {
	MethodEndpoint `yaml:",inline"`
}

PutEndpoint implements the EndpointGenerator interface

func (PutEndpoint) Generate

func (e PutEndpoint) Generate(path string, r *gin.Engine)

Generate generates the endpoint

type Response

type Response struct {
	Code    int      `yaml:"code"`
	Body    string   `yaml:"body"`
	Headers []Header `yaml:"headers"`
	Preset  string   `yaml:"preset"`
	Ratio   int      `yaml:"ratio"`
}

Response is a simple response struct used to parse the configuration file

func (Response) Info

func (r Response) Info(prefix string, last bool) string

Info returns a string to print out the information of a response