vona-module-test-vona 5.0.38 → 5.0.41

package/test/guardPassport.test.ts

@@ -0,0 +1,44 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('guardPassport.test.ts', () => {
+  it('action:guardPassport:userName', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const jwt = await app.bean.passport.signinMock();
+      const res = await app.bean.executor.performAction('get', '/test/vona/guardPassport/testUserName', {
+        innerAccess: false,
+        authToken: jwt.accessToken,
+      });
+      assert.equal(res, undefined);
+      const [_, err] = await catchError(() => {
+        return app.bean.executor.performAction('get', '/test/vona/guardPassport/testUserNameFail', {
+          innerAccess: false,
+          authToken: jwt.accessToken,
+        });
+      });
+      assert.equal(err?.code, 403);
+      await app.bean.passport.signout();
+    });
+  });
+
+  it('action:guardPassport:roleName', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const jwt = await app.bean.passport.signinMock();
+      const res = await app.bean.executor.performAction('get', '/test/vona/guardPassport/testRoleName', {
+        innerAccess: false,
+        authToken: jwt.accessToken,
+      });
+      assert.equal(res, undefined);
+      const [_, err] = await catchError(() => {
+        return app.bean.executor.performAction('get', '/test/vona/guardPassport/testRoleNameFail', {
+          innerAccess: false,
+          authToken: jwt.accessToken,
+        });
+      });
+      assert.equal(err?.code, 403);
+      await app.bean.passport.signout();
+    });
+  });
+});

package/test/jwt.test.ts

@@ -0,0 +1,27 @@
+import type { IPayloadDataBase } from 'vona-module-a-jwt';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('jwt.test.ts', () => {
+  it('action:jwt', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // sign
+      const payloadData: IPayloadDataBase = { userId: 1, authId: 1 };
+      const token = await app.bean.jwt.get('access').sign(payloadData);
+      assert.equal(token.split('.').length, 3);
+      // verify
+      const [payloadDataVerified1] = await catchError(async () => {
+        return await app.bean.jwt.get('refresh').verify(token);
+      });
+      assert.equal(payloadDataVerified1, undefined);
+      // verify
+      const payloadDataVerified2 = await app.bean.jwt.get('access').verify(token);
+      assert.deepEqual(payloadData, payloadDataVerified2);
+      // create jwt token
+      const jwtToken = await app.bean.jwt.create(payloadData);
+      assert.equal(!!jwtToken.accessToken, true);
+    });
+  });
+});

package/test/locale.test.ts

@@ -0,0 +1,51 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app, mockModuleInfo } from 'vona-mock';
+import { __ThisModule__ } from '../src/.metadata/this.ts';
+
+describe('locale.test.ts', () => {
+  it('action:locale', async () => {
+    const moduleInfo = mockModuleInfo();
+    assert.equal(moduleInfo.relativeName, __ThisModule__);
+    await app.bean.executor.mockCtx(
+      async () => {
+        const ctx = app.ctx;
+        // ctx.locale
+        assert.equal(ctx.locale, 'zh-cn');
+        // getText
+        assert.equal(
+          app.meta.locale.getText(false, moduleInfo.relativeName, ctx.locale, 'TestHelloWorld'),
+          '您好，世界',
+        );
+        assert.equal(app.meta.locale.getText(false, undefined, ctx.locale, 'test-vona::TestHelloWorld'), '您好，世界');
+        // scope locale
+        const scopeTest = app.bean.scope('test-vona');
+        assert.equal(scopeTest.locale.TestHelloWorld(), '您好，世界');
+      },
+      { locale: 'zh-cn' },
+    );
+  });
+
+  it('action:locale:plurals', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      // english
+      assert.equal(scopeTest.locale.TestApples.locale('en-us', 0), 'no apples');
+      assert.equal(scopeTest.locale.TestApples.locale('en-us', 1), 'one apple');
+      assert.equal(scopeTest.locale.TestApples.locale('en-us', 2), '2 apples');
+      // chinese
+      assert.equal(scopeTest.locale.TestApples.locale('zh-cn', 0), '没有苹果');
+      assert.equal(scopeTest.locale.TestApples.locale('zh-cn', 1), '1个苹果');
+      assert.equal(scopeTest.locale.TestApples.locale('zh-cn', 2), '2个苹果');
+      // english
+      assert.equal(scopeTest.locale.TestNameApples_.locale('en-us', 'Mike', 0), 'Mike has no apples');
+      assert.equal(scopeTest.locale.TestNameApples_.locale('en-us', 'Mike', 1), 'Mike has one apple');
+      assert.equal(scopeTest.locale.TestNameApples_.locale('en-us', 'Mike', 2), 'Mike has 2 apples');
+      // chinese
+      assert.equal(scopeTest.locale.TestNameApples_.locale('zh-cn', 'Mike', 0), 'Mike没有苹果');
+      assert.equal(scopeTest.locale.TestNameApples_.locale('zh-cn', 'Mike', 1), 'Mike有1个苹果');
+      assert.equal(scopeTest.locale.TestNameApples_.locale('zh-cn', 'Mike', 2), 'Mike有2个苹果');
+    });
+  });
+});

