tester

type Asserter interface {
	Assert(value interface{}) error
	GetExpected() string
	GetActual() string
}

type Asserter2 interface {
	Assert(data interface{}) AssertionResultList
}

type Asserter2Constructor func(name string, definition interface{}) (Asserter2, error)

type Asserter2Descriptor struct {
	Type        string
	Constructor Asserter2Constructor
}

type Asserter2List struct {
	common.List[Asserter2]
}

type AsserterBuilder interface {
	Build(testCase *TestCase) AssertionProcessor
}

type Assertion struct {
	Name     string
	Expected string
	Actual   string
	// contains filtered or unexported fields
}

type Assertion2 struct {
	Name   string      `yaml:"name"`
	Type   string      `yaml:"type"`
	Assert interface{} `yaml:"assert"`
}

type Assertion2Factory interface {
	Create(assertion Assertion2) (Asserter2, error)
}

type Assertion2FactoryIn struct {
	fx.In
	Descriptors []Asserter2Descriptor `group:"assertion_descriptor"`
}

type AssertionMap map[string]*Assertion

type AssertionProcessor interface {
	Process(testCase *TestCase)
}

type AssertionResult struct {
	Name     string
	Status   AssertionResultStatus
	Expected string
	Actual   string
}

type AssertionResultList struct {
	common.List[AssertionResult]
}

type AssertionResultStatus int

type Engine interface {
	Configure(data interface{}) error
	GetTestCase2List() TestCase2List
	CreateRunner() Runner
}

type EngineConstructor func() Engine

type EngineDescriptor struct {
	Type        string
	Constructor EngineConstructor
}

type EngineFactory interface {
	Create(name string) (Engine, error)
}

type EngineFactoryIn struct {
	fx.In
	Descriptors []EngineDescriptor `group:"engine_descriptor"`
}

type PostProcessor interface {
	PostProcess(testCase *TestCase) error
}

type PostProcessorConstructor func(config map[string]interface{}) (PostProcessor, error)

type PostProcessorDescriptor struct {
	Type        string
	Constructor PostProcessorConstructor
}

type PostProcessorDescriptorIn struct {
	fx.In
	Descriptors []PostProcessorDescriptor `group:"post_processor_descriptor"`
}

type PostProcessorFactory interface {
	Create(def common.PostProcessor) (PostProcessor, error)
}

type Reporter interface {
	Report(container TestCaseContainer) error
}

type Reporter2 interface {
	Report(report RunnerReport)
}

type Reporter2Constructor func(definition interface{}) Reporter2

type Reporter2Descriptor struct {
	Type        string
	Constructor Reporter2Constructor
}

type Reporter2Factory interface {
	Create(name string, definition interface{}) (Reporter2, error)
}

type Reporter2FactoryIn struct {
	fx.In
	Descriptors []Reporter2Descriptor `group:"reporter_descriptor"`
}

type Runner interface {
	Setup(testCase TestCase2)
	Run(assertions Asserter2List) RunnerReportList
}

type RunnerReport struct {
	Name       string
	Details    []RunnerReportDetail
	Assertions AssertionResultList
}

type RunnerReportDetail struct {
	Name string
	Data interface{}
}

type RunnerReportList struct {
	common.List[RunnerReport]
}

type TestCase struct {
	Name   string
	Status TestCaseStatus
	Err    error

	Template       *common.Template
	ExpectedResult TestCaseResult
	ActualResult   *TestCaseResult
	Assertions     []*Assertion
	// contains filtered or unexported fields
}

type TestCase2 struct {
	Name       string         `yaml:"name"`
	Tags       []string       `yaml:"tags"`
	Priority   int            `yaml:"priority"`
	Setup      TestCase2Setup `yaml:"setup"`
	Assertions []Assertion2   `yaml:"assertions"`
}

type TestCase2List struct {
	common.List[TestCase2]
}

type TestCase2Setup struct {
	Query string        `yaml:"query"`
	Range time.Duration `yaml:"range"`
}

type TestCaseContainer []*TestCase

type TestCaseResult struct {
	StatusCode int
	Headers    map[string]string
	Body       interface{}
	Buf        []byte
}

type TestCaseStatus int

type Tester interface {
	Configure(ctx context.Context, arguments common.Arguments, containers common.TemplateContainer)
	Test() (TestCaseContainer, error)
}

type WorkerIn struct {
	fx.In
	ConverterContainer converter.Container
	Tester             Tester
	Reporters          []Reporter `group:"reporter"`
}