w-orm-lmdb 1.0.18 → 1.0.20

package/src/WOrmLmdb.mjs

@@ -1,4 +1,4 @@
-import { open } from 'lmdb'
+import { open, ABORT } from 'lmdb'
 // import mingo from 'mingo' //mingo內未更新import寫法, 會導致ERR_UNSUPPORTED_DIR_IMPORT, 故須改用require引入使用
 import mingo from './reqMingo.js'
 import size from 'lodash-es/size.js'
@@ -28,13 +28,13 @@ import waitFun from 'wsemi/src/waitFun.mjs'
  * 故不監聽亦能取得完整資訊，且監聽與否不改變任何操作之回傳值。
  *
  * change事件，參數為(mode, data, res)，於資料實際異動成功後發出：
- * mode為操作別字串，可為'insert'、'save'、'del'、'delAll'；save內若逐筆走自動插入則該筆另發出mode為'insert'之事件。
+ * mode為操作別字串，可為'insert'、'insertBulk'、'save'、'del'、'delAll'；save內若逐筆走自動插入則該筆另發出mode為'insert'之事件。
  * data為本次操作之輸入數據，delAll固定為null。
  * res為本次操作之回傳結果。
  * 逐筆函數以整批為單位發出一次而不逐筆發出，select與selectByPk不發出本事件。
  *
  * error事件，參數為(mode, data, err)，於操作發生錯誤時發出：
- * mode為操作別字串，可為'select'、'selectByPk'、'insert'、'save'、'del'、'delAll'。
+ * mode為操作別字串，可為'select'、'selectByPk'、'insert'、'insertBulk'、'save'、'del'、'delAll'。
  * data為本次操作之輸入數據，無輸入數據者為null。
  * err為錯誤訊息字串，內容與正規管道所送出者一致。
  * 整批性錯誤於reject之前發出；逐筆失敗於該筆結果定案後發出，每筆一次。
@@ -126,13 +126,25 @@ function WOrmLmdb(opt = {}) {
     }
 
     //waitOpen, 等待client開啟, 因getRange與get於client關閉時會拋錯
+    //closed為終態: LMDB env一旦關閉不會自行回到open, 續等必然逾時, 故直接拋出而非空轉至逾時
+    //各函數入口已有procClosed守門, 此處之終態判斷為縱深防禦, 攔[操作進行中被close]之競態
+    //等待參數收斂: 開啟中為毫秒級過渡, 50次x200ms=10秒已極寬裕, 不使非終態之等待拖至waitFun預設之200秒
     let waitOpen = async () => {
+        if (client.status === 'closed') {
+            throw new Error('client is closed, instance can not be used after close()')
+        }
         await waitFun(() => {
-            if (client.status === 'closed') {
-                console.log(`client.status[${client.status}], level is closed`)
-            }
             return client.status === 'open'
-        })
+        }, { attemptNum: 50, timeInterval: 200 })
+    }
+
+    //procClosed, 各函數入口之終態守門: close()後再操作屬整批性錯誤, 立即reject令誤用當場可見
+    //不可靜默回正常空值(如null或未命中), 否則[已關閉]與[查無資料]同形,
+    //去重類呼叫端將把每筆判為未存在而fail-open, 整批重送下游昂貴動作
+    let procClosed = (mode, data) => {
+        let msg = `can not ${mode} by closed client, instance can not be used after close()`
+        emitError(mode, data, msg)
+        return Promise.reject(new Error(msg))
     }
 
     //emitChange, 資料實際異動成功後發出, 事件僅為附加通知不承擔回傳義務
@@ -212,6 +224,11 @@ function WOrmLmdb(opt = {}) {
      * @returns {Promise} 回傳Promise，resolve回傳數據，reject回傳錯誤訊息
      */
     async function select(find = {}) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('select', null)
+        }
         let isErr = false
         let res = null
 
@@ -271,6 +288,11 @@ function WOrmLmdb(opt = {}) {
      * @returns {Promise} 回傳Promise，resolve回傳數據物件，若無此主鍵則回傳null，reject回傳錯誤訊息
      */
     async function selectByPk(pk) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('selectByPk', null)
+        }
         let isErr = false
         let res = null
 
