@voxgig/sdkgen 4.3.0 → 4.4.1

package/project/.sdk/tm/clojure/test/sdk/test/primary.clj

@@ -4,8 +4,100 @@
   (:require [sdk.core :as core]
             [sdk.client :as client]
             [sdk.testutil :as t]
+            [sdk.test.struct-corpus :as corpus]
             [voxgig.struct :as vs]
-            [clojure.string :as str]))
+            [clojure.string :as str])
+  (:import [java.util Map]))
+
+;; THE SHARED CORPUS.
+;;
+;; The checks below assert against inputs written here; this drives
+;; .sdk/test/test.json -> "primary" through the same utilities, so the cases
+;; cannot drift from the reference implementation. That is what moves clojure
+;; from the MIRRORED parity tier to FULL — a mirrored suite cannot notice a
+;; corpus case that changed, or one that was added.
+
+(def ^:private CORPUS "../.sdk/test/test.json")
+
+(defn- getspec [root & path]
+  (reduce (fn [acc k] (when acc (.get ^Map acc k))) root path))
+
+(defn- lower-headers [m]
+  ;; Header names arrive in any case and the contract is lowercase; the SDK
+  ;; copies them verbatim, so the driver normalises, as the lua reference does.
+  (when (vs/ismap m)
+    (let [out (vs/jm)]
+      (doseq [k (vs/keysof m)] (vs/setprop out (str/lower-case k) (vs/getprop m k)))
+      out)))
+
+(defn- neutral
+  "A struct map with STRING keys, from this port's keyword-keyed atom.
+
+   spec/result/response are atoms wrapping {:base ... :status-text ...}; the
+   corpus is camelCase and string-keyed, so a raw deref matches nothing.
+   status-text is spelled statusText here for the same reason."
+  [v]
+  (let [m (if (instance? clojure.lang.Atom v) (deref v) v)]
+    (if-not (map? m)
+      m
+      (let [out (vs/jm)]
+        (doseq [[k val] m]
+          (let [ks (if (keyword? k) (name k) (str k))
+                ks (case ks "status-text" "statusText" ks)
+                v0 (if (instance? clojure.lang.Atom val) (deref val) val)
+                ;; An SDK error object is keyword-keyed with :msg; the contract
+                ;; spells it err.message, so a raw copy reads null.
+                v1 (if (and (map? v0) (core/sdk-error? v0))
+                     (vs/jm "message" (str (:msg v0)))
+                     v0)]
+            (vs/setprop out ks v1)))
+        out))))
+
+(defn- publish-ctx
+  "Write the mutated spec/result/response back onto the corpus map.
+
+   The match reads entry.ctx — the raw corpus map — while the utilities mutate
+   the live objects hanging off the context, so without this every ctx.*
+   assertion reads null."
+  [ctxmap ctx]
+  (doseq [[k kw] [["spec" :spec] ["result" :result] ["response" :response]
+                  ["err" :err]]]
+    (when-let [v (core/oget ctx kw)]
+      (vs/setprop ctxmap k (neutral v))))
+  ctxmap)
+
+(defn- corpus-ctx
+  "A LIVE context from a corpus map: the utilities read and MUTATE spec, result
+   and response, so a bare map leaves them nothing to work on.
+
+   The context is an ATOM here, not a struct map — core/oget and core/oset!
+   with KEYWORD keys are its accessors, and vs/setprop on it silently does
+   nothing."
+  [sdk utility ctxmap]
+  (let [ctxmap (if (vs/ismap ctxmap) ctxmap (vs/jm))
+        opname (vs/getprop ctxmap "opname")
+        ctx (core/make-context
+              (vs/jm "opname" (or opname "") "client" sdk "utility" utility) nil)]
+    (when (nil? (core/oget ctx :options))
+      (core/oset! ctx :options (core/client-options-map sdk)))
+    (when-let [sp (vs/getprop ctxmap "spec")]
+      (when (vs/ismap sp) (core/oset! ctx :spec (core/make-spec sp))))
+    (when-let [rs (vs/getprop ctxmap "result")]
+      (when (vs/ismap rs) (core/oset! ctx :result (core/make-result rs))))
+    (when-let [rp (vs/getprop ctxmap "response")]
+      (when (vs/ismap rp)
+        (let [resp (core/make-response rp)]
+          (when-let [lh (lower-headers (vs/getprop rp "headers"))]
+            (core/oset! resp :headers lh))
+          ;; result-body reads the response's json thunk, not its body; the
+          ;; corpus supplies a plain body, so wrap it as the other drivers do.
+          (when-let [b (vs/getprop rp "body")]
+            (core/oset! resp :json (fn [] b)))
+          (core/oset! ctx :response resp))))
+    (doseq [[k kw] [["point" :point] ["reqdata" :reqdata]
+                    ["reqmatch" :reqmatch] ["data" :data]]]
+      (when-let [v (vs/getprop ctxmap k)] (core/oset! ctx kw v)))
+    ctx))
 
 (defn run [rec]
   (let [sdk (client/test-sdk nil nil)
@@ -50,3 +142,81 @@
                  (t/is-eq (vs/getprop fetchdef "method") "GET" "GET")
                  (t/is-true (str/includes? (str (vs/getprop fetchdef "url")) "/api/items/item01") "url includes")))))
     nil))
