Migrate public alias API E2E test to global TestSetup

Signed-off-by: David Mehren <git@herrmehren.de>

test/public-api/alias.e2e-spec.ts

@@ -3,73 +3,29 @@
  *
  * SPDX-License-Identifier: AGPL-3.0-only
  */
-import { INestApplication } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { Test } from '@nestjs/testing';
-import { TypeOrmModule } from '@nestjs/typeorm';
 import request from 'supertest';
 
-import { PublicApiModule } from '../../src/api/public/public-api.module';
-import { AuthModule } from '../../src/auth/auth.module';
-import { MockAuthGuard } from '../../src/auth/mock-auth.guard';
-import { TokenAuthGuard } from '../../src/auth/token.strategy';
-import appConfigMock from '../../src/config/mock/app.config.mock';
-import mediaConfigMock from '../../src/config/mock/media.config.mock';
-import { GroupsModule } from '../../src/groups/groups.module';
-import { LoggerModule } from '../../src/logger/logger.module';
 import { AliasCreateDto } from '../../src/notes/alias-create.dto';
 import { AliasUpdateDto } from '../../src/notes/alias-update.dto';
-import { AliasService } from '../../src/notes/alias.service';
-import { NotesModule } from '../../src/notes/notes.module';
-import { NotesService } from '../../src/notes/notes.service';
-import { PermissionsModule } from '../../src/permissions/permissions.module';
 import { User } from '../../src/users/user.entity';
