优化

server/test/integration/user/dmlist.spec.ts

@@ -0,0 +1,177 @@
+import { createTestServiceBroker } from '../../utils';
+import UserDMListService from '../../../services/core/user/dmlist.service';
+import { Types } from 'mongoose';
+import type { UserDMList } from '../../../models/user/dmList';
+
+describe('Test "dmlist" service', () => {
+  const { broker, service, insertTestData } =
+    createTestServiceBroker<UserDMListService>(UserDMListService);
+
+  describe('Test "user.dmlist.addConverse"', () => {
+    test('addConverse should be ok', async () => {
+      const userId = String(new Types.ObjectId());
+      const converseId = String(new Types.ObjectId());
+
+      await broker.call(
+        'user.dmlist.addConverse',
+        {
+          converseId,
+        },
+        {
+          meta: {
+            userId,
+          },
+        }
+      );
+
+      try {
+        const res = await service.adapter.model.findOne({
+          userId,
+        });
+
+        expect(res.converseIds.map((r) => String(r))).toEqual([converseId]); // 应该被成功插入
+      } finally {
+        await service.adapter.model.deleteOne({
+          userId,
+        });
+      }
+    });
+
+    test('addConverse should not be repeat', async () => {
+      const userId = String(new Types.ObjectId());
+      const converseId = String(new Types.ObjectId());
+
+      await broker.call(
+        'user.dmlist.addConverse',
+        {
+          converseId,
+        },
+        {
+          meta: {
+            userId,
+          },
+        }
+      );
+
+      await broker.call(
+        'user.dmlist.addConverse',
+        {
+          converseId,
+        },
+        {
+          meta: {
+            userId,
+          },
+        }
+      );
+
+      try {
+        const res = await service.adapter.model.findOne({
+          userId,
+        });
+
+        expect(res.converseIds.map((r) => String(r))).toEqual([converseId]); // 应该被成功插入
+      } finally {
+        await service.adapter.model.deleteOne({
+          userId,
+        });
+      }
+    });
+
+    test('addConverse can be add more', async () => {
+      const userId = String(new Types.ObjectId());
+      const converseId = String(new Types.ObjectId());
+      const converseId2 = String(new Types.ObjectId());
+
+      await broker.call(
+        'user.dmlist.addConverse',
+        {
+          converseId,
+        },
+        {
+          meta: {
+            userId,
+          },
+        }
+      );
+
+      await broker.call(
+        'user.dmlist.addConverse',
+        {
+          converseId: converseId2,
+        },
+        {
+          meta: {
+            userId,
+          },
+        }
+      );
+
+      try {
+        const res = await service.adapter.model.findOne({
+          userId,
+        });
+
+        expect(res.converseIds.map((r) => String(r))).toEqual([
+          converseId,
+          converseId2,
+        ]);
+      } finally {
+        await service.adapter.model.deleteOne({
+          userId,
+        });
+      }
+    });
+  });
+
+  test('Test "user.dmlist.removeConverse"', async () => {
+    const userId = String(new Types.ObjectId());
+    const converseId = new Types.ObjectId();
+
+    await insertTestData({
+      userId,
+      converseIds: [converseId],
+    });
+
+    expect(
+      (await service.adapter.model.findOne({ userId })).converseIds.length
+    ).toBe(1);
+
+    await broker.call(
+      'user.dmlist.removeConverse',
+      {
+        converseId: String(converseId),
+      },
+      {
+        meta: {
+          userId,
+        },
+      }
+    );
+
+    expect(
+      (await service.adapter.model.findOne({ userId })).converseIds.length
+    ).toBe(0);
+  });
+
+  test('Test "user.dmlist.getAllConverse"', async () => {
+    const userId = String(new Types.ObjectId());
+
+    const testData = await insertTestData({
+      userId,
+      converseIds: [new Types.ObjectId()],
+    });
+
+    const converseIds: UserDMList = await broker.call(
+      'user.dmlist.getAllConverse',
+      {},
+      {
+        meta: {
+          userId,
+        },
+      }
+    );
+
+    expect(converseIds).toEqual([...testData.converseIds]);
+  });
+});

server/test/integration/user/user.spec.ts