package/test/passport.test.ts

@@ -0,0 +1,57 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('passport.test.ts', () => {
+  it('action:passport:simple', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      assert.equal(app.bean.passport.isAuthenticated, true);
+      await app.bean.executor.performAction('get', '/test/vona/passport/echo/:name', { params: { name: 'admin' } });
+      await app.bean.passport.signout();
+      assert.equal(app.bean.passport.isAuthenticated, false);
+    });
+  });
+
+  it('action:passport:full', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // login
+      const jwt = await app.bean.executor.performAction('post', '/test/vona/passport/login', {
+        body: {
+          name: 'admin',
+        },
+      });
+      assert.equal(!!jwt?.accessToken, true);
+      // isAuthenticated
+      let isAuthenticated = await app.bean.executor.performAction('get', '/test/vona/passport/isAuthenticated');
+      assert.equal(isAuthenticated, 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
+      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);
+      // refresh
+      const jwtNew = await app.bean.executor.performAction('post', '/test/vona/passport/refresh', {
+        body: {
+          refreshToken: jwt.refreshToken,
+        },
+      });
+      assert.notEqual(jwt?.accessToken, jwtNew.accessToken);
+      // logout
+      await app.bean.executor.performAction('post', '/test/vona/passport/logout');
+      // isAuthenticated: isolate + header
+      const [isAuthenticated3] = await catchError(async () => {
+        return await app.bean.executor.performAction('get', '/test/vona/passport/isAuthenticated');
+      });
+      assert.equal(isAuthenticated3, undefined);
+    });
+  });
+});

package/test/queue.test.ts

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

package/test/tail.test.ts

@@ -0,0 +1,21 @@
+import { describe, it } from 'node:test';
+import { cast } from 'vona';
+import { app } from 'vona-mock';
+
+describe('tail.test.ts', () => {
+  it('action:tail', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      cast(app.ctx)._tail_test_caller = 1;
+      await app.bean.executor.performAction('post', '/test/vona/tail');
+    });
+  });
+
+  it('action:tail:transaction', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      cast(app.ctx)._tail_test_als_caller = 1;
+      await app.ctx.db.transaction.begin(async () => {
+        await app.bean.executor.performAction('post', '/test/vona/tail');
+      });
+    });
+  });
+});

