mirror of
https://github.com/immich-app/immich.git
synced 2024-12-24 10:37:28 +02:00
8d5bf93360
* feat: asset e2e with job option * feat: checkout test assets * feat: library e2e tests * fix: use node 21 in e2e * fix: tests * fix: use normalized external path * feat: more external path tests * chore: use parametrized tests * chore: remove unused test code * chore: refactor test asset path * feat: centralize test app creation * fix: correct error message for missing assets * feat: test file formats * fix: don't compare checksum * feat: build libvips * fix: install meson * fix: use immich test asset repo * feat: test nikon raw files * fix: set Z timezone * feat: test offline library files * feat: richer metadata tests * feat: e2e tests in docker * feat: e2e test with arm64 docker * fix: manual docker compose run * fix: remove metadata processor import * fix: run e2e tests in test.yml * fix: checkout e2e assets * fix: typo * fix: checkout files in app directory * fix: increase e2e memory * fix: rm submodules * fix: revert action name * test: mark file offline when external path changes * feat: rename env var to TEST_ENV * docs: new test procedures * feat: can run docker e2e tests manually if needed * chore: use new node 20.8 for e2e * chore: bump exiftool-vendored * feat: simplify test launching * fix: rename env vars to use immich_ prefix * feat: asset folder is submodule * chore: cleanup after 20.8 upgrade * fix: don't log postgres in e2e * fix: better warning about not running all tests --------- Co-authored-by: Jonathan Jogenfors <jonathan@jogenfors.se>
184 lines
6.2 KiB
TypeScript
184 lines
6.2 KiB
TypeScript
import { IPersonRepository, LoginResponseDto } from '@app/domain';
|
|
import { PersonController } from '@app/immich';
|
|
import { PersonEntity } from '@app/infra/entities';
|
|
import { INestApplication } from '@nestjs/common';
|
|
import { api } from '@test/api';
|
|
import { db } from '@test/db';
|
|
import { errorStub, uuidStub } from '@test/fixtures';
|
|
import { createTestApp } from '@test/test-utils';
|
|
import request from 'supertest';
|
|
|
|
describe(`${PersonController.name}`, () => {
|
|
let app: INestApplication;
|
|
let server: any;
|
|
let loginResponse: LoginResponseDto;
|
|
let accessToken: string;
|
|
let personRepository: IPersonRepository;
|
|
let visiblePerson: PersonEntity;
|
|
let hiddenPerson: PersonEntity;
|
|
|
|
beforeAll(async () => {
|
|
app = await createTestApp();
|
|
server = app.getHttpServer();
|
|
personRepository = app.get<IPersonRepository>(IPersonRepository);
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await db.reset();
|
|
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 personRepository.createFace({ assetId: faceAsset.id, personId: visiblePerson.id });
|
|
|
|
hiddenPerson = await personRepository.create({
|
|
ownerId: loginResponse.userId,
|
|
name: 'hidden_person',
|
|
isHidden: true,
|
|
thumbnailPath: '/thumbnail/face_asset',
|
|
});
|
|
await personRepository.createFace({ assetId: faceAsset.id, personId: hiddenPerson.id });
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await db.disconnect();
|
|
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}`);
|
|
expect(status).toBe(401);
|
|
expect(body).toEqual(errorStub.unauthorized);
|
|
});
|
|
|
|
for (const { key, type } of [
|
|
{ key: 'name', type: 'string' },
|
|
{ key: 'featureFaceAssetId', type: 'string' },
|
|
{ key: 'isHidden', type: 'boolean value' },
|
|
]) {
|
|
it(`should not allow null ${key}`, async () => {
|
|
const { status, body } = await request(server)
|
|
.put(`/person/${visiblePerson.id}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.send({ [key]: null });
|
|
expect(status).toBe(400);
|
|
expect(body).toEqual(errorStub.badRequest([`${key} must be a ${type}`]));
|
|
});
|
|
}
|
|
|
|
it('should not accept invalid birth dates', async () => {
|
|
for (const { birthDate, response } of [
|
|
{ birthDate: false, response: ['id must be a UUID'] },
|
|
{ birthDate: 'false', response: ['birthDate must be a Date instance'] },
|
|
{ birthDate: '123567', response: ['id must be a UUID'] },
|
|
{ birthDate: 123456, response: ['id must be a UUID'] },
|
|
]) {
|
|
const { status, body } = await request(server)
|
|
.put(`/person/${uuidStub.notFound}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.send({ birthDate });
|
|
expect(status).toBe(400);
|
|
expect(body).toEqual(errorStub.badRequest(response));
|
|
}
|
|
});
|
|
|
|
it('should update a date of birth', async () => {
|
|
const { status, body } = await request(server)
|
|
.put(`/person/${visiblePerson.id}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.send({ birthDate: '1990-01-01T05:00:00.000Z' });
|
|
expect(status).toBe(200);
|
|
expect(body).toMatchObject({ birthDate: '1990-01-01' });
|
|
});
|
|
|
|
it('should clear a date of birth', async () => {
|
|
const person = await personRepository.create({
|
|
birthDate: new Date('1990-01-01'),
|
|
ownerId: loginResponse.userId,
|
|
});
|
|
|
|
expect(person.birthDate).toBeDefined();
|
|
|
|
const { status, body } = await request(server)
|
|
.put(`/person/${person.id}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.send({ birthDate: null });
|
|
expect(status).toBe(200);
|
|
expect(body).toMatchObject({ birthDate: null });
|
|
});
|
|
});
|
|
});
|