@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/java/test/PrimaryUtilityTest.java

@@ -1,8 +1,14 @@
 package JAVAPACKAGE.sdktest;
 
 // Drives the primary utility functions against the shared test.json spec
-// (../.sdk/test/test.json, section "primary"). Mirrors
+// (../.sdk/test/test.json, section "primary") through the VENDORED omni
+// runner (OmniResolver over test/vendor/omni). Mirrors
 // tm/go/test/primary_utility_test.go.
+//
+// Subjects receive omni's native argument list: a ctx entry arrives as
+// args[0], a MAP - OmniResolver.omniCtx builds the typed Context a
+// generated utility takes, and OmniResolver.omniSyncCtx writes the
+// observable ctx state back for `match: {ctx: ...}` assertions.
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -12,24 +18,23 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import static JAVAPACKAGE.sdktest.FeatureHarness.fhMap;
-import static JAVAPACKAGE.sdktest.RunnerSupport.getSpec;
-import static JAVAPACKAGE.sdktest.RunnerSupport.loadTestSpec;
-import static JAVAPACKAGE.sdktest.RunnerSupport.makeCtxFromMap;
-import static JAVAPACKAGE.sdktest.RunnerSupport.runset;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.BiFunction;
 
 import org.junit.jupiter.api.Test;
 
 import JAVAPACKAGE.core.Context;
+import JAVAPACKAGE.core.Entity;
 import JAVAPACKAGE.core.Helpers;
 import JAVAPACKAGE.core.Operation;
 import JAVAPACKAGE.core.ProjectNameSDK;
 import JAVAPACKAGE.core.Result;
+import JAVAPACKAGE.core.SdkError;
 import JAVAPACKAGE.core.Spec;
 import JAVAPACKAGE.core.Utility;
 import JAVAPACKAGE.feature.BaseFeature;
