TGD-30: FeatureFlags add tests

src/Consts/FeatureFlags.consts.ts

@@ -0,0 +1,3 @@
+export class FeatureFlagsConsts {
+  static EnableEndgamePoints = 'EnableEndgamePoints';
+}

src/featureflag/featureflag.controller.spec.ts

@@ -1,18 +1,49 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { FeatureflagController } from './featureflag.controller';
+import {FeatureflagService} from "./featureflag.service";
+import {FeatureflagServiceMock} from "../mocks/featureflag-service.mock";
 
 describe('FeatureflagController', () => {
   let controller: FeatureflagController;
+  let featureflagService: FeatureflagService;
 
   beforeEach(async () => {
+    jest.resetAllMocks();
     const module: TestingModule = await Test.createTestingModule({
       controllers: [FeatureflagController],
+      providers: [
+        { provide: FeatureflagService, useValue: FeatureflagServiceMock },
+      ]
     }).compile();
-
     controller = module.get<FeatureflagController>(FeatureflagController);
+    featureflagService = module.get<FeatureflagService>(FeatureflagService);
   });
 
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  it('should call feature flag service to get state', async() => {
+    const ffNameToTest = "TestFeature";
+    const getFFMock = jest.spyOn(featureflagService, 'getFeatureFlag')
+      .mockImplementation(
+        (name) =>  Promise.resolve({ name: name, state: true})
+      );
+
+    await controller.getFeatureFlag({ ffname: ffNameToTest });
+
+    expect(getFFMock).toHaveBeenCalled();
+    expect(getFFMock).toHaveBeenCalledWith(ffNameToTest);
+  });
+
+  it('should call feature flag service to set state', async () => {
+    const ffNameToTest = "TestFeature";
+    const setFFMock = jest.spyOn(featureflagService, 'setFeatureFlag')
+      .mockImplementation((id, status) => Promise.resolve({ name: id, state: false}));
+
+    await controller.setFeatureFlag({ name: ffNameToTest, state: true });
+
+    expect(setFFMock).toHaveBeenCalled();
+    expect(setFFMock).toHaveBeenCalledWith(ffNameToTest, true);
+  });
 });

src/featureflag/featureflag.controller.ts

@@ -11,8 +11,8 @@ export class FeatureflagController {
     return await this.featureflagService.getFeatureFlag(params.ffname);
   }
 
-  @Post(':ffname')
+  @Post()
-  async setFeatureFlag(@Param() params: { ffname: string}, @Body() ffState: { name: string, state: boolean }) {
+  async setFeatureFlag(@Body() ffState: { name: string, state: boolean }) {
-    return await this.featureflagService.setFeatureFlag(params.ffname, ffState.state );
+    return await this.featureflagService.setFeatureFlag(ffState.name, ffState.state );
   }
 }

src/featureflag/featureflag.service.ts

@@ -24,8 +24,6 @@ export class FeatureflagService {
   async setFeatureFlag(id: string, status: boolean) : Promise<IFeatureFlagStatus> {
     this.logger.verbose(`Setting feature flag status for ${id} to ${status} `);
     const result = await this.sharedService.setConfig(`featureflag/${id}`, status.toString());
-    console.log(result.value);
-    console.log(!!result.value);
     return {
       name: id,
       state: result.value !== 'false',

src/scheduler/scheduler.service.ts

@@ -4,6 +4,8 @@ import { StateService } from '../state/state.service';
 import { QuizService } from '../quiz/quiz.service';
 import { GiftsService } from '../gifts/gifts.service';
 import { SharedService } from '../shared/shared.service';
+import {FeatureflagService} from "../featureflag/featureflag.service";
+import {FeatureFlagsConsts} from "../Consts/FeatureFlags.consts";
 
 @Injectable()
 export class SchedulerService {
@@ -16,6 +18,7 @@ export class SchedulerService {
     private giftsService: GiftsService,
     private quizService: QuizService,
     private sharedService: SharedService,
+    private featureFlagService: FeatureflagService,
   ) {}
 
   @Cron('* * * * *')
@@ -31,6 +34,9 @@ export class SchedulerService {
   async gameStatus() {
     const giftsLeft = await this.giftsService.getRemainingPrizeCount();
     if (giftsLeft === 0) {
+      if(await this.featureFlagService.getFeatureFlag(FeatureFlagsConsts.EnableEndgamePoints)) {
+        this.logger.verbose(`Feature flag ${FeatureFlagsConsts.EnableEndgamePoints} is enabled`);
+      }
       const state = await this.stateService.setState('main', 'finish');
       this.sharedService.sendSocketNotificationToAllClients(
         'state_changed',