feat(server,web): libraries (#3124)

* feat: libraries

Co-authored-by: Jason Rasmussen <jrasm91@gmail.com>
Co-authored-by: Alex <alex.tran1502@gmail.com>

server/test/test-utils.ts

@@ -0,0 +1,175 @@
+import {
+  AdminSignupResponseDto,
+  AlbumResponseDto,
+  AuthDeviceResponseDto,
+  AuthUserDto,
+  CreateUserDto,
+  LibraryResponseDto,
+  LoginCredentialDto,
+  LoginResponseDto,
+  SharedLinkCreateDto,
+  SharedLinkResponseDto,
+  UpdateUserDto,
+  UserResponseDto,
+} from '@app/domain';
+import { CreateAlbumDto } from '@app/domain/album/dto/album-create.dto';
+import { dataSource } from '@app/infra';
+import { UserEntity } from '@app/infra/entities';
+import request from 'supertest';
+import { adminSignupStub, loginResponseStub, loginStub, signupResponseStub } from './fixtures';
+
+export const db = {
+  reset: async () => {
+    if (!dataSource.isInitialized) {
+      await dataSource.initialize();
+    }
+
+    await dataSource.transaction(async (em) => {
+      for (const entity of dataSource.entityMetadatas) {
+        if (entity.tableName === 'users') {
+          continue;
+        }
+        await em.query(`DELETE FROM ${entity.tableName} CASCADE;`);
+      }
+      await em.query(`DELETE FROM "users" CASCADE;`);
+    });
+  },
+  disconnect: async () => {
+    if (dataSource.isInitialized) {
+      await dataSource.destroy();
+    }
+  },
+};
+
+export function getAuthUser(): AuthUserDto {
+  return {
+    id: '3108ac14-8afb-4b7e-87fd-39ebb6b79750',
+    email: 'test@email.com',
+    isAdmin: false,
+  };
+}
+
+export const api = {
+  adminSignUp: async (server: any) => {
+    const { status, body } = await request(server).post('/auth/admin-sign-up').send(adminSignupStub);
+
+    expect(status).toBe(201);
+    expect(body).toEqual(signupResponseStub);
+
+    return body as AdminSignupResponseDto;
+  },
+  adminLogin: async (server: any) => {
+    const { status, body } = await request(server).post('/auth/login').send(loginStub.admin);
+
+    expect(body).toEqual(loginResponseStub.admin.response);
+    expect(body).toMatchObject({ accessToken: expect.any(String) });
+    expect(status).toBe(201);
+
+    return body as LoginResponseDto;
+  },
+  userCreate: async (server: any, accessToken: string, user: Partial<UserEntity>) => {
+    const { status, body } = await request(server)
+      .post('/user')
+      .set('Authorization', `Bearer ${accessToken}`)
+      .send(user);
+
+    expect(status).toBe(201);
+
+    return body as UserResponseDto;
+  },
+  login: async (server: any, dto: LoginCredentialDto) => {
+    const { status, body } = await request(server).post('/auth/login').send(dto);
+
+    expect(status).toEqual(201);
+    expect(body).toMatchObject({ accessToken: expect.any(String) });
+
+    return body as LoginResponseDto;
+  },
+  getAuthDevices: async (server: any, accessToken: string) => {
+    const { status, body } = await request(server).get('/auth/devices').set('Authorization', `Bearer ${accessToken}`);
+
+    expect(body).toEqual(expect.any(Array));
+    expect(status).toBe(200);
+
+    return body as AuthDeviceResponseDto[];
+  },
+  validateToken: async (server: any, accessToken: string) => {
+    const response = await request(server).post('/auth/validateToken').set('Authorization', `Bearer ${accessToken}`);
+    expect(response.body).toEqual({ authStatus: true });
+    expect(response.status).toBe(200);
+  },
+  albumApi: {
+    create: async (server: any, accessToken: string, dto: CreateAlbumDto) => {
+      const res = await request(server).post('/album').set('Authorization', `Bearer ${accessToken}`).send(dto);
+      expect(res.status).toEqual(201);
+      return res.body as AlbumResponseDto;
+    },
+  },
+  libraryApi: {
+    getAll: async (server: any, accessToken: string) => {
+      const res = await request(server).get('/library').set('Authorization', `Bearer ${accessToken}`);
+      expect(res.status).toEqual(200);
+      expect(Array.isArray(res.body)).toBe(true);
+      return res.body as LibraryResponseDto[];
+    },
+  },
+  sharedLinkApi: {
+    create: async (server: any, accessToken: string, dto: SharedLinkCreateDto) => {
+      const { status, body } = await request(server)
+        .post('/shared-link')
+        .set('Authorization', `Bearer ${accessToken}`)
+        .send(dto);
+      expect(status).toBe(201);
+      return body as SharedLinkResponseDto;
+    },
+  },
+  userApi: {
+    create: async (server: any, accessToken: string, dto: CreateUserDto) => {
+      const { status, body } = await request(server)
+        .post('/user')
+        .set('Authorization', `Bearer ${accessToken}`)
+        .send(dto);
+
+      expect(status).toBe(201);
+      expect(body).toMatchObject({
+        id: expect.any(String),
+        createdAt: expect.any(String),
+        updatedAt: expect.any(String),
+        email: dto.email,
+      });
+
+      return body as UserResponseDto;
+    },
+    get: async (server: any, accessToken: string, id: string) => {
+      const { status, body } = await request(server)
+        .get(`/user/info/${id}`)
+        .set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toMatchObject({ id });
+
+      return body as UserResponseDto;
+    },
+    update: async (server: any, accessToken: string, dto: UpdateUserDto) => {
+      const { status, body } = await request(server)
+        .put('/user')
+        .set('Authorization', `Bearer ${accessToken}`)
+        .send(dto);
+
+      expect(status).toBe(200);
+      expect(body).toMatchObject({ id: dto.id });
+
+      return body as UserResponseDto;
+    },
+    delete: async (server: any, accessToken: string, id: string) => {
+      const { status, body } = await request(server)
+        .delete(`/user/${id}`)
+        .set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toMatchObject({ id, deletedAt: expect.any(String) });
+
+      return body as UserResponseDto;
+    },
+  },
+} as const;