Files
archie/internal/plugin/architecture_test.go
T
sam 4b250ba929 test(plugin): stop asserting documentation prose in a test
TestPluginEngineRuleIsCanonicalAndSharedByAgentInstructions read
ARCHITECTURE.md and CLAUDE.md and failed if their prose did not contain a
particular heading and link. That is not a behaviour check: it makes an
agent-instruction file load-bearing for the build, so editing documentation
can break compilation of the test suite, and a doc drift becomes a red gate
that says nothing about the code.

The genuine invariant -- that an engine family has one owner that both
registers and resolves it -- is asserted on the AST by
TestEngineFamilyInspectionRejectsInvalidShapes, which is untouched.

Removes the readTestFile helper it was the only caller of.
2026-09-14 08:09:14 +00:00

301 lines
7.3 KiB
Go

package plugin_test
import (
"go/ast"
"go/parser"
"go/token"
"maps"
"path/filepath"
"slices"
"strings"
"testing"
)
func TestEngineFamilyInspectionRejectsInvalidShapes(t *testing.T) {
t.Parallel()
tests := []struct {
name string
src string
valid bool
}{
{
name: "typed family",
src: `package fixture
type Engine interface { Name() string; Version() string; Resolve(string) (string, error) }
type Registry struct{}
func (*Registry) Register(Engine) {}
func (*Registry) Get(string) (Engine, bool) { return nil, false }
`,
valid: true,
},
{
name: "embedded typed family",
src: `package fixture
type Resolver interface { Resolve(string) (string, error) }
type Engine interface { Resolver }
type Registry struct{}
func (*Registry) Register(Engine) {}
func (*Registry) Get(string) (Engine, bool) { return nil, false }
`,
valid: true,
},
{
name: "metadata only",
src: `package fixture
type Engine interface { Name() string; Version() string }
type Registry struct{}
func (*Registry) Register(Engine) {}
func (*Registry) Get(string) (Engine, bool) { return nil, false }
`,
},
{
name: "lifecycle only",
src: `package fixture
type Engine interface {
Name() string
Version() string
Start() error
Health() string
Stop() error
}
type Registry struct{}
func (*Registry) Register(Engine) {}
func (*Registry) Get(string) (Engine, bool) { return nil, false }
`,
},
{
name: "embedded metadata only",
src: `package fixture
type Metadata interface { Name() string; Version() string }
type Engine interface { Metadata }
type Registry struct{}
func (*Registry) Register(Engine) {}
func (*Registry) Get(string) (Engine, bool) { return nil, false }
`,
},
{
name: "unrelated owner methods",
src: `package fixture
type Engine interface { Resolve(string) (string, error) }
type Registry struct{}
func (*Registry) Register(string) {}
func (*Registry) Get(string) (string, bool) { return "", false }
`,
},
{
name: "split owners",
src: `package fixture
type Engine interface { Resolve(string) (string, error) }
type Registry struct{}
func (*Registry) Register(Engine) {}
type Manager struct{}
func (*Manager) Get(string) (Engine, bool) { return nil, false }
`,
},
{
name: "pointer to engine interface",
src: `package fixture
type Engine interface { Resolve(string) (string, error) }
type Registry struct{}
func (*Registry) Register(*Engine) {}
func (*Registry) Get(string) (*Engine, bool) { return nil, false }
`,
},
{
name: "collection of engine interfaces",
src: `package fixture
type Engine interface { Resolve(string) (string, error) }
type Registry struct{}
func (*Registry) Register([]Engine) {}
func (*Registry) Get(string) ([]Engine, bool) { return nil, false }
`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
file, err := parser.ParseFile(token.NewFileSet(), tt.name+".go", tt.src, 0)
if err != nil {
t.Fatal(err)
}
families := engineFamiliesInPackage(".", ".", []*ast.File{file})
if len(families) != 1 {
t.Fatalf("found %d engine families, want 1", len(families))
}
family := families[0]
got := family.hasDomainMethod && family.hasOwner &&
family.ownerRegisters && family.ownerManages && family.singleOwner
if got != tt.valid {
t.Fatalf("family validity = %t, want %t: %+v", got, tt.valid, family)
}
})
}
}
type engineFamily struct {
packagePath string
engineName string
hasDomainMethod bool
hasOwner bool
ownerRegisters bool
ownerManages bool
singleOwner bool
}
func engineFamiliesInPackage(root, dir string, files []*ast.File) []engineFamily {
engines := make(map[string]bool)
interfaces := make(map[string]*ast.InterfaceType)
owners := make(map[string]bool)
ownerMethods := make(map[string][]*ast.FuncDecl)
for _, file := range files {
for _, decl := range file.Decls {
switch decl := decl.(type) {
case *ast.GenDecl:
for _, spec := range decl.Specs {
typeSpec, ok := spec.(*ast.TypeSpec)
if !ok {
continue
}
if iface, ok := typeSpec.Type.(*ast.InterfaceType); ok {
interfaces[typeSpec.Name.Name] = iface
}
if typeSpec.Name.Name == "Registry" || typeSpec.Name.Name == "Manager" {
owners[typeSpec.Name.Name] = true
}
}
case *ast.FuncDecl:
receiver := receiverName(decl)
if receiver != "Registry" && receiver != "Manager" {
continue
}
ownerMethods[receiver] = append(ownerMethods[receiver], decl)
}
}
}
for name, iface := range interfaces {
if strings.HasSuffix(name, "Engine") {
engines[name] = hasDomainMethod(iface, interfaces, nil)
}
}
packagePath, err := filepath.Rel(root, dir)
if err != nil {
packagePath = dir
}
out := make([]engineFamily, 0, len(engines))
for name, domainMethod := range engines {
registers := false
manages := false
singleOwner := false
for owner := range owners {
ownerRegisters := ownerRegistersEngine(ownerMethods[owner], name)
ownerManages := ownerReturnsEngine(ownerMethods[owner], name)
registers = registers || ownerRegisters
manages = manages || ownerManages
singleOwner = singleOwner || ownerRegisters && ownerManages
}
out = append(out, engineFamily{
packagePath: filepath.ToSlash(packagePath),
engineName: name,
hasDomainMethod: domainMethod,
hasOwner: len(owners) > 0,
ownerRegisters: registers,
ownerManages: manages,
singleOwner: singleOwner,
})
}
return out
}
func hasDomainMethod(
iface *ast.InterfaceType,
interfaces map[string]*ast.InterfaceType,
visiting map[string]bool,
) bool {
genericMethods := []string{
"Health",
"Manifest",
"Name",
"Start",
"Stop",
"Version",
}
for _, field := range iface.Methods.List {
for _, name := range field.Names {
if _, generic := slices.BinarySearch(genericMethods, name.Name); !generic {
return true
}
}
if len(field.Names) != 0 {
continue
}
embedded, ok := field.Type.(*ast.Ident)
if !ok || visiting[embedded.Name] {
continue
}
embeddedInterface, ok := interfaces[embedded.Name]
if !ok {
continue
}
next := maps.Clone(visiting)
if next == nil {
next = make(map[string]bool)
}
next[embedded.Name] = true
if hasDomainMethod(embeddedInterface, interfaces, next) {
return true
}
}
return false
}
func receiverName(decl *ast.FuncDecl) string {
if decl.Recv == nil || len(decl.Recv.List) == 0 {
return ""
}
switch receiver := decl.Recv.List[0].Type.(type) {
case *ast.Ident:
return receiver.Name
case *ast.StarExpr:
if ident, ok := receiver.X.(*ast.Ident); ok {
return ident.Name
}
}
return ""
}
func ownerRegistersEngine(methods []*ast.FuncDecl, engineName string) bool {
for _, method := range methods {
if method.Name.Name != "Register" || method.Type.Params == nil {
continue
}
for _, field := range method.Type.Params.List {
if expressionNamesType(field.Type, engineName) {
return true
}
}
}
return false
}
func ownerReturnsEngine(methods []*ast.FuncDecl, engineName string) bool {
for _, method := range methods {
if method.Type.Results == nil {
continue
}
for _, field := range method.Type.Results.List {
if expressionNamesType(field.Type, engineName) {
return true
}
}
}
return false
}
func expressionNamesType(expr ast.Expr, typeName string) bool {
ident, ok := expr.(*ast.Ident)
return ok && ident.Name == typeName
}