@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/src/cmp/rb/TestDirect_rb.ts

@@ -15,11 +15,26 @@ import {
   serverVarEnv,
   serverVariables,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 import { formatRubyValue } from './utility_rb'
 
 
+// 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]
+      [${keys.map((k) => JSON.stringify(k)).join(', ')}].each do |_live_key|
+        if setup[:idmap][_live_key].nil?
+          Runner.live_miss(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,25 +174,17 @@ require_relative "../${model.const.Name}_sdk"
 require_relative "runner"
 
 class ${entity.Name}DirectTest < Minitest::Test
+${liveStrictNote(liveStrict(model, target.name), '#', '  ')}
+  LIVE_STRICT = ${liveStrict(model, target.name)}
+
+  def live_ok(result)
+    status = Helpers.to_int(result["status"])
+    result["err"].nil? && result["ok"] && status >= 200 && status < 300
+  end
+
 `)
 
     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]
-      [${listLiveIdKeys.map(k => `"${k}"`).join(', ')}].each do |_live_key|
-        if setup[:idmap][_live_key].nil?
-          skip "live test needs #{_live_key} via *_ENTID env var (synthetic IDs only)"
-          return
-        end
-      end
-    end
-`
-        : ''
       Content(`  def test_direct_list_${entity.name}
     setup = ${entity.name}_direct_setup([
       { "id" => "direct01" },
@@ -184,58 +195,28 @@ class ${entity.Name}DirectTest < Minitest::Test
       skip(_reason || "skipped via sdk-test-control.json")
       return
     end
-${listSkipBlock}    client = setup[:client]
+${liveKeysBlock(listParams.map(liveKey), entidEnvVar)}    client = setup[:client]
 
+    params = {}
 `)
-
-      if (listParams.length > 0) {
-        Content(`    params = {}
+      listParams.forEach((lp: any, i: number) => {
+        Content(`    params["${lp.n}"] = setup[:live] ? setup[:idmap]["${liveKey(lp)}"] : "direct0${i + 1}"
 `)
-        for (const lp of listParams) {
-          const key = lp.n === 'id'
-            ? entity.name + '01'
-            : lp.n.replace(/_id$/, '') + '01'
-          Content(`    if setup[:live]
-      params["${lp.n}"] = setup[:idmap]["${key}"]
-    else
-      params["${lp.n}"] = "direct01"
-    end
-`)
-        }
-        Content(`
+      })
+      Content(`
     result = client.direct({
       "path" => "${listPath}",
       "method" => "GET",
       "params" => params,
     })
-`)
-      } else {
-        Content(`
-    result = client.direct({
-      "path" => "${listPath}",
-      "method" => "GET",
-      "params" => {},
-    })
-`)
-      }
-
-      Content(`    if setup[:live]
-      # 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 !result["err"].nil?
-        skip("list call failed (likely synthetic IDs against live API): #{result["err"]}")
-        return
-      end
-      unless result["ok"]
-        skip("list call not ok (likely synthetic IDs against live API)")
-        return
+    if setup[:live]
+      unless live_ok(result)
+        Runner.live_miss(LIVE_STRICT, "Live list failed: " + Runner.live_describe(result))
       end
-      status = Helpers.to_int(result["status"])
-      if status < 200 || status >= 300
-        skip("expected 2xx status, got #{status}")
-        return
+      if Runner.live_list(result["data"]).nil?
+        Runner.live_miss(LIVE_STRICT, "Live list returned no list: " + Runner.live_describe(result))
       end
+      assert Runner.live_list(result["data"]).is_a?(Array)
     else
       assert_nil result["err"]
       assert result["ok"]
@@ -250,13 +231,11 @@ ${listSkipBlock}    client = setup[:client]
     }
 
     if (hasLoad && loadPoint) {
-      const loadSkipBlock = (loadParams.length > 0 && !loadAllHaveExamples)
-        ? `    if setup[:live]
-      skip "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(`  def test_direct_load_${entity.name}
     setup = ${entity.name}_direct_setup({ "id" => "direct01" })
     _should_skip, _reason = Runner.is_control_skipped("direct", "direct-load-${entity.name}", setup[:live] ? "live" : "unit")
@@ -264,82 +243,71 @@ ${listSkipBlock}    client = setup[:client]
       skip(_reason || "skipped via sdk-test-control.json")
       return
     end
-${loadSkipBlock}    client = setup[:client]
+${liveKeysBlock([...new Set(loadLiveIdKeys)], entidEnvVar)}    client = setup[:client]
 
-`)
-
-      const needsQuery = loadParams.length > 0 || loadLiveQueryLines !== ''
-      if (needsQuery) {
-        Content(`    params = {}
+    params = {}
     query = {}
+    if setup[:live]
+${loadLiveQueryLines ? loadLiveQueryLines + '\n' : ''}`)
+      if (loadAllHaveExamples) {
+        Content(loadExampleLines + '\n')
+      }
+      else if (discover) {
+        Content(`      list_result = client.direct({
+        "path" => "${listPath}",
+        "method" => "GET",
+        "params" => {${listParams.map((p: any) => `"${p.n}" => setup[:idmap]["${liveKey(p)}"]`).join(', ')}},
+      })
+      unless live_ok(list_result)
+        Runner.live_miss(LIVE_STRICT, "Live list discovery failed: " + Runner.live_describe(list_result))
+      end
+      records = Runner.live_list(list_result["data"])
+      if records.nil?
+        Runner.live_miss(LIVE_STRICT, "Live list discovery returned no list: " + Runner.live_describe(list_result))
+      end
+      if records.empty?
+        Runner.live_empty("The account has no ${entity.name} record to load")
+      end
+      first = records[0].is_a?(Hash) ? records[0] : {}
+      found = first.fetch("${idParam}", first["id"])
+      if found.nil?
+        Runner.live_miss(LIVE_STRICT, "Live load blocked: discovery returned no usable identity")
+      end
+      params["${idParam}"] = found
 `)
-        if (loadAllHaveExamples) {
-          Content(`    if setup[:live]
-`)
-          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]
-${loadLiveQueryLines}
-    end
+        for (const p of loadParams.filter((p: any) => idParam !== p.n)) {
+          Content(`      params["${p.n}"] = setup[:idmap]["${liveKey(p)}"]
 `)
-          }
-          Content(`    unless setup[:live]
-`)
-          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]
-${loadLiveQueryLines}
-    end
+      for (let i = 0; i < loadParams.length; i++) {
+        Content(`      params["${loadParams[i].n}"] = "direct0${i + 1}"
 `)
-        }
       }
+      Content(`    end
 
-      Content(`
     result = client.direct({
       "path" => "${loadPath}",
       "method" => "GET",
-`)
-      if (needsQuery) {
-        Content(`      "params" => params,
+      "params" => params,
       "query" => query,
-`)
-      } else {
-        Content(`      "params" => {},
-`)
-      }
-      Content(`    })
+    })
     if setup[:live]
-      # 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 !result["err"].nil?
-        skip("load call failed (likely synthetic IDs against live API): #{result["err"]}")
-        return
+      unless live_ok(result)
+        Runner.live_miss(LIVE_STRICT, "Live load failed: " + Runner.live_describe(result))
       end
-      unless result["ok"]
-        skip("load call not ok (likely synthetic IDs against live API)")
-        return
-      end
-      status = Helpers.to_int(result["status"])
-      if status < 200 || status >= 300
-        skip("expected 2xx status, got #{status}")
-        return
+      if result["data"].nil?
+        Runner.live_miss(LIVE_STRICT, "Live load returned no data: " + Runner.live_describe(result))
       end
+      assert !result["data"].nil?
     else
       assert_nil result["err"]
       assert result["ok"]
@@ -376,11 +344,12 @@ def ${entity.name}_direct_setup(mockres)
     merged_opts = Runner.live_client_options.merge({${apikeyLiveField}${serverLiveField}
     })
     client = ${model.const.Name}SDK.new(merged_opts)
+    idmap = env["${entidEnvVar}"]
     return {
       client: client,
       calls: calls,
       live: true,
-      idmap: {},
+      idmap: idmap.is_a?(Hash) ? idmap : {},
     }
   end
 

package/project/.sdk/src/cmp/rb/TestEntity_rb.ts

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable } from '@voxgig/sdkgen'
 
 import {
   flatten,
@@ -27,12 +27,49 @@ import {
   isAuthActive,
   entityDataIdField, envName, envToken,
   serverVarEnv,
-  serverVariables
+  serverVariables,
+  invalidRequest,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 import { formatRubyValue } from './utility_rb'
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, and a create-less load reading the first listed record.
+function liveFlowGate(entity: any, needs: any, entidEnv: string): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `    if setup[:live]
+      [${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')}].each do |_live_key|
+        if setup[:synthetic_only] || setup[:idmap][_live_key].nil?
+          Runner.live_miss(LIVE_STRICT, "Live entity test blocked: needs #{_live_key} via ${entidEnv}")
+        end
+      end
+    end
+`
+  }
+  if (null != needs.blocked) {
+    out += `    if setup[:live]
+      Runner.live_miss(LIVE_STRICT, "Live entity test blocked: " + ${JSON.stringify(needs.blocked)})
+    end
+`
+  }
+  out += '    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]
+      Runner.live_existing(setup, LIVE_STRICT, ${JSON.stringify(entity.name)}) do
+        client.${entity.Name}(nil).list({${match}}, nil)
+      end
+    end
+`
+  }
+  return out
+}
+
+
 // See TestEntity_ts.ts for the GenCtx/OpGen contract.
 type GenCtx = {
   model: Model
@@ -51,11 +88,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 +135,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
@@ -108,12 +149,33 @@ require_relative "../${model.const.Name}_sdk"
 require_relative "runner"
 
 class ${entity.Name}EntityTest < Minitest::Test
+${liveStrictNote(strict, '#', '  ')}
+  LIVE_STRICT = ${strict}
+
   def test_create_instance
     testsdk = ${model.const.Name}SDK.test(nil, nil)
     ent = testsdk.${entity.Name}(nil)
     assert !ent.nil?
   end
 ${hasList ? `
+  def test_list_entities
+    seed = {
+      "entity" => {
+        "${entity.name}" => {
+          "l1" => { "id" => "l1" },
+          "l2" => { "id" => "l2" },
+        },
+      },
+    }
+    items = ${model.const.Name}SDK.test(seed, nil).${entity.Name}(nil).list(nil, nil)
+    # list resolves to one entity per record; data_get reads the record.
+    assert_equal 2, items.length
+    items.each do |item|
+      assert item.respond_to?(:data_get)
+      assert item.data_get.is_a?(Hash)
+    end
+  end
+
   # Feature #4: the entity stream(action, ...) method runs the op pipeline and
   # returns an Enumerator over result items. With the streaming feature active
   # it yields the feature's incremental output; otherwise it falls back to the
@@ -149,7 +211,7 @@ ${hasList ? `
       assert_equal 3, got.length
     end
   end
-` : ''}
+${failureTests(model, entity)}` : ''}${validateTest(model, entity)}
   def test_basic_flow
     setup = ${entity.name}_basic_setup(nil)
     # Per-op sdk-test-control.json skip.
@@ -161,14 +223,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]
-      skip "live entity test uses synthetic IDs from fixture — set ${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID JSON to run live"
-      return
-    end
-    client = setup[:client]
-
+${liveFlowGate(entity, needs, entidEnv)}
 `)
 
     // Check if the flow has a create step
@@ -202,7 +257,11 @@ ${hasList ? `
       }
     })
 
