validator

package
v0.0.0-...-4ed06ba Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 7, 2026 License: MIT Imports: 20 Imported by: 0

Documentation

Overview

Package validator provides validation utilities including request validation and diff detection.

Package validator provides validation utilities including request validation and diff detection.

Package validator provides validation utilities including request validation and diff detection.

Package validator provides validation utilities including request validation and diff detection.

Package validator provides validation utilities including request validation and diff detection.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ReadRequestBody 

func ReadRequestBody(req *http.Request) ([]byte, error)

ReadRequestBody reads the request body

Types

type AnomalyDetector 

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

AnomalyDetector detects anomalies in API behavior

func NewAnomalyDetector 

func NewAnomalyDetector() *AnomalyDetector

NewAnomalyDetector creates a new anomaly detector

func (*AnomalyDetector) DetectAnomalies 

func (d *AnomalyDetector) DetectAnomalies(endpoint string, current BaselineMetrics) []string

DetectAnomalies checks if current metrics deviate from baseline

func (*AnomalyDetector) SetBaseline 

func (d *AnomalyDetector) SetBaseline(endpoint string, metrics BaselineMetrics)

SetBaseline sets the baseline metrics for an endpoint

type BaselineMetrics 

type BaselineMetrics struct {
	AvgResponseTime float64 `json:"avgResponseTime"`
	ErrorRate       float64 `json:"errorRate"`
	P95ResponseTime float64 `json:"p95ResponseTime"`
}

BaselineMetrics stores baseline metrics for an endpoint

type BenchmarkResult 

type BenchmarkResult struct {
	Endpoint string        `json:"endpoint"`
	Count    int           `json:"count"`
	Min      time.Duration `json:"min"`
	Max      time.Duration `json:"max"`
	Mean     time.Duration `json:"mean"`
	Median   time.Duration `json:"median"`
	P95      time.Duration `json:"p95"`
	P99      time.Duration `json:"p99"`
	StdDev   time.Duration `json:"stdDev"`
	Total    time.Duration `json:"total"`
}

BenchmarkResult contains statistical analysis of performance measurements

type BreakingChange 

type BreakingChange struct {
	Type        string `json:"type"`
	Path        string `json:"path"`
	Method      string `json:"method,omitempty"`
	Description string `json:"description"`
	Severity    string `json:"severity"` // breaking, warning, info
}

BreakingChange represents a breaking change between specs

type BusinessRuleCondition 

type BusinessRuleCondition string

BusinessRuleCondition represents a business rule condition type 

const (
	ConditionEquals      BusinessRuleCondition = "equals"
	ConditionNotEquals   BusinessRuleCondition = "not_equals"
	ConditionGreaterThan BusinessRuleCondition = "greater_than"
	ConditionLessThan    BusinessRuleCondition = "less_than"
	ConditionContains    BusinessRuleCondition = "contains"
	ConditionStartsWith  BusinessRuleCondition = "starts_with"
	ConditionEndsWith    BusinessRuleCondition = "ends_with"
	ConditionMatches     BusinessRuleCondition = "matches"
	ConditionExists      BusinessRuleCondition = "exists"
	ConditionNotExists   BusinessRuleCondition = "not_exists"
	ConditionIn          BusinessRuleCondition = "in"
	ConditionNotIn       BusinessRuleCondition = "not_in"
	ConditionBetween     BusinessRuleCondition = "between"
	ConditionCustom      BusinessRuleCondition = "custom"
)

type CookieValidation 

type CookieValidation struct {
	Name     string `json:"name"`
	Required bool   `json:"required"`
	Secure   bool   `json:"secure"`
	HTTPOnly bool   `json:"httpOnly"`
	SameSite string `json:"sameSite"` // strict, lax, none
	MaxAge   int    `json:"maxAge"`
}

CookieValidation validates cookie attributes

type CookieValidator 

type CookieValidator struct{}

CookieValidator validates cookies

