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.
301 lines
7.3 KiB
Go
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
|
|
}
|