refactor(server): split api and jobs into separate e2e suites (#6307)

* refactor: domain and infra modules

* refactor(server): e2e tests

server/e2e/api/jest-e2e.json

@@ -2,9 +2,9 @@
   "moduleFileExtensions": ["js", "json", "ts"],
   "modulePaths": ["<rootDir>"],
   "rootDir": "../..",
-  "globalSetup": "<rootDir>/test/e2e/setup.ts",
+  "globalSetup": "<rootDir>/e2e/api/setup.ts",
   "testEnvironment": "node",
-  "testRegex": ".e2e-spec.ts$",
+  "testMatch": ["**/e2e/api/specs/*.e2e-spec.[tj]s"],
   "testTimeout": 60000,
   "transform": {
     "^.+\\.(t|j)s$": "ts-jest"

server/e2e/api/setup.ts

@@ -0,0 +1,16 @@
+import { PostgreSqlContainer } from '@testcontainers/postgresql';
+
+export default async () => {
+  const pg = await new PostgreSqlContainer('tensorchord/pgvecto-rs:pg14-v0.1.11')
+    .withDatabase('immich')
+    .withUsername('postgres')
+    .withPassword('postgres')
+    .withReuse()
+    .withCommand(['-c', 'fsync=off', '-c', 'shared_preload_libraries=vectors.so'])
+    .start();
+
+  process.env.DB_URL = pg.getConnectionUri();
+  process.env.NODE_ENV = 'development';
+  process.env.LOG_LEVEL = 'fatal';
+  process.env.TZ = 'Z';
+};

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

@@ -2,10 +2,10 @@ import { AlbumResponseDto, LoginResponseDto, ReactionType } from '@app/domain';
 import { ActivityController } from '@app/immich';
 import { AssetFileUploadResponseDto } from '@app/immich/api-v1/asset/response-dto/asset-file-upload-response.dto';
 import { ActivityEntity } from '@app/infra/entities';
-import { api } from '@test/api';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import request from 'supertest';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 describe(`${ActivityController.name} (e2e)`, () => {
   let server: any;

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

@@ -2,10 +2,10 @@ import { AlbumResponseDto, LoginResponseDto } from '@app/domain';
 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 { api } from '@test/api';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import request from 'supertest';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 const user1SharedUser = 'user1SharedUser';
 const user1SharedLink = 'user1SharedLink';

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

@@ -13,11 +13,11 @@ import { AssetController } from '@app/immich';
 import { AssetEntity, AssetType, SharedLinkType } from '@app/infra/entities';
 import { AssetRepository } from '@app/infra/repositories';
 import { INestApplication } from '@nestjs/common';
-import { api } from '@test/api';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
-import { generateAsset, testApp, today, yesterday } from '@test/test-utils';
 import { randomBytes } from 'crypto';
 import request from 'supertest';
+import { api } from '../client';
+import { generateAsset, testApp, today, yesterday } from '../utils';
 
 const makeUploadDto = (options?: { omit: string }): Record<string, any> => {
   const dto: Record<string, any> = {

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

@@ -1,5 +1,4 @@
 import { AuthController } from '@app/immich';
-import { api } from '@test/api';
 import {
   adminSignupStub,
   changePasswordStub,
@@ -9,8 +8,9 @@ import {
   loginStub,
   uuidStub,
 } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import request from 'supertest';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 const name = 'Immich Admin';
 const password = 'Password123';

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

@@ -0,0 +1,387 @@
+import { LibraryResponseDto, LoginResponseDto } from '@app/domain';
+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 { testApp } from '../utils';
+
+describe(`${LibraryController.name} (e2e)`, () => {
+  let server: any;
+  let admin: LoginResponseDto;
+
+  beforeAll(async () => {
+    server = (await testApp.create()).getHttpServer();
+  });
+
+  afterAll(async () => {
+    await testApp.teardown();
+  });
+
+  beforeEach(async () => {
+    await testApp.reset();
+    await api.authApi.adminSignUp(server);
+    admin = await api.authApi.adminLogin(server);
+  });
+
+  describe('GET /library', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/library');
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should start with a default upload library', async () => {
+      const { status, body } = await request(server)
+        .get('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`);
+      expect(status).toBe(200);
+      expect(body).toHaveLength(1);
+      expect(body).toEqual([
+        expect.objectContaining({
+          ownerId: admin.userId,
+          type: LibraryType.UPLOAD,
+          name: 'Default Library',
+          refreshedAt: null,
+          assetCount: 0,
+          importPaths: [],
+          exclusionPatterns: [],
+        }),
+      ]);
+    });
+  });
+
+  describe('POST /library', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).post('/library').send({});
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should create an external library with defaults', async () => {
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({ type: LibraryType.EXTERNAL });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(
+        expect.objectContaining({
+          ownerId: admin.userId,
+          type: LibraryType.EXTERNAL,
+          name: 'New External Library',
+          refreshedAt: null,
+          assetCount: 0,
+          importPaths: [],
+          exclusionPatterns: [],
+        }),
+      );
+    });
+
+    it('should create an external library with options', async () => {
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({
+          type: LibraryType.EXTERNAL,
+          name: 'My Awesome Library',
+          importPaths: ['/path/to/import'],
+          exclusionPatterns: ['**/Raw/**'],
+        });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(
+        expect.objectContaining({
+          name: 'My Awesome Library',
+          importPaths: ['/path/to/import'],
+        }),
+      );
+    });
+
+    it('should create an upload library with defaults', async () => {
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({ type: LibraryType.UPLOAD });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(
+        expect.objectContaining({
+          ownerId: admin.userId,
+          type: LibraryType.UPLOAD,
+          name: 'New Upload Library',
+          refreshedAt: null,
+          assetCount: 0,
+          importPaths: [],
+          exclusionPatterns: [],
+        }),
+      );
+    });
+
+    it('should create an upload library with options', async () => {
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({ type: LibraryType.UPLOAD, name: 'My Awesome Library' });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(
+        expect.objectContaining({
+          name: 'My Awesome Library',
+        }),
+      );
+    });
+
+    it('should not allow upload libraries to have import paths', async () => {
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({ type: LibraryType.UPLOAD, importPaths: ['/path/to/import'] });
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest('Upload libraries cannot have import paths'));
+    });
+
+    it('should not allow upload libraries to have exclusion patterns', async () => {
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({ type: LibraryType.UPLOAD, exclusionPatterns: ['**/Raw/**'] });
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest('Upload libraries cannot have exclusion patterns'));
+    });
+
+    it('should allow a non-admin to create a library', async () => {
+      await api.userApi.create(server, admin.accessToken, userDto.user1);
+      const user1 = await api.authApi.login(server, userDto.user1);
+
+      const { status, body } = await request(server)
+        .post('/library')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ type: LibraryType.EXTERNAL });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(
+        expect.objectContaining({
+          ownerId: user1.userId,
+          type: LibraryType.EXTERNAL,
+          name: 'New External Library',
+          refreshedAt: null,
+          assetCount: 0,
+          importPaths: [],
+          exclusionPatterns: [],
+        }),
+      );
+    });
+  });
+
+  describe('PUT /library/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).put(`/library/${uuidStub.notFound}`).send({});
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    describe('external library', () => {
+      let library: LibraryResponseDto;
+
+      beforeEach(async () => {
+        // Create an external library with default settings
+        library = await api.libraryApi.create(server, admin.accessToken, { type: LibraryType.EXTERNAL });
+      });
+
+      it('should change the library name', async () => {
+        const { status, body } = await request(server)
+          .put(`/library/${library.id}`)
+          .set('Authorization', `Bearer ${admin.accessToken}`)
+          .send({ name: 'New Library Name' });
+
+        expect(status).toBe(200);
+        expect(body).toEqual(
+          expect.objectContaining({
+            name: 'New Library Name',
+          }),
+        );
+      });
+
+      it('should not set an empty name', async () => {
+        const { status, body } = await request(server)
+          .put(`/library/${library.id}`)
+          .set('Authorization', `Bearer ${admin.accessToken}`)
+          .send({ name: '' });
+
+        expect(status).toBe(400);
+        expect(body).toEqual(errorStub.badRequest(['name should not be empty']));
+      });
+
+      it('should change the import paths', async () => {
+        const { status, body } = await request(server)
+          .put(`/library/${library.id}`)
+          .set('Authorization', `Bearer ${admin.accessToken}`)
+          .send({ importPaths: ['/path/to/import'] });
+
+        expect(status).toBe(200);
+        expect(body).toEqual(
+          expect.objectContaining({
+            importPaths: ['/path/to/import'],
+          }),
+        );
+      });
+
+      it('should not allow an empty import path', async () => {
+        const { status, body } = await request(server)
+          .put(`/library/${library.id}`)
+          .set('Authorization', `Bearer ${admin.accessToken}`)
+          .send({ importPaths: [''] });
+
+        expect(status).toBe(400);
+        expect(body).toEqual(errorStub.badRequest(['each value in importPaths should not be empty']));
+      });
+
+      it('should change the exclusion pattern', async () => {
+        const { status, body } = await request(server)
+          .put(`/library/${library.id}`)
+          .set('Authorization', `Bearer ${admin.accessToken}`)
+          .send({ exclusionPatterns: ['**/Raw/**'] });
+
+        expect(status).toBe(200);
+        expect(body).toEqual(
+          expect.objectContaining({
+            exclusionPatterns: ['**/Raw/**'],
+          }),
+        );
+      });
+
+      it('should not allow an empty exclusion pattern', async () => {
+        const { status, body } = await request(server)
+          .put(`/library/${library.id}`)
+          .set('Authorization', `Bearer ${admin.accessToken}`)
+          .send({ exclusionPatterns: [''] });
+
+        expect(status).toBe(400);
+        expect(body).toEqual(errorStub.badRequest(['each value in exclusionPatterns should not be empty']));
+      });
+    });
+  });
+
+  describe('GET /library/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get(`/library/${uuidStub.notFound}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should get library by id', async () => {
+      const library = await api.libraryApi.create(server, admin.accessToken, { type: LibraryType.EXTERNAL });
+
+      const { status, body } = await request(server)
+        .get(`/library/${library.id}`)
+        .set('Authorization', `Bearer ${admin.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual(
+        expect.objectContaining({
+          ownerId: admin.userId,
+          type: LibraryType.EXTERNAL,
+          name: 'New External Library',
+          refreshedAt: null,
+          assetCount: 0,
+          importPaths: [],
+          exclusionPatterns: [],
+        }),
+      );
+    });
+
+    it("should not allow getting another user's library", async () => {
+      await Promise.all([
+        api.userApi.create(server, admin.accessToken, userDto.user1),
+        api.userApi.create(server, admin.accessToken, userDto.user2),
+      ]);
+
+      const [user1, user2] = await Promise.all([
+        api.authApi.login(server, userDto.user1),
+        api.authApi.login(server, userDto.user2),
+      ]);
+
+      const library = await api.libraryApi.create(server, user1.accessToken, { type: LibraryType.EXTERNAL });
+
+      const { status, body } = await request(server)
+        .get(`/library/${library.id}`)
+        .set('Authorization', `Bearer ${user2.accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest('Not found or no library.read access'));
+    });
+  });
+
+  describe('DELETE /library/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).delete(`/library/${uuidStub.notFound}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should not delete the last upload library', async () => {
+      const [defaultLibrary] = await api.libraryApi.getAll(server, admin.accessToken);
+      expect(defaultLibrary).toBeDefined();
+
+      const { status, body } = await request(server)
+        .delete(`/library/${defaultLibrary.id}`)
+        .set('Authorization', `Bearer ${admin.accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.noDeleteUploadLibrary);
+    });
+
+    it('should delete an empty library', async () => {
+      const library = await api.libraryApi.create(server, admin.accessToken, { type: LibraryType.EXTERNAL });
+
+      const { status, body } = await request(server)
+        .delete(`/library/${library.id}`)
+        .set('Authorization', `Bearer ${admin.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual({});
+
+      const libraries = await api.libraryApi.getAll(server, admin.accessToken);
+      expect(libraries).toHaveLength(1);
+      expect(libraries).not.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: library.id,
+          }),
+        ]),
+      );
+    });
+  });
+
+  describe('GET /library/:id/statistics', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get(`/library/${uuidStub.notFound}/statistics`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+  });
+
+  describe('POST /library/:id/scan', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).post(`/library/${uuidStub.notFound}/scan`).send({});
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+  });
+
+  describe('POST /library/:id/removeOffline', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).post(`/library/${uuidStub.notFound}/removeOffline`).send({});
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+  });
+});

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

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

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

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

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

