elastic infrastructure test

Author: alemarcha

src/Contexts/Backoffice/domain/BackofficeCourse.ts

@@ -40,4 +40,8 @@ export class BackofficeCourse extends AggregateRoot {
       duration: this.duration.value
     };
   }
+
+  static sort(backofficeCourse1: BackofficeCourse, backofficeCourse2: BackofficeCourse): number {
+    return backofficeCourse1?.id?.value.localeCompare(backofficeCourse2?.id?.value);
+  }
 }

src/Contexts/Backoffice/infrastructure/ElasticBackofficeCourseRepository.ts

@@ -1,10 +1,6 @@
 import { ElasticRepository } from '../../Shared/infrastructure/persistence/elasticsearch/ElasticRepository';
 import { BackofficeCourse } from '../domain/BackofficeCourse';
 import { BackofficeCourseRepository } from '../domain/BackofficeCourseRepository';
-import { Uuid } from '../../Shared/domain/value-object/Uuid';
-import { BackofficeCourseName } from '../domain/BackofficeCourseName';
-import { BackofficeCourseId } from '../domain/BackofficeCourseId';
-import { BackofficeCourseDuration } from '../domain/BackofficeCourseDuration';
 
 type ElasticBackofficeCourseDocument = { _source: { id: string; duration: string; name: string } };
 
@@ -27,27 +23,12 @@ export class ElasticBackofficeCourseRepository
       }
     });
 
-    // console.log(response.body.hits.hits);
-
     return response.body.hits.hits.map((hit: ElasticBackofficeCourseDocument) =>
       BackofficeCourse.fromPrimitives({ ...hit._source })
     );
   }
 
-  async save(course: BackofficeCourse) {
+  async save(course: BackofficeCourse): Promise<void> {
     return this.persist(this.moduleName(), course);
   }
-
-  async delete() {
-    const client = await this.client();
-
-    return client.deleteByQuery({
-      index: this.moduleName(),
-      body: {
-        query: {
-          match_all: {}
-        }
-      }
-    });
-  }
 }

src/Contexts/Shared/infrastructure/persistence/elasticsearch/ElasticRepository.ts

@@ -12,8 +12,8 @@ export abstract class ElasticRepository<T extends AggregateRoot> {
 
   protected async persist(index: string, aggregateRoot: T): Promise<void> {
     const document = { ...aggregateRoot.toPrimitives() };
+    const client = await this.client();
 
-    console.log('persist', document);
-    (await this.client()).index({ index: index, body: document });
+    await client.index({ index: index, body: document, refresh: 'wait_for' }); // wait_for wait for a refresh to make this operation visible to search
   }
 }

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

@@ -1,27 +1,26 @@
-import container from '../../../../src/apps/backoffice/backend/config/dependency-injection';
 import { ElasticBackofficeCourseRepository } from '../../../../src/Contexts/Backoffice/infrastructure/ElasticBackofficeCourseRepository';
 import { ElasticClientFactory } from '../../../../src/Contexts/Shared/infrastructure/persistence/elasticsearch/ElasticClientFactory';
-import { EnvironmentArranger } from '../../Shared/infrastructure/arranger/EnvironmentArranger';
+import { ElasticEnvironmentArranger } from '../../Shared/infrastructure/elastic/ElasticEnvironmentArranger';
 import { BackofficeCourseMother } from '../application/domain/BackofficeCourseMother';
+import { BackofficeCourse } from '../../../../src/Contexts/Backoffice/domain/BackofficeCourse';
 
 const client = ElasticClientFactory.createClient('test');
 const repository: ElasticBackofficeCourseRepository = new ElasticBackofficeCourseRepository(client);
-const environmentArranger: Promise<EnvironmentArranger> = container.get('Backoffice.Backend.EnvironmentArranger');
+const environmentArranger = new ElasticEnvironmentArranger(client);
 
-beforeEach(async () => {
-  await repository.delete();
-});
-
-afterAll(async () => {
-  //   await repository.delete();
+afterEach(async () => {
+  await environmentArranger.arrange();
 });
 
 describe('Search all courses', () => {
   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(async course => repository.save(course)));
+
     const expectedCourses = await repository.searchAll();
+
     expect(courses.length).toEqual(expectedCourses.length);
-    expect(courses.sort()).toEqual(expectedCourses.sort());
+    expect(courses.sort(BackofficeCourse.sort)).toEqual(expectedCourses.sort(BackofficeCourse.sort));
   });
 });

tests/Contexts/Shared/infrastructure/elastic/ElasticEnvironmentArranger.ts

@@ -0,0 +1,25 @@
+import { Client as ElasticClient } from '@elastic/elasticsearch';
+import { EnvironmentArranger } from '../arranger/EnvironmentArranger';
+
+export class ElasticEnvironmentArranger extends EnvironmentArranger {
+  constructor(private _client: Promise<ElasticClient>) {
+    super();
+  }
+
+  public async arrange(): Promise<void> {
+    await this.dropAllIndex();
+  }
+
+  protected async dropAllIndex(): Promise<void> {
+    const client = await this.client();
+    await client.indices.delete({
+      index: '*'
+    });
+  }
+
+  protected client(): Promise<ElasticClient> {
+    return this._client;
+  }
+
+  public async close(): Promise<void> {}
+}