@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -0,0 +1,221 @@
+package JAVAPACKAGE.sdktest;
+
+// Requests in flight at once on one client. Each resolves its operation
+// through the cache the client's root context shares with every request, and
+// registers and cleans secrets through the one registry the client holds.
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
+import java.util.function.BiFunction;
+import java.util.function.IntConsumer;
+import java.util.function.Supplier;
+
+import org.junit.jupiter.api.Test;
+
+import JAVAPACKAGE.core.Context;
+import JAVAPACKAGE.core.Operation;
+import JAVAPACKAGE.core.ProjectNameSDK;
+import JAVAPACKAGE.core.Utility;
+
+public class ConcurrencyTest {
+
+  static final int ROUNDS = 200;
+  static final int WIDTH = 8;
+  static final int OPS = 32;
+
+  static Map<String, Object> map(Object... kv) {
+    Map<String, Object> out = new LinkedHashMap<>();
+    for (int i = 0; i + 1 < kv.length; i += 2) {
+      out.put((String) kv[i], kv[i + 1]);
+    }
+    return out;
+  }
+
+  // A live client whose transport answers at once.
+  static ProjectNameSDK liveClient() {
+    BiFunction<String, Map<String, Object>, Map<String, Object>> fetch =
+        (url, fetchdef) -> map(
+            "status", 200,
+            "statusText", "OK",
+            "headers", new LinkedHashMap<String, Object>(),
+            "json", (Supplier<Object>) () -> map("ok", true));
+    return new ProjectNameSDK(map(
+        "base", "http://concurrency.test/api",
+        "allow", map("op", "direct"),
+        "system", map("fetch", fetch)));
+  }
+
+  // Runs body on WIDTH threads released together, and returns what they threw.
+  static List<Throwable> atOnce(IntConsumer body) throws InterruptedException {
+    CyclicBarrier start = new CyclicBarrier(WIDTH);
+    ConcurrentLinkedQueue<Throwable> thrown = new ConcurrentLinkedQueue<>();
+    List<Thread> threads = new ArrayList<>();
+    for (int i = 0; i < WIDTH; i++) {
+      final int n = i;
+      Thread thread = new Thread(() -> {
+        try {
+          start.await();
+          body.accept(n);
+        }
+        catch (Throwable t) {
+          thrown.add(t);
+        }
+      });
+      thread.start();
+      threads.add(thread);
+    }
+    for (Thread thread : threads) {
+      thread.join();
+    }
+    return new ArrayList<>(thrown);
+  }
+
+  @Test
+  public void concurrentFirstRequestsSucceed() throws InterruptedException {
+    for (int round = 0; round < ROUNDS; round++) {
+      // A fresh client each round, so every request in it is a first request.
+      ProjectNameSDK client = liveClient();
+      List<Map<String, Object>> results = new ArrayList<>();
+      for (int n = 0; n < WIDTH; n++) {
+        results.add(null);
+      }
+      List<Throwable> thrown = atOnce(n -> results.set(n, client.direct(map("path", "p" + n))));
+
+      assertTrue(thrown.isEmpty(), "round " + round + " threw: " + thrown);
+      for (int n = 0; n < WIDTH; n++) {
+        Map<String, Object> res = results.get(n);
+        assertEquals(true, null == res ? null : res.get("ok"),
+            "round " + round + ", request " + n + " failed: " + res);
+      }
+    }
+  }
+
+  @Test
+  public void concurrentResolutionsShareOneCachedOperation() throws InterruptedException {
+    for (int round = 0; round < ROUNDS; round++) {
+      ProjectNameSDK client = liveClient();
+      Utility utility = client.getUtility();
+      Context root = client.getRootCtx();
+      Operation[][] ops = new Operation[WIDTH][OPS];
+      List<Throwable> thrown = atOnce(n -> {
+        for (int k = 0; k < OPS; k++) {
+          ops[n][k] = utility.makeContext.apply(map("opname", "op" + k), root).op;
+        }
+      });
+
+      assertTrue(thrown.isEmpty(), "round " + round + " threw: " + thrown);
+      for (int k = 0; k < OPS; k++) {
+        Operation cached = utility.makeContext.apply(map("opname", "op" + k), root).op;
+        for (int n = 0; n < WIDTH; n++) {
+          assertSame(cached, ops[n][k],
+              "round " + round + ": op" + k + " resolved to more than one Operation");
+        }
+      }
+    }
+  }
+
+  static String addedSecret(int round, int n, int k) {
+    return "ADDED-SECRET-" + round + "-" + n + "-" + k;
+  }
+
+  // Registers thread n's secrets, then counts the thread out of registering.
+  static void registerSecrets(Utility utility, Context root, int round, int n,
+      CountDownLatch registering) {
+    try {
+      for (int k = 0; k < OPS; k++) {
+        utility.cleanAdd.apply(root, addedSecret(round, n, k));
+      }
+    }
+    finally {
+      registering.countDown();
+    }
+  }
+
+  static void assertEverySecretMasked(Utility utility, Context root, int round) {
+    for (int n = 0; n < WIDTH / 2; n++) {
+      for (int k = 0; k < OPS; k++) {
+        String added = addedSecret(round, n, k);
+        assertEquals("[redacted]", utility.clean.apply(root, added),
+            "round " + round + ": " + added + " was registered but not masked");
+      }
+    }
+  }
+
+  // Secrets registered on some threads while others clean: every clean masks
+  // what was registered before it, the longer secret whole, and no
+  // registration is lost.
+  @Test
+  public void concurrentRegistrationKeepsEverySecretMasked() throws InterruptedException {
+    for (int round = 0; round < ROUNDS / 4; round++) {
+      final int r = round;
+      ProjectNameSDK client = liveClient();
+      Utility utility = client.getUtility();
+      Context root = client.getRootCtx();
+      String inner = "INNER-SECRET-" + round;
+      utility.cleanAdd.apply(root, inner);
+      utility.cleanAdd.apply(root, "OUTER-" + inner + "-TAIL");
+      String text = "a " + inner + " b OUTER-" + inner + "-TAIL c";
+      String masked = "a [redacted] b [redacted] c";
+      assertEquals(masked, utility.clean.apply(root, text));
+
+      CountDownLatch registering = new CountDownLatch(WIDTH / 2);
+      ConcurrentLinkedQueue<Object> wrong = new ConcurrentLinkedQueue<>();
+      List<Throwable> thrown = atOnce(n -> {
+        if (n < WIDTH / 2) {
+          registerSecrets(utility, root, r, n, registering);
+          return;
+        }
+        while (0 < registering.getCount()) {
+          Object got = utility.clean.apply(root, text);
+          if (!masked.equals(got)) {
+            wrong.add(String.valueOf(got));
+          }
+        }
+      });
+
+      assertTrue(thrown.isEmpty(), "round " + round + " threw: " + thrown);
+      assertTrue(wrong.isEmpty(), "round " + round + " cleaned to: " + wrong);
+      assertEverySecretMasked(utility, root, round);
+    }
+  }
+
+  // Requests on one client while secrets register on it: each request copies
+  // the client's options, the registry among them.
+  @Test
+  public void concurrentRequestsSurviveRegistration() throws InterruptedException {
+    for (int round = 0; round < ROUNDS / 4; round++) {
+      final int r = round;
+      ProjectNameSDK client = liveClient();
+      Utility utility = client.getUtility();
+      Context root = client.getRootCtx();
+      CountDownLatch registering = new CountDownLatch(WIDTH / 2);
+      ConcurrentLinkedQueue<Object> failed = new ConcurrentLinkedQueue<>();
+      List<Throwable> thrown = atOnce(n -> {
+        if (n < WIDTH / 2) {
+          registerSecrets(utility, root, r, n, registering);
+          return;
+        }
+        while (0 < registering.getCount()) {
+          Map<String, Object> res = client.direct(map("path", "p" + n));
+          if (!Boolean.TRUE.equals(res.get("ok"))) {
+            failed.add(String.valueOf(res));
+            return;
+          }
+        }
+      });
+
+      assertTrue(thrown.isEmpty(), "round " + round + " threw: " + thrown);
+      assertTrue(failed.isEmpty(), "round " + round + ", a request failed: " + failed);
+      assertEverySecretMasked(utility, root, round);
+    }
+  }
+}

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

