@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/go/test/omnismoke_test.go

@@ -0,0 +1,112 @@
+// Smoke tests for the vendored omni runner itself: a runner that cannot
+// FAIL a bad entry would turn every corpus suite vacuously green, so pin
+// the failure paths, not just the happy one. (The go peer of
+// tm/ts/test/omni.test.ts.)
+
+package sdktest
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	sdk "GOMODULE"
+)
+
+// omniRecorder captures RunSet failures, so a test can assert that a
+// failure HAPPENED without itself failing - RunSet reports through
+// TestingT rather than returning an error.
+type omniRecorder struct {
+	failures []string
+}
+
+func (rec *omniRecorder) Helper() {}
+
+func (rec *omniRecorder) Error(args ...any) {
+	rec.failures = append(rec.failures, fmt.Sprint(args...))
+}
+
+// A minimal in-memory spec: no fixture file, no OMNI block (lenient v0,
+// like the shared corpus).
+func omniSmokeSpec() map[string]any {
+	return map[string]any{
+		"primary": map[string]any{
+			"smoke": map[string]any{
+				"basic": map[string]any{
+					"set": []any{
+						map[string]any{"in": 1, "out": 2},
+						map[string]any{"in": 41, "out": 42},
+					},
+				},
+				"bad": map[string]any{
+					"set": []any{
+						map[string]any{"in": 1, "out": 999},
+					},
+				},
+				"err": map[string]any{
+					"set": []any{
+						map[string]any{"in": 0, "err": "zero refused"},
+					},
+				},
+			},
+		},
+	}
+}
+
+func omniSmokeInc(n int) (any, error) {
+	if 0 == n {
+		return nil, errors.New("smoke: zero refused")
+	}
+	return n + 1, nil
+}
+
+func omniSmokeRun(t *testing.T) *RunPack {
+	t.Helper()
+	runner := MakeRunner(omniSmokeSpec(), sdk.TestSDK(nil, nil))
+	run, err := runner("smoke", nil)
+	if err != nil {
+		t.Fatalf("smoke runner failed to resolve: %v", err)
+	}
+	return run
+}
+
+func TestOmniRunner(t *testing.T) {
+
+	t.Run("runset passes a correct subject", func(t *testing.T) {
+		run := omniSmokeRun(t)
+		run.RunSet(t, run.Spec["basic"], omniSmokeInc)
+	})
+
+	t.Run("runset FAILS a wrong result", func(t *testing.T) {
+		run := omniSmokeRun(t)
+		rec := &omniRecorder{}
+
+		run.RunSet(rec, run.Spec["bad"], omniSmokeInc)
+
+		if 0 == len(rec.failures) {
+			t.Fatal("a wrong result went unreported - the corpus suites would be vacuously green")
+		}
+		if !strings.Contains(rec.failures[0], "result mismatch") {
+			t.Fatalf("expected a result mismatch failure, got: %s", rec.failures[0])
+		}
+	})
+
+	t.Run("an expected error is matched, an unexpected one fails", func(t *testing.T) {
+		run := omniSmokeRun(t)
+
+		run.RunSet(t, run.Spec["err"], omniSmokeInc)
+
+		rec := &omniRecorder{}
+		run.RunSet(rec, run.Spec["err"], func(n int) (any, error) {
+			return n, nil
+		})
+
+		if 0 == len(rec.failures) {
+			t.Fatal("a missing expected error went unreported")
+		}
+		if !strings.Contains(rec.failures[0], "expected error did not occur") {
+			t.Fatalf("expected an expected-error failure, got: %s", rec.failures[0])
+		}
+	})
+}

package/project/.sdk/tm/go/test/primary_utility_test.go

@@ -11,15 +11,55 @@ import (
 	vs "github.com/voxgig/struct"
 )
 
