@voxgig/sdkgen 1.3.7 → 1.3.9

package/project/.sdk/tm/elixir/test/primary_utility_test.exs

@@ -0,0 +1,133 @@
+# ProjectName SDK primary-utility test
+#
+# Directly exercises the request-shaping utilities (make_url, param,
+# prepare_*, make_options) through the client's utility object. API-agnostic.
+
+defmodule ProjectName.PrimaryUtilityTest do
+  use ExUnit.Case
+
+  alias Voxgig.Struct, as: S
+  alias ProjectName.Helpers, as: H
+  alias ProjectName.{Context, Utility, Spec, Result}
+
+  defp client, do: ProjectName.test()
+
+  defp ctx(client, opname \\ "load") do
+    Context.new(S.jm(["opname", opname]), ProjectName.get_root_ctx(client))
+  end
+
+  test "make_url substitutes path params and appends query" do
+    c = client()
+    ctx = ctx(c)
+
+    S.setprop(ctx, "spec",
+      Spec.new(H.deep(%{
+        "base" => "http://h",
+        "path" => "planet/{id}",
+        "params" => %{"id" => "P1"},
+        "query" => %{"q" => "x"}
+      })))
+
+    S.setprop(ctx, "result", Result.new(nil))
+
+    {url, err} = Utility.make_url(ctx)
+    assert err == nil
+    assert String.contains?(url, "planet/P1")
+    assert String.contains?(url, "q=x")
+    assert S.getprop(S.getprop(ctx, "result"), "resmatch") != nil
+  end
+
+  test "param resolves reqmatch over match, then data" do
+    c = client()
+    ctx = ctx(c)
+    S.setprop(ctx, "reqmatch", H.deep(%{"id" => "R1"}))
+    S.setprop(ctx, "match", H.deep(%{"id" => "M1", "k" => "mk"}))
+    S.setprop(ctx, "reqdata", H.deep(%{"d" => "rd"}))
+    S.setprop(ctx, "data", H.deep(%{"d" => "dd", "only" => "od"}))
+
+    assert Utility.param(ctx, "id") == "R1"
+    assert Utility.param(ctx, "k") == "mk"
+    assert Utility.param(ctx, "d") == "rd"
+    assert Utility.param(ctx, "only") == "od"
+    assert Utility.param(ctx, "missing") == nil
+  end
+
+  test "prepare_method maps op names to HTTP verbs" do
+    c = client()
+    assert Utility.prepare_method(ctx(c, "create")) == "POST"
+    assert Utility.prepare_method(ctx(c, "update")) == "PUT"
+    assert Utility.prepare_method(ctx(c, "load")) == "GET"
+    assert Utility.prepare_method(ctx(c, "list")) == "GET"
+    assert Utility.prepare_method(ctx(c, "remove")) == "DELETE"
+  end
+
+  test "prepare_query keeps reqmatch keys not declared as point params" do
+    c = client()
+    ctx = ctx(c)
+    S.setprop(ctx, "point", H.deep(%{"params" => ["id"]}))
+    S.setprop(ctx, "reqmatch", H.deep(%{"id" => "x", "extra" => "y"}))
+    q = Utility.prepare_query(ctx)
+    assert S.getprop(q, "extra") == "y"
+    assert S.getprop(q, "id") == nil
+  end
+
+  test "prepare_params resolves declared params" do
+    c = client()
+    ctx = ctx(c)
+    S.setprop(ctx, "point", H.deep(%{"args" => %{"params" => [%{"name" => "id"}]}}))
+    S.setprop(ctx, "reqmatch", H.deep(%{"id" => "P9"}))
+    p = Utility.prepare_params(ctx)
+    assert S.getprop(p, "id") == "P9"
+  end
+
+  test "prepare_auth sets an authorization header when an apikey is present" do
+    c = ProjectName.new(H.deep(%{"apikey" => "secret"}))
+    ctx = ctx(c)
+    spec = Spec.new(H.deep(%{"headers" => %{}}))
+    S.setprop(ctx, "spec", spec)
+    {_spec, err} = Utility.prepare_auth(ctx)
+    assert err == nil
+    assert S.getprop(S.getprop(spec, "headers"), "authorization") == "secret"
+  end
+
+  test "prepare_auth omits the header when no apikey" do
+    c = ProjectName.new()
+    ctx = ctx(c)
+    spec = Spec.new(H.deep(%{"headers" => %{"authorization" => "stale"}}))
+    S.setprop(ctx, "spec", spec)
+    {_spec, err} = Utility.prepare_auth(ctx)
+    assert err == nil
+    assert S.getprop(S.getprop(spec, "headers"), "authorization") == nil
+  end
+
+  test "make_options derives a clean key regex" do
+    c = ProjectName.test()
+    opts = ProjectName.options_map(c)
+    assert S.getpath(opts, "__derived__.clean.keyre") == "key|token|id"
+  end
+
+  test "make_error formats a namespaced message and raises by default" do
+    c = client()
+    ctx = ctx(c, "load")
+
+    err =
+      assert_raise ProjectName.Error, fn ->
+        Utility.make_error(ctx, Context.make_error(ctx, "boom", "kaboom"))
+      end
+
+    assert String.contains?(err.msg, "load")
+    assert String.contains?(err.msg, "kaboom")
+    assert err.code == "boom"
+  end
+
+  test "make_error returns bare resdata when throw_err is disabled" do
+    c = client()
+    ctx = ctx(c, "load")
+    S.setprop(S.getprop(ctx, "ctrl"), "throw_err", false)
+    result = Result.new(H.deep(%{"resdata" => %{"x" => 1}}))
+    S.setprop(ctx, "result", result)
+    out = Utility.make_error(ctx, Context.make_error(ctx, "boom", "kaboom"))
+    assert S.ismap(out)
+    assert S.getprop(out, "x") == 1
+  end
+end

