refactor: asset e2e (#7769)

server/e2e/client/asset-api.ts

@@ -1,77 +1,10 @@
 import { AssetResponseDto } from '@app/domain';
-import { CreateAssetDto } from '@app/immich/api-v1/asset/dto/create-asset.dto';
-import { AssetFileUploadResponseDto } from '@app/immich/api-v1/asset/response-dto/asset-file-upload-response.dto';
-import { randomBytes } from 'node:crypto';
 import request from 'supertest';
 
-type UploadDto = Partial<CreateAssetDto> & { content?: Buffer; filename?: string };
-
-const asset = {
-  deviceAssetId: 'test-1',
-  deviceId: 'test',
-  fileCreatedAt: new Date(),
-  fileModifiedAt: new Date(),
-};
-
 export const assetApi = {
-  create: async (
-    server: any,
-    accessToken: string,
-    dto?: Omit<CreateAssetDto, 'assetData'>,
-  ): Promise<AssetResponseDto> => {
-    dto = dto || asset;
-    const { status, body } = await request(server)
-      .post(`/asset/upload`)
-      .field('deviceAssetId', dto.deviceAssetId)
-      .field('deviceId', dto.deviceId)
-      .field('fileCreatedAt', dto.fileCreatedAt.toISOString())
-      .field('fileModifiedAt', dto.fileModifiedAt.toISOString())
-      .attach('assetData', randomBytes(32), 'example.jpg')
-      .set('Authorization', `Bearer ${accessToken}`);
-
-    expect([200, 201].includes(status)).toBe(true);
-
-    return body as AssetResponseDto;
-  },
-  get: async (server: any, accessToken: string, id: string): Promise<AssetResponseDto> => {
-    const { body, status } = await request(server).get(`/asset/${id}`).set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(200);
-    return body as AssetResponseDto;
-  },
   getAllAssets: async (server: any, accessToken: string) => {
     const { body, status } = await request(server).get(`/asset/`).set('Authorization', `Bearer ${accessToken}`);
     expect(status).toBe(200);
     return body as AssetResponseDto[];
   },
-  upload: async (server: any, accessToken: string, deviceAssetId: string, dto: UploadDto = {}) => {
-    const { content, filename, isFavorite = false, isArchived = false } = dto;
-    const { body, status } = await request(server)
-      .post('/asset/upload')
-      .set('Authorization', `Bearer ${accessToken}`)
-      .field('deviceAssetId', deviceAssetId)
-      .field('deviceId', 'TEST')
-      .field('fileCreatedAt', new Date().toISOString())
-      .field('fileModifiedAt', new Date().toISOString())
-      .field('isFavorite', isFavorite)
-      .field('isArchived', isArchived)
-      .field('duration', '0:00:00.000000')
-      .attach('assetData', content || randomBytes(32), filename || 'example.jpg');
-
-    expect(status).toBe(201);
-    return body as AssetFileUploadResponseDto;
-  },
-  getWebpThumbnail: async (server: any, accessToken: string, assetId: string) => {
-    const { body, status } = await request(server)
-      .get(`/asset/thumbnail/${assetId}`)
-      .set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(200);
-    return body;
-  },
-  getJpegThumbnail: async (server: any, accessToken: string, assetId: string) => {
-    const { body, status } = await request(server)
-      .get(`/asset/thumbnail/${assetId}?format=JPEG`)
-      .set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(200);
-    return body;
-  },
 };

server/e2e/client/auth-api.ts

@@ -1,4 +1,4 @@
-import { LoginCredentialDto, LoginResponseDto, UserResponseDto } from '@app/domain';
+import { LoginResponseDto, UserResponseDto } from '@app/domain';
 import { adminSignupStub, loginResponseStub, loginStub } from '@test';
 import request from 'supertest';
 
@@ -17,14 +17,6 @@ export const authApi = {
     expect(body).toMatchObject({ accessToken: expect.any(String) });
     expect(status).toBe(201);
 
-    return body as LoginResponseDto;
-  },
-  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;
   },
 };

server/e2e/client/index.ts

@@ -1,15 +1,9 @@
 import { assetApi } from './asset-api';
 import { authApi } from './auth-api';
 import { libraryApi } from './library-api';
-import { sharedLinkApi } from './shared-link-api';
-import { trashApi } from './trash-api';
-import { userApi } from './user-api';
 
 export const api = {
   authApi,
   assetApi,
   libraryApi,
-  sharedLinkApi,
-  trashApi,
-  userApi,
 };

server/e2e/client/library-api.ts

@@ -1,12 +1,4 @@
-import {
-  CreateLibraryDto,
-  LibraryResponseDto,
-  LibraryStatsResponseDto,
-  ScanLibraryDto,
-  UpdateLibraryDto,
-  ValidateLibraryDto,
-  ValidateLibraryResponseDto,
-} from '@app/domain';
+import { CreateLibraryDto, LibraryResponseDto, ScanLibraryDto } from '@app/domain';
 import request from 'supertest';
 
 export const libraryApi = {
@@ -38,34 +30,4 @@ export const libraryApi = {
       .send(dto);
     expect(status).toBe(204);
   },
-  removeOfflineFiles: async (server: any, accessToken: string, id: string) => {
-    const { status } = await request(server)
-      .post(`/library/${id}/removeOffline`)
-      .set('Authorization', `Bearer ${accessToken}`)
-      .send();
-    expect(status).toBe(204);
-  },
-  getLibraryStatistics: async (server: any, accessToken: string, id: string): Promise<LibraryStatsResponseDto> => {
-    const { body, status } = await request(server)
-      .get(`/library/${id}/statistics`)
-      .set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(200);
-    return body;
-  },
-  update: async (server: any, accessToken: string, id: string, data: UpdateLibraryDto) => {
-    const { body, status } = await request(server)
-      .put(`/library/${id}`)
-      .set('Authorization', `Bearer ${accessToken}`)
-      .send(data);
-    expect(status).toBe(200);
-    return body as LibraryResponseDto;
-  },
-  validate: async (server: any, accessToken: string, id: string, data: ValidateLibraryDto) => {
-    const { body, status } = await request(server)
-      .post(`/library/${id}/validate`)
-      .set('Authorization', `Bearer ${accessToken}`)
-      .send(data);
-    expect(status).toBe(200);
-    return body as ValidateLibraryResponseDto;
-  },
 };

server/e2e/client/shared-link-api.ts

@@ -1,13 +0,0 @@
-import { SharedLinkCreateDto, SharedLinkResponseDto } from '@app/domain';
-import request from 'supertest';
-
-export const 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;
-  },
-};

server/e2e/client/trash-api.ts

@@ -1,13 +0,0 @@
-import request from 'supertest';
-import type { App } from 'supertest/types';
-
-export const trashApi = {
-  async empty(server: App, accessToken: string) {
-    const { status } = await request(server).post('/trash/empty').set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(204);
-  },
-  async restore(server: App, accessToken: string) {
-    const { status } = await request(server).post('/trash/restore').set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(204);
-  },
-};

server/e2e/client/user-api.ts

@@ -1,37 +0,0 @@
-import { CreateUserDto, UpdateUserDto, UserResponseDto } from '@app/domain';
-import request from 'supertest';
-
-export const 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;
-  },
-  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;
-  },
-};