package/test/upload.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert';
+import { Blob } from 'node:buffer';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { $apiPath } from 'vona-module-a-web';
+
+describe('upload.test.ts', () => {
+  it('action:upload:fields', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const formData = new FormData();
+      formData.append('name', 'zhennann');
+      formData.append('checkes', 'apple');
+      formData.append('checkes', 'pear');
+      // formData.append('checkes', ['apple', 'pear']);
+      const url = app.util.getAbsoluteUrlByApiPath($apiPath('/test/vona/upload/fields'));
+      const res = await fetch(url, {
+        method: 'POST',
+        body: formData,
+      });
+      const data = await res.json();
+      assert.equal(data.data.fields.find(item => item.name === 'name')?.value, 'zhennann');
+    });
+  });
+  it('action:upload:file', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const formData = new FormData();
+      formData.append('name', 'zhennann');
+      formData.append('welcome', new (Blob as any)(['hello world!']), 'file-test.txt');
+      const url = app.util.getAbsoluteUrlByApiPath($apiPath('/test/vona/upload/file'));
+      const res = await fetch(url, {
+        method: 'POST',
+        body: formData,
+      });
+      const data = await res.json();
+      assert.equal(data.data.fields.find(item => item.name === 'name')?.value, 'zhennann');
+      assert.equal(data.data.files.find(item => item.name === 'welcome')?.info.filename, 'file-test.txt');
+    });
+  });
+  it('action:upload:files', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const formData = new FormData();
+      formData.append('name', 'zhennann');
+      formData.append('welcome1', new (Blob as any)(['hello world!'], { type: 'text/plain' }), 'file-test1.txt');
+      formData.append('welcome2', new (Blob as any)(['hello world!'], { type: 'text/plain' }), 'file-test2.txt');
+      formData.append('images', new (Blob as any)(['hello world!'], { type: 'text/plain' }));
+      formData.append('images', new (Blob as any)(['hello world!'], { type: 'text/plain' }));
+      const url = app.util.getAbsoluteUrlByApiPath($apiPath('/test/vona/upload/files'));
+      const res = await fetch(url, {
+        method: 'POST',
+        body: formData,
+      });
+      const data = await res.json();
+      assert.equal(data.data.fields.find(item => item.name === 'name')?.value, 'zhennann');
+      assert.equal(data.data.files.find(item => item.name === 'welcome1')?.info.filename, 'file-test1.txt');
+      assert.equal(data.data.files.find(item => item.name === 'welcome2')?.info.filename, 'file-test2.txt');
+    });
+  });
+});

package/test/utils/cabloyUtils.test.ts

@@ -0,0 +1,22 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { getProperty } from '@cabloy/utils';
+
+describe('cabloyUtils.test.ts', () => {
+  it('action:getProperty', async () => {
+    const user = {
+      id: 1,
+      name: 'tom',
+      role: { name: 'admin' },
+      books: [
+        { name: 'piao' },
+        { name: 'flying' },
+      ],
+    };
+    assert.equal(getProperty(user, 'id'), 1);
+    assert.equal(getProperty(user, 'role.name'), 'admin');
+    assert.equal(getProperty(user, 'role.xx'), undefined);
+    assert.equal(getProperty(user, 'role.xx.yy'), undefined);
+    assert.equal(getProperty(user, 'books[0].name'), 'piao');
+  });
+});

package/test/utils/celjs.test.ts

@@ -0,0 +1,26 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { evaluateExpressions } from '@cabloy/utils';
+import { cast } from 'vona';
+import { app } from 'vona-mock';
+
+describe('celjs.test.ts', () => {
+  it('action:celjs', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      //
+      const beanJwt = app.bean.jwt;
+      assert.equal(evaluateExpressions('cel://self.app.config.server.workers', { self: beanJwt, app: cast(beanJwt).app, ctx: cast(beanJwt).ctx }) > 0, true);
+      assert.equal(evaluateExpressions('cel://app.config.server.workers', { self: beanJwt, app: cast(beanJwt).app, ctx: cast(beanJwt).ctx }) > 0, true);
+      assert.equal(evaluateExpressions('cel://ctx.app.config.server.workers', { self: beanJwt, app: cast(beanJwt).app, ctx: cast(beanJwt).ctx }) > 0, true);
+      // map
+      assert.deepEqual(evaluateExpressions('cel://{"a": 1, "b": true}'), { a: 1, b: true });
+      assert.deepEqual(evaluateExpressions('cel://{"id": 1, "name": "tom"}'), { id: 1, name: 'tom' });
+      // array
+      assert.deepEqual(evaluateExpressions('cel://concat(1,[2,3],4)'), [1, 2, 3, 4]);
+      assert.deepEqual(evaluateExpressions('cel://join(concat(1,[2,3],4),"_")'), '1_2_3_4');
+      // +
+      assert.equal(evaluateExpressions('cel://1+"a"'), '1a');
+      assert.equal(evaluateExpressions('cel://"a"+1'), 'a1');
+    });
+  });
+});

