testhelper

type CompareFunc func(*testing.T, string, interface{}, interface{}) error

type Comparer struct {
	Value        interface{}
	Accessor     string
	Compare      CompareFunc
	DefaultValue bool
}

type ExtraConfig struct {
	*greenery.BaseConfig

	Bool bool `greenery:"bool|bool|,    bool.bool, BOOL"`

	NameValue []ExtraConfigCustomNameValue `greenery:"||custom,  custom.namevalue,"`
	NameEnum  []ExtraConfigCustomNameEnum  `greenery:"||custom,  custom.nameenum,"`

	FlagIP      *greenery.IPValue           `greenery:"flag|ip|,      flag.ip,      FLAGIP"`
	FlagPort    greenery.PortValue          `greenery:"flag|port|,    flag.port,    FLAGPORT"`
	FlagEnum    *greenery.EnumValue         `greenery:"flag|enum|,    flag.enum,    FLAGENUM"`
	FlagInt     *greenery.IntValue          `greenery:"flag|int|,     flag.int,     FLAGINT"`
	FlagCString *greenery.CustomStringValue `greenery:"flag|cstring|, flag.cstring, FLAGCSTRING"`

	Float32 float32 `greenery:"float|float32|,        float.float32,     FLOAT32"`
	Float64 float64 `greenery:"float|float64|,        float.float64,     FLOAT64"`

	Int      int           `greenery:"int|int|,          int.int,       INT"`
	Int8     int8          `greenery:"int|int8|,         int.int8,      INT8"`
	Int16    int16         `greenery:"int|int16|,        int.int16,     INT16"`
	Int32    int32         `greenery:"int|int32|,        int.int32,     INT32"`
	Int64    int64         `greenery:"int|int64|,        int.int64,     INT64"`
	Uint     uint          `greenery:"int|uint|,         int.uint,      UINT"`
	Uint8    uint8         `greenery:"int|uint8|,        int.uint8,     UINT8"`
	Uint16   uint16        `greenery:"int|uint16|,       int.uint16,    UINT16"`
	Uint32   uint32        `greenery:"int|uint32|,       int.uint32,    UINT32"`
	Uint64   uint64        `greenery:"int|uint64|,       int.uint64,    UINT64"`
	Time     time.Time     `greenery:"||none,            int.time,      TIME"`
	PTime    *time.Time    `greenery:"||none,            int.ptime,     PTIME"`
	Duration time.Duration `greenery:"||none,            int.duration,  DURATION"`

	String string `greenery:"string|string|,    string.string, STRING"`

	SliceString []string `greenery:"||none,    slice.string, "`
	SliceInt    []int    `greenery:"||none,    slice.int, "`
	// contains filtered or unexported fields
}

type ExtraConfigCustomNameEnum struct {
	Name string
	Enum *greenery.EnumValue
}

type ExtraConfigCustomNameValue struct {
	Name  string
	Value string
}

type LogLine struct {
	Level       string
	Msg         string
	MsgRegex    string
	Custom      map[string]interface{}
	CustomRegex map[string]string
}

type SimpleConfig struct {
	*greenery.BaseConfig
}