+
+
+(defn run-corpus
+  "Drive every primary section of the shared corpus through this SDK."
+  [rec]
+  (let [sdk (client/test-sdk nil nil)
+        utility (core/get-utility sdk)
+        u (fn [k] (get (deref utility) k))
+        alltests (core/json-parse (slurp CORPUS))
+        primary (.get ^Map alltests "primary")
+        setup-of (fn [nm] (getspec primary nm "DEF" "setup" "a"))
+        client-for (fn [nm] (let [su (setup-of nm)]
+                              (if (vs/ismap su) (client/test-sdk nil su) sdk)))
+        ;; make-spec and prepare-auth read defaults off the CLIENT, as the ts
+        ;; reference does via client.options(), so a section's DEF.setup cannot
+        ;; reach them through ctx options.
+        spec-sdk (client-for "makeSpec")
+        auth-sdk (client-for "prepareAuth")
+        ran (atom 0)
+        ;; One section, driven with a ctx built from the corpus entry.
+        runset (fn [nm cl f]
+              (let [node (getspec primary nm "basic")]
+                (when (nil? node)
+                  (throw (ex-info (str "corpus section missing: " nm) {})))
+                (swap! ran inc)
+                ;; run-set APPLIES the resolved args, so an args-style entry
+                ;; calls the subject with more than one — variadic, and the
+                ;; extra arg reaches the section through `more`.
+                (corpus/run-set nm node
+                  (fn [& as]
+                    (let [ctxmap (first as)
+                          more (second as)
+                          ctx (corpus-ctx cl (core/get-utility cl) ctxmap)
+                          out (f ctx ctxmap more)]
+                      (publish-ctx ctxmap ctx)
+                      out)))))
+        argof (fn [ctxmap k] (vs/getprop ctxmap k))]
+
+    (t/run-check rec "primary-corpus"
+      (fn []
+        (binding [corpus/*results* (atom {:pass [] :fail []})]
+          (runset "done" sdk              (fn [c _ _2] ((u :done) c)))
+          (runset "makeUrl" sdk           (fn [c _ _2] (first ((u :make-url) c))))
+          (runset "makeRequest" sdk       (fn [c _ _2] (first ((u :make-request) c))))
+          (runset "makeResponse" sdk      (fn [c _ _2] (first ((u :make-response) c))))
+          (runset "makeSpec" spec-sdk     (fn [c _ _2] (first ((u :make-spec) c))))
+          (runset "prepareAuth" auth-sdk  (fn [c _ _2] (first ((u :prepare-auth) c))))
+          (runset "prepareBody" sdk       (fn [c _ _2] ((u :prepare-body) c)))
+          (runset "prepareHeaders" sdk    (fn [c _ _2] ((u :prepare-headers) c)))
+          (runset "prepareMethod" sdk     (fn [c _ _2] ((u :prepare-method) c)))
+          (runset "prepareParams" sdk     (fn [c _ _2] ((u :prepare-params) c)))
+          (runset "preparePath" sdk       (fn [c _ _2] ((u :prepare-path) c)))
+          (runset "prepareQuery" sdk      (fn [c _ _2] ((u :prepare-query) c)))
+          (runset "resultBasic" sdk       (fn [c _ _2] (neutral ((u :result-basic) c))))
+          (runset "resultBody" sdk        (fn [c _ _2] (neutral ((u :result-body) c))))
+          (runset "resultHeaders" sdk     (fn [c _ _2] (neutral ((u :result-headers) c))))
+          (runset "transformRequest" sdk  (fn [c _ _2] ((u :transform-request) c)))
+          (runset "transformResponse" sdk (fn [c _ _2] ((u :transform-response) c)))
+          (runset "makeOptions" sdk       (fn [c m _2]
+                                         (core/oset! c :config (argof m "config"))
+                                         (core/oset! c :options (argof m "options"))
+                                         ((u :make-options) c)))
+          (runset "makeContext" sdk       (fn [c _ _2]
+                                         (let [op (core/oget c :op)]
+                                           (vs/jm "op" (neutral op)))))
+          (runset "makeError" sdk         (fn [c _ err] (first ((u :make-error) c err))))
+          (runset "operator" sdk          (fn [_ m _2] (neutral (core/make-operation m))))
+          (runset "param" sdk             (fn [c _ pd] ((u :param) c pd)))
+
+          (let [r @corpus/*results*
+                np (count (:pass r))
+                nf (count (:fail r))]
+            (doseq [f (:fail r)]
+              (println "PRIMARY-FAIL" (:group f) (:name f) "-" (:msg f)))
+            (println "PRIMARY CORPUS: PASS" np " FAIL" nf)
+            (t/is-true (< 0 @ran) "the primary corpus executed no sections")
+            (t/is-true (< 0 np) "the primary corpus executed no cases")
+            (t/is-true (= 0 nf) (str nf " primary corpus failures"))))))))

package/project/.sdk/tm/clojure/test/sdk/test/struct_corpus.clj

@@ -68,7 +68,14 @@
 (defn- resolve-args [^Map entry subject]
   (cond
     (.containsKey entry "ctx") [(.get entry "ctx")]
-    (.containsKey entry "args") (vec (.get entry "args"))
+    (.containsKey entry "args")
+    (let [args (vec (.get entry "args"))]
+      ;; ts's resolveArgs writes the live first arg back as entry.ctx, so a
+      ;; `match: {ctx: ...}` resolves for args-style entries too. Without it
+      ;; every such assertion reads null and silently passes nothing.
+      (when (and (seq args) (s/ismap (first args)))
+        (.put entry "ctx" (first args)))
+      args)
     (.containsKey entry "in") [(s/clone (.get entry "in"))]
     :else []))
 
@@ -98,7 +105,11 @@
         (when (.containsKey entry "match")
           (do-match (.get entry "match")
                     (omap "in" (.get entry "in") "out" (.get entry "res")
-                          "ctx" (.get entry "ctx") "err" msg)))
+                          ;; The ts runner hands do-match the ERROR OBJECT, so a
+                          ;; corpus `match: {err: {message: ...}}` resolves. This
+                          ;; port passed the bare message string, where err.message
+                          ;; walks into a string and reads null.
+                          "ctx" (.get entry "ctx") "err" (omap "message" msg))))
         (throw (AssertionError. (str "ERROR MATCH: [" (s/stringify entry-err) "] <=> [" msg "]"))))
       (throw (if (instance? AssertionError err) err (AssertionError. (str err)))))))
 

package/project/.sdk/tm/clojure/test/sdk/test_runner.clj

@@ -18,6 +18,8 @@
   (let [results (atom [])
         rec (fn [name ok? msg] (swap! results conj {:name name :ok ok? :msg msg}))]
     (primary/run rec)
+    ;; The shared corpus, driven through this SDK's utilities.
+    (primary/run-corpus rec)
     (pipeline/run rec)
     (feature/run rec)
     (netsim/run rec)

package/project/.sdk/tm/csharp/test/CustomUtilityTest.cs

@@ -48,4 +48,108 @@ public class CustomUtilityTest
             Assert.Equal(name.ToUpperInvariant(), result["util"]);
         }
     }
+
+    // The half the test above cannot see. Those keys are ALIASES - `auth`,
+    // `body`, `spec` - and no utility member has those names, so landing in
+    // Custom is the right outcome for them and the assertion passes whether or
+    // not overriding works at all.
+    //
+    // A key that DOES name a member must replace it. That is the documented
+    // contract, it is what ts does, and it was silently absent here: every
+    // entry went to Custom, which nothing reads, so `utility: { fetcher = ... }`
+    // did nothing while ts honoured it.
+    [Fact]
+    public void ARealUtilityMemberIsReplacedNotShelved()
+    {
+        var reached = 0;
+
+        // A NATURAL lambda, as a caller writes it - NOT declared as
+        // FetcherFunc. C# delegate types are nominal, so this is a `Func`4`
+        // and not an instance of FetcherFunc at all; declaring it as the named
+        // type here would test only the one form that already worked and hide
+        // every ordinary caller. It captures `reached`, so the conversion has
+        // to carry the closure target too.
+        var scripted = (Context ctx, string fullurl, Dictionary<string, object?> fetchdef) =>
+        {
+            reached++;
+            return (object?)new Dictionary<string, object?>
+            {
+                ["status"] = 200,
+                ["statusText"] = "OK",
+                ["headers"] = new Dictionary<string, object?>(),
+                ["body"] = "{}",
+            };
+        };
+
+        // The plain constructor, not TestSDK. The `test` feature is
+        // transport: 'base' - it REPLACES the transport by design - so a client
+        // in test mode would shadow the scripted fetcher and this would assert
+        // nothing.
+        var client = new ProjectNameSDK(new Dictionary<string, object?>
+        {
+            ["utility"] = new Dictionary<string, object?> { ["fetcher"] = scripted },
+        });
+
+        var u = client.GetUtility();
+
+        Assert.NotNull(u.Fetcher);
+        Assert.False(u.Custom.ContainsKey("fetcher"),
+            "fetcher was shelved in Custom instead of replacing the member");
+
+        // Behaviour, not identity: drive it.
+        var ctx = u.MakeContext(new Dictionary<string, object?>(), client.GetRootCtx());
+        u.Fetcher(ctx, "http://example.test/probe", new Dictionary<string, object?>());
+        Assert.Equal(1, reached);
+    }
+
+    // The other spelling of the same value. A caller who names the exported
+    // delegate gets a FetcherFunc, which IS an instance of the field type and
+    // needs no conversion - the mirror image of the test above, and broken by
+    // any fix that swaps one path for the other.
+    [Fact]
+    public void ANamedDelegateIsAcceptedToo()
+    {
+        var reached = 0;
+        FetcherFunc scripted = (ctx, fullurl, fetchdef) =>
+        {
+            reached++;
+            return new Dictionary<string, object?>
+            {
+                ["status"] = 200,
+                ["statusText"] = "OK",
+                ["headers"] = new Dictionary<string, object?>(),
+                ["body"] = "{}",
+            };
+        };
+
+        var client = new ProjectNameSDK(new Dictionary<string, object?>
+        {
+            ["utility"] = new Dictionary<string, object?> { ["fetcher"] = scripted },
+        });
+
+        var u = client.GetUtility();
+        Assert.False(u.Custom.ContainsKey("fetcher"),
+            "a named-delegate fetcher was shelved in Custom");
+
+        var ctx = u.MakeContext(new Dictionary<string, object?>(), client.GetRootCtx());
+        u.Fetcher(ctx, "http://example.test/probe", new Dictionary<string, object?>());
+        Assert.Equal(1, reached);
+    }
+
+    // An unknown key must still be attached rather than dropped, so the two
+    // halves cannot be satisfied by a rule that also swallows extras.
+    [Fact]
+    public void AnUnknownKeyIsStillAttached()
+    {
+        var client = new ProjectNameSDK(new Dictionary<string, object?>
+        {
+            ["utility"] = new Dictionary<string, object?>
+            {
+                ["notAUtilityMember"] = Util("EXTRA"),
+            },
+        });
+
+        Assert.True(client.GetUtility().Custom.ContainsKey("notAUtilityMember"),
+            "an unknown utility key was dropped instead of kept in Custom");
+    }
 }

package/project/.sdk/tm/csharp/utility/MakeOptions.cs

@@ -15,12 +15,89 @@ public static partial class SdkUtility
         new(@"\{([A-Za-z0-9_]+)\}", RegexOptions.Compiled);
 
 
+    /// <summary>
+    /// Replaces one utility member from <c>options.utility</c>, matching the
+    /// ts reference: a key naming a real member REPLACES it, and any other
+    /// key is attached as a custom extra. Returns false when the key names no
+    /// member or the value is not that member's delegate type, so the caller
+    /// keeps it in Custom.
+    /// </summary>
+    /// <remarks>
+    /// REFLECTION, NOT A KEYED SWITCH. The go and java ports list every member
+    /// by hand and carry a "keep this in step with registerAll" warning,
+    /// because a utility added to one list and not the other is overridable
+    /// there and not here. C# can read the field set off the type itself, so
+    /// the list cannot drift, and FieldType.IsInstanceOfType is a real check
+    /// rather than an unchecked cast - a wrongly-shaped value falls through to
+    /// Custom instead of throwing later in the pipeline.
+    ///
+    /// Only a PUBLIC name may replace a member. Option keys are camelCase, as
+    /// ts spells them, and fields here are PascalCase; public names carry no
+    /// underscore, so an underscore means the caller named something of their
+    /// own rather than a member.
+    /// </remarks>
+    internal static bool OverrideUtil(Utility utility, string key, object? val)
+    {
+        if (string.IsNullOrEmpty(key) || key.Contains('_'))
+        {
+            return false;
+        }
+
+        var name = char.ToUpperInvariant(key[0]) + key.Substring(1);
+        if ("Custom" == name)
+        {
+            return false;
+        }
+
+        var field = typeof(Utility).GetField(name);
+        if (null == field || null == val)
+        {
+            return false;
+        }
+
+        if (field.FieldType.IsInstanceOfType(val))
+        {
+            field.SetValue(utility, val);
+            return true;
+        }
+
+        // SAME SHAPE, DIFFERENT NAMED TYPE. Every member is a NAMED delegate
+        // (FetcherFunc) or a constructed Func/Action, and C# delegate types are
+        // nominal: a naturally-typed lambda gets Func`4, and
+        // `Func<Context, string, Dictionary<string, object?>, object?>` written
+        // out longhand is a third type again. None is an instance of
+        // FetcherFunc despite an identical signature, so IsInstanceOfType alone
+        // honoured only a caller who knew to declare the named type - which is
+        // to say, almost nobody.
+        //
+        // CreateDelegate rebinds the same target and method onto the field's
+        // type, and with throwOnBindFailure: false it returns null rather than
+        // throwing when the signature genuinely does not match - so a wrongly
+        // shaped delegate still falls through to `custom`.
+        if (val is Delegate d && typeof(Delegate).IsAssignableFrom(field.FieldType))
+        {
+            var converted = Delegate.CreateDelegate(field.FieldType, d.Target, d.Method, false);
+            if (null != converted)
+            {
+                field.SetValue(utility, converted);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     internal static Dictionary<string, object?> MakeOptionsUtil(Context ctx)
     {
         var options = ctx.Options ?? new Dictionary<string, object?>();
 
-        // Merge custom utility overrides onto the utility object.
+        // Merge utility overrides from options onto the utility object.
         // Read from original options before clone for safety.
+        //
+        // A key naming a real utility member REPLACES it; anything else is
+        // attached as a custom extra. Shelving everything in Custom - a map
+        // nothing reads - made `utility: { fetcher = ... }`, the documented
+        // transport seam, a silent no-op here while ts honoured it.
         if (Helpers.ToMapAny(options.TryGetValue("utility", out var cu) ? cu : null)
             is Dictionary<string, object?> customUtils)
         {
@@ -29,7 +106,10 @@ public static partial class SdkUtility
             {
                 foreach (var kv in customUtils)
                 {
-                    utility.Custom[kv.Key] = kv.Value;
+                    if (!OverrideUtil(utility, kv.Key, kv.Value))
+                    {
+                        utility.Custom[kv.Key] = kv.Value;
+                    }
                 }
             }
         }

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -193,17 +193,53 @@ defmodule ProjectName.Utility do
 
   # ---- make_options --------------------------------------------------------
 
+  # Public camelCase option key -> snake_case utility member name, or nil
+  # when the key is not a public name (see make_options_impl).
+  defp util_member(key) when is_binary(key) do
+    if String.contains?(key, "_") do
+      nil
+    else
+      String.replace(key, ~r/([A-Z])/, "_\\1") |> String.downcase()
+    end
+  end
+
+  defp util_member(_key), do: nil
+
   def make_options_impl(ctx) do
     options = H.or_(S.getprop(ctx, "options"), S.jm([]))
 
     custom_utils = S.getprop(options, "utility")
 
+    # Utility overrides from options.
+    #
+    # A key naming a real utility member REPLACES it; anything else is
+    # attached as a custom extra. Shelving everything in `custom` - a map
+    # nothing reads - made `utility: %{"fetcher" => ...}`, the documented
+    # transport seam, a silent no-op here while ts honoured it.
+    #
+    # Only a PUBLIC name may replace. Option keys are camelCase, as ts spells
+    # them, and members here are snake_case; public names carry no underscore,
+    # so an underscore means the caller named something of their own -
+    # possibly the internal spelling of a real member. `make_error` must stay
+    # an extension, or a non-callable would break the error path on the next
+    # request.
     if S.ismap(custom_utils) do
       utility = S.getprop(ctx, "utility")
 
       if utility != nil do
         custom = S.getprop(utility, "custom")
-        Enum.each(S.keysof(custom_utils), fn k -> S.setprop(custom, k, S.getprop(custom_utils, k)) end)
+
+        Enum.each(S.keysof(custom_utils), fn k ->
+          val = S.getprop(custom_utils, k)
+          member = util_member(k)
+
+          if member != nil and member != "custom" and
+               S.getprop(utility, member) != nil do
+            S.setprop(utility, member, val)
+          else
+            S.setprop(custom, k, val)
+          end
+        end)
       end
     end
 
@@ -863,6 +899,16 @@ defmodule ProjectName.Utility do
       cond do
         match?(%ProjectName.Error{}, err) -> err.msg
         is_exception(err) -> Exception.message(err)
+        # S.ismap, not is_map: a struct value is a {:vmap, id} TUPLE, so
+        # is_map/1 is false for every heap map and this branch could never
+        # fire for one. And the neutral contract spells it "message" — "msg"
+        # is this port's own internal name. Between them, an error map reached
+        # the stringify fallback and the SDK reported
+        # "foo: {message:zed}" where every other target reports "foo: zed".
+        S.ismap(err) ->
+          m = S.getprop(err, "message") || S.getprop(err, "msg")
+          if is_binary(m) and m != "", do: m, else: "unknown error"
+
         is_map(err) and not is_struct(err) and S.getprop(err, "msg") != nil -> S.getprop(err, "msg")
         is_binary(err) -> err
         true -> S.stringify(err)
@@ -1066,7 +1112,9 @@ defmodule ProjectName.Utility do
     # Only fall back to the op-name convention when the point has no method.
     case S.getprop(S.getprop(ctx, "point"), "method") do
       m when is_binary(m) and m != "" -> String.upcase(m)
-      _ -> Map.get(@method_map, opname, "GET")
+      # No GET catch-all: an unrecognised op must fall through to the
+      # allow.method gate, not be silently issued as a GET.
+      _ -> Map.get(@method_map, opname)
     end
   end