wsemi 1.9.13 → 1.9.14

package/test/alive.test.mjs

@@ -1,4 +1,5 @@
 import assert from 'assert'
+import { spawnSync } from 'child_process'
 import alive from '../src/alive.mjs'
 
 
@@ -65,4 +66,204 @@ describe(`alive`, function() {
         assert.strict.deepStrictEqual(JSON.stringify(ms), r1)
     })
 
+    function test2() {
+        return new Promise((resolve, reject) => {
+            let ms = []
+
+            let oAL = alive({ timeAlive: 1500 })
+
+            oAL.on('message', function({ eventName, key }) {
+                ms.push(eventName + '|' + key)
+            })
+
+            oAL.trigger('a', { data: 123 })
+
+            setTimeout(() => {
+                oAL.trigger('b', { data: '34.56' })
+                let r = oAL.clear() //b剛trigger尚未發出enter, 故只回傳a, 且b之enter不再發出
+                ms.push('clear|' + r.map((v) => v.key).join(','))
+            }, 500)
+
+            setTimeout(() => {
+                resolve(ms)
+            }, 2500)
+
+        })
+    }
+    let r2 = '["enter|a","clear|a"]'
+    it(`should return '${r2}' when run test2'`, async function() {
+        let ms = await test2()
+        assert.strict.deepStrictEqual(JSON.stringify(ms), r2)
+    })
+
+    describe(`key`, function() {
+
+        let sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+        //trigger之key為任意非空字串, 每個key皆須於首次trigger時enter、逾時leave、存活期間列於get
+        //__proto__與Object原型之屬性名(constructor、toString等)亦同, 不得被誤判為已存在或改掉佇列之原型
+        let keys = ['__proto__', 'data', 'time', 'constructor', 'toString', 'hasOwnProperty', 'valueOf', 'isPrototypeOf', '__defineGetter__']
+
+        it(`should treat __proto__ and names on Object.prototype as ordinary keys`, async function() {
+            let ms = []
+            let o = alive({ timeAlive: 100, timeDetect: 20 })
+            o.on('message', (m) => ms.push(m.eventName + '|' + m.key))
+            for (let k of keys) {
+                o.trigger(k, { k })
+            }
+            await sleep(30)
+            assert.strict.deepStrictEqual(o.get(), keys.map((k) => ({ key: k, data: { k } })))
+            await sleep(300)
+            assert.strict.deepStrictEqual(ms, [...keys.map((k) => 'enter|' + k), ...keys.map((k) => 'leave|' + k)])
+            assert.strict.deepStrictEqual(o.get(), [])
+        })
+
+        it(`should return __proto__ and names on Object.prototype from clear`, async function() {
+            let o = alive({ timeAlive: 300 })
+            o.trigger('__proto__', 1)
+            o.trigger('constructor', 2)
+            await sleep(30)
+            assert.strict.deepStrictEqual(o.clear(), [{ key: '__proto__', data: 1 }, { key: 'constructor', data: 2 }])
+        })
+
+    })
+
+    describe(`clear`, function() {
+
+        let sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+        let create = (opt) => {
+            let ms = []
+            let errs = []
+            let o = alive(opt)
+            o.on('error', (e) => errs.push(e))
+            o.on('message', (m) => ms.push(m.eventName + '|' + m.key))
+            return { o, ms, errs }
+        }
+
+        it(`should return entered units, emit nothing afterwards and get [] (two units entered then clear)`, async function() {
+            let { o, ms } = create({ timeAlive: 300 })
+            o.trigger('a', { x: 1 })
+            o.trigger('b', { x: 2 })
+            await sleep(30)
+            let r = o.clear()
+            assert.strict.deepStrictEqual(r, [{ key: 'a', data: { x: 1 } }, { key: 'b', data: { x: 2 } }])
+            await sleep(500) //逾timeAlive仍不得發leave
+            assert.strict.deepStrictEqual(ms, ['enter|a', 'enter|b'])
+            assert.strict.deepStrictEqual(o.get(), [])
+        })
+
+        it(`should return [] and cancel the enter when cleared right after trigger`, async function() {
+            let { o, ms } = create({ timeAlive: 300 })
+            o.trigger('a', 1)
+            let r = o.clear()
+            await sleep(400)
+            assert.strict.deepStrictEqual(r, [])
+            assert.strict.deepStrictEqual(ms, [])
+        })
+
+        it(`should return only units whose enter was emitted`, async function() {
+            let { o, ms } = create({ timeAlive: 300 })
+            o.trigger('a', 1)
+            await sleep(30)
+            o.trigger('b', 2)
+            let r = o.clear()
+            await sleep(400)
+            assert.strict.deepStrictEqual(r, [{ key: 'a', data: 1 }])
+            assert.strict.deepStrictEqual(ms, ['enter|a'])
+        })
+
+        it(`should not return a unit that left and was triggered again but not yet re-entered`, async function() {
+            let { o, ms } = create({ timeAlive: 100, timeDetect: 20 })
+            o.trigger('a', 1)
+            await sleep(300) //a已enter且已leave
+            o.trigger('a', 2)
+            let r = o.clear()
+            await sleep(100)
+            assert.strict.deepStrictEqual(r, [])
+            assert.strict.deepStrictEqual(ms, ['enter|a', 'leave|a'])
+        })
+
+        it(`should not throw and return [] when called repeatedly or before any trigger`, function() {
+            let o = alive()
+            assert.strict.deepStrictEqual(o.clear(), [])
+            assert.strict.deepStrictEqual(o.clear(), [])
+        })
+
+        it(`should ignore trigger after clear`, async function() {
+            let { o, ms } = create({ timeAlive: 300 })
+            o.trigger('a', 1)
+            await sleep(30)
+            o.clear()
+            o.trigger('b', 2)
+            o.trigger('a', 3)
+            await sleep(400)
+            assert.strict.deepStrictEqual(ms, ['enter|a'])
+            assert.strict.deepStrictEqual(o.get(), [])
+            assert.strict.deepStrictEqual(o.clear(), [])
+        })
+
+        it(`should return the unit being dispatched and stop pending enters when cleared in an enter listener`, async function() {
+            let { o, ms, errs } = create({ timeAlive: 300 })
+            let rc = null
+            o.on('message', (m) => {
+                if (m.key === 'a' && rc === null) {
+                    rc = o.clear()
+                }
+            })
+            o.trigger('a', 1)
+            o.trigger('b', 2)
+            await sleep(400)
+            assert.strict.deepStrictEqual(rc, [{ key: 'a', data: 1 }])
+            assert.strict.deepStrictEqual(ms, ['enter|a'])
+            assert.strict.deepStrictEqual(errs, [])
+        })
+
+        it(`should stop the eviction round without throwing when cleared in a leave listener`, async function() {
+            //三單元同一輪逾時, 第一則leave中clear: 其餘二單元不再發leave且由clear回傳; 未防護時同輪下一單元會讀到已清空之佇列而拋錯
+            let { o, ms, errs } = create({ timeAlive: 100, timeDetect: 20 })
+            let rc = null
+            o.on('message', (m) => {
+                if (m.eventName === 'leave' && rc === null) {
+                    rc = o.clear()
+                }
+            })
+            o.trigger('a', 1)
+            o.trigger('b', 2)
+            o.trigger('c', 3)
+            await sleep(400)
+            assert.strict.deepStrictEqual(ms, ['enter|a', 'enter|b', 'enter|c', 'leave|a'])
+            assert.strict.deepStrictEqual(rc, [{ key: 'b', data: 2 }, { key: 'c', data: 3 }])
+            assert.strict.deepStrictEqual(errs, [])
+        })
+
+        it(`should leave no active timer so the process exits at once (child process)`, function() {
+            //於呼叫clear之計時器回呼結束後(setImmediate)才查資源, 回呼內該計時器自身仍會列出
+            let url = new URL('../src/alive.mjs', import.meta.url).href
+            let code = `
+                import alive from '${url}'
+                let t0 = Date.now()
+                let o = alive()
+                o.trigger('a', 1)
+                o.trigger('b', 2)
+                setTimeout(() => {
+                    let r = o.clear()
+                    setImmediate(() => {
+                        let res = process.getActiveResourcesInfo().filter((x) => x !== 'TTYWrap' && x !== 'Immediate')
+                        process.on('exit', () => {
+                            console.log(JSON.stringify({ r, res, ms: Date.now() - t0 }))
+                        })
+                    })
+                }, 100)
+            `
+            let p = spawnSync(process.execPath, ['--input-type=module', '-e', code], { encoding: 'utf8', timeout: 20000 })
+            assert.strict.deepStrictEqual(p.status, 0, p.stderr)
+            let o = JSON.parse(p.stdout.trim())
+            assert.strict.deepStrictEqual(o.r, [{ key: 'a', data: 1 }, { key: 'b', data: 2 }])
+            assert.strict.deepStrictEqual(o.res, [])
+            assert.strict.deepStrictEqual(o.ms < 2000, true, `exit after ${o.ms}ms`) //未clear時須逾timeAlive(預設10000)才結束
+        })
+
+    })
+
 })

