w-orm-lowdb 1.0.30 → 1.0.32

package/test/unit-find-whitelist.test.mjs

@@ -0,0 +1,533 @@
+import assert from 'assert'
+import fs from 'fs'
+import w from 'wsemi'
+import cvCases from 'wsemi/src/_cvOrmFindCases.mjs'
+import cvOrmFind from 'wsemi/src/cvOrmFind.mjs'
+import WOrm from '../src/WOrmLowdb.mjs'
+
+
+//條件(find)之系列白名單(帳本R-FIND-01; 規則: C:\opensrcOper\dspec\w-orm系列條件語法支援盤點.md〈一之三〉)
+//共用檢核為wsemi之cvOrmFind, 契約案例表為wsemi之_cvOrmFindCases(各w-orm-*逐案對公開select與delAll執行, 每案以seed()重建),
+//本檔驗證select與delAll確實於入口(serialize佇列之外)呼叫並只使用檢核後之複本, 而未被後端(mingo)略過
+//lowdb屬MongoDB式族, 命中集合取案例之ids.mongo; 數據以JSON存檔, 故條件內之Date由本套件轉為ISO字串後方能命中(E05 C09 I17);
+//本套件之$in上限即共用預設(10000), 故案例之need不使本套件reject
+describe('find-whitelist', function() {
+    let { seed, cases } = cvCases
+    let dir = './test/_tmp/find-whitelist'
+    let dbName = 'worm'
+
+    //ids, 取id集合(升冪)
+    let ids = (rs) => rs.map((v) => v.id).sort()
+
+    //tick, 讓出一個macrotask, 令延遲發出之事件有機會發出
+    let tick = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+    //directMsg, 共用檢核對同一條件直接給出之訊息(後端須原樣給出, 不得改寫、包裝或另立訊息)
+    let directMsg = (f) => {
+        try {
+            cvOrmFind(f)
+        }
+        catch (err) {
+            return err.message
+        }
+        return null
+    }
+
+    //mkObserver, 建立呼叫觀測器: 事件記錄於evs, 每筆error事件附帶發出當下呼叫端之await是否已恢復(settledAtEmit, 即呼叫端可觀察之先後)
+    let mkObserver = (wo) => {
+        let evs = []
+        let cur = { settled: false }
+        wo.on('error', function(mode, data, err) {
+            evs.push({ t: 'error', mode, data, err, settledAtEmit: cur.settled })
+        })
+        wo.on('change', function(mode) {
+            evs.push({ t: 'change', mode })
+        })
+
+        //invoke, 呼叫wo[fn](arg)並回傳{ ok, val, err, nAtSettle, probe, evs }, nAtSettle為結果定案當下之事件數,
+        //probe為結果定案當下(同一microtask鏈內, 尚未讓出macrotask)呼叫probeFn()之回傳, evs為再讓出一個macrotask後之事件
+        let invoke = async(fn, arg, probeFn = null) => {
+            evs.length = 0
+            cur = { settled: false }
+            let out = { ok: false, val: null, err: null, nAtSettle: 0, probe: null, evs: [] }
+            try {
+                out.val = await wo[fn](arg)
+                out.ok = true
+            }
+            catch (err) {
+                out.err = err
+            }
+            cur.settled = true
+            out.nAtSettle = evs.length
+            out.probe = probeFn ? probeFn() : null
+            await tick()
+            out.evs = evs.slice()
+            return out
+        }
+
+        //clear
+        let clear = () => {
+            evs.length = 0
+        }
+
+        return { invoke, clear }
+    }
+
+    //mk, 於測試資料夾下建立資料庫檔(url為檔案路徑)
+    let mk = (name, opt = {}) => {
+        let url = `${dir}/${name}.json`
+        w.fsDeleteFile(url)
+        return { url, wo: WOrm({ url, db: dbName, cl: name, ...opt }) }
+    }
+
+    //reset, 清空後以seed()重建
+    let reset = async(wo) => {
+        await wo.delAll()
+        await wo.insertBulk(seed())
+    }
+
+    //sortRows
+    let sortRows = (rows) => rows.sort((a, b) => (a.id < b.id ? -1 : 1))
+
+    //chkRej, 整批reject之共同斷言(WL-R1、WL-R3): 訊息以invalid find開頭且逐字等於共用檢核給出之訊息(expectMsg), error事件於reject前恰發出一次(訊息同reject), change不發
+    let chkRej = (out, fn, expectMsg = null) => {
+        assert.strict.equal(out.ok, false, `${fn} should reject`)
+        assert.strict.ok(out.err instanceof Error, `${fn} should reject with Error`)
+        assert.strict.ok(out.err.message.indexOf('invalid find: ') === 0, `${fn} message should start with 'invalid find: ' but got: ${out.err.message}`)
+        if (expectMsg !== null) {
+            assert.strict.equal(out.err.message, expectMsg, `${fn} message should be the one of cvOrmFind`)
+        }
+        let evErr = out.evs.filter((v) => v.t === 'error')
+        let evChg = out.evs.filter((v) => v.t === 'change' && v.mode === fn) //只計本函數之change(佇列測試中同時排入之insertBulk會發出自己的change)
+        assert.strict.equal(evErr.length, 1, `${fn} should emit error exactly once`)
+        assert.strict.equal(out.nAtSettle, 1, `${fn} should emit error before reject`)
+        assert.strict.equal(evErr[0].settledAtEmit, false, `${fn} should emit error before reject`)
+        assert.strict.equal(evErr[0].mode, fn)
+        assert.strict.equal(evErr[0].data, null)
+        assert.strict.equal(evErr[0].err, out.err.message, `${fn} error event should carry the reject message`)
+        assert.strict.equal(evChg.length, 0, `${fn} should not emit change`)
+    }
+
+    before(function() {
+        w.fsDeleteFolder(dir)
+        fs.mkdirSync(dir, { recursive: true })
+    })
+
+    after(function() {
+        w.fsDeleteFolder(dir)
+    })
+
+    describe('cases', function() {
+        let wo = null
+        let ob = null
+        let seedIds = ids(seed())
+        let seedRows = null
+
+        before(async function() {
+            wo = mk('cases').wo
+            ob = mkObserver(wo)
+            await reset(wo)
+            seedRows = sortRows(await wo.select())
+        })
+
+        //案例表本身: 防案例表被替換為空表或缺組別而使下列逐案全綠成為假象
+        it('should get nonempty case table covering all groups with seed of 6 rows', function() {
+            let groups = [...new Set(cases.map((c) => c.group))].sort().join('')
+            assert.strict.equal(groups, 'CEFHILNTVX')
+            assert.strict.ok(cases.length >= 241)
+            assert.strict.deepStrictEqual(seedIds, ['a1', 'a2', 'a3', 'a4', 'a5', 'a6'])
+        })
+
+        for (let c of cases) {
+
+            if (c.expect === 'REJ') {
+
+                //REJ案: select與delAll皆整批reject, 資料表不變(WL-02、WL-07等; 對應案例表expect=REJ)
+                it(`should reject select and delAll without any change for ${c.id} ${c.label}`, async function() {
+                    await reset(wo)
+                    ob.clear()
+
+                    let expectMsg = directMsg(c.find())
+                    assert.strict.notEqual(expectMsg, null, 'cvOrmFind should reject the case')
+                    let outS = await ob.invoke('select', c.find())
+                    chkRej(outS, 'select', expectMsg)
+                    let outD = await ob.invoke('delAll', c.find())
+                    chkRej(outD, 'delAll', expectMsg)
+
+                    //資料不變
+                    assert.strict.deepStrictEqual(sortRows(await wo.select()), seedRows)
+                })
+
+            }
+            else {
+
+                //ALL與OK案: select命中ids.mongo; delAll刪除之集合等於select命中之集合(系列最低要求①), n與nDeleted為實際刪除筆數
+                it(`should select ${JSON.stringify(c.ids.mongo)} and delAll the same set for ${c.id} ${c.label}`, async function() {
+                    await reset(wo)
+                    ob.clear()
+
+                    let outS = await ob.invoke('select', c.find())
+                    assert.strict.equal(outS.ok, true, `select should resolve but got: ${outS.err}`)
+                    let sel = ids(outS.val)
+                    assert.strict.deepStrictEqual(sel, c.ids.mongo)
+                    assert.strict.equal(outS.evs.filter((v) => v.t === 'error').length, 0)
+
+                    await reset(wo)
+                    ob.clear()
+                    let outD = await ob.invoke('delAll', c.find())
+                    assert.strict.equal(outD.ok, true, `delAll should resolve but got: ${outD.err}`)
+                    assert.strict.deepStrictEqual(outD.val, { n: sel.length, nDeleted: sel.length, ok: 1 })
+                    assert.strict.equal(outD.evs.filter((v) => v.t === 'error').length, 0)
+
+                    let rest = ids(await wo.select())
+                    let deleted = seedIds.filter((id) => rest.indexOf(id) < 0)
+                    assert.strict.deepStrictEqual(deleted, sel)
+                })
+
+            }
+
+        }
+
+    })
+
+    //檢查之值即使用之值(WL-H4): 檢核回傳之複本即後續查詢與刪除所用之條件, 不得再讀呼叫端之原物件
+    //以Proxy令欄位g於第1次讀取回'A'(檢核所讀)、其後回'B', 若後端改讀原物件(mingo以[]取值)則命中集合改變
+    describe('copy', function() {
+        let wo = null
+
+        before(async function() {
+            wo = mk('copy').wo
+            await reset(wo)
+        })
+
+        //mkFlip, 欄位g第1次被讀取(不論以屬性描述子或get)回'A', 其後回'B'; 同時回傳讀取次數
+        let mkFlip = () => {
+            let st = { n: 0 }
+            let val = () => {
+                st.n++
+                return st.n === 1 ? 'A' : 'B'
+            }
+            let px = new Proxy({ g: 'A' }, {
+                getOwnPropertyDescriptor(t, k) {
+                    let d = Reflect.getOwnPropertyDescriptor(t, k)
+                    if (k === 'g') {
+                        d = { ...d, value: val() }
+                    }
+                    return d
+                },
+                get(t, k, r) {
+                    if (k === 'g') {
+                        return val()
+                    }
+                    return Reflect.get(t, k, r)
+                },
+            })
+            return { px, st }
+        }
+
+        let shapes = {
+            top: (px) => px,
+            nested: (px) => ({ $or: [px] }),
+        }
+
+        for (let name of Object.keys(shapes)) {
+
+            it(`should select by the checked value only for ${name} condition`, async function() {
+                await reset(wo)
+                let { px, st } = mkFlip()
+                let r = await wo.select(shapes[name](px))
+                assert.strict.deepStrictEqual(ids(r), ['a1', 'a2'])
+                assert.strict.equal(st.n, 1, 'value should be read once')
+            })
+
+            it(`should delAll by the checked value only for ${name} condition`, async function() {
+                await reset(wo)
+                let { px, st } = mkFlip()
+                let r = await wo.delAll(shapes[name](px))
+                assert.strict.deepStrictEqual(r, { n: 2, nDeleted: 2, ok: 1 })
+                assert.strict.deepStrictEqual(ids(await wo.select()), ['a3', 'a4', 'a5', 'a6'])
+                assert.strict.equal(st.n, 1, 'value should be read once')
+            })
+
+        }
+
+        //熱快取(useCache已填入)時亦只用檢核後之複本: 原快取測試只以壞條件與穩定條件驗快取, 守不住「合法條件改讀原物件」
+        for (let fn of ['select', 'delAll']) {
+            it(`should use the checked copy only with warm cache for ${fn}`, async function() {
+                let { wo: wc } = mk(`warm${fn}`, { useCache: true })
+                await wc.insertBulk(seed())
+                assert.strict.equal((await wc.select()).length, 6) //填入快取
+                let { px, st } = mkFlip()
+                if (fn === 'select') {
+                    assert.strict.deepStrictEqual(ids(await wc.select(px)), ['a1', 'a2'])
+                }
+                else {
+                    assert.strict.deepStrictEqual(await wc.delAll(px), { n: 2, nDeleted: 2, ok: 1 })
+                    assert.strict.deepStrictEqual(ids(await wc.select()), ['a3', 'a4', 'a5', 'a6'])
+                }
+                assert.strict.equal(st.n, 1, 'value should be read once')
+            })
+        }
+
+        //「是否有條件」之判斷亦須依檢核後之複本: ownKeys於第1次回['g']、其後回[](若改讀原物件, select會回全部、delAll會刪光)
+        for (let fn of ['select', 'delAll']) {
+            it(`should decide the empty condition by the checked copy only for ${fn}`, async function() {
+                await reset(wo)
+                let n = 0
+                let px = new Proxy({ g: 'A' }, {
+                    ownKeys() {
+                        n++
+                        return n === 1 ? ['g'] : []
+                    },
+                })
+                if (fn === 'select') {
+                    assert.strict.deepStrictEqual(ids(await wo.select(px)), ['a1', 'a2'])
+                }
+                else {
+                    assert.strict.deepStrictEqual(await wo.delAll(px), { n: 2, nDeleted: 2, ok: 1 })
+                    assert.strict.deepStrictEqual(ids(await wo.select()), ['a3', 'a4', 'a5', 'a6'])
+                }
+                assert.strict.equal(n, 1, 'ownKeys should be read once')
+            })
+        }
+
+        //運算子物件內之值亦只讀一次並只用複本: {age:Proxy({$gt:20})}, $gt第1次被讀取回20、其後回100(若改讀原物件, 命中集合改變)
+        for (let fn of ['select', 'delAll']) {
+            it(`should read the value in operator object once for ${fn}`, async function() {
+                await reset(wo)
+                let n = 0
+                let val = () => (++n === 1 ? 20 : 100)
+                let op = new Proxy({ $gt: 20 }, {
+                    getOwnPropertyDescriptor(t, k) {
+                        let d = Reflect.getOwnPropertyDescriptor(t, k)
+                        return k === '$gt' ? { ...d, value: val() } : d
+                    },
+                    get(t, k, r) {
+                        return k === '$gt' ? val() : Reflect.get(t, k, r)
+                    },
+                })
+                if (fn === 'select') {
+                    assert.strict.deepStrictEqual(ids(await wo.select({ age: op })), ['a2', 'a3', 'a5'])
+                }
+                else {
+                    assert.strict.deepStrictEqual(await wo.delAll({ age: op }), { n: 3, nDeleted: 3, ok: 1 })
+                    assert.strict.deepStrictEqual(ids(await wo.select()), ['a1', 'a4', 'a6'])
+                }
+                assert.strict.equal(n, 1, 'value should be read once')
+            })
+        }
+
+        //呼叫端的條件物件不被改動: 複本內之Date轉為ISO字串不得波及呼叫端之Date
+        it('should not modify the find object of caller', async function() {
+            await reset(wo)
+            let find = { $and: [{ g: 'A' }, { age: { $in: [20, 30] } }], d: new Date(Date.UTC(2026, 0, 1)) }
+            let snap = JSON.stringify(find)
+            let d0 = find.d.getTime()
+            let r = await wo.select(find)
+            assert.strict.deepStrictEqual(ids(r), ['a1'])
+            await wo.delAll(find)
+            assert.strict.equal(JSON.stringify(find), snap)
+            assert.strict.ok(find.d instanceof Date)
+            assert.strict.equal(find.d.getTime(), d0)
+            assert.strict.ok(Object.getPrototypeOf(find) === Object.prototype)
+        })
+
+        //select與delAll對同一條件之判定一致(逐案已驗, 此處以非空巢狀條件再驗一次)
+        it('should delAll exactly what select returns for nested condition', async function() {
+            await reset(wo)
+            let find = { $or: [{ $and: [{ g: 'B' }, { age: { $gte: 40 } }] }, { id: { $in: ['a1'] } }] }
+            let sel = ids(await wo.select(find))
+            assert.strict.deepStrictEqual(sel, ['a1', 'a3', 'a5'])
+            let r = await wo.delAll(find)
+            assert.strict.deepStrictEqual(r, { n: 3, nDeleted: 3, ok: 1 })
+            assert.strict.deepStrictEqual(ids(await wo.select()), ['a2', 'a4', 'a6'])
+        })
+
+    })
+
+    //欄名同於Object.prototype成員(WL-F2: constructor、toString、hasOwnProperty、valueOf等為白名單內之合法欄名):
+    //數據無此自有欄位者須與一般不存在之欄位同為缺欄(null語意), 不得取到繼承之成員(修正前mingo取到函數, {constructor:null}無命中、{constructor:{$ne:null}}命中全部而delAll刪光)
+    describe('protoname', function() {
+        let wo = null
+
+        //resetP, 種子6列(皆無自有constructor、toString等欄)另加p1(自有constructor與toString欄)
+        let resetP = async() => {
+            await reset(wo)
+            await wo.insert({ id: 'p1', constructor: 'own', toString: 'ts' })
+        }
+        let A6 = ['a1', 'a2', 'a3', 'a4', 'a5', 'a6']
+
+        before(async function() {
+            wo = mk('proto').wo
+        })
+
+        let finds = [
+            { name: '{constructor:null}', find: () => ({ constructor: null }), ids: A6 },
+            { name: '{constructor:{$eq:null}}', find: () => ({ constructor: { $eq: null } }), ids: A6 },
+            { name: '{constructor:{$ne:null}}', find: () => ({ constructor: { $ne: null } }), ids: ['p1'] },
+            { name: '{constructor:"own"}', find: () => ({ constructor: 'own' }), ids: ['p1'] },
+            { name: '{toString:{$ne:null}}', find: () => ({ toString: { $ne: null } }), ids: ['p1'] },
+            { name: '{toString:null}', find: () => ({ toString: null }), ids: A6 },
+            { name: '{hasOwnProperty:{$ne:null}}', find: () => ({ hasOwnProperty: { $ne: null } }), ids: [] },
+            { name: '{valueOf:null}', find: () => ({ valueOf: null }), ids: [...A6, 'p1'] },
+            { name: '{valueOf:{$in:["x"]}}', find: () => ({ valueOf: { $in: ['x'] } }), ids: [] },
+            { name: '{valueOf:{$nin:["x"]}}', find: () => ({ valueOf: { $nin: ['x'] } }), ids: [...A6, 'p1'] },
+            { name: '$or', find: () => ({ $or: [{ constructor: 'own' }, { id: 'a1' }] }), ids: ['a1', 'p1'] },
+            { name: '$and', find: () => ({ $and: [{ toString: null }, { id: 'a2' }] }), ids: ['a2'] },
+            { name: 'nested $or in $and', find: () => ({ $and: [{ $or: [{ hasOwnProperty: { $ne: null } }, { id: 'a3' }] }] }), ids: ['a3'] },
+            { name: 'with ordinary field', find: () => ({ g: 'A', constructor: null }), ids: ['a1', 'a2'] },
+        ]
+        for (let f of finds) {
+            it(`should select and delAll by ${f.name} as missing-field semantics`, async function() {
+                await resetP()
+                assert.strict.deepStrictEqual(ids(await wo.select(f.find())), f.ids)
+                await resetP()
+                let r = await wo.delAll(f.find())
+                assert.strict.deepStrictEqual(r, { n: f.ids.length, nDeleted: f.ids.length, ok: 1 })
+                let rest = ids(await wo.select())
+                assert.strict.deepStrictEqual([...A6, 'p1'].filter((id) => rest.indexOf(id) < 0), f.ids)
+            })
+        }
+
+        //對照組: 一般不存在之欄位(全部列皆缺欄)之語意, 原型成員欄名須與之同(數據無自有欄位者皆缺欄)
+        it('should get the same result for an ordinary missing field', async function() {
+            await resetP()
+            assert.strict.deepStrictEqual(ids(await wo.select({ nocolumn: null })), [...A6, 'p1'])
+            assert.strict.deepStrictEqual(ids(await wo.select({ nocolumn: { $ne: null } })), [])
+            assert.strict.deepStrictEqual(ids(await wo.select({ nocolumn: { $nin: ['x'] } })), [...A6, 'p1'])
+            assert.strict.deepStrictEqual(ids(await wo.select({ nocolumn: { $in: ['x'] } })), [])
+        })
+
+    })
+
+    //Date(WL-S3): 數據以JSON存檔(Date成ISO字串), 條件內之Date由本套件於轉譯層轉為ISO字串, 於各位置皆須命中
+    describe('date', function() {
+        let wo = null
+        let D1 = () => new Date(Date.UTC(2026, 0, 1))
+        let D2 = () => new Date(Date.UTC(2026, 1, 1))
+
+        before(async function() {
+            wo = mk('date').wo
+            await reset(wo)
+        })
+
+        it('should get ISO string of Date in stored rows', async function() {
+            await reset(wo)
+            let a1 = (await wo.selectByPk('a1'))
+            assert.strict.equal(a1.d, '2026-01-01T00:00:00.000Z')
+        })
+
+        let finds = [
+            { name: '$eq', find: () => ({ d: { $eq: D1() } }), ids: ['a1'] },
+            { name: '$ne', find: () => ({ d: { $ne: D1() } }), ids: ['a2', 'a3', 'a4', 'a5', 'a6'] },
+            { name: '$gt', find: () => ({ d: { $gt: D1() } }), ids: ['a2'] },
+            { name: '$lt', find: () => ({ d: { $lt: D2() } }), ids: ['a1'] },
+            { name: '$lte', find: () => ({ d: { $lte: D2() } }), ids: ['a1', 'a2'] },
+            { name: '$in', find: () => ({ d: { $in: [D2()] } }), ids: ['a2'] },
+            { name: '$nin', find: () => ({ d: { $nin: [D1(), D2()] } }), ids: ['a3', 'a4', 'a5', 'a6'] },
+            { name: '$or', find: () => ({ $or: [{ d: D2() }, { id: 'a3' }] }), ids: ['a2', 'a3'] },
+            { name: '$and', find: () => ({ $and: [{ d: { $gte: D1() } }, { d: { $lte: D1() } }] }), ids: ['a1'] },
+            { name: 'range', find: () => ({ d: { $gte: D1(), $lte: D2() } }), ids: ['a1', 'a2'] },
+        ]
+        for (let f of finds) {
+            it(`should select and delAll by Date in ${f.name}`, async function() {
+                await reset(wo)
+                assert.strict.deepStrictEqual(ids(await wo.select(f.find())), f.ids)
+                let r = await wo.delAll(f.find())
+                assert.strict.deepStrictEqual(r, { n: f.ids.length, nDeleted: f.ids.length, ok: 1 })
+                let rest = ids(await wo.select())
+                assert.strict.deepStrictEqual(['a1', 'a2', 'a3', 'a4', 'a5', 'a6'].filter((id) => rest.indexOf(id) < 0), f.ids)
+            })
+        }
+
+    })
+
+    //時序(find檢核置於serialize佇列之外且先於讀取)
+    describe('order', function() {
+        let bad = () => ({ $where: () => true })
+
+        //serialize佇列: 壞條件於佇列之外立即reject, 不等候先前已排入佇列之操作, 且不使其後之呼叫失敗
+        it('should reject bad find before queued operations finish and keep queue working', async function() {
+            let { wo } = mk('queue')
+            let ob = mkObserver(wo)
+            await reset(wo)
+            let rows = []
+            for (let i = 0; i < 2000; i++) {
+                rows.push({ id: `q${i}`, g: 'Q', v: i })
+            }
+            for (let fn of ['select', 'delAll']) {
+                let done = false
+                let pmBig = wo.insertBulk(rows.map((v) => ({ ...v, id: `${fn}-${v.id}` }))).then(function(r) {
+                    done = true
+                    return r
+                })
+                let out = await ob.invoke(fn, bad(), () => done)
+                chkRej(out, fn)
+                assert.strict.equal(out.probe, false, `${fn} should reject before the queued insertBulk finishes`)
+                let rBulk = await pmBig
+                assert.strict.equal(rBulk.nInserted, 2000)
+            }
+            //佇列不受影響
+            assert.strict.deepStrictEqual(ids(await wo.select({ id: 'a1' })), ['a1'])
+            let r = await wo.delAll({ g: 'Q' })
+            assert.strict.deepStrictEqual(r, { n: 4000, nDeleted: 4000, ok: 1 })
+            assert.strict.deepStrictEqual(ids(await wo.select()), ['a1', 'a2', 'a3', 'a4', 'a5', 'a6'])
+        })
+
+        //find檢核先於讀取: 資料庫檔案無法解析(任何讀取皆拋錯)時, 壞條件仍須回invalid find(未讀取), 合法條件則因讀取而回解析錯誤
+        it('should check find before reading the database file', async function() {
+            let { url, wo } = mk('unreadable')
+            let ob = mkObserver(wo)
+            fs.writeFileSync(url, '{ not a json')
+
+            //對照: 合法條件須讀取資料庫檔案, 因解析錯誤而reject, 且訊息不是invalid find
+            for (let fn of ['select', 'delAll']) {
+                let out = await ob.invoke(fn, { g: 'A' })
+                assert.strict.equal(out.ok, false, `${fn} with valid find should reject by unreadable file`)
+                assert.strict.ok(out.err.message.indexOf('invalid find') < 0, `${fn} valid find should not get invalid find: ${out.err.message}`)
+            }
+
+            //壞條件: 於讀取之前reject
+            for (let fn of ['select', 'delAll']) {
+                for (let f of [bad(), null, [], { g: undefined }, { $and: [] }]) {
+                    let out = await ob.invoke(fn, f)
+                    chkRej(out, fn)
+                }
+            }
+        })
+
+        //壞條件之delAll不得改寫資料庫檔案(內容與修改時間皆不變)
+        it('should not rewrite the database file when delAll is rejected', async function() {
+            let { url, wo } = mk('norewrite')
+            let ob = mkObserver(wo)
+            await reset(wo)
+            let txt0 = fs.readFileSync(url, 'utf8')
+            let mt0 = fs.statSync(url).mtimeMs
+            await tick()
+            for (let f of [bad(), null, [], { g: undefined }, { $nin: [] }, { $or: [{}] }]) {
+                let out = await ob.invoke('delAll', f)
+                chkRej(out, 'delAll')
+            }
+            assert.strict.equal(fs.readFileSync(url, 'utf8'), txt0)
+            assert.strict.equal(fs.statSync(url).mtimeMs, mt0)
+        })
+
+        //useCache: 快取已填入時壞條件仍須reject, 快取與資料不受影響
+        it('should reject bad find with filled cache and keep data', async function() {
+            let { wo } = mk('cache', { useCache: true })
+            let ob = mkObserver(wo)
+            await wo.insertBulk(seed())
+            assert.strict.equal((await wo.select()).length, 6)
+            for (let fn of ['select', 'delAll']) {
+                for (let f of [bad(), null, [], { g: undefined }, { g: { $nin: [] } }]) {
+                    let out = await ob.invoke(fn, f)
+                    chkRej(out, fn, directMsg(f))
+                }
+            }
+            assert.strict.deepStrictEqual(ids(await wo.select()), ['a1', 'a2', 'a3', 'a4', 'a5', 'a6'])
+            assert.strict.deepStrictEqual(ids(await wo.select({ g: 'A' })), ['a1', 'a2'])
+        })
+
+    })
+
+})