vona-module-test-vona 5.0.38 → 5.0.41

package/src/service/post.ts

@@ -0,0 +1,219 @@
+import type { TableIdentity } from 'table-identity';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Database } from 'vona-module-a-orm';
+
+@Service()
+export class ServicePost extends BeanBase {
+  async relationBelongsTo() {
+    const postContent = await this.scope.model.postContent.select({
+      include: {
+        post: true,
+      },
+    });
+    console.log(postContent[0]?.post?.title);
+  }
+
+  async relationHasOne() {
+    // insert
+    const postCreate = await this.scope.model.post.insert(
+      {
+        title: 'Post001',
+        postContent: {
+          content: 'This is a post',
+        },
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    // get
+    const post = await this.scope.model.post.get(
+      {
+        id: postCreate.id,
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    // update
+    await this.scope.model.post.update(
+      {
+        id: postCreate.id,
+        title: 'Post001-Update',
+        postContent: {
+          content: 'This is a post-changed',
+        },
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    // delete
+    await this.scope.model.post.delete(
+      {
+        id: postCreate.id,
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    console.log(post?.postContent?.id);
+  }
+
+  @Database.transaction()
+  async transaction() {
+    // insert
+    const post = await this.scope.model.post.insert({
+      title: 'Post001',
+    });
+    // cache
+    await this.scope.cacheRedis.post.set(post, post.id);
+  }
+
+  async transactionManually() {
+    const db = this.bean.database.getDb({ clientName: 'default' });
+    await db.transaction.begin(async () => {
+      const modelPost = this.scope.model.post.newInstance(db);
+      const post = await modelPost.insert({ title: 'Post001' });
+      await this.scope.cacheRedis.post.set(post, post.id, { db });
+    });
+  }
+
+  async create() {
+    const post = await this.scope.model.post.insert({
+      title: 'Post001',
+    });
+    // console.log(post.id);
+    return post;
+  }
+
+  async createBulk() {
+    const posts = await this.scope.model.post.insertBulk([
+      { title: 'Post001' },
+      { title: 'Post002' },
+    ]);
+    // console.log(posts[0].id, posts[1].id);
+    return posts;
+  }
+
+  async update() {
+    const post = await this.scope.model.post.update({
+      id: 1,
+      title: 'Post001-Update',
+    });
+    return post;
+  }
+
+  async update2() {
+    const post = await this.scope.model.post.update(
+      {
+        title: 'Post001-Update',
+      },
+      {
+        where: {
+          title: { _startsWith_: 'Post001' },
+        },
+      },
+    );
+    return post;
+  }
+
+  async updateBulk() {
+    const posts = await this.scope.model.post.updateBulk([
+      { id: 1, title: 'Post001-Update' },
+      { id: 2, title: 'Post002-Update' },
+    ]);
+    return posts;
+  }
+
+  async delete() {
+    await this.scope.model.post.delete({
+      id: 1,
+    });
+  }
+
+  async delete2() {
+    await this.scope.model.post.delete({
+      title: {
+        _startsWith_: 'Post',
+      },
+    });
+  }
+
+  async deleteBulk() {
+    await this.scope.model.post.deleteBulk([1, 2]);
+  }
+
+  async mutate() {
+    // insert
+    const post = await this.scope.model.post.mutate({
+      title: 'Post001',
+    });
+    // update
+    await this.scope.model.post.mutate({
+      id: post.id,
+      title: 'Post001-Update',
+    });
+    // delete
+    await this.scope.model.post.mutate({
+      id: post.id,
+      deleted: true,
+    });
+  }
+
+  async mutateBulk() {
+    await this.scope.model.post.mutateBulk([
+      // insert
+      { title: 'Post003' },
+      // update
+      { id: 1, title: 'Post001-Update' },
+      // delete
+      { id: 2, deleted: true },
+    ]);
+  }
+
+  async select() {
+    return await this.scope.model.post.select({
+      where: {
+        stars: '_skip_',
+      },
+    });
+  }
+
+  async select2() {
+    return await this.scope.model.post.select({
+      columns: ['id', 'title', 'userId'],
+      where: {
+        'id': { _gt_: 1 },
+        'testVonaUser.id': 1,
+      },
+      joins: [['innerJoin', 'testVonaUser', ['userId', 'testVonaUser.id']]],
+      offset: 0,
+      limit: 20,
+      orders: [['createdAt', 'desc']],
+    }, {
+      disableDeleted: false,
+    }, 'test-vona:user');
+  }
+
+  async get(id: TableIdentity) {
+    return await this.scope.model.post.get({ id });
+  }
+
+  async mget(ids: TableIdentity[]) {
+    return await this.scope.model.post.mget(ids);
+  }
+
+  async count() {
+    return await this.scope.model.post.count();
+  }
+}

package/src/service/test.ts

@@ -0,0 +1,9 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceTest extends BeanBase {
+  get name() {
+    return 'serviceTest';
+  }
+}

package/src/service/testApp.ts

@@ -0,0 +1,13 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceTestApp extends BeanBase {
+  actionSync({ a, b }: any) {
+    return a + b;
+  }
+
+  async actionAsync({ a, b }: any) {
+    return Promise.resolve(a + b);
+  }
+}

package/src/service/testClass.ts

@@ -0,0 +1,15 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+class ClassBeanBase extends BeanBase {
+  actionSync({ a, b }: any) {
+    return a + b;
+  }
+}
+
+@Service()
+export class ServiceTestClass extends ClassBeanBase {
+  async actionAsync({ a, b }: any) {
+    return Promise.resolve(a + b);
+  }
+}

package/src/service/testData.ts

@@ -0,0 +1,67 @@
+import type { EntityRole } from 'vona-module-home-user';
+import type { EntityPost } from '../entity/post.ts';
+import type { EntityPostContent } from '../entity/postContent.ts';
+import type { EntityUser } from '../entity/user.ts';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+export interface ITestData {
+  userTom: EntityUser;
+  userJimmy: EntityUser;
+  roleFamily: EntityRole;
+  roleFriend: EntityRole;
+  postApple: EntityPost;
+  postPear: EntityPost;
+  postContentApple: EntityPostContent;
+}
+
+@Service()
+export class ServiceTestData extends BeanBase {
+  async create(prefix: string): Promise<ITestData> {
+    const scopeTest = this.scope;
+    const userTom = await scopeTest.model.user.insert({ name: `${prefix}:tom` });
+    const userJimmy = await scopeTest.model.user.insert({ name: `${prefix}:jimmy` });
+    const roleFamily = await scopeTest.model.role.insert({ name: `${prefix}:family` });
+    const roleFriend = await scopeTest.model.role.insert({ name: `${prefix}:friend` });
+    await scopeTest.model.roleUser.insertBulk([
+      { userId: userTom.id, roleId: roleFamily.id },
+      { userId: userTom.id, roleId: roleFriend.id },
+      { userId: userJimmy.id, roleId: roleFamily.id },
+    ]);
+    const postApple = await scopeTest.model.post.insert({ title: `${prefix}:postApple`, userId: userTom.id });
+    const postPear = await scopeTest.model.post.insert({ title: `${prefix}:postPear`, userId: userTom.id });
+    const postContentApple = await scopeTest.model.postContent.insert({ content: `${prefix}:postContentApple`, postId: postApple.id });
+    // ok
+    return {
+      userTom,
+      userJimmy,
+      roleFamily,
+      roleFriend,
+      postApple,
+      postPear,
+      postContentApple,
+    };
+  }
+
+  async drop(data: ITestData) {
+    const {
+      userTom,
+      userJimmy,
+      roleFamily,
+      roleFriend,
+      postApple,
+      postPear,
+      postContentApple,
+    } = data;
+    const scopeTest = this.scope;
+    await scopeTest.model.postContent.delete({ id: postContentApple.id });
+    await scopeTest.model.post.delete({ id: postApple.id });
+    await scopeTest.model.post.delete({ id: postPear.id });
+    await scopeTest.model.roleUser.delete({ userId: userTom.id });
+    await scopeTest.model.roleUser.delete({ userId: userJimmy.id });
+    await scopeTest.model.role.delete({ id: roleFamily.id });
+    await scopeTest.model.role.delete({ id: roleFriend.id });
+    await scopeTest.model.user.delete({ id: userTom.id });
+    await scopeTest.model.user.delete({ id: userJimmy.id });
+  }
+}

package/src/service/transaction.ts

@@ -0,0 +1,20 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Database } from 'vona-module-a-orm';
+
+const tableNameFail = '__tempTransactionFail';
+const tableNameSuccess = '__tempTransactionSuccess';
+
+@Service()
+export class ServiceTransaction extends BeanBase {
+  @Database.transaction()
+  async fail(item: object) {
+    await this.bean.model.update(`${tableNameFail}` as any, item);
+    await this.bean.model.update(`${tableNameFail}error` as any, item);
+  }
+
+  @Database.transaction()
+  async success(item: object) {
+    await this.bean.model.update(tableNameSuccess as any, item);
+  }
+}

package/test/aopMethod.test.ts

@@ -0,0 +1,21 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('aopMethod.test.ts', () => {
+  it('action:aopMethod', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      let result = scopeTest.service.aopMethod.testSyncBase();
+      assert.equal(result, '-+hello+-');
+      result = scopeTest.service.aopMethod.testSync();
+      assert.equal(result, '-+hello+-');
+      result = await scopeTest.service.aopMethod.testAsync();
+      assert.equal(result, '-+hello+-');
+      scopeTest.service.aopMethod.name = '-+vona+-';
+      result = scopeTest.service.aopMethod.name;
+      assert.equal(result, '-+vona+-');
+    });
+  });
+});

package/test/authSimple.test.ts

@@ -0,0 +1,45 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('authSimple.test.ts', () => {
+  it('action:passwordHash', async () => {
+    const scope = app.bean.scope('a-authsimple');
+    const password = '12344##1xxaasDFQ,.$';
+    const hash = await scope.service.authSimple.calcPasswordHash(password);
+    let verified = await scope.service.authSimple.verifyPasswordHash(password, hash);
+    assert.equal(verified, true);
+    verified = await scope.service.authSimple.verifyPasswordHash(`${password}failed`, hash);
+    assert.equal(verified, false);
+  });
+
+  it('action:authSimple', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // login
+      const jwt = await app.bean.auth.authenticate('a-authsimple:simple', {
+        clientName: 'default',
+        clientOptions: { username: 'admin', password: '123456' },
+      });
+      assert.equal(!!jwt?.accessToken, true);
+      // isAuthenticated: isolate
+      const [isAuthenticated2, _err] = await catchError(async () => {
+        return await app.bean.executor.newCtxIsolate(async () => {
+          return await app.bean.executor.performAction('get', '/test/vona/passport/isAuthenticated');
+        });
+      });
+      assert.equal(isAuthenticated2, undefined);
+      // isAuthenticated: isolate + header
+      const isAuthenticated = await app.bean.executor.newCtxIsolate(async () => {
+        return await app.bean.executor.performAction('get', '/test/vona/passport/isAuthenticated', { authToken: jwt?.accessToken });
+      });
+      assert.equal(isAuthenticated, true);
+      // login again
+      const jwt2 = await app.bean.authSimple.authenticate(
+        { username: 'admin', password: '123456' },
+        'default',
+      );
+      assert.equal(!!jwt2?.accessToken, true);
+    });
+  });
+});

package/test/bean.test.ts

@@ -0,0 +1,16 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('bean.test.ts', () => {
+  it('action:bean', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('get', '/test/vona/bean/test');
+    });
+  });
+
+  it('action:service', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('get', '/test/vona/bean/service');
+    });
+  });
+});