func NewCookieValidator 

func NewCookieValidator() *CookieValidator

NewCookieValidator creates a new cookie validator

func (*CookieValidator) ValidateCookies 

func (cv *CookieValidator) ValidateCookies(cookies []*http.Cookie, validations []CookieValidation) []ValidationIssue

ValidateCookies validates response cookies

type CustomRule 

type CustomRule struct {
	Name        string                 `json:"name" yaml:"name"`
	Description string                 `json:"description,omitempty" yaml:"description,omitempty"`
	Type        RuleType               `json:"type" yaml:"type"`
	Path        string                 `json:"path" yaml:"path"`
	Condition   string                 `json:"condition,omitempty" yaml:"condition,omitempty"`
	Value       interface{}            `json:"value,omitempty" yaml:"value,omitempty"`
	Min         *float64               `json:"min,omitempty" yaml:"min,omitempty"`
	Max         *float64               `json:"max,omitempty" yaml:"max,omitempty"`
	Pattern     string                 `json:"pattern,omitempty" yaml:"pattern,omitempty"`
	Enum        []interface{}          `json:"enum,omitempty" yaml:"enum,omitempty"`
	Required    bool                   `json:"required,omitempty" yaml:"required,omitempty"`
	Message     string                 `json:"message,omitempty" yaml:"message,omitempty"`
	Severity    ValidationSeverity     `json:"severity,omitempty" yaml:"severity,omitempty"`
	Config      map[string]interface{} `json:"config,omitempty" yaml:"config,omitempty"`
}

CustomRule represents a user-defined validation rule

func (CustomRule) Validate 

func (r CustomRule) Validate() error

Validate validates a custom rule definition

type CustomValidator 

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

CustomValidator wraps a validation function with metadata

func (*CustomValidator) Description 

func (cv *CustomValidator) Description() string

Description returns the validator description

func (*CustomValidator) Name 

func (cv *CustomValidator) Name() string

Name returns the validator name

func (*CustomValidator) Validate 

func (cv *CustomValidator) Validate(value interface{}, context map[string]interface{}) error

Validate implements the ValidationFunction interface

type DiffDetector 

type DiffDetector struct{}

DiffDetector detects breaking changes between specs

func NewDiffDetector 

func NewDiffDetector() *DiffDetector

NewDiffDetector creates a new diff detector

func (*DiffDetector) DetectBreakingChanges 

func (dd *DiffDetector) DetectBreakingChanges(oldSpec, newSpec map[string]interface{}) []BreakingChange

DetectBreakingChanges compares old and new specs for breaking changes

type Engine 

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

Engine handles validation of API responses against OpenAPI specs

func NewEngine 

func NewEngine() *Engine

NewEngine creates a new validation engine

func (*Engine) SetStrict 

func (e *Engine) SetStrict(strict bool)

SetStrict sets strict mode (warnings become errors)

func (*Engine) ValidateResponse 

func (e *Engine) ValidateResponse(operation *openapi.Operation, resp *http.Response, body []byte) *ValidationResult

ValidateResponse validates an HTTP response against an operation

type ErrorExplainer 

type ErrorExplainer struct{}

ErrorExplainer provides intelligent error explanations

func NewErrorExplainer 

func NewErrorExplainer() *ErrorExplainer

NewErrorExplainer creates a new error explainer

func (*ErrorExplainer) Explain 

func (e *ErrorExplainer) Explain(error string) ErrorExplanation

Explain provides an explanation for a validation error

type ErrorExplanation 

type ErrorExplanation struct {
	Error       string   `json:"error"`
	Explanation string   `json:"explanation"`
	Suggestions []string `json:"suggestions"`
}

ErrorExplanation contains an explanation and suggestions

type HeaderAssertionType 

type HeaderAssertionType string

HeaderAssertionType represents types of header assertions 

