@voxgig/sdkgen 0.16.0 → 0.18.0

package/project/.sdk/tm/js/src/utility/Utility.js

@@ -0,0 +1,74 @@
+
+/* Utility functions.
+ *
+ * Many of these functions expect the operation context as the first argument, and
+ * assume the following top level properties of the context:
+ *   * client: SDK client instance
+ *   * op: operation definition
+ *   * utility: map of these utility functions
+ *   * entity?: SDK entity instance
+ *   * spec?: request specification
+ *   * response?: unprocessed response
+ *   * result?: processed result built from response
+ *   * config?: SDK builtin configuration
+ *
+ */
+
+const { auth } = require('./AuthUtility')
+const { body } = require('./BodyUtility')
+const { done } = require('./DoneUtility')
+const { error } = require('./ErrorUtility')
+const { findparam } = require('./FindparamUtility')
+const { fullurl } = require('./FullurlUtility')
+const { headers } = require('./HeadersUtility')
+const { method } = require('./MethodUtility')
+const { operator } = require('./OperatorUtility')
+const { options } = require('./OptionsUtility')
+const { params } = require('./ParamsUtility')
+const { query } = require('./QueryUtility')
+const { reqform } = require('./ReqformUtility')
+const { request } = require('./RequestUtility')
+const { resbasic } = require('./ResbasicUtility')
+const { resbody } = require('./ResbodyUtility')
+const { resform } = require('./ResformUtility')
+const { resheaders } = require('./ResheadersUtility')
+const { response } = require('./ResponseUtility')
+const { result } = require('./ResultUtility')
+const { spec } = require('./SpecUtility')
+
+
+const struct = require('./StructUtility')
+// const validate = require('./ValidateUtility')
+
+const Utility = {
+  auth,
+  body,
+  done,
+  error,
+  findparam,
+  fullurl,
+  headers,
+  method,
+  operator,
+  options,
+  params,
+  query,
+  reqform,
+  request,
+  resbasic,
+  resbody,
+  resform,
+  resheaders,
+  response,
+  result,
+  spec,
+
+  struct,
+  // validate,
+}
+
+
+module.exports = {
+  Utility
+}
+

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

@@ -0,0 +1,171 @@
+
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+const { equal, deepEqual, fail, AssertionError } = require('node:assert')
+
+const { NameSDK: SDK } = require('..')
+
+const client = SDK.test()
+const utility = client.utility()
+const { walk, items, clone, isnode, ismap, getpath, stringify, inject } = utility.struct
+
+
+async function runner(name, store) {
+
+  const alltests =
+        JSON.parse(readFileSync(join(
+          __dirname, '..', '..', '.sdk', 'test', 'test.json'), 'utf8'))
+
+  // TODO: a more coherent namespace perhaps?
+  let spec = alltests.primary[name] || alltests[name]
+
+  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)
+      }
+      
+      clients[cdef[0]] = await SDK.test(copts)
+    }
+  }
+
+  let subject = utility[name]
+
+  let runset = async (testspec, testsubject, makesubject) => {
+    testsubject = testsubject || 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)
+        }
+
+        let args = [clone(entry.in)]
+
+        if(entry.ctx) {
+          args = [entry.ctx]
+        }
+        else if(entry.args) {
+          args = entry.args
+        }
+
+        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
+
+        if (null != entry_err) {
+          // if (true === entry_err || (err.message.includes(entry_err))) {
+          if (true === entry_err || matchval(entry_err, err.message)) {
+
+            if(entry.match) {
+              match(entry.match, {in:entry.in, out:entry.res, ctx:entry.ctx, err})
+            }
+
+            continue next_entry
+          }
+
+          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))
+        }
+      }
+    }
+  }
+
+  
+  return {
+    spec,
+    runset,
+    subject,
+  }
+}
+
+
+function match(check, base) {
+  let nodes = [base]
+
+  // 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)+']')
+      }
+    }
+  })
+}
+
+
+function matchval(check, base) {
+  check = '__UNDEF__' === check ? undefined : check
+  
+  let pass = check === base
+
+  if(!pass) {
+
+    if('string' === typeof check) {
+      let basestr = stringify(base)
+    
+      let rem = check.match(/^\/(.+)\/$/)
+      if(rem) {
+        pass = new RegExp(rem[1]).test(basestr)
+      }
+      else {
+        pass = basestr.toLowerCase().includes(stringify(check).toLowerCase())
+      }
+    }
+    else if('function' === typeof check) {
+      pass = true
+    }
+  }
+
+  
+  
+  return pass
+}
+
+
+module.exports = {
+  runner
+}
+
+
+

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

@@ -0,0 +1,85 @@
+
+const { test, describe } = require('node:test')
+const { equal, deepEqual } = require('node:assert')
+
+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.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.resbasic().util, 'RESBASIC')
+    equal(u.resbody().util, 'RESBODY')
+    equal(u.resheaders().util, 'RESHEADERS')
+    equal(u.response().util, 'RESPONSE')
+    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')
+    
+  })
+})

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

