wip: experiment resolver test

api/src/experiments/experiments.resolver.spec.ts

 import { Test, TestingModule } from '@nestjs/testing';
+import { User } from 'src/users/models/user.model';
 import { ENGINE_SERVICE } from '../engine/engine.constants';
 import { IEngineService } from '../engine/engine.interfaces';
 import { ExperimentsResolver } from './experiments.resolver';
 import { ExperimentsService } from './experiments.service';
+import { ExperimentCreateInput } from './models/input/experiment-create.input';
+import { ExperimentEditInput } from './models/input/experiment-edit.input';
 
-const createEngineService = (): IEngineService => ({
+type MockEngineService = Partial<Record<keyof IEngineService, jest.Mock>>;
+type MockExperimentService = Partial<
+  Record<keyof ExperimentsService, jest.Mock>
+>;
+
+const createEngineService = (): MockEngineService => ({
   getDomains: jest.fn(),
   getAlgorithms: jest.fn(),
   createExperiment: jest.fn(),
+  runExperiment: jest.fn(),
   getExperiment: jest.fn(),
-  editExperient: jest.fn(),
+  editExperiment: jest.fn(),
   listExperiments: jest.fn(),
+  removeExperiment: jest.fn(),
 });
 
-const createExperimentsService = () => ({
+const createExperimentsService = (): MockExperimentService => ({
   findAll: jest.fn(),
   findOne: jest.fn(),
   dataToExperiment: jest.fn(),
@@ -24,8 +34,8 @@ const createExperimentsService = () => ({
 
 describe('ExperimentsResolver', () => {
   let resolver: ExperimentsResolver;
-  let engineService: IEngineService;
-  let experimentsService: ExperimentsService;
+  let engineService: MockEngineService;
+  let experimentsService: MockExperimentService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -39,8 +49,10 @@ describe('ExperimentsResolver', () => {
       ],
     }).compile();
 
-    engineService = module.get<IEngineService>(ENGINE_SERVICE);
-    experimentsService = module.get<ExperimentsService>(ExperimentsService);
+    engineService = module.get<MockEngineService>(ENGINE_SERVICE);
+    experimentsService = module.get<ExperimentsService>(
+      ExperimentsService,
+    ) as unknown as MockExperimentService;
     resolver = module.get<ExperimentsResolver>(ExperimentsResolver);
   });
 
@@ -52,9 +64,177 @@ describe('ExperimentsResolver', () => {
     describe('when engine method exist', () => {
       it('should call engine method', async () => {
         const request: any = jest.fn();
+        engineService.listExperiments.mockReturnValue({});
+        await resolver.experimentList(0, '', request);
+
+        expect(engineService.listExperiments.mock.calls.length).toBeGreaterThan(
+          0,
+        );
+      });
+    });
+
+    describe('when engine method does not exist', () => {
+      it('should call service method', async () => {
+        const request: any = jest.fn();
+        engineService.listExperiments = undefined;
+        experimentsService.findAll.mockReturnValue([[], 9]);
         await resolver.experimentList(0, '', request);
 
-        expect(request).toBeDefined();
+        expect(experimentsService.findAll.mock.calls.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe('experiment', () => {
+    describe('when engine method exist', () => {
+      it('should call engine method', async () => {
+        const request: any = jest.fn();
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        await resolver.experiment('test', request, user);
+
+        expect(experimentsService.findOne.mock.calls.length).toBe(0);
+        expect(engineService.getExperiment.mock.calls.length).toBeGreaterThan(
+          0,
+        );
+      });
+    });
+
+    describe('when engine method does not exist', () => {
+      it('should call service method', async () => {
+        const request: any = jest.fn();
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        engineService.getExperiment = undefined;
+        await resolver.experiment('test', request, user);
+
+        expect(experimentsService.findOne.mock.calls.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe('createExperiment', () => {
+    describe('when engine method exist', () => {
+      it('should call engine method', async () => {
+        const request: any = jest.fn();
+        const data: ExperimentCreateInput =
+          {} as unknown as ExperimentCreateInput;
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        await resolver.createExperiment(request, user, data, true);
+
+        expect(experimentsService.create.mock.calls.length).toBe(0);
+        expect(
+          engineService.createExperiment.mock.calls.length,
+        ).toBeGreaterThan(0);
+      });
+    });
+
+    describe('when engine method does not exist', () => {
+      it('should call service method', async () => {
+        const request: any = jest.fn();
+        const data: ExperimentCreateInput =
+          {} as unknown as ExperimentCreateInput;
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        engineService.createExperiment = undefined;
+        engineService.runExperiment.mockResolvedValue([]);
+        experimentsService.create.mockReturnValue({ id: 'test' });
+        await resolver.createExperiment(request, user, data, false);
+
+        expect(experimentsService.create.mock.calls.length).toBeGreaterThan(0);
+      });
+
+      it('should only call runExperiment if transient', async () => {
+        const request: any = jest.fn();
+        const data: ExperimentCreateInput =
+          {} as unknown as ExperimentCreateInput;
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        engineService.createExperiment = undefined;
+        engineService.runExperiment.mockResolvedValue([]);
+        experimentsService.create.mockReturnValue({ id: 'test' });
+        await resolver.createExperiment(request, user, data, true);
+
+        expect(engineService.runExperiment.mock.calls.length).toBeGreaterThan(
+          0,
+        );
+      });
+    });
+  });
+
+  describe('editExperiment', () => {
+    describe('when engine method exist', () => {
+      it('should call engine method', async () => {
+        const request: any = jest.fn();
+        const data: ExperimentEditInput = {} as unknown as ExperimentEditInput;
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        await resolver.editExperiment(request, 'test', data, user);
+
+        expect(experimentsService.update.mock.calls.length).toBe(0);
+        expect(engineService.editExperiment.mock.calls.length).toBeGreaterThan(
+          0,
+        );
+      });
+    });
+
+    describe('when engine method does not exist', () => {
+      it('should call service method', async () => {
+        const request: any = jest.fn();
+        const data: ExperimentEditInput = {} as unknown as ExperimentEditInput;
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        engineService.editExperiment = undefined;
+        await resolver.editExperiment(request, 'test', data, user);
+
+        expect(experimentsService.update.mock.calls.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe('removeExperiment', () => {
+    describe('when engine method exist', () => {
+      it('should call engine method', async () => {
+        const request: any = jest.fn();
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        await resolver.removeExperiment('test', request, user);
+
+        expect(experimentsService.remove.mock.calls.length).toBe(0);
+        expect(
+          engineService.removeExperiment.mock.calls.length,
+        ).toBeGreaterThan(0);
+      });
+    });
+
+    describe('when engine method does not exist', () => {
+      it('should call service method', async () => {
+        const request: any = jest.fn();
+        const user: User = {
+          id: 'dummyUser',
+          username: 'test',
+        };
+        engineService.removeExperiment = undefined;
+        await resolver.removeExperiment('test', request, user);
+
+        expect(experimentsService.remove.mock.calls.length).toBeGreaterThan(0);
       });
     });
   });

api/src/experiments/experiments.resolver.ts

@@ -35,8 +35,9 @@ export class ExperimentsResolver {
     @Args('name', { nullable: true, defaultValue: '' }) name: string,
     @GQLRequest() req: Request,
   ): Promise<ListExperiments> {
-    if (this.engineService.listExperiments)
+    if (this.engineService.listExperiments) {
       return this.engineService.listExperiments(page, name, req);
+    }
 
     const [results, total] = await this.experimentService.findAll(
       {
@@ -77,18 +78,21 @@ export class ExperimentsResolver {
       return this.engineService.createExperiment(data, isTransient, req);
     }
 
+    //if the experiment is transient we wait a response before returning a response
     if (isTransient) {
       const results = await this.engineService.runExperiment(data, req);
       const expTransient = this.experimentService.dataToExperiment(data, user);
       return { ...expTransient, results, status: ExperimentStatus.SUCCESS };
     }
 
+    //if not we will create an experiment in local db
     const experiment = await this.experimentService.create(
       data,
       user,
       ExperimentStatus.PENDING,
     );
 
+    //create an async query that will update the result when it's done
     this.engineService.runExperiment(data, req).then((results) => {
       this.experimentService.update(
         experiment.id,
@@ -101,6 +105,7 @@ export class ExperimentsResolver {
       );
     });
 
+    //we return the experiment before finishing the runExperiment
     return experiment;
   }
 
@@ -111,8 +116,9 @@ export class ExperimentsResolver {
     @Args('data') experiment: ExperimentEditInput,
     @CurrentUser() user: User,
   ) {
-    if (this.engineService.editExperient)
-      return this.engineService.editExperient(id, experiment, req);
+    console.log(this.engineService.editExperiment);
+    if (this.engineService.editExperiment)
+      return this.engineService.editExperiment(id, experiment, req);
 
     return this.experimentService.update(id, experiment, user);
   }