-import { UsersModule } from '../../src/users/users.module';
-import { UsersService } from '../../src/users/users.service';
+import { TestSetup } from '../test-setup';
 
 describe('Notes', () => {
-  let app: INestApplication;
-  let notesService: NotesService;
-  let aliasService: AliasService;
+  let testSetup: TestSetup;
+
   let user: User;
   let content: string;
   let forbiddenNoteId: string;
 
   beforeAll(async () => {
-    const moduleRef = await Test.createTestingModule({
-      imports: [
-        ConfigModule.forRoot({
-          isGlobal: true,
-          load: [mediaConfigMock, appConfigMock],
-        }),
-        PublicApiModule,
-        NotesModule,
-        PermissionsModule,
-        GroupsModule,
-        TypeOrmModule.forRoot({
-          type: 'sqlite',
-          database: './hedgedoc-e2e-notes.sqlite',
-          autoLoadEntities: true,
-          synchronize: true,
-          dropSchema: true,
-        }),
-        LoggerModule,
-        AuthModule,
-        UsersModule,
-      ],
-    })
-      .overrideGuard(TokenAuthGuard)
-      .useClass(MockAuthGuard)
-      .compile();
+    testSetup = await TestSetup.create();
 
-    const config = moduleRef.get<ConfigService>(ConfigService);
-    forbiddenNoteId = config.get('appConfig').forbiddenNoteIds[0];
-    app = moduleRef.createNestApplication();
-    await app.init();
-    notesService = moduleRef.get(NotesService);
-    aliasService = moduleRef.get(AliasService);
-    const userService = moduleRef.get(UsersService);
-    user = await userService.createUser('hardcoded', 'Testy');
+    forbiddenNoteId =
+      testSetup.configService.get('appConfig').forbiddenNoteIds[0];
+
+    await testSetup.app.init();
+
+    user = await testSetup.userService.createUser('hardcoded', 'Testy');
     content = 'This is a test note.';
   });
 
@@ -81,14 +37,18 @@ describe('Notes', () => {
     };
     let publicId = '';
     beforeAll(async () => {
-      const note = await notesService.createNote(content, testAlias, user);
+      const note = await testSetup.notesService.createNote(
+        content,
+        testAlias,
+        user,
+      );
       publicId = note.publicId;
     });
 
     it('create with normal alias', async () => {
       const newAlias = 'normalAlias';
       newAliasDto.newAlias = newAlias;
-      const metadata = await request(app.getHttpServer())
+      const metadata = await request(testSetup.app.getHttpServer())
         .post(`/alias`)
         .set('Content-Type', 'application/json')
         .send(newAliasDto)
@@ -96,7 +56,7 @@ describe('Notes', () => {
       expect(metadata.body.name).toEqual(newAlias);
       expect(metadata.body.primaryAlias).toBeFalsy();
       expect(metadata.body.noteId).toEqual(publicId);
-      const note = await request(app.getHttpServer())
+      const note = await request(testSetup.app.getHttpServer())
         .get(`/notes/${newAlias}`)
         .expect(200);
       expect(note.body.metadata.aliases).toContain(newAlias);
@@ -107,7 +67,7 @@ describe('Notes', () => {
     describe('does not create an alias', () => {
       it('because of a forbidden alias', async () => {
         newAliasDto.newAlias = forbiddenNoteId;
-        await request(app.getHttpServer())
+        await request(testSetup.app.getHttpServer())
           .post(`/alias`)
           .set('Content-Type', 'application/json')
           .send(newAliasDto)
@@ -115,7 +75,7 @@ describe('Notes', () => {
       });
       it('because of a alias that is a public id', async () => {
         newAliasDto.newAlias = publicId;
-        await request(app.getHttpServer())
+        await request(testSetup.app.getHttpServer())
           .post(`/alias`)
           .set('Content-Type', 'application/json')
           .send(newAliasDto)
@@ -132,13 +92,17 @@ describe('Notes', () => {
     };
     let publicId = '';
     beforeAll(async () => {
-      const note = await notesService.createNote(content, testAlias, user);
+      const note = await testSetup.notesService.createNote(
+        content,
+        testAlias,
+        user,
+      );
       publicId = note.publicId;
-      await aliasService.addAlias(note, newAlias);
+      await testSetup.aliasService.addAlias(note, newAlias);
     });
 
     it('updates a note with a normal alias', async () => {
-      const metadata = await request(app.getHttpServer())
+      const metadata = await request(testSetup.app.getHttpServer())
         .put(`/alias/${newAlias}`)
         .set('Content-Type', 'application/json')
         .send(changeAliasDto)
@@ -146,7 +110,7 @@ describe('Notes', () => {
       expect(metadata.body.name).toEqual(newAlias);
       expect(metadata.body.primaryAlias).toBeTruthy();
       expect(metadata.body.noteId).toEqual(publicId);
-      const note = await request(app.getHttpServer())
+      const note = await request(testSetup.app.getHttpServer())
         .get(`/notes/${newAlias}`)
         .expect(200);
       expect(note.body.metadata.aliases).toContain(newAlias);
@@ -156,7 +120,7 @@ describe('Notes', () => {
 
     describe('does not update', () => {
       it('a note with unknown alias', async () => {
-        await request(app.getHttpServer())
+        await request(testSetup.app.getHttpServer())
           .put(`/alias/i_dont_exist`)
           .set('Content-Type', 'application/json')
           .send(changeAliasDto)
@@ -164,7 +128,7 @@ describe('Notes', () => {
       });
       it('if the property primaryAlias is false', async () => {
         changeAliasDto.primaryAlias = false;
-        await request(app.getHttpServer())
+        await request(testSetup.app.getHttpServer())
           .put(`/alias/${newAlias}`)
           .set('Content-Type', 'application/json')
           .send(changeAliasDto)
@@ -177,37 +141,45 @@ describe('Notes', () => {
     const testAlias = 'aliasTest3';
     const newAlias = 'normalAlias3';
     beforeAll(async () => {
-      const note = await notesService.createNote(content, testAlias, user);
-      await aliasService.addAlias(note, newAlias);
+      const note = await testSetup.notesService.createNote(
+        content,
+        testAlias,
+        user,
+      );
+      await testSetup.aliasService.addAlias(note, newAlias);
     });
 
     it('deletes a normal alias', async () => {
-      await request(app.getHttpServer())
+      await request(testSetup.app.getHttpServer())
         .delete(`/alias/${newAlias}`)
         .expect(204);
-      await request(app.getHttpServer()).get(`/notes/${newAlias}`).expect(404);
+      await request(testSetup.app.getHttpServer())
+        .get(`/notes/${newAlias}`)
+        .expect(404);
     });
 
     it('does not delete an unknown alias', async () => {
-      await request(app.getHttpServer())
+      await request(testSetup.app.getHttpServer())
         .delete(`/alias/i_dont_exist`)
         .expect(404);
     });
 
     it('does not delete a primary alias (if it is not the only one)', async () => {
-      const note = await notesService.getNoteByIdOrAlias(testAlias);
-      await aliasService.addAlias(note, newAlias);
-      await request(app.getHttpServer())
+      const note = await testSetup.notesService.getNoteByIdOrAlias(testAlias);
+      await testSetup.aliasService.addAlias(note, newAlias);
+      await request(testSetup.app.getHttpServer())
         .delete(`/alias/${testAlias}`)
         .expect(400);
-      await request(app.getHttpServer()).get(`/notes/${newAlias}`).expect(200);
+      await request(testSetup.app.getHttpServer())
+        .get(`/notes/${newAlias}`)
+        .expect(200);
     });
 
     it('deletes a primary alias (if it is the only one)', async () => {
-      await request(app.getHttpServer())
+      await request(testSetup.app.getHttpServer())
         .delete(`/alias/${newAlias}`)
         .expect(204);
-      await request(app.getHttpServer())
+      await request(testSetup.app.getHttpServer())
         .delete(`/alias/${testAlias}`)
         .expect(204);
     });

test/test-setup.ts

@@ -25,6 +25,7 @@ import { IdentityService } from '../src/identity/identity.service';
 import { LoggerModule } from '../src/logger/logger.module';
 import { MediaModule } from '../src/media/media.module';
 import { MediaService } from '../src/media/media.service';
+import { AliasService } from '../src/notes/alias.service';
 import { NotesModule } from '../src/notes/notes.module';
 import { NotesService } from '../src/notes/notes.service';
 import { PermissionsModule } from '../src/permissions/permissions.module';
@@ -41,6 +42,7 @@ export class TestSetup {
   notesService: NotesService;
   mediaService: MediaService;
   historyService: HistoryService;
+  aliasService: AliasService;
 
   public static async create(): Promise<TestSetup> {
     const testSetup = new TestSetup();
@@ -91,6 +93,8 @@ export class TestSetup {
       testSetup.moduleRef.get<MediaService>(MediaService);
     testSetup.historyService =
       testSetup.moduleRef.get<HistoryService>(HistoryService);
+    testSetup.aliasService =
+      testSetup.moduleRef.get<AliasService>(AliasService);
 
     testSetup.app = testSetup.moduleRef.createNestApplication();