209 lines
5.7 KiB
Go
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())
|
|
}
|
|
}
|