refactor(server): e2e

e2e/src/api/specs/download.e2e-spec.ts

@@ -0,0 +1,62 @@
+import { AssetResponseDto, LoginResponseDto } from '@immich/sdk';
+import { errorDto } from 'src/responses';
+import { apiUtils, app, dbUtils } from 'src/utils';
+import request from 'supertest';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+describe('/download', () => {
+  let admin: LoginResponseDto;
+  let asset1: AssetResponseDto;
+
+  beforeAll(async () => {
+    apiUtils.setup();
+    await dbUtils.reset();
+    admin = await apiUtils.adminSetup();
+    asset1 = await apiUtils.createAsset(admin.accessToken);
+  });
+
+  describe('POST /download/info', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(app)
+        .post(`/download/info`)
+        .send({ assetIds: [asset1.id] });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorDto.unauthorized);
+    });
+
+    it('should download info', async () => {
+      const { status, body } = await request(app)
+        .post('/download/info')
+        .set('Authorization', `Bearer ${admin.accessToken}`)
+        .send({ assetIds: [asset1.id] });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(
+        expect.objectContaining({
+          archives: [expect.objectContaining({ assetIds: [asset1.id] })],
+        })
+      );
+    });
+  });
+
+  describe('POST /download/asset/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(app).post(
+        `/download/asset/${asset1.id}`
+      );
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorDto.unauthorized);
+    });
+
+    it('should download file', async () => {
+      const response = await request(app)
+        .post(`/download/asset/${asset1.id}`)
+        .set('Authorization', `Bearer ${admin.accessToken}`);
+
+      expect(response.status).toBe(200);
+      expect(response.headers['content-type']).toEqual('image/jpeg');
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+import { errorDto } from 'src/responses';
+import { apiUtils, app, dbUtils } from 'src/utils';
+import request from 'supertest';
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+describe(`/oauth`, () => {
+  beforeAll(() => {
+    apiUtils.setup();
+  });
+
+  beforeEach(async () => {
+    await dbUtils.reset();
+    await apiUtils.adminSetup();
+  });
+
+  describe('POST /oauth/authorize', () => {
+    it(`should throw an error if a redirect uri is not provided`, async () => {
+      const { status, body } = await request(app)
+        .post('/oauth/authorize')
+        .send({});
+      expect(status).toBe(400);
+      expect(body).toEqual(
+        errorDto.badRequest([
+          'redirectUri must be a string',
+          'redirectUri should not be empty',
+        ])
+      );
+    });
+  });
+});

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

@@ -1,68 +1,63 @@
-import { LoginResponseDto, PartnerDirection } from '@app/domain';
-import { PartnerController } from '@app/immich';
-import { errorStub, userDto } from '@test/fixtures';
+import { LoginResponseDto, createPartner } from '@immich/sdk';
+import { createUserDto } from 'src/fixtures';
+import { errorDto } from 'src/responses';
+import { apiUtils, app, asBearerAuth, dbUtils } from 'src/utils';
 import request from 'supertest';
-import { api } from '../../client';
-import { testApp } from '../utils';
+import { beforeAll, describe, expect, it } from 'vitest';
 
-describe(`${PartnerController.name} (e2e)`, () => {
-  let server: any;
+describe('/partner', () => {
+  let admin: LoginResponseDto;
   let user1: LoginResponseDto;
   let user2: LoginResponseDto;
   let user3: LoginResponseDto;
 
   beforeAll(async () => {
-    server = (await testApp.create()).getHttpServer();
+    apiUtils.setup();
+    await dbUtils.reset();
 
-    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),
-      api.userApi.create(server, admin.accessToken, userDto.user3),
-    ]);
+    admin = await apiUtils.adminSetup();
 
     [user1, user2, user3] = await Promise.all([
-      api.authApi.login(server, userDto.user1),
-      api.authApi.login(server, userDto.user2),
-      api.authApi.login(server, userDto.user3),
+      apiUtils.userSetup(admin.accessToken, createUserDto.user1),
+      apiUtils.userSetup(admin.accessToken, createUserDto.user2),
+      apiUtils.userSetup(admin.accessToken, createUserDto.user3),
     ]);
 
     await Promise.all([
-      api.partnerApi.create(server, user1.accessToken, user2.userId),
-      api.partnerApi.create(server, user2.accessToken, user1.userId),
+      createPartner(
+        { id: user2.userId },
+        { headers: asBearerAuth(user1.accessToken) }
+      ),
+      createPartner(
+        { id: user1.userId },
+        { headers: asBearerAuth(user2.accessToken) }
+      ),
     ]);
   });
 
-  afterAll(async () => {
-    await testApp.teardown();
-  });
-
   describe('GET /partner', () => {
     it('should require authentication', async () => {
-      const { status, body } = await request(server).get('/partner');
+      const { status, body } = await request(app).get('/partner');
 
       expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
+      expect(body).toEqual(errorDto.unauthorized);
     });
 
     it('should get all partners shared by user', async () => {
-      const { status, body } = await request(server)
+      const { status, body } = await request(app)
         .get('/partner')
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .query({ direction: PartnerDirection.SharedBy });
+        .query({ direction: 'shared-by' });
 
       expect(status).toBe(200);
       expect(body).toEqual([expect.objectContaining({ id: user2.userId })]);
     });
 
     it('should get all partners that share with user', async () => {
-      const { status, body } = await request(server)
+      const { status, body } = await request(app)
         .get('/partner')
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .query({ direction: PartnerDirection.SharedWith });
+        .query({ direction: 'shared-with' });
 
       expect(status).toBe(200);
       expect(body).toEqual([expect.objectContaining({ id: user2.userId })]);
@@ -71,14 +66,16 @@ describe(`${PartnerController.name} (e2e)`, () => {
 
   describe('POST /partner/:id', () => {
     it('should require authentication', async () => {
-      const { status, body } = await request(server).post(`/partner/${user3.userId}`);
+      const { status, body } = await request(app).post(
+        `/partner/${user3.userId}`
+      );
 
       expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
+      expect(body).toEqual(errorDto.unauthorized);
     });
 
     it('should share with new partner', async () => {
-      const { status, body } = await request(server)
+      const { status, body } = await request(app)
         .post(`/partner/${user3.userId}`)
         .set('Authorization', `Bearer ${user1.accessToken}`);
 
@@ -87,57 +84,67 @@ describe(`${PartnerController.name} (e2e)`, () => {
     });
 
     it('should not share with new partner if already sharing with this partner', async () => {
-      const { status, body } = await request(server)
+      const { status, body } = await request(app)
         .post(`/partner/${user2.userId}`)
         .set('Authorization', `Bearer ${user1.accessToken}`);
 
       expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'Partner already exists' }));
+      expect(body).toEqual(
+        expect.objectContaining({ message: 'Partner already exists' })
+      );
     });
   });
 
   describe('PUT /partner/:id', () => {
     it('should require authentication', async () => {
-      const { status, body } = await request(server).put(`/partner/${user2.userId}`);
+      const { status, body } = await request(app).put(
+        `/partner/${user2.userId}`
+      );
 
       expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
+      expect(body).toEqual(errorDto.unauthorized);
     });
 
     it('should update partner', async () => {
-      const { status, body } = await request(server)
+      const { status, body } = await request(app)
         .put(`/partner/${user2.userId}`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
         .send({ inTimeline: false });
 
       expect(status).toBe(200);
-      expect(body).toEqual(expect.objectContaining({ id: user2.userId, inTimeline: false }));
+      expect(body).toEqual(
+        expect.objectContaining({ id: user2.userId, inTimeline: false })
+      );
     });
   });
 
   describe('DELETE /partner/:id', () => {
     it('should require authentication', async () => {
-      const { status, body } = await request(server).delete(`/partner/${user3.userId}`);
+      const { status, body } = await request(app).delete(
+        `/partner/${user3.userId}`
+      );
 
       expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
+      expect(body).toEqual(errorDto.unauthorized);
     });
 
     it('should delete partner', async () => {
-      const { status } = await request(server)
+      const { status } = await request(app)
         .delete(`/partner/${user3.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)
+      const { status, body } = await request(app)
         .delete(`/partner/${user3.userId}`)
         .set('Authorization', `Bearer ${user1.accessToken}`);
 
       expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'Partner not found' }));
+      expect(body).toEqual(
+        expect.objectContaining({ message: 'Partner not found' })
+      );
     });
   });
 });