vona-module-test-vona 5.0.38 → 5.0.41

package/test/database/modelRelationsMutate.test.ts

@@ -0,0 +1,354 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { $relationMutate } from 'vona-module-a-orm';
+import { ModelPost, ModelRole, ModelRoleUser } from 'vona-module-test-vona';
+
+describe('modelRelationsMutate.test.ts', () => {
+  it('action:modelRelationsMutate', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelRelationsMutate';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // insert: roles
+      const roles = await scopeTest.model.role.insertBulk([
+        { name: `${prefix}:family` },
+        { name: `${prefix}:friend` },
+      ]);
+      assert.equal(roles.length, 2);
+      assert.equal(roles[0].id !== undefined, true);
+      // insert: users
+      const users = await scopeTest.model.user.insertBulk([
+        {
+          name: `${prefix}:tom`,
+          posts: [{
+            title: `${prefix}:postApple`,
+            postContent: {
+              content: `${prefix}:postContentApple`,
+            },
+          }],
+          roles: [{
+            id: roles[0].id,
+          }],
+        },
+      ], {
+        include: {
+          posts: { include: { postContent: true } },
+          roles: true,
+        },
+      });
+      assert.equal(users.length, 1);
+      // check
+      const post = await scopeTest.model.post.get({ id: users[0].posts[0].id }, { include: { postContent: true } });
+      assert.equal(post?.postContent?.content, `${prefix}:postContentApple`);
+      // update: users
+      const _usersUpdate = await scopeTest.model.user.update({
+        id: users[0].id,
+        posts: [
+          // update
+          {
+            id: users[0].posts[0].id,
+            title: `${prefix}:postApple-update`,
+            // update
+            postContent: {
+              content: `${prefix}:postContentApple-update`,
+            },
+          },
+          // insert
+          {
+            title: `${prefix}:postPear`,
+            postContent: {
+              content: `${prefix}:postContentPear`,
+            },
+          },
+        ],
+        roles: [
+          // delete
+          { id: users[0].roles[0].id, deleted: true },
+          // insert
+          { id: roles[1].id },
+        ],
+      }, { include: {
+        posts: { include: { postContent: true } },
+        roles: true,
+      } });
+      // check
+      const usersUpdateCheck = await scopeTest.model.user.get({
+        id: users[0].id,
+      }, { include: {
+        posts: {
+          include: { postContent: true },
+          orders: [['id', 'asc']],
+        },
+        roles: true,
+      } });
+      assert.equal(usersUpdateCheck?.posts.length, 2);
+      assert.equal(usersUpdateCheck?.posts[0].title, `${prefix}:postApple-update`);
+      assert.equal(usersUpdateCheck?.posts[0].postContent?.content, `${prefix}:postContentApple-update`);
+      assert.equal(usersUpdateCheck?.posts[1].postContent?.content, `${prefix}:postContentPear`);
+      assert.equal(usersUpdateCheck?.roles.length, 1);
+      assert.equal(usersUpdateCheck?.roles[0].id, roles[1].id);
+      // mutate: users
+      const _usersMutate = await scopeTest.model.user.mutate({
+        id: users[0].id,
+        posts: [
+          // update
+          {
+            id: users[0].posts[0].id,
+            title: `${prefix}:postApple-mutate`,
+            // update
+            postContent: {
+              id: users[0].posts[0].postContent?.id,
+              content: `${prefix}:postContentApple-mutate`,
+            },
+          },
+        ],
+        roles: [
+          // delete
+          { id: roles[1].id, deleted: true },
+        ],
+      }, {
+        include: {
+          posts: { include: { postContent: true } },
+          roles: true,
+        },
+      });
+      // check
+      const usersMutateCheck = await scopeTest.model.user.get({
+        id: users[0].id,
+      }, { include: {
+        posts: {
+          include: { postContent: true },
+          orders: [['id', 'asc']],
+        },
+        roles: { columns: '*' as any },
+      } });
+      assert.equal(usersMutateCheck?.posts.length, 2);
+      assert.equal(usersMutateCheck?.posts[0].title, `${prefix}:postApple-mutate`);
+      assert.equal(usersMutateCheck?.posts[0].postContent?.content, `${prefix}:postContentApple-mutate`);
+      assert.equal(usersMutateCheck?.posts[1].postContent?.content, `${prefix}:postContentPear`);
+      assert.equal(usersMutateCheck?.roles.length, 0);
+      // delete: users
+      await scopeTest.model.user.deleteBulk(users.map(item => item.id), {
+        include: {
+          posts: { include: { postContent: true } },
+          roles: true,
+        },
+      });
+      const roleUsers = await scopeTest.model.roleUser.select({ where: { userId: users.map(item => item.id) } });
+      assert.equal(roleUsers.length, 0);
+      // delete: roles
+      await scopeTest.model.role.deleteBulk(roles.map(item => item.id));
+      const roles2 = await scopeTest.model.role.select({
+        where: {
+          id: roles.map(item => item.id!),
+        },
+      }, { disableDeleted: true });
+      assert.equal(roles2.length, 2);
+      assert.equal(roles2[0].id !== undefined, true);
+      assert.equal(roles2[0].deleted, true);
+    });
+  });
+
+  it('action:modelRelationsMutateWith', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelRelationsMutateWith';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // insert: roles
+      const roles = await scopeTest.model.role.insertBulk([
+        { name: `${prefix}:family` },
+        { name: `${prefix}:friend` },
+      ]);
+      assert.equal(roles.length, 2);
+      assert.equal(roles[0].id !== undefined, true);
+      // insert: users
+      const users = await scopeTest.model.user.insertBulk([
+        {
+          name: `${prefix}:tom`,
+          posts: [{
+            title: `${prefix}:postApple`,
+            postContent: {
+              content: `${prefix}:postContentApple`,
+            },
+          }],
+          roles: [{
+            id: roles[0].id,
+          }],
+        },
+      ], {
+        with: {
+          posts: $relationMutate.hasMany(ModelPost, 'userId', { include: { postContent: true } }),
+          roles: $relationMutate.belongsToMany(ModelRoleUser, ModelRole, 'userId', 'roleId'),
+        },
+      });
+      assert.equal(users.length, 1);
+      // check
+      const post = await scopeTest.model.post.get({ id: users[0].posts[0].id }, { include: { postContent: true } });
+      assert.equal(post?.postContent?.content, `${prefix}:postContentApple`);
+      // update: users
+      const _usersUpdate = await scopeTest.model.user.update({
+        id: users[0].id,
+        posts: [
+          // update
+          {
+            id: users[0].posts[0].id,
+            title: `${prefix}:postApple-update`,
+            // update
+            postContent: {
+              content: `${prefix}:postContentApple-update`,
+            },
+          },
+          // insert
+          {
+            title: `${prefix}:postPear`,
+            postContent: {
+              content: `${prefix}:postContentPear`,
+            },
+          },
+        ],
+        roles: [
+          // delete
+          { id: users[0].roles[0].id, deleted: true },
+          // insert
+          { id: roles[1].id },
+        ],
+      }, {
+        with: {
+          posts: $relationMutate.hasMany(ModelPost, 'userId', { include: { postContent: true } }),
+          roles: $relationMutate.belongsToMany(ModelRoleUser, ModelRole, 'userId', 'roleId'),
+        },
+      });
+      // check
+      const usersUpdateCheck = await scopeTest.model.user.get({
+        id: users[0].id,
+      }, { include: {
+        posts: {
+          include: { postContent: true },
+          orders: [['id', 'asc']],
+        },
+        roles: true,
+      } });
+      assert.equal(usersUpdateCheck?.posts.length, 2);
+      assert.equal(usersUpdateCheck?.posts[0].title, `${prefix}:postApple-update`);
+      assert.equal(usersUpdateCheck?.posts[0].postContent?.content, `${prefix}:postContentApple-update`);
+      assert.equal(usersUpdateCheck?.posts[1].postContent?.content, `${prefix}:postContentPear`);
+      assert.equal(usersUpdateCheck?.roles.length, 1);
+      assert.equal(usersUpdateCheck?.roles[0].id, roles[1].id);
+      // mutate: users
+      const _usersMutate = await scopeTest.model.user.mutate({
+        id: users[0].id,
+        posts: [
+          // update
+          {
+            id: users[0].posts[0].id,
+            title: `${prefix}:postApple-mutate`,
+            // update
+            postContent: {
+              id: users[0].posts[0].postContent?.id,
+              content: `${prefix}:postContentApple-mutate`,
+            },
+          },
+        ],
+        roles: [
+          // delete
+          { id: roles[1].id, deleted: true },
+        ],
+      }, {
+        with: {
+          posts: $relationMutate.hasMany(ModelPost, 'userId', { include: { postContent: true } }),
+          roles: $relationMutate.belongsToMany(ModelRoleUser, ModelRole, 'userId', 'roleId'),
+        },
+      });
+      // check
+      const usersMutateCheck = await scopeTest.model.user.get({
+        id: users[0].id,
+      }, { include: {
+        posts: {
+          include: { postContent: true },
+          orders: [['id', 'asc']],
+        },
+        roles: { columns: '*' as any },
+      } });
+      assert.equal(usersMutateCheck?.posts.length, 2);
+      assert.equal(usersMutateCheck?.posts[0].title, `${prefix}:postApple-mutate`);
+      assert.equal(usersMutateCheck?.posts[0].postContent?.content, `${prefix}:postContentApple-mutate`);
+      assert.equal(usersMutateCheck?.posts[1].postContent?.content, `${prefix}:postContentPear`);
+      assert.equal(usersMutateCheck?.roles.length, 0);
+      // delete: users
+      await scopeTest.model.user.deleteBulk(users.map(item => item.id), {
+        with: {
+          posts: $relationMutate.hasMany(ModelPost, 'userId', { include: { postContent: true } }),
+          roles: $relationMutate.belongsToMany(ModelRoleUser, ModelRole, 'userId', 'roleId'),
+        },
+      });
+      const roleUsers = await scopeTest.model.roleUser.select({ where: { userId: users.map(item => item.id) } });
+      assert.equal(roleUsers.length, 0);
+      // delete: roles
+      await scopeTest.model.role.deleteBulk(roles.map(item => item.id));
+      const roles2 = await scopeTest.model.role.select({
+        where: {
+          id: roles.map(item => item.id!),
+        },
+      }, { disableDeleted: true });
+      assert.equal(roles2.length, 2);
+      assert.equal(roles2[0].id !== undefined, true);
+      assert.equal(roles2[0].deleted, true);
+    });
+  });
+
+  it('action:modelRelationsMutateTree', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const prefix = 'action:modelRelationsMutateTree';
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // create: categoryTree
+      const categoryTree = await scopeTest.model.category.insert({
+        name: `${prefix}:1`,
+        children: [
+          {
+            name: `${prefix}:1-1`,
+            children: [
+              { name: `${prefix}:1-1-1` },
+              { name: `${prefix}:1-1-2` },
+            ],
+          },
+          {
+            name: `${prefix}:1-2`,
+          },
+        ],
+      });
+      const categoryTreeCheck = await scopeTest.model.category.get({ id: categoryTree.id });
+      assert.equal(categoryTree.id, categoryTreeCheck?.id);
+      const children = categoryTree.children.sort((a, b) => Number(a.id) - Number(b.id));
+      const childrenCheck = categoryTreeCheck!.children.sort((a, b) => Number(a.id) - Number(b.id));
+      assert.equal(children[0].name, childrenCheck[0].name);
+      assert.equal(children[0].name, `${prefix}:1-1`);
+      assert.equal(children[0].children?.length, childrenCheck[0].children.length);
+      assert.equal(children[0].children?.length, 2);
+      // get: categoryChain
+      const categoryChain = await scopeTest.model.categoryChain.get({
+        id: children[0].children![0].id,
+      });
+      assert.equal(categoryChain?.parent?.id, children[0].id);
+      assert.equal(categoryChain?.parent?.parent?.id, categoryTree.id);
+      assert.equal(categoryChain?.parent?.parent?.parent, undefined);
+      // delete: categoryTree
+      const items = await scopeTest.model.category.select({
+        where: {
+          name: { _startsWith_: `${prefix}:` },
+        },
+        include: { children: false },
+      });
+      assert.equal(items.length, 5);
+      await scopeTest.model.category.delete({ id: categoryTree.id }, { include: { children: { meta: { client: '_auto_' } } } });
+      const items2 = await scopeTest.model.category.select({
+        where: {
+          name: { _startsWith_: `${prefix}:` },
+        },
+        include: { children: false },
+      });
+      assert.equal(items2.length, 0);
+    });
+  });
+});