package/test/cache.test.mjs

@@ -706,4 +706,30 @@ describe(`cache`, function() {
         assert.strict.deepStrictEqual(r, { defIsolated: true, getFalseSame: true, setFalseSame: true, overrideCloned: true, invalidUseSet: true, waitTrueIsolated: true, waitFalseSame: true, proxySame: true })
     })
 
+    //key為任意字串, __proto__與Object原型之屬性名(constructor、toString等)亦為一般key: 未set視為無效key、不得寫到原型上之物件, set後可取回
+    it(`should treat __proto__ and names on Object.prototype as ordinary keys`, async function() {
+        let had = Object.prototype.hasOwnProperty.call(Object, 'value')
+        try {
+            let oc = cache()
+            for (let k of ['__proto__', 'constructor', 'toString', 'hasOwnProperty', 'valueOf']) {
+                assert.strict.deepStrictEqual(await oc.get(k), null, `get ${k} before set`)
+            }
+            oc.update('constructor', 5) //未set之key不得寫入, 一般物件時會寫到Object本身
+            oc.clear('constructor')
+            assert.strict.deepStrictEqual(Object.prototype.hasOwnProperty.call(Object, 'value'), had)
+            oc.set('constructor', { fun: async () => 1 })
+            oc.set('__proto__', { fun: async () => 2 })
+            assert.strict.deepStrictEqual(await oc.get('constructor'), 1)
+            assert.strict.deepStrictEqual(await oc.get('__proto__'), 2)
+            assert.strict.deepStrictEqual(await oc.get('needExec'), null) //set __proto__不得使未set之key被視為存在
+            oc.remove('constructor')
+            assert.strict.deepStrictEqual(await oc.get('constructor'), null)
+        }
+        finally {
+            if (!had) {
+                delete Object.value //修正前之版本會寫入Object.value, 測試後還原以免影響同檔其他測試
+            }
+        }
+    })
+
 })