@@ -0,0 +1,194 @@
+import { generateRandomStr, getEmailAddress } from '../../../lib/utils';
+import UserService from '../../../services/core/user/user.service';
+import { createTestServiceBroker } from '../../utils';
+import bcrypt from 'bcryptjs';
+import type { UserDocument } from '../../../models/user/user';
+
+/**
+ * 创建测试用户
+ */
+function createTestUser(email = 'foo@bar.com') {
+  return {
+    email,
+    nickname: getEmailAddress(email),
+    password: bcrypt.hashSync('123456'),
+    avatar: null,
+    discriminator: '0000',
+  };
+}
+
+/**
+ * 创建正常用户
+ */
+function createTestTemporaryUser() {
+  return {
+    email: `${generateRandomStr()}.temporary@msgbyte.com`,
+    nickname: generateRandomStr(),
+    password: bcrypt.hashSync('123456'),
+    avatar: null,
+    discriminator: '0000',
+    temporary: true,
+  };
+}
+
+describe('Test "user" service', () => {
+  const { broker, service, insertTestData } =
+    createTestServiceBroker<UserService>(UserService);
+
+  test('Test "user.register"', async () => {
+    const params = {
+      email: 'test@example.com',
+      password: '123456',
+    };
+    const user: any = await broker.call('user.register', params);
+
+    try {
+      expect(user.email).toBe(params.email);
+      expect(user.avatar).toBe(null);
+      expect(user.nickname).toBe(getEmailAddress(params.email));
+    } finally {
+      await service.adapter.removeById(user._id);
+    }
+  });
+
+  test('Test "user.createTemporaryUser"', async () => {
+    const nickname = generateRandomStr();
+    const params = {
+      nickname,
+    };
+    const user: any = await broker.call('user.createTemporaryUser', params);
+
+    try {
+      expect(user).toHaveProperty('nickname', nickname);
+      expect(user).toHaveProperty('discriminator');
+      expect(user).toHaveProperty('token');
+      expect(user).toHaveProperty('temporary', true);
+      expect(String(user.email).endsWith('.temporary@msgbyte.com'));
+    } finally {
+      await service.adapter.removeById(user._id);
+    }
+  });
+
+  test('Test "user.claimTemporaryUser"', async () => {
+    const testDoc = await insertTestData(createTestTemporaryUser());
+    const email = `${generateRandomStr()}@msgbyte.com`;
+    const password = '654321';
+
+    const newUser: any = await broker.call('user.claimTemporaryUser', {
+      userId: String(testDoc._id),
+      email,
+      password,
+    });
+
+    expect(newUser).toHaveProperty('nickname', testDoc.nickname); // 昵称不变
+    expect(newUser).toHaveProperty('email', email);
+    expect(newUser).toHaveProperty('password');
+    expect(bcrypt.compareSync(password, newUser.password)).toBe(true); // 校验密码修改是否正确
+    expect(newUser).toHaveProperty('token');
+    expect(newUser).toHaveProperty('temporary', false);
+  });
+
+  test('Test "user.searchUserWithUniqueName"', async () => {
+    const testDoc = await insertTestData(createTestUser());
+
+    const res: UserDocument = await broker.call(
+      'user.searchUserWithUniqueName',
+      {
+        uniqueName: testDoc.nickname + '#' + testDoc.discriminator,
+      }
+    );
+
+    expect(res).not.toBe(null);
+    expect(res.nickname).toBe(testDoc.nickname);
+    expect(res).not.toHaveProperty('password');
+  });
+
+  test('Test "user.updateUserExtra"', async () => {
+    const testUser = await insertTestData(createTestUser());
+
+    const res = await broker.call(
+      'user.updateUserExtra',
+      {
+        fieldName: 'foo',
+        fieldValue: 'bar',
+      },
+      {
+        meta: {
+          userId: String(testUser._id),
+        },
+      }
+    );
+
+    expect(res).toMatchObject({
+      extra: {
+        foo: 'bar',
+      },
+    });
+
+    const res2 = await broker.call(
+      'user.updateUserExtra',
+      {
+        fieldName: 'foo',
+        fieldValue: 'baz',
+      },
+      {
+        meta: {
+          userId: String(testUser._id),
+        },
+      }
+    );
+
+    expect(res2).toMatchObject({
+      extra: {
+        foo: 'baz',
+      },
+    });
+  });
+
+  test('Test "user.setUserSettings"', async () => {
+    const testUser = await insertTestData(createTestUser());
+
+    const res = await broker.call(
+      'user.setUserSettings',
+      {
+        settings: {
+          foo: 'aaa',
+          bar: 233,
+        },
+      },
+      {
+        meta: {
+          userId: String(testUser._id),
+        },
+      }
+    );
+
+    expect(res).toEqual({
+      foo: 'aaa',
+      bar: 233,
+    });
+
+    // and can be merge
+
+    const res2 = await broker.call(
+      'user.setUserSettings',
+      {
+        settings: {
+          foo: 'bbb',
+          baz: 963,
+        },
+      },
+      {
+        meta: {
+          userId: String(testUser._id),
+        },
+      }
+    );
+
+    expect(res2).toEqual({
+      foo: 'bbb',
+      bar: 233,
+      baz: 963,
+    });
+  });
+});