Fixing mark experiment point when experiment point and Id doesn't exist

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

@@ -116,17 +116,13 @@ export class ExperimentAssignmentService {
 
     let enrollmentCode: ENROLLMENT_CODE | null = null;
     const experimentId = getExperimentPartitionID(experimentPoint, experimentName);
-    const { experiment } = experimentPartition;
 
-    const { logging, state } = experiment;
-
-    if (logging || state === EXPERIMENT_STATE.PREVIEW) {
-      this.log.info(
-        `markExperimentPoint: Experiment: ${experiment.id}, Experiment Name: ${experimentName}, Experiment Point: ${experimentPoint} for User: ${userId}`
-      );
-    }
+    this.log.info(
+      `markExperimentPoint: Experiment Name: ${experimentName}, Experiment Point: ${experimentPoint} for User: ${userId}`
+    );
 
     if (experimentPartition) {
+      const { experiment } = experimentPartition;
       const { conditions } = await this.experimentRepository.findOne({
         where: {
           id: experiment.id,
@@ -211,8 +207,9 @@ export class ExperimentAssignmentService {
      * Check the enrollment complete condition for experiments with ending criteria
      * group count and participants count
      */
-    if (experiment.enrollmentCompleteCondition && experiment.state === EXPERIMENT_STATE.ENROLLING) {
-      await this.checkEnrollmentEndingCriteriaForCount(experiment);
+    const experimentDoc = experimentPartition?.experiment;
+    if (experimentDoc && experimentDoc.enrollmentCompleteCondition && experimentDoc.state === EXPERIMENT_STATE.ENROLLING) {
+      await this.checkEnrollmentEndingCriteriaForCount(experimentDoc);
     }
 
     // save monitored log document

backend/packages/Upgrade/test/integration/Experiment/markExperimentPoint/NoExperiment.ts

@@ -0,0 +1,73 @@
+import { individualAssignmentExperiment } from '../../mockData/experiment/index';
+import { Logger as WinstonLogger } from '../../../../src/lib/logger';
+import { ExperimentService } from '../../../../src/api/services/ExperimentService';
+import { Container } from 'typedi';
+import { UserService } from '../../../../src/api/services/UserService';
+import { systemUser } from '../../mockData/user';
+import { experimentUsers } from '../../mockData/experimentUsers';
+import { EXPERIMENT_STATE } from 'upgrade_types';
+import {
+  getAllExperimentCondition,
+  markExperimentPoint,
+  checkMarkExperimentPointForUser,
+  checkExperimentAssignedIsNull,
+} from '../../utils';
+
+export default async function NoExperiment(): Promise<void> {
+  // const logger = new WinstonLogger(__filename);
+  const experimentService = Container.get<ExperimentService>(ExperimentService);
+  // experiment object
+  const experimentObject = individualAssignmentExperiment;
+  const userService = Container.get<UserService>(UserService);
+
+  // creating new user
+  const user = await userService.create(systemUser as any);
+
+  const experimentName = experimentObject.partitions[0].expId;
+  const experimentPoint = experimentObject.partitions[0].expPoint;
+  const condition = experimentObject.conditions[0].conditionCode;
+
+  let markedExperimentPoint = await markExperimentPoint(
+    experimentUsers[0].id,
+    experimentName,
+    experimentPoint,
+    condition
+  );
+  checkMarkExperimentPointForUser(markedExperimentPoint, experimentUsers[0].id, experimentName, experimentPoint);
+
+  // create experiment
+  await experimentService.create(experimentObject as any, user);
+  let experiments = await experimentService.find();
+  expect(experiments).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({
+        name: experimentObject.name,
+        state: experimentObject.state,
+        postExperimentRule: experimentObject.postExperimentRule,
+        assignmentUnit: experimentObject.assignmentUnit,
+        consistencyRule: experimentObject.consistencyRule,
+      }),
+    ])
+  );
+
+  const experimentId = experiments[0].id;
+  await experimentService.updateState(experimentId, EXPERIMENT_STATE.ENROLLING, user);
+
+  // fetch experiment
+  experiments = await experimentService.find();
+  expect(experiments).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({
+        name: experimentObject.name,
+        state: EXPERIMENT_STATE.ENROLLING,
+        postExperimentRule: experimentObject.postExperimentRule,
+        assignmentUnit: experimentObject.assignmentUnit,
+        consistencyRule: experimentObject.consistencyRule,
+      }),
+    ])
+  );
+
+  // get all experiment condition for user 2
+  let experimentConditionAssignments = await getAllExperimentCondition(experimentUsers[0].id);
+  checkExperimentAssignedIsNull(experimentConditionAssignments, experimentName, experimentPoint);
+}

backend/packages/Upgrade/test/integration/Experiment/markExperimentPoint/index.ts

@@ -0,0 +1,44 @@
+import { Container } from 'typedi';
+import { experimentUsers } from '../../mockData/experimentUsers/index';
+import { ExperimentUserService } from '../../../../src/api/services/ExperimentUserService';
+import { CheckService } from '../../../../src/api/services/CheckService';
+import TestCase1 from './NoExperiment';
+
+const initialChecks = async () => {
+  const userService = Container.get<ExperimentUserService>(ExperimentUserService);
+  const checkService = Container.get<CheckService>(CheckService);
+
+  // check all the tables are empty
+  const users = await userService.find();
+  expect(users.length).toEqual(0);
+
+  const monitoredPoints = await checkService.getAllMarkedExperimentPoints();
+  expect(monitoredPoints.length).toEqual(0);
+
+  const groupAssignments = await checkService.getAllGroupAssignments();
+  expect(groupAssignments.length).toEqual(0);
+
+  const groupExclusions = await checkService.getAllGroupExclusions();
+  expect(groupExclusions.length).toEqual(0);
+
+  const individualAssignments = await checkService.getAllIndividualAssignment();
+  expect(individualAssignments.length).toEqual(0);
+
+  const individualExclusions = await checkService.getAllIndividualExclusion();
+  expect(individualExclusions.length).toEqual(0);
+
+  // create users over here
+  await userService.create(experimentUsers as any);
+
+  // get all user here
+  const userList = await userService.find();
+  expect(userList.length).toBe(experimentUsers.length);
+  experimentUsers.map(user => {
+    expect(userList).toContainEqual(user);
+  });
+};
+
+export const NoExperiment = async () => {
+  await initialChecks();
+  await TestCase1();
+};

backend/packages/Upgrade/test/integration/index.test.ts

@@ -34,6 +34,7 @@ import {
 import { MainAuditLog } from './Experiment/auditLogs';
 import { NoPartitionPoint } from './Experiment/onlyExperimentPoint';
 // import { StatsGroupExperiment } from './ExperimentStats';
+import { NoExperiment } from './Experiment/markExperimentPoint';
 import {
   NoPreviewUser,
   PreviewAssignments,
@@ -95,6 +96,11 @@ describe('Integration Tests', () => {
   // Test cases
   // -------------------------------------------------------------------------
 
+  test('Mark Experiment before experiment is created', async (done) => {
+    await NoExperiment();
+    done();
+  });
+
   test('No Group for Experiment', async (done) => {
     await NoGroup();
     done();