package/test/cacheSt.test.mjs

@@ -256,4 +256,44 @@ describe(`cacheSt`, function() {
         assert.strict.deepStrictEqual(ms, ms9)
     })
 
+    //key為任意字串, __proto__與Object原型之屬性名(constructor、toString等)亦為一般key: 未set不存在、set後可取回、不影響其他key
+    it(`should treat __proto__ and names on Object.prototype as ordinary keys`, async function() {
+        let cs = cacheSt({ timeDetect: 1000 })
+        try {
+            let names = ['__proto__', 'constructor', 'toString', 'hasOwnProperty', 'valueOf']
+            for (let k of names) {
+                assert.strict.deepStrictEqual(await cs.check(k), false, `check ${k} before set`)
+                assert.strict.deepStrictEqual(await cs.get(k), null, `get ${k} before set`)
+            }
+            assert.strict.deepStrictEqual(cs.checkWithSet('toString'), true)
+            assert.strict.deepStrictEqual(await cs.check('toString'), true)
+            await cs.set('__proto__', 'v')
+            assert.strict.deepStrictEqual(await cs.get('__proto__'), 'v')
+            assert.strict.deepStrictEqual(await cs.check('value'), false) //set __proto__不得使未set之key被視為存在
+            assert.strict.deepStrictEqual(await cs.check('time'), false)
+            await cs.set('constructor', 1)
+            assert.strict.deepStrictEqual(await cs.get('constructor'), 1)
+            await cs.del('constructor')
+            assert.strict.deepStrictEqual(await cs.check('constructor'), false)
+            await cs.del('__proto__')
+            assert.strict.deepStrictEqual(await cs.check('__proto__'), false)
+        }
+        finally {
+            cs.clear()
+        }
+    })
+
+    it(`should expire __proto__ like other keys`, async function() {
+        let cs = cacheSt({ timeExpire: 100, timeDetect: 50 })
+        try {
+            await cs.set('__proto__', 1)
+            assert.strict.deepStrictEqual(await cs.check('__proto__'), true)
+            await delay(300)
+            assert.strict.deepStrictEqual(await cs.check('__proto__'), false)
+        }
+        finally {
+            cs.clear()
+        }
+    })
+
 })

package/toolfp/dist/wsemip.umd.js

@@ -1,5 +1,5 @@
 /*!
- * wsemip v1.9.13
+ * wsemip v1.9.14
  * (c) 2018-2021 yuda-lyu(semisphere)
  * Released under the MIT License.
  */

package/toolparfor/dist/wpf.umd.js

@@ -1,5 +1,5 @@
 /*!
- * wpf v1.9.13
+ * wpf v1.9.14
  * (c) 2018-2021 yuda-lyu(semisphere)
  * Released under the MIT License.
  */

package/toolparfor/dist/wpf_pmSeries.umd.js

@@ -1,5 +1,5 @@
 /*!
- * wpf_pmSeries v1.9.13
+ * wpf_pmSeries v1.9.14
  * (c) 2018-2021 yuda-lyu(semisphere)
  * Released under the MIT License.
  */