package/test/broadcast.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('broadcast.test.ts', () => {
+  it('action:broadcast', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      app.bean.scope('test-vona').broadcast.test.emit(
+        { message: 'hello' },
+        {
+          locale: 'zh-cn',
+        },
+      );
+      assert.equal(app.ctx.instanceName, '');
+    });
+  });
+});

package/test/cache/cacheMem.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('cacheMem.test.ts', () => {
+  it('action:cacheMem', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('post', '/test/vona/cacheMem');
+    });
+  });
+});

package/test/cache/cacheRedis.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('cacheRedis.test.ts', () => {
+  it('action:cacheRedis', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('post', '/test/vona/cacheRedis');
+    });
+  });
+});

package/test/cache/caching.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('caching.test.ts', () => {
+  it('action:caching', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scopeTest = app.bean.scope('test-vona');
+      // get: cacheKeyFn(string)
+      const res = await scopeTest.service.caching.get(2);
+      assert.equal(res.id, 2);
+      // get: cacheKeyFn(function)
+      const res2 = await scopeTest.service.caching.get2(2);
+      assert.equal(res.id, res2.id);
+      // get: cacheKey(celjs expression)
+      const res3 = await scopeTest.service.caching.get3(2);
+      assert.equal(res.id, res3.id);
+      // get: cacheKey(default)
+      const res4 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res4.id);
+      // get: cacheKey(default) not hit cache
+      const res5 = await scopeTest.service.caching.get4(5);
+      assert.equal(res5, undefined);
+      // set: cacheKeyFn/cacheValueFn
+      await scopeTest.service.caching.set(2, { ...res, name: `${res.name}!` });
+      // get again
+      const res6 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res6.id);
+      assert.equal(`${res.name}!`, res6.name);
+      // set: cacheKey/cacheValue
+      await scopeTest.service.caching.set2(2, { ...res, name: `${res.name}!` });
+      // get again
+      const res7 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res7.id);
+      assert.equal(`${res.name}!`, res7.name);
+      // set: no cacheValue/cacheValueFn
+      await scopeTest.service.caching.set3(2, { ...res, name: `${res.name}!` });
+      // get again
+      const res8 = await scopeTest.service.caching.get4(2);
+      assert.equal(res.id, res8.id);
+      assert.equal(`${res.name}!`, res8.name);
+      // del
+      await scopeTest.service.caching.del(2);
+      // get again
+      const res9 = await scopeTest.service.caching.get4(2);
+      assert.equal(res9, undefined);
+      // cache again
+      const res10 = await scopeTest.service.caching.get(2);
+      assert.equal(res10.id, 2);
+      const res11 = await scopeTest.service.caching.get4(2);
+      assert.equal(res11.id, 2);
+      // clear
+      await scopeTest.service.caching.clear();
+      const res12 = await scopeTest.service.caching.get4(2);
+      assert.equal(res12, undefined);
+    });
+  });
+});

