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

import {
  AssetResponseDto,
  IAssetRepository,
  IPersonRepository,
  LibraryResponseDto,
  LoginResponseDto,
  TimeBucketSize,
  WithoutProperty,
  mapAsset,
  usePagination,
} from '@app/domain';
import { AssetController } from '@app/immich';
import { AssetEntity, AssetType, LibraryType, 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 { testApp } from '@test/test-utils';
import { randomBytes } from 'crypto';
import { DateTime } from 'luxon';
import request from 'supertest';

const today = DateTime.fromObject({ year: 2023, month: 11, day: 3 });
const yesterday = today.minus({ days: 1 });

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;
};

describe(`${AssetController.name} (e2e)`, () => {
  let app: INestApplication;
  let server: any;
  let assetRepository: IAssetRepository;
  let user1: LoginResponseDto;
  let user2: LoginResponseDto;
  let libraries: LibraryResponseDto[];
  let asset1: AssetResponseDto;
  let asset2: AssetResponseDto;
  let asset3: AssetResponseDto;
  let asset4: AssetResponseDto;
  let asset5: AssetResponseDto;

  let assetCount = 0;
  const createAsset = async (loginResponse: LoginResponseDto, createdAt: Date, other: Partial<AssetEntity> = {}) => {
    const id = assetCount++;
    const asset = await assetRepository.create({
      createdAt: today.toJSDate(),
      updatedAt: today.toJSDate(),
      ownerId: loginResponse.userId,
      checksum: randomBytes(20),
      originalPath: `/tests/test_${id}`,
      deviceAssetId: `test_${id}`,
      deviceId: 'e2e-test',
      libraryId: (
        libraries.find(
          ({ ownerId, type }) => ownerId === loginResponse.userId && type === LibraryType.UPLOAD,
        ) as LibraryResponseDto
      ).id,
      isVisible: true,
      fileCreatedAt: createdAt,
      fileModifiedAt: new Date(),
      localDateTime: createdAt,
      type: AssetType.IMAGE,
      originalFileName: `test_${id}`,
      ...other,
    });

    return mapAsset(asset);
  };

  beforeAll(async () => {
    [server, app] = await testApp.create();
    assetRepository = app.get<IAssetRepository>(IAssetRepository);

    await testApp.reset();

    await api.authApi.adminSignUp(server);
    const admin = await api.authApi.adminLogin(server);

    await Promise.all([
      api.userApi.create(server, admin.accessToken, userDto.user1),
      api.userApi.create(server, admin.accessToken, userDto.user2),
    ]);

    [user1, user2] = await Promise.all([
      api.authApi.login(server, userDto.user1),
      api.authApi.login(server, userDto.user2),
    ]);

    const [user1Libraries, user2Libraries] = await Promise.all([
      api.libraryApi.getAll(server, user1.accessToken),
      api.libraryApi.getAll(server, user2.accessToken),
    ]);

    libraries = [...user1Libraries, ...user2Libraries];
  });

  beforeEach(async () => {
    await testApp.reset({ entities: [AssetEntity] });

    [asset1, asset2, asset3, asset4, asset5] = await Promise.all([
      createAsset(user1, new Date('1970-01-01')),
      createAsset(user1, new Date('1970-02-10')),
      createAsset(user1, new Date('1970-02-11'), {
        isFavorite: true,
        isArchived: true,
        isExternal: true,
        isReadOnly: true,
        type: AssetType.VIDEO,
        fileCreatedAt: yesterday.toJSDate(),
        fileModifiedAt: yesterday.toJSDate(),
        createdAt: yesterday.toJSDate(),
        updatedAt: yesterday.toJSDate(),
        localDateTime: yesterday.toJSDate(),
      }),
      createAsset(user2, new Date('1970-01-01')),
      createAsset(user1, new Date('1970-01-01'), {
        deletedAt: yesterday.toJSDate(),
      }),
    ]);
  });

  beforeEach(async () => {
    await testApp.reset({ entities: [AssetEntity] });

    [asset1, asset2, asset3, asset4, asset5] = await Promise.all([
      createAsset(user1, new Date('1970-01-01')),
      createAsset(user1, new Date('1970-02-10')),
      createAsset(user1, new Date('1970-02-11'), {
        isFavorite: true,
        isArchived: true,
        isExternal: true,
        isReadOnly: true,
        type: AssetType.VIDEO,
        fileCreatedAt: yesterday.toJSDate(),
        fileModifiedAt: yesterday.toJSDate(),
        createdAt: yesterday.toJSDate(),
        updatedAt: yesterday.toJSDate(),
        localDateTime: yesterday.toJSDate(),
        encodedVideoPath: '/path/to/encoded-video.mp4',
        webpPath: '/path/to/thumb.webp',
        resizePath: '/path/to/thumb.jpg',
      }),
      createAsset(user2, new Date('1970-01-01')),
      createAsset(user1, new Date('1970-01-01'), {
        deletedAt: yesterday.toJSDate(),
      }),
    ]);

    await assetRepository.upsertExif({
      assetId: asset3.id,
      latitude: 90,
      longitude: 90,
      city: 'Immich',
      state: 'Nebraska',
      country: 'United States',
      make: 'Cannon',
      model: 'EOS Rebel T7',
      lensModel: 'Fancy lens',
    });
  });

  afterAll(async () => {
    await testApp.teardown();
  });

  describe('GET /assets', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server).get('/assets');
      expect(body).toEqual(errorStub.unauthorized);
      expect(status).toBe(401);
    });

    const badTests = [
      //
      {
        should: 'should reject page as a string',
        query: { page: 'abc' },
        expected: ['page must not be less than 1', 'page must be an integer number'],
      },
      {
        should: 'should reject page as a decimal',
        query: { page: 1.5 },
        expected: ['page must be an integer number'],
      },
      {
        should: 'should reject page as a negative number',
        query: { page: -10 },
        expected: ['page must not be less than 1'],
      },
      {
        should: 'should reject page as 0',
        query: { page: 0 },
        expected: ['page must not be less than 1'],
      },
      {
        should: 'should reject size as a string',
        query: { size: 'abc' },
        expected: ['size must not be less than 1', 'size must be an integer number'],
      },
      {
        should: 'should reject an invalid size',
        query: { size: -1.5 },
        expected: ['size must not be less than 1', 'size must be an integer number'],
      },
      ...[
        'isArchived',
        'isFavorite',
        'isReadOnly',
        'isExternal',
        'isEncoded',
        'isMotion',
        'isOffline',
        'isVisible',
      ].map((value) => ({
        should: `should reject ${value} not a boolean`,
        query: { [value]: 'immich' },
        expected: [`${value} must be a boolean value`],
      })),
    ];

    for (const { should, query, expected } of badTests) {
      it(should, async () => {
        const { status, body } = await request(server)
          .get('/assets')
          .set('Authorization', `Bearer ${user1.accessToken}`)
          .query(query);
        expect(status).toBe(400);
        expect(body).toEqual(errorStub.badRequest(expected));
      });
    }

    const searchTests = [
      {
        should: 'should only return my own assets',
        deferred: () => ({
          query: {},
          assets: [asset3, asset2, asset1],
        }),
      },
      {
        should: 'should sort my assets in reverse',
        deferred: () => ({
          query: { order: 'asc' },
          assets: [asset1, asset2, asset3],
        }),
      },
      {
        should: 'should support custom page sizes',
        deferred: () => ({
          query: { size: 1 },
          assets: [asset3],
        }),
      },
      {
        should: 'should support pagination',
        deferred: () => ({
          query: { size: 1, page: 2 },
          assets: [asset2],
        }),
      },
      {
        should: 'should search by checksum (base64)',
        deferred: () => ({
          query: { checksum: asset1.checksum },
          assets: [asset1],
        }),
      },
      {
        should: 'should search by checksum (hex)',
        deferred: () => ({
          query: { checksum: Buffer.from(asset1.checksum, 'base64').toString('hex') },
          assets: [asset1],
        }),
      },
      {
        should: 'should search by id',
        deferred: () => ({
          query: { id: asset1.id },
          assets: [asset1],
        }),
      },
      {
        should: 'should search by isFavorite (true)',
        deferred: () => ({
          query: { isFavorite: true },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by isFavorite (false)',
        deferred: () => ({
          query: { isFavorite: false },
          assets: [asset2, asset1],
        }),
      },
      {
        should: 'should search by isArchived (true)',
        deferred: () => ({
          query: { isArchived: true },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by isArchived (false)',
        deferred: () => ({
          query: { isArchived: false },
          assets: [asset2, asset1],
        }),
      },
      {
        should: 'should search by isReadOnly (true)',
        deferred: () => ({
          query: { isReadOnly: true },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by isReadOnly (false)',
        deferred: () => ({
          query: { isReadOnly: false },
          assets: [asset2, asset1],
        }),
      },
      {
        should: 'should search by type (image)',
        deferred: () => ({
          query: { type: 'IMAGE' },
          assets: [asset2, asset1],
        }),
      },
      {
        should: 'should search by type (video)',
        deferred: () => ({
          query: { type: 'VIDEO' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by createdBefore',
        deferred: () => ({
          query: { createdBefore: yesterday.plus({ hour: 1 }).toJSDate() },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by createdBefore (no results)',
        deferred: () => ({
          query: { createdBefore: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by createdAfter',
        deferred: () => ({
          query: { createdAfter: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [asset3, asset2, asset1],
        }),
      },
      {
        should: 'should search by createdAfter (no results)',
        deferred: () => ({
          query: { createdAfter: today.plus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by updatedBefore',
        deferred: () => ({
          query: { updatedBefore: yesterday.plus({ hour: 1 }).toJSDate() },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by updatedBefore (no results)',
        deferred: () => ({
          query: { updatedBefore: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by updatedAfter',
        deferred: () => ({
          query: { updatedAfter: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [asset3, asset2, asset1],
        }),
      },
      {
        should: 'should search by updatedAfter (no results)',
        deferred: () => ({
          query: { updatedAfter: today.plus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by trashedBefore',
        deferred: () => ({
          query: { trashedBefore: yesterday.plus({ hour: 1 }).toJSDate() },
          assets: [asset5],
        }),
      },
      {
        should: 'should search by trashedBefore (no results)',
        deferred: () => ({
          query: { trashedBefore: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by trashedAfter',
        deferred: () => ({
          query: { trashedAfter: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [asset5],
        }),
      },
      {
        should: 'should search by trashedAfter (no results)',
        deferred: () => ({
          query: { trashedAfter: today.plus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by takenBefore',
        deferred: () => ({
          query: { takenBefore: yesterday.plus({ hour: 1 }).toJSDate() },
          assets: [asset3, asset2, asset1],
        }),
      },
      {
        should: 'should search by takenBefore (no results)',
        deferred: () => ({
          query: { takenBefore: yesterday.minus({ years: 100 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by takenAfter',
        deferred: () => ({
          query: { takenAfter: yesterday.minus({ hour: 1 }).toJSDate() },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by takenAfter (no results)',
        deferred: () => ({
          query: { takenAfter: today.plus({ hour: 1 }).toJSDate() },
          assets: [],
        }),
      },
      {
        should: 'should search by originalPath',
        deferred: () => ({
          query: { originalPath: asset1.originalPath },
          assets: [asset1],
        }),
      },
      {
        should: 'should search by originalFilename',
        deferred: () => ({
          query: { originalFileName: asset1.originalFileName },
          assets: [asset1],
        }),
      },
      {
        should: 'should search by encodedVideoPath',
        deferred: () => ({
          query: { encodedVideoPath: '/path/to/encoded-video.mp4' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by resizePath',
        deferred: () => ({
          query: { resizePath: '/path/to/thumb.jpg' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by webpPath',
        deferred: () => ({
          query: { webpPath: '/path/to/thumb.webp' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by city',
        deferred: () => ({
          query: { city: 'Immich' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by state',
        deferred: () => ({
          query: { state: 'Nebraska' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by country',
        deferred: () => ({
          query: { country: 'United States' },
          assets: [asset3],
        }),
      },
      {
        should: 'sohuld search by make',
        deferred: () => ({
          query: { make: 'Cannon' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by country',
        deferred: () => ({
          query: { model: 'EOS Rebel T7' },
          assets: [asset3],
        }),
      },
      {
        should: 'should search by lensModel',
        deferred: () => ({
          query: { lensModel: 'Fancy lens' },
          assets: [asset3],
        }),
      },
    ];

    for (const { should, deferred } of searchTests) {
      it(should, async () => {
        const { assets, query } = deferred();
        const { status, body } = await request(server)
          .get('/assets')
          .query(query)
          .set('Authorization', `Bearer ${user1.accessToken}`);

        expect(status).toBe(200);
        expect(body.length).toBe(assets.length);
        for (let i = 0; i < assets.length; i++) {
          expect(body[i]).toEqual(expect.objectContaining({ id: assets[i].id }));
        }
      });
    }
  });

  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 `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);
    });

    it("should not upload to another user's library", async () => {
      const content = randomBytes(32);
      const library = (await api.libraryApi.getAll(server, user2.accessToken))[0];
      await api.assetApi.upload(server, user1.accessToken, 'example-image', { content });

      const { body, status } = await request(server)
        .post('/asset/upload')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .field('libraryId', library.id)
        .field('deviceAssetId', 'example-image')
        .field('deviceId', 'TEST')
        .field('fileCreatedAt', new Date().toISOString())
        .field('fileModifiedAt', new Date().toISOString())
        .field('isFavorite', false)
        .field('duration', '0:00:00.000000')
        .attach('assetData', content, 'example.jpg');

      expect(status).toBe(400);
      expect(body).toEqual(errorStub.badRequest('Not found or no asset.upload access'));
    });
  });

  describe('PUT /asset/:id', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server).put(`/asset/:${uuidStub.notFound}`);
      expect(status).toBe(401);
      expect(body).toEqual(errorStub.unauthorized);
    });

    it('should require a valid id', async () => {
      const { status, body } = await request(server)
        .put(`/asset/${uuidStub.invalid}`)
        .set('Authorization', `Bearer ${user1.accessToken}`);
      expect(status).toBe(400);
      expect(body).toEqual(errorStub.badRequest(['id must be a UUID']));
    });

    it('should require access', async () => {
      const { status, body } = await request(server)
        .put(`/asset/${asset4.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`);
      expect(status).toBe(400);
      expect(body).toEqual(errorStub.noPermission);
    });

    it('should favorite an asset', async () => {
      expect(asset1).toMatchObject({ isFavorite: false });

      const { status, body } = await request(server)
        .put(`/asset/${asset1.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ isFavorite: true });
      expect(body).toMatchObject({ id: asset1.id, isFavorite: true });
      expect(status).toEqual(200);
    });

    it('should archive an asset', async () => {
      expect(asset1).toMatchObject({ isArchived: false });

      const { status, body } = await request(server)
        .put(`/asset/${asset1.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ isArchived: true });
      expect(body).toMatchObject({ id: asset1.id, isArchived: true });
      expect(status).toEqual(200);
    });

    it('should set the description', async () => {
      const { status, body } = await request(server)
        .put(`/asset/${asset1.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ description: 'Test asset description' });
      expect(body).toMatchObject({
        id: asset1.id,
        exifInfo: expect.objectContaining({ description: 'Test asset description' }),
      });
      expect(status).toEqual(200);
    });

    it('should return tagged people', async () => {
      const personRepository = app.get<IPersonRepository>(IPersonRepository);
      const person = await personRepository.create({ ownerId: asset1.ownerId, name: 'Test Person' });

      await personRepository.createFace({ assetId: asset1.id, personId: person.id });

      const { status, body } = await request(server)
        .put(`/asset/${asset1.id}`)
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ isFavorite: true });
      expect(status).toEqual(200);
      expect(body).toMatchObject({
        id: asset1.id,
        isFavorite: true,
        people: [
          {
            birthDate: null,
            id: expect.any(String),
            isHidden: false,
            name: 'Test Person',
            thumbnailPath: '',
          },
        ],
      });
    });
  });

  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('/asset/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(body).toEqual({ images: 5, videos: 1, total: 6 });
      expect(status).toBe(200);
    });

    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: 1, total: 3 });
    });

    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: 1, total: 3 });
    });

    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: 1, total: 2 });
    });

    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: 2, videos: 0, total: 2 });
    });
  });

  describe('GET /asset/random', () => {
    beforeAll(async () => {
      await Promise.all([
        createAsset(user1, new Date('1970-02-01')),
        createAsset(user1, new Date('1970-02-01')),
        createAsset(user1, new Date('1970-02-01')),
        createAsset(user1, new Date('1970-02-01')),
        createAsset(user1, new Date('1970-02-01')),
        createAsset(user1, new Date('1970-02-01')),
      ]);
    });
    it('should require authentication', async () => {
      const { status, body } = await request(server).get('/asset/random');

      expect(status).toBe(401);
      expect(body).toEqual(errorStub.unauthorized);
    });

    it.each(Array(10))('should return 1 random assets', async () => {
      const { status, body } = await request(server)
        .get('/asset/random')
        .set('Authorization', `Bearer ${user1.accessToken}`);

      expect(status).toBe(200);

      const assets: AssetResponseDto[] = body;
      expect(assets.length).toBe(1);
      expect(assets[0].ownerId).toBe(user1.userId);
      //
      // assets owned by user2
      expect(assets[0].id).not.toBe(asset4.id);
      // assets owned by user1
      expect([asset1.id, asset2.id, asset3.id]).toContain(assets[0].id);
    });

    it.each(Array(10))('should return 2 random assets', async () => {
      const { status, body } = await request(server)
        .get('/asset/random?count=2')
        .set('Authorization', `Bearer ${user1.accessToken}`);

      expect(status).toBe(200);

      const assets: AssetResponseDto[] = body;
      expect(assets.length).toBe(2);

      for (const asset of assets) {
        expect(asset.ownerId).toBe(user1.userId);
        // assets owned by user1
        expect([asset1.id, asset2.id, asset3.id]).toContain(asset.id);
        // assets owned by user2
        expect(asset.id).not.toBe(asset4.id);
      }
    });

    it.each(Array(10))(
      'should return 1 asset if there are 10 assets in the database but user 2 only has 1',
      async () => {
        const { status, body } = await request(server)
          .get('/[]asset/random')
          .set('Authorization', `Bearer ${user2.accessToken}`);

        expect(status).toBe(200);
        expect(body).toEqual([expect.objectContaining({ id: asset4.id })]);
      },
    );

    it('should return error', async () => {
      const { status } = await request(server)
        .get('/asset/random?count=ABC')
        .set('Authorization', `Bearer ${user1.accessToken}`);

      expect(status).toBe(400);
    });
  });

  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: '2023-11-01T00:00:00.000Z' },
          { count: 1, timeBucket: '1970-01-01T00:00:00.000Z' },
          { count: 1, timeBucket: '1970-02-01T00:00:00.000Z' },
        ]),
      );
    });

    it('should not allow access for unrelated shared links', async () => {
      const sharedLink = await api.sharedLinkApi.create(server, user1.accessToken, {
        type: SharedLinkType.INDIVIDUAL,
        assetIds: [asset1.id, asset2.id],
      });

      const { status, body } = await request(server)
        .get('/asset/time-buckets')
        .query({ key: sharedLink.key, size: TimeBucketSize.MONTH });

      expect(status).toBe(400);
      expect(body).toEqual(errorStub.noPermission);
    });

    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: asset2.id })]));
    });

    it('should return error if time bucket is requested with partners asset and archived', async () => {
      const req1 = await request(server)
        .get('/asset/time-buckets')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .query({ size: TimeBucketSize.MONTH, withPartners: true, isArchived: true });

      expect(req1.status).toBe(400);
      expect(req1.body).toEqual(errorStub.badRequest());

      const req2 = await request(server)
        .get('/asset/time-buckets')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .query({ size: TimeBucketSize.MONTH, withPartners: true, isArchived: undefined });

      expect(req2.status).toBe(400);
      expect(req2.body).toEqual(errorStub.badRequest());
    });

    it('should return error if time bucket is requested with partners asset and favorite', async () => {
      const req1 = await request(server)
        .get('/asset/time-buckets')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .query({ size: TimeBucketSize.MONTH, withPartners: true, isFavorite: true });

      expect(req1.status).toBe(400);
      expect(req1.body).toEqual(errorStub.badRequest());

      const req2 = await request(server)
        .get('/asset/time-buckets')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .query({ size: TimeBucketSize.MONTH, withPartners: true, isFavorite: false });

      expect(req2.status).toBe(400);
      expect(req2.body).toEqual(errorStub.badRequest());
    });

    it('should return error if time bucket is requested with partners asset and trash', async () => {
      const req = await request(server)
        .get('/asset/time-buckets')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .query({ size: TimeBucketSize.MONTH, withPartners: true, isTrashed: true });

      expect(req.status).toBe(400);
      expect(req.body).toEqual(errorStub.badRequest());
    });
  });

  describe('GET /asset/map-marker', () => {
    beforeEach(async () => {
      await Promise.all([
        assetRepository.save({ id: asset1.id, isArchived: true }),
        assetRepository.upsertExif({ assetId: asset1.id, latitude: 0, longitude: 0 }),
        assetRepository.upsertExif({ assetId: asset2.id, latitude: 0, longitude: 0 }),
      ]);
    });

    it('should require authentication', async () => {
      const { status, body } = await request(server).get('/asset/map-marker');

      expect(status).toBe(401);
      expect(body).toEqual(errorStub.unauthorized);
    });

    it('should get map markers for all non-archived assets', async () => {
      const { status, body } = await request(server)
        .get('/asset/map-marker')
        .query({ isArchived: false })
        .set('Authorization', `Bearer ${user1.accessToken}`);

      expect(status).toBe(200);
      expect(body).toHaveLength(1);
      expect(body).toEqual(expect.arrayContaining([expect.objectContaining({ id: asset2.id })]));
    });

    it('should get all map markers', async () => {
      const { status, body } = await request(server)
        .get('/asset/map-marker')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .query({ isArchived: false });

      expect(status).toBe(200);
      expect(body).toHaveLength(1);
      expect(body).toEqual([expect.objectContaining({ id: asset2.id })]);
    });
  });

  describe('PUT /asset', () => {
    beforeEach(async () => {
      const { status } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ stackParentId: asset1.id, ids: [asset2.id, asset3.id] });

      expect(status).toBe(204);
    });

    it('should require authentication', async () => {
      const { status, body } = await request(server).put('/asset');

      expect(status).toBe(401);
      expect(body).toEqual(errorStub.unauthorized);
    });

    it('should require a valid parent id', async () => {
      const { status, body } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ stackParentId: uuidStub.invalid, ids: [asset1.id] });

      expect(status).toBe(400);
      expect(body).toEqual(errorStub.badRequest(['stackParentId must be a UUID']));
    });

    it('should require access to the parent', async () => {
      const { status, body } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ stackParentId: asset4.id, ids: [asset1.id] });

      expect(status).toBe(400);
      expect(body).toEqual(errorStub.noPermission);
    });

    it('should add stack children', async () => {
      const [parent, child] = await Promise.all([
        createAsset(user1, new Date('1970-01-01')),
        createAsset(user1, new Date('1970-01-01')),
      ]);

      const { status } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ stackParentId: parent.id, ids: [child.id] });

      expect(status).toBe(204);

      const asset = await api.assetApi.get(server, user1.accessToken, parent.id);
      expect(asset.stack).not.toBeUndefined();
      expect(asset.stack).toEqual(expect.arrayContaining([expect.objectContaining({ id: child.id })]));
    });

    it('should remove stack children', async () => {
      const { status } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ removeParent: true, ids: [asset2.id] });

      expect(status).toBe(204);

      const asset = await api.assetApi.get(server, user1.accessToken, asset1.id);
      expect(asset.stack).not.toBeUndefined();
      expect(asset.stack).toEqual(expect.arrayContaining([expect.objectContaining({ id: asset3.id })]));
    });

    it('should remove all stack children', async () => {
      const { status } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ removeParent: true, ids: [asset2.id, asset3.id] });

      expect(status).toBe(204);

      const asset = await api.assetApi.get(server, user1.accessToken, asset1.id);
      expect(asset.stack).toHaveLength(0);
    });

    it('should merge stack children', async () => {
      const newParent = await createAsset(user1, new Date('1970-01-01'));
      const { status } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ stackParentId: newParent.id, ids: [asset1.id] });

      expect(status).toBe(204);

      const asset = await api.assetApi.get(server, user1.accessToken, newParent.id);
      expect(asset.stack).not.toBeUndefined();
      expect(asset.stack).toEqual(
        expect.arrayContaining([
          expect.objectContaining({ id: asset1.id }),
          expect.objectContaining({ id: asset2.id }),
          expect.objectContaining({ id: asset3.id }),
        ]),
      );
    });
  });

  describe('PUT /asset/stack/parent', () => {
    beforeEach(async () => {
      const { status } = await request(server)
        .put('/asset')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ stackParentId: asset1.id, ids: [asset2.id, asset3.id] });

      expect(status).toBe(204);
    });

    it('should require authentication', async () => {
      const { status, body } = await request(server).put('/asset/stack/parent');

      expect(status).toBe(401);
      expect(body).toEqual(errorStub.unauthorized);
    });

    it('should require a valid id', async () => {
      const { status, body } = await request(server)
        .put('/asset/stack/parent')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ oldParentId: uuidStub.invalid, newParentId: uuidStub.invalid });

      expect(status).toBe(400);
      expect(body).toEqual(errorStub.badRequest());
    });

    it('should require access', async () => {
      const { status, body } = await request(server)
        .put('/asset/stack/parent')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ oldParentId: asset4.id, newParentId: asset1.id });

      expect(status).toBe(400);
      expect(body).toEqual(errorStub.noPermission);
    });

    it('should make old parent child of new parent', async () => {
      const { status } = await request(server)
        .put('/asset/stack/parent')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ oldParentId: asset1.id, newParentId: asset2.id });

      expect(status).toBe(200);

      const asset = await api.assetApi.get(server, user1.accessToken, asset2.id);
      expect(asset.stack).not.toBeUndefined();
      expect(asset.stack).toEqual(expect.arrayContaining([expect.objectContaining({ id: asset1.id })]));
    });

    it('should make all childrens of old parent, a child of new parent', async () => {
      const { status } = await request(server)
        .put('/asset/stack/parent')
        .set('Authorization', `Bearer ${user1.accessToken}`)
        .send({ oldParentId: asset1.id, newParentId: asset2.id });

      expect(status).toBe(200);

      const asset = await api.assetApi.get(server, user1.accessToken, asset2.id);
      expect(asset.stack).not.toBeUndefined();
      expect(asset.stack).toEqual(expect.arrayContaining([expect.objectContaining({ id: asset3.id })]));
    });
  });

  describe(AssetRepository.name, () => {
    describe('getWithout', () => {
      describe('WithoutProperty.FACES', () => {
        const getAssetIdsWithoutFaces = async () => {
          const assetPagination = usePagination(10, (pagination) =>
            assetRepository.getWithout(pagination, WithoutProperty.FACES),
          );
          let assets: AssetEntity[] = [];
          for await (const assetsPage of assetPagination) {
            assets = [...assets, ...assetsPage];
          }
          return assets.map((a) => a.id);
        };

        beforeEach(async () => {
          await assetRepository.save({ id: asset1.id, resizePath: '/path/to/resize' });
          expect(await getAssetIdsWithoutFaces()).toContain(asset1.id);
        });

        describe('with recognized faces', () => {
          beforeEach(async () => {
            const personRepository = app.get<IPersonRepository>(IPersonRepository);
            const person = await personRepository.create({ ownerId: asset1.ownerId, name: 'Test Person' });
            await personRepository.createFace({ assetId: asset1.id, personId: person.id });
          });

          it('should not return asset with facesRecognizedAt unset', async () => {
            expect(await getAssetIdsWithoutFaces()).not.toContain(asset1.id);
          });

          it('should not return asset with facesRecognizedAt set', async () => {
            await assetRepository.upsertJobStatus({ assetId: asset1.id, facesRecognizedAt: new Date() });
            expect(await getAssetIdsWithoutFaces()).not.toContain(asset1.id);
          });
        });

        describe('without recognized faces', () => {
          it('should return asset with facesRecognizedAt unset', async () => {
            expect(await getAssetIdsWithoutFaces()).toContain(asset1.id);
          });

          it('should not return asset with facesRecognizedAt set', async () => {
            expect(await getAssetIdsWithoutFaces()).toContain(asset1.id);
            await assetRepository.upsertJobStatus({ assetId: asset1.id, facesRecognizedAt: new Date() });
            expect(await getAssetIdsWithoutFaces()).not.toContain(asset1.id);
          });
        });
      });
    });
  });
});