w-serv-orm 1.1.5 → 1.1.7

package/src/WServOrm.mjs

@@ -9,6 +9,10 @@ import getProc from './getProc.mjs'
 /**
  * 產生伺服器ORM的支援物件
  *
+ * procOrm之save、del與mix，於ORM回傳之逐筆結果有任一筆ok為0(單筆失敗)時reject，訊息列出失敗筆之主鍵(無有效主鍵者列其於輸入內之位置)，錯誤原文另由console.log輸出。
+ * 單筆失敗不中斷整批，故reject時其餘筆數已寫入；save與del皆以主鍵為準，數據帶有主鍵時整批重送不會產生重複資料，未帶主鍵者重送則會由ORM另產生主鍵而重複寫入。
+ * mix之各步驟遇單筆失敗不中斷後續步驟，待全部步驟完成後一併reject；遇整批性錯誤則立即reject，後續步驟不執行。
+ *
  * @class
  * @param {Object} ds 輸入資料表設定物件
  * @param {Object} WOrm 輸入資料庫ORM物件

package/src/genTestData.mjs

@@ -1,7 +1,9 @@
-import get from 'lodash-es/get.js'
+import get from 'lodash-es/get.js'
+import size from 'lodash-es/size.js'
 import isbol from 'wsemi/src/isbol.mjs'
-import isfun from 'wsemi/src/isfun.mjs'
+import isfun from 'wsemi/src/isfun.mjs'
 import pmSeries from 'wsemi/src/pmSeries.mjs'
+import getItemsFail from './getItemsFail.mjs'
 
 
 async function genTestData(ds, woItems, opt = {}) {
@@ -44,7 +46,13 @@ async function genTestData(ds, woItems, opt = {}) {
             }
 
             //save
-            await woItems[k].save(rs)
+            let rss = await woItems[k].save(rs)
+
+            //check, 單筆失敗時整批仍resolve並以該筆ok為0回報, 須逐筆檢查
+            let fails = getItemsFail(rss, rs)
+            if (size(fails) > 0) {
+                throw new Error(`資料表[${k}]寫入測試資料失敗: ${JSON.stringify(fails)}`)
+            }
 
             if (bLog) {
                 console.log(`${k}.funTest and save`, rs)

package/src/getItemsFail.mjs

@@ -0,0 +1,37 @@
+import get from 'lodash-es/get.js'
+import each from 'lodash-es/each.js'
+import isarr from 'wsemi/src/isarr.mjs'
+
+
+function getItemsFail(rs, data) {
+    //由ORM逐筆函數(save、del)之回傳結果取出失敗者, 回傳[{k,id,err}], k為該筆於輸入內之位置
+    //w-orm系列規格: 逐筆函數回傳與輸入等長保序之陣列, 單筆失敗時整批仍resolve, 該筆以ok為0並附err回報, 須由呼叫端逐筆檢查
+    //逐筆結果不含主鍵, 故主鍵取自輸入之同位置數據
+
+    //check, 未依規格之ORM可能回傳非陣列, 無從逐筆檢查
+    if (!isarr(rs)) {
+        return []
+    }
+
+    //check, 輸入為單一物件時ORM回傳長度為1之陣列
+    if (!isarr(data)) {
+        data = [data]
+    }
+
+    //fails, 僅ok為0者視為失敗
+    let fails = []
+    each(rs, (v, k) => {
+        if (get(v, 'ok') === 0) {
+            fails.push({
+                k,
+                id: get(data, [k, 'id']),
+                err: get(v, 'err', ''),
+            })
+        }
+    })
+
+    return fails
+}
+
+
+export default getItemsFail

package/src/getMapOrm.mjs

@@ -2,17 +2,46 @@ import get from 'lodash-es/get.js'
 import each from 'lodash-es/each.js'
 import map from 'lodash-es/map.js'
 import size from 'lodash-es/size.js'
+import take from 'lodash-es/take.js'
+import join from 'lodash-es/join.js'
 import nowms2str from 'wsemi/src/nowms2str.mjs'
 import isarr from 'wsemi/src/isarr.mjs'
 import iseobj from 'wsemi/src/iseobj.mjs'
 import isestr from 'wsemi/src/isestr.mjs'
+import isnum from 'wsemi/src/isnum.mjs'
 import clearXSS from 'wsemi/src/clearXSS.mjs'
+import getItemsFail from './getItemsFail.mjs'
 
 
 let _ds = null
 let _woItems = null
 
 
+function getMsgFail(msg, fails) {
+    //前端訊息僅列出失敗筆, 錯誤原文另由console.log輸出, 與既有整批錯誤之處理一致
+    //有效主鍵(非空字串或數字)列為id[...], 否則列其於輸入內之位置, 失敗筆數過多時僅列前nShow筆並附總筆數
+
+    //nShow
+    let nShow = 10
+
+    //ss
+    let ss = map(take(fails, nShow), (v) => {
+        if (isestr(v.id) || isnum(v.id)) {
+            return `id[${v.id}]`
+        }
+        return `第${v.k + 1}筆`
+    })
+
+    //c
+    let c = `${msg}: ${join(ss, ', ')}`
+    if (size(fails) > nShow) {
+        c += `等共${size(fails)}筆`
+    }
+
+    return c
+}
+
+
 function adjustData(woName, userId, data, mode = 'save') { //mode: 'insert', 'save', 'insert+save'
 
     //check
@@ -172,6 +201,16 @@ async function mapOrm(userId, woName, mode, input) {
             return Promise.reject(err)
         }
 
+        //check, save單筆失敗時整批仍resolve並以該筆ok為0回報, 須逐筆檢查
+        //insert之錯誤皆屬整批性而reject, 其回傳為聚合物件而非逐筆陣列, 故不須檢查
+        if (mode === 'save') {
+            let fails = getItemsFail(r, input)
+            if (size(fails) > 0) {
+                console.log(`${woName}.save fail`, fails)
+                return Promise.reject(getMsgFail('儲存資料失敗', fails))
+            }
+        }
+
         //僅回傳id避免大量數據時造成負擔
         if (isarr(input)) {
             r = map(input, (v) => {
@@ -193,6 +232,15 @@ async function mapOrm(userId, woName, mode, input) {
                 err = '刪除資料失敗'
             })
 
+        //check, 單筆失敗時整批仍resolve並以該筆ok為0回報, 須逐筆檢查
+        if (!isestr(err)) {
+            let fails = getItemsFail(r, input)
+            if (size(fails) > 0) {
+                console.log(`${woName}.del fail`, fails)
+                err = getMsgFail('刪除資料失敗', fails)
+            }
+        }
+
     }
     else if (mode === 'delAll') {
 
@@ -215,6 +263,9 @@ async function mapOrm(userId, woName, mode, input) {
         let rt
         r = [] //default to array
 
+        //msgsFail, 逐筆失敗僅影響該筆, 不中斷後續步驟, 待全部步驟完成後一併reject; 整批性錯誤則仍立即reject
+        let msgsFail = []
+
         let add = get(input, 'add', [])
         if (size(add) > 0) {
 
@@ -251,7 +302,7 @@ async function mapOrm(userId, woName, mode, input) {
         if (size(del) > 0) {
 
             //del
-            await wo.del(del)
+            let rs = await wo.del(del)
                 .catch((msg) => {
                     console.log(`${woName}.save catch`, msg)
                     err = '刪除資料失敗'
@@ -262,6 +313,13 @@ async function mapOrm(userId, woName, mode, input) {
                 return Promise.reject(err)
             }
 
+            //check, 單筆失敗時整批仍resolve並以該筆ok為0回報, 須逐筆檢查
+            let fails = getItemsFail(rs, del)
+            if (size(fails) > 0) {
+                console.log(`${woName}.del fail`, fails)
+                msgsFail.push(getMsgFail('刪除資料失敗', fails))
+            }
+
             //r
             rt = map(del, (v) => {
                 return { id: v.id } //僅回傳id避免大量數據時造成負擔
@@ -283,7 +341,7 @@ async function mapOrm(userId, woName, mode, input) {
             }
 
             //save
-            await wo.save(diff)
+            let rs = await wo.save(diff)
                 .catch((msg) => {
                     console.log(`${woName}.save catch`, msg)
                     err = '變更資料失敗'
@@ -294,6 +352,13 @@ async function mapOrm(userId, woName, mode, input) {
                 return Promise.reject(err)
             }
 
+            //check, 單筆失敗時整批仍resolve並以該筆ok為0回報, 須逐筆檢查
+            let fails = getItemsFail(rs, diff)
+            if (size(fails) > 0) {
+                console.log(`${woName}.save fail`, fails)
+                msgsFail.push(getMsgFail('變更資料失敗', fails))
+            }
+
             //r
             rt = map(diff, (v) => {
                 return { id: v.id } //僅回傳id避免大量數據時造成負擔
@@ -301,6 +366,11 @@ async function mapOrm(userId, woName, mode, input) {
             r = [...r, ...rt]
         }
 
+        //check, 各步驟之逐筆失敗於全部步驟完成後一併reject
+        if (size(msgsFail) > 0) {
+            return Promise.reject(join(msgsFail, '; '))
+        }
+
         //console.log('mix r', r)
     }
     else {

package/test/api-procOrm.test.mjs

@@ -0,0 +1,68 @@
+import fs from 'fs'
+import assert from 'assert'
+import WOrm from 'w-orm-lowdb/src/WOrmLowdb.mjs'
+import ds from '../schema/index.mjs'
+import WServOrm from '../src/WServOrm.mjs'
+
+
+//以真ORM(w-orm-lowdb)經procOrm驗證逐筆失敗之回報; del帶無效主鍵為各w-orm後端共通之逐筆失敗(規格T6), 不須資料庫例外即可觸發
+let fd = './test/_tmp/api-procOrm'
+
+async function getReject(pm) {
+    try {
+        await pm
+    }
+    catch (err) {
+        return err
+    }
+    throw new Error('預期reject但resolve')
+}
+
+
+describe('procOrm接w-orm-lowdb', function() {
+
+    let so = null
+    let proc = (mode, input) => so.procOrm('u1', 'tests', mode, input)
+
+    before(function() {
+        fs.rmSync(fd, { recursive: true, force: true })
+        fs.mkdirSync(fd, { recursive: true })
+        so = WServOrm(ds, WOrm, `${fd}/db.json`, 'worm', { useCheckUser: false, useExcludeWhenNotAdmin: false })
+    })
+
+    after(async function() {
+        await so.closeAll()
+        fs.rmSync(fd, { recursive: true, force: true })
+    })
+
+    it('A01 save成功', async function() {
+        //R04: 全部成功時回傳id, 數據已寫入
+        let r = await proc('save', [{ id: 'a1', isActive: 'y' }])
+        assert.strict.deepEqual(r, [{ id: 'a1' }])
+        let rs = await proc('select', { id: 'a1' })
+        assert.strict.equal(rs.length, 1)
+    })
+
+    it('A02 del含無效主鍵', async function() {
+        //R02: 逐筆ok為0即reject並列出失敗主鍵; R10: 單筆失敗不中斷整批, 有效筆已刪除
+        let err = await getReject(proc('del', [{ id: 'a1' }, { id: 123 }]))
+        assert.strict.equal(err, '刪除資料失敗: id[123]')
+        let rs = await proc('select', { id: 'a1' })
+        assert.strict.equal(rs.length, 0)
+    })
+
+    it('A03 mix之del含無效主鍵', async function() {
+        //R03: del之逐筆失敗不中斷diff, diff已寫入, 最後reject列出del之失敗
+        let err = await getReject(proc('mix', { del: [{ id: 456 }], diff: [{ id: 'a2', isActive: 'y' }] }))
+        assert.strict.equal(err, '刪除資料失敗: id[456]')
+        let rs = await proc('select', { id: 'a2' })
+        assert.strict.equal(rs.length, 1)
+    })
+
+    it('A04 del主鍵未命中', async function() {
+        //R04: 主鍵未命中屬正常結果, 回傳ORM原始逐筆陣列
+        let r = await proc('del', [{ id: 'a-none' }])
+        assert.strict.deepEqual(r, [{ n: 0, nDeleted: 0, ok: 1 }])
+    })
+
+})

package/test/unit-mapOrm.test.mjs

@@ -0,0 +1,268 @@
+import assert from 'assert'
+import WServOrm from '../src/WServOrm.mjs'
+import genTestData from '../src/genTestData.mjs'
+
+
+//替身ORM, 回傳形狀依w-orm系列規格(資料庫函數回傳定義計算.md T2、T4):
+//save與del回傳與輸入等長保序之逐筆陣列, 單筆失敗時整批仍resolve, 該筆以ok為0並附err回報; 整批性錯誤則reject
+let plan = {}
+let calls = []
+function WOrmStub() {
+    let ev = {}
+    for (let fn of ['select', 'insert', 'save', 'del', 'delAll']) {
+        ev[fn] = async (data) => {
+            calls.push({ fn, data })
+            return plan[fn](data)
+        }
+    }
+    return ev
+}
+
+let ds = {
+    tests: {
+        keys: ['id', 'name', 'timeCreate', 'timeUpdate'],
+    },
+}
+
+let okSave = { n: 1, nInserted: 0, nModified: 1, ok: 1 }
+let okDel = { n: 1, nDeleted: 1, ok: 1 }
+
+async function getReject(pm) {
+    try {
+        await pm
+    }
+    catch (err) {
+        return err
+    }
+    throw new Error('預期reject但resolve')
+}
+
+
+describe('mapOrm逐筆失敗', function() {
+
+    let so = WServOrm(ds, WOrmStub, 'stub-url', 'stub-db', { useCheckUser: false, useExcludeWhenNotAdmin: false })
+    let proc = (mode, input) => so.procOrm('u1', 'tests', mode, input)
+
+    beforeEach(function() {
+        plan = {}
+        calls = []
+    })
+
+    it('U01 save陣列全部成功', async function() {
+        //R04: 全部成功時save回傳不變, 僅回傳id
+        plan.save = (data) => data.map(() => okSave)
+        let r = await proc('save', [{ id: 's1', name: 'a' }, { id: 's2', name: 'b' }])
+        assert.strict.deepEqual(r, [{ id: 's1' }, { id: 's2' }])
+    })
+
+    it('U02 save物件全部成功', async function() {
+        //R04: 輸入為單一物件時回傳單一{id}
+        plan.save = () => [okSave]
+        let r = await proc('save', { id: 's1', name: 'a' })
+        assert.strict.deepEqual(r, { id: 's1' })
+    })
+
+    it('U03 save陣列中一筆ok為0', async function() {
+        //R01: 逐筆ok為0即reject, 訊息帶失敗筆之主鍵, 不含成功筆
+        plan.save = () => [okSave, { n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-save' }]
+        let err = await getReject(proc('save', [{ id: 's1' }, { id: 's2' }]))
+        assert.strict.equal(err, '儲存資料失敗: id[s2]')
+    })
+
+    it('U04 save物件ok為0', async function() {
+        //R01: 輸入為單一物件時ORM回傳長度為1之陣列, 仍須檢出
+        plan.save = () => [{ n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-save' }]
+        let err = await getReject(proc('save', { id: 's1' }))
+        assert.strict.equal(err, '儲存資料失敗: id[s1]')
+    })
+
+    it('U05 save未帶主鍵之筆ok為0且無err', async function() {
+        //R01: 無有效主鍵者以輸入位置標示; R07: ok為0而無err(舊版ORM)仍判失敗
+        plan.save = () => [okSave, { n: 1, ok: 0 }]
+        let err = await getReject(proc('save', [{ id: 's1' }, { name: 'no-id' }]))
+        assert.strict.equal(err, '儲存資料失敗: 第2筆')
+    })
+
+    it('U06 save整批reject', async function() {
+        //R05: 整批性錯誤之訊息不變
+        plan.save = () => Promise.reject(new Error('E-batch'))
+        let err = await getReject(proc('save', [{ id: 's1' }]))
+        assert.strict.equal(err, '儲存資料失敗')
+    })
+
+    it('U07 save之ORM回傳非陣列', async function() {
+        //R07: 未依規格之ORM回傳非陣列時不檢查, 照舊回傳id
+        plan.save = () => ({ n: 1, ok: 1 })
+        let r = await proc('save', [{ id: 's1' }])
+        assert.strict.deepEqual(r, [{ id: 's1' }])
+    })
+
+    it('U08 save多筆ok為0', async function() {
+        //R08: 失敗筆數超過10筆時僅列前10筆並附總筆數
+        let input = []
+        for (let i = 1; i <= 12; i++) {
+            input.push({ id: `f${i}` })
+        }
+        plan.save = (data) => data.map(() => ({ n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-full' }))
+        let err = await getReject(proc('save', input))
+        let ids = input.slice(0, 10).map((v) => `id[${v.id}]`).join(', ')
+        assert.strict.equal(err, `儲存資料失敗: ${ids}等共12筆`)
+    })
+
+    it('U09 del全部成功含主鍵未命中', async function() {
+        //R04: del回傳ORM原始逐筆陣列不變; 主鍵未命中(n為0、ok為1)屬正常結果而非失敗
+        let rs = [okDel, { n: 0, nDeleted: 0, ok: 1 }]
+        plan.del = () => rs
+        let r = await proc('del', [{ id: 'd1' }, { id: 'd-none' }])
+        assert.strict.deepEqual(r, rs)
+    })
+
+    it('U10 del數字主鍵ok為0', async function() {
+        //R02: del逐筆ok為0即reject; 數字主鍵照列
+        plan.del = () => [okDel, { n: 0, nDeleted: 0, ok: 0, err: 'can not delete by invalid id[123]' }]
+        let err = await getReject(proc('del', [{ id: 'd1' }, { id: 123 }]))
+        assert.strict.equal(err, '刪除資料失敗: id[123]')
+    })
+
+    it('U10b del物件輸入ok為0且無err', async function() {
+        //R02: 物件輸入亦須檢出; R07: ok為0而無err仍判失敗
+        plan.del = () => [{ n: 1, nDeleted: 0, ok: 0 }]
+        let err = await getReject(proc('del', { id: 'd1' }))
+        assert.strict.equal(err, '刪除資料失敗: id[d1]')
+    })
+
+    it('U11 del整批reject', async function() {
+        //R05: 整批性錯誤之訊息不變
+        plan.del = () => Promise.reject(new Error('E-batch'))
+        let err = await getReject(proc('del', [{ id: 'd1' }]))
+        assert.strict.equal(err, '刪除資料失敗')
+    })
+
+    it('U12 del之ORM回傳非陣列', async function() {
+        //R07: 未依規格之ORM回傳非陣列時不檢查, 照舊回傳原值
+        plan.del = () => ({ n: 1, nDeleted: 1, ok: 1 })
+        let r = await proc('del', [{ id: 'd1' }])
+        assert.strict.deepEqual(r, { n: 1, nDeleted: 1, ok: 1 })
+    })
+
+    it('U13 mix全部成功', async function() {
+        //R04: mix依add、del、diff順序執行, 回傳累積之id
+        plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
+        plan.del = (data) => data.map(() => okDel)
+        plan.save = (data) => data.map(() => okSave)
+        let r = await proc('mix', { add: [{ id: 'a1' }], del: [{ id: 'd1' }], diff: [{ id: 'f1' }] })
+        assert.strict.deepEqual(r, [{ id: 'a1' }, { id: 'd1' }, { id: 'f1' }])
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'del', 'save'])
+    })
+
+    it('U14 mix之del與diff皆有ok為0', async function() {
+        //R03: 逐筆失敗不中斷後續步驟, 全部步驟完成後一次reject並分步列出
+        plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
+        plan.del = () => [okDel, { n: 0, nDeleted: 0, ok: 0, err: 'E-del' }]
+        plan.save = () => [{ n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-save' }]
+        let err = await getReject(proc('mix', { add: [{ id: 'a1' }], del: [{ id: 'd1' }, { id: 'd2' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, '刪除資料失敗: id[d2]; 變更資料失敗: id[f1]')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'del', 'save'])
+    })
+
+    it('U15 mix僅del有ok為0', async function() {
+        //R03: del之逐筆失敗不中斷diff, diff仍寫入, 最後reject僅列del之失敗
+        plan.del = () => [{ n: 0, nDeleted: 0, ok: 0, err: 'E-del' }]
+        plan.save = (data) => data.map(() => okSave)
+        let err = await getReject(proc('mix', { del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, '刪除資料失敗: id[d1]')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['del', 'save'])
+    })
+
+    it('U16 mix之del整批reject', async function() {
+        //R05: 整批性錯誤維持立即reject, 後續步驟不執行
+        plan.del = () => Promise.reject(new Error('E-batch'))
+        plan.save = (data) => data.map(() => okSave)
+        let err = await getReject(proc('mix', { del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, '刪除資料失敗')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['del'])
+    })
+
+    it('U17 mix之add整批reject', async function() {
+        //R05: insert整批性錯誤維持立即reject, 後續步驟不執行
+        plan.insert = () => Promise.reject(new Error('E-batch'))
+        plan.del = (data) => data.map(() => okDel)
+        let err = await getReject(proc('mix', { add: [{ id: 'a1' }], del: [{ id: 'd1' }] }))
+        assert.strict.equal(err, '新增資料失敗')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['insert'])
+    })
+
+    it('U18 mix之del有ok為0後diff整批reject', async function() {
+        //R05: 遇整批性錯誤即以該步驟之訊息reject, 先前之逐筆失敗已由log輸出
+        plan.del = () => [{ n: 0, nDeleted: 0, ok: 0, err: 'E-del' }]
+        plan.save = () => Promise.reject(new Error('E-batch'))
+        let err = await getReject(proc('mix', { del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, '變更資料失敗')
+    })
+
+    it('U19 insert成功', async function() {
+        //R04: insert回傳聚合物件而非逐筆陣列, 照舊回傳id
+        plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
+        let r = await proc('insert', [{ id: 'i1' }])
+        assert.strict.deepEqual(r, [{ id: 'i1' }])
+    })
+
+    it('U22 錯誤原文寫入log而不進reject訊息', async function() {
+        //R06: 前端訊息只帶主鍵, 錯誤原文由console.log輸出
+        plan.save = () => [{ n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-secret-detail' }]
+        let logs = []
+        let logOrig = console.log
+        console.log = (...args) => {
+            logs.push(args)
+        }
+        let err
+        try {
+            err = await getReject(proc('save', [{ id: 's1' }]))
+        }
+        finally {
+            console.log = logOrig
+        }
+        assert.ok(!String(err).includes('E-secret-detail'))
+        assert.ok(JSON.stringify(logs).includes('E-secret-detail'))
+    })
+
+})
+
+
+describe('genTestData逐筆失敗', function() {
+
+    let dsGen = {
+        tests: {
+            funTest: () => [{ id: 'g1' }, { id: 'g2' }],
+        },
+    }
+
+    it('U20 funTest全部成功', async function() {
+        //R09: 全部成功時照舊resolve, 並以funTest產生之數據呼叫save
+        let saved = null
+        let woItems = {
+            tests: {
+                save: async (rs) => {
+                    saved = rs
+                    return rs.map(() => okSave)
+                },
+            },
+        }
+        await genTestData(dsGen, woItems, { mode: 'funTest', bLog: false })
+        assert.strict.deepEqual(saved, [{ id: 'g1' }, { id: 'g2' }])
+    })
+
+    it('U21 funTest之save有ok為0', async function() {
+        //R09: 逐筆ok為0即reject, 訊息含資料表名與錯誤原文(伺服器端開發工具)
+        let woItems = {
+            tests: {
+                save: async () => [okSave, { n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-gen' }],
+            },
+        }
+        let err = await getReject(genTestData(dsGen, woItems, { mode: 'funTest', bLog: false }))
+        assert.ok(String(err).includes('tests'))
+        assert.ok(String(err).includes('E-gen'))
+        assert.ok(String(err).includes('g2'))
+    })
+
+})