package/test/utils/mappedTypes.test.ts

@@ -0,0 +1,65 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { $Class, cast } from 'vona';
+import { app } from 'vona-mock';
+import { Api } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { DtoProfile } from '../../src/dto/profile.ts';
+import { DtoUser } from '../../src/dto/user.ts';
+
+interface IDtoOptionsUserWithMarried extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsUserWithMarried>()
+class DtoUserWithMarried extends $Class.omit(DtoUser, ['married']) {
+  @Api.field()
+  married: boolean;
+}
+
+describe('mappedTypes.test.ts', () => {
+  it('action:mappedTypes', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const serviceValidator = app.bean.validator;
+      const data = { id: 1, name: 'tom', married: true };
+      // original
+      const [dataNew, err] = await catchError(async () => {
+        return await serviceValidator.validate(DtoUser, data, { strict: true });
+      });
+      assert.deepEqual(dataNew, data, JSON.stringify(err, null, 2));
+      // OmitClass
+      const [, err2] = await catchError(async () => {
+        return await serviceValidator.validate($Class.omit(DtoUser, ['married']), data, { strict: true });
+      });
+      assert.equal(cast(err2?.message)[0]?.keys[0], 'married');
+      // OmitClass and inherit
+      const [dataNew3] = await catchError(async () => {
+        return await serviceValidator.validate(DtoUserWithMarried, data, { strict: true });
+      });
+      assert.deepEqual(dataNew3, data);
+      // PickClass
+      const [, err4] = await catchError(async () => {
+        return await serviceValidator.validate($Class.pick(DtoUser, ['id', 'name']), data, { strict: true });
+      });
+      assert.equal(cast(err4?.message)[0]?.keys[0], 'married');
+      // PartialClass
+      const [dataNew5] = await catchError(async () => {
+        return await serviceValidator.validate($Class.partial(DtoUser), {}, { strict: true });
+      });
+      assert.deepEqual(dataNew5, {});
+      const [dataNew6] = await catchError(async () => {
+        return await serviceValidator.validate(
+          $Class.partial(DtoUser, ['id', 'name']),
+          { married: true },
+          { strict: true },
+        );
+      });
+      assert.deepEqual(dataNew6, { married: true });
+      // MixinClass
+      const [_, err7] = await catchError(async () => {
+        return await serviceValidator.validate($Class.mixin(DtoUser, DtoProfile), data, { strict: true });
+      });
+      assert.equal(cast(err7?.message)[0]?.path[0], 'email');
+    });
+  });
+});

package/test/utils/performAction.test.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app, mockUrl } from 'vona-mock';
+
+describe('performAction.test.ts', () => {
+  it('action:performAction', async () => {
+    const result: { id: number; url: string } = await app.bean.executor.mockCtx(async () => {
+      return await app.bean.executor.performAction('post', '/test/vona/performAction/echo', {
+        body: {
+          id: 123,
+        },
+      });
+    });
+    assert.equal(result.id, 123);
+    assert.equal(result.url, mockUrl('performAction/echo'));
+  });
+  it('action:performAction:onionsDynamic', async () => {
+    const result: { id: number; url: string } = await app.bean.executor.mockCtx(async () => {
+      return await app.bean.executor.performAction('post', '/test/vona/performAction/echo', {
+        onions: {
+          pipe: { 'a-validation:valid': { enable: false } },
+        },
+      });
+    });
+    assert.equal(result.id, undefined);
+    assert.equal(result.url, mockUrl('performAction/echo'));
+  });
+});