+// PENDING sections are the ones deliberately left empty in the shared corpus
+// (.sdk/test/primary/<name>.aon). Everything else MUST contribute cases.
+var pendingSections = map[string]bool{
+	"fetcher": true, "makeFetchDef": true, "makeResult": true,
+	"featureAdd": true, "featureHook": true, "featureInit": true,
+}
+
 func TestPrimaryUtility(t *testing.T) {
-	spec := loadTestSpec(t)
-	primary := getSpec(spec, "primary")
+	client := sdk.TestSDK(nil, nil)
+	utility := client.GetUtility()
+
+	// The corpus, through the vendored omni runner (see
+	// omniresolver_test.go). Subjects receive omni's native argument list:
+	// a ctx entry arrives as args[0], a MAP - omniCtx builds the typed
+	// context a generated utility takes, and omniSyncCtx writes the
+	// observable ctx state back for `match: {ctx: ...}` assertions.
+	runner := MakeRunner(TEST_JSON_FILE, client)
+	run, err := runner("primary", nil)
+	if err != nil {
+		t.Fatalf("Failed to make the corpus runner: %v", err)
+	}
+	primary := run.Spec
 	if primary == nil {
 		t.Fatal("primary section not found in test.json")
 	}
 
-	client := sdk.TestSDK(nil, nil)
-	utility := client.GetUtility()
+	// Run one corpus section, failing loudly when it would run ZERO cases.
+	// A renamed section, a fixture that failed to compile, or an empty set
+	// used to report PASS while running zero assertions - the whole point
+	// of a shared oracle lost without a single red test. (The guard lives
+	// here rather than in the runner, which is vendored verbatim; the
+	// shared corpus is a v0 spec, and v0 tolerates an empty set.)
+	runsection := func(t *testing.T, name string, subject any) {
+		t.Helper()
+		section, _ := primary[name].(map[string]any)
+		if section == nil {
+			t.Fatalf("test corpus section %q missing - check the name against .sdk/test/primary/", name)
+		}
+		basic, _ := section["basic"].(map[string]any)
+		set, ok := basic["set"].([]any)
+		if !ok {
+			t.Fatalf("test corpus section %q has no basic.set list - zero cases would run", name)
+		}
+		if 0 == len(set) && !pendingSections[name] {
+			t.Fatalf("test corpus section %q is EMPTY - zero cases would run; "+
+				"add cases, or mark the fixture PENDING in .sdk/test/primary/", name)
+		}
+		run.RunSet(t, basic, subject)
+	}
 
 	t.Run("exists", func(t *testing.T) {
 		if utility.Clean == nil {
@@ -121,36 +161,26 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("done-basic", func(t *testing.T) {
-		runsetNamed(t, "done", getSpec(primary, "done", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
-			fixctx(ctx, client)
+		runsection(t, "done", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			return utility.Done(ctx)
 		})
 	})
 
 	t.Run("makeError-basic", func(t *testing.T) {
-		runsetNamed(t, "makeError", getSpec(primary, "makeError", "basic"), func(entry map[string]any) (any, error) {
-			args, _ := entry["args"].([]any)
+		runsection(t, "makeError", func(args ...any) (any, error) {
 			if len(args) == 0 {
 				args = []any{map[string]any{}}
 			}
 
-			ctxmap, _ := args[0].(map[string]any)
-			if ctxmap == nil {
-				ctxmap = map[string]any{}
-			}
-			ctx := makeCtxFromMap(ctxmap, client, utility)
-			fixctx(ctx, client)
+			ctx := omniCtx(args[0], client, utility)
 
-			var err error
+			var errval error
 			if len(args) > 1 {
-				if errMap, ok := args[1].(map[string]any); ok {
-					err = errFromMap(errMap)
-				}
+				errval = omniErrArg(args[1])
 			}
 
-			return utility.MakeError(ctx, err)
+			return utility.MakeError(ctx, errval)
 		})
 	})
 
@@ -313,9 +343,8 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeContext-basic", func(t *testing.T) {
-		runsetNamed(t, "makeContext", getSpec(primary, "makeContext", "basic"), func(entry map[string]any) (any, error) {
-			in := entry["in"]
-			if inMap, ok := in.(map[string]any); ok {
+		runsection(t, "makeContext", func(args ...any) (any, error) {
+			if inMap, ok := args[0].(map[string]any); ok {
 				ctx := utility.MakeContext(inMap, nil)
 				out := map[string]any{
 					"id": ctx.Id,
@@ -402,8 +431,8 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeOptions-basic", func(t *testing.T) {
-		runsetNamed(t, "makeOptions", getSpec(primary, "makeOptions", "basic"), func(entry map[string]any) (any, error) {
-			in, _ := entry["in"].(map[string]any)
+		runsection(t, "makeOptions", func(args ...any) (any, error) {
+			in, _ := args[0].(map[string]any)
 			ctx := utility.MakeContext(map[string]any{
 				"options": in["options"],
 				"config":  in["config"],
@@ -415,9 +444,8 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeRequest-basic", func(t *testing.T) {
-		runsetNamed(t, "makeRequest", getSpec(primary, "makeRequest", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "makeRequest", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			ctx.Options = client.OptionsMap()
 
 			_, err := utility.MakeRequest(ctx)
@@ -425,41 +453,23 @@ func TestPrimaryUtility(t *testing.T) {
 				return nil, err
 			}
 
-			// Update entry ctx for match checking
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Response != nil {
-				entryCtx["response"] = "exists"
-			}
-			if ctx.Result != nil {
-				entryCtx["result"] = "exists"
-			}
+			// Expose response/result existence for the match assertions.
+			omniSyncCtx(args[0], ctx)
 
 			return nil, nil
 		})
 	})
 
 	t.Run("makeResponse-basic", func(t *testing.T) {
-		runsetNamed(t, "makeResponse", getSpec(primary, "makeResponse", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
-			fixctx(ctx, client)
+		runsection(t, "makeResponse", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 
 			_, err := utility.MakeResponse(ctx)
 			if err != nil {
 				return nil, err
 			}
 
-			// Update entry ctx for match checking with result data
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Result != nil {
-				entryCtx["result"] = map[string]any{
-					"ok":         ctx.Result.Ok,
-					"status":     ctx.Result.Status,
-					"statusText": ctx.Result.StatusText,
-					"headers":    ctx.Result.Headers,
-					"body":       ctx.Result.Body,
-				}
-			}
+			omniSyncCtx(args[0], ctx)
 
 			return nil, nil
 		})
@@ -528,9 +538,8 @@ func TestPrimaryUtility(t *testing.T) {
 		specClient := sdk.TestSDK(nil, setupOpts)
 		specUtility := specClient.GetUtility()
 
-		runsetNamed(t, "makeSpec", getSpec(primary, "makeSpec", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, specClient, specUtility)
+		runsection(t, "makeSpec", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], specClient, specUtility)
 			ctx.Options = specClient.OptionsMap()
 
 			_, err := utility.MakeSpec(ctx)
@@ -538,20 +547,7 @@ func TestPrimaryUtility(t *testing.T) {
 				return nil, err
 			}
 
-			// Update entry ctx for match
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Spec != nil {
-				entryCtx["spec"] = map[string]any{
-					"base":    ctx.Spec.Base,
-					"prefix":  ctx.Spec.Prefix,
-					"suffix":  ctx.Spec.Suffix,
-					"method":  ctx.Spec.Method,
-					"params":  ctx.Spec.Params,
-					"query":   ctx.Spec.Query,
-					"headers": ctx.Spec.Headers,
-					"step":    ctx.Spec.Step,
-				}
-			}
+			omniSyncCtx(args[0], ctx)
 
 			return nil, nil
 		})
@@ -568,11 +564,14 @@ func TestPrimaryUtility(t *testing.T) {
 	// corpus says `match: out: code` for both, so the error is normalised to a
 	// map carrying its code here rather than forking the fixture per language.
 	t.Run("makePoint-basic", func(t *testing.T) {
-		runsetNamed(t, "makePoint", getSpec(primary, "makePoint", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
+		runsection(t, "makePoint", func(args ...any) (any, error) {
+			ctxmap, _ := args[0].(map[string]any)
+			if ctxmap == nil {
+				ctxmap = map[string]any{}
+			}
 
 			// NewContext resolves Op from the ENTITY NAME, and reaches it
-			// through the Entity interface — a literal {name:...} map from the
+			// through the Entity interface - a literal {name:...} map from the
 			// fixture is not one, so entname would be "" and every lookup would
 			// miss, reporting point_no_points for all seven cases. TS reads the
 			// same field with getprop and accepts the plain map. Swap in the
@@ -588,7 +587,7 @@ func TestPrimaryUtility(t *testing.T) {
 				ctxmap = swapped
 			}
 
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+			ctx := omniCtx(ctxmap, client, utility)
 			point, err := utility.MakePoint(ctx)
 			if err != nil {
 				var sdkErr *sdk.ProjectNameError
@@ -602,9 +601,8 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeUrl-basic", func(t *testing.T) {
-		runsetNamed(t, "makeUrl", getSpec(primary, "makeUrl", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "makeUrl", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			if ctx.Result == nil {
 				ctx.Result = sdk.NewResult(map[string]any{})
 			}
@@ -613,58 +611,31 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("operator-basic", func(t *testing.T) {
-		runsetNamed(t, "operator", getSpec(primary, "operator", "basic"), func(entry map[string]any) (any, error) {
-			in, _ := entry["in"].(map[string]any)
+		runsection(t, "operator", func(args ...any) (any, error) {
+			in, _ := args[0].(map[string]any)
 			op := sdk.NewOperation(in)
 			return map[string]any{
-				"entity":  op.Entity,
-				"name":    op.Name,
-				"input":   op.Input,
+				"entity": op.Entity,
+				"name":   op.Name,
+				"input":  op.Input,
 				"points": op.Points,
 			}, nil
 		})
 	})
 
 	t.Run("param-basic", func(t *testing.T) {
-		runsetNamed(t, "param", getSpec(primary, "param", "basic"), func(entry map[string]any) (any, error) {
-			args, _ := entry["args"].([]any)
+		runsection(t, "param", func(args ...any) (any, error) {
 			if len(args) < 2 {
 				return nil, nil
 			}
 
-			ctxmap, _ := args[0].(map[string]any)
-			if ctxmap == nil {
-				ctxmap = map[string]any{}
-			}
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+			ctx := omniCtx(args[0], client, utility)
 			paramdef := args[1]
 
 			result := utility.Param(ctx, paramdef)
 
-			// Update entry ctx for match
-			if matchSpec, ok := entry["match"].(map[string]any); ok {
-				if ctxMatch, ok := matchSpec["ctx"].(map[string]any); ok {
-					entryCtx, _ := entry["ctx"].(map[string]any)
-					if entryCtx == nil {
-						entryCtx = map[string]any{}
-						entry["ctx"] = entryCtx
-					}
-					// Copy spec alias back to entry ctx for matching
-					if specMatch, ok := ctxMatch["spec"].(map[string]any); ok {
-						if ctx.Spec != nil {
-							if entryCtx["spec"] == nil {
-								entryCtx["spec"] = map[string]any{}
-							}
-							if aliasMatch, ok := specMatch["alias"].(map[string]any); ok {
-								_ = aliasMatch
-								entryCtx["spec"] = map[string]any{
-									"alias": ctx.Spec.Alias,
-								}
-							}
-						}
-					}
-				}
-			}
+			// The spec alias mutation is what mark 80 asserts on.
+			omniSyncCtx(args[0], ctx)
 
 			return result, nil
 		})
@@ -675,57 +646,51 @@ func TestPrimaryUtility(t *testing.T) {
 		authClient := sdk.TestSDK(nil, setupOpts)
 		authUtility := authClient.GetUtility()
 
-		runsetNamed(t, "prepareAuth", getSpec(primary, "prepareAuth", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, authClient, authUtility)
-			fixctx(ctx, authClient)
+		runsection(t, "prepareAuth", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], authClient, authUtility)
 
 			_, err := utility.PrepareAuth(ctx)
 			if err != nil {
 				return nil, err
 			}
 
-			// Update entry ctx for match
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Spec != nil {
-				entryCtx["spec"] = map[string]any{
-					"headers": ctx.Spec.Headers,
-				}
-			}
+			omniSyncCtx(args[0], ctx)
 
 			return nil, nil
 		})
 	})
 
 	t.Run("prepareBody-basic", func(t *testing.T) {
-		runsetNamed(t, "prepareBody", getSpec(primary, "prepareBody", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
-			fixctx(ctx, client)
+		runsection(t, "prepareBody", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			return utility.PrepareBody(ctx), nil
 		})
 	})
 
 	t.Run("prepareHeaders-basic", func(t *testing.T) {
-		runsetNamed(t, "prepareHeaders", getSpec(primary, "prepareHeaders", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "prepareHeaders", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			return utility.PrepareHeaders(ctx), nil
 		})
 	})
 
 	t.Run("prepareMethod-basic", func(t *testing.T) {
-		runsetNamed(t, "prepareMethod", getSpec(primary, "prepareMethod", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
-			return utility.PrepareMethod(ctx), nil
+		runsection(t, "prepareMethod", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
+			// An op the API does not define resolves NO method; ts answers
+			// undefined there and go answers "" - both are "no value" to
+			// the corpus.
+			method := utility.PrepareMethod(ctx)
+			if "" == method {
+				return nil, nil
+			}
+			return method, nil
 		})
 	})
 
 	t.Run("prepareParams-basic", func(t *testing.T) {
-		runsetNamed(t, "prepareParams", getSpec(primary, "prepareParams", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "prepareParams", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			return utility.PrepareParams(ctx), nil
 		})
 	})
@@ -735,38 +700,32 @@ func TestPrimaryUtility(t *testing.T) {
 	// the corpus like every other section, so all ports assert the same
 	// separator/blank-segment behaviour.
 	t.Run("preparePath-basic", func(t *testing.T) {
-		runsetNamed(t, "preparePath", getSpec(primary, "preparePath", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "preparePath", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			return utility.PreparePath(ctx), nil
 		})
 	})
 
 	t.Run("clean-corpus", func(t *testing.T) {
-		runsetNamed(t, "clean", getSpec(primary, "clean", "basic"), func(entry map[string]any) (any, error) {
-			args, _ := entry["args"].([]any)
+		runsection(t, "clean", func(args ...any) (any, error) {
 			if 2 != len(args) {
 				return nil, fmt.Errorf("clean: expected 2 args, got %d", len(args))
 			}
-			ctxmap, _ := args[0].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+			ctx := omniCtx(args[0], client, utility)
 			return utility.Clean(ctx, args[1]), nil
 		})
 	})
 
 	t.Run("prepareQuery-basic", func(t *testing.T) {
-		runsetNamed(t, "prepareQuery", getSpec(primary, "prepareQuery", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "prepareQuery", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 			return utility.PrepareQuery(ctx), nil
 		})
 	})
 
 	t.Run("resultBasic-basic", func(t *testing.T) {
-		runsetNamed(t, "resultBasic", getSpec(primary, "resultBasic", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
-			fixctx(ctx, client)
+		runsection(t, "resultBasic", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 
 			result := utility.ResultBasic(ctx)
 
@@ -785,76 +744,49 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("resultBody-basic", func(t *testing.T) {
-		runsetNamed(t, "resultBody", getSpec(primary, "resultBody", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "resultBody", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 
 			utility.ResultBody(ctx)
 
-			// Update entry ctx for match
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Result != nil {
-				entryCtx["result"] = map[string]any{
-					"body": ctx.Result.Body,
-				}
-			}
+			omniSyncCtx(args[0], ctx)
 
 			return nil, nil
 		})
 	})
 
 	t.Run("resultHeaders-basic", func(t *testing.T) {
-		runsetNamed(t, "resultHeaders", getSpec(primary, "resultHeaders", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "resultHeaders", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 
 			utility.ResultHeaders(ctx)
 
-			// Update entry ctx for match
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Result != nil {
-				entryCtx["result"] = map[string]any{
-					"headers": ctx.Result.Headers,
-				}
-			}
+			omniSyncCtx(args[0], ctx)
 
 			return nil, nil
 		})
 	})
 
 	t.Run("transformRequest-basic", func(t *testing.T) {
-		runsetNamed(t, "transformRequest", getSpec(primary, "transformRequest", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "transformRequest", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 
 			result := utility.TransformRequest(ctx)
 
-			// Update entry ctx for match (step changed)
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Spec != nil {
-				if specMap, ok := entryCtx["spec"].(map[string]any); ok {
-					specMap["step"] = ctx.Spec.Step
-				}
-			}
+			// The step advance is what the match assertion reads.
+			omniSyncCtx(args[0], ctx)
 
 			return result, nil
 		})
 	})
 
 	t.Run("transformResponse-basic", func(t *testing.T) {
-		runsetNamed(t, "transformResponse", getSpec(primary, "transformResponse", "basic"), func(entry map[string]any) (any, error) {
-			ctxmap, _ := entry["ctx"].(map[string]any)
-			ctx := makeCtxFromMap(ctxmap, client, utility)
+		runsection(t, "transformResponse", func(args ...any) (any, error) {
+			ctx := omniCtx(args[0], client, utility)
 
 			result := utility.TransformResponse(ctx)
 
-			// Update entry ctx for match (step changed)
-			entryCtx, _ := entry["ctx"].(map[string]any)
-			if ctx.Spec != nil {
-				if specMap, ok := entryCtx["spec"].(map[string]any); ok {
-					specMap["step"] = ctx.Spec.Step
-				}
-			}
+			omniSyncCtx(args[0], ctx)
 
 			return result, nil
 		})