refactor(server): e2e (#6632)

server/e2e/api/specs/activity.e2e-spec.ts

@@ -4,7 +4,7 @@ import { AssetFileUploadResponseDto } from '@app/immich/api-v1/asset/response-dt
 import { ActivityEntity } from '@app/infra/entities';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${ActivityController.name} (e2e)`, () => {

server/e2e/api/specs/album.e2e-spec.ts

@@ -4,7 +4,7 @@ import { AssetFileUploadResponseDto } from '@app/immich/api-v1/asset/response-dt
 import { SharedLinkType } from '@app/infra/entities';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 const user1SharedUser = 'user1SharedUser';

server/e2e/api/specs/asset.e2e-spec.ts

@@ -16,7 +16,7 @@ import { INestApplication } from '@nestjs/common';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
 import { randomBytes } from 'crypto';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { generateAsset, testApp, today, yesterday } from '../utils';
 
 const makeUploadDto = (options?: { omit: string }): Record<string, any> => {

server/e2e/api/specs/auth.e2e-spec.ts

@@ -9,7 +9,7 @@ import {
   uuidStub,
 } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 const name = 'Immich Admin';

server/e2e/api/specs/library.e2e-spec.ts

@@ -3,7 +3,7 @@ import { LibraryController } from '@app/immich';
 import { LibraryType } from '@app/infra/entities';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${LibraryController.name} (e2e)`, () => {

server/e2e/api/specs/oauth.e2e-spec.ts

@@ -1,7 +1,7 @@
 import { OAuthController } from '@app/immich';
 import { errorStub } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${OAuthController.name} (e2e)`, () => {

server/e2e/api/specs/partner.e2e-spec.ts

@@ -2,7 +2,7 @@ import { LoginResponseDto, PartnerDirection } from '@app/domain';
 import { PartnerController } from '@app/immich';
 import { errorStub, userDto } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${PartnerController.name} (e2e)`, () => {

server/e2e/api/specs/person.e2e-spec.ts

@@ -4,7 +4,7 @@ import { PersonEntity } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
 import { errorStub, uuidStub } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${PersonController.name}`, () => {

server/e2e/api/specs/search.e2e-spec.ts

@@ -10,7 +10,7 @@ import { SearchController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
 import { errorStub, searchStub } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { generateAsset, testApp } from '../utils';
 
 describe(`${SearchController.name}`, () => {

server/e2e/api/specs/server-info.e2e-spec.ts

@@ -2,7 +2,7 @@ import { LoginResponseDto } from '@app/domain';
 import { ServerInfoController } from '@app/immich';
 import { errorStub, userDto } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${ServerInfoController.name} (e2e)`, () => {

server/e2e/api/specs/shared-link.e2e-spec.ts

@@ -11,7 +11,7 @@ import { INestApplication } from '@nestjs/common';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
 import { DateTime } from 'luxon';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${SharedLinkController.name} (e2e)`, () => {

server/e2e/api/specs/system-config.e2e-spec.ts

@@ -2,7 +2,7 @@ import { LoginResponseDto } from '@app/domain';
 import { SystemConfigController } from '@app/immich';
 import { errorStub, userDto } from '@test/fixtures';
 import request from 'supertest';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${SystemConfigController.name} (e2e)`, () => {

server/e2e/api/specs/user.e2e-spec.ts

@@ -6,7 +6,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 import { errorStub, userDto, userSignupStub, userStub } from '@test/fixtures';
 import request from 'supertest';
 import { Repository } from 'typeorm';
-import { api } from '../client';
+import { api } from '../../client';
 import { testApp } from '../utils';
 
 describe(`${UserController.name}`, () => {

server/e2e/client/asset-api.ts

@@ -4,7 +4,7 @@ import { AssetFileUploadResponseDto } from '@app/immich/api-v1/asset/response-dt
 import { randomBytes } from 'crypto';
 import request from 'supertest';
 
-type UploadDto = Partial<CreateAssetDto> & { content?: Buffer };
+type UploadDto = Partial<CreateAssetDto> & { content?: Buffer; filename?: string };
 
 const asset = {
   deviceAssetId: 'test-1',
@@ -45,19 +45,19 @@ export const assetApi = {
     expect(status).toBe(200);
     return body as AssetResponseDto[];
   },
-  upload: async (server: any, accessToken: string, id: string, dto: UploadDto = {}) => {
-    const { content, isFavorite = false, isArchived = false } = dto;
+  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', id)
+      .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), 'example.jpg');
+      .attach('assetData', content || randomBytes(32), filename || 'example.jpg');
 
     expect(status).toBe(201);
     return body as AssetFileUploadResponseDto;

server/e2e/docker-compose.server-e2e.yml

@@ -9,8 +9,7 @@ services:
       context: ../../
       dockerfile: server/Dockerfile
       target: dev
-    entrypoint: ['/usr/local/bin/npm', 'run']
-    command: e2e:jobs
+    command: ['/usr/src/app/bin/immich-test', 'jobs']
     volumes:
       - /usr/src/app/node_modules
     environment:
@@ -18,7 +17,6 @@ services:
       - DB_USERNAME=postgres
       - DB_PASSWORD=postgres
       - DB_DATABASE_NAME=e2e_test
-      - IMMICH_RUN_ALL_TESTS=true
     depends_on:
       - database
 

server/e2e/jobs/client/asset-api.ts

@@ -1,79 +0,0 @@
-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 'crypto';
-import request from 'supertest';
-
-type UploadDto = Partial<CreateAssetDto> & { content?: Buffer };
-
-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/assetById/${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, id: string, dto: UploadDto = {}) => {
-    const { content, isFavorite = false, isArchived = false } = dto;
-    const { body, status } = await request(server)
-      .post('/asset/upload')
-      .set('Authorization', `Bearer ${accessToken}`)
-      .field('deviceAssetId', id)
-      .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), '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/jobs/client/auth-api.ts

@@ -1,45 +0,0 @@
-import { AuthDeviceResponseDto, LoginCredentialDto, LoginResponseDto, UserResponseDto } from '@app/domain';
-import { adminSignupStub, loginResponseStub, loginStub } from '@test';
-import request from 'supertest';
-
-export const authApi = {
-  adminSignUp: async (server: any) => {
-    const { status, body } = await request(server).post('/auth/admin-sign-up').send(adminSignupStub);
-
-    expect(status).toBe(201);
-
-    return body as UserResponseDto;
-  },
-  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;
-  },
-  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 { status, body } = await request(server)
-      .post('/auth/validateToken')
-      .set('Authorization', `Bearer ${accessToken}`);
-    expect(body).toEqual({ authStatus: true });
-    expect(status).toBe(200);
-  },
-};

server/e2e/jobs/client/index.ts

@@ -1,11 +0,0 @@
-import { assetApi } from './asset-api';
-import { authApi } from './auth-api';
-import { libraryApi } from './library-api';
-import { userApi } from './user-api';
-
-export const api = {
-  authApi,
-  assetApi,
-  libraryApi,
-  userApi,
-};

server/e2e/jobs/client/library-api.ts

@@ -1,47 +0,0 @@
-import { CreateLibraryDto, LibraryResponseDto, LibraryStatsResponseDto, ScanLibraryDto } from '@app/domain';
-import request from 'supertest';
-
-export const libraryApi = {
-  getAll: async (server: any, accessToken: string) => {
-    const { body, status } = await request(server).get(`/library/`).set('Authorization', `Bearer ${accessToken}`);
-    expect(status).toBe(200);
-    return body as LibraryResponseDto[];
-  },
-  create: async (server: any, accessToken: string, dto: CreateLibraryDto) => {
-    const { body, status } = await request(server)
-      .post(`/library/`)
-      .set('Authorization', `Bearer ${accessToken}`)
-      .send(dto);
-    expect(status).toBe(201);
-    return body as LibraryResponseDto;
-  },
-  setImportPaths: async (server: any, accessToken: string, id: string, importPaths: string[]) => {
-    const { body, status } = await request(server)
-      .put(`/library/${id}`)
-      .set('Authorization', `Bearer ${accessToken}`)
-      .send({ importPaths });
-    expect(status).toBe(200);
-    return body as LibraryResponseDto;
-  },
-  scanLibrary: async (server: any, accessToken: string, id: string, dto: ScanLibraryDto = {}) => {
-    const { status } = await request(server)
-      .post(`/library/${id}/scan`)
-      .set('Authorization', `Bearer ${accessToken}`)
-      .send(dto);
-    expect(status).toBe(201);
-  },
-  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(201);
-  },
-  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;
-  },
-};

server/e2e/jobs/client/user-api.ts

@@ -1,50 +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;
-  },
-  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;
-  },
-  setExternalPath: async (server: any, accessToken: string, id: string, externalPath: string) => {
-    return await userApi.update(server, accessToken, { id, externalPath });
-  },
-  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;
-  },
-};