const (
	HeaderAssertionPattern    HeaderAssertionType = "pattern"
	HeaderAssertionEquals     HeaderAssertionType = "equals"
	HeaderAssertionContains   HeaderAssertionType = "contains"
	HeaderAssertionStartsWith HeaderAssertionType = "starts_with"
	HeaderAssertionEndsWith   HeaderAssertionType = "ends_with"
	HeaderAssertionExists     HeaderAssertionType = "exists"
	HeaderAssertionNotExists  HeaderAssertionType = "not_exists"
	HeaderAssertionCount      HeaderAssertionType = "count"
)

type PerformanceBenchmark 

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

PerformanceBenchmark provides response time benchmarking capabilities

func NewPerformanceBenchmark 

func NewPerformanceBenchmark(endpoint string) *PerformanceBenchmark

NewPerformanceBenchmark creates a new performance benchmark

func (*PerformanceBenchmark) AddMeasurement 

func (pb *PerformanceBenchmark) AddMeasurement(duration time.Duration)

AddMeasurement adds a response time measurement

func (*PerformanceBenchmark) DetectRegression 

func (pb *PerformanceBenchmark) DetectRegression(baseline *BenchmarkResult, threshold float64) []string

DetectRegression compares current benchmark against baseline and detects regressions

func (*PerformanceBenchmark) GetResult 

func (pb *PerformanceBenchmark) GetResult() *BenchmarkResult

GetResult calculates and returns benchmark statistics

type PerformanceValidator 

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

PerformanceValidator validates performance constraints

func NewPerformanceValidator 

func NewPerformanceValidator() *PerformanceValidator

NewPerformanceValidator creates a new performance validator

func (*PerformanceValidator) SetMaxDuration 

func (pv *PerformanceValidator) SetMaxDuration(duration time.Duration)

SetMaxDuration sets the maximum allowed duration

func (*PerformanceValidator) SetMinDuration 

func (pv *PerformanceValidator) SetMinDuration(duration time.Duration)

SetMinDuration sets the minimum allowed duration

func (*PerformanceValidator) ValidateResponseTime 

func (pv *PerformanceValidator) ValidateResponseTime(duration time.Duration) *ValidationIssue

ValidateResponseTime validates response time constraints

type PluginLoader 

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

PluginLoader loads custom validation plugins from shared libraries

func NewPluginLoader 

func NewPluginLoader() *PluginLoader

NewPluginLoader creates a new plugin loader

func (*PluginLoader) ExecuteValidator 

func (pl *PluginLoader) ExecuteValidator(name string, value interface{}, context map[string]interface{}) error

ExecuteValidator executes a registered validator

func (*PluginLoader) GetValidator 

func (pl *PluginLoader) GetValidator(name string) (ValidationFunction, error)

GetValidator retrieves a registered validator by name

func (*PluginLoader) ListValidators 

func (pl *PluginLoader) ListValidators() []string

ListValidators returns all registered validator names

func (*PluginLoader) LoadPlugin 

func (pl *PluginLoader) LoadPlugin(path string) error

LoadPlugin loads a validation plugin from a .so file

func (*PluginLoader) RegisterValidator 

func (pl *PluginLoader) RegisterValidator(validator ValidationFunction) error

RegisterValidator registers a custom validator

func (*PluginLoader) RegisterValidatorFunc 

func (pl *PluginLoader) RegisterValidatorFunc(name, description string, fn ValidationFunc) error

RegisterValidatorFunc registers a simple validation function

type Property 

type Property struct {
	Type        string      `json:"type"`
	Format      string      `json:"format"`
	Description string      `json:"description"`
	Default     interface{} `json:"default"`
	Example     interface{} `json:"example"`
	Required    bool        `json:"required"`
	Schema
}

Property represents a single property in a schema

type RequestError 

type RequestError struct {
	Message  string `json:"message"`
	Field    string `json:"field"`
	Location string `json:"location"` // body, query, header, path
	Expected string `json:"expected"`
	Actual   string `json:"actual"`
}

