Refactor test scaffolding for capability and recursion suites

vibes/call_concurrency_test.go

@@ -42,18 +42,14 @@ type callResult struct {
 }
 
 func TestScriptCallOverlappingCallsKeepFunctionEnvIsolated(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def helper
+	script := compileScriptDefault(t, `def helper
   tenant
 end
 
 def run
   sync.wait()
   helper
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	barrier := &blockingSync{
 		entered: make(chan struct{}, 1),
@@ -108,8 +104,7 @@ end`)
 }
 
 func TestScriptCallOverlappingCallsKeepClassVarsIsolated(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`class Counter
+	script := compileScriptDefault(t, `class Counter
   @@count = 0
 
   def self.bump
@@ -126,9 +121,6 @@ def run
   Counter.bump
   Counter.count
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	barrier := &blockingSync{
 		entered: make(chan struct{}, 1),
@@ -181,8 +173,7 @@ end`)
 }
 
 func TestScriptCallRebindsEscapedFunctionsToCurrentCallEnv(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def format_tenant(value)
+	script := compileScriptDefault(t, `def format_tenant(value)
   tenant + "-" + value
 end
 
@@ -193,9 +184,6 @@ end
 def run_with(fn, value)
   fn(value)
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	exported, err := script.Call(context.Background(), "export_fn", nil, CallOptions{
 		Globals: map[string]Value{
@@ -223,8 +211,7 @@ end`)
 }
 
 func TestScriptCallRebindingDoesNotMutateSharedArgMaps(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def format_tenant(value)
+	script := compileScriptDefault(t, `def format_tenant(value)
   tenant + "-" + value
 end
 
@@ -236,9 +223,6 @@ def run(ctx)
   sync.wait()
   ctx.fn("value")
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	exported, err := script.Call(context.Background(), "export_fn", nil, CallOptions{
 		Globals: map[string]Value{
@@ -311,7 +295,7 @@ end`)
 func TestScriptCallPreservesForeignFunctionEnv(t *testing.T) {
 	engine := MustNewEngine(Config{})
 
-	producer, err := engine.Compile(`def helper(value)
+	producer := compileScriptWithEngine(t, engine, `def helper(value)
   "foreign-" + value
 end
 
@@ -322,16 +306,10 @@ end
 def export_fn
   wrapper
 end`)
-	if err != nil {
-		t.Fatalf("compile producer failed: %v", err)
-	}
 
-	consumer, err := engine.Compile(`def run_with(fn, value)
+	consumer := compileScriptWithEngine(t, engine, `def run_with(fn, value)
   fn(value)
 end`)
-	if err != nil {
-		t.Fatalf("compile consumer failed: %v", err)
-	}
 
 	foreignFn, err := producer.Call(context.Background(), "export_fn", nil, CallOptions{})
 	if err != nil {
@@ -351,8 +329,7 @@ end`)
 }
 
 func TestScriptCallRebindsEscapedClassValuesToCurrentCall(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`class Bucket
+	script := compileScriptDefault(t, `class Bucket
   @@count = 0
 
   def self.bump
@@ -373,9 +350,6 @@ def run_with(klass)
   klass.bump
   klass.snapshot
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	exportedClass, err := script.Call(context.Background(), "export_class", nil, CallOptions{
 		Globals: map[string]Value{
@@ -410,8 +384,7 @@ end`)
 }
 
 func TestScriptCallRebindsEscapedInstancesToCurrentCallState(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`class Bucket
+	script := compileScriptDefault(t, `class Bucket
   @@count = 0
 
   def initialize(name)
@@ -431,9 +404,6 @@ end
 def run_with(bucket)
   bucket.report
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	exportedInstance, err := script.Call(context.Background(), "export_instance", []Value{NewString("seed")}, CallOptions{
 		Globals: map[string]Value{
@@ -471,13 +441,9 @@ end`)
 }
 
 func TestScriptCallRebindingPreservesHashAndObjectKindsForAliasedMaps(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def run(a, b)
+	script := compileScriptDefault(t, `def run(a, b)
   [a, b]
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	shared := map[string]Value{"x": NewInt(1)}
 	hashVal := NewHash(shared)

vibes/capability_common_test.go

@@ -1,7 +1,6 @@
 package vibes
 
 import (
-	"strings"
 	"testing"
 )
 
@@ -26,9 +25,7 @@ func TestValidateCapabilityTypedValueUsesCompositeTypeChecks(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected composite type mismatch")
 	}
-	if !strings.Contains(err.Error(), "payload expected array<int | string>, got array<bool | int>") {
-		t.Fatalf("unexpected composite type mismatch: %v", err)
-	}
+	requireErrorContains(t, err, "payload expected array<int | string>, got array<bool | int>")
 }
 
 func TestValidateCapabilityTypedValueUsesShapeTypeChecks(t *testing.T) {
@@ -50,7 +47,5 @@ func TestValidateCapabilityTypedValueUsesShapeTypeChecks(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected shape type mismatch")
 	}
-	if !strings.Contains(err.Error(), "payload expected { id: string }, got { extra: int, id: string }") {
-		t.Fatalf("unexpected shape type mismatch: %v", err)
-	}
+	requireErrorContains(t, err, "payload expected { id: string }, got { extra: int, id: string }")
 }

vibes/capability_context_test.go

@@ -2,18 +2,13 @@ package vibes
 
 import (
 	"context"
-	"strings"
 	"testing"
 )
 
 func TestContextCapabilityResolver(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def run()
+	script := compileScriptDefault(t, `def run()
   ctx.user.id
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	type ctxKey string
 	resolver := func(ctx context.Context) (Value, error) {
@@ -30,25 +25,18 @@ end`)
 	ctx := context.WithValue(context.Background(), ctxKey("user_id"), "player-1")
 	ctx = context.WithValue(ctx, ctxKey("role"), "coach")
 
-	result, err := script.Call(ctx, "run", nil, CallOptions{
-		Capabilities: []CapabilityAdapter{MustNewContextCapability("ctx", resolver)},
-	})
-	if err != nil {
-		t.Fatalf("call failed: %v", err)
-	}
+	result := callScript(t, ctx, script, "run", nil, callOptionsWithCapabilities(
+		MustNewContextCapability("ctx", resolver),
+	))
 	if result.Kind() != KindString || result.String() != "player-1" {
 		t.Fatalf("unexpected result: %#v", result)
 	}
 }
 
 func TestContextCapabilityRejectsCallableValue(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def run()
+	script := compileScriptDefault(t, `def run()
   ctx.user.id
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	resolver := func(ctx context.Context) (Value, error) {
 		return NewObject(map[string]Value{
@@ -61,74 +49,50 @@ end`)
 		}), nil
 	}
 
-	_, err = script.Call(context.Background(), "run", nil, CallOptions{
-		Capabilities: []CapabilityAdapter{MustNewContextCapability("ctx", resolver)},
-	})
-	if err == nil {
-		t.Fatalf("expected callable context data error")
-	}
-	if got := err.Error(); !strings.Contains(got, "ctx capability value must be data-only") {
-		t.Fatalf("unexpected error: %s", got)
-	}
+	err := callScriptErr(t, context.Background(), script, "run", nil, callOptionsWithCapabilities(
+		MustNewContextCapability("ctx", resolver),
+	))
+	requireErrorContains(t, err, "ctx capability value must be data-only")
 }
 
 func TestContextCapabilityRejectsNonObjectValue(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def run()
+	script := compileScriptDefault(t, `def run()
   1
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	resolver := func(ctx context.Context) (Value, error) {
 		return NewString("invalid"), nil
 	}
 
-	_, err = script.Call(context.Background(), "run", nil, CallOptions{
-		Capabilities: []CapabilityAdapter{MustNewContextCapability("ctx", resolver)},
-	})
-	if err == nil {
-		t.Fatalf("expected resolver shape error")
-	}
-	if got := err.Error(); !strings.Contains(got, "ctx capability resolver must return hash/object") {
-		t.Fatalf("unexpected error: %s", got)
-	}
+	err := callScriptErr(t, context.Background(), script, "run", nil, callOptionsWithCapabilities(
+		MustNewContextCapability("ctx", resolver),
+	))
+	requireErrorContains(t, err, "ctx capability resolver must return hash/object")
 }
 
 func TestContextCapabilityRejectsCyclicValue(t *testing.T) {
-	engine := MustNewEngine(Config{})
-	script, err := engine.Compile(`def run()
+	script := compileScriptDefault(t, `def run()
   ctx
 end`)
-	if err != nil {
-		t.Fatalf("compile failed: %v", err)
-	}
 
 	resolver := func(context.Context) (Value, error) {
 		cyclic := map[string]Value{}
 		cyclic["self"] = NewHash(cyclic)
 		return NewHash(cyclic), nil
 	}
 
-	_, err = script.Call(context.Background(), "run", nil, CallOptions{
-		Capabilities: []CapabilityAdapter{MustNewContextCapability("ctx", resolver)},
-	})
-	if err == nil {
-		t.Fatalf("expected cyclic value error")
-	}
-	if got := err.Error(); !strings.Contains(got, "ctx capability value must not contain cyclic references") {
-		t.Fatalf("unexpected error: %s", got)
-	}
+	err := callScriptErr(t, context.Background(), script, "run", nil, callOptionsWithCapabilities(
+		MustNewContextCapability("ctx", resolver),
+	))
+	requireErrorContains(t, err, "ctx capability value must not contain cyclic references")
 }
 
 func TestNewContextCapabilityRejectsInvalidArguments(t *testing.T) {
 	resolver := func(context.Context) (Value, error) { return NewObject(map[string]Value{}), nil }
 
-	if _, err := NewContextCapability("", resolver); err == nil || !strings.Contains(err.Error(), "name must be non-empty") {
-		t.Fatalf("expected empty name error, got %v", err)
-	}
-	if _, err := NewContextCapability("ctx", nil); err == nil || !strings.Contains(err.Error(), "requires a resolver") {
-		t.Fatalf("expected nil resolver error, got %v", err)
-	}
+	_, err := NewContextCapability("", resolver)
+	requireErrorContains(t, err, "name must be non-empty")
+
+	_, err = NewContextCapability("ctx", nil)
+	requireErrorContains(t, err, "requires a resolver")
 }