test(server): full backend end-to-end testing with microservices (#4225)

* feat: asset e2e with job option

* feat: checkout test assets

* feat: library e2e tests

* fix: use node 21 in e2e

* fix: tests

* fix: use normalized external path

* feat: more external path tests

* chore: use parametrized tests

* chore: remove unused test code

* chore: refactor test asset path

* feat: centralize test app creation

* fix: correct error message for missing assets

* feat: test file formats

* fix: don't compare checksum

* feat: build libvips

* fix: install meson

* fix: use immich test asset repo

* feat: test nikon raw files

* fix: set Z timezone

* feat: test offline library files

* feat: richer metadata tests

* feat: e2e tests in docker

* feat: e2e test with arm64 docker

* fix: manual docker compose run

* fix: remove metadata processor import

* fix: run e2e tests in test.yml

* fix: checkout e2e assets

* fix: typo

* fix: checkout files in app directory

* fix: increase e2e memory

* fix: rm submodules

* fix: revert action name

* test: mark file offline when external path changes

* feat: rename env var to TEST_ENV

* docs: new test procedures

* feat: can run docker e2e tests manually if needed

* chore: use new node 20.8 for e2e

* chore: bump exiftool-vendored

* feat: simplify test launching

* fix: rename env vars to use immich_ prefix

* feat: asset folder is submodule

* chore: cleanup after 20.8 upgrade

* fix: don't log postgres in e2e

* fix: better warning about not running all tests

---------

Co-authored-by: Jonathan Jogenfors <jonathan@jogenfors.se>

server/test/api/asset-api.ts

@@ -7,13 +7,18 @@ import request from 'supertest';
 type UploadDto = Partial<CreateAssetDto> & { content?: Buffer };
 
 export const assetApi = {
-  get: async (server: any, accessToken: string, id: string) => {
+  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)

server/test/api/library-api.ts

@@ -1,4 +1,4 @@
-import { LibraryResponseDto } from '@app/domain';
+import { CreateLibraryDto, LibraryResponseDto, LibraryStatsResponseDto, ScanLibraryDto } from '@app/domain';
 import request from 'supertest';
 
 export const libraryApi = {
@@ -7,4 +7,41 @@ export const libraryApi = {
     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/test/api/user-api.ts

@@ -36,6 +36,9 @@ export const userApi = {
 
     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}`);
 

server/test/e2e/album.e2e-spec.ts

@@ -1,12 +1,12 @@
 import { AlbumResponseDto, LoginResponseDto } from '@app/domain';
-import { AlbumController, AppModule } from '@app/immich';
+import { AlbumController } from '@app/immich';
 import { AssetFileUploadResponseDto } from '@app/immich/api-v1/asset/response-dto/asset-file-upload-response.dto';
 import { SharedLinkType } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub, uuidStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 const user1SharedUser = 'user1SharedUser';
@@ -27,11 +27,8 @@ describe(`${AlbumController.name} (e2e)`, () => {
   let user2Albums: AlbumResponseDto[];
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
+    app = await createTestApp();
 
-    app = await moduleFixture.createNestApplication().init();
     server = app.getHttpServer();
   });
 

server/test/e2e/asset.e2e-spec.ts

@@ -6,13 +6,12 @@ import {
   LoginResponseDto,
   TimeBucketSize,
 } from '@app/domain';
-import { AppModule, AssetController } from '@app/immich';
+import { AssetController } from '@app/immich';
 import { AssetEntity, AssetType } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
-import { db } from '@test/db';
 import { errorStub, uuidStub } from '@test/fixtures';
+import { createTestApp, db } from '@test/test-utils';
 import { randomBytes } from 'crypto';
 import request from 'supertest';
 
@@ -85,11 +84,8 @@ describe(`${AssetController.name} (e2e)`, () => {
   let asset4: AssetEntity;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
+    app = await createTestApp();
 
-    app = await moduleFixture.createNestApplication().init();
     server = app.getHttpServer();
     assetRepository = app.get<IAssetRepository>(IAssetRepository);
   });
@@ -200,6 +196,27 @@ describe(`${AssetController.name} (e2e)`, () => {
       expect(status).toBe(200);
       expect(body.duplicate).toBe(true);
     });
+
+    it("should not upload to another user's library", async () => {
+      const content = randomBytes(32);
+      const library = (await api.libraryApi.getAll(server, user2.accessToken))[0];
+      await api.assetApi.upload(server, user1.accessToken, 'example-image', { content });
+
+      const { body, status } = await request(server)
+        .post('/asset/upload')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .field('libraryId', library.id)
+        .field('deviceAssetId', 'example-image')
+        .field('deviceId', 'TEST')
+        .field('fileCreatedAt', new Date().toISOString())
+        .field('fileModifiedAt', new Date().toISOString())
+        .field('isFavorite', false)
+        .field('duration', '0:00:00.000000')
+        .attach('assetData', content, 'example.jpg');
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest('Not found or no asset.upload access'));
+    });
   });
 
   describe('PUT /asset/:id', () => {

server/test/e2e/auth.e2e-spec.ts

@@ -1,6 +1,5 @@
-import { AppModule, AuthController } from '@app/immich';
+import { AuthController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import {
@@ -13,6 +12,7 @@ import {
   signupResponseStub,
   uuidStub,
 } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 const firstName = 'Immich';
@@ -26,11 +26,7 @@ describe(`${AuthController.name} (e2e)`, () => {
   let accessToken: string;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = await moduleFixture.createNestApplication().init();
+    app = await createTestApp();
     server = app.getHttpServer();
   });
 

server/test/e2e/formats.e2e-spec.ts

@@ -0,0 +1,206 @@
+import { LoginResponseDto } from '@app/domain';
+import { AssetType, LibraryType } from '@app/infra/entities';
+import { INestApplication } from '@nestjs/common';
+import { api } from '@test/api';
+import { IMMICH_TEST_ASSET_PATH, createTestApp, db, runAllTests } from '@test/test-utils';
+
+describe(`Supported file formats (e2e)`, () => {
+  let app: INestApplication;
+  let server: any;
+  let admin: LoginResponseDto;
+
+  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,
+      },
+    },
+    {
+      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,
+      },
+    },
+    {
+      format: 'heic',
+      path: 'heic',
+      runTest: runAllTests,
+      expectedAsset: {
+        type: AssetType.IMAGE,
+        originalFileName: 'IMG_2682',
+        resized: true,
+        fileCreatedAt: '2019-03-21T16:04:22.348Z',
+      },
+      expectedExif: {
+        dateTimeOriginal: '2019-03-21T16:04:22.348Z',
+        exifImageWidth: 4032,
+        exifImageHeight: 3024,
+        latitude: 41.2203,
+        longitude: -96.071625,
+        make: 'Apple',
+        model: 'iPhone 7',
+        lensModel: 'iPhone 7 back camera 3.99mm f/1.8',
+        fileSizeInByte: 880703,
+        exposureTime: '1/887',
+        iso: 20,
+        focalLength: 3.99,
+        fNumber: 1.8,
+        state: 'Douglas County, Nebraska',
+        timeZone: 'America/Chicago',
+        city: 'Ralston',
+        country: 'United States of America',
+      },
+    },
+    {
+      format: 'png',
+      path: 'png',
+      runTest: true,
+      expectedAsset: {
+        type: AssetType.IMAGE,
+        originalFileName: 'density_plot',
+        resized: true,
+      },
+      expectedExif: {
+        exifImageWidth: 800,
+        exifImageHeight: 800,
+        latitude: null,
+        longitude: null,
+        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: {
+        make: 'NIKON CORPORATION',
+        model: 'NIKON D80',
+        exposureTime: '1/200',
+        fNumber: 10,
+        focalLength: 18,
+        iso: 100,
+        fileSizeInByte: 9057784,
+        dateTimeOriginal: '2010-07-20T17:27:12.000Z',
+        latitude: null,
+        longitude: null,
+        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: {
+        make: 'NIKON CORPORATION',
+        model: 'NIKON D700',
+        exposureTime: '1/400',
+        fNumber: 11,
+        focalLength: 85,
+        iso: 200,
+        fileSizeInByte: 15856335,
+        dateTimeOriginal: '2016-09-22T22:10:29.060Z',
+        latitude: null,
+        longitude: null,
+        orientation: '1',
+        timeZone: 'UTC-5',
+      },
+    },
+  ];
+
+  // Only run tests with runTest = true
+  const testsToRun = formatTests.filter((formatTest) => formatTest.runTest);
+
+  beforeAll(async () => {
+    app = await createTestApp(true);
+    server = app.getHttpServer();
+  });
+
+  beforeEach(async () => {
+    await db.reset();
+    await api.authApi.adminSignUp(server);
+    admin = await api.authApi.adminLogin(server);
+    await api.userApi.setExternalPath(server, admin.accessToken, admin.userId, '/');
+  });
+
+  afterAll(async () => {
+    await db.disconnect();
+    await app.close();
+  });
+
+  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}`],
+    });
+
+    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/test/e2e/oauth.e2e-spec.ts

@@ -1,9 +1,9 @@
-import { AppModule, OAuthController } from '@app/immich';
+import { OAuthController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 describe(`${OAuthController.name} (e2e)`, () => {
@@ -11,11 +11,7 @@ describe(`${OAuthController.name} (e2e)`, () => {
   let server: any;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = await moduleFixture.createNestApplication().init();
+    app = await createTestApp();
     server = app.getHttpServer();
   });
 

server/test/e2e/partner.e2e-spec.ts

@@ -1,10 +1,10 @@
 import { IPartnerRepository, LoginResponseDto, PartnerDirection } from '@app/domain';
-import { AppModule, PartnerController } from '@app/immich';
+import { PartnerController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 const user1Dto = {
@@ -31,11 +31,7 @@ describe(`${PartnerController.name} (e2e)`, () => {
   let user2: LoginResponseDto;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = await moduleFixture.createNestApplication().init();
+    app = await createTestApp();
     server = app.getHttpServer();
     repository = app.get<IPartnerRepository>(IPartnerRepository);
   });

server/test/e2e/person.e2e-spec.ts

@@ -1,11 +1,11 @@
 import { IPersonRepository, LoginResponseDto } from '@app/domain';
-import { AppModule, PersonController } from '@app/immich';
+import { PersonController } from '@app/immich';
 import { PersonEntity } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub, uuidStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 describe(`${PersonController.name}`, () => {
@@ -18,11 +18,7 @@ describe(`${PersonController.name}`, () => {
   let hiddenPerson: PersonEntity;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = await moduleFixture.createNestApplication().init();
+    app = await createTestApp();
     server = app.getHttpServer();
     personRepository = app.get<IPersonRepository>(IPersonRepository);
   });

server/test/e2e/server-info.e2e-spec.ts

@@ -1,10 +1,10 @@
 import { LoginResponseDto } from '@app/domain';
-import { AppModule, ServerInfoController } from '@app/immich';
+import { ServerInfoController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 describe(`${ServerInfoController.name} (e2e)`, () => {
@@ -14,11 +14,7 @@ describe(`${ServerInfoController.name} (e2e)`, () => {
   let loginResponse: LoginResponseDto;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = await moduleFixture.createNestApplication().init();
+    app = await createTestApp();
     server = app.getHttpServer();
   });
 
@@ -81,9 +77,9 @@ describe(`${ServerInfoController.name} (e2e)`, () => {
       const { status, body } = await request(server).get('/server-info/features');
       expect(status).toBe(200);
       expect(body).toEqual({
-        clipEncode: true,
+        clipEncode: false,
         configFile: false,
-        facialRecognition: true,
+        facialRecognition: false,
         map: true,
         reverseGeocoding: true,
         oauth: false,
@@ -91,7 +87,7 @@ describe(`${ServerInfoController.name} (e2e)`, () => {
         passwordLogin: true,
         search: false,
         sidecar: true,
-        tagImage: true,
+        tagImage: false,
         trash: true,
       });
     });

server/test/e2e/setup.ts

@@ -1,21 +1,55 @@
 import { PostgreSqlContainer } from '@testcontainers/postgresql';
-import { GenericContainer } from 'testcontainers';
+import * as fs from 'fs';
+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 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) {
+    IMMICH_TEST_ASSET_PATH = path.normalize(`${__dirname}/../assets/`);
+    process.env.IMMICH_TEST_ASSET_PATH = IMMICH_TEST_ASSET_PATH;
+  } else {
+    IMMICH_TEST_ASSET_PATH = process.env.IMMICH_TEST_ASSET_PATH;
+  }
+
+  const directoryExists = async (dirPath: string) =>
+    await fs.promises
+      .access(dirPath)
+      .then(() => true)
+      .catch(() => false);
+
+  if (!(await directoryExists(`${IMMICH_TEST_ASSET_PATH}/albums`))) {
+    throw new Error(
+      `Test assets not found. Please checkout https://github.com/immich-app/test-assets into ${IMMICH_TEST_ASSET_PATH} before testing`,
+    );
+  }
+
+  if (process.env.DB_HOSTNAME === undefined) {
+    // DB hostname not set which likely means we're not running e2e through docker compose. Start a local postgres container.
+    const pg = await new PostgreSqlContainer('postgres')
+      .withExposedPorts(5432)
+      .withDatabase('immich')
+      .withUsername('postgres')
+      .withPassword('postgres')
+      .withReuse()
+      .start();
+
+    process.env.DB_URL = pg.getConnectionUri();
+  }
+
   process.env.NODE_ENV = 'development';
   process.env.TYPESENSE_ENABLED = 'false';
-
-  const pg = await new PostgreSqlContainer('postgres')
-    .withExposedPorts(5432)
-    .withDatabase('immich')
-    .withUsername('postgres')
-    .withPassword('postgres')
-    .withReuse()
-    .start();
-
-  process.env.DB_URL = pg.getConnectionUri();
-
-  const redis = await new GenericContainer('redis').withExposedPorts(6379).withReuse().start();
-
-  process.env.REDIS_PORT = String(redis.getMappedPort(6379));
-  process.env.REDIS_HOSTNAME = redis.getHost();
+  process.env.IMMICH_MACHINE_LEARNING_ENABLED = 'false';
+  process.env.IMMICH_TEST_ENV = 'true';
+  process.env.TZ = 'Z';
 };

server/test/e2e/shared-link.e2e-spec.ts

@@ -1,11 +1,11 @@
 import { AlbumResponseDto, LoginResponseDto, SharedLinkResponseDto } from '@app/domain';
-import { AppModule, PartnerController } from '@app/immich';
+import { PartnerController } from '@app/immich';
 import { SharedLinkType } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub, uuidStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 
 const user1Dto = {
@@ -25,11 +25,7 @@ describe(`${PartnerController.name} (e2e)`, () => {
   let sharedLink: SharedLinkResponseDto;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = await moduleFixture.createNestApplication().init();
+    app = await createTestApp();
     server = app.getHttpServer();
   });
 

server/test/e2e/user.e2e-spec.ts

@@ -2,10 +2,10 @@ import { LoginResponseDto, UserResponseDto, UserService } from '@app/domain';
 import { AppModule, UserController } from '@app/immich';
 import { UserEntity } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
 import { api } from '@test/api';
 import { db } from '@test/db';
 import { errorStub, userSignupStub, userStub } from '@test/fixtures';
+import { createTestApp } from '@test/test-utils';
 import request from 'supertest';
 import { Repository } from 'typeorm';
 
@@ -18,12 +18,9 @@ describe(`${UserController.name}`, () => {
   let userRepository: Repository<UserEntity>;
 
   beforeAll(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
+    app = await createTestApp();
+    userRepository = app.select(AppModule).get('UserEntityRepository');
 
-    app = await moduleFixture.createNestApplication().init();
-    userRepository = moduleFixture.get('UserEntityRepository');
     server = app.getHttpServer();
   });
 

server/test/test-utils.ts

@@ -1,22 +1,15 @@
-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';
+
+import { IJobRepository, JobItem, JobItemHandler, QueueName } from '@app/domain';
+import { AppModule } from '@app/immich';
+import { INestApplication, Logger } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import * as fs from 'fs';
+import path from 'path';
+import { AppService } from '../src/microservices/app.service';
+
+export const IMMICH_TEST_ASSET_PATH = process.env.IMMICH_TEST_ASSET_PATH;
+export const IMMICH_TEST_ASSET_TEMP_PATH = path.normalize(`${IMMICH_TEST_ASSET_PATH}/temp/`);
 
 export const db = {
   reset: async () => {
@@ -41,135 +34,53 @@ export const db = {
   },
 };
 
-export function getAuthUser(): AuthUserDto {
-  return {
-    id: '3108ac14-8afb-4b7e-87fd-39ebb6b79750',
-    email: 'test@email.com',
-    isAdmin: false,
-  };
+let _handler: JobItemHandler = () => Promise.resolve();
+
+export async function createTestApp(runJobs = false, log = false): Promise<INestApplication> {
+  const moduleBuilder = Test.createTestingModule({
+    imports: [AppModule],
+    providers: [AppService],
+  })
+    .overrideProvider(IJobRepository)
+    .useValue({
+      addHandler: (_queueName: QueueName, _concurrency: number, handler: JobItemHandler) => (_handler = handler),
+      queue: (item: JobItem) => runJobs && _handler(item),
+      resume: jest.fn(),
+      empty: jest.fn(),
+      setConcurrency: jest.fn(),
+      getQueueStatus: jest.fn(),
+      getJobCounts: jest.fn(),
+      pause: jest.fn(),
+    } as IJobRepository);
+
+  const moduleFixture: TestingModule = await moduleBuilder.compile();
+
+  const app = moduleFixture.createNestApplication();
+  if (log) {
+    app.useLogger(new Logger());
+  } else {
+    app.useLogger(false);
+  }
+  await app.init();
+  const appService = app.get(AppService);
+  await appService.init();
+
+  return app;
 }
 
-export const api = {
-  adminSignUp: async (server: any) => {
-    const { status, body } = await request(server).post('/auth/admin-sign-up').send(adminSignupStub);
+export const runAllTests: boolean = process.env.IMMICH_RUN_ALL_TESTS === 'true';
 
-    expect(status).toBe(201);
-    expect(body).toEqual(signupResponseStub);
+const directoryExists = async (dirPath: string) =>
+  await fs.promises
+    .access(dirPath)
+    .then(() => true)
+    .catch(() => false);
 
-    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;
+export async function restoreTempFolder(): Promise<void> {
+  if (await directoryExists(`${IMMICH_TEST_ASSET_TEMP_PATH}`)) {
+    // Temp directory exists, delete all files inside it
+    await fs.promises.rm(IMMICH_TEST_ASSET_TEMP_PATH, { recursive: true });
+  }
+  // Create temp folder
+  await fs.promises.mkdir(IMMICH_TEST_ASSET_TEMP_PATH);
+}