@@ -2,10 +2,10 @@ import { IPersonRepository, LoginResponseDto } from '@app/domain';
 import { PersonController } from '@app/immich';
 import { PersonEntity } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { api } from '@test/api';
 import { errorStub, uuidStub } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import request from 'supertest';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 describe(`${PersonController.name}`, () => {
   let app: INestApplication;

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

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

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

@@ -1,9 +1,9 @@
 import { LoginResponseDto } from '@app/domain';
 import { ServerInfoController } from '@app/immich';
-import { api } from '@test/api';
 import { errorStub, userDto } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import request from 'supertest';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 describe(`${ServerInfoController.name} (e2e)`, () => {
   let server: any;
@@ -73,11 +73,11 @@ describe(`${ServerInfoController.name} (e2e)`, () => {
       const { status, body } = await request(server).get('/server-info/features');
       expect(status).toBe(200);
       expect(body).toEqual({
-        clipEncode: false,
-        configFile: true,
-        facialRecognition: false,
+        clipEncode: true,
+        configFile: false,
+        facialRecognition: true,
         map: true,
-        reverseGeocoding: false,
+        reverseGeocoding: true,
         oauth: false,
         oauthAutoLaunch: false,
         passwordLogin: true,

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

@@ -8,11 +8,11 @@ import {
 import { SharedLinkController } from '@app/immich';
 import { SharedLinkType } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
-import { api } from '@test/api';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import { DateTime } from 'luxon';
 import request from 'supertest';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 describe(`${SharedLinkController.name} (e2e)`, () => {
   let server: any;

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

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

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

@@ -3,11 +3,11 @@ import { AppModule, UserController } from '@app/immich';
 import { UserEntity } from '@app/infra/entities';
 import { INestApplication } from '@nestjs/common';
 import { getRepositoryToken } from '@nestjs/typeorm';
-import { api } from '@test/api';
 import { errorStub, userDto, userSignupStub, userStub } from '@test/fixtures';
-import { testApp } from '@test/test-utils';
 import request from 'supertest';
 import { Repository } from 'typeorm';
+import { api } from '../client';
+import { testApp } from '../utils';
 
 describe(`${UserController.name}`, () => {
   let app: INestApplication;

server/e2e/api/utils.ts

@@ -0,0 +1,115 @@
+import { AssetCreate, IJobRepository, IMetadataRepository, LibraryResponseDto } from '@app/domain';
+import { AppModule } from '@app/immich';
+import { InfraModule, InfraTestModule, dataSource } from '@app/infra';
+import { AssetEntity, AssetType, LibraryType } from '@app/infra/entities';
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { randomBytes } from 'crypto';
+import { DateTime } from 'luxon';
+import { EntityTarget, ObjectLiteral } from 'typeorm';
+import { AppService } from '../../src/microservices/app.service';
+import { newJobRepositoryMock, newMetadataRepositoryMock } from '../../test';
+
+export const today = DateTime.fromObject({ year: 2023, month: 11, day: 3 });
+export const yesterday = today.minus({ days: 1 });
+
+export interface ResetOptions {
+  entities?: EntityTarget<ObjectLiteral>[];
+}
+export const db = {
+  reset: async (options?: ResetOptions) => {
+    if (!dataSource.isInitialized) {
+      await dataSource.initialize();
+    }
+    await dataSource.transaction(async (em) => {
+      const entities = options?.entities || [];
+      const tableNames =
+        entities.length > 0
+          ? entities.map((entity) => em.getRepository(entity).metadata.tableName)
+          : dataSource.entityMetadatas
+              .map((entity) => entity.tableName)
+              .filter((tableName) => !tableName.startsWith('geodata'));
+
+      let deleteUsers = false;
+      for (const tableName of tableNames) {
+        if (tableName === 'users') {
+          deleteUsers = true;
+          continue;
+        }
+        await em.query(`DELETE FROM ${tableName} CASCADE;`);
+      }
+      if (deleteUsers) {
+        await em.query(`DELETE FROM "users" CASCADE;`);
+      }
+    });
+  },
+  disconnect: async () => {
+    if (dataSource.isInitialized) {
+      await dataSource.destroy();
+    }
+  },
+};
+
+let app: INestApplication;
+
+export const testApp = {
+  create: async (): Promise<INestApplication> => {
+    const moduleFixture = await Test.createTestingModule({ imports: [AppModule], providers: [AppService] })
+      .overrideModule(InfraModule)
+      .useModule(InfraTestModule)
+      .overrideProvider(IJobRepository)
+      .useValue(newJobRepositoryMock())
+      .overrideProvider(IMetadataRepository)
+      .useValue(newMetadataRepositoryMock())
+      .compile();
+
+    app = await moduleFixture.createNestApplication().init();
+    await app.get(AppService).init();
+
+    return app;
+  },
+  reset: async (options?: ResetOptions) => {
+    await db.reset(options);
+  },
+  teardown: async () => {
+    if (app) {
+      await app.get(AppService).teardown();
+      await app.close();
+    }
+    await db.disconnect();
+  },
+};
+
+function randomDate(start: Date, end: Date): Date {
+  return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+}
+
+let assetCount = 0;
+export function generateAsset(
+  userId: string,
+  libraries: LibraryResponseDto[],
+  other: Partial<AssetEntity> = {},
+): AssetCreate {
+  const id = assetCount++;
+  const { fileCreatedAt = randomDate(new Date(1970, 1, 1), new Date(2023, 1, 1)) } = other;
+
+  return {
+    createdAt: today.toJSDate(),
+    updatedAt: today.toJSDate(),
+    ownerId: userId,
+    checksum: randomBytes(20),
+    originalPath: `/tests/test_${id}`,
+    deviceAssetId: `test_${id}`,
+    deviceId: 'e2e-test',
+    libraryId: (
+      libraries.find(({ ownerId, type }) => ownerId === userId && type === LibraryType.UPLOAD) as LibraryResponseDto
+    ).id,
+    isVisible: true,
+    fileCreatedAt,
+    fileModifiedAt: new Date(),
+    localDateTime: fileCreatedAt,
+    type: AssetType.IMAGE,
+    originalFileName: `test_${id}`,
+    ...other,
+  };
+}

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

@@ -10,7 +10,7 @@ services:
       dockerfile: server/Dockerfile
       target: dev
     entrypoint: ['/usr/local/bin/npm', 'run']
-    command: test:e2e
+    command: e2e:jobs
     volumes:
       - /usr/src/app/node_modules
     environment:
@@ -24,6 +24,7 @@ services:
 
   database:
     image: tensorchord/pgvecto-rs:pg14-v0.1.11@sha256:0335a1a22f8c5dd1b697f14f079934f5152eaaa216c09b61e293be285491f8ee
+    command: -c fsync=off -c shared_preload_libraries=vectors.so
     environment:
       POSTGRES_PASSWORD: postgres
       POSTGRES_USER: postgres

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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,50 @@
+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/jest-e2e.json

@@ -0,0 +1,24 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "modulePaths": ["<rootDir>"],
+  "rootDir": "../..",
+  "globalSetup": "<rootDir>/e2e/jobs/setup.ts",
+  "testEnvironment": "node",
+  "testMatch": ["**/e2e/jobs/specs/*.e2e-spec.[tj]s"],
+  "testTimeout": 60000,
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "collectCoverageFrom": [
+    "<rootDir>/src/**/*.(t|j)s",
+    "!<rootDir>/src/**/*.spec.(t|s)s",
+    "!<rootDir>/src/infra/migrations/**"
+  ],
+  "coverageDirectory": "./coverage",
+  "moduleNameMapper": {
+    "^@test(|/.*)$": "<rootDir>/test/$1",
+    "^@app/immich(|/.*)$": "<rootDir>/src/immich/$1",
+    "^@app/infra(|/.*)$": "<rootDir>/src/infra/$1",
+    "^@app/domain(|/.*)$": "<rootDir>/src/domain/$1"
+  }
+}

server/e2e/jobs/setup.ts

@@ -16,7 +16,7 @@ export default async () => {
   let IMMICH_TEST_ASSET_PATH: string = '';
 
   if (process.env.IMMICH_TEST_ASSET_PATH === undefined) {
-    IMMICH_TEST_ASSET_PATH = path.normalize(`${__dirname}/../assets/`);
+    IMMICH_TEST_ASSET_PATH = path.normalize(`${__dirname}/../../test/assets/`);
     process.env.IMMICH_TEST_ASSET_PATH = IMMICH_TEST_ASSET_PATH;
   } else {
     IMMICH_TEST_ASSET_PATH = process.env.IMMICH_TEST_ASSET_PATH;

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

@@ -1,7 +1,7 @@
 import { LoginResponseDto } from '@app/domain';
 import { AssetType, LibraryType } from '@app/infra/entities';
-import { api } from '@test/api';
-import { IMMICH_TEST_ASSET_PATH, runAllTests, testApp } from '@test/test-utils';
+import { api } from '../client';
+import { IMMICH_TEST_ASSET_PATH, runAllTests, testApp } from '../utils';
 
 describe(`Supported file formats (e2e)`, () => {
   let server: any;

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

@@ -1,12 +1,12 @@
 import { LibraryResponseDto, LoginResponseDto } from '@app/domain';
 import { LibraryController } from '@app/immich';
 import { AssetType, LibraryType } from '@app/infra/entities';
-import { api } from '@test/api';
-import { IMMICH_TEST_ASSET_PATH, IMMICH_TEST_ASSET_TEMP_PATH, restoreTempFolder, testApp } from '@test/test-utils';
+import { errorStub, uuidStub } from '@test/fixtures';
 import * as fs from 'fs';
 import request from 'supertest';
 import { utimes } from 'utimes';
-import { errorStub, userDto, uuidStub } from '../fixtures';
+import { api } from '../client';
+import { IMMICH_TEST_ASSET_PATH, IMMICH_TEST_ASSET_TEMP_PATH, restoreTempFolder, testApp } from '../utils';
 
 describe(`${LibraryController.name} (e2e)`, () => {
   let server: any;
@@ -28,365 +28,7 @@ describe(`${LibraryController.name} (e2e)`, () => {
     admin = await api.authApi.adminLogin(server);
   });
 
-  describe('GET /library', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).get('/library');
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    it('should start with a default upload library', async () => {
-      const { status, body } = await request(server)
-        .get('/library')
-        .set('Authorization', `Bearer ${admin.accessToken}`);
-      expect(status).toBe(200);
-      expect(body).toHaveLength(1);
-      expect(body).toEqual([
-        expect.objectContaining({
-          ownerId: admin.userId,
-          type: LibraryType.UPLOAD,
-          name: 'Default Library',
-          refreshedAt: null,
-          assetCount: 0,
-          importPaths: [],
-          exclusionPatterns: [],
-        }),
-      ]);
-    });
-  });
-
-  describe('POST /library', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).post('/library').send({});
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    describe('external library', () => {
-      it('with default settings', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.EXTERNAL });
-
-        expect(status).toBe(201);
-        expect(body).toEqual(
-          expect.objectContaining({
-            ownerId: admin.userId,
-            type: LibraryType.EXTERNAL,
-            name: 'New External Library',
-            refreshedAt: null,
-            assetCount: 0,
-            importPaths: [],
-            exclusionPatterns: [],
-          }),
-        );
-      });
-
-      it('with name', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.EXTERNAL, name: 'My Awesome Library' });
-
-        expect(status).toBe(201);
-        expect(body).toEqual(
-          expect.objectContaining({
-            name: 'My Awesome Library',
-          }),
-        );
-      });
-
-      it('with import paths', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.EXTERNAL, importPaths: ['/path/to/import'] });
-
-        expect(status).toBe(201);
-        expect(body).toEqual(
-          expect.objectContaining({
-            importPaths: ['/path/to/import'],
-          }),
-        );
-      });
-
-      it('with exclusion patterns', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.EXTERNAL, exclusionPatterns: ['**/Raw/**'] });
-
-        expect(status).toBe(201);
-        expect(body).toEqual(
-          expect.objectContaining({
-            exclusionPatterns: ['**/Raw/**'],
-          }),
-        );
-      });
-    });
-
-    describe('upload library', () => {
-      it('with default settings', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.UPLOAD });
-
-        expect(status).toBe(201);
-        expect(body).toEqual(
-          expect.objectContaining({
-            ownerId: admin.userId,
-            type: LibraryType.UPLOAD,
-            name: 'New Upload Library',
-            refreshedAt: null,
-            assetCount: 0,
-            importPaths: [],
-            exclusionPatterns: [],
-          }),
-        );
-      });
-
-      it('with name', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.UPLOAD, name: 'My Awesome Library' });
-
-        expect(status).toBe(201);
-        expect(body).toEqual(
-          expect.objectContaining({
-            name: 'My Awesome Library',
-          }),
-        );
-      });
-
-      it('with import paths should fail', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.UPLOAD, importPaths: ['/path/to/import'] });
-
-        expect(status).toBe(400);
-        expect(body).toEqual(errorStub.badRequest('Upload libraries cannot have import paths'));
-      });
-
-      it('with exclusion patterns should fail', async () => {
-        const { status, body } = await request(server)
-          .post('/library')
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ type: LibraryType.UPLOAD, exclusionPatterns: ['**/Raw/**'] });
-
-        expect(status).toBe(400);
-        expect(body).toEqual(errorStub.badRequest('Upload libraries cannot have exclusion patterns'));
-      });
-    });
-
-    it('should allow a user to create a library', async () => {
-      await api.userApi.create(server, admin.accessToken, userDto.user1);
-      const user1 = await api.authApi.login(server, userDto.user1);
-
-      const { status, body } = await request(server)
-        .post('/library')
-        .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ type: LibraryType.EXTERNAL });
-
-      expect(status).toBe(201);
-      expect(body).toEqual(
-        expect.objectContaining({
-          ownerId: user1.userId,
-          type: LibraryType.EXTERNAL,
-          name: 'New External Library',
-          refreshedAt: null,
-          assetCount: 0,
-          importPaths: [],
-          exclusionPatterns: [],
-        }),
-      );
-    });
-  });
-
-  describe('PUT /library/:id', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).put(`/library/${uuidStub.notFound}`).send({});
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    describe('external library', () => {
-      let library: LibraryResponseDto;
-
-      beforeEach(async () => {
-        // Create an external library with default settings
-        library = await api.libraryApi.create(server, admin.accessToken, { type: LibraryType.EXTERNAL });
-      });
-
-      it('should change the library name', async () => {
-        const { status, body } = await request(server)
-          .put(`/library/${library.id}`)
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ name: 'New Library Name' });
-
-        expect(status).toBe(200);
-        expect(body).toEqual(
-          expect.objectContaining({
-            name: 'New Library Name',
-          }),
-        );
-      });
-
-      it('should not set an empty name', async () => {
-        const { status, body } = await request(server)
-          .put(`/library/${library.id}`)
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ name: '' });
-
-        expect(status).toBe(400);
-        expect(body).toEqual(errorStub.badRequest(['name should not be empty']));
-      });
-
-      it('should change the import paths', async () => {
-        const { status, body } = await request(server)
-          .put(`/library/${library.id}`)
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ importPaths: ['/path/to/import'] });
-
-        expect(status).toBe(200);
-        expect(body).toEqual(
-          expect.objectContaining({
-            importPaths: ['/path/to/import'],
-          }),
-        );
-      });
-
-      it('should not allow an empty import path', async () => {
-        const { status, body } = await request(server)
-          .put(`/library/${library.id}`)
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ importPaths: [''] });
-
-        expect(status).toBe(400);
-        expect(body).toEqual(errorStub.badRequest(['each value in importPaths should not be empty']));
-      });
-
-      it('should change the exclusion pattern', async () => {
-        const { status, body } = await request(server)
-          .put(`/library/${library.id}`)
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ exclusionPatterns: ['**/Raw/**'] });
-
-        expect(status).toBe(200);
-        expect(body).toEqual(
-          expect.objectContaining({
-            exclusionPatterns: ['**/Raw/**'],
-          }),
-        );
-      });
-
-      it('should not allow an empty exclusion pattern', async () => {
-        const { status, body } = await request(server)
-          .put(`/library/${library.id}`)
-          .set('Authorization', `Bearer ${admin.accessToken}`)
-          .send({ exclusionPatterns: [''] });
-
-        expect(status).toBe(400);
-        expect(body).toEqual(errorStub.badRequest(['each value in exclusionPatterns should not be empty']));
-      });
-    });
-  });
-
-  describe('GET /library/:id', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).get(`/library/${uuidStub.notFound}`);
-
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    it('should get library by id', async () => {
-      const library = await api.libraryApi.create(server, admin.accessToken, { type: LibraryType.EXTERNAL });
-
-      const { status, body } = await request(server)
-        .get(`/library/${library.id}`)
-        .set('Authorization', `Bearer ${admin.accessToken}`);
-
-      expect(status).toBe(200);
-      expect(body).toEqual(
-        expect.objectContaining({
-          ownerId: admin.userId,
-          type: LibraryType.EXTERNAL,
-          name: 'New External Library',
-          refreshedAt: null,
-          assetCount: 0,
-          importPaths: [],
-          exclusionPatterns: [],
-        }),
-      );
-    });
-
-    it("should not allow getting another user's library", async () => {
-      await Promise.all([
-        api.userApi.create(server, admin.accessToken, userDto.user1),
-        api.userApi.create(server, admin.accessToken, userDto.user2),
-      ]);
-
-      const [user1, user2] = await Promise.all([
-        api.authApi.login(server, userDto.user1),
-        api.authApi.login(server, userDto.user2),
-      ]);
-
-      const library = await api.libraryApi.create(server, user1.accessToken, { type: LibraryType.EXTERNAL });
-
-      const { status, body } = await request(server)
-        .get(`/library/${library.id}`)
-        .set('Authorization', `Bearer ${user2.accessToken}`);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(errorStub.badRequest('Not found or no library.read access'));
-    });
-  });
-
   describe('DELETE /library/:id', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).delete(`/library/${uuidStub.notFound}`);
