Files
archie/internal/yaegiutil/yaegiutil_test.go
T
sam 1e7f478d2f 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

124 lines
3.0 KiB
Go

package yaegiutil_test
import (
"strings"
"testing"
"time"
"github.com/traefik/yaegi/interp"
"github.com/samcharles93/archie-core/internal/yaegiutil"
)
func TestResolve(t *testing.T) {
i, err := yaegiutil.New(interp.Options{})
if err != nil {
t.Fatal(err)
}
fn, err := yaegiutil.Resolve[func() string](i, `package main
func Greet() string { return "hi" }`, "main.Greet")
if err != nil {
t.Fatal(err)
}
if got := fn(); got != "hi" {
t.Errorf("got %q, want %q", got, "hi")
}
}
func TestResolveWrongType(t *testing.T) {
i, err := yaegiutil.New(interp.Options{})
if err != nil {
t.Fatal(err)
}
_, err = yaegiutil.Resolve[func() int](i, `package main
func Greet() string { return "hi" }`, "main.Greet")
if err == nil {
t.Fatal("want error for wrong type, got nil")
}
}
func TestResolveWrongTypeNamesTheWantedType(t *testing.T) {
// The zero value of an interface T formats as <nil> under %T, so a failed
// assertion used to read "want <nil>" and tell the operator nothing.
i, err := yaegiutil.New(interp.Options{})
if err != nil {
t.Fatal(err)
}
_, err = yaegiutil.Resolve[interface{ Name() string }](i, `package main
var Greet = 42`, "main.Greet")
if err == nil {
t.Fatal("want error for wrong type, got nil")
}
if strings.Contains(err.Error(), "<nil>") {
t.Errorf("error must name the wanted interface, got: %v", err)
}
}
func TestResolveMissingExport(t *testing.T) {
i, err := yaegiutil.New(interp.Options{})
if err != nil {
t.Fatal(err)
}
_, err = yaegiutil.Resolve[func() string](i, `package main
func Other() string { return "hi" }`, "main.Greet")
if err == nil {
t.Fatal("want error for missing export, got nil")
}
}
func TestSafeRecoversPanic(t *testing.T) {
_, err := yaegiutil.Safe("test", func() (string, error) {
panic("boom")
})
if err == nil {
t.Fatal("want error from recovered panic, got nil")
}
if !strings.Contains(err.Error(), "boom") {
t.Errorf("error %q does not mention panic value", err.Error())
}
}
func TestSafePassesThroughResult(t *testing.T) {
got, err := yaegiutil.Safe("test", func() (int, error) {
return 42, nil
})
if err != nil {
t.Fatal(err)
}
if got != 42 {
t.Errorf("got %d, want 42", got)
}
}
func TestResolveTimeoutOnBlockingEval(t *testing.T) {
// Resolve calls i.Eval(src) with no timeout. If src contains
// package-level code that blocks forever (e.g. init() { select{} }),
// Resolve hangs indefinitely. This test asserts the CORRECT behaviour
// (Resolve returns an error or the timeout fires) and FAILS today
// because Resolve hangs.
i, err := yaegiutil.New(interp.Options{})
if err != nil {
t.Fatal(err)
}
done := make(chan struct{})
go func() {
_, _ = yaegiutil.Resolve[func() string](i, `package main
func init() { select {} }
func Greet() string { return "hi" }
`, "main.Greet")
close(done)
}()
select {
case <-done:
// Resolve returned — that is the desired behaviour after the fix.
// Today it hangs, so this branch is unreachable.
case <-time.After(5 * time.Second):
t.Error("Resolve did not return within 5s — Eval has no timeout (issue #43)")
}
}