cfg

type Config ¶

type Config struct {
	Defs []*MatchDef            `json:"pattern_list" yaml:"pattern_list"`
	Vars map[string]interface{} `json:"vars" yaml:"vars"`
}

Config represents an imPOSTer configuration. A set of rule expressions can be defined dy Defs field.

func ReadConfig(configFile string) (*Config, error)

type MatchDef ¶

type MatchDef struct {
	RuleExpression string        `json:"rule_expression" yaml:"rule_expression"`
	Latency        time.Duration `json:"latency" yaml:"latency"`
	Response       interface{}   `json:"response" yaml:"response"`
}

MatchDef represents a single rule expression. The RuleExpression field wraps a boolean expression every incoming HTTP request is matched against. How a matching rule expression should be managed is defined by the Response object.

func (def *MatchDef) Validate(parse functions.ExpressionParser, vars map[string]interface{}) []string

type MatchRsp ¶

type MatchRsp struct {
	Body       string                 `mapstructure:"body"`
	Headers    map[string]interface{} `mapstructure:"headers"`
	StatusCode string                 `mapstructure:"status_code"`
}

MatchRsp is the fully structured version of a Response object. Body represents the payload to be returned and it can be an expression as well. Headers is a collection of HTTP headers to be returned and each entry can be an expression. StatusCode represents the resulting HTTP status code and it MUST be an expression:

rsp := MatchRsp{Body: "some content", StatusCode: `${200}`}

func (rsp *MatchRsp) ParseHeaders(parse functions.ExpressionParser) (map[string]functions.Expression, error)

func (rsp *MatchRsp) ParseStatusCode(parse functions.ExpressionParser) (functions.Expression, error)