dsl

type Bindings subst.Bindings

type Broken struct {
	Err error
}

type Chan interface {
	// Open starts up the Chan.
	Open(ctx *Ctx) error

	// Chose shuts down this Chan.
	Close(ctx *Ctx) error

	// Kill ungracefully closes an underlying connection (if any).
	//
	// Useful for testing MQTT LWT.
	Kill(ctx *Ctx) error

	// Kind returns this Chan's type.
	Kind() ChanKind

	// Sub, when required, initials a subscription.
	//
	// Use the Recv method to obtain messages that arrive via any
	// subscription.
	Sub(ctx *Ctx, topic string) error

	// Recv returns a channel of messages.
	Recv(ctx *Ctx) chan Msg

	// Pub, when supported, publishes a message on this Chan.
	Pub(ctx *Ctx, m Msg) error

	// To is a utility to send a message to the channel returned
	// by Recv.
	To(ctx *Ctx, m Msg) error

	DocSpec() *DocSpec
}

type ChanKind string

type ChanMaker func(ctx *Ctx, def interface{}) (Chan, error)

type ChanOpts interface{}

type ChanRegistry map[ChanKind]ChanMaker

type Close struct {
	Chan string
	// contains filtered or unexported fields
}

type Ctx struct {
	context.Context
	Logger
	IncludeDirs []string
	Dir         string
	LogLevel    string

	*Redactions
}

type DocSpec struct {
	SrcDirs []string

	Chan    Chan
	Doc     string
	OptsDoc string
	Opts    interface{}

	InputDoc string
	Input    interface{}

	OutputDoc string
	Output    interface{}
}

type Errors struct {
	InitErr     error
	Err         error
	FinalErrors map[string]error
}

type Exec struct {
	Process
	Pattern interface{}
}

type Failure struct {
	Err error
}

type GoLogger struct {
}

type Ingest struct {
	Chan    string
	Topic   string
	Payload interface{}
	// contains filtered or unexported fields
}

type Kill struct {
	Chan string
	// contains filtered or unexported fields
}

type Logger interface {
	Printf(format string, args ...interface{})
}

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

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

type MotherMakeRequest struct {
	// Name is the requested name for the channel to be created.
	Name string `json:"name"`

	// Type is something like 'mqtt', 'httpclient', or 'sqs' (the
	// types that are registered with a (or The) ChannelRegistry).
	Type ChanKind `json:"type"`

	// Config is the configuration (if any) for the requested channel.
	Config interface{} `json:"config,omitempty"`
}

type MotherRequest struct {
	Make *MotherMakeRequest `json:"make"`
}

type MotherResponse struct {
	// Request is the request the provoked this response.
	Request *MotherRequest `json:"request"`

	// Success reports whether the request succeeded.
	Success bool `json:"success"`

	// Error, if not zero, is an error message for a failed
	// request.
	Error string `json:"error,omitempty"`
}

type Msg struct {
	Topic      string    `json:"topic"`
	Payload    string    `json:"payload"`
	ReceivedAt time.Time `json:"receivedAt"`
}

type Phase struct {
	// Doc is an optional documentation string.
	Doc string `yaml:",omitempty"`

	// Steps is a sequence of Steps, which are attempted in order.
	//
	// Each Step is subject to bindings substitution.
	Steps []*Step
}

type Process struct {
	// Name is an opaque string used is reports about this
	// Process.
	Name string `json:"name" yaml:"name"`

	// Command is the name of the program.
	//
	// Subject to expansion.
	Command string `json:"command" yaml:"command"`

	// Args is the list of command-line arguments for the program.
	//
	// Subject to expansion.
	Args []string `json:"args" yaml:"args"`

	Stdout   chan string `json:"-"`
	Stderr   chan string `json:"-"`
	Stdin    chan string `json:"-"`
	ExitCode chan int    `json:"-"`
	// contains filtered or unexported fields
}

type Pub struct {
	Chan  string
	Topic string

	// Schema is an optional URI for a JSON Schema that's used to
	// validate outgoing messages.
	Schema string `json:",omitempty" yaml:",omitempty"`

	Payload interface{}

	// Serialization specifies how a string Payload should be
	// deserialized (if at all).
	//
	// Legal values: 'json', 'text'.  Default is 'json'.
	//
	// If given a non-string, that value is always used as is.
	//
	// If given a string, if serialization is 'json' or not
	// specified, then the string is parsed as JSON.  If the
	// serialization is 'text', then the string is used as is.
	Serialization string `json:",omitempty" yaml:",omitempty"`

	Run string `json:",omitempty" yaml:",omitempty"`
	// contains filtered or unexported fields
}

type Reconnect struct {
	Chan string
	// contains filtered or unexported fields
}

