add tests

Author: danoswaltCL

backend/packages/Upgrade/src/api/controllers/ExperimentController.ts

@@ -1948,6 +1948,6 @@ export class ExperimentController {
     if (!env.mooclets?.enabled) {
       throw new BadRequestError('Mooclet is not enabled in the environment');
     }
-    return this.moocletRewardService.getRewardsSummaryForExperiment(id, request);
+    return this.moocletRewardService.getRewardsSummaryForExperiment(id, request.logger);
   }
 }

backend/packages/Upgrade/src/api/services/MoocletRewardsService.ts

@@ -17,7 +17,6 @@ import {
 } from '../../types/Mooclet';
 import { RewardValidator } from '../controllers/validators/RewardValidator';
 import { ExperimentRewardsByCondition, ExperimentRewardsSummary } from 'upgrade_types';
-import { AppRequest } from 'src/types';
 import { MoocletExperimentService } from './MoocletExperimentService';
 
 export interface IRewardResponse {
@@ -215,16 +214,16 @@ export class MoocletRewardsService {
 
   public async getRewardsSummaryForExperiment(
     experimentId: string,
-    request: AppRequest
+    logger: UpgradeLogger
   ): Promise<ExperimentRewardsSummary> {
     try {
       const moocletExperimentRef = await this.moocletExperimentService.getMoocletExperimentRefByUpgradeExperimentId(
         experimentId
       );
-      const moocletRewardsResponse = await this.fetchRewardsForExperiment(moocletExperimentRef, request.logger);
-      return this.createExperimentRewardsSummary(moocletExperimentRef, moocletRewardsResponse, request.logger);
+      const moocletRewardsResponse = await this.fetchRewardsForExperiment(moocletExperimentRef, logger);
+      return this.createExperimentRewardsSummary(moocletExperimentRef, moocletRewardsResponse, logger);
     } catch (error) {
-      request.logger.error({ message: 'Error fetching rewards summary for experiment', experimentId, error });
+      logger.error({ message: 'Error fetching rewards summary for experiment', experimentId, error });
       throw error;
     }
   }

backend/packages/Upgrade/test/unit/controllers/ExperimentController.test.ts

@@ -11,6 +11,8 @@ import { ExperimentAssignmentService } from '../../../src/api/services/Experimen
 import ExperimentAssignmentServiceMock from './mocks/ExperimentAssignmentServiceMock';
 import { MoocletExperimentService } from '../../../src/api/services/MoocletExperimentService';
 import MoocletExperimentServiceMock from './mocks/MoocletExperimentServiceMock';
+import { MoocletRewardsService } from '../../../src/api/services/MoocletRewardsService';
+import MoocletRewardsServiceMock from './mocks/MoocletRewardsServiceMock';
 import { ImportExportService } from '../../../src/api/services/ImportExportService';
 import ImportExportServiceMock from './mocks/ImportExportServiceMock';
 import { env } from './../../../src/env';
@@ -37,6 +39,7 @@ describe('Experiment Controller Testing', () => {
     Container.set(ExperimentService, new ExperimentServiceMock());
     Container.set(ExperimentAssignmentService, new ExperimentAssignmentServiceMock());
     Container.set(MoocletExperimentService, new MoocletExperimentServiceMock());
+    Container.set(MoocletRewardsService, new MoocletRewardsServiceMock());
     Container.set(ImportExportService, new ImportExportServiceMock());
   });
 

backend/packages/Upgrade/test/unit/controllers/mocks/MoocletRewardsServiceMock.ts

@@ -0,0 +1,25 @@
+import { Service } from 'typedi';
+
+@Service()
+export default class MoocletRewardsServiceMock {
+  public async getRewardsSummaryForExperiment(experimentId: string, logger: any): Promise<any> {
+    return [
+      {
+        conditionCode: 'Control',
+        successes: 10,
+        failures: 5,
+        total: 15,
+        successRate: '66.7%',
+        order: 0,
+      },
+      {
+        conditionCode: 'Treatment',
+        successes: 8,
+        failures: 7,
+        total: 15,
+        successRate: '53.3%',
+        order: 1,
+      },
+    ];
+  }
+}

backend/packages/Upgrade/test/unit/services/MoocletDataService.test.ts

@@ -459,4 +459,109 @@ describe('#MoocletDataService', () => {
       );
     });
   });
+
+  describe('#getRewardsForExperiment', () => {
+    it('should successfully fetch rewards for an experiment', async () => {
+      const requestBody = {
+        moocletId: 456,
+        variableName: 'outcome_var',
+      };
+
+      const mockResponse = {
+        count: 5,
+        next: null,
+        previous: null,
+        results: [
+          { id: '1', version: 100, value: 1.0, variable: 'outcome_var', learner: 'user-1', mooclet: 456 },
+          { id: '2', version: 100, value: 0.0, variable: 'outcome_var', learner: 'user-2', mooclet: 456 },
+          { id: '3', version: 200, value: 1.0, variable: 'outcome_var', learner: 'user-3', mooclet: 456 },
+        ],
+      };
+
+      jest.spyOn(moocletDataService, 'fetchExternalMoocletsData').mockResolvedValue(mockResponse);
+
+      const result = await moocletDataService.getRewardsForExperiment(requestBody, logger);
+
+      expect(result).toEqual(mockResponse);
+      expect(moocletDataService.fetchExternalMoocletsData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'GET',
+          url: expect.stringContaining('/value?mooclet=456&variable__name=outcome_var'),
+        }),
+        logger
+      );
+    });
+
+    it('should construct correct query parameters with moocletId and variableName', async () => {
+      const requestBody = {
+        moocletId: 789,
+        variableName: 'test_variable',
+      };
+
+      const mockResponse = {
+        count: 0,
+        next: null,
+        previous: null,
+        results: [],
+      };
+
+      jest.spyOn(moocletDataService, 'fetchExternalMoocletsData').mockResolvedValue(mockResponse);
+
+      await moocletDataService.getRewardsForExperiment(requestBody, logger);
+
+      expect(moocletDataService.fetchExternalMoocletsData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'GET',
+          url: expect.stringContaining('mooclet=789'),
+        }),
+        logger
+      );
+      expect(moocletDataService.fetchExternalMoocletsData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'GET',
+          url: expect.stringContaining('variable__name=test_variable'),
+        }),
+        logger
+      );
+    });
+
+    it('should handle paginated responses with next page', async () => {
+      const requestBody = {
+        moocletId: 456,
+        variableName: 'outcome_var',
+      };
+
+      const mockResponse = {
+        count: 100,
+        next: 'http://api.mooclet.com/next-page',
+        previous: null,
+        results: [{ id: '1', version: 100, value: 1.0 }],
+      };
+
+      jest.spyOn(moocletDataService, 'fetchExternalMoocletsData').mockResolvedValue(mockResponse);
+
+      const result = await moocletDataService.getRewardsForExperiment(requestBody, logger);
+
+      expect(result.next).toBe('http://api.mooclet.com/next-page');
+      expect(result.count).toBe(100);
+    });
+
+    it('should throw error when fetchExternalMoocletsData fails', async () => {
+      const requestBody = {
+        moocletId: 456,
+        variableName: 'outcome_var',
+      };
+
+      const mockError = new Error('API connection failed');
+      jest.spyOn(moocletDataService, 'fetchExternalMoocletsData').mockRejectedValue(mockError);
+
+      await expect(moocletDataService.getRewardsForExperiment(requestBody, logger)).rejects.toThrow(
+        'API connection failed'
+      );
+    });
+
+    afterAll(() => {
+      jest.restoreAllMocks();
+    });
+  });
 });