@@ -0,0 +1,187 @@
+
+const { test, describe } = require('node:test')
+const { equal, deepEqual } = require('node:assert')
+
+const { runner } = require('../runner')
+
+
+describe('PrimaryUtility', async ()=>{
+
+  async function MockFetch(url, fetchdef) {
+    return {
+      status: 200,
+    }
+  }
+
+  const runners = {
+    auth: await runner('auth'),
+    body: await runner('body'),
+    error: await runner('error'),
+    findparam: await runner('findparam'),
+    fullurl: await runner('fullurl'),
+    headers: await runner('headers'),
+    method: await runner('method'),
+    operator: await runner('operator'),
+    options: await runner('options'),
+    params: await runner('params'),
+    query: await runner('query'),
+    reqform: await runner('reqform'),
+    request: await runner('request', { fetch: MockFetch }),
+    resbasic: await runner('resbasic'),
+    resbody: await runner('resbody'),
+    resform: await runner('resform'),
+    resheaders: await runner('resheaders'),
+    response: await runner('response'),
+    spec: await runner('spec'),
+  }
+  
+  
+  test('exists', async ()=>{
+    equal('function', typeof runners.auth.subject)
+    equal('function', typeof runners.body.subject)
+    equal('function', typeof runners.error.subject)
+    equal('function', typeof runners.findparam.subject)
+    equal('function', typeof runners.fullurl.subject)
+    equal('function', typeof runners.method.subject)
+    equal('function', typeof runners.operator.subject)
+    equal('function', typeof runners.options.subject)
+    equal('function', typeof runners.params.subject)
+    equal('function', typeof runners.query.subject)
+    equal('function', typeof runners.reqform.subject)
+    equal('function', typeof runners.request.subject)
+    equal('function', typeof runners.resbasic.subject)
+    equal('function', typeof runners.resbody.subject)
+    equal('function', typeof runners.resform.subject)
+    equal('function', typeof runners.resheaders.subject)
+    equal('function', typeof runners.response.subject)
+    equal('function', typeof runners.spec.subject)
+  })
+
+
+  test('auth-basic', async () => {
+    const { runset, spec, subject } = runners.auth
+    await runset(spec.basic, undefined, (subject)=>(vin)=>{
+      return subject(vin, vin.spec)
+    })
+  })
+
+
+  test('body-basic', async () => {
+    const { runset, spec, subject } = runners.body
+    await runset(spec.basic, subject)
+  })
+
+
+  test('error-basic', async () => {
+    const { runset, spec, subject } = runners.error
+    await runset(spec.basic, subject)
+  })
+
+
+  test('findparam-basic', async () => {
+    const { runset, spec, subject } = runners.findparam
+    await runset(spec.basic, subject)
+  })
+
+
+  test('fullurl-basic', async () => {
+    const { runset, spec, subject } = runners.fullurl
+    await runset(spec.basic, subject)
+  })
+
+
+  test('headers-basic', async () => {
+    const { runset, spec, subject } = runners.headers
+    await runset(spec.basic, subject)
+  })
+
+
+  test('method-basic', async () => {
+    const { runset, spec, subject } = runners.method
+    await runset(spec.basic, subject)
+  })
+
+
+  test('operator-basic', async () => {
+    const { runset, spec, subject } = runners.operator
+    await runset(spec.basic, subject)
+  })
+  
+
+  test('options-basic', async () => {
+    const { runset, spec, subject } = runners.options
+    await runset(spec.basic, subject)
+  })
+  
+
+  test('params-basic', async () => {
+    const { runset, spec, subject } = runners.params
+    await runset(spec.basic, subject)
+  })
+
+
+  test('query-basic', async () => {
+    const { runset, spec, subject } = runners.query
+    await runset(spec.basic, subject)
+  })
+
+
+  test('reqform-basic', async () => {
+    const { runset, spec, subject } = runners.reqform
+    await runset(spec.basic, subject)
+  })
+
+
+  test('request-basic', async () => {
+    const { runset, spec, subject } = runners.request
+    await runset(spec.basic, subject)
+  })
+
+
+  test('resbasic-basic', async () => {
+    const { runset, spec, subject } = runners.resbasic
+    await runset(spec.basic, subject)
+  })
+
+  
+  test('resbody-basic', async () => {
+    const { runset, spec, subject } = runners.resbody
+    await runset(spec.basic, (ctx, result)=>{
+      let resdata = ctx.utility.struct.clone(ctx.response)
+      ctx.response.json = async ()=>resdata
+      return subject(ctx, result)
+    })
+  })
+
+
+  test('resform-basic', async () => {
+    const { runset, spec, subject } = runners.resform
+    await runset(spec.basic, subject)
+  })
+
+
+  test('resheaders-basic', async () => {
+    const { runset, spec, subject } = runners.resheaders
+    await runset(spec.basic, (ctx, result)=>{
+      ctx.response.headers.forEach = function (callback) {
+        Object.keys(this).forEach((key) => {
+          callback(this[key], key, this)
+        })
+      }
+      return subject(ctx, result)
+    })
+  })
+
+  
+  test('response-basic', async () => {
+    const { runset, spec, subject } = runners.response
+    await runset(spec.basic, subject)
+  })
+
+
+  test('spec-basic', async () => {
+    const { runset, spec, subject } = runners.spec
+    await runset(spec.basic, subject)
+  })
+  
+})