@voxgig/sdkgen 0.36.0 → 0.37.0

package/project/.sdk/tm/js/test/runner.js

@@ -1,171 +1,387 @@
+// VERSION: @voxgig/struct 0.0.10
+// This test utility runs the JSON-specified tests in build/test/test.json.
+// (or .sdk/test/test.json if used in a @voxgig/sdkgen project)
 
 const { readFileSync } = require('node:fs')
 const { join } = require('node:path')
-const { equal, deepEqual, fail, AssertionError } = require('node:assert')
+const { deepStrictEqual, fail, AssertionError } = require('node:assert')
 
-const { NameSDK: SDK } = require('..')
+const NULLMARK = '__NULL__' // Value is JSON null
+const UNDEFMARK = '__UNDEF__' // Value is not present (thus, undefined).
+const EXISTSMARK = '__EXISTS__' // Value exists (not undefined).
 
-const client = SDK.test()
-const utility = client.utility()
-const { walk, items, clone, isnode, ismap, getpath, stringify, inject } = utility.struct
 
+async function makeRunner(testfile, client) {
 
-async function runner(name, store) {
+  return async function runner(
+    name,
+    store,
+  ) {
+    store = store || {}
 
+    const utility = client.utility()
+    const structUtils = utility.struct
+
+    let spec = resolveSpec(name, testfile)
+    let clients = await resolveClients(client, spec, store, structUtils)
+    let subject = resolveSubject(name, utility)
+
+    let runsetflags = async (
+      testspec,
+      flags,
+      testsubject
+    ) => {
+      subject = testsubject || subject
+      flags = resolveFlags(flags)
+      const testspecmap = fixJSON(testspec, flags)
+
+      const testset = testspecmap.set
+      for (let entry of testset) {
+        try {
+          entry = resolveEntry(entry, flags)
+
+          let testpack = resolveTestPack(name, entry, subject, client, clients)
+          let args = resolveArgs(entry, testpack, utility, structUtils)
+
+          let res = await testpack.subject(...args)
+          res = fixJSON(res, flags)
+          entry.res = res
+
+          checkResult(entry, args, res, structUtils)
+        }
+        catch (err) {
+          if (err instanceof AssertionError) {
+            throw err
+          }
+          handleError(entry, err, structUtils)
+        }
+      }
+    }
+
+    let runset = async (
+      testspec,
+      testsubject
+    ) => runsetflags(testspec, {}, testsubject)
+
+    const runpack = {
+      spec,
+      runset,
+      runsetflags,
+      subject,
+      client,
+    }
+
+    return runpack
+  }
+}
+
+function resolveSpec(name, testfile) {
   const alltests =
-        JSON.parse(readFileSync(join(
-          __dirname, '..', '..', '.sdk', 'test', 'test.json'), 'utf8'))
+    JSON.parse(readFileSync(join(__dirname, testfile), 'utf8'))
+
+  let spec = alltests.primary?.[name] || alltests[name] || alltests
+  return spec
+}
+
 
-  // TODO: a more coherent namespace perhaps?
-  let spec = alltests.primary[name] || alltests[name]
+async function resolveClients(
+  client,
+  spec,
+  store,
+  structUtils
+) {
 
   const clients = {}
-  if(spec.DEF) {
-    for(let cdef of items(spec.DEF.client)) {
-      const copts = cdef[1].test.options || {}
-      if(ismap(store)) {
-        inject(copts, store)
+  if (spec.DEF && spec.DEF.client) {
+    for (let cn in spec.DEF.client) {
+      const cdef = spec.DEF.client[cn]
+      const copts = cdef.test.options || {}
+      if ('object' === typeof store && structUtils?.inject) {
+        structUtils.inject(copts, store)
       }
-      
-      clients[cdef[0]] = await SDK.test(copts)
+
+      clients[cn] = await client.tester(copts)
     }
   }
+  return clients
+}
 
-  let subject = utility[name]
 
-  let runset = async (testspec, testsubject, makesubject) => {
-    testsubject = testsubject || subject
+function resolveSubject(name, container) {
+  const subject = container[name] || container.struct[name]
+  return subject
+}
 
-    next_entry:
-    for (let entry of testspec.set) {
-      try {
-        let testclient = client
-        
-        if(entry.client) {
-          testclient = clients[entry.client]
-          testsubject = client.utility()[name]
-        }
 
-        if(makesubject) {
-          testsubject = makesubject(testsubject)
-        }
+function resolveFlags(flags) {
+  if (null == flags) {
+    flags = {}
+  }
+  flags.null = null == flags.null ? true : !!flags.null
+  return flags
+}
 
-        let args = [clone(entry.in)]
 
-        if(entry.ctx) {
-          args = [entry.ctx]
-        }
-        else if(entry.args) {
-          args = entry.args
-        }
+function resolveEntry(entry, flags) {
+  entry.out = null == entry.out && flags.null ? NULLMARK : entry.out
+  return entry
+}
 
-        if(entry.ctx || entry.args) {
-          let first = args[0]
-          if(ismap(first)) {
-            entry.ctx = first = args[0] = clone(args[0])
-            first.client = testclient
-            first.utility = testclient.utility()
-          }
-        }
 
-        let res = await testsubject(...args)
-        entry.res = res
-        
-        if(undefined === entry.match || undefined !== entry.out) {
-          // NOTE: don't use clone as we want to strip functions
-          deepEqual(null != res ? JSON.parse(JSON.stringify(res)) : res, entry.out)
-        }
-        
-        if(entry.match) {
-          match(entry.match, {in:entry.in, out:entry.res, ctx:entry.ctx})
-        }
-      }
-      catch (err) {
-        entry.thrown = err
-        
-        const entry_err = entry.err
+function checkResult(entry, args, res, structUtils) {
+  let matched = false
 
-        if (null != entry_err) {
-          // if (true === entry_err || (err.message.includes(entry_err))) {
-          if (true === entry_err || matchval(entry_err, err.message)) {
+  if (entry.err) {
+    return fail('Expected error did not occur: ' + entry.err +
+      '\n\nENTRY: ' + safeStringify(entry))
+  }
 
-            if(entry.match) {
-              match(entry.match, {in:entry.in, out:entry.res, ctx:entry.ctx, err})
-            }
+  if (entry.match) {
+    const result = { in: entry.in, args, out: entry.res, ctx: entry.ctx }
+    match(
+      entry.match,
+      result,
+      structUtils
+    )
 
-            continue next_entry
-          }
+    matched = true
+  }
 
-          fail('ERROR MATCH: ['+stringify(entry_err)+'] <=> ['+err.message+']')
-        }
-        else if(err instanceof AssertionError ) {
-          fail(err.message+'\n\nENTRY: '+JSON.stringify(entry,null,2))
-        }
-        else {
-          fail(err.stack+'\\nnENTRY: '+JSON.stringify(entry,null,2))
-        }
+  const out = entry.out
+
+  if (out === res) {
+    return
+  }
+
+  // NOTE: allow match with no out.
+  if (matched && (NULLMARK === out || null == out)) {
+    return
+  }
+
+  deepStrictEqual(null != res ? JSON.parse(safeStringify(res)) : res, entry.out)
+}
+
+
+// Handle errors from test execution
+function handleError(entry, err, structUtils) {
+  entry.thrown = err
+
+  const entry_err = entry.err
+
+  if (null != entry_err) {
+    if (true === entry_err || matchval(entry_err, err.message, structUtils)) {
+      if (entry.match) {
+        match(
+          entry.match,
+          { in: entry.in, out: entry.res, ctx: entry.ctx, err: fixJSON(err, { null: true }) },
+          structUtils
+        )
       }
+      return
+    }
+
+    fail('ERROR MATCH: [' + structUtils.stringify(entry_err) +
+      '] <=> [' + err.message + ']')
+  }
+
+  // Unexpected error (test didn't specify an error expectation)
+  else if (err instanceof AssertionError) {
+    fail(err.message + '\n\nENTRY: ' + safeStringify(entry))
+  }
+  else {
+    fail(err.stack + '\n\nENTRY: ' + safeStringify(entry))
+  }
+}
+
+
+function resolveArgs(
+  entry,
+  testpack,
+  utility,
+  structUtils
+) {
+  let args = []
+
+  if (entry.ctx) {
+    args = [entry.ctx]
+  }
+  else if (entry.args) {
+    args = entry.args
+  }
+  else {
+    args = [structUtils.clone(entry.in)]
+  }
+
+  if (entry.ctx || entry.args) {
+    let first = args[0]
+    if (structUtils.ismap(first)) {
+      first = structUtils.clone(first)
+      first = utility.makeContext(first)
+      args[0] = first
+      entry.ctx = first
+
+      first.client = testpack.client
+      first.utility = testpack.utility
     }
   }
 
-  
-  return {
-    spec,
-    runset,
+  return args
+}
+
+
+function resolveTestPack(
+  name,
+  entry,
+  subject,
+  client,
+  clients
+) {
+  const testpack = {
+    name,
+    client,
     subject,
+    utility: client.utility(),
   }
+
+  if (entry.client) {
+    testpack.client = clients[entry.client]
+    testpack.utility = testpack.client.utility()
+    testpack.subject = resolveSubject(name, testpack.utility)
+  }
+
+  return testpack
 }
 
 
-function match(check, base) {
-  let nodes = [base]
+function match(
+  check,
+  basex,
+  structUtils
+) {
+  const cbase = structUtils.clone(basex)
+
+  structUtils.walk(check, (_key, val, _parent, path) => {
+    if (!structUtils.isnode(val)) {
+      let baseval = structUtils.getpath(cbase, path)
+
+      if (baseval === val) {
+        return val
+      }
+
+      // Explicit undefined expected
+      if (UNDEFMARK === val && undefined === baseval) {
+        return val
+      }
+
+      // Explicit defined expected
+      if (EXISTSMARK === val && null != baseval) {
+        return val
+      }
 
-  // TODO: walk should be called on entry and exit from a node to
-  // avoid needing getpath
-  walk(check, (key, val, parent, path)=>{
-    if(!isnode(val)) {
-      let baseval = getpath(path, base)
-      
-      if(!matchval(val, baseval)) {
-        fail('MATCH: '+path.join('.')+': ['+stringify(val)+'] <=> ['+stringify(baseval)+']')
+      if (!matchval(val, baseval, structUtils)) {
+        fail('MATCH: ' + path.join('.') +
+          ': [' + structUtils.stringify(val) +
+          '] <=> [' + structUtils.stringify(baseval) + ']')
       }
     }
+
+    return val
   })
 }
 
 
-function matchval(check, base) {
-  check = '__UNDEF__' === check ? undefined : check
-  
+function matchval(
+  check,
+  base,
+  structUtils
+) {
   let pass = check === base
 
-  if(!pass) {
+  if (!pass) {
+
+    if ('string' === typeof check) {
+      let basestr = structUtils.stringify(base)
 
-    if('string' === typeof check) {
-      let basestr = stringify(base)
-    
       let rem = check.match(/^\/(.+)\/$/)
-      if(rem) {
+      if (rem) {
         pass = new RegExp(rem[1]).test(basestr)
       }
       else {
-        pass = basestr.toLowerCase().includes(stringify(check).toLowerCase())
+        pass = basestr.toLowerCase().includes(structUtils.stringify(check).toLowerCase())
       }
     }
-    else if('function' === typeof check) {
+    else if ('function' === typeof check) {
       pass = true
     }
   }
 
-  
-  
   return pass
 }
 
 
-module.exports = {
-  runner
+function safeStringify(val) {
+  const seen = new WeakSet()
+  return JSON.stringify(val, (_k, v) => {
+    if ('object' === typeof v && null !== v) {
+      if (seen.has(v)) return '[Circular]'
+      seen.add(v)
+    }
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message }
+    }
+    return v
+  }, 2)
+}
+
+
+function fixJSON(val, flags) {
+  if (null == val) {
+    return flags?.null ? NULLMARK : val
+  }
+
+  const seen = new WeakSet()
+  const replacer = (_k, v) => {
+    if (null == v && flags?.null) {
+      return NULLMARK
+    }
+
+    if (v instanceof Error) {
+      return {
+        ...v,
+        name: v.name,
+        message: v.message,
+      }
+    }
+
+    if ('object' === typeof v && null !== v) {
+      if (seen.has(v)) return '[Circular]'
+      seen.add(v)
+    }
+
+    return v
+  }
+
+  return JSON.parse(JSON.stringify(val, replacer))
 }
 
 
+function nullModifier(
+  val,
+  key,
+  parent
+) {
+  if ("__NULL__" === val) {
+    parent[key] = null
+  }
+  else if ('string' === typeof val) {
+    parent[key] = val.replaceAll('__NULL__', 'null')
+  }
+}
 
+
+module.exports = {
+  NULLMARK,
+  EXISTSMARK,
+  nullModifier,
+  makeRunner,
+}

package/project/.sdk/tm/js/test/utility/Custom.test.js

@@ -1,85 +1,63 @@
 
 const { test, describe } = require('node:test')
-const { equal, deepEqual } = require('node:assert')
+const { equal } = require('node:assert')
+
+const { ProjectNameSDK } = require('../..')
+
+
+describe('Custom', () => {
+
+  test('basic', async () => {
+    const client = ProjectNameSDK.test({}, {
+      apikey: 'APIKEY01',
+
+      // NOTE: original utility.options must remain in place.
+      utility: {
+        auth: () => ({ util: 'AUTH' }),
+        body: () => ({ util: 'BODY' }),
+        contextify: () => ({ util: 'CONTEXTIFY' }),
+        done: () => ({ util: 'DONE' }),
+        error: () => ({ util: 'ERROR' }),
+        findparam: () => ({ util: 'FINDPARAM' }),
+        fullurl: () => ({ util: 'FULLURL' }),
+        headers: () => ({ util: 'HEADERS' }),
+        method: () => ({ util: 'METHOD' }),
+        operator: () => ({ util: 'OPERATOR' }),
+        params: () => ({ util: 'PARAMS' }),
+        query: () => ({ util: 'QUERY' }),
+        reqform: () => ({ util: 'REQFORM' }),
+        request: () => ({ util: 'REQUEST' }),
+        resbasic: () => ({ util: 'RESBASIC' }),
+        resbody: () => ({ util: 'RESBODY' }),
+        resform: () => ({ util: 'RESFORM' }),
+        resheaders: () => ({ util: 'RESHEADERS' }),
+        response: () => ({ util: 'RESPONSE' }),
+        result: () => ({ util: 'RESULT' }),
+        spec: () => ({ util: 'SPEC' }),
+      }
+    })
 
-const { StatuspageSDK } = require('../..')
-
-const client = StatuspageSDK.test({
-  apikey: 'APIKEY01',
-  utility: {
-    auth: ()=> ({util:'AUTH'}),
-    body: () => ({util:'BODY'}),
-    empty: () => ({util:'EMPTY'}),
-    error: () => ({util:'ERROR'}),
-    escre: () => ({util:'ESCRE'}),
-    escurl: () => ({util:'ESCURL'}),
-    fetch: () => ({util:'FETCH'}),
-    findparam: () => ({util:'FINDPARAM'}),
-    fullurl: () => ({util:'FULLURL'}),
-    headers: () => ({util:'HEADERS'}),
-    inward: () => ({util:'INWARD'}),
-    joinurl: () => ({util:'JOINURL'}),
-    method: () => ({util:'METHOD'}),
-    operator: () => ({util:'OPERATOR'}),
-    options: () => ({util:'OPTIONS'}),
-    outward: () => ({util:'OUTWARD'}),
-    params: () => ({util:'PARAMS'}),
-    query: () => ({util:'QUERY'}),
-    resbasic: () => ({util:'RESBASIC'}),
-    resbody: () => ({util:'RESBODY'}),
-    resheaders: () => ({util:'RESHEADERS'}),
-    response: () => ({util:'RESPONSE'}),
-    spec: () => ({util:'SPEC'}),
-
-    string: {
-      stringify: () => ({util:'STRING-STRINGIFY'}),
-    },
-
-    validate: {
-      string: () => ({util:'VALIDATE-STRING'}),
-      array: () => ({util:'VALIDATE-ARRAY'}),
-      object: () => ({util:'VALIDATE-OBJECT'}),
-      func: () => ({util:'VALIDATE-FUNC'}),
-    }
-
-  }
-})
-
-
-describe('Custom', ()=>{
-  test('basic', async ()=>{
     const u = client.utility()
 
     equal(u.auth().util, 'AUTH')
     equal(u.body().util, 'BODY')
-    equal(u.empty().util, 'EMPTY')
+    equal(u.contextify().util, 'CONTEXTIFY')
+    equal(u.done().util, 'DONE')
     equal(u.error().util, 'ERROR')
-    equal(u.escre().util, 'ESCRE')
-    equal(u.escurl().util, 'ESCURL')
-    equal(u.fetch().util, 'FETCH')
     equal(u.findparam().util, 'FINDPARAM')
     equal(u.fullurl().util, 'FULLURL')
     equal(u.headers().util, 'HEADERS')
-    equal(u.inward().util, 'INWARD')
-    equal(u.joinurl().util, 'JOINURL')
     equal(u.method().util, 'METHOD')
     equal(u.operator().util, 'OPERATOR')
-    equal(u.options().util, 'OPTIONS')
-    equal(u.outward().util, 'OUTWARD')
     equal(u.params().util, 'PARAMS')
     equal(u.query().util, 'QUERY')
+    equal(u.reqform().util, 'REQFORM')
     equal(u.resbasic().util, 'RESBASIC')
     equal(u.resbody().util, 'RESBODY')
+    equal(u.resform().util, 'RESFORM')
     equal(u.resheaders().util, 'RESHEADERS')
     equal(u.response().util, 'RESPONSE')
+    equal(u.result().util, 'RESULT')
     equal(u.spec().util, 'SPEC')
-
-    equal(u.string.stringify().util, 'STRING-STRINGIFY')
-
-    equal(u.validate.string().util, 'VALIDATE-STRING')
-    equal(u.validate.array().util, 'VALIDATE-ARRAY')
-    equal(u.validate.object().util, 'VALIDATE-OBJECT')
-    equal(u.validate.func().util, 'VALIDATE-FUNC')
-    
   })
 })