type Recv struct {
	Chan  string
	Topic string

	// Pattern is a Sheens pattern
	// https://github.com/Comcast/sheens/blob/main/README.md#pattern-matching
	// for matching incoming messages.
	//
	// Use a pattern for matching JSON-serialized messages.
	//
	// Also see Regexp.
	Pattern interface{}

	// Regexp, which is an alternative to Pattern, gives a (Go)
	// regular expression used to match incoming messages.
	//
	// A named group match becomes a bound variable.
	Regexp string

	Timeout time.Duration

	// Target is an optional switch to specify what part of the
	// incoming message is considered for matching.
	//
	// By default, only the payload is matched.  If Target is
	// "message", then matching is performed against
	//
	//   {"Topic":TOPIC,"Payload":PAYLOAD}
	//
	// which allows matching based on the topic of in-bound
	// messages.
	Target string

	// ClearBindings will remove all bindings for variables that
	// do not start with '?!' before executing this step.
	ClearBindings bool

	// Guard is optional Javascript (!) that should return a
	// boolean to indicate whether this Recv has been satisfied.
	//
	// The code is executed in a function body, and the code
	// should 'return' a boolean.
	//
	// The following variables are bound in the global
	// environment:
	//
	//   bindingss: the set (array) of bindings returned by match()
	//
	//   elapsed: the elapsed time in milliseconds since the last step
	//
	//   msg: the receved message ({"topic":TOPIC,"payload":PAYLOAD})
	//
	//   print: a function that prints its arguments to stdout.
	//
	Guard string `json:",omitempty" yaml:",omitempty"`

	Run string `json:",omitempty" yaml:",omitempty"`

	// Schema is an optional URI for a JSON Schema that's used to
	// validate incoming messages before other processing.
	Schema string `json:",omitempty" yaml:",omitempty"`

	// Max attempts to receive a message; optionally for a specific topic
	Attempts int `json:",omitempty" yaml:",omitempty`
	// contains filtered or unexported fields
}

type Redactions struct {
	// Redact enables or disables redactions.
	//
	// The sketchy field name is for backwards compatibility.
	Redact bool

	// Pattens maps strings representing regular expressions to
	// Repexps.
	Patterns map[string]*regexp.Regexp

	// RWMutex makes this gear safe for concurrent use.
	sync.RWMutex
}

type Retries struct {
	// N is the maximum number of retries.
	N int

	// Delay is the initial delay before the first retry.
	Delay time.Duration

	// DelayFactor is multiplied by the last delay to return the
	// next delay.
	DelayFactor float64
}

type Serialization string

type Spec struct {
	// InitialPhase is the starting phase, which defaults to
	// DefaultInitialPhase.
	InitialPhase string

	// FinalPhases is an option list of phases to execute after
	// the execution starting at InitialPhase terminates.
	FinalPhases []string

	// Phases maps phase names to Phases.
	//
	// Each Phase is subject to bindings substitution.
	Phases map[string]*Phase
}

type Step struct {
	// Doc is an optional documentation string.
	Doc string `yaml:",omitempty"`

	// Fails indicates that this Step is expected to fail, which
	// currently means returning an error from exec.
	Fails bool `yaml:",omitempty"`

	// Skip will make the test execution skip this step.
	Skip bool `yaml:",omitempty"`

	Pub       *Pub       `yaml:",omitempty"`
	Sub       *Sub       `yaml:",omitempty"`
	Recv      *Recv      `yaml:",omitempty"`
	Kill      *Kill      `yaml:",omitempty"`
	Reconnect *Reconnect `yaml:",omitempty"`
	Close     *Close     `yaml:",omitempty"`
	Run       string     `yaml:",omitempty"`

	// Wait is wait time in milliseconds as a string.
	Wait string `yaml:",omitempty"`

	Goto string `yaml:",omitempty"`

	Branch string `yaml:",omitempty"`

	Ingest *Ingest `yaml:",omitempty"`
}

type Sub struct {
	Chan  string
	Topic string

	// Pattern, which is deprecated, is really 'Topic'.
	Pattern string
	// contains filtered or unexported fields
}

type Test struct {
	// Id usually comes from the filename that defines the test.
	Id string `json:",omitempty" yaml:",omitempty"`

	// Name is the test specification name
	Name string `json:",omitempty" yaml:",omitempty"`

	// Doc is an optional documentation string.
	Doc string `json:",omitempty" yaml:",omitempty"`

	// Labels is an optional set of labels (e.g., "cpe", "app").
	Labels []string `json:",omitempty" yaml:",omitempty"`

	// Priority 0 is the highest priority.
	Priority int

	// Spec is the test specification.
	//
	// Parts of the Spec are subject to bindings substitution.
	Spec *Spec

	// State is arbitrary state the Javascript code can use.
	State map[string]interface{}

	// Bindings is the first set of bindings returned by the last
	// pattern match (if any).
	Bindings Bindings

	// Chans is the map of Chan names to Chans.
	Chans map[string]Chan

	// T is the time the last Step executed.
	T time.Time

	// Optional seed for random number generator.
	//
	// Effectively defaults to the current time in UNIX
	// nanoseconds
	Seed int64

	// MaxSteps, when not zero, is the maximum number of steps to
	// execute.
	//
	// Can act as a circuit breaker for infinite loops due to
	// branches.
	MaxSteps int

	// Libraries is a list of filenames that should contain
	// Javascript.  This source is loaded into each Javascript
	// environment.
	//
	// Warning: These files are loaded for each Javascript
	// invocation (because re-using the Javascript environment is
	// not a safe thing to do -- and I don't think I can "seal"
	// one environment and extend it per-invocation).
	Libraries []string

	// Negative indicates that a reported failure (but not error)
	// should be interpreted as a success.
	Negative bool

	// Dir is the base directory for reading relative pathnames
	// (for libraries, includes, and ##FILENAMEs).
	Dir string

	// Retries is an optional retry specification.
	//
	// This data isn't actually used in the code here.  Instead,
	// this data is here to make it easy for a test to specify its
	// own retry policy (if any).  Actual implementation provided
	// by invoke.Run().
	Retries *Retries

	// Registry is the channel (type) registry for this test.
	//
	// Defaults to TheChanRegistry.
	Registry ChanRegistry
	// contains filtered or unexported fields
}