-
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    it('should not delete the last upload library', async () => {
-      const [defaultLibrary] = await api.libraryApi.getAll(server, admin.accessToken);
-      expect(defaultLibrary).toBeDefined();
-
-      const { status, body } = await request(server)
-        .delete(`/library/${defaultLibrary.id}`)
-        .set('Authorization', `Bearer ${admin.accessToken}`);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(errorStub.noDeleteUploadLibrary);
-    });
-
-    it('should delete an empty library', async () => {
-      const library = await api.libraryApi.create(server, admin.accessToken, { type: LibraryType.EXTERNAL });
-
-      const { status, body } = await request(server)
-        .delete(`/library/${library.id}`)
-        .set('Authorization', `Bearer ${admin.accessToken}`);
-
-      expect(status).toBe(200);
-      expect(body).toEqual({});
-
-      const libraries = await api.libraryApi.getAll(server, admin.accessToken);
-      expect(libraries).toHaveLength(1);
-      expect(libraries).not.toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: library.id,
-          }),
-        ]),
-      );
-    });
-
     it('should delete an external library with assets', async () => {
       const library = await api.libraryApi.create(server, admin.accessToken, {
         type: LibraryType.EXTERNAL,
@@ -418,15 +60,6 @@ describe(`${LibraryController.name} (e2e)`, () => {
     });
   });
 
-  describe('GET /library/:id/statistics', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).get(`/library/${uuidStub.notFound}/statistics`);
-
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-  });
-
   describe('POST /library/:id/scan', () => {
     it('should require authentication', async () => {
       const { status, body } = await request(server).post(`/library/${uuidStub.notFound}/scan`).send({});

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

@@ -1,9 +1,9 @@
 import { AssetResponseDto, LoginResponseDto } from '@app/domain';
 import { AssetController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
-import { api } from '@test/api';
+import { exiftool } from 'exiftool-vendored';
 import * as fs from 'fs';
-
+import { api } from '../client';
 import {
   IMMICH_TEST_ASSET_PATH,
   IMMICH_TEST_ASSET_TEMP_PATH,
@@ -12,8 +12,7 @@ import {
   restoreTempFolder,
   runAllTests,
   testApp,
-} from '@test/test-utils';
-import { exiftool } from 'exiftool-vendored';
+} from '../utils';
 
 describe(`${AssetController.name} (e2e)`, () => {
   let app: INestApplication;
@@ -33,8 +32,7 @@ describe(`${AssetController.name} (e2e)`, () => {
   });
 
   afterAll(async () => {
-    await db.disconnect();
-    await app.close();
+    await testApp.teardown();
     await restoreTempFolder();
   });
 
@@ -82,8 +80,6 @@ describe(`${AssetController.name} (e2e)`, () => {
 
       const exifData = await exiftool.read(`${IMMICH_TEST_ASSET_TEMP_PATH}/thumbnail.jpg`);
 
-      console.log(assetWithLocation);
-
       expect(exifData).not.toHaveProperty('GPSLongitude');
       expect(exifData).not.toHaveProperty('GPSLatitude');
     });

server/e2e/jobs/utils.ts

@@ -10,7 +10,7 @@ import { DateTime } from 'luxon';
 import path from 'path';
 import { Server } from 'tls';
 import { EntityTarget, ObjectLiteral } from 'typeorm';
-import { AppService } from '../src/microservices/app.service';
+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/`);

server/package.json

@@ -22,7 +22,8 @@
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "NODE_OPTIONS='--experimental-vm-modules' jest --config test/e2e/jest-e2e.json --runInBand",
+    "e2e:jobs": "NODE_OPTIONS='--experimental-vm-modules' jest --config e2e/jobs/jest-e2e.json --runInBand",
+    "e2e:api": "jest --config e2e/api/jest-e2e.json --runInBand",
     "typeorm": "typeorm",
     "typeorm:migrations:create": "typeorm migration:create",
     "typeorm:migrations:generate": "typeorm migration:generate -d ./dist/infra/database.config.js",

server/src/domain/job/job.service.spec.ts

@@ -2,7 +2,6 @@ import { SystemConfig, SystemConfigKey } from '@app/infra/entities';
 import { BadRequestException } from '@nestjs/common';
 import {
   assetStub,
-  asyncTick,
   newAssetRepositoryMock,
   newCommunicationRepositoryMock,
   newJobRepositoryMock,
@@ -327,7 +326,6 @@ describe(JobService.name, () => {
 
         await sut.init(makeMockHandlers(true));
         await jobMock.addHandler.mock.calls[0][2](item);
-        await asyncTick(3);
 
         if (jobs.length > 1) {
           expect(jobMock.queueAll).toHaveBeenCalledWith(
@@ -344,7 +342,6 @@ describe(JobService.name, () => {
       it(`should not queue any jobs when ${item.name} finishes with 'false'`, async () => {
         await sut.init(makeMockHandlers(false));
         await jobMock.addHandler.mock.calls[0][2](item);
-        await asyncTick(3);
 
         expect(jobMock.queueAll).not.toHaveBeenCalled();
       });

server/test/index.ts

@@ -1,8 +1,2 @@
 export * from './fixtures';
 export * from './repositories';
-
-export async function asyncTick(steps: number) {
-  for (let i = 0; i < steps; i++) {
-    await Promise.resolve();
-  }
-}