chore(server): Improve test coverage! (#3889)

* tests for person service * tests for auth service * tests for access core * improve tests for album service * fix missing brackets and remove comments * tests for asset service * tests for face recognition * tests for job service * feedback * tests for search service (broken) * fix: disabled search test * tests for smart-info service * tests for storage template service * tests for user service * fix formatting of untouched files LOL * attempt to fix formatting * streamline api utils, add asset api for uploading files * test upload of assets * fix formatting * move test-utils to correct folder * test add assets to album * use random bytes instead of test image * (e2e) test albums with assets * (e2e) complete tests for album endpoints * (e2e) tests for asset endpoint * fix: asset upload/import dto validation * (e2e) tests for statistics asset endpoint * fix wrong describe text * (e2e) tests for people with faces * (e2e) clean up person tests * (e2e) tests for partner sharing endpoints * (e2e) tests for link sharing * (e2e) tests for the asset time bucket endpoint * fix minor issues * remove access.core.spec.ts * chore: wording * chore: organize test api files * chore: fix test describe * implement feedback * fix race condition in album tests --------- Co-authored-by: Jason Rasmussen <jrasm91@gmail.com>
2025-12-28 20:51:17 +00:00 · 2023-09-11 17:56:38 +02:00
parent afccb37a3b
commit 7173af60e4
32 changed files with 1635 additions and 291 deletions
--- a/server/test/e2e/album.e2e-spec.ts
+++ b/server/test/e2e/album.e2e-spec.ts
@@ -1,11 +1,13 @@
-import { LoginResponseDto } from '@app/domain';
+import { AlbumResponseDto, LoginResponseDto } from '@app/domain';
 import { AlbumController, AppModule } 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 request from 'supertest';
-import { errorStub, uuidStub } from '../fixtures';
-import { api, db } from '../test-utils';

 const user1SharedUser = 'user1SharedUser';
 const user1SharedLink = 'user1SharedLink';
@@ -18,7 +20,10 @@ describe(`${AlbumController.name} (e2e)`, () => {
  let app: INestApplication;
  let server: any;
  let user1: LoginResponseDto;
+  let user1Asset: AssetFileUploadResponseDto;
+  let user1Albums: AlbumResponseDto[];
  let user2: LoginResponseDto;
+  let user2Albums: AlbumResponseDto[];

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
@@ -31,8 +36,8 @@ describe(`${AlbumController.name} (e2e)`, () => {

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
-    const admin = await api.adminLogin(server);
+    await api.authApi.adminSignUp(server);
+    const admin = await api.authApi.adminLogin(server);

    await api.userApi.create(server, admin.accessToken, {
      email: 'user1@immich.app',
@@ -40,7 +45,7 @@ describe(`${AlbumController.name} (e2e)`, () => {
      firstName: 'User 1',
      lastName: 'Test',
    });
-    user1 = await api.login(server, { email: 'user1@immich.app', password: 'Password123' });
+    user1 = await api.authApi.login(server, { email: 'user1@immich.app', password: 'Password123' });

    await api.userApi.create(server, admin.accessToken, {
      email: 'user2@immich.app',
@@ -48,15 +53,17 @@ describe(`${AlbumController.name} (e2e)`, () => {
      firstName: 'User 2',
      lastName: 'Test',
    });
-    user2 = await api.login(server, { email: 'user2@immich.app', password: 'Password123' });
+    user2 = await api.authApi.login(server, { email: 'user2@immich.app', password: 'Password123' });

-    const user1Albums = await Promise.all([
+    user1Asset = await api.assetApi.upload(server, user1.accessToken, 'example');
+    user1Albums = await Promise.all([
      api.albumApi.create(server, user1.accessToken, {
        albumName: user1SharedUser,
        sharedWithUserIds: [user2.userId],
+        assetIds: [user1Asset.id],
      }),
-      api.albumApi.create(server, user1.accessToken, { albumName: user1SharedLink }),
-      api.albumApi.create(server, user1.accessToken, { albumName: user1NotShared }),
+      api.albumApi.create(server, user1.accessToken, { albumName: user1SharedLink, assetIds: [user1Asset.id] }),
+      api.albumApi.create(server, user1.accessToken, { albumName: user1NotShared, assetIds: [user1Asset.id] }),
    ]);

    // add shared link to user1SharedLink album
@@ -65,10 +72,11 @@ describe(`${AlbumController.name} (e2e)`, () => {
      albumId: user1Albums[1].id,
    });

-    const user2Albums = await Promise.all([
+    user2Albums = await Promise.all([
      api.albumApi.create(server, user2.accessToken, {
        albumName: user2SharedUser,
        sharedWithUserIds: [user1.userId],
+        assetIds: [user1Asset.id],
      }),
      api.albumApi.create(server, user2.accessToken, { albumName: user2SharedLink }),
      api.albumApi.create(server, user2.accessToken, { albumName: user2NotShared }),
@@ -150,31 +158,30 @@ describe(`${AlbumController.name} (e2e)`, () => {
      );
    });

-    // TODO: Add asset to album and test if it returns correctly.
    it('should return the album collection filtered by assetId', async () => {
+      const asset = await api.assetApi.upload(server, user1.accessToken, 'example2');
+      await api.albumApi.addAssets(server, user1.accessToken, user1Albums[0].id, { ids: [asset.id] });
      const { status, body } = await request(server)
-        .get('/album?assetId=ecb120db-45a2-4a65-9293-51476f0d8790')
+        .get(`/album?assetId=${asset.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`);
      expect(status).toEqual(200);
-      expect(body).toHaveLength(0);
+      expect(body).toHaveLength(1);
    });

-    // TODO: Add asset to album and test if it returns correctly.
    it('should return the album collection filtered by assetId and ignores shared=true', async () => {
      const { status, body } = await request(server)
-        .get('/album?shared=true&assetId=ecb120db-45a2-4a65-9293-51476f0d8790')
+        .get(`/album?shared=true&assetId=${user1Asset.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`);
      expect(status).toEqual(200);
-      expect(body).toHaveLength(0);
+      expect(body).toHaveLength(4);
    });

-    // TODO: Add asset to album and test if it returns correctly.
    it('should return the album collection filtered by assetId and ignores shared=false', async () => {
      const { status, body } = await request(server)
-        .get('/album?shared=false&assetId=ecb120db-45a2-4a65-9293-51476f0d8790')
+        .get(`/album?shared=false&assetId=${user1Asset.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`);
      expect(status).toEqual(200);
-      expect(body).toHaveLength(0);
+      expect(body).toHaveLength(4);
    });
  });

@@ -205,6 +212,79 @@ describe(`${AlbumController.name} (e2e)`, () => {
    });
  });

+  describe('GET /album/count', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/album/count');
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should return total count of albums the user has access to', async () => {
+      const { status, body } = await request(server)
+        .get('/album/count')
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ owned: 3, shared: 3, notShared: 1 });
+    });
+  });
+
+  describe('GET /album/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get(`/album/${user1Albums[0].id}`);
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should return album info for own album', async () => {
+      const { status, body } = await request(server)
+        .get(`/album/${user1Albums[0].id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual(user1Albums[0]);
+    });
+
+    it('should return album info for shared album', async () => {
+      const { status, body } = await request(server)
+        .get(`/album/${user2Albums[0].id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual(user2Albums[0]);
+    });
+  });
+
+  describe('PUT /album/:id/assets', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).put(`/album/${user1Albums[0].id}/assets`);
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should be able to add own asset to own album', async () => {
+      const asset = await api.assetApi.upload(server, user1.accessToken, 'example1');
+      const { status, body } = await request(server)
+        .put(`/album/${user1Albums[0].id}/assets`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ ids: [asset.id] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: asset.id, success: true })]);
+    });
+
+    it('should be able to add own asset to shared album', async () => {
+      const asset = await api.assetApi.upload(server, user1.accessToken, 'example1');
+      const { status, body } = await request(server)
+        .put(`/album/${user2Albums[0].id}/assets`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ ids: [asset.id] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: asset.id, success: true })]);
+    });
+  });
+
  describe('PATCH /album/:id', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server)