@@ -37,15 +42,62 @@ import JAVAPACKAGE.feature.BaseFeature;
 @SuppressWarnings({"unchecked"})
 public class PrimaryUtilityTest {
 
-  static Map<String, Object> primary() {
-    Map<String, Object> spec = loadTestSpec();
-    Map<String, Object> primary = getSpec(spec, "primary");
-    assertNotNull(primary, "primary section not found in test.json");
-    return primary;
+  static final String TEST_JSON_FILE = "../.sdk/test/test.json";
+
+  // PENDING sections are the ones deliberately left empty in the shared
+  // corpus (.sdk/test/primary/<name>.aon). Everything else MUST contribute
+  // cases.
+  static final Set<String> PENDING = Set.of(
+      "fetcher", "makeFetchDef", "makeResult",
+      "featureAdd", "featureHook", "featureInit");
+
+  // One client + one corpus runner for the whole suite (the go shape).
+  private static ProjectNameSDK CLIENT;
+  private static Utility UTILITY;
+  private static OmniResolver.Run RUN;
+
+  static synchronized OmniResolver.Run run() {
+    if (RUN == null) {
+      CLIENT = ProjectNameSDK.testSDK();
+      UTILITY = CLIENT.getUtility();
+      RUN = OmniResolver.makeRunner(TEST_JSON_FILE, CLIENT).runner("primary", null);
+      assertNotNull(RUN.spec, "primary section not found in test.json");
+    }
+    return RUN;
   }
 
   static ProjectNameSDK client() {
-    return ProjectNameSDK.testSDK();
+    run();
+    return CLIENT;
+  }
+
+  static Utility utility() {
+    run();
+    return UTILITY;
+  }
+
+  // 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.)
+  static void runsection(String name, OmniResolver.Subject subject) {
+    OmniResolver.Run run = run();
+    Map<String, Object> section = Helpers.toMapAny(run.spec.get(name));
+    assertNotNull(section, "test corpus section \"" + name
+        + "\" missing - check the name against .sdk/test/primary/");
+    Map<String, Object> basic = Helpers.toMapAny(section.get("basic"));
+    Object set = basic == null ? null : basic.get("set");
+    if (!(set instanceof List)) {
+      fail("test corpus section \"" + name
+          + "\" has no basic.set list - zero cases would run");
+    }
+    if (((List<Object>) set).isEmpty() && !PENDING.contains(name)) {
+      fail("test corpus section \"" + name + "\" is EMPTY - zero cases "
+          + "would run; add cases, or mark the fixture PENDING in .sdk/test/primary/");
+    }
+    run.runset(basic, subject);
   }
 
   // Helper: create basic test context.
@@ -86,8 +138,7 @@ public class PrimaryUtilityTest {
 
   @Test
   public void exists() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
 
     assertNotNull(utility.clean, "clean");
     assertNotNull(utility.done, "done");
@@ -123,55 +174,53 @@ public class PrimaryUtilityTest {
   @Test
   public void cleanBasic() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestCtx(client, utility, null);
     Object cleaned = utility.clean.apply(ctx, fhMap("key", "secret123", "name", "test"));
     assertNotNull(cleaned, "cleaned should not be null");
   }
 
+  @Test
+  public void cleanCorpus() {
+    runsection("clean", (args) -> {
+      if (2 != args.length) {
+        throw new RuntimeException("clean: expected 2 args, got " + args.length);
+      }
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().clean.apply(ctx, args[1]);
+    });
+  }
+
   @Test
   public void doneBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "done", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      RunnerSupport.fixctx(ctx, client);
-      return utility.done.apply(ctx);
+    runsection("done", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().done.apply(ctx);
     });
   }
 
   @Test
   public void makeErrorBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "makeError", "basic"), (entry) -> {
-      List<Object> args = entry.get("args") instanceof List
-          ? (List<Object>) entry.get("args") : new ArrayList<>();
-      if (args.isEmpty()) {
-        args.add(new LinkedHashMap<String, Object>());
+    runsection("makeError", (args) -> {
+      if (0 == args.length) {
+        args = new Object[] { new LinkedHashMap<String, Object>() };
       }
 
-      Map<String, Object> ctxmap = Helpers.toMapAny(args.get(0));
-      if (ctxmap == null) {
-        ctxmap = new LinkedHashMap<>();
-      }
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      RunnerSupport.fixctx(ctx, client);
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
 
       RuntimeException err = null;
-      if (args.size() > 1) {
-        err = RunnerSupport.errFromMap(Helpers.toMapAny(args.get(1)));
+      if (args.length > 1) {
+        err = RunnerSupport.errFromMap(Helpers.toMapAny(args[1]));
       }
 
-      return utility.makeError.apply(ctx, err);
+      return utility().makeError.apply(ctx, err);
     });
   }
 
   @Test
   public void makeErrorNoThrow() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestFullCtx(client, utility);
     ctx.ctrl.throwing = false;
     Map<String, Object> resmap = new LinkedHashMap<>();
@@ -189,7 +238,7 @@ public class PrimaryUtilityTest {
   @Test
   public void featureAddBasic() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestCtx(client, utility, null);
     int startLen = client.features.size();
 
@@ -210,7 +259,7 @@ public class PrimaryUtilityTest {
 
   @Test
   public void featureHookBasic() {
-    ProjectNameSDK hookClient = client();
+    ProjectNameSDK hookClient = ProjectNameSDK.testSDK();
     Utility hookUtility = hookClient.getUtility();
     Context ctx = makeTestCtx(hookClient, hookUtility, null);
 
@@ -236,7 +285,7 @@ public class PrimaryUtilityTest {
 
   @Test
   public void featureInitBasic() {
-    ProjectNameSDK initClient = client();
+    ProjectNameSDK initClient = ProjectNameSDK.testSDK();
     Utility initUtility = initClient.getUtility();
     Context ctx = makeTestCtx(initClient, initUtility, null);
     ctx.options.put("feature", fhMap("initfeat", fhMap("active", true)));
@@ -253,7 +302,7 @@ public class PrimaryUtilityTest {
 
   @Test
   public void featureInitInactive() {
-    ProjectNameSDK initClient = client();
+    ProjectNameSDK initClient = ProjectNameSDK.testSDK();
     Utility initUtility = initClient.getUtility();
     Context ctx = makeTestCtx(initClient, initUtility, null);
     ctx.options.put("feature", fhMap("nofeat", fhMap("active", false)));
@@ -329,12 +378,10 @@ public class PrimaryUtilityTest {
 
   @Test
   public void makeContextBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "makeContext", "basic"), (entry) -> {
-      Map<String, Object> in = Helpers.toMapAny(entry.get("in"));
+    runsection("makeContext", (args) -> {
+      Map<String, Object> in = Helpers.toMapAny(args[0]);
       if (in != null) {
-        Context ctx = utility.makeContext.apply(in, null);
+        Context ctx = utility().makeContext.apply(in, null);
         Map<String, Object> out = new LinkedHashMap<>();
         out.put("id", ctx.id);
         if (ctx.op != null) {
@@ -349,7 +396,7 @@ public class PrimaryUtilityTest {
   @Test
   public void makeFetchDefBasic() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestFullCtx(client, utility);
     ctx.spec = new Spec(fhMap(
         "base", "http://localhost:8080",
@@ -376,7 +423,7 @@ public class PrimaryUtilityTest {
   @Test
   public void makeFetchDefWithBody() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestFullCtx(client, utility);
     ctx.spec = new Spec(fhMap(
         "base", "http://localhost:8080",
@@ -401,43 +448,30 @@ public class PrimaryUtilityTest {
 
   @Test
   public void makeOptionsBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "makeOptions", "basic"), (entry) -> {
-      Map<String, Object> in = Helpers.toMapAny(entry.get("in"));
+    runsection("makeOptions", (args) -> {
+      Map<String, Object> in = Helpers.toMapAny(args[0]);
       Map<String, Object> ctxmap = new LinkedHashMap<>();
       if (in != null) {
         ctxmap.put("options", in.get("options"));
         ctxmap.put("config", in.get("config"));
       }
-      Context ctx = utility.makeContext.apply(ctxmap, null);
-      ctx.client = client;
-      ctx.utility = utility;
-      return utility.makeOptions.apply(ctx);
+      Context ctx = utility().makeContext.apply(ctxmap, null);
+      ctx.client = client();
+      ctx.utility = utility();
+      return utility().makeOptions.apply(ctx);
     });
   }
 
   @Test
   public void makeRequestBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "makeRequest", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      ctx.options = client.optionsMap();
-
-      utility.makeRequest.apply(ctx);
-
-      // Update entry ctx for match checking.
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null) {
-        if (ctx.response != null) {
-          entryCtx.put("response", "exists");
-        }
-        if (ctx.result != null) {
-          entryCtx.put("result", "exists");
-        }
-      }
+    runsection("makeRequest", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      ctx.options = client().optionsMap();
+
+      utility().makeRequest.apply(ctx);
+
+      // Expose response/result existence for the match assertions.
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return null;
     });
@@ -445,25 +479,12 @@ public class PrimaryUtilityTest {
 
   @Test
   public void makeResponseBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "makeResponse", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      RunnerSupport.fixctx(ctx, client);
-
-      utility.makeResponse.apply(ctx);
-
-      // Update entry ctx for match checking with result data.
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.result != null) {
-        entryCtx.put("result", fhMap(
-            "ok", ctx.result.ok,
-            "status", ctx.result.status,
-            "statusText", ctx.result.statusText,
-            "headers", ctx.result.headers,
-            "body", ctx.result.body));
-      }
+    runsection("makeResponse", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+
+      utility().makeResponse.apply(ctx);
+
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return null;
     });
@@ -472,7 +493,7 @@ public class PrimaryUtilityTest {
   @Test
   public void makeResultBasic() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestFullCtx(client, utility);
     ctx.spec = new Spec(fhMap(
         "base", "http://localhost:8080",
@@ -498,7 +519,7 @@ public class PrimaryUtilityTest {
   @Test
   public void makeResultNoSpec() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestFullCtx(client, utility);
     ctx.spec = null;
     ctx.result = new Result(fhMap(
@@ -517,7 +538,7 @@ public class PrimaryUtilityTest {
   @Test
   public void makeResultNoResult() {
     ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
+    Utility utility = utility();
     Context ctx = makeTestFullCtx(client, utility);
     ctx.spec = new Spec(fhMap("step", "start"));
     ctx.result = null;
@@ -533,75 +554,101 @@ public class PrimaryUtilityTest {
 
   @Test
   public void makeSpecBasic() {
-    Map<String, Object> setupOpts = getSpec(primary(), "makeSpec", "DEF", "setup", "a");
+    Map<String, Object> setupOpts =
+        RunnerSupport.getSpec(run().spec, "makeSpec", "DEF", "setup", "a");
     ProjectNameSDK specClient = ProjectNameSDK.testSDK(null, setupOpts);
     Utility specUtility = specClient.getUtility();
 
-    runset(getSpec(primary(), "makeSpec", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, specClient, specUtility);
+    runsection("makeSpec", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], specClient, specUtility);
       ctx.options = specClient.optionsMap();
 
       specUtility.makeSpec.apply(ctx);
 
-      // Update entry ctx for match.
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.spec != null) {
-        entryCtx.put("spec", fhMap(
-            "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));
-      }
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return null;
     });
   }
 
+  // A minimal Entity: Context resolves the op through the Entity
+  // interface, and a literal {name: ...} map from the fixture is not one -
+  // 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. (The go peer is plEntity.)
+  static final class PlEntity implements Entity {
+    private final String name;
+
+    PlEntity(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String getName() {
+      return name;
+    }
+
+    @Override
+    public Entity make() {
+      return new PlEntity(name);
+    }
+
+    @Override
+    public Object data(Object... args) {
+      return null;
+    }
+
+    @Override
+    public Object match(Object... args) {
+      return null;
+    }
+  }
+
+  // Corpus-driven, like go: TS returns the error AS the value; java throws
+  // SdkError. The 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.
   @Test
   public void makePointBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    Context ctx = makeTestCtx(client, utility, null);
-    List<Object> parts = new ArrayList<>();
-    parts.add("items");
-    parts.add("{id}");
-    Map<String, Object> point = fhMap(
-        "parts", parts,
-        "args", fhMap("params", new ArrayList<>()),
-        "params", new ArrayList<>(),
-        "alias", new LinkedHashMap<>(),
-        "select", new LinkedHashMap<>(),
-        "active", true,
-        "transform", new LinkedHashMap<>());
-    ctx.op.points = new ArrayList<>(List.of(point));
+    runsection("makePoint", (args) -> {
+      Map<String, Object> ctxmap = Helpers.toMapAny(args[0]);
+      if (ctxmap == null) {
+        ctxmap = new LinkedHashMap<>();
+      }
+
+      Map<String, Object> em = Helpers.toMapAny(ctxmap.get("entity"));
+      if (em != null) {
+        String name = em.get("name") instanceof String ? (String) em.get("name") : "";
+        Map<String, Object> swapped = new LinkedHashMap<>(ctxmap);
+        swapped.put("entity", new PlEntity(name));
+        ctxmap = swapped;
+      }
 
-    utility.makePoint.apply(ctx);
-    assertNotNull(ctx.point, "expected point to be set");
+      Context ctx = OmniResolver.omniCtx(ctxmap, client(), utility());
+      try {
+        return utility().makePoint.apply(ctx);
+      }
+      catch (SdkError e) {
+        return fhMap("code", e.code);
+      }
+    });
   }
 
   @Test
   public void makeUrlBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "makeUrl", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
+    runsection("makeUrl", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
       if (ctx.result == null) {
         ctx.result = new Result(new LinkedHashMap<>());
       }
-      return utility.makeUrl.apply(ctx);
+      return utility().makeUrl.apply(ctx);
     });
   }
 
   @Test
   public void operatorBasic() {
-    runset(getSpec(primary(), "operator", "basic"), (entry) -> {
-      Map<String, Object> in = Helpers.toMapAny(entry.get("in"));
+    runsection("operator", (args) -> {
+      Map<String, Object> in = Helpers.toMapAny(args[0]);
       Operation op = new Operation(in == null ? new LinkedHashMap<>() : in);
       return fhMap(
           "entity", op.entity,
@@ -613,41 +660,18 @@ public class PrimaryUtilityTest {
 
   @Test
   public void paramBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "param", "basic"), (entry) -> {
-      List<Object> args = entry.get("args") instanceof List
-          ? (List<Object>) entry.get("args") : new ArrayList<>();
-      if (args.size() < 2) {
+    runsection("param", (args) -> {
+      if (args.length < 2) {
         return null;
       }
 
-      Map<String, Object> ctxmap = Helpers.toMapAny(args.get(0));
-      if (ctxmap == null) {
-        ctxmap = new LinkedHashMap<>();
-      }
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      Object paramdef = args.get(1);
-
-      Object result = utility.param.apply(ctx, paramdef);
-
-      // Copy spec alias back to entry ctx for matching.
-      Map<String, Object> matchSpec = Helpers.toMapAny(entry.get("match"));
-      if (matchSpec != null) {
-        Map<String, Object> ctxMatch = Helpers.toMapAny(matchSpec.get("ctx"));
-        if (ctxMatch != null) {
-          Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-          if (entryCtx == null) {
-            entryCtx = new LinkedHashMap<>();
-            entry.put("ctx", entryCtx);
-          }
-          Map<String, Object> specMatch = Helpers.toMapAny(ctxMatch.get("spec"));
-          if (specMatch != null && ctx.spec != null
-              && specMatch.get("alias") instanceof Map) {
-            entryCtx.put("spec", fhMap("alias", ctx.spec.alias));
-          }
-        }
-      }
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      Object paramdef = args[1];
+
+      Object result = utility().param.apply(ctx, paramdef);
+
+      // The spec alias mutation is what mark 80 asserts on.
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return result;
     });
@@ -655,22 +679,17 @@ public class PrimaryUtilityTest {
 
   @Test
   public void prepareAuthBasic() {
-    Map<String, Object> setupOpts = getSpec(primary(), "prepareAuth", "DEF", "setup", "a");
+    Map<String, Object> setupOpts =
+        RunnerSupport.getSpec(run().spec, "prepareAuth", "DEF", "setup", "a");
     ProjectNameSDK authClient = ProjectNameSDK.testSDK(null, setupOpts);
     Utility authUtility = authClient.getUtility();
 
-    runset(getSpec(primary(), "prepareAuth", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, authClient, authUtility);
-      RunnerSupport.fixctx(ctx, authClient);
+    runsection("prepareAuth", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], authClient, authUtility);
 
       authUtility.prepareAuth.apply(ctx);
 
-      // Update entry ctx for match.
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.spec != null) {
-        entryCtx.put("spec", fhMap("headers", ctx.spec.headers));
-      }
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return null;
     });
@@ -678,83 +697,69 @@ public class PrimaryUtilityTest {
 
   @Test
   public void prepareBodyBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "prepareBody", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      RunnerSupport.fixctx(ctx, client);
-      return utility.prepareBody.apply(ctx);
+    runsection("prepareBody", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().prepareBody.apply(ctx);
     });
   }
 
   @Test
   public void prepareHeadersBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "prepareHeaders", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      return utility.prepareHeaders.apply(ctx);
+    runsection("prepareHeaders", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().prepareHeaders.apply(ctx);
     });
   }
 
   @Test
   public void prepareMethodBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "prepareMethod", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      return utility.prepareMethod.apply(ctx);
+    runsection("prepareMethod", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      // An op the API does not define resolves NO method; ts answers
+      // undefined there and java answers null - both are "no value" to
+      // the corpus.
+      String method = utility().prepareMethod.apply(ctx);
+      if (method == null || method.isEmpty()) {
+        return null;
+      }
+      return method;
     });
   }
 
   @Test
   public void prepareParamsBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "prepareParams", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      return utility.prepareParams.apply(ctx);
+    runsection("prepareParams", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().prepareParams.apply(ctx);
     });
   }
 
+  // Was two hand-written cases that had drifted out of the shared corpus
+  // (the preparePath fixture shipped as an empty `set: []`). Now driven by
+  // the corpus like every other section, so all ports assert the same
+  // separator/blank-segment behaviour.
   @Test
   public void preparePathBasic() {
-    // Was two hand-written cases that had drifted out of the shared corpus
-    // (the preparePath fixture shipped as an empty `set: []`).
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "preparePath", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      return utility.preparePath.apply(ctx);
+    runsection("preparePath", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().preparePath.apply(ctx);
     });
   }
 
   @Test
   public void prepareQueryBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "prepareQuery", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      return utility.prepareQuery.apply(ctx);
+    runsection("prepareQuery", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+      return utility().prepareQuery.apply(ctx);
     });
   }
 
   @Test
   public void resultBasicBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "resultBasic", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-      RunnerSupport.fixctx(ctx, client);
+    runsection("resultBasic", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
 
-      Result result = utility.resultBasic.apply(ctx);
+      Result result = utility().resultBasic.apply(ctx);
 
       Map<String, Object> out = fhMap(
           "status", result.status,
@@ -769,18 +774,12 @@ public class PrimaryUtilityTest {
 
   @Test
   public void resultBodyBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "resultBody", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
+    runsection("resultBody", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
 
-      utility.resultBody.apply(ctx);
+      utility().resultBody.apply(ctx);
 
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.result != null) {
-        entryCtx.put("result", fhMap("body", ctx.result.body));
-      }
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return null;
     });
@@ -788,18 +787,12 @@ public class PrimaryUtilityTest {
 
   @Test
   public void resultHeadersBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "resultHeaders", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
+    runsection("resultHeaders", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
 
-      utility.resultHeaders.apply(ctx);
+      utility().resultHeaders.apply(ctx);
 
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.result != null) {
-        entryCtx.put("result", fhMap("headers", ctx.result.headers));
-      }
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return null;
     });
@@ -807,22 +800,13 @@ public class PrimaryUtilityTest {
 
   @Test
   public void transformRequestBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "transformRequest", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-
-      Object result = utility.transformRequest.apply(ctx);
-
-      // Update entry ctx for match (step changed).
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.spec != null) {
-        Map<String, Object> specMap = Helpers.toMapAny(entryCtx.get("spec"));
-        if (specMap != null) {
-          specMap.put("step", ctx.spec.step);
-        }
-      }
+    runsection("transformRequest", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+
+      Object result = utility().transformRequest.apply(ctx);
+
+      // The step advance is what the match assertion reads.
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return result;
     });
@@ -830,22 +814,12 @@ public class PrimaryUtilityTest {
 
   @Test
   public void transformResponseBasic() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    runset(getSpec(primary(), "transformResponse", "basic"), (entry) -> {
-      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
-      Context ctx = makeCtxFromMap(ctxmap, client, utility);
-
-      Object result = utility.transformResponse.apply(ctx);
-
-      // Update entry ctx for match (step changed).
-      Map<String, Object> entryCtx = Helpers.toMapAny(entry.get("ctx"));
-      if (entryCtx != null && ctx.spec != null) {
-        Map<String, Object> specMap = Helpers.toMapAny(entryCtx.get("spec"));
-        if (specMap != null) {
-          specMap.put("step", ctx.spec.step);
-        }
-      }
+    runsection("transformResponse", (args) -> {
+      Context ctx = OmniResolver.omniCtx(args[0], client(), utility());
+
+      Object result = utility().transformResponse.apply(ctx);
+
+      OmniResolver.omniSyncCtx(args[0], ctx);
 
       return result;
     });