@@ -50,7 +50,7 @@ public class FeatureCorpusTest {
 
   // The standard operation names, in the order the runner prefers them.
   private static final List<String> FEATURE_CORPUS_OPS =
-      List.of("load", "list", "create", "update", "remove");
+      List.of("load", "list", "create", "update", "patch", "remove");
 
   /** One discovered operation: the client accessor plus the entity method. */
   private static final class Op {
@@ -349,6 +349,37 @@ public class FeatureCorpusTest {
     return null;
   }
 
+  /**
+   * The first feature a case composes that this SDK does not generate, probed
+   * as a section's own feature is. Such a case is skipped rather than failed.
+   */
+  private static String missingFeature(Object kaseRaw, Map<String, Boolean> have) {
+    Object spec = kaseRaw instanceof Map ? ((Map<String, Object>) kaseRaw).get("feature") : null;
+    List<String> names = new ArrayList<>();
+    if (spec instanceof List) {
+      for (Object f : (List<Object>) spec) {
+        if (f instanceof Map && ((Map<String, Object>) f).get("name") instanceof String) {
+          names.add((String) ((Map<String, Object>) f).get("name"));
+        }
+      }
+    }
+    else if (spec instanceof Map) {
+      names.addAll(new TreeMap<>((Map<String, Object>) spec).keySet());
+    }
+    for (String name : names) {
+      Boolean known = have.get(name);
+      if (null == known) {
+        known = null != record(buildClient(Map.of("feature",
+            List.of(Map.of("name", name, "active", true)))), name);
+        have.put(name, known);
+      }
+      if (!known) {
+        return name;
+      }
+    }
+    return null;
+  }
+
   @Test
   public void corpusCarriesAFeatureSection() {
     // A corpus with no `feature` section is a SKIP, not a failure. Each
@@ -385,6 +416,8 @@ public class FeatureCorpusTest {
         "this project's test.json has no `feature` section - recompile the "
             + "corpus (create-sdkgen .sdk/test/feature/) to run these cases");
 
+    List<String> failed = new ArrayList<>();
+    Map<String, Boolean> have = new LinkedHashMap<>();
     for (String name : new TreeMap<>(features).keySet()) {
       Object sectionRaw = features.get(name);
       if (!(sectionRaw instanceof Map)) {
@@ -419,8 +452,20 @@ public class FeatureCorpusTest {
 
       int ran = 0;
       for (Object rawCase : cases) {
+        String rawName = rawCase instanceof Map
+            ? String.valueOf(((Map<String, Object>) rawCase).get("name")) : "";
         int need = tokensUsed(rawCase);
         if (need > ops.size()) {
+          System.err.println(String.format(
+              "skip \"%s\": needs %d operations, this SDK offers %d", rawName, need, ops.size()));
+          continue;
+        }
+
+        String missing = missingFeature(rawCase, have);
+        if (null != missing) {
+          System.err.println(String.format(
+              "skip \"%s\": needs the %s feature, which this SDK does not generate",
+              rawName, missing));
           continue;
         }
 
@@ -429,54 +474,67 @@ public class FeatureCorpusTest {
           tokens.put("#OP" + (i + 1), ops.get(i).key);
         }
         Map<String, Object> kase = (Map<String, Object>) resolve(rawCase, tokens);
-
-        ProjectNameSDK client = buildClient(kase);
         String label = String.valueOf(kase.get("name"));
+        ran++;
 
-        List<Object> steps = kase.get("op") instanceof List
-            ? (List<Object>) kase.get("op") : List.of();
-        for (Object stepRaw : steps) {
-          Map<String, Object> step = (Map<String, Object>) stepRaw;
-          Op op = byKey.get(step.get("op"));
-          assertNotNull(op, label + ": no operation " + step.get("op"));
-          Map<String, Object> ctrl = step.get("ctrl") instanceof Map
-              ? new LinkedHashMap<>((Map<String, Object>) step.get("ctrl"))
-              : new LinkedHashMap<>();
-          Object wanterr = step.get("err");
-
-          try {
-            invoke(client, op, ctrl);
-            if (null != wanterr) {
-              fail(label + ": " + step.get("op") + " was expected to fail, and did not");
+        // Every failing case is reported, not only the first.
+        try {
+          ProjectNameSDK client = buildClient(kase);
+
+          List<Object> steps = kase.get("op") instanceof List
+              ? (List<Object>) kase.get("op") : List.of();
+          for (Object stepRaw : steps) {
+            Map<String, Object> step = (Map<String, Object>) stepRaw;
+            Op op = byKey.get(step.get("op"));
+            assertNotNull(op, label + ": no operation " + step.get("op"));
+            Map<String, Object> ctrl = step.get("ctrl") instanceof Map
+                ? new LinkedHashMap<>((Map<String, Object>) step.get("ctrl"))
+                : new LinkedHashMap<>();
+            Object wanterr = step.get("err");
+
+            try {
+              invoke(client, op, ctrl);
+              if (null != wanterr) {
+                fail(label + ": " + step.get("op") + " was expected to fail, and did not");
+              }
             }
-          }
-          catch (org.opentest4j.AssertionFailedError e) {
-            throw e;
-          }
-          catch (Exception err) {
-            assertNotNull(wanterr,
-                label + ": " + step.get("op") + " failed unexpectedly: " + err);
-            if (wanterr instanceof String) {
-              // The CODE, not the message: makeError prefixes and humanises
-              // the text, so matching it would pass on any error that
-              // happened to mention the word.
-              String code = err instanceof SdkError ? ((SdkError) err).code : null;
-              assertEquals(wanterr, code, label + ": wrong error code (" + err + ")");
+            catch (org.opentest4j.AssertionFailedError e) {
+              throw e;
+            }
+            catch (Exception err) {
+              assertNotNull(wanterr,
+                  label + ": " + step.get("op") + " failed unexpectedly: " + err);
+              if (wanterr instanceof String) {
+                // The CODE, not the message: makeError prefixes and humanises
+                // the text, so matching it would pass on any error that
+                // happened to mention the word.
+                String code = err instanceof SdkError ? ((SdkError) err).code : null;
+                assertEquals(wanterr, code, label + ": wrong error code (" + err + ")");
+              }
             }
           }
-        }
 
-        subset(record(client, name), kase.get("out"), label + ": _" + name);
-        ran++;
+          subset(record(client, name), kase.get("out"), label + ": _" + name);
+        }
+        catch (AssertionError | Exception e) {
+          String msg = String.valueOf(e.getMessage());
+          failed.add(msg.startsWith(label) ? msg : label + ": " + msg);
+        }
       }
 
-      assertTrue(0 < ran, "every feature." + name + " case was skipped");
       // Say how many ran. A partial run is legitimate (an SDK with one
       // operation skips the cases needing two) but it should be visible
       // rather than inferred from a green tick.
       System.err.println(String.format(
           "feature.%s: ran %d of %d case(s) against %d operation(s)",
           name, ran, cases.size(), ops.size()));
+      if (0 == ran) {
+        failed.add("every feature." + name + " case was skipped");
+      }
+    }
+
+    if (!failed.isEmpty()) {
+      fail(failed.size() + " feature corpus case(s) failed:\n  " + String.join("\n  ", failed));
     }
   }
 }

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

@@ -203,6 +203,7 @@ public final class FeatureHarness {
       case "create":
         return "POST";
       case "update":
+      case "patch":
         return "PATCH";
       case "remove":
         return "DELETE";

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

@@ -297,6 +297,39 @@ public class FeatureTest {
     assertEquals(1, f.count, "expected 1 timeout");
   }
 
+  // The deadline runs from the request's start, not from the wait: a response
+  // that arrives after it is a timeout even when the caller only looks once it
+  // is complete, as a paused thread did on a loaded runner. The clock stands
+  // at the start for the caller and 300 ms later for the worker, so the
+  // response is instant in real time and late by the clock.
+  @Test
+  public void timeout_lateResponseTimesOutHoweverLateTheCallerLooks() {
+    assumeFeatures("timeout");
+    TimeoutFeature f = new TimeoutFeature();
+    FhHarness h = fhMake(null, fhF(f, fhMap("ms", 20, "now", workerClock(300L))));
+    FhOpResult res = h.op(fhOp("load"));
+    assertEquals("timeout", fhErrCode(res.err), "expected timeout error, got " + res.err);
+    assertEquals(1, f.count, "expected 1 timeout");
+  }
+
+  // A transport failure after the deadline is a timeout too, not the failure.
+  @Test
+  public void timeout_lateFailureTimesOut() {
+    assumeFeatures("timeout");
+    TimeoutFeature f = new TimeoutFeature();
+    FhHarness h = fhMake((ctx, url, fetchdef) -> { throw new IllegalStateException("socket closed"); },
+        fhF(f, fhMap("ms", 20, "now", workerClock(300L))));
+    FhOpResult res = h.op(fhOp("load"));
+    assertEquals("timeout", fhErrCode(res.err), "expected timeout error, got " + res.err);
+    assertEquals(1, f.count, "expected 1 timeout");
+  }
+
+  // A clock standing at 0 for the calling thread and at `later` for any other.
+  private static LongSupplier workerClock(long later) {
+    Thread caller = Thread.currentThread();
+    return () -> Thread.currentThread() == caller ? 0L : later;
+  }
+
   @Test
   public void timeout_fastRequestPasses() {
     assumeFeatures("timeout");

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

@@ -611,7 +611,10 @@ public class PipelineTest {
     Context ctx = plCtx(client, utility, null);
     ctx.spec = authSpec();
     if (cred != null && seed != null) {
-      authBag(ctx.spec, cred.where()).put(cred.name(), seed);
+      // Seed what prepareAuth would have written: cred.pair() is the
+      // `<scheme>=` lead-in for a cookie and "" for a header or query, so an
+      // opaque seed is never mistaken for a stranger's cookie.
+      authBag(ctx.spec, cred.where()).put(cred.name(), cred.pair() + seed);
     }
     utility.prepareAuth.apply(ctx);
     if (cred == null) {

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

@@ -381,6 +381,103 @@ public final class RunnerSupport {
     return new SdkError(code, msg, null);
   }
 
+  // A live check that did not pass, as main.kit.test.live.strict decides:
+  // strict fails the test, lenient skips it with the same reason.
+  public static void liveMiss(boolean strict, String reason) {
+    if (strict) {
+      org.junit.jupiter.api.Assertions.fail(reason);
+    }
+    org.junit.jupiter.api.Assumptions.abort(reason);
+  }
+
+  // An account holding no record for the test to read skips either way.
+  public static void liveEmpty(String reason) {
+    org.junit.jupiter.api.Assumptions.abort(reason);
+  }
+
+  // A live list response's records: the body, or the first list an
+  // envelope holds.
+  public static List<Object> liveList(Object data) {
+    if (data instanceof List) {
+      return (List<Object>) data;
+    }
+    if (data instanceof Map) {
+      for (Object value : new TreeMap<>((Map<String, Object>) data).values()) {
+        if (value instanceof List) {
+          return (List<Object>) value;
+        }
+      }
+    }
+    return null;
+  }
+
+  // A live response for a message: the SDK's error, or else its status and
+  // content type, never its body.
+  public static String liveDescribe(Map<String, Object> result) {
+    if (result == null) {
+      return "no response";
+    }
+    Object err = result.get("err");
+    if (err instanceof Throwable) {
+      return ((Throwable) err).getMessage();
+    }
+    if (err != null) {
+      return String.valueOf(err);
+    }
+    String out = "HTTP " + result.get("status");
+    if (result.get("headers") instanceof Map) {
+      for (Map.Entry<String, Object> e : ((Map<String, Object>) result.get("headers")).entrySet()) {
+        if ("content-type".equalsIgnoreCase(e.getKey()) && e.getValue() != null) {
+          out += " " + String.valueOf(e.getValue()).split(";")[0].trim();
+        }
+      }
+    }
+    return out;
+  }
+
+  // The record a create-less flow reads live: the first its list returns,
+  // put where the flow reads the fixture's existing records.
+  public static void liveExisting(Map<String, Object> data, boolean strict, String name,
+      Supplier<Object> list) {
+    Object found = null;
+    try {
+      found = list.get();
+    }
+    catch (RuntimeException e) {
+      liveMiss(strict, "Live list discovery failed: " + e.getMessage());
+    }
+    if (!(found instanceof List)) {
+      liveMiss(strict, "Live list discovery returned no list");
+    }
+    List<Object> items = (List<Object>) found;
+    if (items.isEmpty()) {
+      liveEmpty("The account has no " + name + " record to load");
+    }
+    Object first = items.get(0);
+    Object record = first instanceof Entity ? ((Entity) first).data() : first;
+    Object existing = data.get("existing");
+    if (!(existing instanceof Map)) {
+      existing = new LinkedHashMap<String, Object>();
+      data.put("existing", existing);
+    }
+    Map<String, Object> holder = new LinkedHashMap<>();
+    holder.put("live01", record);
+    ((Map<String, Object>) existing).put(name, holder);
+  }
+
+  // In a lenient live run a failing check skips, observing the live API.
+  public static void liveObserve(Throwable err, boolean live, boolean strict) {
+    if (strict || !live || err instanceof org.opentest4j.TestAbortedException) {
+      RunnerSupport.<RuntimeException>rethrow(err);
+    }
+    org.junit.jupiter.api.Assumptions.abort(
+        "live run, main.kit.test.live.strict is false: " + err.getMessage());
+  }
+
+  private static <T extends Throwable> void rethrow(Throwable err) throws T {
+    throw (T) err;
+  }
+
   // entityListToData extracts data maps from a list of Entity objects.
   public static List<Object> entityListToData(List<Object> list) {
     List<Object> out = new ArrayList<>();