type TestCase struct {
	// Name contains the name of the test, will be used as t.Run()'s name
	Name string

	// Env is a map of strings containing the environment for this test case
	Env map[string]string

	// CmdLine is the command line passed to our executable
	CmdLine []string

	// CfgContents is a string containing the configuration file contents for
	// this test
	CfgContents string

	// ExecError is the expected exec function error (if any) this will be
	// matched as a substring
	ExecError string

	// ExecErrorRegex is the expected exec function error (if any) this will be
	// matched as a regex
	ExecErrorRegex string

	// ExecErrorOutput will cause the output of the program (stdout/err/logs)
	// to be checked even if the execution had an error
	ExecErrorOutput bool

	// ExpectedValues is a map of interface{} containing the values that are
	// to be expected to be set in the config object after the environment,
	// command line and configuration file are taken into account. Any config
	// object fields not included here will be validated to remain their
	// default value as set by the config generator function. This will be
	// ignored if Validate is set
	ExpectedValues map[string]Comparer

	// ValuesValidator contains a custom validation function, which will be used
	// instead of the internal configuration values validation. It will be
	// passed the configuration, it is expected to fail the test itself if the
	// validation is unsuccessful.
	ValuesValidator func(*testing.T, greenery.Config)

	// Trace is used to output trace log messages, trace is an undocumented
	// log level used primarily during development.
	Trace bool

	// CmdlineCfgName contains a name to be passed as the config file name to
	// the test, it is typically used to validate a non-existent configuration
	// file, because configuration files are passed via CfgContents
	CmdlineCfgName string

	// ConfigGen is the function that will return the configuration struct to
	// be used
	ConfigGen func() greenery.Config

	// OverrideHandlerMap will enable overriding of the test handler map via
	// HandlerMap
	OverrideHandlerMap bool

	// HandlerMap is a map of handlers, that will be used on the passed in
	// configuration.
	HandlerMap map[string]greenery.Handler

	// OverrideBuiltinHandlers will enable overriding the test default
	// handlers for the configuration
	OverrideBuiltinHandlers bool

	// BuiltinHandlers is a map of override builtin handlers, that will be
	// used on the passed in configuration. Note the key of the map is a
	// string, not an OverrideHandler type to allow arbitrary test overrides.
	BuiltinHandlers map[string]greenery.Handler

	// OverrideUserDocList allows overriding of the test user doc list
	OverrideUserDocList bool

	// UserDocList is a map with the application user documents, if the map
	// contains a "" key, that will be meant to indicate the default language
	// docset.
	UserDocList map[string]*greenery.DocSet
	CfgFile     string

	// GoldStdOut contains the gold expected standard output for this test case
	GoldStdOut *TestFile

	// GoldStdErr contains the gold expected standard error for this test case
	GoldStdErr *TestFile

	// GoldStdOut contains the gold expected logfile for this test case
	GoldLog string

	// NoValidateConfigValues if set will cause the test to not look at the
	// configuration values
	NoValidateConfigValues bool

	// ConfigDefaults allows specifying config defaults via SetOptions on a
	// per-testcase basis
	ConfigDefaults *greenery.BaseConfigOptions

	// GoldFiles is a list of expected gold files
	GoldFiles []TestFile

	// PrecreateFiles is a list of files to be created in the test environment
	// before executing the test
	PrecreateFiles []TestFile

	// RealFilesystem controls whether the test executes on the filesystem or
	// on an in-memory cache
	RealFilesystem bool

	// RemoveFiles contains a list of files to be removed after the test
	// execution
	RemoveFiles []string

	// CustomVars is a list of expected custom variables in the config file
	CustomVars []string

	// CustomParser contains a custom parser to be used for custom variables
	CustomParser func(greenery.Config, map[string]interface{}) ([]string, error)

	// OverrideTraceLogger controls overriding of the test default trace
	// logger creation function
	OverrideTraceLogger bool

	// TraceLogger contains the MakeTraceLogger function to use
	TraceLogger greenery.MakeTraceLogger

	// OverridePrettyLogger controls overriding of the test default pretty
	// logger creation function
	OverridePrettyLogger bool

	// PrettyLogger contains the MakePrettyLogger function to use
	PrettyLogger greenery.MakeLogger

	// OverrideStructuredLogger controls overriding of the test default
	// structured logger creation function
	OverrideStructuredLogger bool

	// StructuredLogger contains the MakeStructuredLogger function to use
	StructuredLogger greenery.MakeLogger

	// OutStdOut is the expected stdout output from the executed command
	OutStdOut string

	// OutStdOutRegex will be matched against the output from the executed command
	OutStdOutRegex string

	// OutStdErr is the expected stderr output from the executed command
	OutStdErr string

	// OutStdErrRegex will be matched against the stderr output from the executed command
	OutStdErrRegex string

	// OutLogAllLines means one regex per expected log line will be tested
	OutLogAllLines bool

	// OutLogLines contains the expected log lines. All regexes must match at
	// least one of the log lines, done in sequence so go through the log
	// lines until the first regex matches, then the second and so on
	OutLogLines []LogLine

	// OutLogRegex will be matched against the log output from the executed command
	OutLogRegex string

	// Pretty is set to true if the expected logging output is 'pretty'
	// otherwise it's assumed to be standard JSON
	Pretty bool
	// Parallel makes this test case run parallel, parallel tests do not
	// have their stdout/stderr captured, and only OutLog directives are taken
	// into account.
	Parallel bool
	// contains filtered or unexported fields
}

type TestFile struct {
	Location string
	Source   string
	Contents []byte
	Perms    os.FileMode
	Custom   func(*testing.T, []byte, []byte) bool
}

type TestRunnerOptions struct {
	ConfigGen                func() greenery.Config
	Parallel                 bool
	HandlerMap               map[string]greenery.Handler
	OverrideHandlerMap       bool
	UserDocList              map[string]*greenery.DocSet
	OverrideTraceLogger      bool
	TraceLogger              greenery.MakeTraceLogger
	OverridePrettyLogger     bool
	PrettyLogger             greenery.MakeLogger
	OverrideStructuredLogger bool
	StructuredLogger         greenery.MakeLogger
	CompareMap               map[string]CompareFunc
	OverrideBuiltinHandlers  bool
	BuiltinHandlers          map[string]greenery.Handler
}