Files
archie/internal/domain/eda/module/module_test.go
T

209 lines
5.7 KiB
Go

package module
import (
"context"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/eda/expr"
"github.com/samcharles93/archie-core/internal/domain/eda/module/log"
)
func writeModule(t *testing.T, dir, content string) string {
t.Helper()
path := filepath.Join(dir, "log.go")
if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
t.Fatalf("write %s: %v", path, err)
}
return path
}
func TestRegisterAndInvokeLogKind(t *testing.T) {
dir := t.TempDir()
writeModule(t, dir, `package main
import "github.com/samcharles93/archie-core/internal/domain/eda/module/log"
func Run(a log.Args) log.Result {
return log.Result{Written: a.Message != "", Level: a.Level}
}
`)
r := New()
if err := r.Register("log", dir); err != nil {
t.Fatalf("Register: %v", err)
}
res, err := r.Invoke(context.Background(), "log", map[string]any{"message": "hello", "level": "info"})
if err != nil {
t.Fatalf("Invoke: %v", err)
}
if res["written"] != true {
t.Errorf("result written = %v, want true", res["written"])
}
if res["level"] != "info" {
t.Errorf("result level = %q, want info", res["level"])
}
}
func TestInvokeUnknownKindIsError(t *testing.T) {
r := New()
if _, err := r.Invoke(context.Background(), "notify", nil); err == nil {
t.Fatal("Invoke(unknown kind) = nil, want error")
}
}
func TestRegisterUnknownKindIsError(t *testing.T) {
r := New()
if err := r.Register("notify", t.TempDir()); err == nil {
t.Fatal("Register(unknown kind) = nil, want error")
}
}
func TestKindSchema(t *testing.T) {
r := New()
argsType, resultType, ok := r.KindSchema("log")
if !ok {
t.Fatal("KindSchema(log) = not ok, want the built-in log contract")
}
if want := reflect.TypeFor[log.Args](); argsType != want {
t.Errorf("KindSchema(log) args type = %v, want %v", argsType, want)
}
if want := reflect.TypeFor[log.Result](); resultType != want {
t.Errorf("KindSchema(log) result type = %v, want %v", resultType, want)
}
if _, _, ok := r.KindSchema("notify"); ok {
t.Fatal("KindSchema(notify) = ok, want false for an unregistered kind")
}
}
func TestRegisterMissingFileIsError(t *testing.T) {
r := New()
if err := r.Register("log", t.TempDir()); err == nil {
t.Fatal("Register(missing file) = nil, want error")
}
}
func TestInvokeWrongShapeIsReportedError(t *testing.T) {
dir := t.TempDir()
writeModule(t, dir, `package main
import "github.com/samcharles93/archie-core/internal/domain/eda/module/log"
func Run(a log.Args) log.Result {
return log.Result{Written: true}
}
`)
r := New()
if err := r.Register("log", dir); err != nil {
t.Fatalf("Register: %v", err)
}
// Unknown arg key: shape mismatch, reported error, not silent ignore.
if _, err := r.Invoke(context.Background(), "log", map[string]any{"message": "hi", "bogus": 1}); err == nil {
t.Fatal("Invoke(unknown arg) = nil, want error")
}
// Wrong type for a known arg: reported error.
if _, err := r.Invoke(context.Background(), "log", map[string]any{"message": 42}); err == nil {
t.Fatal("Invoke(wrong type) = nil, want error")
}
}
func TestInvokeMalformedFileIsReported(t *testing.T) {
dir := t.TempDir()
writeModule(t, dir, `package main
func Run( {{{`)
r := New()
if err := r.Register("log", dir); err == nil {
t.Fatal("Register(malformed) = nil, want error")
}
}
// TestDecodeResultEndToEnd ties Invoke's real flat result map through the
// schema-aware conversion into the typed expr environment: the value the
// checker validates and the value the run reads have one definition.
func TestDecodeResultEndToEnd(t *testing.T) {
dir := t.TempDir()
writeModule(t, dir, `package main
import "github.com/samcharles93/archie-core/internal/domain/eda/module/log"
func Run(a log.Args) log.Result {
return log.Result{Written: a.Message != "", Level: a.Level}
}
`)
r := New()
if err := r.Register("log", dir); err != nil {
t.Fatalf("Register: %v", err)
}
flat, err := r.Invoke(context.Background(), "log", map[string]any{"message": "hello", "level": "info"})
if err != nil {
t.Fatalf("Invoke: %v", err)
}
decoded, err := r.DecodeResult("log", flat)
if err != nil {
t.Fatalf("DecodeResult: %v", err)
}
env := expr.NewEnv(expr.DeclaredResult{ID: "build", Type: reflect.TypeFor[log.Result]()})
prg, err := env.Compile(`actions.build.result.written`)
if err != nil {
t.Fatalf("Compile: %v", err)
}
got, err := env.Eval(prg, expr.Context{
Actions: map[string]map[string]any{
"build": {"result": decoded},
},
})
if err != nil {
t.Fatalf("Eval: %v", err)
}
if b, ok := got.(bool); !ok || !b {
t.Fatalf("Eval(actions.build.result.written) = %#v, want true", got)
}
}
func TestDecodeResultUnknownFieldIsError(t *testing.T) {
r := New()
_, err := r.DecodeResult("log", map[string]any{"written": true, "bogus": "x"})
if err == nil {
t.Fatal("DecodeResult(unknown field) = nil, want error")
}
for _, want := range []string{"bogus", "unknown result field"} {
if !strings.Contains(err.Error(), want) {
t.Errorf("DecodeResult error = %q, want it to contain %q", err.Error(), want)
}
}
}
func TestInvokePanicRecovered(t *testing.T) {
dir := t.TempDir()
writeModule(t, dir, `package main
import "github.com/samcharles93/archie-core/internal/domain/eda/module/log"
func Run(a log.Args) log.Result {
var s []string
return log.Result{Level: s[5]}
}
`)
r := New()
if err := r.Register("log", dir); err != nil {
t.Fatalf("Register: %v", err)
}
_, err := r.Invoke(context.Background(), "log", map[string]any{"message": "boom"})
if err == nil {
t.Fatal("Invoke(panicking module) = nil, want recovered error")
}
if !strings.Contains(err.Error(), "panicked") {
t.Errorf("Invoke panic error = %q, want recovered-panic text", err.Error())
}
}