RequestError represents a request validation error

type RequestValidationResult 

type RequestValidationResult struct {
	Valid  bool           `json:"valid"`
	Errors []RequestError `json:"errors"`
}

RequestValidationResult holds request validation results

type RequestValidator 

type RequestValidator struct {
}

RequestValidator validates HTTP requests against OpenAPI specs

func NewRequestValidator 

func NewRequestValidator() *RequestValidator

NewRequestValidator creates a new request validator

func (*RequestValidator) ValidateRequest 

func (rv *RequestValidator) ValidateRequest(req *http.Request, schema *Schema, body []byte) *RequestValidationResult

ValidateRequest validates an HTTP request against a schema

type RuleEngine 

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

RuleEngine executes custom validation rules

func NewRuleEngine 

func NewRuleEngine() *RuleEngine

NewRuleEngine creates a new rule engine

func (*RuleEngine) AddRule 

func (re *RuleEngine) AddRule(rule CustomRule) error

AddRule adds a custom rule to the engine

func (*RuleEngine) Execute 

func (re *RuleEngine) Execute(result *ValidationResult) []ValidationIssue

Execute runs all rules against a validation result

func (*RuleEngine) LoadRules 

func (re *RuleEngine) LoadRules(data []byte, format string) error

LoadRules loads rules from JSON or YAML data

type RuleTemplate 

type RuleTemplate struct {
	ID          string             `json:"id" yaml:"id"`
	Name        string             `json:"name" yaml:"name"`
	Description string             `json:"description" yaml:"description"`
	Category    string             `json:"category" yaml:"category"`
	Tags        []string           `json:"tags" yaml:"tags"`
	Rule        CustomRule         `json:"rule" yaml:"rule"`
	Variables   []TemplateVariable `json:"variables,omitempty" yaml:"variables,omitempty"`
	Version     string             `json:"version" yaml:"version"`
	Author      string             `json:"author,omitempty" yaml:"author,omitempty"`
}

RuleTemplate represents a reusable validation rule template

func GetBuiltInTemplates 

func GetBuiltInTemplates() []*RuleTemplate

GetBuiltInTemplates returns a set of built-in validation templates

type RuleType 

type RuleType string

RuleType defines the type of custom rule 

const (
	RuleTypeField       RuleType = "field"       // Validate a specific field
	RuleTypeResponse    RuleType = "response"    // Validate entire response
	RuleTypeHeader      RuleType = "header"      // Validate headers
	RuleTypeStatus      RuleType = "status"      // Validate status code
	RuleTypeSchema      RuleType = "schema"      // Custom schema validation
	RuleTypeBusiness    RuleType = "business"    // Business logic rules
	RuleTypeSecurity    RuleType = "security"    // Security-focused rules
	RuleTypePerformance RuleType = "performance" // Performance rules
)

type Schema 

type Schema struct {
	Type       string              `json:"type"`
	Properties map[string]Property `json:"properties"`
	Required   []string            `json:"required"`
	Enum       []interface{}       `json:"enum"`
	MinLength  *int                `json:"minLength"`
	MaxLength  *int                `json:"maxLength"`
	Minimum    *float64            `json:"minimum"`
	Maximum    *float64            `json:"maximum"`
	Pattern    string              `json:"pattern"`
	Items      *Schema             `json:"items"`
}

Schema represents a simplified request/response schema

type SmartTestSuggester 

type SmartTestSuggester struct{}

SmartTestSuggester uses AI to suggest test cases

func NewSmartTestSuggester 

func NewSmartTestSuggester() *SmartTestSuggester

NewSmartTestSuggester creates a new test suggester

func (*SmartTestSuggester) SuggestTests 

func (s *SmartTestSuggester) SuggestTests(spec map[string]interface{}) ([]TestSuggestion, error)

SuggestTests generates test case suggestions from an OpenAPI spec

type TemplateEngine 

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