server/e2e/jobs/setup.ts

@@ -3,16 +3,6 @@ import { access } from 'fs/promises';
 import path from 'path';
 
 export default async () => {
-  const allTests: boolean = process.env.IMMICH_RUN_ALL_TESTS === 'true';
-
-  if (!allTests) {
-    console.warn(
-      `\n\n
-      *** Not running all server e2e tests. Run 'make test-e2e' to run all tests inside Docker (recommended)\n
-      *** or set 'IMMICH_RUN_ALL_TESTS=true' to run all tests (requires dependencies to be installed)\n`,
-    );
-  }
-
   let IMMICH_TEST_ASSET_PATH: string = '';
 
   if (process.env.IMMICH_TEST_ASSET_PATH === undefined) {

server/e2e/jobs/specs/formats.e2e-spec.ts

@@ -1,84 +1,43 @@
 import { LoginResponseDto } from '@app/domain';
-import { AssetType, LibraryType } from '@app/infra/entities';
-import { api } from '../client';
-import { IMMICH_TEST_ASSET_PATH, runAllTests, testApp } from '../utils';
+import { AssetType } from '@app/infra/entities';
+import { readFile } from 'fs/promises';
+import { basename, join } from 'path';
+import { api } from '../../client';
+import { IMMICH_TEST_ASSET_PATH, testApp } from '../utils';
 
-describe(`Supported file formats (e2e)`, () => {
-  let server: any;
-  let admin: LoginResponseDto;
+const JPEG = {
+  type: AssetType.IMAGE,
+  originalFileName: 'el_torcal_rocks',
+  resized: true,
+  exifInfo: {
+    dateTimeOriginal: '2012-08-05T11:39:59.000Z',
+    exifImageWidth: 512,
+    exifImageHeight: 341,
+    latitude: null,
+    longitude: null,
+    focalLength: 75,
+    iso: 200,
+    fNumber: 11,
+    exposureTime: '1/160',
+    fileSizeInByte: 53493,
+    make: 'SONY',
+    model: 'DSLR-A550',
+    orientation: null,
+    description: 'SONY DSC',
+  },
+};
 
-  interface FormatTest {
-    format: string;
-    path: string;
-    runTest: boolean;
-    expectedAsset: any;
-    expectedExif: any;
-  }
-
-  const formatTests: FormatTest[] = [
-    {
-      format: 'jpg',
-      path: 'jpg',
-      runTest: true,
-      expectedAsset: {
-        type: AssetType.IMAGE,
-        originalFileName: 'el_torcal_rocks',
-        resized: true,
-      },
-      expectedExif: {
-        dateTimeOriginal: '2012-08-05T11:39:59.000Z',
-        exifImageWidth: 512,
-        exifImageHeight: 341,
-        latitude: null,
-        longitude: null,
-        focalLength: 75,
-        iso: 200,
-        fNumber: 11,
-        exposureTime: '1/160',
-        fileSizeInByte: 53493,
-        make: 'SONY',
-        model: 'DSLR-A550',
-        orientation: null,
-        description: 'SONY DSC',
-      },
-    },
-    {
-      format: 'jpeg',
-      path: 'jpeg',
-      runTest: true,
-      expectedAsset: {
-        type: AssetType.IMAGE,
-        originalFileName: 'el_torcal_rocks',
-        resized: true,
-      },
-      expectedExif: {
-        dateTimeOriginal: '2012-08-05T11:39:59.000Z',
-        exifImageWidth: 512,
-        exifImageHeight: 341,
-        latitude: null,
-        longitude: null,
-        focalLength: 75,
-        iso: 200,
-        fNumber: 11,
-        exposureTime: '1/160',
-        fileSizeInByte: 53493,
-        make: 'SONY',
-        model: 'DSLR-A550',
-        orientation: null,
-        description: 'SONY DSC',
-      },
-    },
-    {
-      format: 'heic',
-      path: 'heic',
-      runTest: runAllTests,
-      expectedAsset: {
-        type: AssetType.IMAGE,
-        originalFileName: 'IMG_2682',
-        resized: true,
-        fileCreatedAt: '2019-03-21T16:04:22.348Z',
-      },
-      expectedExif: {
+const tests = [
+  { input: 'formats/jpg/el_torcal_rocks.jpg', expected: JPEG },
+  { input: 'formats/jpeg/el_torcal_rocks.jpeg', expected: JPEG },
+  {
+    input: 'formats/heic/IMG_2682.heic',
+    expected: {
+      type: AssetType.IMAGE,
+      originalFileName: 'IMG_2682',
+      resized: true,
+      fileCreatedAt: '2019-03-21T16:04:22.348Z',
+      exifInfo: {
         dateTimeOriginal: '2019-03-21T16:04:22.348Z',
         exifImageWidth: 4032,
         exifImageHeight: 3024,
@@ -95,16 +54,14 @@ describe(`Supported file formats (e2e)`, () => {
         timeZone: 'America/Chicago',
       },
     },
-    {
-      format: 'png',
-      path: 'png',
-      runTest: true,
-      expectedAsset: {
-        type: AssetType.IMAGE,
-        originalFileName: 'density_plot',
-        resized: true,
-      },
-      expectedExif: {
+  },
+  {
+    input: 'formats/png/density_plot.png',
+    expected: {
+      type: AssetType.IMAGE,
+      originalFileName: 'density_plot',
+      resized: true,
+      exifInfo: {
         exifImageWidth: 800,
         exifImageHeight: 800,
         latitude: null,
@@ -112,17 +69,15 @@ describe(`Supported file formats (e2e)`, () => {
         fileSizeInByte: 25408,
       },
     },
-    {
-      format: 'nef (Nikon D80)',
-      path: 'raw/Nikon/D80',
-      runTest: true,
-      expectedAsset: {
-        type: AssetType.IMAGE,
-        originalFileName: 'glarus',
-        resized: true,
-        fileCreatedAt: '2010-07-20T17:27:12.000Z',
-      },
-      expectedExif: {
+  },
+  {
+    input: 'formats/raw/Nikon/D80/glarus.nef',
+    expected: {
+      type: AssetType.IMAGE,
+      originalFileName: 'glarus',
+      resized: true,
+      fileCreatedAt: '2010-07-20T17:27:12.000Z',
+      exifInfo: {
         make: 'NIKON CORPORATION',
         model: 'NIKON D80',
         exposureTime: '1/200',
@@ -136,17 +91,15 @@ describe(`Supported file formats (e2e)`, () => {
         orientation: '1',
       },
     },
-    {
-      format: 'nef (Nikon D700)',
-      path: 'raw/Nikon/D700',
-      runTest: true,
-      expectedAsset: {
-        type: AssetType.IMAGE,
-        originalFileName: 'philadelphia',
-        resized: true,
-        fileCreatedAt: '2016-09-22T22:10:29.060Z',
-      },
-      expectedExif: {
+  },
+  {
+    input: 'formats/raw/Nikon/D700/philadelphia.nef',
+    expected: {
+      type: AssetType.IMAGE,
+      originalFileName: 'philadelphia',
+      resized: true,
+      fileCreatedAt: '2016-09-22T22:10:29.060Z',
+      exifInfo: {
         make: 'NIKON CORPORATION',
         model: 'NIKON D700',
         exposureTime: '1/400',
@@ -161,41 +114,45 @@ describe(`Supported file formats (e2e)`, () => {
         timeZone: 'UTC-5',
       },
     },
-  ];
+  },
+];
 
-  // Only run tests with runTest = true
-  const testsToRun = formatTests.filter((formatTest) => formatTest.runTest);
+describe(`Format (e2e)`, () => {
+  let server: any;
+  let admin: LoginResponseDto;
 
   beforeAll(async () => {
-    server = (await testApp.create({ jobs: true })).getHttpServer();
-  });
-
-  afterAll(async () => {
-    await testApp.teardown();
+    const app = await testApp.create();
+    server = app.getHttpServer();
   });
 
   beforeEach(async () => {
     await testApp.reset();
     await api.authApi.adminSignUp(server);
     admin = await api.authApi.adminLogin(server);
-    await api.userApi.setExternalPath(server, admin.accessToken, admin.userId, '/');
   });
 
-  it.each(testsToRun)('should import file of format $format', async (testedFormat) => {
-    const library = await api.libraryApi.create(server, admin.accessToken, {
-      type: LibraryType.EXTERNAL,
-      importPaths: [`${IMMICH_TEST_ASSET_PATH}/formats/${testedFormat.path}`],
+  afterAll(async () => {
+    await testApp.teardown();
+  });
+
+  for (const { input, expected } of tests) {
+    it(`should generate a thumbnail for ${input}`, async () => {
+      const filepath = join(IMMICH_TEST_ASSET_PATH, input);
+      const content = await readFile(filepath);
+      await api.assetApi.upload(server, admin.accessToken, 'test-device-id', {
+        content,
+        filename: basename(filepath),
+      });
+      const assets = await api.assetApi.getAllAssets(server, admin.accessToken);
+
+      expect(assets).toHaveLength(1);
+
+      const asset = assets[0];
+
+      expect(asset.exifInfo).toBeDefined();
+      expect(asset.exifInfo).toMatchObject(expected.exifInfo);
+      expect(asset).toMatchObject(expected);
     });
-
-    await api.libraryApi.scanLibrary(server, admin.accessToken, library.id, {});
-
-    const assets = await api.assetApi.getAllAssets(server, admin.accessToken);
-
-    expect(assets).toEqual([
-      expect.objectContaining({
-        ...testedFormat.expectedAsset,
-        exifInfo: expect.objectContaining(testedFormat.expectedExif),
-      }),
-    ]);
-  });
+  }
 });

server/e2e/jobs/specs/library.e2e-spec.ts

@@ -5,7 +5,7 @@ import { errorStub, uuidStub } from '@test/fixtures';
 import * as fs from 'fs';
 import request from 'supertest';
 import { utimes } from 'utimes';
-import { api } from '../client';
+import { api } from '../../client';
 import { IMMICH_TEST_ASSET_PATH, IMMICH_TEST_ASSET_TEMP_PATH, restoreTempFolder, testApp } from '../utils';
 
 describe(`${LibraryController.name} (e2e)`, () => {
@@ -13,7 +13,7 @@ describe(`${LibraryController.name} (e2e)`, () => {
   let admin: LoginResponseDto;
 
   beforeAll(async () => {
-    server = (await testApp.create({ jobs: true })).getHttpServer();
+    server = (await testApp.create()).getHttpServer();
   });
 
   afterAll(async () => {
@@ -148,48 +148,6 @@ describe(`${LibraryController.name} (e2e)`, () => {
       );
     });
 
-    it('should scan external library with import paths', async () => {
-      const library = await api.libraryApi.create(server, admin.accessToken, {
-        type: LibraryType.EXTERNAL,
-        importPaths: [`${IMMICH_TEST_ASSET_PATH}/albums/nature`],
-      });
-      await api.userApi.setExternalPath(server, admin.accessToken, admin.userId, '/');
-
-      await api.libraryApi.scanLibrary(server, admin.accessToken, library.id);
-
-      const assets = await api.assetApi.getAllAssets(server, admin.accessToken);
-
-      expect(assets).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            type: AssetType.IMAGE,
-            originalFileName: 'el_torcal_rocks',
-            libraryId: library.id,
-            resized: true,
-            exifInfo: expect.objectContaining({
-              exifImageWidth: 512,
-              exifImageHeight: 341,
-              latitude: null,
-              longitude: null,
-            }),
-          }),
-          expect.objectContaining({
-            type: AssetType.IMAGE,
-            originalFileName: 'silver_fir',
-            libraryId: library.id,
-            resized: true,
-            thumbhash: expect.any(String),
-            exifInfo: expect.objectContaining({
-              exifImageWidth: 511,
-              exifImageHeight: 323,
-              latitude: null,
-              longitude: null,
-            }),
-          }),
-        ]),
-      );
-    });
-
     it('should offline missing files', async () => {
       await fs.promises.cp(`${IMMICH_TEST_ASSET_PATH}/albums/nature`, `${IMMICH_TEST_ASSET_TEMP_PATH}/albums/nature`, {
         recursive: true,

server/e2e/jobs/specs/metadata.e2e-spec.ts

@@ -2,17 +2,9 @@ import { AssetResponseDto, LoginResponseDto } from '@app/domain';
 import { AssetController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
 import { exiftool } from 'exiftool-vendored';
-import * as fs from 'fs';
-import { api } from '../client';
-import {
-  IMMICH_TEST_ASSET_PATH,
-  IMMICH_TEST_ASSET_TEMP_PATH,
-  db,
-  itif,
-  restoreTempFolder,
-  runAllTests,
-  testApp,
-} from '../utils';
+import { readFile, writeFile } from 'fs/promises';
+import { api } from '../../client';
+import { IMMICH_TEST_ASSET_PATH, IMMICH_TEST_ASSET_TEMP_PATH, db, restoreTempFolder, testApp } from '../utils';
 
 describe(`${AssetController.name} (e2e)`, () => {
   let app: INestApplication;
@@ -20,7 +12,7 @@ describe(`${AssetController.name} (e2e)`, () => {
   let admin: LoginResponseDto;
 
   beforeAll(async () => {
-    app = await testApp.create({ jobs: true });
+    app = await testApp.create();
     server = app.getHttpServer();
   });
 
@@ -40,9 +32,7 @@ describe(`${AssetController.name} (e2e)`, () => {
     let assetWithLocation: AssetResponseDto;
 
     beforeEach(async () => {
-      const fileContent = await fs.promises.readFile(
-        `${IMMICH_TEST_ASSET_PATH}/metadata/gps-position/thompson-springs.jpg`,
-      );
+      const fileContent = await readFile(`${IMMICH_TEST_ASSET_PATH}/metadata/gps-position/thompson-springs.jpg`);
 
       await api.assetApi.upload(server, admin.accessToken, 'test-asset-id', { content: fileContent });
 
@@ -58,12 +48,12 @@ describe(`${AssetController.name} (e2e)`, () => {
       );
     });
 
-    itif(runAllTests)('small webp thumbnails', async () => {
+    it('small webp thumbnails', async () => {
       const assetId = assetWithLocation.id;
 
       const thumbnail = await api.assetApi.getWebpThumbnail(server, admin.accessToken, assetId);
 
-      await fs.promises.writeFile(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.webp`, thumbnail);
+      await writeFile(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.webp`, thumbnail);
 
       const exifData = await exiftool.read(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.webp`);
 
@@ -71,12 +61,12 @@ describe(`${AssetController.name} (e2e)`, () => {
       expect(exifData).not.toHaveProperty('GPSLatitude');
     });
 
-    itif(runAllTests)('large jpeg thumbnails', async () => {
+    it('large jpeg thumbnails', async () => {
       const assetId = assetWithLocation.id;
 
       const thumbnail = await api.assetApi.getJpegThumbnail(server, admin.accessToken, assetId);
 
-      await fs.promises.writeFile(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.jpg`, thumbnail);
+      await writeFile(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.jpg`, thumbnail);
 
       const exifData = await exiftool.read(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.jpg`);
 
@@ -95,8 +85,8 @@ describe(`${AssetController.name} (e2e)`, () => {
     ['Samsung One UI 6.jpg', 'lT9Uviw/FFJYCjfIxAGPTjzAmmw='],
     ['Samsung One UI 6.heic', '/ejgzywvgvzvVhUYVfvkLzFBAF0='],
   ])('should extract motionphoto video', (file, checksum) => {
-    itif(runAllTests)(`with checksum ${checksum} from ${file}`, async () => {
-      const fileContent = await fs.promises.readFile(`${IMMICH_TEST_ASSET_PATH}/formats/motionphoto/${file}`);
+    it(`with checksum ${checksum} from ${file}`, async () => {
+      const fileContent = await readFile(`${IMMICH_TEST_ASSET_PATH}/formats/motionphoto/${file}`);
 
       const response = await api.assetApi.upload(server, admin.accessToken, 'test-asset-id', { content: fileContent });
       const asset = await api.assetApi.get(server, admin.accessToken, response.id);

server/e2e/jobs/utils.ts

@@ -12,7 +12,7 @@ import { Server } from 'tls';
 import { EntityTarget, ObjectLiteral } from 'typeorm';
 import { AppService } from '../../src/microservices/app.service';
 
-export const IMMICH_TEST_ASSET_PATH = process.env.IMMICH_TEST_ASSET_PATH;
+export const IMMICH_TEST_ASSET_PATH = process.env.IMMICH_TEST_ASSET_PATH as string;
 export const IMMICH_TEST_ASSET_TEMP_PATH = path.normalize(`${IMMICH_TEST_ASSET_PATH}/temp/`);
 
 export const today = DateTime.fromObject({ year: 2023, month: 11, day: 3 });
@@ -57,16 +57,10 @@ export const db = {
 
 let _handler: JobItemHandler = () => Promise.resolve();
 
-interface TestAppOptions {
-  jobs: boolean;
-}
-
 let app: INestApplication;
 
 export const testApp = {
-  create: async (options?: TestAppOptions): Promise<INestApplication> => {
-    const { jobs } = options || { jobs: false };
-
+  create: async (): Promise<INestApplication> => {
     const moduleFixture = await Test.createTestingModule({ imports: [AppModule], providers: [AppService] })
       .overrideModule(InfraModule)
       .useModule(InfraTestModule)
@@ -77,8 +71,8 @@ export const testApp = {
         updateCronJob: jest.fn(),
         deleteCronJob: jest.fn(),
         validateCronExpression: jest.fn(),
-        queue: (item: JobItem) => jobs && _handler(item),
-        queueAll: (items: JobItem[]) => jobs && Promise.all(items.map(_handler)).then(() => Promise.resolve()),
+        queue: (item: JobItem) => _handler(item),
+        queueAll: (items: JobItem[]) => Promise.all(items.map(_handler)).then(() => Promise.resolve()),
         resume: jest.fn(),
         empty: jest.fn(),
         setConcurrency: jest.fn(),
@@ -113,10 +107,6 @@ export const testApp = {
   },
 };
 
-export const runAllTests: boolean = process.env.IMMICH_RUN_ALL_TESTS === 'true';
-
-export const itif = (condition: boolean) => (condition ? it : it.skip);
-
 const directoryExists = async (dirPath: string) =>
   await fs.promises
     .access(dirPath)