@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/src/cmp/ts/TestClean_ts.ts

@@ -148,10 +148,34 @@ const SCENARIOS: Scenario[] = [
   { name: 'coded', respond: (_url: string, _fetchdef: any, ctx: any) => {
     throw ctx.error('denied_' + CANARY.apikey, 'coded failure')
   } },
+  // fetch rejects a timed-out or aborted request with a DOMException, whose
+  // message is a getter with no setter.
+  { name: 'timeout', respond: (url: string) => {
+    throw new DOMException('timed out sending ' + CANARY.apikey + ' (URL was: "' + url + '")', 'TimeoutError')
+  } },
 ]
 
 
-function makeSdk(scenario: Scenario, sinks: Sink[], cleanopts?: any, extra?: any[]): any {
+// Offline, as every generated suite is: the test OPTION resolves a required
+// server variable to test-<name>, and installs no transport.
+function offline(opts: any): any {
+  return { ...opts, test: { active: true } }
+}
+
+
+// A client the sweep cannot build leaves nothing swept: a harness error, not a leak.
+function construct(opts: any): any {
+  try {
+    return new (SDK as any)(offline(opts))
+  }
+  catch (err: any) {
+    throw new Error('clean harness: the client could not be constructed, so nothing was swept: ' +
+      (err?.message ?? String(err)))
+  }
+}
+
+
+function makeSdk(scenario: Scenario, sinks: Sink[], cleanopts?: any, extra?: any[], auth?: any): any {
   const capture = (name: string) => (rec: any) => { sinks.push(...forms(name, rec)) }
   const feature: any = {}
   if (hasFeature('log')) {
@@ -180,7 +204,8 @@ function makeSdk(scenario: Scenario, sinks: Sink[], cleanopts?: any, extra?: any
   }
   // null builds the client with no clean block at all, as most callers do.
   if (null !== cleanopts) opts.clean = { values: CANARY.value, ...(cleanopts || {}) }
-  return new (SDK as any)(opts)
+  if (null != auth) opts.auth = auth
+  return construct(opts)
 }
 
 
@@ -189,7 +214,7 @@ function makeSdk(scenario: Scenario, sinks: Sink[], cleanopts?: any, extra?: any
 type Target = { accessor: string, op: string, match: any }
 
 async function usableOp(): Promise<Target | null> {
-  const plain = new (SDK as any)({
+  const plain = construct({
     apikey: CANARY.apikey,
     utility: { fetcher: async () => response(200, { id: 'i1' }) },
   })
@@ -268,16 +293,19 @@ class StreamOkFeature extends BaseFeature {
 async function drive(sdk: any, target: Target, ctrl: any, sinks: Sink[]) {
   // A caller may keep the record it passed rather than read ctrl.explain.
   const held = ctrl.explain
+  const entity = sdk[target.accessor]()
   let out: any = undefined
   let err: any = undefined
   try {
-    out = await sdk[target.accessor]()[target.op]({ ...target.match }, ctrl)
+    out = await entity[target.op]({ ...target.match }, ctrl)
   }
   catch (e: any) {
     err = e
   }
   if (undefined !== err) sinks.push(...forms('error', err))
   if (undefined !== out) sinks.push(...forms('result', out))
+  // Raw, as a caller copying the match into another query reads it.
+  sinks.push(...forms('match', entity.match()))
   if (null != ctrl.explain) sinks.push(...forms('explain', ctrl.explain))
   if (null != held && held !== ctrl.explain) sinks.push(...forms('explain:held', held))
   return err
@@ -312,12 +340,17 @@ describe('clean', () => {
       }
     }
 
+    // A name given at run time replaces the declared one: the match leaves
+    // out whichever name prepareAuth placed.
+    await drive(makeSdk(SCENARIOS[0], sinks, undefined, undefined, { name: 'zzcred' }),
+      target, {}, sinks)
+
     // A credential mistyped as an object is rejected by validation, whose
     // message quotes the value it rejected; with and without a clean block.
     for (const cleanblock of [{ clean: { values: CANARY.value } }, {}]) {
       let rejected: any = undefined
       try {
-        new (SDK as any)({ apikey: { value: CANARY.apikey }, ...cleanblock })
+        new (SDK as any)(offline({ apikey: { value: CANARY.apikey }, ...cleanblock }))
       }
       catch (e: any) {
         rejected = e
@@ -369,15 +402,22 @@ describe('clean', () => {
 
     // A feature's name is not a field name: only the sensitive names inside
     // its settings register. An entity block, of per-entity settings or seeded
-    // records keyed by entity name and id, is not read at all.
-    const featured: any = new (SDK as any)({ apikey: CANARY.apikey, feature: {
+    // records keyed by entity name and id, is not read at all, and nor are
+    // rbac's rules, keyed by entity and operation names.
+    const featured: any = construct({ apikey: CANARY.apikey, feature: {
       zzsecrets: { active: false, kind: 'PLAINSETTING-q8w2e4r6' },
       zzfeat: { active: false, apitoken: 'FEATTOKEN-z9y8x7w6' },
+      rbac: { active: false, rules: { 'zztoken.load': 'PLAINRULE-k7j5h3g1' } },
       test: { active: false, entity: { zztoken: { ZZTOKEN01: { note: 'PLAINRECORD-t5r3e1w9' } } } },
     }, entity: { zztoken: { alias: { zzkey: 'PLAINALIAS-m2n4b6v8' } } } })
     const fctx = { options: featured._options }
 
-    // The raw path returns its failure rather than throwing it.
+    // The raw path returns its failure rather than throwing it, a
+    // DOMException's included.
+    const timedout = await makeSdk(SCENARIOS[SCENARIOS.length - 1], sinks).direct({ path: 'raw' })
+    ok(false === timedout.ok && 'TimeoutError' === timedout.err?.name,
+      'a timed-out transport should fail direct() with its own error')
+    sinks.push(...forms('direct:timeout', timedout.err))
     const raw = await makeSdk(SCENARIOS[3], sinks).direct({ path: 'raw' })
     ok(false === raw.ok && null != raw.err, 'a transport failure should fail direct()')
     sinks.push(...forms('direct', raw.err))
@@ -391,6 +431,9 @@ describe('clean', () => {
     equal(leaked.length, 0, 'credential leaked through: ' +
       leaked.map((l) => l.name + ' [' + l.found.join(', ') + ']').join('; '))
 
+    // A DOMException is masked in place, and stays the error it was.
+    equal(errors['timeout/throw']?.name, 'TimeoutError', 'a timed-out operation should throw its own error')
+
     // The positive half: the slot the credential travelled in is masked,
     // and an unregistered token in a response header is masked by name.
     const notfound = errors['notfound/throw']
@@ -419,6 +462,7 @@ describe('clean', () => {
     equal(featured.utility().clean(fctx, 'token FEATTOKEN-z9y8x7w6'), 'token ' + MASK)
     equal(featured.utility().clean(fctx, 'record PLAINRECORD-t5r3e1w9'), 'record PLAINRECORD-t5r3e1w9')
     equal(featured.utility().clean(fctx, 'alias PLAINALIAS-m2n4b6v8'), 'alias PLAINALIAS-m2n4b6v8')
+    equal(featured.utility().clean(fctx, 'rule PLAINRULE-k7j5h3g1'), 'rule PLAINRULE-k7j5h3g1')
 
     const coded = errors['coded/throw']
     ok(null != coded, 'the coded scenario must throw')

package/project/.sdk/src/cmp/ts/TestDirect_ts.ts

@@ -21,7 +21,7 @@ import {
   serverVariables,
   isHttpBasicAuth,
   jsProp,
-  jsOptProp, envName, envToken, liveStrict,
+  jsOptProp, envName, envToken, liveStrict, liveStrictNote,
   jsKey,
   pointParts,
   hasLiveScenarios,
@@ -94,6 +94,9 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
         Slot({ name: 'directSetup' }, () => {
           Content(`
+${liveStrictNote(strict, '//')}
+const LIVE_STRICT = ${strict}
+
 function liveScenariosActive() { return ${hasLiveScenarios(model)} && process.env.${PROJECTNAME}_TEST_LIVE === 'TRUE' }
 function directSetup(mockres?: any) {
   const calls: any[] = []
@@ -160,11 +163,11 @@ function unwrapListData(data: any): any[] | null {
         Slot({ name: 'direct' }, () => {
 
           if (hasLoad) {
-            generateDirectLoad(model, entity, strict)
+            generateDirectLoad(model, entity)
           }
 
           if (hasList) {
-            generateDirectList(model, entity, strict)
+            generateDirectList(model, entity)
           }
         })
 
@@ -178,7 +181,6 @@ function generateDirectGraphql(
   opname: 'load' | 'list',
   entity: ModelEntity,
   point: any,
-  strict: boolean,
 ) {
   const doc: string = point.gq.doc
   const vars: any[] = point.gq.vars || []
@@ -201,7 +203,7 @@ function generateDirectGraphql(
   })
 
   const skipMissingLine = 0 < liveIdKeys.length
-    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
+    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)}, LIVE_STRICT)) return\n`
     : ''
 
   const varAsserts = vars.map((_v: any, i: number) =>
@@ -214,31 +216,7 @@ function generateDirectGraphql(
       assert(calls[0].init.method === 'POST')
 ${varAsserts}`
 
-  const checks = strict ?
-    `    if (setup.live) {
-      // STRICT live mode: a non-2xx is a real failure - this project owns
-      // the server it points at, so there is nothing to be lenient about.
-      //
-      // What is NOT asserted here is the MOCK's own fixtures. \`direct01\`
-      // is a scripted id and \`calls\` records the mock transport; neither
-      // exists on a live run, so asserting them made strict mode mean
-      // "compare the live server against the mock's script" - a suite that
-      // could not pass against any real API, including this project's own.
-      assert(result.ok === true,
-        'Live request failed: HTTP ' + result.status)
-      assert(result.status >= 200 && result.status < 300)
-      assert(null != result.data)
-    } else {
-${offlineChecks}    }` :
-    `    if (setup.live) {
-      // Live mode is lenient: synthetic ids frequently fail server-side
-      // validation. Skip rather than fail when the call doesn't come back
-      // clean.
-      if (!result.ok || result.status < 200 || result.status >= 300) {
-        return
-      }
-    } else {
-${offlineChecks}    }`
+  const checks = liveChecks(opname, 'null != result.data', 'no data', offlineChecks)
 
   Content(`
   test('direct-${opname}-${entity.name}', async (t: any) => {
@@ -262,7 +240,7 @@ ${checks}
 }
 
 
-function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean) {
+function generateDirectLoad(model: Model, entity: ModelEntity) {
   const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
 
@@ -271,7 +249,7 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
   }
 
   if ('graphql' === (loadPoint as any).kind) {
-    generateDirectGraphql('load', entity, loadPoint, strict)
+    generateDirectGraphql('load', entity, loadPoint)
     return
   }
 
@@ -367,7 +345,7 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direc
     // so the test can succeed without ENTID env var. Ancestor params, if
     // any, still need ENTID overrides because the list call itself can need
     // them embedded.
-    liveIdKeys = liveAncestorParams.map((lp: any) => lp.key)
+    liveIdKeys = [...new Set([...liveListParams, ...liveAncestorParams].map((lp: any) => lp.key))]
     const listParamLines = liveListParams.map((lp: any) =>
       `        ${lp.name}: setup.idmap['${lp.key}'],`).join('\n')
     const ancestorParamLines = liveAncestorParams.map((lp: any) =>
@@ -384,15 +362,19 @@ ${liveQueryPrefix}      const listResult: any = await client.direct({
 ${listParamLines}
         },
       })
-      assert(listResult.ok && listResult.status >= 200 && listResult.status < 300,
-        'Live list discovery failed')
+      if (!listResult.ok || listResult.status < 200 || listResult.status >= 300) {
+        return void liveMiss(t, LIVE_STRICT, 'Live list discovery failed: ' + describeLive(listResult))
+      }
       const listArr = unwrapListData(listResult.data)
-      if (null == listArr || listArr.length === 0) {
-        throw new Error('Live load blocked: discovery returned no entities')
+      if (null == listArr) {
+        return void liveMiss(t, LIVE_STRICT, 'Live list discovery returned no list: ' + describeLive(listResult))
+      }
+      if (0 === listArr.length) {
+        return void liveEmpty(t, 'The account has no ${entity.name} record to load')
       }
       const candidateId = ${jsOptProp('listArr[0]', idParamName)} ?? listArr[0]?.id
       if (null == candidateId) {
-        throw new Error('Live load blocked: discovery returned no usable identity')
+        return void liveMiss(t, LIVE_STRICT, 'Live load blocked: discovery returned no usable identity')
       }
       ${jsProp('params', idParamName)} = candidateId
 ${ancestorParamLines}
@@ -400,15 +382,15 @@ ${ancestorParamLines}
 ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direct0${i + 1}'`).join('\n')}
     }`
   } else if (hasLiveQuery || loadParams.length > 0) {
-    // Synthetic-only fallback: if there are load params with no examples
-    // and no list to bootstrap from, the live request would 4xx on
-    // undefined values. Mark the path-param keys so the test skips when
-    // ENTID overrides aren't supplied.
-    if (loadParams.length > 0) {
-      liveIdKeys = loadParams.map((p: any) => p.n + '01')
-    }
+    // With no examples and no list to discover from, the ids come from the
+    // *_ENTID variable; without them the test is blocked.
+    const liveLoadParams = loadParams.map((p: any) => ({
+      name: p.n, key: p.n === 'id' ? entity.name + '01' : p.n.replace(/_id$/, '') + '01',
+    }))
+    liveIdKeys = liveLoadParams.map((lp: any) => lp.key)
     liveParamsBlock = `    if (setup.live) {
-${liveQueryPrefix.replace(/\n$/, '')}
+${liveQueryPrefix}${liveLoadParams.map((lp: any) =>
+      `      ${jsProp('params', lp.name)} = setup.idmap['${lp.key}']`).join('\n')}
     } else {
 ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direct0${i + 1}'`).join('\n')}
     }`
@@ -417,14 +399,9 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direc
   }
 
   const skipMissingLine = liveIdKeys.length > 0
-    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
+    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)}, LIVE_STRICT)) return\n`
     : ''
 
-  // Live-mode leniency is a MODEL decision (main.kit.test.live.strict).
-  // The default stays lenient: a fleet SDK generated against an arbitrary
-  // public API 4xxes on synthetic IDs, and asserting would mean permanent
-  // red. A project that owns its test server wants the opposite — without
-  // it, the suite passes with nothing listening on the port.
   const offlineChecks = `      assert(result.ok === true)
       assert(result.status === 200)
       assert(null != result.data)
@@ -433,31 +410,7 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direc
       assert(calls[0].init.method === 'GET')
 ${paramAsserts}`
 
-  const loadChecks = strict ?
-    `    if (setup.live) {
-      // STRICT live mode: a non-2xx is a real failure - this project owns
-      // the server it points at, so there is nothing to be lenient about.
-      //
-      // What is NOT asserted here is the MOCK's own fixtures. \`direct01\`
-      // is a scripted id and \`calls\` records the mock transport; neither
-      // exists on a live run, so asserting them made strict mode mean
-      // "compare the live server against the mock's script" - a suite that
-      // could not pass against any real API, including this project's own.
-      assert(result.ok === true,
-        'Live request failed: HTTP ' + result.status)
-      assert(result.status >= 200 && result.status < 300)
-      assert(null != result.data)
-    } else {
-${offlineChecks}    }` :
-    `    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.ok || result.status < 200 || result.status >= 300) {
-        return
-      }
-    } else {
-${offlineChecks}    }`
+  const loadChecks = liveChecks('load', 'null != result.data', 'no data', offlineChecks)
 
   Content(`
   test('direct-load-${entity.name}', async (t: any) => {
@@ -483,7 +436,7 @@ ${loadChecks}
 }
 
 
-function generateDirectList(model: Model, entity: ModelEntity, strict: boolean) {
+function generateDirectList(model: Model, entity: ModelEntity) {
   const listOp = entity.op?.list
   const listPoint: ModelPoint | undefined = listOp?.points?.[0]
 
@@ -492,7 +445,7 @@ function generateDirectList(model: Model, entity: ModelEntity, strict: boolean)
   }
 
   if ('graphql' === (listPoint as any).kind) {
-    generateDirectGraphql('list', entity, listPoint, strict)
+    generateDirectGraphql('list', entity, listPoint)
     return
   }
 
@@ -543,7 +496,7 @@ ${mockLines}
     ? liveParams.map((lp: any) => lp.key)
     : []
   const skipMissingLine = liveIdKeys.length > 0
-    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
+    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)}, LIVE_STRICT)) return\n`
     : ''
 
   const offlineChecks = `      assert(result.ok === true)
@@ -556,35 +509,8 @@ ${mockLines}
       assert(calls[0].init.method === 'GET')
 ${paramAsserts}`
 
-  const listChecks = strict ?
-    `    if (setup.live) {
-      // STRICT live mode: a non-2xx is a real failure - this project owns
-      // the server it points at, so there is nothing to be lenient about.
-      //
-      // What is NOT asserted here is the MOCK's own fixtures. \`direct01\`
-      // is a scripted id and \`calls\` records the mock transport; neither
-      // exists on a live run, so asserting them made strict mode mean
-      // "compare the live server against the mock's script" - a suite that
-      // could not pass against any real API, including this project's own.
-      assert(result.ok === true,
-        'Live request failed: HTTP ' + result.status)
-      assert(result.status >= 200 && result.status < 300)
-      assert(Array.isArray(unwrapListData(result.data)), 'Expected live list response')
-    } else {
-${offlineChecks}    }` :
-    `    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.ok || result.status < 200 || result.status >= 300) {
-        return
-      }
-      const listArr = unwrapListData(result.data)
-      if (!Array.isArray(listArr)) {
-        return
-      }
-    } else {
-${offlineChecks}    }`
+  const listChecks = liveChecks('list', 'Array.isArray(unwrapListData(result.data))', 'no list',
+    offlineChecks)
 
   Content(`
   test('direct-list-${entity.name}', async (t: any) => {
@@ -607,6 +533,21 @@ ${listChecks}
 }
 
 
+// A live run asserts what any server answers, never the mock's own script
+// (`direct01`, `calls`), and never a record count.
+function liveChecks(opname: string, usable: string, unusable: string, offline: string): string {
+  return `    if (setup.live) {
+      if (!result.ok || result.status < 200 || result.status >= 300) {
+        return void liveMiss(t, LIVE_STRICT, 'Live ${opname} failed: ' + describeLive(result))
+      }
+      if (!(${usable})) {
+        return void liveMiss(t, LIVE_STRICT, 'Live ${opname} returned ${unusable}: ' + describeLive(result))
+      }
+    } else {
+${offline}    }`
+}
+
+
 function normalizePathParams(
   parts: string[],
   params: any[],

package/project/.sdk/src/cmp/ts/TestEntity_ts.ts

@@ -1,6 +1,6 @@
 import { boundedFacts, pointFacts } from '@voxgig/sdkgen'
 import { buildIdNames } from '@voxgig/sdkgen'
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable, invalidRequest } from '@voxgig/sdkgen'
 
 import * as Path from 'node:path'
 
@@ -40,6 +40,8 @@ import {
   jsKey,
   jsProp,
   hasLiveScenarios,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -115,12 +117,22 @@ const TestEntity = cmp(function TestEntity(props: any) {
           return;
         }
 
+        Slot({ name: 'failure' }, () => {
+          if (opReachable((entity.op as any)?.list, [])) {
+            Content(failureTests(model, entity))
+          }
+          Content(validateTest(model, entity))
+        })
+
         const indent = 2
 
         const idlist = buildIdNames(entity, basicflow)
 
         Slot({ name: 'basicSetup' }, () => {
           Content(`
+${liveStrictNote(liveStrict(model, target.name), '//')}
+const LIVE_STRICT = ${liveStrict(model, target.name)}
+
 function basicSetup(extra?: any) {
   // TODO: fix test def options
   const options: any = {} // ${jsonify(basicflow.test, { offset: indent - 2 })}
@@ -228,7 +240,7 @@ function basicSetup(extra?: any) {
     ${hasLiveScenarios(model) ? `if (live) { t.skip('Covered by live operation scenarios'); return }` : ''}
     const setup = basicSetup()
     if (setup.live) {
-      return runLiveEntity(setup, ${JSON.stringify(entity)}, ${JSON.stringify(basicflow)}, '${nom(entity, 'Name')}', ${JSON.stringify(liveFacts)})
+      return runLiveEntity(setup, ${JSON.stringify(entity)}, ${JSON.stringify(basicflow)}, '${nom(entity, 'Name')}', ${JSON.stringify(liveFacts)}, { strict: LIVE_STRICT, t })
     }
     const client = setup.client
     const struct = setup.struct
@@ -565,6 +577,84 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A failed operation rejects a stream as it rejects the operation: a
+// transport failure, and a hook that rejects the call. A throwing hook fires
+// PreUnexpected, and under throw false the call resolves to undefined. The
+// caller's ctrl stays its own.
+function failureTests(model: Model, entity: ModelEntity): string {
+  const SDK = model.Name + 'SDK'
+  const Entity = nom(entity, 'Name')
+  return `
+  class FailHook extends BaseFeature {
+    name = 'failhook'
+    version = '0.0.1'
+    active = true
+    unexpected = 0
+    init() { }
+    PreSpec() { throw new Error('${entity.name} hook failed') }
+    PreUnexpected() { this.unexpected++ }
+  }
+
+  test('stream-error', async () => {
+    const offline = { net: { offline: true } }
+    await assert.rejects(async () => {
+      for await (const _item of ${SDK}.test(offline).${Entity}().stream('list')) { }
+    }, /offline/)
+
+    for await (const _item of ${SDK}.test(offline).${Entity}()
+      .stream('list', undefined, { ctrl: { throw: false } })) { }
+
+    if (null != (config as any).feature?.rbac) {
+      const denied = ${SDK}.test(undefined, { feature: { rbac: { active: true, deny: true } } })
+      await assert.rejects(async () => {
+        for await (const _item of denied.${Entity}().stream('list')) { }
+      }, (err: any) => 'rbac_denied' === err.code)
+    }
+  })
+
+  test('stream-ctrl', async () => {
+    const explain: any = {}
+    const ctrl: any = { explain }
+    for await (const _item of ${SDK}.test().${Entity}().stream('list', undefined, { ctrl })) { }
+    assert.deepStrictEqual(Object.keys(ctrl), ['explain'])
+    assert(explain === ctrl.explain && 0 < Object.keys(explain).length)
+  })
+
+  test('unexpected', async () => {
+    const hook = new FailHook()
+    const client = new ${SDK}({ feature: { test: { active: true } }, extend: [hook] })
+    await assert.rejects(client.${Entity}().list(), /hook failed/)
+    assert(0 < hook.unexpected)
+
+    const fired = hook.unexpected
+    assert.strictEqual(await client.${Entity}().list(undefined, { throw: false }), undefined)
+    assert(fired < hook.unexpected)
+  })
+`
+}
+
+
+// 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 SDK = model.Name + 'SDK'
+  return `
+  test('validate', async (t) => {
+    if (null == (config as any).feature?.validate) {
+      t.skip('feature not present in this SDK: validate')
+      return
+    }
+    const client = ${SDK}.test(undefined, { feature: { validate: { active: true } } })
+    await assert.rejects(client.${nom(entity, 'Name')}().${bad.op}(${JSON.stringify(bad.args)} as any),
+      (err: any) => 'validate_failed' === err.code)
+  })
+`
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/ts/TestLive_ts.ts

@@ -1,4 +1,4 @@
-import { cmp, File, Content, entityCollection, envName, serverVariables, serverVarEnv, liveHint, pointFacts } from '@voxgig/sdkgen'
+import { cmp, File, Content, entityCollection, envName, serverVariables, serverVarEnv, liveHint, pointFacts, liveStrict, liveStrictNote } from '@voxgig/sdkgen'
 import { nom } from '@voxgig/apidef'
 
 const TestLive = cmp(function TestLive(props: any) {
@@ -30,8 +30,9 @@ import { SDK } from '..'
 import { runLiveScenarios } from './live-scenarios'
 import { loadEnvLocal } from './utility'
 loadEnvLocal(__dirname + '/../.env.local')
-test('live operation coverage', { skip: process.env.${envName(model)}_TEST_LIVE !== 'TRUE' }, async () => {
-  await runLiveScenarios(SDK, ${JSON.stringify(plan, null, 2)}, '${envName(model)}', { server: { ${server} }, secret: process.env.${envName(model)}_SECRET })
+${liveStrictNote(liveStrict(model, props.target.name), '//')}
+test('live operation coverage', { skip: process.env.${envName(model)}_TEST_LIVE !== 'TRUE' }, async (t) => {
+  await runLiveScenarios(SDK, ${JSON.stringify(plan, null, 2)}, '${envName(model)}', { server: { ${server} }, secret: process.env.${envName(model)}_SECRET }, { strict: ${liveStrict(model, props.target.name)}, t })
 })
 `))
 })

package/project/.sdk/src/cmp/ts/fragment/Direct.test.fragment.ts

@@ -14,6 +14,9 @@ import {
   loadEnvLocal,
   maybeSkipControl,
   skipIfMissingIds,
+  liveMiss,
+  liveEmpty,
+  describeLive,
 } from '../../utility'
 
 

package/project/.sdk/src/cmp/ts/fragment/Entity.fragment.ts

@@ -40,6 +40,8 @@ class EntyClass extends ProjectNameEntityBase<EntityDataType> {
 
   // #UpdateOp
 
+  // #PatchOp
+
   // #RemoveOp
 
 }

package/project/.sdk/src/cmp/ts/fragment/Entity.test.fragment.ts

@@ -9,7 +9,7 @@ import { createLiveTransport } from '../../live-runner'
 import { runLiveEntity } from '../../live-entity'
 
 
-import { ProjectNameSDK, BaseFeature, stdutil } from '../../..'
+import { ProjectNameSDK, BaseFeature, config, stdutil } from '../../..'
 
 import {
   envOverride,
@@ -40,6 +40,8 @@ describe('EntityNameEntity', async () => {
     assert(null != ent)
   })
 
+  // <[SLOT:failure]>
+
 
   test('basic', async (t) => {
     // <[SLOT:basic]>