TemplateEngine manages rule templates

func NewTemplateEngine 

func NewTemplateEngine() *TemplateEngine

NewTemplateEngine creates a new template engine

func (*TemplateEngine) GetTemplate 

func (te *TemplateEngine) GetTemplate(id string) (*RuleTemplate, error)

GetTemplate retrieves a template by ID

func (*TemplateEngine) Instantiate 

func (te *TemplateEngine) Instantiate(templateID string, variables map[string]interface{}) (*CustomRule, error)

Instantiate creates a CustomRule from a template with variable substitutions

func (*TemplateEngine) ListTemplates 

func (te *TemplateEngine) ListTemplates() []*RuleTemplate

ListTemplates returns all registered templates

func (*TemplateEngine) ListTemplatesByCategory 

func (te *TemplateEngine) ListTemplatesByCategory(category string) []*RuleTemplate

ListTemplatesByCategory returns templates filtered by category

func (*TemplateEngine) LoadTemplates 

func (te *TemplateEngine) LoadTemplates(dir string) error

LoadTemplates loads templates from a directory

func (*TemplateEngine) RegisterTemplate 

func (te *TemplateEngine) RegisterTemplate(template *RuleTemplate) error

RegisterTemplate registers a template

func (*TemplateEngine) SearchTemplates 

func (te *TemplateEngine) SearchTemplates(query string) []*RuleTemplate

SearchTemplates searches templates by name, description, or tags

type TemplateLoader 

type TemplateLoader struct{}

TemplateLoader loads templates from various sources

func NewTemplateLoader 

func NewTemplateLoader() *TemplateLoader

NewTemplateLoader creates a new template loader

func (*TemplateLoader) LoadFromDirectory 

func (tl *TemplateLoader) LoadFromDirectory(dir string) ([]*RuleTemplate, error)

LoadFromDirectory loads all templates from a directory

type TemplateVariable 

type TemplateVariable struct {
	Name        string      `json:"name" yaml:"name"`
	Description string      `json:"description" yaml:"description"`
	Type        string      `json:"type" yaml:"type"` // string, number, boolean, array
	Default     interface{} `json:"default,omitempty" yaml:"default,omitempty"`
	Required    bool        `json:"required" yaml:"required"`
}

TemplateVariable represents a variable in a template that can be customized

type TestDataGenerator 

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

TestDataGenerator generates test data based on schemas

func NewTestDataGenerator 

func NewTestDataGenerator() *TestDataGenerator

NewTestDataGenerator creates a new test data generator

func (*TestDataGenerator) GenerateFromSchema 

func (g *TestDataGenerator) GenerateFromSchema(schema map[string]interface{}) (interface{}, error)

GenerateFromSchema generates test data from a JSON schema

type TestRun 

type TestRun struct {
	ID            string              `json:"id"`
	Name          string              `json:"name"`
	SpecPath      string              `json:"specPath"`
	BaseURL       string              `json:"baseUrl"`
	StartTime     time.Time           `json:"startTime"`
	EndTime       time.Time           `json:"endTime,omitempty"`
	Results       []*ValidationResult `json:"results"`
	Status        TestRunStatus       `json:"status"`
	TotalErrors   int                 `json:"totalErrors"`
	TotalWarnings int                 `json:"totalWarnings"`
}

TestRun represents a complete test run with multiple validations

func NewTestRun 

func NewTestRun(name, specPath, baseURL string) *TestRun

NewTestRun creates a new test run

func (*TestRun) AddResult 

func (tr *TestRun) AddResult(result *ValidationResult)

AddResult adds a validation result to the test run

func (*TestRun) Complete 

func (tr *TestRun) Complete()

Complete marks the test run as complete

func (*TestRun) Duration 

func (tr *TestRun) Duration() time.Duration

Duration returns the duration of the test run

func (*TestRun) Summary 

func (tr *TestRun) Summary() string

Summary returns a summary of the test run