package/test/database/modelWhere.test.ts

@@ -0,0 +1,138 @@
+import type { Knex } from 'knex';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('modelWhere.test.ts', () => {
+  it('action:modelWhere', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scopeTest = app.bean.scope('test-vona');
+      // ref
+      let builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, { id: scopeTest.model.post.ref('id') as any });
+      let sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where "id" = "id"');
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, { id: scopeTest.model.post.ref('testVonaPost.id') as any });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where "id" = "testVonaPost"."id"');
+      // raw
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, scopeTest.model.post.raw('?? = ?', ['id', 1]) as any);
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where "id" = 1');
+      // op: normal
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, { id: 1 });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where "id" = 1');
+      // op: normal: joint
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, { id: { _or_: { _eq_: 3, _gt_: 4 } } });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where ((("id" = 3) or ("id" > 4)))');
+      // op: and
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _and_: { iid: 1, id: 2 },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where (("iid" = 1) and ("id" = 2))');
+      // op: and: empty
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _and_: { _and_: {} },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost"');
+      // op: or
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _or_: { iid: 1, id: 2 },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where (("iid" = 1) or ("id" = 2))');
+      // op: or: more
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _or_: {
+          _and_: { iid: 1, id: 2 },
+          title: 'test',
+        },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where (((("iid" = 1) and ("id" = 2))) or ("title" = \'test\'))');
+      // op: not
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _not_: { iid: 1, id: 2 },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where not ("iid" = 1 and "id" = 2)');
+      // op: exists
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _exists_: function (this: Knex.QueryBuilder) {
+          this.select('id').from('testVonaUser').where({ 'testVonaUser.id': app.bean.model.ref('userId') });
+        } as any,
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where exists (select "id" from "testVonaUser" where "testVonaUser"."id" = "userId")');
+      // op: notExists
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        _notExists_: function (this: Knex.QueryBuilder) {
+          this.select('id').from('testVonaUser').where({ 'testVonaUser.id': app.bean.model.ref('userId') });
+        } as any,
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where not exists (select "id" from "testVonaUser" where "testVonaUser"."id" = "userId")');
+      // op: array direct/in/notIn
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        id: [1, 2],
+        iid: [],
+        _or_: { id: { _in_: [2, 3] }, iid: { _notIn_: [3, 4] } },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where "id" in (1, 2) and 1 = 0 and ((("id" in (2, 3))) or (("iid" not in (3, 4))))');
+      // op: null/notNull
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        id: { _is_: null },
+        iid: { _isNot_: undefined },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where ("id" is null) and ("iid" is not null)');
+      // op: between/notBetween
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        id: { _between_: [1, 3] },
+        iid: { _notBetween_: [2, 4] },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where ("id" between 1 and 3) and ("iid" not between 2 and 4)');
+      // op: ref
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        iid: { _ref_: 'id' },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where ("iid" = "id")');
+      // op: gt/gte/lt/lte
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        id: { _gt_: 1, _gte_: 2, _lt_: 3, _lte_: 4 },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where ("id" > 1 and "id" >= 2 and "id" < 3 and "id" <= 4)');
+      // op: startsWith/endsWith/includes
+      builder = scopeTest.model.post.builder();
+      scopeTest.model.post.buildWhere(builder, {
+        title: { _startsWith_: 'a', _endsWith_: 'b', _includes_: 'c' },
+      });
+      sql = builder.toQuery();
+      assert.equal(sql, 'select * from "testVonaPost" where ("title" like \'a%\' and "title" like \'%b\' and "title" like \'%c%\')');
+    });
+  });
+});

