Use the same describe style at test suite

Author: vilasmaciel

src/Contexts/Backoffice/Courses/infrastructure/persistence/BackofficeMongoConfigFactory.ts

@@ -3,7 +3,6 @@ import MongoConfig from '../../../../Shared/infrastructure/persistence/mongo/Mon
 
 export class BackofficeMongoConfigFactory {
   static createConfig(): MongoConfig {
-    console.log(config.get('mongo.url'));
     return {
       url: config.get('mongo.url')
     };

tests/Contexts/Backoffice/Courses/infrastructure/ElasticBackofficeCourseRepository.test.ts

@@ -11,23 +11,25 @@ const environmentArranger: Promise<EnvironmentArranger> = container.get(
   'Backoffice.Backend.ElasticEnvironmentArranger'
 );
 
-function sort(backofficeCourse1: BackofficeCourse, backofficeCourse2: BackofficeCourse): number {
-  return backofficeCourse1?.id?.value.localeCompare(backofficeCourse2?.id?.value);
-}
-
 afterEach(async () => {
   await (await environmentArranger).arrange();
 });
 
-describe('Search all courses', () => {
-  it('should return the existing courses', async () => {
-    const courses = [BackofficeCourseMother.random(), BackofficeCourseMother.random()];
+describe('ElasticBackofficeCourseRepository', () => {
+  describe('#searchAll', () => {
+    it('should return the existing courses', async () => {
+      const courses = [BackofficeCourseMother.random(), BackofficeCourseMother.random()];
 
-    await Promise.all(courses.map(async course => repository.save(course)));
+      await Promise.all(courses.map(async course => repository.save(course)));
 
-    const expectedCourses = await repository.searchAll();
+      const expectedCourses = await repository.searchAll();
 
-    expect(courses.length).toEqual(expectedCourses.length);
-    expect(courses.sort(sort)).toEqual(expectedCourses.sort(sort));
+      expect(courses.length).toEqual(expectedCourses.length);
+      expect(courses.sort(sort)).toEqual(expectedCourses.sort(sort));
+    });
   });
 });
+
+function sort(backofficeCourse1: BackofficeCourse, backofficeCourse2: BackofficeCourse): number {
+  return backofficeCourse1?.id?.value.localeCompare(backofficeCourse2?.id?.value);
+}

tests/Contexts/Backoffice/Courses/infrastructure/MongoBackofficeCourseRepository.test.ts

@@ -15,21 +15,23 @@ afterAll(async () => {
   await (await environmentArranger).close();
 });
 
-describe('Mongo BackofficeCourse Repository', () => {
-  it('should return the existing courses', async () => {
-    const courses = [BackofficeCourseMother.random(), BackofficeCourseMother.random()];
+describe('MongoBackofficeCourseRepository', () => {
+  describe('#searchAll', () => {
+    it('should return the existing courses', async () => {
+      const courses = [BackofficeCourseMother.random(), BackofficeCourseMother.random()];
 
-    await Promise.all(courses.map(course => repository.save(course)));
+      await Promise.all(courses.map(course => repository.save(course)));
 
-    const expectedCourses = await repository.searchAll();
-    expect(courses.sort(sort)).toStrictEqual(expectedCourses.sort(sort));
-  });
+      const expectedCourses = await repository.searchAll();
+      expect(courses.sort(sort)).toStrictEqual(expectedCourses.sort(sort));
+    });
 
-  it('should save a course', async () => {
-    const course = BackofficeCourseMother.random();
+    it('should save a course', async () => {
+      const course = BackofficeCourseMother.random();
 
-    await repository.save(course);
-    expect(await repository.searchAll()).toContainEqual(course);
+      await repository.save(course);
+      expect(await repository.searchAll()).toContainEqual(course);
+    });
   });
 });
 

tests/Contexts/Mooc/Courses/application/CourseCreator.test.ts

@@ -16,10 +16,12 @@ beforeEach(() => {
   handler = new CreateCourseCommandHandler(creator);
 });
 
-it('should create a valid course', async () => {
-  const command = CreateCourseCommandMother.random();
-  await handler.handle(command);
+describe('CourseCreator', () => {
+  it('should create a valid course', async () => {
+    const command = CreateCourseCommandMother.random();
+    await handler.handle(command);
 
-  const course = CourseMother.fromCommand(command);
-  repository.assertLastSavedCourseIs(course);
+    const course = CourseMother.fromCommand(command);
+    repository.assertLastSavedCourseIs(course);
+  });
 });

tests/Contexts/Mooc/Courses/infrastructure/persistence/CourseRepository.test.ts renamed to tests/Contexts/Mooc/Courses/infrastructure/persistence/MongoCourseRepository.test.ts

@@ -14,24 +14,26 @@ afterAll(async () => {
   await (await environmentArranger).close();
 });
 
-describe('Save Course', () => {
-  it('should save a course', async () => {
-    const course = CourseMother.random();
+describe('MongoCourseRepository', () => {
+  describe('#save', () => {
+    it('should save a course', async () => {
+      const course = CourseMother.random();
 
-    await repository.save(course);
+      await repository.save(course);
+    });
   });
-});
 
-describe('Search Course', () => {
-  it('should return an existing course', async () => {
-    const course = CourseMother.random();
+  describe('#search', () => {
+    it('should return an existing course', async () => {
+      const course = CourseMother.random();
 
-    await repository.save(course);
+      await repository.save(course);
 
-    expect(course).toEqual(await repository.search(course.id));
-  });
+      expect(course).toEqual(await repository.search(course.id));
+    });
 
-  it('should not return a non existing course', async () => {
-    expect(await repository.search(CourseMother.random().id)).toBeFalsy();
+    it('should not return a non existing course', async () => {
+      expect(await repository.search(CourseMother.random().id)).toBeFalsy();
+    });
   });
 });

tests/Contexts/Mooc/CoursesCounter/application/Find/FindCourseCounterQueryHandler.test.ts

@@ -1,10 +1,10 @@
 import { CoursesCounterFinder } from '../../../../../../src/Contexts/Mooc/CoursesCounter/application/Find/CoursesCounterFinder';
+import { FindCoursesCounterQuery } from '../../../../../../src/Contexts/Mooc/CoursesCounter/application/Find/FindCoursesCounterQuery';
+import { FindCoursesCounterQueryHandler } from '../../../../../../src/Contexts/Mooc/CoursesCounter/application/Find/FindCoursesCounterQueryHandler';
+import { CoursesCounterNotExist } from '../../../../../../src/Contexts/Mooc/CoursesCounter/domain/CoursesCounterNotExist';
 import { CoursesCounterMother } from '../../domain/CoursesCounterMother';
-import { CoursesCounterRepositoryMock } from '../../__mocks__/CoursesCounterRepositoryMock';
 import { CoursesCounterResponseMother } from '../../domain/CoursesCounterResponseMother';
-import { CoursesCounterNotExist } from '../../../../../../src/Contexts/Mooc/CoursesCounter/domain/CoursesCounterNotExist';
-import { FindCoursesCounterQueryHandler } from '../../../../../../src/Contexts/Mooc/CoursesCounter/application/Find/FindCoursesCounterQueryHandler';
-import { FindCoursesCounterQuery } from '../../../../../../src/Contexts/Mooc/CoursesCounter/application/Find/FindCoursesCounterQuery';
+import { CoursesCounterRepositoryMock } from '../../__mocks__/CoursesCounterRepositoryMock';
 
 describe('FindCourseCounter QueryHandler', () => {
   let repository: CoursesCounterRepositoryMock;
@@ -13,16 +13,15 @@ describe('FindCourseCounter QueryHandler', () => {
     repository = new CoursesCounterRepositoryMock();
   });
 
-
   it('should find an existing courses counter', async () => {
     const counter = CoursesCounterMother.random();
     repository.returnOnSearch(counter);
 
     const handler = new FindCoursesCounterQueryHandler(new CoursesCounterFinder(repository));
-    
+
     const query = new FindCoursesCounterQuery();
     const response = await handler.handle(query);
-    
+
     repository.assertSearch();
 
     const expected = CoursesCounterResponseMother.create(counter.total);

tests/Contexts/Mooc/CoursesCounter/doubles/CoursesCounterRepository.ts

@@ -14,24 +14,26 @@ afterAll(async () => {
   await (await environmentArranger).close();
 });
 
-describe('Save CoursesCounter', () => {
-  it('should save a courses counter', async () => {
-    const course = CoursesCounterMother.random();
+describe('MongoCoursesCounterRepository', () => {
+  describe('#save', () => {
+    it('should save a courses counter', async () => {
+      const course = CoursesCounterMother.random();
 
-    await repository.save(course);
+      await repository.save(course);
+    });
   });
-});
 
-describe('Search CoursesCounter', () => {
-  it('should return an existing course', async () => {
-    const counter = CoursesCounterMother.random();
+  describe('#search', () => {
+    it('should return an existing course', async () => {
+      const counter = CoursesCounterMother.random();
 
-    await repository.save(counter);
+      await repository.save(counter);
 
-    expect(counter).toEqual(await repository.search());
-  });
+      expect(counter).toEqual(await repository.search());
+    });
 
-  it('should not return null if there is no courses counter', async () => {
-    expect(await repository.search()).toBeFalsy();
+    it('should not return null if there is no courses counter', async () => {
+      expect(await repository.search()).toBeFalsy();
+    });
   });
 });

tests/Contexts/Mooc/CoursesCounter/infrastructure/CoursesCounterRepository.test.ts renamed to tests/Contexts/Mooc/CoursesCounter/infrastructure/MongoCoursesCounterRepository.test.ts

@@ -32,17 +32,7 @@ describe('SendWelcomeUserEmailOnUserRegistered event handler', () => {
     const sendWelcomeUserEmailOnUserRegistered = new SendWelcomeUserEmailOnUserRegistered(sendWelcomeUserEmail);
 
     const domainEvent = aDomainEventWithEmailAddress(anEmailAddress());
-    let error;
-
-    try {
-      await sendWelcomeUserEmailOnUserRegistered.on(domainEvent);
-    } catch (e) {
-      error = e;
-    }
-
-    expect(error).toBeDefined();
-    expect(error).toBeInstanceOf(WelcomeUserEmailError);
-    expect(error.message).toBe(`Error sending WelcomeUser email to ${domainEvent.userEmailAddress}`);
+    await expect(sendWelcomeUserEmailOnUserRegistered.on(domainEvent)).rejects.toBeInstanceOf(WelcomeUserEmailError);
   });
 });
 

tests/Contexts/Mooc/Notifications/application/SendWelcomeUserEmail/SendWelcomeUserEmailOnUserRegistered.test.ts

@@ -1,36 +1,38 @@
 import { MongoClientFactory } from '../../../../src/Contexts/Shared/infrastructure/persistence/mongo/MongoClientFactory';
 import { MongoClient } from 'mongodb';
 
-describe('Create a client', () => {
-  const factory = MongoClientFactory;
-  let client: MongoClient;
+describe('MongoClientFactory', () => {
+  describe('#createClient', () => {
+    const factory = MongoClientFactory;
+    let client: MongoClient;
 
-  beforeEach(async () => {
-    client = await factory.createClient('test', { url: 'mongodb://localhost:27017/mooc-backend-test' });
-  });
+    beforeEach(async () => {
+      client = await factory.createClient('test', { url: 'mongodb://localhost:27017/mooc-backend-test' });
+    });
 
-  afterEach(async () => {
-    await client.close();
-  });
+    afterEach(async () => {
+      await client.close();
+    });
 
-  it('creates a new client with the connection already established', () => {
-    expect(client).toBeInstanceOf(MongoClient);
-    expect(client.isConnected()).toBeTruthy();
-  });
+    it('creates a new client with the connection already established', () => {
+      expect(client).toBeInstanceOf(MongoClient);
+      expect(client.isConnected()).toBeTruthy();
+    });
 
-  it('creates a new client if it does not exist a client with the given name', async () => {
-    const newClient = await factory.createClient('test2', { url: 'mongodb://localhost:27017/mooc-backend-test' });
+    it('creates a new client if it does not exist a client with the given name', async () => {
+      const newClient = await factory.createClient('test2', { url: 'mongodb://localhost:27017/mooc-backend-test' });
 
-    expect(newClient).not.toBe(client);
+      expect(newClient).not.toBe(client);
 
-    await newClient.close();
-  });
+      await newClient.close();
+    });
 
-  it('returns a client if it already exists', async () => {
-    const newClient = await factory.createClient('test', { url: 'mongodb://localhost:27017/mooc-backend-test' });
+    it('returns a client if it already exists', async () => {
+      const newClient = await factory.createClient('test', { url: 'mongodb://localhost:27017/mooc-backend-test' });
 
-    expect(newClient).toBe(client);
+      expect(newClient).toBe(client);
 
-    await newClient.close();
+      await newClient.close();
+    });
   });
 });