-    Content(`  end
+    Content(`${strict ? '' : `  rescue Minitest::Skip
+    raise
+  rescue StandardError, Minitest::Assertion => e
+    Runner.live_observe(e, setup, LIVE_STRICT)
+`}  end
 end
 
 `)
@@ -212,7 +271,7 @@ end
   Runner.load_env_local
 
   entity_data_file = File.join(__dir__, "..", "..", ".sdk", "test", "entity", "${entity.name}", "${entity.Name}TestData.json")
-  entity_data_source = File.read(entity_data_file)
+  entity_data_source = File.read(entity_data_file, encoding: "UTF-8")
   entity_data = JSON.parse(entity_data_source)
 
   options = {}
@@ -236,9 +295,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.
   entid_env_raw = ENV["${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID"]
   idmap_overridden = !entid_env_raw.nil? && entid_env_raw.strip.start_with?("{")
 
@@ -588,6 +646,104 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A failed operation raises from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A raising hook fires
+// PreUnexpected, and under throw false the call returns nil. The caller's
+// ctrl stays its own.
+function failureTests(model: Model, entity: ModelEntity): string {
+  const Name = model.const.Name
+  const Entity = entity.Name
+  return `
+  class FailHook < ${Name}BaseFeature
+    attr_reader :unexpected
+
+    def initialize
+      super()
+      @name = "failhook"
+      @unexpected = 0
+    end
+
+    def PreSpec(ctx)
+      raise "${entity.name} hook failed"
+    end
+
+    def PreUnexpected(ctx)
+      @unexpected += 1
+    end
+  end
+
+  def test_stream_error
+    offline = { "net" => { "offline" => true } }
+    err = assert_raises(StandardError) do
+      ${Name}SDK.test(offline, nil).${Entity}(nil).stream("list", nil, nil).to_a
+    end
+    assert_match(/offline/, err.message)
+
+    ${Name}SDK.test(offline, nil).${Entity}(nil)
+      .stream("list", nil, { "ctrl" => { "throw" => false } }).to_a
+
+    cfg = ${Name}Config.shared_config
+    if cfg["feature"].is_a?(Hash) && cfg["feature"].key?("rbac")
+      denied = ${Name}SDK.test(nil, { "feature" => { "rbac" => { "active" => true, "deny" => true } } })
+      err = assert_raises(StandardError) do
+        denied.${Entity}(nil).stream("list", nil, nil).to_a
+      end
+      assert_equal "rbac_denied", err.code
+    end
+  end
+
+  def test_stream_ctrl
+    explain = {}
+    ctrl = { "explain" => explain }
+    ${Name}SDK.test(nil, nil).${Entity}(nil).stream("list", nil, { "ctrl" => ctrl }).to_a
+    assert_equal ["explain"], ctrl.keys
+    assert_same explain, ctrl["explain"]
+    refute_empty explain
+  end
+
+  def test_unexpected
+    hook = FailHook.new
+    client = ${Name}SDK.new({ "feature" => { "test" => { "active" => true } }, "extend" => [hook] })
+
+    err = assert_raises(StandardError) do
+      client.${Entity}(nil).list(nil, nil)
+    end
+    assert_match(/hook failed/, err.message)
+    assert_operator hook.unexpected, :>, 0
+
+    fired = hook.unexpected
+    assert_nil client.${Entity}(nil).list(nil, { "throw" => false })
+    assert_operator hook.unexpected, :>, fired
+  end
+`
+}
+
+
+// An invalid request fails with validate's own error, before it is sent.
+function validateTest(model: Model, entity: ModelEntity): string {
+  const bad = invalidRequest(entity)
+  if (null == bad) {
+    return ''
+  }
+  const Name = model.const.Name
+  const args = Object.entries(bad.args)
+    .map(([k, v]) => JSON.stringify(k) + ' => ' + formatRubyValue(v)).join(', ')
+  return `
+  def test_validate
+    cfg = ${Name}Config.shared_config
+    unless cfg["feature"].is_a?(Hash) && cfg["feature"].key?("validate")
+      skip("feature not present in this SDK: validate")
+    end
+    client = ${Name}SDK.test(nil, { "feature" => { "validate" => { "active" => true } } })
+    err = assert_raises(StandardError) do
+      client.${entity.Name}(nil).${bad.op}({ ${args} }, nil)
+    end
+    assert_equal "validate_failed", err.code
+  end
+`
+}
+
+
 export {
   TestEntity
 }