package/project/.sdk/tm/elixir/test/stream_test.exs

@@ -0,0 +1,119 @@
+# ProjectName SDK entity stream() test
+#
+# Exercises the generated entity stream(action, args, callopts) method. stream
+# runs an op through the full pipeline and returns a lazy Elixir Stream over
+# result items. With the streaming feature active the result carries an
+# incremental iterator and stream yields from it (honouring chunkSize);
+# otherwise it falls back to the materialised items, so stream always yields.
+# API-agnostic: discovers a top-level list entity from the config (a list op
+# point with no required params) and seeds it via the test mock.
+
+defmodule ProjectName.StreamTest do
+  use ExUnit.Case
+
+  alias Voxgig.Struct, as: S
+  alias ProjectName.Helpers, as: H
+
+  # True when this SDK was generated with the named feature.
+  defp has_feature?(name) do
+    f = S.getprop(ProjectName.Config.make_config(), "feature")
+    S.ismap(f) and S.getprop(f, name) != nil
+  end
+
+  # Discover an entity whose `list` op has a point with no required params, so
+  # the seeded list needs no path parameters.
+  defp find_list_entity do
+    config = ProjectName.Config.make_config()
+    entities = H.or_(H.to_map(S.getprop(config, "entity")), S.jm([]))
+
+    Enum.find_value(S.keysof(entities), fn name ->
+      points = S.getpath(config, "entity.#{name}.op.list.points")
+
+      clean =
+        S.islist(points) and S.size(points) > 0 and
+          Enum.any?(0..(S.size(points) - 1), fn i ->
+            params = S.getpath(S.getelem(points, i), "args.params")
+
+            reqd =
+              if S.islist(params) and S.size(params) > 0 do
+                Enum.count(0..(S.size(params) - 1), fn j ->
+                  S.getprop(S.getelem(params, j), "reqd") == true
+                end)
+              else
+                0
+              end
+
+            reqd == 0
+          end)
+
+      if clean, do: name, else: nil
+    end)
+  end
+
+  # Three seeded records via the test mock (the mock walk sets id to the key).
+  defp seed(name) do
+    S.jm([
+      name,
+      S.jm([
+        "S1", S.jm(["id", "S1", "name", "a"]),
+        "S2", S.jm(["id", "S2", "name", "b"]),
+        "S3", S.jm(["id", "S3", "name", "c"])
+      ])
+    ])
+  end
+
+  defp entity(sdk, name), do: apply(ProjectName, String.to_atom(name), [sdk, nil])
+  defp entmod(name), do: Module.concat([ProjectName.Entity, Macro.camelize(name)])
+
+  defp do_stream(sdk, name, callopts) do
+    apply(entmod(name), :stream, [entity(sdk, name), "list", S.jm([]), callopts])
+    |> Enum.to_list()
+  end
+
+  test "entity stream() runs the pipeline and yields items" do
+    name = find_list_entity()
+
+    if name == nil do
+      # No top-level list entity in this SDK; nothing to exercise.
+      assert true
+    else
+      # Fallback (no streaming feature): materialised items.
+      sdk = ProjectName.test(S.jm(["entity", seed(name)]), nil)
+      items = do_stream(sdk, name, nil)
+      assert length(items) == 3
+      assert S.ismap(hd(items))
+
+      # signal cancels iteration between yields.
+      sdk2 = ProjectName.test(S.jm(["entity", seed(name)]), nil)
+      counter = :counters.new(1, [])
+
+      sig = fn ->
+        :counters.add(counter, 1, 1)
+        :counters.get(counter, 1) >= 2
+      end
+
+      items2 = do_stream(sdk2, name, S.jm(["signal", sig]))
+      assert length(items2) == 1
+
+      if has_feature?("streaming") do
+        # Streaming feature active: yields from the streaming iterator.
+        ssdk =
+          ProjectName.test(
+            S.jm(["entity", seed(name)]),
+            S.jm(["feature", S.jm(["streaming", S.jm(["active", true])])])
+          )
+
+        assert length(do_stream(ssdk, name, nil)) == 3
+
+        # chunkSize groups items into batches: 3 items / 2 -> 2 batches.
+        csdk =
+          ProjectName.test(
+            S.jm(["entity", seed(name)]),
+            S.jm(["feature", S.jm(["streaming", S.jm(["active", true, "chunkSize", 2])])])
+          )
+
+        assert length(do_stream(csdk, name, nil)) == 2
+      end
+    end
+  end
+end

