《游戏服务端架构·平台化与架构治理》11.3 AI 辅助测试与压测

// file: internal/aitestload/cases.go
// tier: L1
// verify: go test ./internal/aitestload/
package aitestload

import (
	"errors"
	"fmt"
	"sort"
	"strings"
)

var (
	ErrNoSource      = errors.New("aitestload: candidate has no source")
	ErrNoVersion     = errors.New("aitestload: candidate has no version")
	ErrNoReviewer    = errors.New("aitestload: candidate needs human review")
	ErrBadRisk       = errors.New("aitestload: risk must be 1..5")
	ErrMissingID     = errors.New("aitestload: candidate needs an id")
	ErrNoSteps       = errors.New("aitestload: candidate needs at least one step")
	ErrNoRequirement = errors.New("aitestload: candidate needs a requirement")
)

// Candidate is a generated test case before it enters the suite. Source and
// Version make the origin reproducible; ApprovedBy is the human who accepted
// it. A generated case without all three is a draft, not a test.
type Candidate struct {
	ID          string
	Source      string
	Requirement string
	Steps       []string
	Risk        int
	GeneratedBy string
	Version     string
	ApprovedBy  string
}

// Admit validates a candidate and records the reviewer. It performs no model
// calls: generation is a separate, replaceable step, while admission is the
// control point that keeps unreviewed output out of CI.
func Admit(c Candidate, reviewer string) (Candidate, error) {
	if strings.TrimSpace(c.ID) == "" {
		return Candidate{}, ErrMissingID
	}
	if strings.TrimSpace(c.Source) == "" {
		return Candidate{}, ErrNoSource
	}
	if strings.TrimSpace(c.Requirement) == "" {
		return Candidate{}, ErrNoRequirement
	}
	if len(c.Steps) == 0 {
		return Candidate{}, ErrNoSteps
	}
	if strings.TrimSpace(c.Version) == "" {
		return Candidate{}, ErrNoVersion
	}
	if c.Risk < 1 || c.Risk > 5 {
		return Candidate{}, ErrBadRisk
	}
	if strings.TrimSpace(reviewer) == "" {
		return Candidate{}, ErrNoReviewer
	}

	c.ApprovedBy = reviewer
	return c, nil
}

// Fingerprint is the dedupe key for candidates. Steps are sorted so the same
// scenario expressed in a different order does not enter twice. It is not a
// semantic comparison; reviewers still decide whether two cases overlap.
func Fingerprint(c Candidate) string {
	steps := make([]string, len(c.Steps))
	for i, s := range c.Steps {
		steps[i] = strings.TrimSpace(s)
	}
	sort.Strings(steps)

	req := strings.TrimSpace(c.Requirement)
	return fmt.Sprintf("%s::%s", req, strings.Join(steps, "|"))
}

// file: internal/aitestload/regression.go
// tier: L1
// verify: go test ./internal/aitestload/
package aitestload

import "sort"

// Case is an existing test case in the regression suite. Touches lists the
// packages or modules the case exercises; LastFail marks a case that failed
// in the last run.
type Case struct {
	ID       string
	Touches  []string
	LastFail bool
	Risk     int
	Duration int // seconds
}

// Selection is the regression plan. Skipped carries a reason per case so a
// reviewer can challenge the filter instead of trusting a black box.
type Selection struct {
	Chosen  []string
	Skipped map[string]string
	Seconds int
}

// Selector chooses cases under a time budget. Scores are intentionally
// simple and explainable: a changed dependency dominates, a recent failure
// is next, and risk breaks ties. No model output is involved in the decision.
type Selector struct {
	BudgetSeconds int
}

// Select returns a deterministic plan. Cases with no changed dependency and
// no recent failure are skipped as no_signal; the rest are ordered by score,
// then by shortest duration, then by ID.
func (s Selector) Select(changed []string, cases []Case) Selection {
	out := Selection{Skipped: make(map[string]string)}
	changedSet := make(map[string]bool, len(changed))
	for _, c := range changed {
		changedSet[c] = true
	}

	type scored struct {
		c     Case
		score int
	}
	var candidates []scored
	for _, c := range cases {
		score := 0
		if hitsChanged(c, changedSet) {
			score += 100
		}
		if c.LastFail {
			score += 50
		}
		if score == 0 {
			out.Skipped[c.ID] = "no_signal"
			continue
		}
		score += c.Risk * 2
		candidates = append(candidates, scored{c: c, score: score})
	}

	sort.SliceStable(candidates, func(i, j int) bool {
		if candidates[i].score != candidates[j].score {
			return candidates[i].score > candidates[j].score
		}
		if candidates[i].c.Duration != candidates[j].c.Duration {
			return candidates[i].c.Duration < candidates[j].c.Duration
		}
		return candidates[i].c.ID < candidates[j].c.ID
	})

	for _, cand := range candidates {
		if out.Seconds+cand.c.Duration > s.BudgetSeconds {
			out.Skipped[cand.c.ID] = "over_budget"
			continue
		}
		out.Chosen = append(out.Chosen, cand.c.ID)
		out.Seconds += cand.c.Duration
	}
	return out
}

func hitsChanged(c Case, changed map[string]bool) bool {
	for _, t := range c.Touches {
		if changed[t] {
			return true
		}
	}
	return false
}