@@ -232,4 +312,107 @@ describe(`${AlbumController.name} (e2e)`, () => {
      });
    });
  });
+
+  describe('DELETE /album/:id/assets', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .delete(`/album/${user1Albums[0].id}/assets`)
+        .send({ ids: [user1Asset.id] });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should be able to remove own asset from own album', async () => {
+      const { status, body } = await request(server)
+        .delete(`/album/${user1Albums[0].id}/assets`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ ids: [user1Asset.id] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: user1Asset.id, success: true })]);
+    });
+
+    it('should be able to remove own asset from shared album', async () => {
+      const { status, body } = await request(server)
+        .delete(`/album/${user2Albums[0].id}/assets`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ ids: [user1Asset.id] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: user1Asset.id, success: true })]);
+    });
+
+    it('should not be able to remove foreign asset from own album', async () => {
+      const { status, body } = await request(server)
+        .delete(`/album/${user2Albums[0].id}/assets`)
+        .set('Authorization', `Bearer ${user2.accessToken}`)
+        .send({ ids: [user1Asset.id] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: user1Asset.id, success: false, error: 'no_permission' })]);
+    });
+
+    it('should not be able to remove foreign asset from foreign album', async () => {
+      const { status, body } = await request(server)
+        .delete(`/album/${user1Albums[0].id}/assets`)
+        .set('Authorization', `Bearer ${user2.accessToken}`)
+        .send({ ids: [user1Asset.id] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: user1Asset.id, success: false, error: 'no_permission' })]);
+    });
+  });
+
+  describe('PUT :id/users', () => {
+    let album: AlbumResponseDto;
+
+    beforeEach(async () => {
+      album = await api.albumApi.create(server, user1.accessToken, { albumName: 'testAlbum' });
+    });
+
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .put(`/album/${user1Albums[0].id}/users`)
+        .send({ sharedUserIds: [] });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should be able to add user to own album', async () => {
+      const { status, body } = await request(server)
+        .put(`/album/${album.id}/users`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ sharedUserIds: [user2.userId] });
+
+      expect(status).toBe(200);
+      expect(body).toEqual(expect.objectContaining({ sharedUsers: [expect.objectContaining({ id: user2.userId })] }));
+    });
+
+    // it('should not be able to share album with owner', async () => {
+    //   const { status, body } = await request(server)
+    //     .put(`/album/${album.id}/users`)
+    //     .set('Authorization', `Bearer ${user1.accessToken}`)
+    //     .send({ sharedUserIds: [user2.userId] });
+
+    //   expect(status).toBe(400);
+    //   expect(body).toEqual(errorStub.badRequest);
+    // });
+
+    it('should not be able to add existing user to shared album', async () => {
+      await request(server)
+        .put(`/album/${album.id}/users`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ sharedUserIds: [user2.userId] });
+
+      const { status, body } = await request(server)
+        .put(`/album/${album.id}/users`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ sharedUserIds: [user2.userId] });
+
+      expect(status).toBe(400);
+      expect(body).toEqual({ ...errorStub.badRequest, message: 'User already added' });
+    });
+  });
 });