package/project/.sdk/tm/elixir/test/struct_corpus_test.exs

@@ -0,0 +1,18 @@
+# Runs the vendored struct library against the shared corpus
+# (.sdk/test/test.json -> "struct"). Prints a PASS/FAIL summary and asserts
+# zero failures.
+
+defmodule ProjectName.StructCorpusTest do
+  use ExUnit.Case
+
+  test "vendored struct passes the shared corpus" do
+    {pass, fail, failures} = ProjectName.StructCorpus.run()
+
+    if fail > 0 do
+      IO.puts("\n" <> Enum.join(Enum.take(failures, 40), "\n"))
+    end
+
+    IO.puts("\nSTRUCT CORPUS: PASS #{pass}  FAIL #{fail}")
+    assert fail == 0
+  end
+end

package/project/.sdk/tm/elixir/test/support/feature_harness.ex

@@ -0,0 +1,346 @@
+# ProjectName SDK feature test harness
+#
+# Offline harness that drives each feature through a faithful miniature of
+# the real operation pipeline against a configurable mock transport — same
+# hook order and short-circuit rules as the generated op runner, no live
+# server. Everything is a vendored-struct node, exactly like the SDK.
+
+defmodule ProjectName.FeatureHarness do
+  alias Voxgig.Struct, as: S
+  alias ProjectName.Helpers, as: H
+  alias ProjectName.{Control, Spec, Result, Context, Features}
+
+  # True when this SDK was generated with the named feature.
+  def has_feature(name) do
+    feature = S.getprop(ProjectName.Config.make_config(), "feature")
+    S.ismap(feature) and S.getprop(feature, name) != nil
+  end
+
+  # --- deterministic clock -------------------------------------------------
+  # now() advances only when sleep(ms) is called.
+
+  def make_clock(start \\ 0) do
+    S.jm(["_t", start])
+  end
+
+  def clock_now(clock), do: fn -> S.getprop(clock, "_t") end
+  def clock_sleep(clock), do: fn ms -> S.setprop(clock, "_t", S.getprop(clock, "_t") + (ms || 0)) end
+  def clock_time(clock), do: S.getprop(clock, "_t")
+  def clock_advance(clock, ms), do: S.setprop(clock, "_t", S.getprop(clock, "_t") + ms)
+
+  # --- transport helpers ---------------------------------------------------
+
+  def make_response(status, data \\ nil, headers \\ nil) do
+    lower = S.jm([])
+
+    if S.ismap(headers) do
+      Enum.each(H.entries(headers), fn {k, v} -> S.setprop(lower, String.downcase(to_string(k)), v) end)
+    end
+
+    S.jm([
+      "status", status,
+      "statusText", if(is_integer(status) and status < 400, do: "OK", else: "ERR"),
+      "body", "not-used",
+      "json", fn -> data end,
+      "headers", lower
+    ])
+  end
+
+  def default_server do
+    fn _ctx, _url, fetchdef ->
+      method = String.upcase(to_string(H.or_(S.getprop(fetchdef, "method"), "GET")))
+
+      if method == "GET" do
+        {make_response(200, S.jm(["ok", true, "method", method])), nil}
+      else
+        {make_response(200, S.jm(["ok", true, "method", method, "echo", S.getprop(fetchdef, "body")])), nil}
+      end
+    end
+  end
+
+  # A transport recording every call. `reply` (fn n, fetchdef -> resp | {resp, err})
+  # customises responses. Returns {server_fn, calls_node}.
+  def recording_server(reply \\ nil) do
+    calls = S.jt([])
+
+    server = fn _ctx, url, fetchdef ->
+      S.setprop(calls, S.size(calls), S.jm(["url", url, "fetchdef", fetchdef]))
+      n = S.size(calls)
+
+      if reply != nil do
+        out = reply.(n, fetchdef)
+
+        case out do
+          {resp, err} -> {resp, err}
+          resp -> {resp, nil}
+        end
+      else
+        {make_response(200, S.jm(["ok", true, "n", n])), nil}
+      end
+    end
+
+    {server, calls}
+  end
+
+  def default_method("create"), do: "POST"
+  def default_method("update"), do: "PATCH"
+  def default_method("remove"), do: "DELETE"
+  def default_method(_), do: "GET"
+
+  def build_url(spec) do
+    query = H.or_(S.getprop(spec, "query"), S.jm([]))
+
+    keys =
+      S.keysof(query)
+      |> Enum.filter(fn k -> S.getprop(query, k) != nil end)
+      |> Enum.sort()
+
+    qs =
+      keys
+      |> Enum.map(fn k -> S.escurl(to_string(k)) <> "=" <> S.escurl(to_string(S.getprop(query, k))) end)
+      |> Enum.join("&")
+
+    S.getprop(spec, "base") <> H.or_(S.getprop(spec, "path"), "") <> if(qs != "", do: "?" <> qs, else: "")
+  end
+
+  # --- mini pipeline objects ----------------------------------------------
+
+  defp mk_utility(fetcher) do
+    u = S.jm([])
+    S.setprop(u, "fetcher", fetcher)
+
+    param =
+      fn ctx, name ->
+        spec = S.getprop(ctx, "spec")
+        params = if spec != nil, do: S.getprop(spec, "params"), else: nil
+        query = if spec != nil, do: S.getprop(spec, "query"), else: nil
+        val = if S.ismap(params), do: S.getprop(params, name), else: nil
+        if val != nil, do: val, else: if(S.ismap(query), do: S.getprop(query, name), else: nil)
+      end
+
+    S.setprop(u, "param", param)
+    u
+  end
+
+  defp mk_client(mode, options) do
+    c = S.jm([])
+    S.setprop(c, "mode", mode)
+    S.setprop(c, "features", [])
+    S.setprop(c, "options", options)
+    c
+  end
+
+  defp mk_op(name, entity) do
+    S.jm(["name", name, "entity", entity, "input", "match", "points", S.jt([]), "alias", nil])
+  end
+
+  defp mk_entity(name), do: S.jm(["_name", name])
+
+  defp mk_ctx(client, utility, op, entity, ctrl) do
+    ctx = S.jm([])
+    S.setprop(ctx, "id", "C" <> Integer.to_string(:rand.uniform(89_999_999) + 10_000_000))
+    S.setprop(ctx, "client", client)
+    S.setprop(ctx, "utility", utility)
+    S.setprop(ctx, "out", S.jm([]))
+    S.setprop(ctx, "ctrl", if(ctrl != nil, do: ctrl, else: Control.new(nil)))
+    S.setprop(ctx, "meta", S.jm([]))
+    S.setprop(ctx, "op", op)
+    S.setprop(ctx, "entity", entity)
+    S.setprop(ctx, "spec", nil)
+    S.setprop(ctx, "response", nil)
+    S.setprop(ctx, "result", nil)
+    S.setprop(ctx, "shared", S.jm([]))
+    ctx
+  end
+
+  # --- construction --------------------------------------------------------
+  # opts: %{features: [%{"name"=>..,"options"=>node}], server:, mode:, base:, headers: node}
+  def new(feature_specs, opts \\ %{}) do
+    base = Map.get(opts, :base, "http://api.test")
+    headers = Map.get(opts, :headers) || S.jm([])
+    server = Map.get(opts, :server) || default_server()
+    mode = Map.get(opts, :mode, "test")
+
+    utility = mk_utility(server)
+
+    client =
+      mk_client(mode, S.jm(["base", base, "headers", S.clone(headers), "feature", S.jm([])]))
+
+    rootctx = mk_ctx(client, utility, mk_op("root", "_"), nil, nil)
+
+    h = %{client: client, utility: utility, rootctx: rootctx, base: base, headers: headers}
+
+    Enum.each(feature_specs, fn fspec ->
+      name = S.getprop(fspec, "name")
+
+      if has_feature(name) do
+        feature = Features.make_feature(name)
+        fopts = S.jm(["active", true])
+        fspec_opts = S.getprop(fspec, "options")
+
+        if S.ismap(fspec_opts) do
+          Enum.each(H.entries(fspec_opts), fn {k, v} -> S.setprop(fopts, k, v) end)
+        end
+
+        S.setprop(S.getprop(client, "options") |> S.getprop("feature"), S.getprop(feature, "name"), fopts)
+        init_fn = S.getprop(feature, "init")
+        if S.isfunc(init_fn), do: init_fn.(rootctx, fopts)
+        S.setprop(client, "features", S.getprop(client, "features") ++ [feature])
+      end
+    end)
+
+    feature_hook(h, rootctx, "PostConstruct")
+    h
+  end
+
+  def feature(h, name) do
+    Enum.find(S.getprop(h.client, "features"), fn f -> S.getprop(f, "name") == name end)
+  end
+
+  def feature_hook(h, ctx, name) do
+    Enum.each(S.getprop(h.client, "features"), fn f ->
+      method = S.getprop(f, name)
+      if S.isfunc(method), do: method.(ctx)
+    end)
+  end
+
+  defp populate_result(ctx, response, fetch_err) do
+    result = Result.new(nil)
+    S.setprop(ctx, "result", result)
+
+    cond do
+      fetch_err != nil ->
+        S.setprop(result, "err", fetch_err)
+
+      response == nil ->
+        S.setprop(result, "err", Context.make_error(ctx, "request_no_response", "response: undefined"))
+
+      H.is_error(response) ->
+        S.setprop(result, "err", response)
+
+      true ->
+        S.setprop(result, "status", S.getprop(response, "status"))
+        S.setprop(result, "status_text", H.or_(S.getprop(response, "statusText"), ""))
+        S.setprop(result, "headers", S.clone(H.or_(S.getprop(response, "headers"), S.jm([]))))
+
+        jf = S.getprop(response, "json")
+        if S.isfunc(jf), do: S.setprop(result, "body", jf.())
+        S.setprop(result, "resdata", S.getprop(result, "body"))
+
+        status = S.getprop(result, "status")
+
+        cond do
+          is_integer(status) and status >= 400 ->
+            S.setprop(result, "err",
+              Context.make_error(ctx, "request_status",
+                "request: " <> Integer.to_string(status) <> ": " <> H.or_(S.getprop(result, "status_text"), "")))
+
+          S.getprop(response, "err") != nil ->
+            S.setprop(result, "err", S.getprop(response, "err"))
+
+          true ->
+            :ok
+        end
+
+        if S.getprop(result, "err") == nil, do: S.setprop(result, "ok", true)
+    end
+  end
+
+  # Run one op through the mini pipeline. opts is a keyword/map:
+  #   op:, entity:, method:, path:, query:(node), headers:(node), body:, ctrl:(node)
+  def op(h, opts \\ %{}) do
+    opname = Map.get(opts, :op, "load")
+    entity = Map.get(opts, :entity, "widget")
+    method = Map.get(opts, :method) || default_method(opname)
+    ctrl = Control.new(Map.get(opts, :ctrl) || S.jm([]))
+
+    ctx = mk_ctx(h.client, h.utility, mk_op(opname, entity), mk_entity(entity), ctrl)
+
+    feature_hook(h, ctx, "PostConstructEntity")
+
+    try do
+      feature_hook(h, ctx, "PrePoint")
+      pre_point = S.getprop(S.getprop(ctx, "out"), "point")
+      if H.is_error(pre_point), do: throw({:harness_raise, pre_point})
+
+      feature_hook(h, ctx, "PreSpec")
+      spec = S.getprop(S.getprop(ctx, "out"), "spec")
+
+      spec =
+        if spec == nil do
+          merged = S.clone(h.headers)
+          uh = Map.get(opts, :headers)
+          if S.ismap(uh), do: Enum.each(H.entries(uh), fn {k, v} -> S.setprop(merged, k, v) end)
+
+          Spec.new(
+            S.jm([
+              "method", method,
+              "base", h.base,
+              "path", Map.get(opts, :path) || ("/" <> entity),
+              "params", S.jm([]),
+              "headers", merged,
+              "query", S.clone(Map.get(opts, :query) || S.jm([])),
+              "body", Map.get(opts, :body),
+              "step", "start"
+            ])
+          )
+        else
+          spec
+        end
+
+      S.setprop(ctx, "spec", spec)
+
+      feature_hook(h, ctx, "PreRequest")
+      S.setprop(spec, "url", build_url(spec))
+
+      response = S.getprop(S.getprop(ctx, "out"), "request")
+
+      {response, fetch_err} =
+        if response == nil do
+          fetchdef =
+            S.jm([
+              "url", S.getprop(spec, "url"),
+              "method", S.getprop(spec, "method"),
+              "headers", S.getprop(spec, "headers"),
+              "body", S.getprop(spec, "body")
+            ])
+
+          S.getprop(h.utility, "fetcher").(ctx, S.getprop(fetchdef, "url"), fetchdef)
+        else
+          {response, nil}
+        end
+
+      S.setprop(ctx, "response", response)
+
+      feature_hook(h, ctx, "PreResponse")
+      populate_result(ctx, response, fetch_err)
+      feature_hook(h, ctx, "PreResult")
+      feature_hook(h, ctx, "PreDone")
+
+      result = S.getprop(ctx, "result")
+
+      if result != nil and S.getprop(result, "ok") == true do
+        %{ok: true, data: S.getprop(result, "resdata"), result: result, ctx: ctx, error: nil}
+      else
+        err =
+          if result != nil and S.getprop(result, "err") != nil do
+            S.getprop(result, "err")
+          else
+            Context.make_error(ctx, "op_failed", "operation failed")
+          end
+
+        throw({:harness_raise, err})
+      end
+    rescue
+      err ->
+        S.setprop(S.getprop(ctx, "ctrl"), "err", err)
+        feature_hook(h, ctx, "PreUnexpected")
+        %{ok: false, error: err, result: S.getprop(ctx, "result"), ctx: ctx, data: nil}
+    catch
+      {:harness_raise, err} ->
+        S.setprop(S.getprop(ctx, "ctrl"), "err", err)
+        feature_hook(h, ctx, "PreUnexpected")
+        %{ok: false, error: err, result: S.getprop(ctx, "result"), ctx: ctx, data: nil}
+    end
+  end
+end