@@ -320,13 +342,30 @@ function WOrmLmdb(opt = {}) {
      *
      * @memberOf WOrmLmdb
      * @param {Object|Array} data 輸入數據物件或陣列
-     * @returns {Promise} 回傳Promise，resolve回傳插入結果物件{n,nInserted,ok}，n為輸入筆數、nInserted為實際插入筆數，reject回傳錯誤訊息
+     * @param {Object} [option={}] 輸入設定物件，預設為{}
+     * @param {Boolean} [option.returnList=false] 輸入是否改回傳逐筆結果布林值，預設false。給true時回傳與輸入等長保序之陣列，各筆為{n,nInserted,ok}，nInserted為1即該筆為新增；聚合計數只回答有幾筆是新的，逐筆結果方能回答是哪幾筆，供下游僅對新資料執行昂貴動作。回傳形式由呼叫點靜態決定，共用之結果處理程式碼不可跨不同取值之呼叫點混用
+     * @returns {Promise} 回傳Promise，resolve依returnList回傳插入結果：預設回傳聚合物件{n,nInserted,ok}，n為輸入筆數、nInserted為實際插入筆數；returnList為true時回傳逐筆陣列，各筆n恆為1(主鍵命中或經插入)、ok恆為1(insert之錯誤皆屬整批性而reject，不進逐筆)；reject回傳錯誤訊息
      */
-    async function insert(data) {
+    async function insert(data, option = {}) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('insert', data)
+        }
         let isErr = false
 
+        //returnList
+        let returnList = get(option, 'returnList')
+        if (!isbol(returnList)) {
+            returnList = false
+        }
+
         //check
         if (!iseobj(data) && !isearr(data)) {
+            if (returnList) {
+                //輸入無效, 對齊save與del之T5規定回傳空陣列
+                return []
+            }
             return {
                 n: 0,
                 nInserted: 0,
@@ -375,9 +414,122 @@ function WOrmLmdb(opt = {}) {
             })
 
             //res
+            if (returnList) {
+                //逐筆結果, 與輸入等長保序, 元素沿用逐筆結果之家族形狀(同save與del之元素)
+                //n恆為1(主鍵命中既有或經插入而產生), ok恆為1(insert之錯誤皆屬整批性而reject, 不進逐筆),
+                //資訊由nInserted承載, filter(v=>v.nInserted===1)之長度必等於聚合模式之nInserted
+                res = map(ltdone, function(done) {
+                    return {
+                        n: 1,
+                        nInserted: done ? 1 : 0,
+                        ok: 1,
+                    }
+                })
+            }
+            else {
+                res = {
+                    n: nAll,
+                    nInserted: nPush,
+                    ok: 1,
+                }
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證插入多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            emitChange('insert', data, res)
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('insert', data, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 批次插入數據，全批視為一個單位，全部插入成功或一筆都不寫入
+     * 註: 本函數非insert之加速版，兩者衝突政策不同。insert於主鍵已存在時跳過該筆而整批ok為1，
+     * 本函數則整批reject且不寫入任何一筆；同批含重複主鍵者亦視為衝突。確無衝突時兩者結果相同
+     * 註: 於本套件不會較insert快，因insert本即以Promise.all一次送出全部條件寫入而非逐筆await，
+     * 提供本函數係為與其他w-orm系列套件維持同一組函數，令呼叫端得於各套件間替換而不須改寫呼叫
+     *
+     * @memberOf WOrmLmdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @returns {Promise} 回傳Promise，resolve回傳插入結果物件{n,nInserted,ok}，n為輸入筆數、nInserted成功時恆等於n，任一筆主鍵已存在則reject回傳錯誤訊息
+     */
+    async function insertBulk(data) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('insertBulk', data)
+        }
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return {
+                n: 0,
+                nInserted: 0,
+                ok: 1,
+            }
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check id
+            data = procPk(data, 'insertBulk')
+
+            //nAll
+            let nAll = size(data)
+
+            //childTransaction, 全有全無由交易回滾保證
+            //註: 非同步之client.transaction於中止時並不回滾, 實測其內之put仍會落盤, 故此處須用childTransaction
+            //註: 交易內之client.get讀得到同一交易稍早之put, 故同批含重複主鍵者亦會於此被偵測為衝突
+            //註: 存在與否採鍵層判定, 與insert之ifNoExists一致
+            let pkConflict = null
+            await client.childTransaction(() => {
+                for (let v of data) {
+                    if (client.get(v.id) !== undefined) {
+                        pkConflict = v.id
+                        return ABORT
+                    }
+                    client.put(v.id, v)
+                }
+            })
+
+            //check, 衝突則整批視為失敗, 交易已回滾故無任何寫入
+            if (isestr(pkConflict)) {
+                throw new Error(`can not insertBulk by existed id[${pkConflict}]`)
+            }
+
+            //res, 未衝突則全數插入, 故nInserted恆等於n
             res = {
                 n: nAll,
-                nInserted: nPush,
+                nInserted: nAll,
                 ok: 1,
             }
 
@@ -392,14 +544,14 @@ function WOrmLmdb(opt = {}) {
 
         //emit, 於change可能須使用select, 故須放在重設快取之後
         if (!isErr) {
-            emitChange('insert', data, res)
+            emitChange('insertBulk', data, res)
         }
 
         //check
         if (isErr) {
 
             //emit, 整批性錯誤須於reject之前發出
-            emitError('insert', data, res)
+            emitError('insertBulk', data, res)
 
             return Promise.reject(res)
         }
@@ -417,6 +569,11 @@ function WOrmLmdb(opt = {}) {
      * @returns {Promise} 回傳Promise，resolve回傳與輸入等長之儲存結果陣列，各筆為{n,nInserted,nModified,ok}，n為主鍵命中筆數，單筆失敗者ok為0並附err，reject回傳錯誤訊息
      */
     async function save(data, option = {}) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('save', data)
+        }
         let isErr = false
 
         //check
@@ -618,6 +775,11 @@ function WOrmLmdb(opt = {}) {
      * @returns {Promise} 回傳Promise，resolve回傳與輸入等長之刪除結果陣列，各筆為{n,nDeleted,ok}，n為主鍵命中筆數，單筆失敗或未給有效id者ok為0並附err，reject回傳錯誤訊息
      */
     async function del(data) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('del', data)
+        }
         let isErr = false
 
         //check
@@ -749,6 +911,11 @@ function WOrmLmdb(opt = {}) {
      * @returns {Promise} 回傳Promise，resolve回傳刪除結果物件{n,nDeleted,ok}，n與nDeleted同為實際刪除筆數，reject回傳錯誤訊息
      */
     async function delAll(find = {}) {
+
+        //check client, closed為終態, 於任何檢查與寫入之前先行攔下(T4: 實例已關閉屬整批性錯誤)
+        if (client.status === 'closed') {
+            return procClosed('delAll', null)
+        }
         let isErr = false
 
         //res
@@ -851,7 +1018,8 @@ function WOrmLmdb(opt = {}) {
         return res
     }
 
-    //close, 關閉內部LMDB env並釋放檔案鎖, close後該實例即報廢, 須重新new WOrmLmdb
+    //close, 關閉內部LMDB env並釋放檔案鎖, close後該實例即報廢, 須重新new WOrmLmdb,
+    //再呼叫任何操作函數將立即reject(訊息明示closed), 不與[查無資料]同形
     let close = async () => {
         if (client && client.status !== 'closed') {
             await client.close() //lmdb root database之close(), 回傳Promise
@@ -862,6 +1030,7 @@ function WOrmLmdb(opt = {}) {
     ee.select = select
     ee.selectByPk = selectByPk
     ee.insert = insert
+    ee.insertBulk = insertBulk
     ee.save = save
     ee.del = del
     ee.delAll = delAll

package/test/unit-closed.test.mjs

@@ -0,0 +1,108 @@
+import assert from 'assert'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import WOrm from '../src/WOrmLmdb.mjs'
+
+
+describe('closed', function() {
+    let vans = {}
+    let vget = {}
+
+    before(async function() {
+
+        w.fsDeleteFolder('./_db_closed')
+
+        let wo = WOrm({ url: './_db_closed', db: 'worm', cl: 'users' })
+        await wo.insert({ id: 'k1', name: 'peter' })
+        await wo.close()
+
+        //evs, close後之操作屬整批性錯誤, 依T10.3須發出error事件
+        let evs = []
+        wo.on('error', function(mode, data, err) {
+            evs.push({ mode, isStr: _.isString(err) })
+        })
+
+        //run, close後各函數皆須立即reject(而非空轉約200秒), 且訊息明示closed而不與[查無資料]同形
+        let run = async (fn) => {
+            let t0 = Date.now()
+            let r = await fn()
+                .then(function(msg) {
+                    return { type: 'resolve', msg }
+                })
+                .catch(function(err) {
+                    return { type: 'reject', closed: String(err).indexOf('closed') >= 0 }
+                })
+            r.fast = (Date.now() - t0) < 2000
+            return r
+        }
+
+        vget[1] = await run(() => wo.select())
+        vget[2] = await run(() => wo.selectByPk('k1'))
+        vget[3] = await run(() => wo.insert({ id: 'k2' }))
+        vget[4] = await run(() => wo.insert({ id: 'k2' }, { returnList: true }))
+        vget[5] = await run(() => wo.insertBulk({ id: 'k3' }))
+        vget[6] = await run(() => wo.save({ id: 'k1', name: 'mary' }))
+        vget[7] = await run(() => wo.del({ id: 'k1' }))
+        vget[8] = await run(() => wo.delAll())
+        vget[9] = _.map(evs, 'mode')
+        vget[10] = _.uniq(_.map(evs, 'isStr'))
+
+    })
+
+    let rj = { type: 'reject', closed: true, fast: true }
+
+    vans[1] = rj
+    it(`should get ${JSON.stringify(vans[1])} for select after close`, async function() {
+        assert.strict.deepStrictEqual(vget[1], vans[1])
+    })
+
+    //不可回null, 否則[已關閉]與[查無資料]同形而fail-open
+    vans[2] = rj
+    it(`should get ${JSON.stringify(vans[2])} for selectByPk after close`, async function() {
+        assert.strict.deepStrictEqual(vget[2], vans[2])
+    })
+
+    vans[3] = rj
+    it(`should get ${JSON.stringify(vans[3])} for insert after close`, async function() {
+        assert.strict.deepStrictEqual(vget[3], vans[3])
+    })
+
+    vans[4] = rj
+    it(`should get ${JSON.stringify(vans[4])} for insert(returnList) after close`, async function() {
+        assert.strict.deepStrictEqual(vget[4], vans[4])
+    })
+
+    //守門須在進入childTransaction之前, 否則已關閉env上之非同步回調會拋出未捕捉例外使行程崩潰
+    vans[5] = rj
+    it(`should get ${JSON.stringify(vans[5])} for insertBulk after close`, async function() {
+        assert.strict.deepStrictEqual(vget[5], vans[5])
+    })
+
+    //屬整批性錯誤而reject, 不可降為逐筆ok:0之resolve
+    vans[6] = rj
+    it(`should get ${JSON.stringify(vans[6])} for save after close`, async function() {
+        assert.strict.deepStrictEqual(vget[6], vans[6])
+    })
+
+    //不可回[{n:0,nDeleted:0,ok:1}]之正常未命中結果
+    vans[7] = rj
+    it(`should get ${JSON.stringify(vans[7])} for del after close`, async function() {
+        assert.strict.deepStrictEqual(vget[7], vans[7])
+    })
+
+    vans[8] = rj
+    it(`should get ${JSON.stringify(vans[8])} for delAll after close`, async function() {
+        assert.strict.deepStrictEqual(vget[8], vans[8])
+    })
+
+    vans[9] = ['select', 'selectByPk', 'insert', 'insert', 'insertBulk', 'save', 'del', 'delAll']
+    it(`should get ${JSON.stringify(vans[9])} for error events after close`, async function() {
+        assert.strict.deepStrictEqual(vget[9], vans[9])
+    })
+
+    vans[10] = [true]
+    it(`should get ${JSON.stringify(vans[10])} for err of error events being string`, async function() {
+        assert.strict.deepStrictEqual(vget[10], vans[10])
+    })
+
+})

package/test/unit-insertbulk.test.mjs

@@ -0,0 +1,205 @@
+import assert from 'assert'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import WOrm from '../src/WOrmLmdb.mjs'
+
+
+describe('insertBulk', function() {
+    let rt = null
+    let vans = {}
+    let vget = {}
+
+    before(async function() {
+
+        w.fsDeleteFolder('./_db_insertbulk')
+
+        let url = './_db_insertbulk'
+
+        let wo = WOrm({ url, db: 'worm', cl: 'users' })
+
+        //輸入無效
+        vget[1] = await wo.insertBulk(null)
+
+        //正常插入, nInserted須恆等於n
+        rt = null
+        // vans[2] = { n: 3, nInserted: 3, ok: 1 }
+        await wo.insertBulk([{ id: 'a' }, { id: 'b' }, { id: 'c' }])
+            .then(function(msg) {
+                // console.log('insertBulk then', msg)
+                // insertBulk then { n: 3, nInserted: 3, ok: 1 }
+                rt = msg
+            })
+            .catch(function(msg) {
+                // console.log('insertBulk catch', msg)
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[2] = rt
+        vget[3] = _.map(_.sortBy(await wo.select(), 'id'), 'id')
+
+        //單一物件亦須回傳單一物件而非陣列
+        rt = null
+        // vans[4] = { n: 1, nInserted: 1, ok: 1 }
+        await wo.insertBulk({ id: 'd' })
+            .then(function(msg) {
+                rt = msg
+            })
+            .catch(function(msg) {
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[4] = rt
+
+        //含既有主鍵須整批reject, 且不得寫入任何一筆
+        rt = null
+        await wo.insertBulk([{ id: 'e' }, { id: 'a' }, { id: 'f' }])
+            .then(function(msg) {
+                rt = 'resolve: ' + JSON.stringify(msg)
+            })
+            .catch(function() {
+                rt = 'reject'
+            })
+        vget[5] = rt
+        vget[6] = _.map(_.sortBy(await wo.select(), 'id'), 'id')
+
+        //同批含重複主鍵亦視為衝突
+        rt = null
+        await wo.insertBulk([{ id: 'g' }, { id: 'g' }])
+            .then(function(msg) {
+                rt = 'resolve: ' + JSON.stringify(msg)
+            })
+            .catch(function() {
+                rt = 'reject'
+            })
+        vget[7] = rt
+        vget[8] = _.map(_.sortBy(await wo.select(), 'id'), 'id')
+
+        //事件: 成功發change, 衝突發error且不發change
+        let evs = []
+        wo.on('change', function(mode) {
+            evs.push('change:' + mode)
+        })
+        wo.on('error', function(mode, data, err) {
+            evs.push({ ev: 'error:' + mode, isStr: _.isString(err) })
+        })
+        await wo.insertBulk({ id: 'h' })
+        vget[9] = _.map(evs, function(v) {
+            return v.ev || v
+        })
+        evs = []
+        await wo.insertBulk({ id: 'h' }).catch(function() {})
+        vget[10] = _.map(evs, function(v) {
+            return v.ev || v
+        })
+        vget[11] = _.get(evs, '0.isStr')
+        await wo.close()
+
+        //autoGenPk為true時補值
+        let woGen = WOrm({ url, db: 'worm', cl: 'gen' })
+        rt = null
+        // vans[12] = { n: 2, nInserted: 2, ok: 1 }
+        await woGen.insertBulk([{ v: 1 }, { v: 2 }])
+            .then(function(msg) {
+                rt = msg
+            })
+            .catch(function(msg) {
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[12] = rt
+        vget[13] = _.size(_.filter(await woGen.select(), function(v) {
+            return w.isestr(v.id)
+        }))
+        await woGen.close()
+
+        //autoGenPk為false而未帶有效主鍵, 須reject且不得寫入任何一筆
+        let woNo = WOrm({ url, db: 'worm', cl: 'nogen', autoGenPk: false })
+        rt = null
+        await woNo.insertBulk([{ id: 'x1' }, { v: 1 }])
+            .then(function(msg) {
+                rt = 'resolve: ' + JSON.stringify(msg)
+            })
+            .catch(function() {
+                rt = 'reject'
+            })
+        vget[14] = rt
+        vget[15] = _.size(await woNo.select())
+        await woNo.close()
+
+    })
+
+    vans[1] = { n: 0, nInserted: 0, ok: 1 }
+    it(`should get ${JSON.stringify(vans[1])} for insertBulk with invalid input`, async function() {
+        assert.strict.deepStrictEqual(vget[1], vans[1])
+    })
+
+    vans[2] = { n: 3, nInserted: 3, ok: 1 }
+    it(`should get ${JSON.stringify(vans[2])} for insertBulk without conflict`, async function() {
+        assert.strict.deepStrictEqual(vget[2], vans[2])
+    })
+
+    vans[3] = ['a', 'b', 'c']
+    it(`should get ${JSON.stringify(vans[3])} for records after insertBulk`, async function() {
+        assert.strict.deepStrictEqual(vget[3], vans[3])
+    })
+
+    vans[4] = { n: 1, nInserted: 1, ok: 1 }
+    it(`should get ${JSON.stringify(vans[4])} for insertBulk by single object`, async function() {
+        assert.strict.deepStrictEqual(vget[4], vans[4])
+    })
+
+    //全有全無: 衝突須整批reject
+    vans[5] = 'reject'
+    it(`should get ${JSON.stringify(vans[5])} for insertBulk with existed id`, async function() {
+        assert.strict.deepStrictEqual(vget[5], vans[5])
+    })
+
+    //全有全無: 衝突時同批之無衝突筆數亦不得寫入
+    vans[6] = ['a', 'b', 'c', 'd']
+    it(`should get ${JSON.stringify(vans[6])} for no writing when insertBulk rejected`, async function() {
+        assert.strict.deepStrictEqual(vget[6], vans[6])
+    })
+
+    vans[7] = 'reject'
+    it(`should get ${JSON.stringify(vans[7])} for insertBulk with duplicated id in same batch`, async function() {
+        assert.strict.deepStrictEqual(vget[7], vans[7])
+    })
+
+    vans[8] = ['a', 'b', 'c', 'd']
+    it(`should get ${JSON.stringify(vans[8])} for no writing when duplicated id in same batch`, async function() {
+        assert.strict.deepStrictEqual(vget[8], vans[8])
+    })
+
+    vans[9] = ['change:insertBulk']
+    it(`should get ${JSON.stringify(vans[9])} for change event of insertBulk`, async function() {
+        assert.strict.deepStrictEqual(vget[9], vans[9])
+    })
+
+    vans[10] = ['error:insertBulk']
+    it(`should get ${JSON.stringify(vans[10])} for error event of insertBulk with conflict`, async function() {
+        assert.strict.deepStrictEqual(vget[10], vans[10])
+    })
+
+    vans[11] = true
+    it(`should get ${JSON.stringify(vans[11])} for err of error event being string`, async function() {
+        assert.strict.deepStrictEqual(vget[11], vans[11])
+    })
+
+    vans[12] = { n: 2, nInserted: 2, ok: 1 }
+    it(`should get ${JSON.stringify(vans[12])} for insertBulk without id by autoGenPk=true`, async function() {
+        assert.strict.deepStrictEqual(vget[12], vans[12])
+    })
+
+    vans[13] = 2
+    it(`should get ${JSON.stringify(vans[13])} for records with generated id`, async function() {
+        assert.strict.deepStrictEqual(vget[13], vans[13])
+    })
+
+    vans[14] = 'reject'
+    it(`should get ${JSON.stringify(vans[14])} for insertBulk without id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[14], vans[14])
+    })
+
+    vans[15] = 0
+    it(`should get ${JSON.stringify(vans[15])} for no writing when autoGenPk=false rejected`, async function() {
+        assert.strict.deepStrictEqual(vget[15], vans[15])
+    })
+
+})