testing

type AggregateCoverage struct {
	// Services maps service name to coverage data
	Services map[string]*CoverageData
	// Aggregate is the combined coverage across all services
	Aggregate *CoverageData
	// Threshold is the required coverage threshold
	Threshold float64
	// Met indicates whether the threshold was met
	Met bool
}

type AggregateResult struct {
	// Services contains results for each service
	Services []*TestResult
	// Passed is the total number of passed tests
	Passed int
	// Failed is the total number of failed tests
	Failed int
	// Skipped is the total number of skipped tests
	Skipped int
	// Total is the total number of tests
	Total int
	// Duration is the total test execution time
	Duration float64
	// Coverage is the aggregated coverage data
	Coverage *AggregateCoverage
	// Success indicates whether all tests passed
	Success bool
	// Error message if test execution failed
	Error string
}

type CoberturaClass struct {
	XMLName    xml.Name        `xml:"class"`
	Name       string          `xml:"name,attr"`
	Filename   string          `xml:"filename,attr"`
	LineRate   float64         `xml:"line-rate,attr"`
	BranchRate float64         `xml:"branch-rate,attr"`
	Complexity float64         `xml:"complexity,attr"`
	Lines      []CoberturaLine `xml:"lines>line,omitempty"`
}

type CoberturaCoverage struct {
	XMLName    xml.Name           `xml:"coverage"`
	LineRate   float64            `xml:"line-rate,attr"`
	BranchRate float64            `xml:"branch-rate,attr"`
	Version    string             `xml:"version,attr"`
	Timestamp  int64              `xml:"timestamp,attr"`
	Sources    []string           `xml:"sources>source,omitempty"`
	Packages   []CoberturaPackage `xml:"packages>package"`
}

type CoberturaLine struct {
	XMLName xml.Name `xml:"line"`
	Number  int      `xml:"number,attr"`
	Hits    int      `xml:"hits,attr"`
}

type CoberturaPackage struct {
	XMLName    xml.Name         `xml:"package"`
	Name       string           `xml:"name,attr"`
	LineRate   float64          `xml:"line-rate,attr"`
	BranchRate float64          `xml:"branch-rate,attr"`
	Complexity float64          `xml:"complexity,attr"`
	Classes    []CoberturaClass `xml:"classes>class"`
}

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

type CoverageConfig struct {
	// Enabled indicates whether to collect coverage
	Enabled bool `yaml:"enabled" json:"enabled"`
	// Tool is the coverage tool name
	Tool string `yaml:"tool" json:"tool"`
	// Threshold is the minimum coverage percentage for this service
	Threshold float64 `yaml:"threshold" json:"threshold"`
	// Source is the source directory to measure coverage (Python)
	Source string `yaml:"source" json:"source"`
	// OutputFormat is the coverage output format
	OutputFormat string `yaml:"outputFormat" json:"outputFormat"`
	// Exclude are files/patterns to exclude from coverage
	Exclude []string `yaml:"exclude" json:"exclude"`
}

type CoverageData struct {
	// Lines coverage metric
	Lines CoverageMetric
	// Branches coverage metric
	Branches CoverageMetric
	// Functions coverage metric
	Functions CoverageMetric
	// Files contains per-file coverage data
	Files []*FileCoverage
}

type CoverageJSONReport struct {
	Generated    string                      `json:"generated"`
	Threshold    float64                     `json:"threshold"`
	ThresholdMet bool                        `json:"threshold_met"`
	Summary      CoverageSummary             `json:"summary"`
	Services     map[string]*ServiceCoverage `json:"services"`
	Files        []*FileCoverageReport       `json:"files,omitempty"`
}

type CoverageMetric struct {
	// Covered is the number of covered items
	Covered int
	// Total is the total number of items
	Total int
	// Percent is the coverage percentage
	Percent float64
}

type CoverageSummary struct {
	Lines         CoverageMetric `json:"lines"`
	TotalFiles    int            `json:"total_files"`
	TotalServices int            `json:"total_services"`
}

type DetectedTestTypes struct {
	HasUnit          bool
	HasIntegration   bool
	HasE2E           bool
	UnitPaths        []string
	IntegrationPaths []string
	E2EPaths         []string
}

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

type FileCoverage struct {
	// Path is the file path
	Path string
	// Lines coverage metric
	Lines CoverageMetric
	// Branches coverage metric
	Branches CoverageMetric
	// Functions coverage metric
	Functions CoverageMetric
	// CoveredLines are the line numbers that are covered
	CoveredLines []int
	// LineHits maps line numbers to the number of times they were executed
	LineHits map[int]int
}

type FileCoverageReport struct {
	Path           string         `json:"path"`
	Lines          CoverageMetric `json:"lines"`
	UncoveredLines []int          `json:"uncovered_lines,omitempty"`
}

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

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

type JUnitError struct {
	Message string `xml:"message,attr,omitempty"`
	Type    string `xml:"type,attr,omitempty"`
	Content string `xml:",chardata"`
}

type JUnitFailure struct {
	Message string `xml:"message,attr,omitempty"`
	Type    string `xml:"type,attr,omitempty"`
	Content string `xml:",chardata"`
}

type JUnitSkipped struct {
	Message string `xml:"message,attr,omitempty"`
}

type JUnitTestCase struct {
	XMLName   xml.Name      `xml:"testcase"`
	Name      string        `xml:"name,attr"`
	ClassName string        `xml:"classname,attr"`
	Time      float64       `xml:"time,attr"`
	Failure   *JUnitFailure `xml:"failure,omitempty"`
	Error     *JUnitError   `xml:"error,omitempty"`
	Skipped   *JUnitSkipped `xml:"skipped,omitempty"`
	SystemOut string        `xml:"system-out,omitempty"`
	SystemErr string        `xml:"system-err,omitempty"`
}