type TestRunStatus 

type TestRunStatus string

TestRunStatus represents the status of a test run 

const (
	TestRunStatusPending   TestRunStatus = "pending"
	TestRunStatusRunning   TestRunStatus = "running"
	TestRunStatusCompleted TestRunStatus = "completed"
	TestRunStatusFailed    TestRunStatus = "failed"
)

type TestSuggestion 

type TestSuggestion struct {
	Method      string                 `json:"method"`
	Path        string                 `json:"path"`
	Description string                 `json:"description"`
	Priority    string                 `json:"priority"` // high, medium, low
	TestData    map[string]interface{} `json:"testData"`
	Expected    map[string]interface{} `json:"expected"`
}

TestSuggestion represents a suggested test case

type ValidationFunc 

type ValidationFunc func(value interface{}, context map[string]interface{}) error

ValidationFunc is a function type that can be used as a validation function

type ValidationFunction 

type ValidationFunction interface {
	// Validate performs custom validation on the provided value
	// Returns an error if validation fails, nil otherwise
	Validate(value interface{}, context map[string]interface{}) error

	// Name returns the name of the validation function
	Name() string

	// Description returns a description of what the validation function does
	Description() string
}

ValidationFunction is the interface that custom validation functions must implement

type ValidationIssue 

type ValidationIssue struct {
	Severity    ValidationSeverity `json:"severity"`
	Message     string             `json:"message"`
	Path        string             `json:"path,omitempty"`
	OperationID string             `json:"operationId,omitempty"`
	Field       string             `json:"field,omitempty"`
	Expected    interface{}        `json:"expected,omitempty"`
	Actual      interface{}        `json:"actual,omitempty"`
}

ValidationIssue represents a single validation problem found

type ValidationPluginManager 

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

ValidationPluginManager manages custom validation plugins and functions

func NewValidationPluginManager 

func NewValidationPluginManager() *ValidationPluginManager

NewValidationPluginManager creates a new plugin manager

func (*ValidationPluginManager) GetLoader 

func (vpm *ValidationPluginManager) GetLoader() *PluginLoader

GetLoader returns the plugin loader

func (*ValidationPluginManager) LoadBuiltInValidators 

func (vpm *ValidationPluginManager) LoadBuiltInValidators()

LoadBuiltInValidators loads built-in custom validators

type ValidationResult 

type ValidationResult struct {
	Valid           bool              `json:"valid"`
	OperationID     string            `json:"operationId"`
	Path            string            `json:"path"`
	Method          string            `json:"method"`
	StatusCode      int               `json:"statusCode"`
	Issues          []ValidationIssue `json:"issues"`
	Duration        time.Duration     `json:"duration"`
	Timestamp       time.Time         `json:"timestamp"`
	RequestURL      string            `json:"requestUrl,omitempty"`
	ResponseBody    []byte            `json:"responseBody,omitempty"`
	ResponseHeaders map[string]string `json:"responseHeaders,omitempty"`
}

ValidationResult represents the result of validating an API response

func NewValidationResult 

func NewValidationResult(operationID, path, method string) *ValidationResult

NewValidationResult creates a new validation result

func (*ValidationResult) AddIssue 

func (vr *ValidationResult) AddIssue(severity ValidationSeverity, message, path, field string, expected, actual interface{})

AddIssue adds a validation issue to the result

func (*ValidationResult) ErrorCount 

func (vr *ValidationResult) ErrorCount() int

ErrorCount returns the number of error-level issues

func (*ValidationResult) WarningCount 

func (vr *ValidationResult) WarningCount() int

WarningCount returns the number of warning-level issues

type ValidationSeverity 

type ValidationSeverity string

ValidationSeverity represents the severity level of a validation issue 

const (
	SeverityError   ValidationSeverity = "error"
	SeverityWarning ValidationSeverity = "warning"
	SeverityInfo    ValidationSeverity = "info"
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.