package/test/cache/summer.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('summer.test.ts', () => {
+  it('action:summer', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('post', '/test/vona/summer');
+    });
+  });
+});

package/test/database/database.test.ts

@@ -0,0 +1,127 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import moment from 'moment';
+import { app } from 'vona-mock';
+
+describe('database.test.ts', () => {
+  it('action:database:switchClient', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scopeDatabase = app.bean.scope('a-orm');
+      const defaultClientName = scopeDatabase.service.database.getDefaultClientName();
+      // current
+      assert.equal(app.ctx.db.clientName, defaultClientName);
+      // switch
+      const clientNames = Object.keys(app.config.database.clients);
+      const clientName2 = clientNames.find(item => item !== defaultClientName);
+      await app.bean.database.switchDb(async () => {
+        assert.equal(app.ctx.db.clientName, clientName2);
+      }, { clientName: clientName2 as any });
+      // restore
+      assert.equal(app.ctx.db.clientName, defaultClientName);
+    });
+  });
+  it('action:model:clientName', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const modelTest = scopeTest.model.test;
+      assert.equal(modelTest.options.client, 'default');
+      const modelTest2 = scopeTest.model.test;
+      assert.equal(modelTest, modelTest2);
+    });
+  });
+  it('action:model:clientNameDynamic:transaction:fail', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = await scopeTest.model.test.insert({ title: 'clientNameDynamic:fail' });
+      assert.equal(entityTest.title, 'clientNameDynamic:fail');
+      await catchError(async () => {
+        const db = app.bean.database.getDb({ clientName: 'default' });
+        await db.transaction.begin(async () => {
+          const modelTest = scopeTest.model.test.newInstance(db);
+          assert.equal(modelTest.options.client, 'default');
+          await modelTest.update({ id: entityTest.id, title: 'clientNameDynamic:fail_1' });
+          throw new Error('rollback');
+        });
+      });
+      const entityTest2 = await scopeTest.model.test.get({ id: entityTest.id });
+      assert.equal(entityTest2?.title, 'clientNameDynamic:fail');
+      // delete
+      await scopeTest.model.test.delete({ id: entityTest.id });
+    });
+  });
+  it('action:model:clientNameDynamic:transaction:success', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = await scopeTest.model.test.insert({ title: 'clientNameDynamic:success' });
+      assert.equal(entityTest.title, 'clientNameDynamic:success');
+      const db = app.bean.database.getDb({ clientName: 'default' });
+      await db.transaction.begin(async () => {
+        const modelTest = scopeTest.model.test.newInstance(db);
+        assert.equal(modelTest.options.client, 'default');
+        await modelTest.update({ id: entityTest.id, title: 'clientNameDynamic:success_1' });
+      });
+      const entityTest2 = await scopeTest.model.test.get({ id: entityTest.id });
+      assert.equal(entityTest2?.title, 'clientNameDynamic:success_1');
+      // delete
+      await scopeTest.model.test.delete({ id: entityTest.id });
+    });
+  });
+  it('action:database:transaction:compensate', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = await scopeTest.model.test.insert({ title: 'transaction:compensate:fail' });
+      assert.equal(entityTest.title, 'transaction:compensate:fail');
+      await catchError(async () => {
+        const db = app.bean.database.getDb({ clientName: 'default' });
+        await db.transaction.begin(async () => {
+          const modelTest = scopeTest.model.test.newInstance(db);
+          assert.equal(modelTest.options.client, 'default');
+          await modelTest.update({ id: entityTest.id, title: 'transaction:compensate:fail_1' });
+          // let cache take effect
+          await modelTest.get({ id: entityTest.id });
+          throw new Error('rollback');
+        });
+      });
+      const entityTest2 = await scopeTest.model.test.get({ id: entityTest.id });
+      assert.equal(entityTest2?.title, 'transaction:compensate:fail');
+      // delete
+      await scopeTest.model.test.delete({ id: entityTest.id });
+    });
+  });
+  it('action:model:dynamicTableName', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const entityTest = scopeTest.entity.test;
+      const modelTest = scopeTest.model.testDynamicTable;
+      // tableName
+      const tableName = `${entityTest.$table}_${moment().format('YYYYMMDD')}`;
+      // create table
+      await app.bean.model.createTable(tableName, table => {
+        table.basicFields();
+        table.string(entityTest.title, 255);
+        table.string(entityTest.description, 255);
+      });
+      // insert
+      const item = await modelTest.insert({ title: 'title', description: 'description' });
+      // get
+      const item2 = await modelTest.get({ id: item.id });
+      assert.equal(item2?.id, item.id);
+      // get by tableName
+      const item3 = await app.bean.model.get(tableName as any, { id: item.id });
+      assert.equal(item3.id, item.id);
+      // delete
+      await modelTest.delete({ id: item.id });
+      // get by tableName
+      const item4 = await app.bean.model.get(tableName as any, { id: item.id });
+      assert.equal(item4, undefined);
+      // drop table
+      await app.bean.model.dropTable(tableName);
+    });
+  });
+});