type JUnitTestSuite struct {
	XMLName   xml.Name        `xml:"testsuite"`
	Name      string          `xml:"name,attr"`
	Tests     int             `xml:"tests,attr"`
	Failures  int             `xml:"failures,attr"`
	Errors    int             `xml:"errors,attr"`
	Skipped   int             `xml:"skipped,attr"`
	Time      float64         `xml:"time,attr"`
	Timestamp string          `xml:"timestamp,attr,omitempty"`
	TestCases []JUnitTestCase `xml:"testcase"`
}

type JUnitTestSuites struct {
	XMLName    xml.Name         `xml:"testsuites"`
	Name       string           `xml:"name,attr,omitempty"`
	Tests      int              `xml:"tests,attr"`
	Failures   int              `xml:"failures,attr"`
	Errors     int              `xml:"errors,attr"`
	Skipped    int              `xml:"skipped,attr"`
	Time       float64          `xml:"time,attr"`
	Timestamp  string           `xml:"timestamp,attr,omitempty"`
	TestSuites []JUnitTestSuite `xml:"testsuite"`
}

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

type OutputMode int

type OutputModeOptions struct {
	// ForceStream forces streaming output mode (--stream flag).
	ForceStream bool
	// ForceProgress forces progress bar mode (--no-stream flag).
	ForceProgress bool
	// Parallel indicates if tests run in parallel.
	Parallel bool
}

type ProgressCallback func(event ProgressEvent)

type ProgressEvent struct {
	// Type indicates the type of progress event
	Type ProgressEventType
	// Service is the name of the service (if applicable)
	Service string
	// Framework is the test framework being used (if applicable)
	Framework string
	// Message is an optional message for the event
	Message string
}

type ProgressEventType int

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

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

type ServiceCoverage struct {
	Lines CoverageMetric        `json:"lines"`
	Files []*FileCoverageReport `json:"files,omitempty"`
}

type ServiceInfo struct {
	Name     string
	Language string
	Dir      string
	Config   *ServiceTestConfig
}

type ServiceTestConfig struct {
	// Framework is the test framework name (jest, pytest, xunit, etc.)
	Framework string `yaml:"framework" json:"framework"`
	// Unit test configuration
	Unit *TestTypeConfig `yaml:"unit" json:"unit"`
	// Integration test configuration
	Integration *TestTypeConfig `yaml:"integration" json:"integration"`
	// E2E test configuration
	E2E *TestTypeConfig `yaml:"e2e" json:"e2e"`
	// Coverage configuration
	Coverage *CoverageConfig `yaml:"coverage" json:"coverage"`
}

type ServiceValidation struct {
	// Name is the service name
	Name string
	// Language is the programming language
	Language string
	// Framework is the detected test framework
	Framework string
	// TestFiles is the count of test files found
	TestFiles int
	// CanTest indicates if the service can be tested
	CanTest bool
	// SkipReason explains why a service cannot be tested (if CanTest is false)
	SkipReason string
}

type TestConfig struct {
	// Parallel indicates whether to run tests for services in parallel
	Parallel bool
	// FailFast indicates whether to stop on first test failure
	FailFast bool
	// CoverageThreshold is the minimum coverage percentage required (0-100)
	CoverageThreshold float64
	// OutputDir is the directory for test reports and coverage
	OutputDir string
	// Verbose enables verbose test output
	Verbose bool
	// Timeout is the per-service test timeout duration
	// Default is 10 minutes if not set
	Timeout time.Duration
}

type TestFailure struct {
	// Name is the test name
	Name string
	// Message is the failure message
	Message string
	// StackTrace is the failure stack trace
	StackTrace string
	// File is the file where the test failed
	File string
	// Line is the line number where the test failed
	Line int
}

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

type TestResult struct {
	// Service name
	Service string
	// TestType is the type of test (unit, integration, e2e)
	TestType string
	// Passed is the number of passed tests
	Passed int
	// Failed is the number of failed tests
	Failed int
	// Skipped is the number of skipped tests
	Skipped int
	// Total is the total number of tests
	Total int
	// Duration is the test execution time in seconds
	Duration float64
	// Failures contains details of failed tests
	Failures []TestFailure
	// Coverage data (if coverage was enabled)
	Coverage *CoverageData
	// Success indicates whether all tests passed
	Success bool
	// Error message if test execution failed
	Error string
}

type TestRunner interface {
	RunTests(testType string, coverage bool) (*TestResult, error)
}

type TestTypeConfig struct {
	// Command is the command to run tests
	Command string `yaml:"command" json:"command"`
	// Pattern is the test file pattern (Node.js)
	Pattern string `yaml:"pattern" json:"pattern"`
	// Markers are pytest markers to filter tests (Python)
	Markers []string `yaml:"markers" json:"markers"`
	// Filter is the test filter expression (.NET)
	Filter string `yaml:"filter" json:"filter"`
	// Projects are test project paths (.NET)
	Projects []string `yaml:"projects" json:"projects"`
	// Setup commands to run before tests
	Setup []string `yaml:"setup" json:"setup"`
	// Teardown commands to run after tests
	Teardown []string `yaml:"teardown" json:"teardown"`
}

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

type WatchCallback func(changedServices []string) error

type WatcherOption func(*FileWatcher)