--- a/server/test/e2e/asset.e2e-spec.ts
+++ b/server/test/e2e/asset.e2e-spec.ts
@@ -1,12 +1,13 @@
-import { IAssetRepository, IFaceRepository, IPersonRepository, LoginResponseDto } from '@app/domain';
+import { IAssetRepository, IFaceRepository, IPersonRepository, LoginResponseDto, TimeBucketSize } from '@app/domain';
 import { AppModule, 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 { randomBytes } from 'crypto';
 import request from 'supertest';
-import { errorStub, uuidStub } from '../fixtures';
-import { api, db } from '../test-utils';

 const user1Dto = {
  email: 'user1@immich.app',
@@ -22,8 +23,30 @@ const user2Dto = {
  lastName: 'Test',
 };

+const makeUploadDto = (options?: { omit: string }): Record<string, any> => {
+  const dto: Record<string, any> = {
+    deviceAssetId: 'example-image',
+    deviceId: 'TEST',
+    fileCreatedAt: new Date().toISOString(),
+    fileModifiedAt: new Date().toISOString(),
+    isFavorite: 'testing',
+    duration: '0:00:00.000000',
+  };
+
+  const omit = options?.omit;
+  if (omit) {
+    delete dto[omit];
+  }
+
+  return dto;
+};
+
 let assetCount = 0;
-const createAsset = (repository: IAssetRepository, loginResponse: LoginResponseDto): Promise<AssetEntity> => {
+const createAsset = (
+  repository: IAssetRepository,
+  loginResponse: LoginResponseDto,
+  createdAt: Date,
+): Promise<AssetEntity> => {
  const id = assetCount++;
  return repository.save({
    ownerId: loginResponse.userId,
@@ -31,7 +54,7 @@ const createAsset = (repository: IAssetRepository, loginResponse: LoginResponseD
    originalPath: `/tests/test_${id}`,
    deviceAssetId: `test_${id}`,
    deviceId: 'e2e-test',
-    fileCreatedAt: new Date(),
+    fileCreatedAt: createdAt,
    fileModifiedAt: new Date(),
    type: AssetType.IMAGE,
    originalFileName: `test_${id}`,
@@ -46,6 +69,8 @@ describe(`${AssetController.name} (e2e)`, () => {
  let user2: LoginResponseDto;
  let asset1: AssetEntity;
  let asset2: AssetEntity;
+  let asset3: AssetEntity;
+  let asset4: AssetEntity;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
@@ -59,16 +84,18 @@ describe(`${AssetController.name} (e2e)`, () => {

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
-    const admin = await api.adminLogin(server);
+    await api.authApi.adminSignUp(server);
+    const admin = await api.authApi.adminLogin(server);

    await api.userApi.create(server, admin.accessToken, user1Dto);
-    user1 = await api.login(server, { email: user1Dto.email, password: user1Dto.password });
-    asset1 = await createAsset(assetRepository, user1);
+    user1 = await api.authApi.login(server, { email: user1Dto.email, password: user1Dto.password });
+    asset1 = await createAsset(assetRepository, user1, new Date('1970-01-01'));
+    asset2 = await createAsset(assetRepository, user1, new Date('1970-01-02'));
+    asset3 = await createAsset(assetRepository, user1, new Date('1970-02-01'));

    await api.userApi.create(server, admin.accessToken, user2Dto);
-    user2 = await api.login(server, { email: user2Dto.email, password: user2Dto.password });
-    asset2 = await createAsset(assetRepository, user2);
+    user2 = await api.authApi.login(server, { email: user2Dto.email, password: user2Dto.password });
+    asset4 = await createAsset(assetRepository, user2, new Date('1970-01-01'));
  });

  afterAll(async () => {
@@ -76,6 +103,83 @@ describe(`${AssetController.name} (e2e)`, () => {
    await app.close();
  });

+  describe('POST /asset/upload', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .post(`/asset/upload`)
+        .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', randomBytes(32), 'example.jpg');
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    const invalid = [
+      { should: 'require `deviceAssetId`', dto: { ...makeUploadDto({ omit: 'deviceAssetId' }) } },
+      { should: 'require `deviceId`', dto: { ...makeUploadDto({ omit: 'deviceId' }) } },
+      { should: 'require `fileCreatedAt`', dto: { ...makeUploadDto({ omit: 'fileCreatedAt' }) } },
+      { should: 'require `fileModifiedAt`', dto: { ...makeUploadDto({ omit: 'fileModifiedAt' }) } },
+      { should: 'require `isFavorite`', dto: { ...makeUploadDto({ omit: 'isFavorite' }) } },
+      { should: 'require `duration`', dto: { ...makeUploadDto({ omit: 'duration' }) } },
+      { should: 'throw if `isFavorite` is not a boolean', dto: { ...makeUploadDto(), isFavorite: 'not-a-boolean' } },
+      { should: 'throw if `isVisible` is not a boolean', dto: { ...makeUploadDto(), isVisible: 'not-a-boolean' } },
+      { should: 'throw if `isArchived` is not a boolean', dto: { ...makeUploadDto(), isArchived: 'not-a-boolean' } },
+    ];
+
+    for (const { should, dto } of invalid) {
+      it(`should ${should}`, async () => {
+        const { status, body } = await request(server)
+          .post('/asset/upload')
+          .set('Authorization', `Bearer ${user1.accessToken}`)
+          .attach('assetData', randomBytes(32), 'example.jpg')
+          .field(dto);
+        expect(status).toBe(400);
+        expect(body).toEqual(errorStub.badRequest);
+      });
+    }
+
+    it('should upload a new asset', async () => {
+      const { body, status } = await request(server)
+        .post('/asset/upload')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .field('deviceAssetId', 'example-image')
+        .field('deviceId', 'TEST')
+        .field('fileCreatedAt', new Date().toISOString())
+        .field('fileModifiedAt', new Date().toISOString())
+        .field('isFavorite', 'true')
+        .field('duration', '0:00:00.000000')
+        .attach('assetData', randomBytes(32), 'example.jpg');
+      expect(status).toBe(201);
+      expect(body).toEqual({ id: expect.any(String), duplicate: false });
+
+      const asset = await api.assetApi.get(server, user1.accessToken, body.id);
+      expect(asset).toMatchObject({ id: body.id, isFavorite: true });
+    });
+
+    it('should not upload the same asset twice', async () => {
+      const content = randomBytes(32);
+      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('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(200);
+      expect(body.duplicate).toBe(true);
+    });
+  });
+
  describe('PUT /asset/:id', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server).put(`/asset/:${uuidStub.notFound}`);
@@ -93,7 +197,7 @@ describe(`${AssetController.name} (e2e)`, () => {

    it('should require access', async () => {
      const { status, body } = await request(server)
-        .put(`/asset/${asset2.id}`)
+        .put(`/asset/${asset4.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`);
      expect(status).toBe(400);
      expect(body).toEqual(errorStub.noPermission);
@@ -160,4 +264,198 @@ describe(`${AssetController.name} (e2e)`, () => {
      });
    });
  });
+
+  describe('POST /asset/download/info', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .post(`/asset/download/info`)
+        .send({ assetIds: [asset1.id] });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should download info', async () => {
+      const { status, body } = await request(server)
+        .post('/asset/download/info')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ assetIds: [asset1.id] });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(expect.objectContaining({ archives: [expect.objectContaining({ assetIds: [asset1.id] })] }));
+    });
+  });
+
+  describe('POST /asset/download/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).post(`/asset/download/${asset1.id}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should download file', async () => {
+      const asset = await api.assetApi.upload(server, user1.accessToken, 'example');
+      const response = await request(server)
+        .post(`/asset/download/${asset.id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(response.status).toBe(200);
+      expect(response.headers['content-type']).toEqual('image/jpeg');
+    });
+  });
+
+  describe('GET /asset/statistics', () => {
+    beforeEach(async () => {
+      await api.assetApi.upload(server, user1.accessToken, 'favored_asset', { isFavorite: true });
+      await api.assetApi.upload(server, user1.accessToken, 'archived_asset', { isArchived: true });
+      await api.assetApi.upload(server, user1.accessToken, 'favored_archived_asset', {
+        isFavorite: true,
+        isArchived: true,
+      });
+    });
+
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/album/statistics');
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should return stats of all assets', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/statistics')
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ images: 6, videos: 0, total: 6 });
+    });
+
+    it('should return stats of all favored assets', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/statistics')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ isFavorite: true });
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ images: 2, videos: 0, total: 2 });
+    });
+
+    it('should return stats of all archived assets', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/statistics')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ isArchived: true });
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ images: 2, videos: 0, total: 2 });
+    });
+
+    it('should return stats of all favored and archived assets', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/statistics')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ isFavorite: true, isArchived: true });
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ images: 1, videos: 0, total: 1 });
+    });
+
+    it('should return stats of all assets neither favored nor archived', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/statistics')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ isFavorite: false, isArchived: false });
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ images: 3, videos: 0, total: 3 });
+    });
+  });
+
+  describe('GET /asset/time-buckets', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/asset/time-buckets').query({ size: TimeBucketSize.MONTH });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should get time buckets by month', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/time-buckets')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ size: TimeBucketSize.MONTH });
+
+      expect(status).toBe(200);
+      expect(body).toEqual(
+        expect.arrayContaining([
+          { count: 1, timeBucket: asset3.fileCreatedAt.toISOString() },
+          { count: 2, timeBucket: asset1.fileCreatedAt.toISOString() },
+        ]),
+      );
+    });
+
+    it('should get time buckets by day', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/time-buckets')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ size: TimeBucketSize.DAY });
+
+      expect(status).toBe(200);
+      expect(body).toEqual(
+        expect.arrayContaining([
+          { count: 1, timeBucket: asset1.fileCreatedAt.toISOString() },
+          { count: 1, timeBucket: asset2.fileCreatedAt.toISOString() },
+          { count: 1, timeBucket: asset3.fileCreatedAt.toISOString() },
+        ]),
+      );
+    });
+  });
+
+  describe('GET /asset/time-bucket', () => {
+    let timeBucket: string;
+    beforeEach(async () => {
+      const { body, status } = await request(server)
+        .get('/asset/time-buckets')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ size: TimeBucketSize.MONTH });
+
+      expect(status).toBe(200);
+      timeBucket = body[1].timeBucket;
+    });
+
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/time-bucket')
+        .query({ size: TimeBucketSize.MONTH, timeBucket });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    // it('should fail if time bucket is invalid', async () => {
+    //   const { status, body } = await request(server)
+    //     .get('/asset/time-bucket')
+    //     .set('Authorization', `Bearer ${user1.accessToken}`)
+    //     .query({ size: TimeBucketSize.MONTH, timeBucket: 'foo' });
+
+    //   expect(status).toBe(400);
+    //   expect(body).toEqual(errorStub.badRequest);
+    // });
+
+    it('should return time bucket', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/time-bucket')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ size: TimeBucketSize.MONTH, timeBucket });
+
+      expect(status).toBe(200);
+      expect(body).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: asset1.id }),
+          expect.objectContaining({ id: asset2.id }),
+        ]),
+      );
+    });
+  });
 });
--- a/server/test/e2e/auth.e2e-spec.ts
+++ b/server/test/e2e/auth.e2e-spec.ts
@@ -1,7 +1,8 @@
 import { AppModule, AuthController } from '@app/immich';
 import { INestApplication } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
-import request from 'supertest';
+import { api } from '@test/api';
+import { db } from '@test/db';
 import {
  adminSignupStub,
  changePasswordStub,
@@ -11,8 +12,8 @@ import {
  loginStub,
  signupResponseStub,
  uuidStub,
-} from '../fixtures';
-import { api, db } from '../test-utils';
+} from '@test/fixtures';
+import request from 'supertest';

 const firstName = 'Immich';
 const lastName = 'Admin';
@@ -35,8 +36,8 @@ describe(`${AuthController.name} (e2e)`, () => {

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
-    const response = await api.adminLogin(server);
+    await api.authApi.adminSignUp(server);
+    const response = await api.authApi.adminLogin(server);
    accessToken = response.accessToken;
  });

@@ -67,7 +68,7 @@ describe(`${AuthController.name} (e2e)`, () => {
    }

    it(`should sign up the admin`, async () => {
-      await api.adminSignUp(server);
+      await api.authApi.adminSignUp(server);
    });

    it('should sign up the admin with a local domain', async () => {
@@ -87,7 +88,7 @@ describe(`${AuthController.name} (e2e)`, () => {
    });

    it('should not allow a second admin to sign up', async () => {
-      await api.adminSignUp(server);
+      await api.authApi.adminSignUp(server);

      const { status, body } = await request(server).post('/auth/admin-sign-up').send(adminSignupStub);

@@ -152,7 +153,7 @@ describe(`${AuthController.name} (e2e)`, () => {
    });
  });

-  describe('DELETE /auth/devices/:id', () => {
+  describe('DELETE /auth/devices', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server).delete(`/auth/devices`);
      expect(status).toBe(401);
@@ -161,15 +162,15 @@ describe(`${AuthController.name} (e2e)`, () => {

    it('should logout all devices (except the current one)', async () => {
      for (let i = 0; i < 5; i++) {
-        await api.adminLogin(server);
+        await api.authApi.adminLogin(server);
      }

-      await expect(api.getAuthDevices(server, accessToken)).resolves.toHaveLength(6);
+      await expect(api.authApi.getAuthDevices(server, accessToken)).resolves.toHaveLength(6);

      const { status } = await request(server).delete(`/auth/devices`).set('Authorization', `Bearer ${accessToken}`);
      expect(status).toBe(204);

-      await api.validateToken(server, accessToken);
+      await api.authApi.validateToken(server, accessToken);
    });
  });

@@ -181,7 +182,7 @@ describe(`${AuthController.name} (e2e)`, () => {
    });

    it('should logout a device', async () => {
-      const [device] = await api.getAuthDevices(server, accessToken);
+      const [device] = await api.authApi.getAuthDevices(server, accessToken);
      const { status } = await request(server)
        .delete(`/auth/devices/${device.id}`)
        .set('Authorization', `Bearer ${accessToken}`);
@@ -244,7 +245,7 @@ describe(`${AuthController.name} (e2e)`, () => {
        .set('Authorization', `Bearer ${accessToken}`);
      expect(status).toBe(200);

-      await api.login(server, { email: 'admin@immich.app', password: 'Password1234' });
+      await api.authApi.login(server, { email: 'admin@immich.app', password: 'Password1234' });
    });
  });

--- a/server/test/e2e/oauth.e2e-spec.ts
+++ b/server/test/e2e/oauth.e2e-spec.ts
@@ -1,9 +1,10 @@
 import { AppModule, 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 request from 'supertest';
-import { errorStub } from '../fixtures';
-import { api, db } from '../test-utils';

 describe(`${OAuthController.name} (e2e)`, () => {
  let app: INestApplication;
@@ -20,7 +21,7 @@ describe(`${OAuthController.name} (e2e)`, () => {

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
+    await api.authApi.adminSignUp(server);
  });

  afterAll(async () => {
--- a/server/test/e2e/partner.e2e-spec.ts
+++ b/server/test/e2e/partner.e2e-spec.ts
@@ -0,0 +1,146 @@
+import { IPartnerRepository, LoginResponseDto, PartnerDirection } from '@app/domain';
+import { AppModule, 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 request from 'supertest';
+
+const user1Dto = {
+  email: 'user1@immich.app',
+  password: 'Password123',
+  firstName: 'User 1',
+  lastName: 'Test',
+};
+
+const user2Dto = {
+  email: 'user2@immich.app',
+  password: 'Password123',
+  firstName: 'User 2',
+  lastName: 'Test',
+};
+
+describe(`${PartnerController.name} (e2e)`, () => {
+  let app: INestApplication;
+  let server: any;
+  let loginResponse: LoginResponseDto;
+  let accessToken: string;
+  let repository: IPartnerRepository;
+  let user1: LoginResponseDto;
+  let user2: LoginResponseDto;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = await moduleFixture.createNestApplication().init();
+    server = app.getHttpServer();
+    repository = app.get<IPartnerRepository>(IPartnerRepository);
+  });
+
+  beforeEach(async () => {
+    await db.reset();
+    await api.authApi.adminSignUp(server);
+    loginResponse = await api.authApi.adminLogin(server);
+    accessToken = loginResponse.accessToken;
+
+    await api.userApi.create(server, accessToken, user1Dto);
+    user1 = await api.authApi.login(server, { email: user1Dto.email, password: user1Dto.password });
+
+    await api.userApi.create(server, accessToken, user2Dto);
+    user2 = await api.authApi.login(server, { email: user2Dto.email, password: user2Dto.password });
+  });
+
+  afterAll(async () => {
+    await db.disconnect();
+    await app.close();
+  });
+
+  describe('GET /partner', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/partner');
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should get all partners shared by user', async () => {
+      await repository.create({ sharedById: user1.userId, sharedWithId: user2.userId });
+      const { status, body } = await request(server)
+        .get('/partner')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ direction: PartnerDirection.SharedBy });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: user2.userId })]);
+    });
+
+    it('should get all partners that share with user', async () => {
+      await repository.create({ sharedById: user2.userId, sharedWithId: user1.userId });
+      const { status, body } = await request(server)
+        .get('/partner')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ direction: PartnerDirection.SharedWith });
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ id: user2.userId })]);
+    });
+  });
+
+  describe('POST /partner/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).post(`/partner/${user2.userId}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should share with new partner', async () => {
+      const { status, body } = await request(server)
+        .post(`/partner/${user2.userId}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(201);
+      expect(body).toEqual(expect.objectContaining({ id: user2.userId }));
+    });
+
+    it('should not share with new partner if already sharing with this partner', async () => {
+      await repository.create({ sharedById: user1.userId, sharedWithId: user2.userId });
+      const { status, body } = await request(server)
+        .post(`/partner/${user2.userId}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(expect.objectContaining({ message: 'Partner already exists' }));
+    });
+  });
+
+  describe('DELETE /partner/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).delete(`/partner/${user2.userId}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should delete partner', async () => {
+      await repository.create({ sharedById: user1.userId, sharedWithId: user2.userId });
+      const { status } = await request(server)
+        .delete(`/partner/${user2.userId}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+    });
+
+    it('should throw a bad request if partner not found', async () => {
+      const { status, body } = await request(server)
+        .delete(`/partner/${user2.userId}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(expect.objectContaining({ message: 'Partner not found' }));
+    });
+  });
+});
--- a/server/test/e2e/person.e2e-spec.ts
+++ b/server/test/e2e/person.e2e-spec.ts
@@ -1,16 +1,22 @@
-import { IPersonRepository, LoginResponseDto } from '@app/domain';
+import { IFaceRepository, IPersonRepository, LoginResponseDto } from '@app/domain';
 import { AppModule, 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 request from 'supertest';
-import { errorStub, uuidStub } from '../fixtures';
-import { api, db } from '../test-utils';

 describe(`${PersonController.name}`, () => {
  let app: INestApplication;
  let server: any;
  let loginResponse: LoginResponseDto;
  let accessToken: string;
+  let personRepository: IPersonRepository;
+  let faceRepository: IFaceRepository;
+  let visiblePerson: PersonEntity;
+  let hiddenPerson: PersonEntity;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
@@ -19,13 +25,31 @@ describe(`${PersonController.name}`, () => {

    app = await moduleFixture.createNestApplication().init();
    server = app.getHttpServer();
+    personRepository = app.get<IPersonRepository>(IPersonRepository);
+    faceRepository = app.get<IFaceRepository>(IFaceRepository);
  });

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
-    loginResponse = await api.adminLogin(server);
+    await api.authApi.adminSignUp(server);
+    loginResponse = await api.authApi.adminLogin(server);
    accessToken = loginResponse.accessToken;
+
+    const faceAsset = await api.assetApi.upload(server, accessToken, 'face_asset');
+    visiblePerson = await personRepository.create({
+      ownerId: loginResponse.userId,
+      name: 'visible_person',
+      thumbnailPath: '/thumbnail/face_asset',
+    });
+    await faceRepository.create({ assetId: faceAsset.id, personId: visiblePerson.id });
+
+    hiddenPerson = await personRepository.create({
+      ownerId: loginResponse.userId,
+      name: 'hidden_person',
+      isHidden: true,
+      thumbnailPath: '/thumbnail/face_asset',
+    });
+    await faceRepository.create({ assetId: faceAsset.id, personId: hiddenPerson.id });
  });

  afterAll(async () => {
@@ -33,6 +57,72 @@ describe(`${PersonController.name}`, () => {
    await app.close();
  });

+  describe('GET /person', () => {
+    beforeEach(async () => {});
+
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/person');
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should return all people (including hidden)', async () => {
+      const { status, body } = await request(server)
+        .get('/person')
+        .set('Authorization', `Bearer ${accessToken}`)
+        .query({ withHidden: true });
+
+      expect(status).toBe(200);
+      expect(body).toEqual({
+        total: 2,
+        visible: 1,
+        people: [
+          expect.objectContaining({ name: 'visible_person' }),
+          expect.objectContaining({ name: 'hidden_person' }),
+        ],
+      });
+    });
+
+    it('should return only visible people', async () => {
+      const { status, body } = await request(server).get('/person').set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual({
+        total: 1,
+        visible: 1,
+        people: [expect.objectContaining({ name: 'visible_person' })],
+      });
+    });
+  });
+
+  describe('GET /person/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get(`/person/${uuidStub.notFound}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should throw error if person with id does not exist', async () => {
+      const { status, body } = await request(server)
+        .get(`/person/${uuidStub.notFound}`)
+        .set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest);
+    });
+
+    it('should return person information', async () => {
+      const { status, body } = await request(server)
+        .get(`/person/${visiblePerson.id}`)
+        .set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual(expect.objectContaining({ id: visiblePerson.id }));
+    });
+  });
+
  describe('PUT /person/:id', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server).put(`/person/${uuidStub.notFound}`);
@@ -42,10 +132,8 @@ describe(`${PersonController.name}`, () => {

    for (const key of ['name', 'featureFaceAssetId', 'isHidden']) {
      it(`should not allow null ${key}`, async () => {
-        const personRepository = app.get<IPersonRepository>(IPersonRepository);
-        const person = await personRepository.create({ ownerId: loginResponse.userId });
        const { status, body } = await request(server)
-          .put(`/person/${person.id}`)
+          .put(`/person/${visiblePerson.id}`)
          .set('Authorization', `Bearer ${accessToken}`)
          .send({ [key]: null });
        expect(status).toBe(400);
@@ -65,10 +153,8 @@ describe(`${PersonController.name}`, () => {
    });

    it('should update a date of birth', async () => {
-      const personRepository = app.get<IPersonRepository>(IPersonRepository);
-      const person = await personRepository.create({ ownerId: loginResponse.userId });
      const { status, body } = await request(server)
-        .put(`/person/${person.id}`)
+        .put(`/person/${visiblePerson.id}`)
        .set('Authorization', `Bearer ${accessToken}`)
        .send({ birthDate: '1990-01-01T05:00:00.000Z' });
      expect(status).toBe(200);
@@ -76,7 +162,6 @@ describe(`${PersonController.name}`, () => {
    });

    it('should clear a date of birth', async () => {
-      const personRepository = app.get<IPersonRepository>(IPersonRepository);
      const person = await personRepository.create({
        birthDate: new Date('1990-01-01'),
        ownerId: loginResponse.userId,
--- a/server/test/e2e/server-info.e2e-spec.ts
+++ b/server/test/e2e/server-info.e2e-spec.ts
@@ -2,9 +2,10 @@ import { LoginResponseDto } from '@app/domain';
 import { AppModule, 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 request from 'supertest';
-import { errorStub } from '../fixtures';
-import { api, db } from '../test-utils';

 describe(`${ServerInfoController.name} (e2e)`, () => {
  let app: INestApplication;
@@ -23,8 +24,8 @@ describe(`${ServerInfoController.name} (e2e)`, () => {

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
-    loginResponse = await api.adminLogin(server);
+    await api.authApi.adminSignUp(server);
+    loginResponse = await api.authApi.adminLogin(server);
    accessToken = loginResponse.accessToken;
  });

@@ -116,7 +117,7 @@ describe(`${ServerInfoController.name} (e2e)`, () => {
    it('should only work for admins', async () => {
      const loginDto = { email: 'test@immich.app', password: 'Immich123' };
      await api.userApi.create(server, accessToken, { ...loginDto, firstName: 'test', lastName: 'test' });
-      const { accessToken: userAccessToken } = await api.login(server, loginDto);
+      const { accessToken: userAccessToken } = await api.authApi.login(server, loginDto);
      const { status, body } = await request(server)
        .get('/server-info/stats')
        .set('Authorization', `Bearer ${userAccessToken}`);
--- a/server/test/e2e/shared-link.e2e-spec.ts
+++ b/server/test/e2e/shared-link.e2e-spec.ts
@@ -0,0 +1,241 @@
+import { AlbumResponseDto, LoginResponseDto, SharedLinkResponseDto } from '@app/domain';
+import { AppModule, 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 request from 'supertest';
+
+const user1Dto = {
+  email: 'user1@immich.app',
+  password: 'Password123',
+  firstName: 'User 1',
+  lastName: 'Test',
+};
+
+describe(`${PartnerController.name} (e2e)`, () => {
+  let app: INestApplication;
+  let server: any;
+  let loginResponse: LoginResponseDto;
+  let accessToken: string;
+  let user1: LoginResponseDto;
+  let album: AlbumResponseDto;
+  let sharedLink: SharedLinkResponseDto;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = await moduleFixture.createNestApplication().init();
+    server = app.getHttpServer();
+  });
+
+  beforeEach(async () => {
+    await db.reset();
+    await api.authApi.adminSignUp(server);
+    loginResponse = await api.authApi.adminLogin(server);
+    accessToken = loginResponse.accessToken;
+
+    await api.userApi.create(server, accessToken, user1Dto);
+    user1 = await api.authApi.login(server, { email: user1Dto.email, password: user1Dto.password });
+
+    album = await api.albumApi.create(server, user1.accessToken, { albumName: 'shared with link' });
+    sharedLink = await api.sharedLinkApi.create(server, user1.accessToken, {
+      type: SharedLinkType.ALBUM,
+      albumId: album.id,
+    });
+  });
+
+  afterAll(async () => {
+    await db.disconnect();
+    await app.close();
+  });
+
+  describe('GET /shared-link', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/shared-link');
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should get all shared links created by user', async () => {
+      const { status, body } = await request(server)
+        .get('/shared-link')
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual([expect.objectContaining({ album, userId: user1.userId, type: SharedLinkType.ALBUM })]);
+    });
+
+    it('should not get shared links created by other users', async () => {
+      const { status, body } = await request(server).get('/shared-link').set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual([]);
+    });
+  });
+
+  describe('GET /shared-link/me', () => {
+    it('should not require admin authentication', async () => {
+      const { status } = await request(server).get('/shared-link/me').set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(403);
+    });
+
+    it('should get data for correct shared link', async () => {
+      const { status, body } = await request(server).get('/shared-link/me').query({ key: sharedLink.key });
+
+      expect(status).toBe(200);
+      expect(body).toEqual(expect.objectContaining({ album, userId: user1.userId, type: SharedLinkType.ALBUM }));
+    });
+
+    it('should return unauthorized for incorrect shared link', async () => {
+      const { status, body } = await request(server)
+        .get('/shared-link/me')
+        .query({ key: sharedLink.key + 'foo' });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(expect.objectContaining({ message: 'Invalid share key' }));
+    });
+  });
+
+  describe('GET /shared-link/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get(`/shared-link/${sharedLink.id}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should get shared link by id', async () => {
+      const { status, body } = await request(server)
+        .get(`/shared-link/${sharedLink.id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toEqual(expect.objectContaining({ album, userId: user1.userId, type: SharedLinkType.ALBUM }));
+    });
+
+    it('should not get shared link by id if user has not created the link or it does not exist', async () => {
+      const { status, body } = await request(server)
+        .get(`/shared-link/${sharedLink.id}`)
+        .set('Authorization', `Bearer ${accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(expect.objectContaining({ message: 'Shared link not found' }));
+    });
+  });
+
+  describe('POST /shared-link', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .post('/shared-link')
+        .send({ type: SharedLinkType.ALBUM, albumId: uuidStub.notFound });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should require a type and the correspondent asset/album id', async () => {
+      const { status, body } = await request(server)
+        .post('/shared-link')
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest);
+    });
+
+    it('should require an asset/album id', async () => {
+      const { status, body } = await request(server)
+        .post('/shared-link')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ type: SharedLinkType.ALBUM });
+
+      expect(status).toBe(400);
+      expect(body).toEqual(expect.objectContaining({ message: 'Invalid albumId' }));
+    });
+
+    it('should require a valid asset id', async () => {
+      const { status, body } = await request(server)
+        .post('/shared-link')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ type: SharedLinkType.INDIVIDUAL, assetId: uuidStub.notFound });
+
+      expect(status).toBe(400);
+      expect(body).toEqual(expect.objectContaining({ message: 'Invalid assetIds' }));
+    });
+
+    it('should create a shared link', async () => {
+      const { status, body } = await request(server)
+        .post('/shared-link')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ type: SharedLinkType.ALBUM, albumId: album.id });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(expect.objectContaining({ type: SharedLinkType.ALBUM, userId: user1.userId }));
+    });
+  });
+
+  describe('PATCH /shared-link/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .patch(`/shared-link/${sharedLink.id}`)
+        .send({ description: 'foo' });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should fail if invalid link', async () => {
+      const { status, body } = await request(server)
+        .patch(`/shared-link/${uuidStub.notFound}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ description: 'foo' });
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest);
+    });
+
+    it('should update shared link', async () => {
+      const { status, body } = await request(server)
+        .patch(`/shared-link/${sharedLink.id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ description: 'foo' });
+
+      expect(status).toBe(200);
+      expect(body).toEqual(
+        expect.objectContaining({ type: SharedLinkType.ALBUM, userId: user1.userId, description: 'foo' }),
+      );
+    });
+  });
+
+  describe('DELETE /shared-link/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).delete(`/shared-link/${sharedLink.id}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should fail if invalid link', async () => {
+      const { status, body } = await request(server)
+        .delete(`/shared-link/${uuidStub.notFound}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(400);
+      expect(body).toEqual(errorStub.badRequest);
+    });
+
+    it('should update shared link', async () => {
+      const { status } = await request(server)
+        .delete(`/shared-link/${sharedLink.id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+    });
+  });
+});
--- a/server/test/e2e/user.e2e-spec.ts
+++ b/server/test/e2e/user.e2e-spec.ts
@@ -2,9 +2,10 @@ import { LoginResponseDto } from '@app/domain';
 import { AppModule, UserController } 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, userSignupStub, userStub } from '@test/fixtures';
 import request from 'supertest';
-import { errorStub, userSignupStub, userStub } from '../fixtures';
-import { api, db } from '../test-utils';

 describe(`${UserController.name}`, () => {
  let app: INestApplication;
@@ -23,8 +24,8 @@ describe(`${UserController.name}`, () => {

  beforeEach(async () => {
    await db.reset();
-    await api.adminSignUp(server);
-    loginResponse = await api.adminLogin(server);
+    await api.authApi.adminSignUp(server);
+    loginResponse = await api.authApi.adminLogin(server);
    accessToken = loginResponse.accessToken;
  });