Files
archie/internal/secret/loaddir_test.go
T
sam 71d026feb2 fix(yaegiutil): refuse incomplete Yaegi interface wrappers at load
The generated symbol tables carried 25 hand-added nil guards across three
packages, re-applied by hand after every regeneration because `yaegi extract`
does not emit them. Regeneration silently dropped them, and three package docs
instructed the next agent to put them back.

The guards also answered the wrong way. A nil WResolve returned ("", nil), so a
malformed secret engine served an empty secret and reported success; a nil
WStop reported a clean shutdown for a module that never ran one.

Reject the wrapper where it enters the daemon instead. Yaegi type-checks
"var X Iface = impl{}" and refuses an incomplete impl on its own, but the
wrapper type is exported into the symbol table, so interpreted code can build
one directly and struct-literal semantics leave the omitted method nil.
Resolve now names the missing method and skips the plugin.

Generated tables are used verbatim again. Also names the wanted type on a
failed assertion, which formatted as "want <nil>" for every interface target.
2026-09-20 12:05:39 +10:00

311 lines
8.2 KiB
Go

package secret_test
import (
"os"
"path/filepath"
"testing"
"github.com/samcharles93/archie-core/internal/secret"
"github.com/samcharles93/archie-core/internal/secret/secretextract"
)
// ── LoadDir behavioral tests ─────────────────────────────────────────
var symbols = secretextract.Symbols
func TestLoadDirLoadsValidEngine(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "hello.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: func() string { return "hello" },
WVersion: func() string { return "1.0.0" },
WResolve: func(key string) (string, error) { return "resolved:" + key, nil },
}
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("LoadDir returned %d, want 1", n)
}
e, ok := r.Get("hello")
if !ok {
t.Fatal("engine \"hello\" not registered")
}
if e.Version() != "1.0.0" {
t.Errorf("Version() = %q, want 1.0.0", e.Version())
}
v, err := e.Resolve("k")
if err != nil {
t.Fatal(err)
}
if v != "resolved:k" {
t.Errorf("Resolve() = %q, want resolved:k", v)
}
}
func TestLoadDirSkipsInvalidEngine(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "broken.go"), []byte(`package main
this is not valid Go syntax @@@@
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Errorf("LoadDir returned %d from broken source, want 0", n)
}
}
func TestLoadDirSkipsFileWithoutEngineExport(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "notanengine.go"), []byte(`package main
func Something() string { return "nope" }
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Errorf("LoadDir returned %d from file without Engine export, want 0", n)
}
}
func TestLoadDirSkipsNonGoFiles(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "readme.md"), []byte(`# Not an engine`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "hello.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: func() string { return "hello" },
WVersion: func() string { return "1.0.0" },
WResolve: func(key string) (string, error) { return "v", nil },
}
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("LoadDir returned %d, want 1 (only .go files count)", n)
}
}
func TestLoadDirSubdirectoriesAreIgnored(t *testing.T) {
dir := t.TempDir()
subDir := filepath.Join(dir, "nested")
if err := os.MkdirAll(subDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(subDir, "nested.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: func() string { return "nested" },
WVersion: func() string { return "1.0.0" },
WResolve: func(key string) (string, error) { return "v", nil },
}
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Errorf("LoadDir returned %d, want 0 -- subdirectories must not be traversed", n)
}
}
// ── Adversarial tests ────────────────────────────────────────────────
func TestLoadDirRefusesEngineWithNilFunctionFields(t *testing.T) {
// A hand-built _Engine with nil method fields must be refused at load.
// It previously loaded and answered ("", nil) from a nil WResolve, so a
// malformed engine returned an empty secret and reported success -- a
// silent wrong answer is worse for a secret lookup than a refusal.
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "nilfuncs.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: nil,
WVersion: nil,
WResolve: nil,
}
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Fatalf("LoadDir returned %d, want 0 (an engine missing methods must be refused)", n)
}
}
func TestLoadDirSkipsEngineWithWrongExportType(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "wrongtype.go"), []byte(`package main
var Engine = 42
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Errorf("LoadDir returned %d from wrong-type export, want 0", n)
}
}
func TestLoadDirSkipsEngineWithOnlySomeInterfaceMethods(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "partial.go"), []byte(`package main
type partial struct{}
func (p partial) Name() string { return "partial" }
func (p partial) Version() string { return "1.0.0" }
// No Resolve() method -- deliberately incomplete.
var Engine partial
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Errorf("LoadDir returned %d from partial impl, want 0", n)
}
}
func TestLoadDirEngineWithPanicInResolve(t *testing.T) {
// An engine whose Resolve() panics must still be loadable -- the
// panic only fires on call, not on load. Registry.Resolve does not
// itself recover; callers that invoke a loaded engine's Resolve are
// expected to use yaegiutil.Safe if they need panic recovery, same
// as internal/plugin callers.
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "panicky.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: func() string { return "panicky" },
WVersion: func() string { return "1.0.0" },
WResolve: func(key string) (string, error) { panic("boom") },
}
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("LoadDir returned %d, want 1 (panics are deferred to call time)", n)
}
e, _ := r.Get("panicky")
func() {
defer func() {
if rec := recover(); rec == nil {
t.Error("Resolve() did not panic -- expected panic from panicky engine")
}
}()
_, _ = e.Resolve("k")
}()
}
func TestLoadDirMultipleEnginesSortedByFilename(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "01-alpha.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: func() string { return "alpha" },
WVersion: func() string { return "1.0.0" },
WResolve: func(key string) (string, error) { return "v", nil },
}
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "02-beta.go"), []byte(`package main
import "github.com/samcharles93/archie-core/internal/secret"
var Engine = secret._Engine{
WName: func() string { return "beta" },
WVersion: func() string { return "2.0.0" },
WResolve: func(key string) (string, error) { return "v", nil },
}
`), 0o644); err != nil {
t.Fatal(err)
}
r := secret.NewRegistry()
n, err := r.LoadDir(dir, symbols)
if err != nil {
t.Fatal(err)
}
if n != 2 {
t.Fatalf("LoadDir returned %d, want 2", n)
}
if _, ok := r.Get("alpha"); !ok {
t.Error("alpha engine not registered")
}
if _, ok := r.Get("beta"); !ok {
t.Error("beta engine not registered")
}
}
// The former TestGeneratedWrapperHasNilGuards was retired. It pinned
// hand-added nil guards in the generated wrapper, which every regeneration
// silently dropped, and the behaviour it protected -- a nil WResolve
// answering ("", nil) -- was a silent wrong answer. LoadDir now refuses such
// an engine outright; see TestLoadDirRefusesEngineWithNilFunctionFields.