package/test/database/orm.test.ts

@@ -0,0 +1,22 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('orm.test.ts', () => {
+  it('action:orm:hasOne', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // create: post/postContent
+      const post1 = await scopeTest.model.post.insert({
+        title: 'action:orm:hasOne:post1',
+      });
+      const postContent1 = await scopeTest.model.postContent.insert({
+        content: 'action:orm:hasOne:content',
+        postId: post1.id,
+      });
+      // delete
+      await scopeTest.model.post.delete({ id: post1.id });
+      await scopeTest.model.postContent.delete({ id: postContent1.id });
+    });
+  });
+});

package/test/database/transaction.test.ts

@@ -0,0 +1,142 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('transaction.test.ts', () => {
+  const tableNameFail = '__tempTransactionFail';
+  const tableNameSuccess = '__tempTransactionSuccess';
+
+  it('action:transaction:fail', async () => {
+    // transaction
+    await app.bean.executor.mockCtx(async () => {
+      // create table
+      await app.bean.model.createTable(tableNameFail, table => {
+        table.basicFields();
+        table.string('name');
+      });
+      // create a new item
+      const res = await app.bean.model.insert(tableNameFail as any, {
+        name: 'hello',
+      });
+      const id = res.id;
+
+      // try to change name
+      const itemNew = {
+        id,
+        name: 'hello!!',
+      };
+      try {
+        await app.bean.executor.performAction('post', '/test/vona/transaction/fail', {
+          body: itemNew,
+        });
+      } catch (_err) {}
+
+      // check name
+      const item = await app.bean.model.get(tableNameFail as any, {
+        id,
+      });
+      assert.notEqual(item.name, itemNew.name);
+
+      // drop table
+      await app.bean.model.dropTable(tableNameFail);
+    });
+
+    // aop method
+    const scopeTest = app.bean.scope('test-vona');
+    await app.bean.executor.mockCtx(async () => {
+      // create table
+      await app.bean.model.createTable(tableNameFail, table => {
+        table.basicFields();
+        table.string('name');
+      });
+      // create a new item
+      const res = await app.bean.model.insert(tableNameFail as any, {
+        name: 'hello',
+      });
+      const id = res.id;
+
+      // try to change name
+      const itemNew = {
+        id,
+        name: 'hello!!',
+      };
+      try {
+        await scopeTest.service.transaction.fail(itemNew);
+      } catch (_err) {}
+
+      // check name
+      const item = await app.bean.model.get(tableNameFail as any, {
+        id,
+      });
+      assert.notEqual(item.name, itemNew.name);
+
+      // drop table
+      await app.bean.model.dropTable(tableNameFail);
+    });
+  });
+
+  it('action:transaction:success', async () => {
+    // transaction
+    await app.bean.executor.mockCtx(async () => {
+      // create table
+      await app.bean.model.createTable(tableNameSuccess, table => {
+        table.basicFields();
+        table.string('name');
+      });
+      // create a new item
+      const res = await app.bean.model.insert(tableNameSuccess as any, {
+        name: 'hello',
+      });
+      const id = res.id;
+
+      // try to change name
+      const itemNew = {
+        id,
+        name: 'hello!!',
+      };
+      await app.bean.executor.performAction('post', '/test/vona/transaction/success', {
+        body: itemNew,
+      });
+
+      // check name
+      const item = await app.bean.model.get(tableNameSuccess as any, {
+        id,
+      });
+      assert.equal(item.name, itemNew.name);
+
+      // drop table
+      await app.bean.model.dropTable(tableNameSuccess);
+    });
+
+    // aop method
+    const scopeTest = app.bean.scope('test-vona');
+    await app.bean.executor.mockCtx(async () => {
+      // create table
+      await app.bean.model.createTable(tableNameSuccess, table => {
+        table.basicFields();
+        table.string('name');
+      });
+      // create a new item
+      const res = await app.bean.model.insert(tableNameSuccess as any, {
+        name: 'hello',
+      });
+      const id = res.id;
+
+      // try to change name
+      const itemNew = {
+        id,
+        name: 'hello!!',
+      };
+      await scopeTest.service.transaction.success(itemNew);
+
+      // check name
+      const item = await app.bean.model.get(tableNameSuccess as any, {
+        id,
+      });
+      assert.equal(item.name, itemNew.name);
+
+      // drop table
+      await app.bean.model.dropTable(tableNameSuccess);
+    });
+  });
+});

package/test/event.test.ts

@@ -0,0 +1,14 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('event.test.ts', () => {
+  it('action:event', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      const result = await scopeTest.event.helloEcho.emit({ text: 'hello' }, 'world');
+      assert.equal(result, 'hello world');
+    });
+  });
+});