@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/src/cmp/lua/TestDirect_lua.ts

@@ -15,11 +15,26 @@ import {
   serverVarEnv,
   serverVariables,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 import { formatLuaValue } from './utility_lua'
 
 
+// Blocked without the ids its request needs, rather than sent with nil.
+function liveKeysBlock(keys: string[], entidEnvVar: string): string {
+  return 0 === keys.length ? '' : `    if setup.live then
+      for _, _live_key in ipairs({${keys.map((k) => JSON.stringify(k)).join(', ')}}) do
+        if setup.idmap[_live_key] == nil then
+          runner.live_miss(pending, LIVE_STRICT, "Live test blocked: needs " .. _live_key .. " via ${entidEnvVar}")
+        end
+      end
+    end
+`
+}
+
+
 function normalizePathParams(
   parts: string[],
   params: any[],
@@ -145,6 +160,10 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
+  // The *_ENTID key a live test reads a parameter's value from.
+  const liveKey = (param: any): string =>
+    ('id' === param.n ? entity.name : param.n.replace(/_id$/, '')) + '01'
+
   File({ name: entity.name + '_direct_test.' + target.ext }, () => {
 
     Content(`-- ${entity.Name} direct test
@@ -155,26 +174,21 @@ local sdk = require("${model.name}_sdk")
 local helpers = require("core.helpers")
 local runner = require("test.runner")
 
+${liveStrictNote(liveStrict(model, target.name), '--')}
+local LIVE_STRICT = ${liveStrict(model, target.name)}
+
+local function live_ok(result, err)
+  if err ~= nil or type(result) ~= "table" or result["err"] ~= nil or not result["ok"] then
+    return false
+  end
+  local status = helpers.to_int(result["status"])
+  return status >= 200 and status < 300
+end
+
 describe("${entity.Name}Direct", function()
 `)
 
     if (hasList && listPoint) {
-      const listLiveIdKeys: string[] = listParams.map((lp: any) => {
-        return lp.n === 'id'
-          ? entity.name + '01'
-          : lp.n.replace(/_id$/, '') + '01'
-      })
-      const listSkipBlock = listLiveIdKeys.length > 0
-        ? `    if setup.live then
-      for _, _live_key in ipairs({${listLiveIdKeys.map(k => `"${k}"`).join(', ')}}) do
-        if setup.idmap[_live_key] == nil then
-          pending("live test needs " .. _live_key .. " via *_ENTID env var (synthetic IDs only)")
-          return
-        end
-      end
-    end
-`
-        : ''
       Content(`  it("should direct-list-${entity.name}", function()
     local setup = ${entity.name}_direct_setup({
       { id = "direct01" },
@@ -185,58 +199,32 @@ describe("${entity.Name}Direct", function()
       pending(_reason or "skipped via sdk-test-control.json")
       return
     end
-${listSkipBlock}    local client = setup.client
-
-`)
+${liveKeysBlock(listParams.map(liveKey), entidEnvVar)}    local client = setup.client
 
-      if (listParams.length > 0) {
-        Content(`    local params = {}
+    local params = {}
 `)
-        for (const lp of listParams) {
-          const key = lp.n === 'id'
-            ? entity.name + '01'
-            : lp.n.replace(/_id$/, '') + '01'
-          Content(`    if setup.live then
-      params["${lp.n}"] = setup.idmap["${key}"]
+      listParams.forEach((lp: any, i: number) => {
+        Content(`    if setup.live then
+      params["${lp.n}"] = setup.idmap["${liveKey(lp)}"]
     else
-      params["${lp.n}"] = "direct01"
+      params["${lp.n}"] = "direct0${i + 1}"
     end
 `)
-        }
-        Content(`
+      })
+      Content(`
     local result, err = client:direct({
       path = "${listPath}",
       method = "GET",
       params = params,
     })
-`)
-      } else {
-        Content(`
-    local result, err = client:direct({
-      path = "${listPath}",
-      method = "GET",
-      params = {},
-    })
-`)
-      }
-
-      Content(`    if setup.live then
-      -- Live mode is lenient: synthetic IDs frequently 4xx and the list-
-      -- response shape varies wildly across public APIs. Skip rather than
-      -- fail when the call doesn't return a usable list.
-      if err ~= nil then
-        pending("list call failed (likely synthetic IDs against live API): " .. tostring(err))
-        return
-      end
-      if not result["ok"] then
-        pending("list call not ok (likely synthetic IDs against live API)")
-        return
+    if setup.live then
+      if not live_ok(result, err) then
+        runner.live_miss(pending, LIVE_STRICT, "Live list failed: " .. runner.live_describe(result, err))
       end
-      local status = helpers.to_int(result["status"])
-      if status < 200 or status >= 300 then
-        pending("expected 2xx status, got " .. tostring(status))
-        return
+      if runner.live_list(result["data"]) == nil then
+        runner.live_miss(pending, LIVE_STRICT, "Live list returned no list: " .. runner.live_describe(result, err))
       end
+      assert.is_table(runner.live_list(result["data"]))
     else
       assert.is_nil(err)
       assert.is_true(result["ok"])
@@ -251,13 +239,11 @@ ${listSkipBlock}    local client = setup.client
     }
 
     if (hasLoad && loadPoint) {
-      const loadSkipBlock = (loadParams.length > 0 && !loadAllHaveExamples)
-        ? `    if setup.live then
-      pending("live direct-load needs real ID — set *_ENTID env var with real IDs to run")
-      return
-    end
-`
-        : ''
+      const discover = !loadAllHaveExamples && hasList && 0 < loadParams.length
+      const idParam = loadParams.find((p: any) => 'id' === p.n)?.n ?? loadParams[0]?.n ?? 'id'
+      const loadLiveIdKeys: string[] = loadAllHaveExamples ? [] :
+        discover ? listParams.map(liveKey).concat(loadParams.filter((p: any) => idParam !== p.n).map(liveKey)) :
+          loadParams.map(liveKey)
       Content(`  it("should direct-load-${entity.name}", function()
     local setup = ${entity.name}_direct_setup({ id = "direct01" })
     local _should_skip, _reason = runner.is_control_skipped("direct", "direct-load-${entity.name}", setup.live and "live" or "unit")
@@ -265,82 +251,71 @@ ${listSkipBlock}    local client = setup.client
       pending(_reason or "skipped via sdk-test-control.json")
       return
     end
-${loadSkipBlock}    local client = setup.client
+${liveKeysBlock([...new Set(loadLiveIdKeys)], entidEnvVar)}    local client = setup.client
 
-`)
-
-      const needsQuery = loadParams.length > 0 || loadLiveQueryLines !== ''
-      if (needsQuery) {
-        Content(`    local params = {}
+    local params = {}
     local query = {}
+    if setup.live then
+${loadLiveQueryLines ? loadLiveQueryLines + '\n' : ''}`)
+      if (loadAllHaveExamples) {
+        Content(loadExampleLines + '\n')
+      }
+      else if (discover) {
+        Content(`      local list_result, list_err = client:direct({
+        path = "${listPath}",
+        method = "GET",
+        params = {${listParams.map((p: any) => `["${p.n}"] = setup.idmap["${liveKey(p)}"]`).join(', ')}},
+      })
+      if not live_ok(list_result, list_err) then
+        runner.live_miss(pending, LIVE_STRICT, "Live list discovery failed: " .. runner.live_describe(list_result, list_err))
+      end
+      local records = runner.live_list(list_result["data"])
+      if records == nil then
+        runner.live_miss(pending, LIVE_STRICT, "Live list discovery returned no list: " .. runner.live_describe(list_result, list_err))
+      end
+      if records[1] == nil then
+        runner.live_empty(pending, "The account has no ${entity.name} record to load")
+      end
+      local first = type(records[1]) == "table" and records[1] or {}
+      local found = first["${idParam}"] or first["id"]
+      if found == nil then
+        runner.live_miss(pending, LIVE_STRICT, "Live load blocked: discovery returned no usable identity")
+      end
+      params["${idParam}"] = found
 `)
-        if (loadAllHaveExamples) {
-          Content(`    if setup.live then
-`)
-          if (loadLiveQueryLines) Content(loadLiveQueryLines + '\n')
-          Content(loadExampleLines + '\n')
-          Content(`    else
-`)
-          for (let i = 0; i < loadParams.length; i++) {
-            Content(`      params["${loadParams[i].n}"] = "direct0${i + 1}"
-`)
-          }
-          Content(`    end
-`)
-        } else if (loadParams.length > 0) {
-          if (loadLiveQueryLines) {
-            Content(`    if setup.live then
-${loadLiveQueryLines}
-    end
+        for (const p of loadParams.filter((p: any) => idParam !== p.n)) {
+          Content(`      params["${p.n}"] = setup.idmap["${liveKey(p)}"]
 `)
-          }
-          Content(`    if not setup.live then
-`)
-          for (let i = 0; i < loadParams.length; i++) {
-            Content(`      params["${loadParams[i].n}"] = "direct0${i + 1}"
+        }
+      }
+      else {
+        for (const p of loadParams) {
+          Content(`      params["${p.n}"] = setup.idmap["${liveKey(p)}"]
 `)
-          }
-          Content(`    end
+        }
+      }
+      Content(`    else
 `)
-        } else if (loadLiveQueryLines) {
-          Content(`    if setup.live then
-${loadLiveQueryLines}
-    end
+      for (let i = 0; i < loadParams.length; i++) {
+        Content(`      params["${loadParams[i].n}"] = "direct0${i + 1}"
 `)
-        }
       }
+      Content(`    end
 
-      Content(`
     local result, err = client:direct({
       path = "${loadPath}",
       method = "GET",
-`)
-      if (needsQuery) {
-        Content(`      params = params,
+      params = params,
       query = query,
-`)
-      } else {
-        Content(`      params = {},
-`)
-      }
-      Content(`    })
+    })
     if setup.live then
-      -- Live mode is lenient: synthetic IDs frequently 4xx. Skip rather
-      -- than fail when the load endpoint isn't reachable with the IDs we
-      -- can construct from setup.idmap.
-      if err ~= nil then
-        pending("load call failed (likely synthetic IDs against live API): " .. tostring(err))
-        return
+      if not live_ok(result, err) then
+        runner.live_miss(pending, LIVE_STRICT, "Live load failed: " .. runner.live_describe(result, err))
       end
-      if not result["ok"] then
-        pending("load call not ok (likely synthetic IDs against live API)")
-        return
-      end
-      local status = helpers.to_int(result["status"])
-      if status < 200 or status >= 300 then
-        pending("expected 2xx status, got " .. tostring(status))
-        return
+      if result["data"] == nil then
+        runner.live_miss(pending, LIVE_STRICT, "Live load returned no data: " .. runner.live_describe(result, err))
       end
+      assert.is_not_nil(result["data"])
     else
       assert.is_nil(err)
       assert.is_true(result["ok"])
@@ -382,11 +357,12 @@ function ${entity.name}_direct_setup(mockres)
       end
     end
     local client = sdk.new(merged_opts)
+    local idmap = env["${entidEnvVar}"]
     return {
       client = client,
       calls = calls,
       live = true,
-      idmap = {},
+      idmap = type(idmap) == "table" and idmap or {},
     }
   end
 

package/project/.sdk/src/cmp/lua/TestEntity_lua.ts

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable } from '@voxgig/sdkgen'
 
 import {
   flatten,
@@ -27,7 +27,9 @@ import {
   isAuthActive,
   entityDataIdField, envName, envToken,
   serverVarEnv,
-  serverVariables
+  serverVariables,
+  invalidRequest,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 import { formatLuaValue } from './utility_lua'
@@ -44,6 +46,45 @@ type GenCtx = {
 type OpGen = (ctx: GenCtx, step: ModelEntityFlowStep, index: number) => void
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, a create-less load reading the first listed record, and
+// a lenient run observing its checks rather than failing on them.
+function liveFlowGate(entity: any, needs: any, entidEnv: string, strict: boolean): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `    if setup.live then
+      for _, _live_key in ipairs({${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')}}) do
+        if setup.synthetic_only or setup.idmap[_live_key] == nil then
+          runner.live_miss(pending, LIVE_STRICT, "Live entity test blocked: needs " .. _live_key .. " via ${entidEnv}")
+        end
+      end
+    end
+`
+  }
+  if (null != needs.blocked) {
+    out += `    if setup.live then
+      runner.live_miss(pending, LIVE_STRICT, "Live entity test blocked: " .. ${JSON.stringify(needs.blocked)})
+    end
+`
+  }
+  out += '    local client = setup.client\n'
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => `[${JSON.stringify(k)}] = setup.idmap[${JSON.stringify(v)}]`).join(', ')
+    out += `    if setup.live then
+      runner.live_existing(pending, setup, LIVE_STRICT, ${JSON.stringify(entity.name)}, function()
+        return client:${entity.Name}(nil):list({${match}}, nil)
+      end)
+    end
+`
+  }
+  if (!strict) {
+    out += '    local _live_ok, _live_err = pcall(function()\n'
+  }
+  return out
+}
+
+
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model
@@ -51,11 +92,11 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const target = props.target
   const entity: ModelEntity = props.entity
 
-  // The stream test streams the "list" op and asserts a 3-item collection, so
-  // it only applies to entities that declare a list op. Others (e.g. Batch =
-  // create/load) have no list endpoint — make_point errors and the stream
-  // yields nothing — so skip the stream test for them.
-  const hasList = !!(entity.op && (entity.op as any)?.list)
+  // The stream test streams the "list" op with no match and asserts a 3-item
+  // collection, so it only applies to an entity whose list a bare call can
+  // reach: not one without a list (e.g. Batch = create/load), not a nested
+  // list needing its parent's id, and not one whose routes all need an action.
+  const hasList = opReachable((entity.op as any)?.list, [])
 
   const basicflow: ModelEntityFlow | undefined =
     getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
@@ -98,6 +139,10 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, flow: basicflow, PROJUPPER }
 
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+  const entidEnv = PROJUPPER + '_TEST_' + envToken(entity.name) + '_ENTID'
+
   File({ name: entity.name + '_entity_test.' + target.ext }, () => {
 
     Content(`-- ${entity.Name} entity test
@@ -110,6 +155,10 @@ local runner = require("test.runner")
 
 local _test_dir = debug.getinfo(1, "S").source:match("^@(.+/)")  or "./"
 
+${liveStrictNote(strict, '--')}
+local LIVE_STRICT = ${strict}
+
+${hasList ? failHookClass(entity) : ''}
 describe("${entity.Name}Entity", function()
   it("should create instance", function()
     local testsdk = sdk.test(nil, nil)
@@ -157,7 +206,7 @@ ${hasList ? `
       assert.are.equal(3, #got)
     end
   end)
-` : ''}
+${failureTests(entity)}` : ''}${validateTest(entity)}
   it("should run basic flow", function()
     local setup = ${entity.name}_basic_setup(nil)
     -- Per-op sdk-test-control.json skip.
@@ -169,14 +218,7 @@ ${hasList ? `
         return
       end
     end
-    -- The basic flow consumes synthetic IDs from the fixture. In live mode
-    -- without an *_ENTID env override, those IDs hit the live API and 4xx.
-    if setup.synthetic_only then
-      pending("live entity test uses synthetic IDs from fixture — set ${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID JSON to run live")
-      return
-    end
-    local client = setup.client
-
+${liveFlowGate(entity, needs, entidEnv, strict)}
 `)
 
     // Check if the flow has a create step
@@ -210,7 +252,11 @@ ${hasList ? `
       }
     })
 
-    Content(`  end)
+    Content(`${strict ? '' : `    end)
+    if not _live_ok then
+      runner.live_observe(pending, _live_err, setup, LIVE_STRICT)
+    end
+`}  end)
 end)
 
 `)
@@ -250,9 +296,8 @@ end)
 
 `)
 
-    Content(`  -- Detect ENTID env override before envOverride consumes it. When live
-  -- mode is on without a real override, the basic test runs against synthetic
-  -- IDs from the fixture and 4xx's. Surface this so the test can skip.
+    Content(`  -- Whether *_ENTID supplied the idmap, read before env_override consumes
+  -- it: without it, the ids a live flow binds are the fixture's synthetic ones.
   local entid_env_raw = os.getenv("${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID")
   local idmap_overridden = entid_env_raw ~= nil and entid_env_raw:match("^%s*{") ~= nil
 
@@ -608,6 +653,114 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A feature whose PreSpec hook raises, counting the PreUnexpected calls it sees.
+function failHookClass(entity: ModelEntity): string {
+  return `
+local BaseFeature = require("feature.base_feature")
+
+local FailHook = {}
+FailHook.__index = FailHook
+setmetatable(FailHook, { __index = BaseFeature })
+
+function FailHook.new()
+  local self = setmetatable(BaseFeature.new(), FailHook)
+  self.name = "failhook"
+  self.unexpected = 0
+  return self
+end
+
+function FailHook:init(_ctx, _options) end
+function FailHook:PreSpec(_ctx) error("${entity.name} hook failed") end
+function FailHook:PreUnexpected(_ctx) self.unexpected = self.unexpected + 1 end
+
+local function errtext(err)
+  if type(err) == "table" then
+    return tostring(err.msg or err.message or "")
+  end
+  return tostring(err)
+end
+`
+}
+
+
+// A failed operation raises from a stream as it fails the operation: a
+// transport failure, and a hook that rejects the call. A raising hook fires
+// PreUnexpected, and under throw false the call returns no error. The
+// caller's ctrl stays its own.
+function failureTests(entity: ModelEntity): string {
+  const Entity = entity.Name
+  return `
+  it("should report a failed stream", function()
+    local offline = { net = { offline = true } }
+    local ok, err = pcall(function()
+      for _ in sdk.test(offline, nil):${Entity}(nil):stream("list", nil, nil) do end
+    end)
+    assert.is_false(ok)
+    assert.truthy(string.find(errtext(err), "offline", 1, true))
+
+    for _ in sdk.test(offline, nil):${Entity}(nil):stream("list", nil, { ctrl = { throw = false } }) do end
+
+    local config = require("config_shared")()
+    if type(config.feature) == "table" and config.feature.rbac ~= nil then
+      local denied = sdk.test(nil, { feature = { rbac = { active = true, deny = true } } })
+      local dok, derr = pcall(function()
+        for _ in denied:${Entity}(nil):stream("list", nil, nil) do end
+      end)
+      assert.is_false(dok)
+      assert.are.equal("rbac_denied", type(derr) == "table" and derr.code or nil)
+    end
+  end)
+
+  it("should leave the caller's ctrl", function()
+    local explain = {}
+    local ctrl = { explain = explain }
+    for _ in sdk.test(nil, nil):${Entity}(nil):stream("list", nil, { ctrl = ctrl }) do end
+    assert.is_nil(ctrl.stream)
+    assert.are.equal(explain, ctrl.explain)
+    assert.is_not_nil(next(explain))
+  end)
+
+  it("should fire PreUnexpected", function()
+    local hook = FailHook.new()
+    local client = sdk.new({ feature = { test = { active = true } }, extend = { hook } })
+
+    local out, err = client:${Entity}(nil):list(nil, nil)
+    assert.is_nil(out)
+    assert.truthy(string.find(errtext(err), "hook failed", 1, true))
+    assert.is_true(hook.unexpected > 0)
+
+    local fired = hook.unexpected
+    out, err = client:${Entity}(nil):list(nil, { throw = false })
+    assert.is_nil(err)
+    assert.is_true(hook.unexpected > fired)
+  end)
+`
+}
+
+
+// An invalid request fails with validate's own error, before it is sent.
+function validateTest(entity: ModelEntity): string {
+  const bad = invalidRequest(entity)
+  if (null == bad) {
+    return ''
+  }
+  const args = Object.entries(bad.args)
+    .map(([k, v]) => '[' + JSON.stringify(k) + '] = ' + formatLuaValue(v)).join(', ')
+  return `
+  it("should refuse an invalid request", function()
+    local config = require("config_shared")()
+    if type(config.feature) ~= "table" or config.feature.validate == nil then
+      pending("feature not present in this SDK: validate")
+      return
+    end
+    local client = sdk.test(nil, { feature = { validate = { active = true } } })
+    local _, err = client:${entity.Name}(nil):${bad.op}({ ${args} }, nil)
+    assert.are.equal("validate_failed", type(err) == "table" and err.code or nil)
+  end)
+`
+}
+
+
 export {
   TestEntity
 }