@k3000/store 0.1.0

package/test.mjs

@@ -0,0 +1,766 @@
+import test from "node:test";
+import assert from "node:assert";
+import upgrade, {
+    Bigint,
+    bigintSerialize,
+    BigUint,
+    Buffer,
+    Float,
+    Id,
+    Int,
+    String,
+    Text,
+    Time,
+    Uint
+} from './generator.mjs?test=true'
+// } from 'dmb3/generator.mjs'
+import {existsSync, readdirSync, rmdirSync, statSync, unlinkSync} from "node:fs";
+import {json} from "node:stream/consumers";
+
+test('测试类型类', async t => {
+
+    await t.test('测试Id类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Id('备注').toString(),
+            '{"type":0,"remark":"备注","index":[],"value":1,"length":4,"step":1}')
+    })
+
+    await t.test('测试Id类型完整配置', _ => {
+
+        assert.strictEqual(
+            Id()
+                .index(false)
+                .value('2')
+                .step(2)
+                .remark('备注')
+                .toString(),
+            '{"type":0,"remark":"备注","value":2,"length":4,"step":2}')
+    })
+
+    await t.test('测试Uint类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Uint('备注').toString(),
+            '{"type":1,"remark":"备注","length":4}')
+    })
+
+    await t.test('测试Uint类型完整配置', _ => {
+
+        assert.strictEqual(
+            Uint()
+                .index(false)
+                .value(2)
+                .step(2)
+                .remark('备注')
+                .toString(),
+            '{"type":1,"remark":"备注","value":2,"length":4,"step":2}')
+    })
+
+    await t.test('测试Uint类型异常配置', _ => {
+
+        assert.strictEqual(
+            Uint()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":1,"remark":"","index":[],"value":0,"length":4,"step":1}')
+    })
+
+    await t.test('测试Int类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Int('备注').toString(),
+            '{"type":2,"remark":"备注","length":4}')
+    })
+
+    await t.test('测试Int类型完整配置', _ => {
+
+        assert.strictEqual(
+            Int()
+                .index(false)
+                .value(2)
+                .step(2)
+                .remark('备注')
+                .toString(),
+            '{"type":2,"remark":"备注","value":2,"length":4,"step":2}')
+    })
+
+    await t.test('测试Int类型异常配置', _ => {
+
+        assert.strictEqual(
+            Int()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":2,"remark":"","index":[],"value":0,"length":4,"step":1}')
+    })
+
+    await t.test('测试BigUint类型缺省配置', _ => {
+
+        assert.strictEqual(
+            BigUint('备注').toString(),
+            '{"type":3,"remark":"备注","length":8}')
+    })
+
+    await t.test('测试BigUint类型完整配置', _ => {
+
+        assert.strictEqual(
+            BigUint()
+                .index(false)
+                .value(1n)
+                .step(1n)
+                .remark('备注')
+                .toString(),
+            '{"type":3,"remark":"备注","value":"1","length":8,"step":1}')
+    })
+
+    await t.test('测试BigUint类型异常配置', _ => {
+
+        assert.strictEqual(
+            BigUint()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":3,"remark":"","index":[],"value":"0","length":8,"step":1}')
+    })
+
+    await t.test('测试Bigint类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Bigint('备注').toString(),
+            '{"type":4,"remark":"备注","length":8}')
+    })
+
+    await t.test('测试Bigint类型完整配置', _ => {
+
+        assert.strictEqual(
+            Bigint()
+                .index(false)
+                .value(1n)
+                .step(1n)
+                .remark('备注')
+                .toString(),
+            '{"type":4,"remark":"备注","value":"1","length":8,"step":1}')
+    })
+
+    await t.test('测试Bigint类型异常配置', _ => {
+
+        assert.strictEqual(
+            Bigint()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":4,"remark":"","index":[],"value":"0","length":8,"step":1}')
+    })
+
+    await t.test('测试Time类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Time('备注').toString(),
+            '{"type":5,"remark":"备注","length":6}')
+    })
+
+    await t.test('测试Time类型完整配置', _ => {
+
+        assert.strictEqual(
+            Time()
+                .index(false)
+                .value(Time.update)
+                .remark('备注')
+                .toString(),
+            '{"type":5,"remark":"备注","value":-2,"length":6}')
+    })
+
+    await t.test('测试Time类型异常配置', _ => {
+
+        assert.strictEqual(
+            Time()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":5,"remark":"","index":[],"value":0,"length":6}')
+    })
+
+    await t.test('测试Float类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Float('备注').toString(),
+            '{"type":6,"remark":"备注","length":8}')
+    })
+
+    await t.test('测试Float类型完整配置', _ => {
+
+        assert.strictEqual(
+            Float()
+                .index(false)
+                .value(0.1)
+                .step(0.1)
+                .remark('备注')
+                .toString(),
+            '{"type":6,"remark":"备注","value":0.1,"length":8,"step":0.1}')
+    })
+
+    await t.test('测试Float类型异常配置', _ => {
+
+        assert.strictEqual(
+            Float()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":6,"remark":"","index":[],"value":0,"length":8,"step":1}')
+    })
+
+    await t.test('测试String类型缺省配置', _ => {
+
+        assert.strictEqual(
+            String('备注').toString(),
+            '{"type":7,"remark":"备注","length":12}')
+    })
+
+    await t.test('测试String类型完整配置', _ => {
+
+        assert.strictEqual(
+            String()
+                .index(false)
+                .value('123456')
+                .length(8)
+                .remark('备注')
+                .toString(),
+            '{"type":7,"remark":"备注","value":"123456","length":8}')
+    })
+
+    await t.test('测试String类型异常配置', _ => {
+
+        assert.strictEqual(
+            String()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":7,"remark":"","index":[],"value":"","length":12}')
+    })
+
+    await t.test('测试Buffer类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Buffer('备注').toString(),
+            '{"type":8,"remark":"备注","length":1}')
+    })
+
+    await t.test('测试Buffer类型完整配置', _ => {
+
+        assert.strictEqual(
+            Buffer()
+                .remark('备注')
+                .toString(),
+            '{"type":8,"remark":"备注","length":1}')
+    })
+
+    await t.test('测试Buffer类型异常配置', _ => {
+
+        assert.strictEqual(
+            Buffer()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":8,"remark":"","length":1}')
+    })
+
+    await t.test('测试Text类型缺省配置', _ => {
+
+        assert.strictEqual(
+            Text('备注').toString(),
+            '{"type":9,"remark":"备注","length":1}')
+    })
+
+    await t.test('测试Text类型完整配置', _ => {
+
+        assert.strictEqual(
+            Text()
+                .remark('备注')
+                .toString(),
+            '{"type":9,"remark":"备注","length":1}')
+    })
+
+    await t.test('测试Text类型异常配置', _ => {
+
+        assert.strictEqual(
+            Text()
+                .index()
+                .value()
+                .step()
+                .remark()
+                .toString(),
+            '{"type":9,"remark":"","length":1}')
+    })
+})
+
+if (!existsSync('test/1')) {
+
+    const {appendSet, submit} = upgrade('test')
+
+    appendSet('admin', {
+        id: Id,
+        uid: String('账号').index(true),
+        pwd: String('密码').value('123456'),
+        valid: Uint(1).index(true).value(0).remark('是否有效'),
+        time: Time('登录时间').index(true).value(Time.update),
+    })
+
+    appendSet('log', {
+        id: Id,
+        uid: String('账号').index(true),
+        type: Uint(2).remark('类型'),
+        time: Time('创建时间').index(true).value(Time.now),
+        content: String('内容').length(256)
+    })
+
+    appendSet('test', {
+        id: Id,
+        uint: Uint,
+        int: Int(3),
+        bigint: Bigint,
+        bigUint: BigUint,
+        time: Time,
+        float: Float,
+        string: String,
+        buffer: Buffer,
+        text: Text,
+    })
+
+    submit()
+}
+
+function deleteDir(dir) {
+
+    for (const name of readdirSync(dir)) {
+
+        const path = `${dir}/${name}`
+
+        if (statSync(path).isDirectory()) {
+
+            deleteDir(path)
+
+        } else {
+
+            unlinkSync(path)
+        }
+    }
+
+    rmdirSync(dir)
+}
+
+import('./test/1/index.mjs').then(m => {
+
+    const storage = m.default
+
+    test('测试基础操作', async t => {
+
+        const test = {
+            id: 1,
+            uid: 'test',
+            pwd: '123456',
+            time: new Date('2022/01/01'),
+        }
+
+        const root = {
+            id: 2,
+            uid: 'root',
+            pwd: '123123',
+            valid: 1,
+            time: new Date('2022/01/01'),
+        }
+
+        const predicate = item => item.uid === 'root' && item.pwd === '123123'
+
+        await t.test('测试查找操作（filter）', _ => {
+
+            const result = storage.admin.filter(predicate)
+
+            assert.strictEqual(
+                JSON.stringify(result),
+                '[{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1}]')
+        })
+
+        await t.test('测试查找操作（page）', _ => {
+
+            const params = {key: 'name', index: 1, size: 1}
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin.page(_ => 1, 1, 1)),
+                JSON.stringify(storage.admin.page(_ => 1, 'index', 'size', params)))
+        })
+
+        await t.test('测试查找操作（find）', _ => {
+
+            const result = storage.admin.find(predicate)
+
+            assert.strictEqual(
+                JSON.stringify({...result}),
+                '{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1}')
+        })
+
+        await t.test('测试查找操作（findIndex）', _ => {
+
+            const result = storage.admin[storage.admin.findIndex(predicate)]
+
+            assert.strictEqual(
+                JSON.stringify(result),
+                '{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1}')
+        })
+
+        await t.test('测试查找操作（some）', _ => {
+
+            assert.strictEqual(storage.admin.some(predicate), true)
+        })
+
+        await t.test('测试查找操作（通过索引）', _ => {
+
+            const result = storage.admin.indexByUid('root')
+
+            assert.strictEqual(
+                JSON.stringify(result),
+                '[{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1}]')
+        })
+
+        await t.test('测试查找操作（通过索引时间）', _ => {
+
+            const result = storage.admin.indexByTime({before: -Infinity, after: new Date('2023/01/01')})
+
+            assert.strictEqual(
+                JSON.stringify(result),
+                '[{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1},{"id":1,"pwd":"123456","time":1640966400000,"uid":"test","valid":0}]')
+        })
+
+        await t.test('测试添加操作（push）', _ => {
+
+            storage.admin.remove(...storage.admin.filter(item => ['test', 'root'].includes(item.uid)))
+
+            storage.admin.push(test)
+
+            storage.admin.push(root)
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin),
+                '[{"id":1,"pwd":"123456","time":1640966400000,"uid":"test","valid":0},{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1}]')
+        })
+
+        await t.test('测试添加操作（pop）', _ => {
+
+            storage.admin.pop()
+
+            assert.strictEqual(storage.admin.length, 1)
+
+            storage.admin.remove(...storage.admin.filter(item => ['test', 'root'].includes(item.uid)))
+
+            storage.admin.push(test)
+
+            storage.admin.push(root)
+        })
+
+        await t.test('测试添加操作（unshift）', _ => {
+
+            storage.admin.remove(...storage.admin.indexByUid('root'))
+
+            storage.admin.unshift(root)
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin),
+                '[{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1},{"id":1,"pwd":"123456","time":1640966400000,"uid":"test","valid":0}]')
+        })
+
+        await t.test('测试添加操作（splice）', _ => {
+
+            storage.admin.remove(...storage.admin.indexByUid('root'))
+
+            storage.admin.splice(0, 0, root)
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin),
+                '[{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1},{"id":1,"pwd":"123456","time":1640966400000,"uid":"test","valid":0}]')
+        })
+
+        await t.test('测试联合查询（filterFlat）', _ => {
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin.filterFlat(storage.log, (a, b) => a.uid === b.uid)),
+                '[{"content":"login","id":1,"time":1640966400000,"type":0,"uid":"test","pwd":"123456","valid":0}'
+                + ',{"content":"test","id":1,"time":1640966400000,"type":0,"uid":"test","pwd":"123456","valid":0}]')
+        })
+
+        await t.test('测试联合查询（eachFlat）', _ => {
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin.eachFlat(storage.log, (a, b) => a.uid === b.uid)),
+                '[{"id":2,"pwd":"123123","time":1640966400000,"uid":"root","valid":1},{"content":"login","id":1,'
+                + '"time":1640966400000,"type":0,"uid":"test","pwd":"123456","valid":0},{"content":"test","id":1,"time":1640966400000,'
+                + '"type":0,"uid":"test","pwd":"123456","valid":0}]')
+        })
+
+        await t.test('测试修改操作', _ => {
+
+            let result = storage.admin.filter(predicate)
+
+            result[0].pwd = '111111'
+            result[0].time = new Date('2022/01/01')
+
+            result = storage.admin.filter(item => item.uid === 'root' && item.pwd === '111111')
+
+            assert.strictEqual(
+                JSON.stringify(result),
+                '[{"id":2,"pwd":"111111","time":1640966400000,"uid":"root","valid":1}]')
+        })
+
+        await t.test('测试删除操作', _ => {
+
+            storage.admin.remove(...storage.admin.filter(item => !item.valid))
+
+            assert.strictEqual(
+                JSON.stringify(storage.admin),
+                '[{"id":2,"pwd":"111111","time":1640966400000,"uid":"root","valid":1}]')
+        })
+
+        storage.admin.remove(...storage.admin)
+
+        storage.admin.push(test)
+
+        storage.admin.push(root)
+
+        storage.log.remove(...storage.log)
+
+        storage.log.push({
+            uid: 'test',
+            id: 2,
+            time: new Date('2022/01/01'),
+            content: 'login'
+        })
+
+        storage.log.push({
+            uid: 'test',
+            id: 1,
+            time: new Date('2022/01/02'),
+            content: 'test'
+        })
+
+        storage.close()
+    })
+
+}).catch(e => console.error(e))
+
+test('测试结构操作', async t => {
+
+    if (existsSync('test/2')) {
+
+        deleteDir('test/2')
+    }
+
+    if (existsSync('test/3')) {
+
+        deleteDir('test/3')
+    }
+
+    if (existsSync('test/4')) {
+
+        deleteDir('test/4')
+    }
+
+    if (existsSync('test/5')) {
+
+        deleteDir('test/5')
+    }
+
+    if (existsSync('test/6')) {
+
+        deleteDir('test/6')
+    }
+
+    if (existsSync('test/7')) {
+
+        deleteDir('test/7')
+    }
+
+    await new Promise(resolve => {
+
+        t.test('测试添加操作（appendSet）', _ => {
+
+            const {appendSet, submit} = upgrade('test', {version: 2})
+
+            appendSet('test2', {
+                uid: String(`账
+                户`),
+                pwd: String(),
+                test: Bigint,
+                test3: Int(2)
+            }, '账号表')
+
+            submit().then(() => import('./test/2/index.mjs?v=2')).then(m => {
+
+                const storage = m.default
+
+                storage.test2.push({
+                    uid: 'test',
+                    pwd: '123456',
+                    test: 123123n,
+                    test3: 111
+                })
+
+                assert.strictEqual(
+                    JSON.stringify(storage.test2, bigintSerialize),
+                    '[{"pwd":"123456","test":"123123","test3":111,"uid":"test"}]')
+
+                storage.close()
+
+                resolve()
+
+            }).catch(e => console.error(e))
+        })
+    })
+
+    await new Promise(resolve => {
+
+        t.test('测试更新操作（updateCol）', _ => {
+
+            const {updateCol, submit} = upgrade('test', {version: 3})
+
+            updateCol('test2', {
+                test: String,
+                test2: String(),
+                test3: Int(3)
+            })
+
+            submit().then(() => import('./test/3/index.mjs')).then(m => {
+
+                const storage = m.default
+
+                storage.test2[0].test2 = '456456'
+
+                assert.strictEqual(
+                    JSON.stringify(storage.test2),
+                    '[{"pwd":"123456","test":"123123","test2":"456456","test3":111,"uid":"test"}]')
+
+                storage.close()
+
+                resolve()
+
+            }).catch(e => console.error(e))
+        })
+    })
+
+    await new Promise(resolve => {
+
+        t.test('测试更名操作（renameSet，renameCol）', _ => {
+
+            const {renameSet, renameCol, submit} = upgrade('test', {version: 4})
+
+            renameSet('test2', 'test3')
+
+            renameCol('test3', {
+                test2: 'test3',
+            })
+
+            submit().then(() => import('./test/4/index.mjs')).then(m => {
+
+                const storage = m.default
+
+                assert.strictEqual(
+                    JSON.stringify(storage.test3),
+                    '[{"pwd":"123456","test":"123123","test2":"456456","test3":111,"uid":"test"}]')
+
+                storage.close()
+
+                resolve()
+
+            }).catch(e => console.error(e))
+        })
+    })
+
+    await new Promise(resolve => {
+
+        t.test('测试备注操作（updateSetRemark）', _ => {
+
+            const {updateSetRemark, submit} = upgrade('test', {version: 5})
+
+            updateSetRemark('test3', `备注
+            备注`)
+
+            submit().then(() => import('./test/5/index.mjs?newPwd=123123')).then(m => {
+
+                const storage = m.default
+
+                assert.strictEqual(1, 1)
+
+                storage.close()
+
+                resolve()
+
+            }).catch(e => console.error(e))
+        })
+    })
+
+    await new Promise(resolve => {
+
+        t.test('测试删除操作（deleteSet，deleteCol）', _ => {
+
+            const {deleteSet, deleteCol, submit} = upgrade('test', {version: 6, password: '123123'})
+
+            deleteSet('test')
+
+            deleteCol('test3', 'test3')
+
+            submit().then(() => import('./test/6/index.mjs?password=123123')).then(m => {
+
+                const storage = m.default
+
+                assert.strictEqual(
+                    JSON.stringify(storage.test3) === '[{"pwd":"123456","test":"123123","test2":"456456","uid":"test"}]',
+                    storage.test === undefined)
+
+                storage.close()
+
+                resolve()
+
+            }).catch(e => console.error(e))
+        })
+    })
+
+    await new Promise(resolve => {
+
+        t.test('测试最小化大小操作', _ => {
+
+            const {submit} = upgrade('test', {
+                version: 7,
+                prod: true,
+                password: '123123',
+                newPwd: '111111'
+            })
+
+            submit().then(() => import('./test/7/index.mjs?password=111111')).then(m => {
+
+                const storage = m.default
+
+                assert.strictEqual(1, 1)
+
+                storage.close()
+
+                resolve()
+
+            }).catch(e => console.error(e))
+        })
+    })
+})