5117 lines
158 KiB
TypeScript
5117 lines
158 KiB
TypeScript
import { MysqlStore } from "../../lib/MySQL/store";
|
||
import { TestContext } from "../Context";
|
||
import { EntityDict } from "../test-app-domain";
|
||
import { v4 } from 'uuid';
|
||
import assert from 'assert';
|
||
import { generateNewIdAsync } from 'oak-domain/lib/utils/uuid';
|
||
import { WebConfig } from '../test-app-domain/Application/Schema';
|
||
import { describe, it, before, after } from '../utils/test';
|
||
import { DbStore } from "../../lib/types/dbStore";
|
||
|
||
export const tests = (storeGetter: () => DbStore<EntityDict, TestContext>) => {
|
||
|
||
it('test insert', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: v4(),
|
||
name: 'xc',
|
||
nickname: 'xc',
|
||
},
|
||
{
|
||
id: v4(),
|
||
name: 'zz',
|
||
nickname: 'zzz',
|
||
}
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
});
|
||
|
||
it('test cascade insert', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'xxxc',
|
||
nickname: 'ddd',
|
||
token$player: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
env: {
|
||
type: 'web',
|
||
},
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: Date.now(),
|
||
value: v4(),
|
||
}
|
||
}]
|
||
} as EntityDict['user']['CreateSingle']['data']
|
||
}, context, {});
|
||
});
|
||
|
||
it('test update', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
const tokenId = v4();
|
||
await context.begin();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'xxxc',
|
||
nickname: 'ddd',
|
||
token$player: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: tokenId,
|
||
env: {
|
||
type: 'web',
|
||
},
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: Date.now(),
|
||
value: v4(),
|
||
}
|
||
}]
|
||
}
|
||
} as EntityDict['user']['CreateSingle'], context, {});
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'update',
|
||
filter: {
|
||
id: tokenId,
|
||
},
|
||
data: {
|
||
player: {
|
||
id: v4(),
|
||
action: 'activate',
|
||
data: {
|
||
name: 'xcxcxc0903'
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
});
|
||
|
||
it('test cascade update', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
const userId = v4();
|
||
const tokenId1 = v4();
|
||
const tokenId2 = v4();
|
||
await context.begin();
|
||
await context.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: userId,
|
||
name: 'xxxc',
|
||
nickname: 'ddd',
|
||
token$player: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: tokenId1,
|
||
env: {
|
||
type: 'web',
|
||
},
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: Date.now(),
|
||
value: v4(),
|
||
}
|
||
}]
|
||
}
|
||
} as EntityDict['user']['CreateSingle'], {});
|
||
|
||
await context.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: tokenId2,
|
||
env: {
|
||
type: 'web',
|
||
},
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: Date.now(),
|
||
value: v4(),
|
||
} as EntityDict['token']['CreateSingle']['data'],
|
||
}, {});
|
||
|
||
await context.commit();
|
||
|
||
// cascade update token of userId
|
||
await context.operate('user', {
|
||
id: v4(),
|
||
action: 'update',
|
||
data: {
|
||
name: 'xc',
|
||
token$player: [{
|
||
id: v4(),
|
||
action: 'update',
|
||
data: {
|
||
entity: 'email',
|
||
}
|
||
}]
|
||
},
|
||
filter: {
|
||
id: userId,
|
||
},
|
||
}, {});
|
||
|
||
const [row] = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
entity: 1,
|
||
entityId: 1,
|
||
},
|
||
filter: {
|
||
id: tokenId2,
|
||
}
|
||
}, {});
|
||
|
||
assert(row.entity === 'mobile');
|
||
});
|
||
|
||
it('test delete', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
const tokenId = v4();
|
||
await context.begin();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'xxxc',
|
||
nickname: 'ddd',
|
||
token$player: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: tokenId,
|
||
env: {
|
||
type: 'server',
|
||
},
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: Date.now(),
|
||
value: v4(),
|
||
}
|
||
}]
|
||
}
|
||
}, context, {});
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'remove',
|
||
filter: {
|
||
id: tokenId,
|
||
},
|
||
data: {
|
||
player: {
|
||
id: v4(),
|
||
action: 'update',
|
||
data: {
|
||
name: 'xcxcxc0902'
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
});
|
||
|
||
it('test delete2', async () => {
|
||
const store = storeGetter();
|
||
// 这个例子暂在mysql上过不去，先放着吧
|
||
const context = new TestContext(store);
|
||
const tokenId = v4();
|
||
await context.begin();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'xxxc',
|
||
nickname: 'ddd',
|
||
token$player: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: tokenId,
|
||
env: {
|
||
type: 'server',
|
||
},
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: Date.now(),
|
||
value: v4(),
|
||
}
|
||
}]
|
||
}
|
||
}, context, {});
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'remove',
|
||
filter: {
|
||
id: tokenId,
|
||
},
|
||
data: {
|
||
ref: {
|
||
id: await generateNewIdAsync(),
|
||
action: 'remove',
|
||
data: {},
|
||
}
|
||
},
|
||
}, context, {});
|
||
await context.commit();
|
||
});
|
||
|
||
it('test decimal', async () => {
|
||
const store = storeGetter();
|
||
const id = v4();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id,
|
||
areaId: 'xc',
|
||
ownerId: 'xc',
|
||
district: '杭州',
|
||
size: 77.5,
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
const [house] = await store.select('house', {
|
||
data: {
|
||
id: 1,
|
||
size: 1,
|
||
},
|
||
filter: {
|
||
id,
|
||
},
|
||
}, context, {});
|
||
assert(typeof house.size === 'number');
|
||
});
|
||
|
||
|
||
it('[1.1]子查询', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'xc',
|
||
nickname: 'xc',
|
||
}
|
||
}, context, {});
|
||
|
||
process.env.NODE_ENV = 'development';
|
||
const rows = await store.select('user', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
nickname: 1,
|
||
},
|
||
filter: {
|
||
token$user: {
|
||
}
|
||
},
|
||
}, context, {});
|
||
process.env.NODE_ENV = undefined;
|
||
// console.log(rows);
|
||
assert(rows.length === 0);
|
||
await context.commit();
|
||
});
|
||
|
||
it('[1.2]行内属性上的表达式', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
const id = v4();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
name: 'xc',
|
||
nickname: 'xc',
|
||
}
|
||
}, context, {});
|
||
|
||
const id2 = v4();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id2,
|
||
name: 'xzw',
|
||
nickname: 'xzw22',
|
||
}
|
||
}, context, {});
|
||
|
||
process.env.NODE_ENV = 'development';
|
||
const users = await store.select('user', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
nickname: 1,
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [id, id2],
|
||
},
|
||
$expr: {
|
||
$eq: [{
|
||
'#attr': 'name',
|
||
}, {
|
||
"#attr": 'nickname',
|
||
}]
|
||
},
|
||
},
|
||
}, context, {});
|
||
const users2 = await store.select('user', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
nickname: 1,
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [id, id2],
|
||
},
|
||
$expr: {
|
||
$eq: [{
|
||
$mod: [
|
||
{
|
||
'#attr': '$$seq$$',
|
||
},
|
||
2,
|
||
],
|
||
}, 0]
|
||
},
|
||
},
|
||
}, context, {});
|
||
process.env.NODE_ENV = undefined;
|
||
|
||
assert(users.length === 1);
|
||
assert(users2.length === 1);
|
||
await context.commit();
|
||
});
|
||
|
||
it('[1.3]跨filter结点的表达式', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await context.begin();
|
||
await store.operate('application', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [{
|
||
id: id1,
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
system: {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'bbb',
|
||
name: 'systest',
|
||
description: 'aaaaa',
|
||
config: {},
|
||
folder: '/systest',
|
||
platformId: 'platform-111',
|
||
} as EntityDict['system']['CreateSingle']['data']
|
||
},
|
||
}, {
|
||
id: id2,
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
system: {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'ccc',
|
||
name: 'test2',
|
||
description: 'aaaaa2',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
}
|
||
},
|
||
}]
|
||
}, context, {});
|
||
|
||
const applications = await store.select('application', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
systemId: 1,
|
||
system: {
|
||
id: 1,
|
||
name: 1,
|
||
}
|
||
},
|
||
filter: {
|
||
$expr: {
|
||
$startsWith: [
|
||
{
|
||
"#refAttr": 'name',
|
||
"#refId": 'node-1',
|
||
},
|
||
{
|
||
"#attr": 'name',
|
||
}
|
||
]
|
||
},
|
||
system: {
|
||
"#id": 'node-1',
|
||
},
|
||
id: id2,
|
||
},
|
||
sorter: [
|
||
{
|
||
$attr: {
|
||
system: {
|
||
name: 1,
|
||
}
|
||
},
|
||
$direction: 'asc',
|
||
}
|
||
]
|
||
}, context, {});
|
||
console.log(applications);
|
||
assert(applications.length === 1 && applications[0].id === id2);
|
||
await context.commit();
|
||
});
|
||
|
||
|
||
it('[1.4]跨filter子查询的表达式', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
await store.operate('application', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [{
|
||
id: 'aaaa',
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
system: {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'bbbb',
|
||
name: 'systest',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/systest',
|
||
platformId: 'platform-111',
|
||
}
|
||
},
|
||
}, {
|
||
id: 'aaaa2',
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
system: {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'cccc',
|
||
name: 'test2',
|
||
description: 'aaaaa2',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
}
|
||
},
|
||
}]
|
||
}, context, {});
|
||
|
||
process.env.NODE_ENV = 'development';
|
||
let systems = await store.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
},
|
||
filter: {
|
||
"#id": 'node-1',
|
||
$and: [
|
||
{
|
||
application$system: {
|
||
'#sqp': 'not in',
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
"#attr": 'name',
|
||
},
|
||
{
|
||
'#refId': 'node-1',
|
||
"#refAttr": 'name',
|
||
}
|
||
]
|
||
},
|
||
'#id': 'node-2',
|
||
}
|
||
}, {
|
||
id: {
|
||
$in: ['bbbb', 'cccc'],
|
||
}
|
||
}
|
||
]
|
||
},
|
||
sorter: [
|
||
{
|
||
$attr: {
|
||
name: 1,
|
||
},
|
||
$direction: 'asc',
|
||
}
|
||
]
|
||
}, context, {});
|
||
assert(systems.length === 1 && systems[0].id === 'bbbb');
|
||
systems = await store.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
},
|
||
filter: {
|
||
"#id": 'node-1',
|
||
$and: [
|
||
{
|
||
application$system: {
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
"#attr": 'name',
|
||
},
|
||
{
|
||
'#refId': 'node-1',
|
||
"#refAttr": 'name',
|
||
}
|
||
]
|
||
},
|
||
},
|
||
},
|
||
{
|
||
id: {
|
||
$in: ['bbbb', 'cccc'],
|
||
},
|
||
}
|
||
]
|
||
},
|
||
sorter: [
|
||
{
|
||
$attr: {
|
||
name: 1,
|
||
},
|
||
$direction: 'asc',
|
||
}
|
||
]
|
||
}, context, {});
|
||
process.env.NODE_ENV = undefined;
|
||
assert(systems.length === 1 && systems[0].id === 'cccc');
|
||
await context.commit();
|
||
});
|
||
|
||
it('[1.5]projection中的跨结点表达式', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
await store.operate('application', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [{
|
||
id: 'aaa5',
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
system: {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'bbb5',
|
||
name: 'systest',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/systest',
|
||
platformId: 'platform-111',
|
||
}
|
||
},
|
||
}, {
|
||
id: 'aaa5-2',
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
system: {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'ccc5',
|
||
name: 'test2',
|
||
description: 'aaaaa2',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
} as EntityDict['system']['CreateSingle']['data'],
|
||
},
|
||
}]
|
||
}, context, {});
|
||
|
||
let applications = await store.select('application', {
|
||
data: {
|
||
"#id": 'node-1',
|
||
id: 1,
|
||
name: 1,
|
||
system: {
|
||
id: 1,
|
||
name: 1,
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
"#attr": 'name',
|
||
},
|
||
{
|
||
'#refId': 'node-1',
|
||
"#refAttr": 'name',
|
||
}
|
||
]
|
||
},
|
||
}
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: ['aaa5', 'aaa5-2'],
|
||
},
|
||
},
|
||
}, context, {});
|
||
// console.log(applications);
|
||
assert(applications.length === 2);
|
||
applications.forEach(
|
||
(app) => {
|
||
assert(app.id === 'aaa5' && !(app.system!.$expr)
|
||
|| app.id === 'aaa5-2' && !!(app.system!.$expr));
|
||
}
|
||
);
|
||
|
||
const applications2 = await store.select('application', {
|
||
data: {
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
"#attr": 'name',
|
||
},
|
||
{
|
||
'#refId': 'node-1',
|
||
"#refAttr": 'name',
|
||
}
|
||
]
|
||
},
|
||
id: 1,
|
||
name: 1,
|
||
system: {
|
||
"#id": 'node-1',
|
||
id: 1,
|
||
name: 1,
|
||
}
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: ['aaa5', 'aaa5-2'],
|
||
},
|
||
},
|
||
}, context, {});
|
||
// console.log(applications2);
|
||
// assert(applications.length === 2);
|
||
applications2.forEach(
|
||
(app) => {
|
||
assert(app.id === 'aaa5' && !(app.$expr)
|
||
|| app.id === 'aaa5-2' && !!(app.$expr));
|
||
}
|
||
);
|
||
await context.commit();
|
||
});
|
||
|
||
// 这个貌似目前支持不了 by Xc
|
||
it('[1.6]projection中的一对多跨结点表达式', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'bbb6',
|
||
name: 'test2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'aaa6',
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'aaa6-2',
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}]
|
||
}
|
||
} as EntityDict['system']['CreateSingle'], context, {});
|
||
|
||
const systems = await store.select('system', {
|
||
data: {
|
||
"#id": 'node-1',
|
||
id: 1,
|
||
name: 1,
|
||
application$system: {
|
||
$entity: 'application',
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
"#attr": 'name',
|
||
},
|
||
{
|
||
'#refId': 'node-1',
|
||
"#refAttr": 'name',
|
||
}
|
||
]
|
||
},
|
||
$expr2: {
|
||
'#refId': 'node-1',
|
||
"#refAttr": 'id',
|
||
}
|
||
}
|
||
},
|
||
},
|
||
}, context, {});
|
||
// console.log(systems);
|
||
assert(systems.length === 1);
|
||
const [system] = systems;
|
||
const { application$system: applications } = system;
|
||
assert(applications!.length === 2);
|
||
applications!.forEach(
|
||
(ele) => {
|
||
assert(ele.id === 'aaa' && ele.$expr === false && ele.$expr2 === 'bbb'
|
||
|| ele.id === 'aaa2' && ele.$expr === true && ele.$expr2 === 'bbb');
|
||
}
|
||
);
|
||
});
|
||
|
||
it('[1.7]事务性测试', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
|
||
await context.begin();
|
||
const systemId = v4();
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: systemId,
|
||
name: 'test2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'aaa7',
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}, {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: 'aaa7-2',
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}]
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
await context.begin();
|
||
const systems = await store.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
application$system: {
|
||
$entity: 'application',
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
systemId: 1,
|
||
}
|
||
},
|
||
},
|
||
filter: {
|
||
id: systemId,
|
||
},
|
||
}, context, {});
|
||
assert(systems.length === 1 && systems[0].application$system!.length === 2);
|
||
|
||
await store.operate('application', {
|
||
id: v4(),
|
||
action: 'remove',
|
||
data: {},
|
||
filter: {
|
||
id: 'aaa7',
|
||
}
|
||
}, context, {});
|
||
|
||
const systems2 = await store.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
application$system: {
|
||
$entity: 'application',
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
systemId: 1,
|
||
}
|
||
},
|
||
},
|
||
filter: {
|
||
id: systemId,
|
||
},
|
||
}, context, {});
|
||
assert(systems2.length === 1 && systems2[0].application$system!.length === 1);
|
||
await context.rollback();
|
||
|
||
const systems3 = await store.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
application$system: {
|
||
$entity: 'application',
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
systemId: 1,
|
||
}
|
||
},
|
||
},
|
||
filter: {
|
||
id: systemId,
|
||
},
|
||
}, context, {});
|
||
assert(systems3.length === 1 && systems3[0].application$system!.length === 2);
|
||
});
|
||
|
||
it('[1.8]aggregation', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId1 = v4();
|
||
const systemId2 = v4();
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: systemId1,
|
||
name: 'test2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
},
|
||
}
|
||
}]
|
||
},
|
||
{
|
||
id: systemId2,
|
||
name: 'test2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
},
|
||
}
|
||
}]
|
||
}
|
||
]
|
||
} as EntityDict['system']['CreateMulti'], context, {});
|
||
await context.commit();
|
||
|
||
await context.begin();
|
||
const result = await store.aggregate('application', {
|
||
data: {
|
||
'#aggr': {
|
||
system: {
|
||
id: 1,
|
||
},
|
||
},
|
||
'#count-1': {
|
||
id: 1,
|
||
}
|
||
},
|
||
filter: {
|
||
systemId: {
|
||
$in: [systemId1, systemId2],
|
||
},
|
||
},
|
||
}, context, {});
|
||
await context.commit();
|
||
// console.log(result);
|
||
assert(result.length === 2);
|
||
result.forEach(
|
||
(row) => assert(row['#count-1'] === 2)
|
||
);
|
||
});
|
||
|
||
it('[1.9]test + aggregation', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId1 = v4();
|
||
const systemId2 = v4();
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: systemId1,
|
||
name: 'test2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}]
|
||
},
|
||
{
|
||
id: systemId2,
|
||
name: 'test2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}]
|
||
}
|
||
]
|
||
} as EntityDict['system']['CreateMulti'], context, {});
|
||
await context.commit();
|
||
|
||
await context.begin();
|
||
const result = await store.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
application$system$$aggr: {
|
||
$entity: 'application',
|
||
data: {
|
||
'#aggr': {
|
||
systemId: 1,
|
||
},
|
||
'#count-1': {
|
||
id: 1,
|
||
}
|
||
},
|
||
},
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [systemId1, systemId2],
|
||
},
|
||
},
|
||
}, context, {});
|
||
await context.commit();
|
||
// console.log(result);
|
||
assert(result.length === 2);
|
||
result.forEach(
|
||
(row) => assert(row.application$system$$aggr?.length === 1 && row.application$system$$aggr[0]['#count-1'] === 2)
|
||
);
|
||
});
|
||
|
||
it('[1.10]json insert/select', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
let id = await generateNewIdAsync();
|
||
await context.operate('application', {
|
||
id: await generateNewIdAsync(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
name: 'xuchang',
|
||
description: 'tt',
|
||
type: 'web',
|
||
systemId: 'system',
|
||
config: {
|
||
type: 'web',
|
||
passport: ['email', 'mobile'],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}, {});
|
||
|
||
let result = await context.select('application', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
config: {
|
||
passport: [undefined, 1],
|
||
wechat: {
|
||
appId: 1,
|
||
}
|
||
},
|
||
},
|
||
filter: {
|
||
id,
|
||
},
|
||
}, {});
|
||
// console.log(JSON.stringify(result));
|
||
|
||
id = await generateNewIdAsync();
|
||
await context.operate('application', {
|
||
id: await generateNewIdAsync(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
name: 'xuchang',
|
||
description: 'tt',
|
||
type: 'web',
|
||
systemId: 'system',
|
||
config: {
|
||
type: 'web',
|
||
wechat: {
|
||
appId: 'aaaa\\nddddd',
|
||
appSecret: '',
|
||
},
|
||
passport: ['email', 'mobile'],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}, {});
|
||
|
||
result = await context.select('application', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
config: {
|
||
passport: [undefined, 1],
|
||
wechat: {
|
||
appId: 1,
|
||
}
|
||
},
|
||
},
|
||
filter: {
|
||
id,
|
||
},
|
||
}, {});
|
||
console.log((result[0].config as WebConfig)!.wechat!.appId);
|
||
});
|
||
|
||
it('[1.11]json as filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id = await generateNewIdAsync();
|
||
await store.operate('oper', {
|
||
id: await generateNewIdAsync(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
action: 'test',
|
||
data: {
|
||
name: 'xc',
|
||
books: [{
|
||
title: 'mathmatics',
|
||
price: 1,
|
||
}, {
|
||
title: 'english',
|
||
price: 2,
|
||
}],
|
||
},
|
||
targetEntity: 'bbb',
|
||
bornAt: 111,
|
||
}
|
||
}, context, {});
|
||
|
||
const row = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
books: [undefined, {
|
||
title: 1,
|
||
price: 1,
|
||
}],
|
||
},
|
||
},
|
||
filter: {
|
||
id,
|
||
data: {
|
||
name: 'xc',
|
||
}
|
||
}
|
||
}, context, {});
|
||
const row2 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
books: [undefined, {
|
||
title: 1,
|
||
price: 1,
|
||
}],
|
||
},
|
||
},
|
||
filter: {
|
||
id,
|
||
data: {
|
||
name: 'xc2',
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
// console.log(JSON.stringify(row));
|
||
assert(row.length === 1, JSON.stringify(row));
|
||
assert(row2.length === 0, JSON.stringify(row2));
|
||
});
|
||
|
||
|
||
it('[1.11.2]json filter on top level', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id = await generateNewIdAsync();
|
||
await store.operate('actionAuth', {
|
||
id: await generateNewIdAsync(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
pathId: await generateNewIdAsync(),
|
||
deActions: ['1.12'],
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
|
||
const row = await store.select('actionAuth', {
|
||
data: {
|
||
id: 1,
|
||
deActions: 1,
|
||
},
|
||
filter: {
|
||
id,
|
||
deActions: {
|
||
$overlaps: '1.12',
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
|
||
const row2 = await store.select('actionAuth', {
|
||
data: {
|
||
id: 1,
|
||
deActions: 1,
|
||
},
|
||
filter: {
|
||
id,
|
||
deActions: {
|
||
$contains: ['1.13333'],
|
||
}
|
||
}
|
||
}, context, {});
|
||
// console.log(JSON.stringify(row));
|
||
assert(row.length === 1, JSON.stringify(row));
|
||
console.log(JSON.stringify(row));
|
||
assert(row2.length === 0, JSON.stringify(row2));
|
||
|
||
const row3 = await store.select('actionAuth', {
|
||
data: {
|
||
id: 1,
|
||
deActions: 1,
|
||
},
|
||
filter: {
|
||
id,
|
||
deActions: {
|
||
$exists: true,
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
assert(row3.length === 1);
|
||
const row4 = await store.select('actionAuth', {
|
||
data: {
|
||
id: 1,
|
||
deActions: 1,
|
||
},
|
||
filter: {
|
||
id,
|
||
deActions: {
|
||
$exists: false,
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
assert(row4.length === 0);
|
||
});
|
||
|
||
it('[1.11.3]json escape', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id = await generateNewIdAsync();
|
||
await store.operate('oper', {
|
||
id: await generateNewIdAsync(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
action: 'test',
|
||
data: {
|
||
$or: [{
|
||
name: 'xc',
|
||
}, {
|
||
name: {
|
||
$includes: 'xc',
|
||
}
|
||
}],
|
||
},
|
||
targetEntity: 'bbb',
|
||
bornAt: 123,
|
||
}
|
||
}, context, {});
|
||
|
||
const row = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
id,
|
||
data: {
|
||
'.$or': {
|
||
$contains: {
|
||
name: 'xc',
|
||
},
|
||
},
|
||
},
|
||
}
|
||
}, context, {});
|
||
|
||
process.env.NODE_ENV = 'development';
|
||
const row2 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
id,
|
||
data: {
|
||
'.$or': [
|
||
{
|
||
name: 'xc',
|
||
},
|
||
{
|
||
name: {
|
||
'.$includes': 'xc',
|
||
}
|
||
}
|
||
],
|
||
},
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
assert(row.length === 1);
|
||
assert(row2.length === 1);
|
||
});
|
||
|
||
it('[1.12]complicated json filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id = await generateNewIdAsync();
|
||
await store.operate('oper', {
|
||
id: await generateNewIdAsync(),
|
||
action: 'create',
|
||
data: {
|
||
id,
|
||
action: 'test',
|
||
data: {
|
||
name: 'xcc',
|
||
price: [100, 400, 1000],
|
||
},
|
||
targetEntity: 'bbb',
|
||
bornAt: 123,
|
||
}
|
||
}, context, {});
|
||
|
||
const row = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: [undefined, 400],
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row2 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: [undefined, 200],
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row3 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: [undefined, {
|
||
$gt: 300,
|
||
}],
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row4 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: {
|
||
$contains: [200, 500],
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row5 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: {
|
||
$contains: [100, 400],
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row6 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: {
|
||
$contains: ['xc'],
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row7 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
name: {
|
||
$includes: 'xc',
|
||
},
|
||
price: {
|
||
$overlaps: [200, 400, 800],
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
/**
|
||
* 带$or的查询
|
||
*/
|
||
process.env.NODE_ENV = 'development';
|
||
const row8 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
$or: [
|
||
{
|
||
name: {
|
||
$includes: 'xc',
|
||
},
|
||
},
|
||
{
|
||
name: {
|
||
$includes: 'xzw',
|
||
}
|
||
}
|
||
],
|
||
price: {
|
||
$overlaps: [200, 400, 800],
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
const row9 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: {
|
||
$length: 3,
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
const row10 = await store.select('oper', {
|
||
data: {
|
||
id: 1,
|
||
data: {
|
||
name: 1,
|
||
price: 1,
|
||
},
|
||
},
|
||
filter: {
|
||
data: {
|
||
price: {
|
||
$length: {
|
||
$gt: 3,
|
||
},
|
||
},
|
||
}
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
assert(row.length === 1);
|
||
assert(row2.length === 0);
|
||
assert(row3.length === 1);
|
||
assert(row4.length === 0);
|
||
assert(row5.length === 1);
|
||
assert(row6.length === 0);
|
||
assert(row7.length === 1);
|
||
assert(row8.length === 1);
|
||
assert(row9.length === 1);
|
||
assert(row10.length === 0);
|
||
// console.log(JSON.stringify(row7));
|
||
});
|
||
|
||
it('[1.13]sub query predicate', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
const id1 = await generateNewIdAsync();
|
||
const id2 = await generateNewIdAsync();
|
||
const id3 = await generateNewIdAsync();
|
||
const systems: EntityDict['system']['CreateSingle']['data'][] = [
|
||
{
|
||
id: id1,
|
||
name: 'test1.13-1',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test1.13-1-1',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test1.13-1-2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}]
|
||
},
|
||
{
|
||
id: id2,
|
||
name: 'test1.13-2',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
application$system: [{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test1.13-2-1',
|
||
description: 'ttttt',
|
||
type: 'web',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: v4(),
|
||
name: 'test1.13-2-2',
|
||
description: 'ttttt2',
|
||
type: 'wechatMp',
|
||
config: {
|
||
type: 'web',
|
||
passport: [],
|
||
location: {
|
||
protocol: "http:",
|
||
hostname: '',
|
||
port: '',
|
||
},
|
||
},
|
||
}
|
||
}]
|
||
},
|
||
{
|
||
|
||
id: id3,
|
||
name: 'test1.13-3',
|
||
description: 'aaaaa',
|
||
config: {
|
||
App: {},
|
||
},
|
||
folder: '/test2',
|
||
platformId: 'platform-111',
|
||
}
|
||
];
|
||
|
||
await context.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: systems,
|
||
}, {});
|
||
|
||
await context.commit();
|
||
|
||
const r1 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1);
|
||
|
||
const r2 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
'#sqp': 'not in',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r2.length === 0);
|
||
|
||
const r22 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
name: {
|
||
$startsWith: 'test1.13-2',
|
||
},
|
||
'#sqp': 'not in',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r22.length === 1);
|
||
|
||
const r23 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
name: {
|
||
$startsWith: 'test1.13-2',
|
||
},
|
||
'#sqp': 'all',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r23.length === 0);
|
||
|
||
const r24 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
name: {
|
||
$startsWith: 'test1.13-2',
|
||
},
|
||
'#sqp': 'not all',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r24.length === 1);
|
||
|
||
const r3 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
'#sqp': 'all',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r3.length === 0);
|
||
|
||
|
||
const r4 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
application$system: {
|
||
'#sqp': 'not all',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r4.length === 1);
|
||
|
||
const r5 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [id1, id2, id3],
|
||
},
|
||
application$system: {
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r5.length === 2);
|
||
assert(r5.map(ele => ele.id).includes(id1));
|
||
assert(r5.map(ele => ele.id).includes(id2));
|
||
|
||
const r6 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [id1, id2, id3],
|
||
},
|
||
application$system: {
|
||
'#sqp': 'not in',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r6.length === 1);
|
||
assert(r6.map(ele => ele.id).includes(id3));
|
||
|
||
const r7 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [id1, id2, id3],
|
||
},
|
||
application$system: {
|
||
'#sqp': 'all',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r7.length === 0);
|
||
|
||
const r8 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: {
|
||
$in: [id1, id2, id3],
|
||
},
|
||
application$system: {
|
||
'#sqp': 'not all',
|
||
},
|
||
},
|
||
}, {});
|
||
assert(r8.length === 3);
|
||
assert(r8.map(ele => ele.id).includes(id1));
|
||
assert(r8.map(ele => ele.id).includes(id2));
|
||
assert(r8.map(ele => ele.id).includes(id3));
|
||
});
|
||
|
||
it('[1.14]$dateDiff expression', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const now = Date.now();
|
||
const oneHourAgo = now - 3600 * 1000; // 1小时前
|
||
const oneDayAgo = now - 24 * 3600 * 1000; // 1天前
|
||
const oneMonthAgo = now - 30 * 24 * 3600 * 1000; // 约30天前
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: oneHourAgo,
|
||
value: v4(),
|
||
},
|
||
{
|
||
id: id2,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: oneDayAgo,
|
||
value: v4(),
|
||
},
|
||
{
|
||
id: id3,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: oneMonthAgo,
|
||
value: v4(),
|
||
}
|
||
]
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
|
||
// 测试秒级差异
|
||
const r1 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateDiff: [
|
||
now,
|
||
{ '#attr': 'refreshedAt' },
|
||
's'
|
||
]
|
||
},
|
||
3500 // 约1小时 = 3600秒，给一些误差
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row for seconds diff, got ${r1.length}`);
|
||
|
||
// 测试分钟级差异
|
||
const r2 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateDiff: [
|
||
now,
|
||
{ '#attr': 'refreshedAt' },
|
||
'm'
|
||
]
|
||
},
|
||
55 // 约1小时 = 60分钟
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `Expected 1 row for minutes diff, got ${r2.length}`);
|
||
|
||
// 测试小时级差异
|
||
const r3 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id2,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateDiff: [
|
||
now,
|
||
{ '#attr': 'refreshedAt' },
|
||
'h'
|
||
]
|
||
},
|
||
23 // 约1天 = 24小时
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r3.length === 1, `Expected 1 row for hours diff, got ${r3.length}`);
|
||
|
||
// 测试天级差异
|
||
const r4 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id3,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateDiff: [
|
||
now,
|
||
{ '#attr': 'refreshedAt' },
|
||
'd'
|
||
]
|
||
},
|
||
25 // 约30天
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r4.length === 1, `Expected 1 row for days diff, got ${r4.length}`);
|
||
});
|
||
|
||
it('[1.15]$dateFloor expression', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 创建一个特定时间的记录: 2024-06-15 14:30:45
|
||
const specificTime = new Date('2024-06-15T14:30:45.123Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificTime,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
|
||
// 测试向下取整到分钟 - 应该得到 14:30:00
|
||
const startOfMinute = new Date('2024-06-15T14:30:00.000Z').valueOf();
|
||
const endOfMinute = new Date('2024-06-15T14:31:00.000Z').valueOf();
|
||
|
||
const r1 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$and: [
|
||
{
|
||
$gte: [
|
||
{
|
||
$dateFloor: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'm'
|
||
]
|
||
},
|
||
startOfMinute
|
||
]
|
||
},
|
||
{
|
||
$lt: [
|
||
{
|
||
$dateFloor: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'm'
|
||
]
|
||
},
|
||
endOfMinute
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row for minute floor, got ${r1.length}`);
|
||
|
||
// 测试向下取整到小时 - 应该得到 14:00:00
|
||
const startOfHour = new Date('2024-06-15T14:00:00.000Z').valueOf();
|
||
const endOfHour = new Date('2024-06-15T15:00:00.000Z').valueOf();
|
||
|
||
const r2 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$and: [
|
||
{
|
||
$gte: [
|
||
{
|
||
$dateFloor: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'h'
|
||
]
|
||
},
|
||
startOfHour
|
||
]
|
||
},
|
||
{
|
||
$lt: [
|
||
{
|
||
$dateFloor: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'h'
|
||
]
|
||
},
|
||
endOfHour
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `Expected 1 row for hour floor, got ${r2.length}`);
|
||
|
||
// 测试向下取整到天 - 应该得到 2024-06-15 00:00:00
|
||
const startOfDay = new Date('2024-06-15T00:00:00.000Z').valueOf();
|
||
const endOfDay = new Date('2024-06-16T00:00:00.000Z').valueOf();
|
||
|
||
const r3 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$and: [
|
||
{
|
||
$gte: [
|
||
{
|
||
$dateFloor: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'd'
|
||
]
|
||
},
|
||
startOfDay
|
||
]
|
||
},
|
||
{
|
||
$lt: [
|
||
{
|
||
$dateFloor: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'd'
|
||
]
|
||
},
|
||
endOfDay
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r3.length === 1, `Expected 1 row for day floor, got ${r3.length}`);
|
||
});
|
||
|
||
it('[1.16]$dateCeil expression', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 创建一个特定时间的记录: 2024-06-15 14:30:45
|
||
const specificTime = new Date('2024-06-15T14:30:45.123Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificTime,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
|
||
// 测试向上取整到分钟 - 应该得到 14:31:00
|
||
const ceilMinute = new Date('2024-06-15T14:31:00.000Z').valueOf();
|
||
|
||
const r1 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateCeil: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'm'
|
||
]
|
||
},
|
||
ceilMinute
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row for minute ceil, got ${r1.length}`);
|
||
|
||
// 测试向上取整到小时 - 应该得到 15:00:00
|
||
const ceilHour = new Date('2024-06-15T15:00:00.000Z').valueOf();
|
||
|
||
const r2 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateCeil: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'h'
|
||
]
|
||
},
|
||
ceilHour
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `Expected 1 row for hour ceil, got ${r2.length}`);
|
||
|
||
// 测试向上取整到天 - 应该得到 2024-06-16 00:00:00
|
||
const ceilDay = new Date('2024-06-16T00:00:00.000Z').valueOf();
|
||
|
||
const r3 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
refreshedAt: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$dateCeil: [
|
||
{ '#attr': 'refreshedAt' },
|
||
'd'
|
||
]
|
||
},
|
||
ceilDay
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r3.length === 1, `Expected 1 row for day ceil, got ${r3.length}`);
|
||
});
|
||
|
||
it('[1.17]aggregation functions $$sum, $$max, $$min, $$avg', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const areaId = v4();
|
||
const ownerId = v4();
|
||
|
||
// 创建多个房屋记录用于测试聚合函数
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: v4(),
|
||
areaId,
|
||
ownerId,
|
||
district: '杭州',
|
||
size: 80.0,
|
||
},
|
||
{
|
||
id: v4(),
|
||
areaId,
|
||
ownerId,
|
||
district: '杭州',
|
||
size: 100.0,
|
||
},
|
||
{
|
||
id: v4(),
|
||
areaId,
|
||
ownerId,
|
||
district: '杭州',
|
||
size: 120.0,
|
||
},
|
||
{
|
||
id: v4(),
|
||
areaId,
|
||
ownerId,
|
||
district: '上海',
|
||
size: 150.0,
|
||
},
|
||
]
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
|
||
// 测试 $$count
|
||
const countResult = await store.aggregate('house', {
|
||
data: {
|
||
'#aggr': {
|
||
district: 1,
|
||
},
|
||
'#count-1': {
|
||
id: 1,
|
||
}
|
||
},
|
||
filter: {
|
||
areaId,
|
||
},
|
||
}, context, {});
|
||
|
||
assert(countResult.length === 2, `Expected 2 groups, got ${countResult.length}`);
|
||
const hangzhouCount = countResult.find(r => r['#data']?.district === '杭州');
|
||
const shanghaiCount = countResult.find(r => r['#data']?.district === '上海');
|
||
assert(hangzhouCount && hangzhouCount['#count-1'] === 3, `Expected 3 houses in 杭州, got ${hangzhouCount?.['#count-1']}`);
|
||
assert(shanghaiCount && shanghaiCount['#count-1'] === 1, `Expected 1 house in 上海, got ${shanghaiCount?.['#count-1']}`);
|
||
|
||
// TODO: 下面的测试用例暂不支持，先注释掉
|
||
// // 测试 $$sum
|
||
// const sumResult = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': {
|
||
// district: 1,
|
||
// },
|
||
// '#sum-1': {
|
||
// $$sum: {
|
||
// '#attr': 'size',
|
||
// },
|
||
// }
|
||
// },
|
||
// filter: {
|
||
// areaId,
|
||
// },
|
||
// }, context, {});
|
||
|
||
// const hangzhouSum = sumResult.find(r => r['#data']?.district === '杭州');
|
||
// assert(hangzhouSum && hangzhouSum['#sum-1'] === 300, `Expected sum 300 for 杭州, got ${hangzhouSum?.['#sum-1']}`);
|
||
|
||
// // 测试 $$max
|
||
// const maxResult = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': {
|
||
// district: 1,
|
||
// },
|
||
// '#max-1': {
|
||
// $$max: {
|
||
// '#attr': 'size',
|
||
// },
|
||
// }
|
||
// },
|
||
// filter: {
|
||
// areaId,
|
||
// },
|
||
// }, context, {});
|
||
|
||
// const hangzhouMax = maxResult.find(r => r['#data']?.district === '杭州');
|
||
// assert(hangzhouMax && hangzhouMax['#max-1'] === 120, `Expected max 120 for 杭州, got ${hangzhouMax?.['#max-1']}`);
|
||
|
||
// // 测试 $$min
|
||
// const minResult = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': {
|
||
// district: 1,
|
||
// },
|
||
// '#min-1': {
|
||
// $$min: {
|
||
// '#attr': 'size',
|
||
// },
|
||
// }
|
||
// },
|
||
// filter: {
|
||
// areaId,
|
||
// },
|
||
// }, context, {});
|
||
|
||
// const hangzhouMin = minResult.find(r => r['#data']?.district === '杭州');
|
||
// assert(hangzhouMin && hangzhouMin['#min-1'] === 80, `Expected min 80 for 杭州, got ${hangzhouMin?.['#min-1']}`);
|
||
|
||
// // 测试 $$avg
|
||
// const avgResult = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': {
|
||
// district: 1,
|
||
// },
|
||
// '#avg-1': {
|
||
// $$avg: {
|
||
// '#attr': 'size',
|
||
// },
|
||
// }
|
||
// },
|
||
// filter: {
|
||
// areaId,
|
||
// },
|
||
// }, context, {});
|
||
|
||
// const hangzhouAvg = avgResult.find(r => r['#data']?.district === '杭州');
|
||
// assert(hangzhouAvg && hangzhouAvg['#avg-1'] === 100, `Expected avg 100 for 杭州, got ${hangzhouAvg?.['#avg-1']}`);
|
||
});
|
||
|
||
it('[1.18]date expression with constants', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const now = Date.now();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: now,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
|
||
await context.commit();
|
||
|
||
// 测试 $dateDiff 使用常量日期
|
||
const yesterday = now - 24 * 3600 * 1000;
|
||
|
||
const r1 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
$dateDiff: [
|
||
now,
|
||
yesterday,
|
||
'd'
|
||
]
|
||
},
|
||
1
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row for constant date diff, got ${r1.length}`);
|
||
|
||
// 测试 $dateDiff 混合使用属性和常量
|
||
const r2 = await context.select('token', {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$lt: [
|
||
{
|
||
$dateDiff: [
|
||
{ '#attr': 'refreshedAt' },
|
||
yesterday,
|
||
'h'
|
||
]
|
||
},
|
||
48 // 应该在48小时以内
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `Expected 1 row for mixed date diff, got ${r2.length}`);
|
||
});
|
||
|
||
// ==================== 数学运算符测试 ====================
|
||
|
||
it('[2.1]math expression $add', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 80.5,
|
||
},
|
||
{
|
||
id: id2,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '上海',
|
||
size: 100.0,
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $add: size + 20 > 100
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$gt: [
|
||
{
|
||
$add: [{ '#attr': 'size' }, 20]
|
||
},
|
||
100
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 2, `Expected 2 rows, got ${r1.length}`);
|
||
|
||
// 测试多参数 $add: size + 10 + 20 > 120
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$gt: [
|
||
{
|
||
$add: [{ '#attr': 'size' }, 10, 20]
|
||
},
|
||
120
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].id === id2, `Expected id2, got ${r2.map(r => r.id)}`);
|
||
});
|
||
|
||
it('[2.2]math expression $subtract', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 80.0,
|
||
},
|
||
{
|
||
id: id2,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '上海',
|
||
size: 120.0,
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $subtract: size - 50 > 50
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$gt: [
|
||
{
|
||
$subtract: [{ '#attr': 'size' }, 50]
|
||
},
|
||
50
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id2, `Expected id2, got ${r1.map(r => r.id)}`);
|
||
});
|
||
|
||
it('[2.3]math expression $multiply', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 50.0,
|
||
},
|
||
{
|
||
id: id2,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '上海',
|
||
size: 100.0,
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $multiply: size * 2 >= 200
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$gte: [
|
||
{
|
||
$multiply: [{ '#attr': 'size' }, 2]
|
||
},
|
||
200
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id2, `Expected id2, got ${r1.map(r => r.id)}`);
|
||
|
||
// 测试多参数 $multiply: size * 2 * 3 > 500
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$gt: [
|
||
{
|
||
$multiply: [{ '#attr': 'size' }, 2, 3]
|
||
},
|
||
500
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].id === id2, `Expected id2, got ${r2.map(r => r.id)}`);
|
||
});
|
||
|
||
it('[2.4]math expression $divide', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 80.0,
|
||
},
|
||
{
|
||
id: id2,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '上海',
|
||
size: 200.0,
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $divide: size / 2 > 50
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$gt: [
|
||
{
|
||
$divide: [{ '#attr': 'size' }, 2]
|
||
},
|
||
50
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id2, `Expected id2, got ${r1.map(r => r.id)}`);
|
||
});
|
||
|
||
it('[2.5]math expression $abs', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 80.0,
|
||
},
|
||
{
|
||
id: id2,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '上海',
|
||
size: 120.0,
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $abs: abs(size - 100) <= 20
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$lte: [
|
||
{
|
||
$abs: {
|
||
$subtract: [{ '#attr': 'size' }, 100]
|
||
}
|
||
},
|
||
20
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 2, `Expected 2 rows, got ${r1.length}`);
|
||
});
|
||
|
||
it('[2.6]math expression $round', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 80.567,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $round: round(size, 1) = 80.6
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
$round: [{ '#attr': 'size' }, 1]
|
||
},
|
||
80.6
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row, got ${r1.length}`);
|
||
|
||
// 测试 $round: round(size, 0) = 81
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
$round: [{ '#attr': 'size' }, 0]
|
||
},
|
||
81
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `Expected 1 row, got ${r2.length}`);
|
||
});
|
||
|
||
it('[2.7]math expression $ceil and $floor', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 80.3,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $ceil: ceil(size) = 81
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{ $ceil: { '#attr': 'size' } },
|
||
81
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row for ceil, got ${r1.length}`);
|
||
|
||
// 测试 $floor: floor(size) = 80
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{ $floor: { '#attr': 'size' } },
|
||
80
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `Expected 1 row for floor, got ${r2.length}`);
|
||
});
|
||
|
||
it('[2.8]math expression $pow', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 10.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $pow: pow(size, 2) = 100
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{ $pow: [{ '#attr': 'size' }, 2] },
|
||
100
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row, got ${r1.length}`);
|
||
});
|
||
|
||
// ==================== 字符串操作测试 ====================
|
||
|
||
it('[3.1]string expression $endsWith', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
name: 'test_user',
|
||
nickname: 'test',
|
||
},
|
||
{
|
||
id: id2,
|
||
name: 'admin_role',
|
||
nickname: 'admin',
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $endsWith: name ends with '_user'
|
||
const r1 = await context.select('user', {
|
||
data: { id: 1, name: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$endsWith: [{ '#attr': 'name' }, '_user']
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id1, `Expected id1, got ${r1.map(r => r.id)}`);
|
||
});
|
||
|
||
it('[3.2]string expression $includes', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
name: 'test_admin_user',
|
||
nickname: 'test',
|
||
},
|
||
{
|
||
id: id2,
|
||
name: 'guest_role',
|
||
nickname: 'guest',
|
||
},
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $includes: name includes 'admin'
|
||
const r1 = await context.select('user', {
|
||
data: { id: 1, name: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$includes: [{ '#attr': 'name' }, 'admin']
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id1, `Expected id1, got ${r1.map(r => r.id)}`);
|
||
});
|
||
|
||
it('[3.3]string expression $concat', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
name: 'hello',
|
||
nickname: 'world',
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $concat: concat(name, '_', nickname) = 'hello_world'
|
||
const r1 = await context.select('user', {
|
||
data: { id: 1, name: 1, nickname: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{ $concat: [{ '#attr': 'name' }, '_', { '#attr': 'nickname' }] },
|
||
'hello_world'
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Expected 1 row, got ${r1.length}`);
|
||
});
|
||
|
||
// ==================== 比较运算符测试 ====================
|
||
|
||
it('[4.1]comparison expressions $gt $gte $lt $lte $ne', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, areaId: v4(), ownerId: v4(), district: '杭州', size: 50.0 },
|
||
{ id: id2, areaId: v4(), ownerId: v4(), district: '上海', size: 100.0 },
|
||
{ id: id3, areaId: v4(), ownerId: v4(), district: '北京', size: 150.0 },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
const ids = [id1, id2, id3];
|
||
|
||
// $gt: size > 100
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: { $gt: [{ '#attr': 'size' }, 100] }
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id3, `$gt failed`);
|
||
|
||
// $gte: size >= 100
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: { $gte: [{ '#attr': 'size' }, 100] }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 2, `$gte failed, expected 2, got ${r2.length}`);
|
||
|
||
// $lt: size < 100
|
||
const r3 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: { $lt: [{ '#attr': 'size' }, 100] }
|
||
}
|
||
}, {});
|
||
assert(r3.length === 1 && r3[0].id === id1, `$lt failed`);
|
||
|
||
// $lte: size <= 100
|
||
const r4 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: { $lte: [{ '#attr': 'size' }, 100] }
|
||
}
|
||
}, {});
|
||
assert(r4.length === 2, `$lte failed, expected 2, got ${r4.length}`);
|
||
|
||
// $ne: size != 100
|
||
const r5 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: { $ne: [{ '#attr': 'size' }, 100] }
|
||
}
|
||
}, {});
|
||
assert(r5.length === 2, `$ne failed, expected 2, got ${r5.length}`);
|
||
});
|
||
|
||
// ==================== 布尔运算符测试 ====================
|
||
|
||
it('[5.1]boolean expression $true $false', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, areaId: v4(), ownerId: v4(), district: '杭州', size: 100.0 },
|
||
{ id: id2, areaId: v4(), ownerId: v4(), district: '上海', size: 50.0 },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// $true: 检查表达式为真
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$true: { $gt: [{ '#attr': 'size' }, 80] }
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id1, `$true failed`);
|
||
|
||
// $false: 检查表达式为假
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$false: { $gt: [{ '#attr': 'size' }, 80] }
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].id === id2, `$false failed`);
|
||
});
|
||
|
||
it('[5.2]logic expression $and $or $not', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, areaId: v4(), ownerId: v4(), district: '杭州', size: 80.0 },
|
||
{ id: id2, areaId: v4(), ownerId: v4(), district: '上海', size: 120.0 },
|
||
{ id: id3, areaId: v4(), ownerId: v4(), district: '北京', size: 100.0 },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
const ids = [id1, id2, id3];
|
||
|
||
// $and: size > 70 AND size < 110
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: {
|
||
$and: [
|
||
{ $gt: [{ '#attr': 'size' }, 70] },
|
||
{ $lt: [{ '#attr': 'size' }, 110] }
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 2, `$and failed, expected 2, got ${r1.length}`);
|
||
|
||
// $or: size < 90 OR size > 110
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: {
|
||
$or: [
|
||
{ $lt: [{ '#attr': 'size' }, 90] },
|
||
{ $gt: [{ '#attr': 'size' }, 110] }
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 2, `$or failed, expected 2, got ${r2.length}`);
|
||
|
||
// $not: NOT (size = 100)
|
||
const r3 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: { $in: ids },
|
||
$expr: {
|
||
$not: { $eq: [{ '#attr': 'size' }, 100] }
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r3.length === 2, `$not failed, expected 2, got ${r3.length}`);
|
||
});
|
||
|
||
// ==================== 日期函数测试 ====================
|
||
|
||
it('[6.1]date expression $year $month $day', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 2024-06-15 14:30:45
|
||
const specificDate = new Date('2024-06-15T14:30:45.000Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificDate,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $year
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $year: { '#attr': 'refreshedAt' } }, 2024] }
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `$year failed`);
|
||
|
||
// 测试 $month
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $month: { '#attr': 'refreshedAt' } }, 6] }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `$month failed`);
|
||
|
||
// 测试 $day
|
||
const r3 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $day: { '#attr': 'refreshedAt' } }, 15] }
|
||
}
|
||
}, {});
|
||
assert(r3.length === 1, `$day failed`);
|
||
});
|
||
|
||
it('[6.2]date expression $dayOfMonth $dayOfWeek $dayOfYear', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 2024-06-15 是星期六，是一年中的第167天
|
||
const specificDate = new Date('2024-06-15T14:30:45.000Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificDate,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
|
||
// 测试 $dayOfMonth
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $dayOfMonth: { '#attr': 'refreshedAt' } }, 15] }
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `$dayOfMonth failed`);
|
||
|
||
// 测试 $dayOfWeek (MySQL: 1=周日, 7=周六; 2024-06-15是周六)
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $dayOfWeek: { '#attr': 'refreshedAt' } }, 7] }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `$dayOfWeek failed`);
|
||
|
||
// 测试 $dayOfYear (2024-06-15 是第167天)
|
||
const r3 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $dayOfYear: { '#attr': 'refreshedAt' } }, 167] }
|
||
}
|
||
}, {});
|
||
assert(r3.length === 1, `$dayOfYear failed`);
|
||
});
|
||
|
||
it('[6.3]date expression $weekday $weekOfYear', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 2024-06-15 是第24周
|
||
const specificDate = new Date('2024-06-15T14:30:45.000Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificDate,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $weekday (MySQL WEEKDAY: 0=周一, 6=周日; 2024-06-15是周六=5)
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $weekday: { '#attr': 'refreshedAt' } }, 5] }
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `$weekday failed`);
|
||
|
||
// 测试 $weekOfYear
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: { $eq: [{ $weekOfYear: { '#attr': 'refreshedAt' } }, 24] }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `$weekOfYear failed`);
|
||
});
|
||
|
||
it('[6.4]$dateDiff with different units', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const now = Date.now();
|
||
const oneYearAgo = now - 365 * 24 * 3600 * 1000;
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: oneYearAgo,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试年份差异
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{ $dateDiff: [now, { '#attr': 'refreshedAt' }, 'y'] },
|
||
1
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `$dateDiff year failed`);
|
||
|
||
// 测试月份差异
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{ $dateDiff: [now, { '#attr': 'refreshedAt' }, 'M'] },
|
||
11
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `$dateDiff month failed`);
|
||
});
|
||
|
||
it('[6.5]$dateFloor with different units', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 2024-06-15 14:30:45.123
|
||
const specificDate = new Date('2024-06-15T14:30:45.123Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificDate,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
//TODO: 暂不支持
|
||
// // 测试向下取整到月 - 应该是 2024-06-01
|
||
const startOfMonth = new Date('2024-06-01T00:00:00.000Z').valueOf();
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{ $dateFloor: [{ '#attr': 'refreshedAt' }, 'M'] },
|
||
startOfMonth
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `$dateFloor month failed`);
|
||
|
||
// 测试向下取整到年 - 应该是 2024-01-01
|
||
const startOfYear = new Date('2024-01-01T00:00:00.000Z').valueOf();
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$gte: [
|
||
{ $dateFloor: [{ '#attr': 'refreshedAt' }, 'y'] },
|
||
startOfYear
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `$dateFloor year failed`);
|
||
});
|
||
|
||
// TODO: 暂不支持
|
||
it('[6.6]$dateCeil with different units', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
// 2024-06-15 14:30:45.123
|
||
const specificDate = new Date('2024-06-15T14:30:45.123Z').valueOf();
|
||
const id1 = v4();
|
||
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: specificDate,
|
||
value: v4(),
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试向上取整到月 - 应该是 2024-07-01
|
||
const startOfNextMonth = new Date('2024-07-01T00:00:00.000Z').valueOf();
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$lte: [
|
||
{ $dateCeil: [{ '#attr': 'refreshedAt' }, 'M'] },
|
||
startOfNextMonth
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `$dateCeil month failed`);
|
||
|
||
// 测试向上取整到年 - 应该是 2025-01-01
|
||
const startOfNextYear = new Date('2025-01-01T00:00:00.000Z').valueOf();
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$lte: [
|
||
{ $dateCeil: [{ '#attr': 'refreshedAt' }, 'y'] },
|
||
startOfNextYear
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1, `$dateCeil year failed`);
|
||
});
|
||
|
||
// ==================== 聚合函数测试 ====================
|
||
|
||
it('[7.1]aggregation $$count', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId = v4();
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: systemId,
|
||
name: 'test-count',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/test',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app1', description: 't1', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app2', description: 't2', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app3', description: 't3', type: 'wechatMp', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
}
|
||
} as EntityDict['system']['CreateSingle'], context, {});
|
||
await context.commit();
|
||
|
||
const result = await store.aggregate('application', {
|
||
data: {
|
||
'#aggr': { systemId: 1 },
|
||
'#count-1': { id: 1 }
|
||
},
|
||
filter: { systemId }
|
||
}, context, {});
|
||
|
||
assert(result.length === 1, `Expected 1 group`);
|
||
assert(result[0]['#count-1'] === 3, `Expected count 3, got ${result[0]['#count-1']}`);
|
||
});
|
||
|
||
// TODO: 下面聚合暂不支持
|
||
// it('[7.2]aggregation $$sum', async () => {
|
||
// const context = new TestContext(store);
|
||
// await context.begin();
|
||
|
||
// const areaId = v4();
|
||
// await store.operate('house', {
|
||
// id: v4(),
|
||
// action: 'create',
|
||
// data: [
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 100.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 150.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 200.0 },
|
||
// ]
|
||
// }, context, {});
|
||
// await context.commit();
|
||
|
||
// const result = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': { areaId: 1 },
|
||
// '#sum-1': { $$sum: { '#attr': 'size' } }
|
||
// },
|
||
// filter: { areaId }
|
||
// }, context, {});
|
||
|
||
// assert(result.length === 1, `Expected 1 group`);
|
||
// assert(result[0]['#sum-1'] === 450, `Expected sum 450, got ${result[0]['#sum-1']}`);
|
||
// });
|
||
|
||
// it('[7.3]aggregation $$max $$min', async () => {
|
||
// const context = new TestContext(store);
|
||
// await context.begin();
|
||
|
||
// const areaId = v4();
|
||
// await store.operate('house', {
|
||
// id: v4(),
|
||
// action: 'create',
|
||
// data: [
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 80.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 120.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 200.0 },
|
||
// ]
|
||
// }, context, {});
|
||
// await context.commit();
|
||
|
||
// const result = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': { areaId: 1 },
|
||
// '#max-1': { $$max: { '#attr': 'size' } },
|
||
// '#min-1': { $$min: { '#attr': 'size' } }
|
||
// },
|
||
// filter: { areaId }
|
||
// }, context, {});
|
||
|
||
// assert(result.length === 1, `Expected 1 group`);
|
||
// assert(result[0]['#max-1'] === 200, `Expected max 200, got ${result[0]['#max-1']}`);
|
||
// assert(result[0]['#min-1'] === 80, `Expected min 80, got ${result[0]['#min-1']}`);
|
||
// });
|
||
|
||
// it('[7.4]aggregation $$avg', async () => {
|
||
// const context = new TestContext(store);
|
||
// await context.begin();
|
||
|
||
// const areaId = v4();
|
||
// await store.operate('house', {
|
||
// id: v4(),
|
||
// action: 'create',
|
||
// data: [
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 100.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 200.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 300.0 },
|
||
// ]
|
||
// }, context, {});
|
||
// await context.commit();
|
||
|
||
// const result = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': { areaId: 1 },
|
||
// '#avg-1': { $$avg: { '#attr': 'size' } }
|
||
// },
|
||
// filter: { areaId }
|
||
// }, context, {});
|
||
|
||
// assert(result.length === 1, `Expected 1 group`);
|
||
// assert(result[0]['#avg-1'] === 200, `Expected avg 200, got ${result[0]['#avg-1']}`);
|
||
// });
|
||
|
||
// it('[7.5]aggregation with multiple groups', async () => {
|
||
// const context = new TestContext(store);
|
||
// await context.begin();
|
||
|
||
// const areaId = v4();
|
||
// await store.operate('house', {
|
||
// id: v4(),
|
||
// action: 'create',
|
||
// data: [
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 100.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '杭州', size: 150.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '上海', size: 200.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '上海', size: 300.0 },
|
||
// { id: v4(), areaId, ownerId: v4(), district: '北京', size: 250.0 },
|
||
// ]
|
||
// }, context, {});
|
||
// await context.commit();
|
||
|
||
// const result = await store.aggregate('house', {
|
||
// data: {
|
||
// '#aggr': { district: 1 },
|
||
// '#count-1': { id: 1 },
|
||
// '#sum-1': { $$sum: { '#attr': 'size' } },
|
||
// '#avg-1': { $$avg: { '#attr': 'size' } }
|
||
// },
|
||
// filter: { areaId }
|
||
// }, context, {});
|
||
|
||
// assert(result.length === 3, `Expected 3 groups, got ${result.length}`);
|
||
|
||
// const hz = result.find(r => r['#data']?.district === '杭州');
|
||
// const sh = result.find(r => r['#data']?.district === '上海');
|
||
// const bj = result.find(r => r['#data']?.district === '北京');
|
||
|
||
// assert(hz && hz['#count-1'] === 2 && hz['#sum-1'] === 250, `杭州 aggregation failed`);
|
||
// assert(sh && sh['#count-1'] === 2 && sh['#sum-1'] === 500, `上海 aggregation failed`);
|
||
// assert(bj && bj['#count-1'] === 1 && bj['#sum-1'] === 250, `北京 aggregation failed`);
|
||
// });
|
||
|
||
// ==================== 复合表达式测试 ====================
|
||
|
||
it('[8.1]nested math expressions', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 100.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试嵌套表达式: size * 2 + 50 / 5 = 210
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: {
|
||
id: id1,
|
||
$expr: {
|
||
$eq: [
|
||
{
|
||
$divide: [
|
||
{
|
||
$add: [
|
||
{ $multiply: [{ '#attr': 'size' }, 2] },
|
||
50
|
||
]
|
||
},
|
||
5
|
||
]
|
||
},
|
||
210
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1, `Nested math expression failed`);
|
||
});
|
||
|
||
it('[8.2]complex logic with date and math', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const now = Date.now();
|
||
const twoDaysAgo = now - 2 * 24 * 3600 * 1000;
|
||
const fiveDaysAgo = now - 5 * 24 * 3600 * 1000;
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
await store.operate('token', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: twoDaysAgo,
|
||
value: v4(),
|
||
},
|
||
{
|
||
id: id2,
|
||
env: { type: 'web' } as any,
|
||
applicationId: v4(),
|
||
userId: v4(),
|
||
playerId: v4(),
|
||
entity: 'mobile',
|
||
entityId: v4(),
|
||
refreshedAt: fiveDaysAgo,
|
||
value: v4(),
|
||
}
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 查询: 刷新时间在3天内 OR 刷新时间超过4天
|
||
const r1 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$or: [
|
||
{
|
||
$lt: [
|
||
{ $dateDiff: [now, { '#attr': 'refreshedAt' }, 'd'] },
|
||
3
|
||
]
|
||
},
|
||
{
|
||
$gt: [
|
||
{ $dateDiff: [now, { '#attr': 'refreshedAt' }, 'd'] },
|
||
4
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 2, `Complex logic failed, expected 2, got ${r1.length}`);
|
||
|
||
// 查询: 刷新时间在3天到4天之间
|
||
const r2 = await context.select('token', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
$expr: {
|
||
$and: [
|
||
{
|
||
$gte: [
|
||
{ $dateDiff: [now, { '#attr': 'refreshedAt' }, 'd'] },
|
||
3
|
||
]
|
||
},
|
||
{
|
||
$lte: [
|
||
{ $dateDiff: [now, { '#attr': 'refreshedAt' }, 'd'] },
|
||
4
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 0, `Complex logic failed, expected 0, got ${r2.length}`);
|
||
});
|
||
|
||
it('[8.3]expression with cross-entity reference', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId = v4();
|
||
const appId1 = v4();
|
||
const appId2 = v4();
|
||
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: systemId,
|
||
name: 'parent_system',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/test',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: appId1,
|
||
name: 'parent_app1',
|
||
description: 't1',
|
||
type: 'web',
|
||
config: { type: 'web', passport: [] } as any
|
||
}
|
||
},
|
||
{
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: appId2,
|
||
name: 'child_app',
|
||
description: 't2',
|
||
type: 'web',
|
||
config: { type: 'web', passport: [] } as any
|
||
}
|
||
}
|
||
]
|
||
}
|
||
} as EntityDict['system']['CreateSingle'], context, {});
|
||
await context.commit();
|
||
|
||
// TODO: 这里有问题
|
||
// // 查询: application.name 以 system.name 的前缀开头
|
||
const r1 = await context.select('application', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
system: { id: 1, name: 1 }
|
||
},
|
||
filter: {
|
||
systemId,
|
||
$expr: {
|
||
$startsWith: [
|
||
{ '#attr': 'name' },
|
||
{
|
||
'#refAttr': 'name',
|
||
'#refId': 'node-1'
|
||
}
|
||
]
|
||
},
|
||
system: {
|
||
'#id': 'node-1'
|
||
}
|
||
}
|
||
}, {});
|
||
|
||
assert(r1.length === 1 && r1[0].id === appId1, `Cross-entity expression failed`);
|
||
});
|
||
|
||
// ==================== JSON 操作符补充测试 ====================
|
||
|
||
it('[9.1]json $exists operator', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
|
||
await store.operate('oper', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
action: 'test1',
|
||
data: { name: 'xc', age: 25 },
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
},
|
||
{
|
||
id: id2,
|
||
action: 'test2',
|
||
data: { name: 'zz' }, // 没有 age 字段
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
}
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $exists: true - 检查 age 字段存在
|
||
const r1 = await context.select('oper', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
data: { age: { $exists: true } }
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id1, `$exists true failed`);
|
||
|
||
// 测试 $exists: false - 检查 age 字段不存在
|
||
const r2 = await context.select('oper', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
data: { age: { $exists: false } }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].id === id2, `$exists false failed`);
|
||
|
||
// 暂不支持这种写法
|
||
// 测试 $exists: 'keyName' - 检查 JSON 对象是否包含指定键
|
||
// const r3 = await context.select('oper', {
|
||
// data: { id: 1 },
|
||
// filter: {
|
||
// id: { $in: [id1, id2] },
|
||
// data: { $exists: 'age' }
|
||
// }
|
||
// }, {});
|
||
// assert(r3.length === 1 && r3[0].id === id1, `$exists keyName failed`);
|
||
});
|
||
|
||
it('[9.2]json nested $and $or in filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
|
||
await store.operate('oper', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
action: 'test1',
|
||
data: { name: 'alice', role: 'admin', level: 10 },
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
},
|
||
{
|
||
id: id2,
|
||
action: 'test2',
|
||
data: { name: 'bob', role: 'user', level: 5 },
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
},
|
||
{
|
||
id: id3,
|
||
action: 'test3',
|
||
data: { name: 'charlie', role: 'admin', level: 3 },
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
}
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试: (role = 'admin' AND level > 5) OR (role = 'user')
|
||
const r1 = await context.select('oper', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2, id3] },
|
||
data: {
|
||
$or: [
|
||
{
|
||
$and: [
|
||
{ role: 'admin' },
|
||
{ level: { $gt: 5 } }
|
||
]
|
||
},
|
||
{ role: 'user' }
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 2, `Nested $and $or failed, expected 2, got ${r1.length}`);
|
||
const ids = r1.map(r => r.id);
|
||
assert(ids.includes(id1) && ids.includes(id2), `Expected id1 and id2`);
|
||
});
|
||
|
||
it('[9.3]json array index access in filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
|
||
await store.operate('oper', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: id1,
|
||
action: 'test1',
|
||
data: { scores: [90, 85, 95] },
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
},
|
||
{
|
||
id: id2,
|
||
action: 'test2',
|
||
data: { scores: [70, 75, 80] },
|
||
targetEntity: 'test',
|
||
bornAt: Date.now(),
|
||
}
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试数组第一个元素 > 80
|
||
const r1 = await context.select('oper', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
data: {
|
||
scores: [{ $gt: 80 }]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id1, `Array index filter failed`);
|
||
|
||
// 测试数组第三个元素 = 95
|
||
const r2 = await context.select('oper', {
|
||
data: { id: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
data: {
|
||
scores: [undefined, undefined, 95]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].id === id1, `Array specific index filter failed`);
|
||
});
|
||
|
||
// ==================== $mod 运算符测试 ====================
|
||
|
||
it('[10.1]math expression $mod', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, name: 'user1', nickname: 'n1' },
|
||
{ id: id2, name: 'user2', nickname: 'n2' },
|
||
{ id: id3, name: 'user3', nickname: 'n3' },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 $mod: $$seq$$ % 2 = 0 (偶数序列号)
|
||
const r1 = await context.select('user', {
|
||
data: { id: 1, $$seq$$: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2, id3] },
|
||
$expr: {
|
||
$eq: [
|
||
{ $mod: [{ '#attr': '$$seq$$' }, 2] },
|
||
0
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
// 偶数序列号的数量取决于插入顺序，这里只检查查询能正常执行
|
||
assert(r1.length >= 0, `$mod expression failed`);
|
||
|
||
// 测试 $mod: $$seq$$ % 3 = 1
|
||
const r2 = await context.select('user', {
|
||
data: { id: 1, $$seq$$: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2, id3] },
|
||
$expr: {
|
||
$eq: [
|
||
{ $mod: [{ '#attr': '$$seq$$' }, 3] },
|
||
1
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r2.length >= 0, `$mod with 3 failed`);
|
||
});
|
||
|
||
// ==================== 字符串 $startsWith 在表达式中测试 ====================
|
||
|
||
it('[10.2]string $startsWith in expression', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, name: 'test_admin', nickname: 'test' },
|
||
{ id: id2, name: 'test_user', nickname: 'test' },
|
||
{ id: id3, name: 'admin_role', nickname: 'admin1' },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 测试 name 以 nickname 开头
|
||
const r1 = await context.select('user', {
|
||
data: { id: 1, name: 1, nickname: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2, id3] },
|
||
$expr: {
|
||
$startsWith: [
|
||
{ '#attr': 'name' },
|
||
{ '#attr': 'nickname' }
|
||
]
|
||
}
|
||
}
|
||
}, {});
|
||
assert(r1.length === 2, `$startsWith with two attrs failed, expected 2, got ${r1.length}`);
|
||
const ids = r1.map(r => r.id);
|
||
assert(ids.includes(id1) && ids.includes(id2), `Expected id1 and id2`);
|
||
});
|
||
|
||
// ==================== 投影中的表达式测试 ====================
|
||
|
||
it('[11.1]expression in projection', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 100.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 在投影中使用表达式计算 size * 2
|
||
const r1 = await context.select('house', {
|
||
data: {
|
||
id: 1,
|
||
size: 1,
|
||
$expr: {
|
||
$multiply: [{ '#attr': 'size' }, 2]
|
||
}
|
||
},
|
||
filter: { id: id1 }
|
||
}, {});
|
||
|
||
assert(r1.length === 1, `Expression in projection failed`);
|
||
assert(r1[0].$expr == 200, `Expected $expr = 200, got ${r1[0].$expr}`);
|
||
});
|
||
|
||
it('[11.2]multiple expressions in projection', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 100.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 多个表达式在投影中
|
||
const r1 = await context.select('house', {
|
||
data: {
|
||
id: 1,
|
||
size: 1,
|
||
$expr1: {
|
||
$multiply: [{ '#attr': 'size' }, 2]
|
||
},
|
||
$expr2: {
|
||
$add: [{ '#attr': 'size' }, 50]
|
||
},
|
||
$expr3: {
|
||
$gt: [{ '#attr': 'size' }, 80]
|
||
}
|
||
},
|
||
filter: { id: id1 }
|
||
}, {});
|
||
|
||
assert(r1.length === 1, `Multiple expressions failed`);
|
||
assert(r1[0].$expr1 == 200, `Expected $expr1 = 200`);
|
||
assert(r1[0].$expr2 == 150, `Expected $expr2 = 150`);
|
||
assert(r1[0].$expr3 == true || r1[0].$expr3 == 1, `Expected $expr3 = true`);
|
||
});
|
||
|
||
// ==================== 子查询中的表达式测试 ====================
|
||
|
||
it('[12.1]expression in subquery filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId1 = v4();
|
||
const systemId2 = v4();
|
||
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: systemId1,
|
||
name: 'system_a',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/a',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app_a1', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app_a2', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
},
|
||
{
|
||
id: systemId2,
|
||
name: 'system_b',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/b',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'other_b1', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
}
|
||
]
|
||
} as EntityDict['system']['CreateMulti'], context, {});
|
||
await context.commit();
|
||
|
||
// 查询: 存在以 'app_' 开头的 application 的 system
|
||
const r1 = await context.select('system', {
|
||
data: { id: 1, name: 1 },
|
||
filter: {
|
||
id: { $in: [systemId1, systemId2] },
|
||
application$system: {
|
||
name: { $startsWith: 'app_' }
|
||
}
|
||
}
|
||
}, {});
|
||
|
||
assert(r1.length === 1 && r1[0].id === systemId1, `Subquery with expression failed`);
|
||
});
|
||
|
||
// ==================== 排序中使用表达式 ====================
|
||
|
||
it('[13.1]sorter with expression', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
const id3 = v4();
|
||
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, areaId: v4(), ownerId: v4(), district: '杭州', size: 150.0 },
|
||
{ id: id2, areaId: v4(), ownerId: v4(), district: '上海', size: 100.0 },
|
||
{ id: id3, areaId: v4(), ownerId: v4(), district: '北京', size: 200.0 },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 按 size 降序排列
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: { id: { $in: [id1, id2, id3] } },
|
||
sorter: [
|
||
{ $attr: { size: 1 }, $direction: 'desc' }
|
||
]
|
||
}, {});
|
||
|
||
assert(r1.length === 3, `Sorter failed`);
|
||
assert(r1[0].id === id3, `Expected first to be id3 (size 200)`);
|
||
assert(r1[1].id === id1, `Expected second to be id1 (size 150)`);
|
||
assert(r1[2].id === id2, `Expected third to be id2 (size 100)`);
|
||
});
|
||
|
||
// ==================== 分页测试 ====================
|
||
|
||
it('[14.1]pagination with indexFrom and count', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const ids: string[] = [];
|
||
const data = [] as any[];
|
||
for (let i = 0; i < 10; i++) {
|
||
const id = v4();
|
||
ids.push(id);
|
||
data.push({
|
||
id,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: `district_${i}`,
|
||
size: (i + 1) * 10.0,
|
||
});
|
||
}
|
||
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 获取第 3-5 条记录 (indexFrom=2, count=3)
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: { id: { $in: ids } },
|
||
sorter: [{ $attr: { size: 1 }, $direction: 'asc' }],
|
||
indexFrom: 2,
|
||
count: 3,
|
||
}, {});
|
||
|
||
assert(r1.length === 3, `Pagination failed, expected 3, got ${r1.length}`);
|
||
assert(r1[0].size === 30, `Expected first size 30, got ${r1[0].size}`);
|
||
assert(r1[1].size === 40, `Expected second size 40, got ${r1[1].size}`);
|
||
assert(r1[2].size === 50, `Expected third size 50, got ${r1[2].size}`);
|
||
|
||
// 获取最后 2 条
|
||
const r2 = await context.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: { id: { $in: ids } },
|
||
sorter: [{ $attr: { size: 1 }, $direction: 'asc' }],
|
||
indexFrom: 8,
|
||
count: 5, // 超出范围
|
||
}, {});
|
||
|
||
assert(r2.length === 2, `Pagination overflow failed, expected 2, got ${r2.length}`);
|
||
});
|
||
|
||
// ==================== FOR UPDATE 锁测试 ====================
|
||
|
||
it('[15.1]select for update', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 100.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
await context.begin();
|
||
// FOR UPDATE 查询
|
||
const r1 = await store.select('house', {
|
||
data: { id: 1, size: 1 },
|
||
filter: { id: id1 }
|
||
}, context, { forUpdate: true });
|
||
|
||
assert(r1.length === 1, `FOR UPDATE select failed`);
|
||
await context.commit();
|
||
});
|
||
|
||
// ==================== includedDeleted 选项测试 ====================
|
||
|
||
it('[16.1]select with includedDeleted option', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 100.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 删除记录
|
||
await context.begin();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'remove',
|
||
data: {},
|
||
filter: { id: id1 }
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 正常查询应该查不到
|
||
const r1 = await context.select('house', {
|
||
data: { id: 1 },
|
||
filter: { id: id1 }
|
||
}, {});
|
||
assert(r1.length === 0, `Deleted record should not be visible`);
|
||
|
||
// 使用 includedDeleted 应该能查到
|
||
const r2 = await store.select('house', {
|
||
data: { id: 1 },
|
||
filter: { id: id1 }
|
||
}, context, { includedDeleted: true });
|
||
assert(r2.length === 1, `includedDeleted should show deleted record`);
|
||
});
|
||
|
||
// ==================== 物理删除测试 ====================
|
||
|
||
it('[16.2]delete physically', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: id1,
|
||
areaId: v4(),
|
||
ownerId: v4(),
|
||
district: '杭州',
|
||
size: 100.0,
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// TODO: 暂不支持物理删除测试
|
||
// 物理删除
|
||
await context.begin();
|
||
await store.operate('house', {
|
||
id: v4(),
|
||
action: 'remove',
|
||
data: {},
|
||
filter: { id: id1 }
|
||
}, context, { deletePhysically: true });
|
||
await context.commit();
|
||
|
||
// 即使使用 includedDeleted 也查不到
|
||
const r1 = await store.select('house', {
|
||
data: { id: 1 },
|
||
filter: { id: id1 }
|
||
}, context, { includedDeleted: true });
|
||
assert(r1.length === 0, `Physically deleted record should not exist`);
|
||
});
|
||
|
||
// ==================== 跨表 JOIN 更新测试 ====================
|
||
|
||
// TODO: 下面会出现死锁，暂不知道为什么
|
||
it('[17.1]update with join filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId = v4();
|
||
const appId1 = v4();
|
||
const appId2 = v4();
|
||
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: systemId,
|
||
name: 'join_test_system',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/test',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: appId1, name: 'join_app1', description: 'old', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
{ id: v4(), action: 'create', data: { id: appId2, name: 'join_app2', description: 'old', type: 'wechatMp', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
}
|
||
} as EntityDict['system']['CreateSingle'], context, {});
|
||
await context.commit();
|
||
|
||
// 通过 system 过滤更新 application
|
||
await context.begin();
|
||
await store.operate('application', {
|
||
id: v4(),
|
||
action: 'update',
|
||
data: { description: 'updated' },
|
||
filter: {
|
||
system: {
|
||
name: 'join_test_system'
|
||
},
|
||
type: 'web'
|
||
}
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 验证只更新了 type='web' 的记录
|
||
const r1 = await context.select('application', {
|
||
data: { id: 1, description: 1 },
|
||
filter: { id: appId1 }
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].description === 'updated', `Join update failed for appId1`);
|
||
|
||
const r2 = await context.select('application', {
|
||
data: { id: 1, description: 1 },
|
||
filter: { id: appId2 }
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].description === 'old', `Join update should not affect appId2`);
|
||
});
|
||
|
||
// ==================== 空值处理测试 ====================
|
||
|
||
// TODO: 空值会报错
|
||
it('[18.1]null value handling', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
|
||
await store.operate('user', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, name: 'user_with_ref', nickname: 'u1', refId: v4() },
|
||
{ id: id2, name: 'user_without_ref', nickname: 'u2' }, // refId 为 null
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 查询 refId 为 null 的记录
|
||
const r1 = await context.select('user', {
|
||
data: { id: 1, name: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
refId: null as any
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id2, `Null filter failed`);
|
||
|
||
// 查询 refId 不为 null 的记录
|
||
const r2 = await context.select('user', {
|
||
data: { id: 1, name: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
refId: { $ne: null as any }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 1 && r2[0].id === id1, `Not null filter failed`);
|
||
});
|
||
|
||
// ==================== 枚举类型测试 ====================
|
||
|
||
it('[19.1]enum type insert and filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const id1 = v4();
|
||
const id2 = v4();
|
||
|
||
await store.operate('application', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{ id: id1, name: 'web_app', description: 't', type: 'web', systemId: v4(), config: { type: 'web', passport: [] } as any },
|
||
{ id: id2, name: 'mp_app', description: 't', type: 'wechatMp', systemId: v4(), config: { type: 'web', passport: [] } as any },
|
||
]
|
||
}, context, {});
|
||
await context.commit();
|
||
|
||
// 按枚举值过滤
|
||
const r1 = await context.select('application', {
|
||
data: { id: 1, type: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
type: 'web'
|
||
}
|
||
}, {});
|
||
assert(r1.length === 1 && r1[0].id === id1, `Enum filter failed`);
|
||
|
||
// 枚举 $in 查询
|
||
const r2 = await context.select('application', {
|
||
data: { id: 1, type: 1 },
|
||
filter: {
|
||
id: { $in: [id1, id2] },
|
||
type: { $in: ['web', 'wechatMp'] }
|
||
}
|
||
}, {});
|
||
assert(r2.length === 2, `Enum $in filter failed`);
|
||
});
|
||
|
||
// ==================== 复杂嵌套查询测试 ====================
|
||
|
||
it('[20.1]deeply nested filter', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const platformId = v4();
|
||
const systemId = v4();
|
||
const appId = v4();
|
||
|
||
// 创建 platform -> system -> application 层级结构
|
||
await store.operate('platform', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: platformId,
|
||
name: 'test_platform',
|
||
description: 'test',
|
||
config: {} as any,
|
||
}
|
||
}, context, {});
|
||
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: {
|
||
id: systemId,
|
||
name: 'nested_system',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/test',
|
||
platformId,
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: appId, name: 'nested_app', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
}
|
||
} as EntityDict['system']['CreateSingle'], context, {});
|
||
await context.commit();
|
||
|
||
// 三层嵌套查询: application -> system -> platform
|
||
const r1 = await context.select('application', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
system: {
|
||
id: 1,
|
||
name: 1,
|
||
platform: {
|
||
id: 1,
|
||
name: 1,
|
||
}
|
||
}
|
||
},
|
||
filter: {
|
||
id: appId,
|
||
system: {
|
||
platform: {
|
||
name: 'test_platform'
|
||
}
|
||
}
|
||
}
|
||
}, {});
|
||
|
||
assert(r1.length === 1, `Deeply nested query failed`);
|
||
assert(r1[0].system?.platform?.name === 'test_platform', `Nested projection failed`);
|
||
});
|
||
|
||
// ==================== 聚合与普通查询组合测试 ====================
|
||
|
||
it('[20.2]select with nested aggregation', async () => {
|
||
const store = storeGetter();
|
||
const context = new TestContext(store);
|
||
await context.begin();
|
||
|
||
const systemId1 = v4();
|
||
const systemId2 = v4();
|
||
|
||
await store.operate('system', {
|
||
id: v4(),
|
||
action: 'create',
|
||
data: [
|
||
{
|
||
id: systemId1,
|
||
name: 'agg_system1',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/test1',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app1_1', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app1_2', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app1_3', description: 't', type: 'wechatMp', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
},
|
||
{
|
||
id: systemId2,
|
||
name: 'agg_system2',
|
||
description: 'test',
|
||
config: { App: {} },
|
||
folder: '/test2',
|
||
platformId: 'p1',
|
||
application$system: [
|
||
{ id: v4(), action: 'create', data: { id: v4(), name: 'app2_1', description: 't', type: 'web', config: { type: 'web', passport: [] } as any } },
|
||
]
|
||
}
|
||
]
|
||
} as EntityDict['system']['CreateMulti'], context, {});
|
||
await context.commit();
|
||
|
||
// 查询 system 并附带 application 聚合统计
|
||
const r1 = await context.select('system', {
|
||
data: {
|
||
id: 1,
|
||
name: 1,
|
||
application$system$$aggr: {
|
||
$entity: 'application',
|
||
data: {
|
||
'#aggr': { type: 1 },
|
||
'#count-1': { id: 1 }
|
||
}
|
||
}
|
||
},
|
||
filter: {
|
||
id: { $in: [systemId1, systemId2] }
|
||
}
|
||
}, {});
|
||
|
||
assert(r1.length === 2, `Nested aggregation query failed`);
|
||
|
||
const sys1 = r1.find(s => s.id === systemId1);
|
||
assert(sys1, `System1 not found`);
|
||
assert(sys1.application$system$$aggr && sys1.application$system$$aggr.length === 2, `System1 should have 2 type groups`);
|
||
|
||
const webCount = sys1.application$system$$aggr.find((a: any) => a['#data']?.type === 'web');
|
||
assert(webCount && webCount['#count-1'] === 2, `System1 web count should be 2`);
|
||
});
|
||
|
||
} |