feat(api): do not return not yet answered challenge if challenge became not playable in the mean time

Author: laura-bergoens

Diff for: api/src/shared/domain/models/Challenge.js

@@ -20,6 +20,12 @@ const Accessibility = Object.freeze({
   OK: 'OK',
 });
 
+const Statuses = Object.freeze({
+  VALIDATED: 'validé',
+  ARCHIVED: 'archivé',
+  OBSOLETE: 'périmé',
+});
+
 /**
  * Traduction: Épreuve
  */
@@ -163,6 +169,10 @@ class Challenge {
     return this._isCompliant('Tablet');
   }
 
+  get isOperative() {
+    return [Statuses.VALIDATED, Statuses.ARCHIVED].includes(this.status);
+  }
+
   get isAccessible() {
     return (
       (this.blindnessCompatibility === Accessibility.OK || this.blindnessCompatibility === Accessibility.RAS) &&
@@ -208,4 +218,4 @@ class Challenge {
 
 Challenge.Type = ChallengeType;
 
-export { Accessibility, Challenge, ChallengeType as Type };
+export { Accessibility, Challenge, Statuses, ChallengeType as Type };

Diff for: api/src/shared/domain/usecases/get-next-challenge.js

@@ -23,7 +23,12 @@ export async function getNextChallenge({
     lastChallengeId: assessment.lastChallengeId,
   });
   if (!hasAnswered) {
-    return challengeRepository.get(assessment.lastChallengeId);
+    nextChallenge = await challengeRepository.get(assessment.lastChallengeId);
+    if (nextChallenge.isOperative) {
+      return nextChallenge;
+    } else {
+      nextChallenge = null;
+    }
   }
   if (assessment.isCertification()) {
     nextChallenge = await certificationEvaluationRepository.selectNextCertificationChallenge({

Diff for: api/tests/shared/unit/domain/usecases/get-next-challenge_test.js

@@ -1,4 +1,5 @@
 import { AssessmentEndedError } from '../../../../../src/shared/domain/errors.js';
+import { Statuses } from '../../../../../src/shared/domain/models/Challenge.js';
 import { Assessment } from '../../../../../src/shared/domain/models/index.js';
 import { getNextChallenge } from '../../../../../src/shared/domain/usecases/get-next-challenge.js';
 import { catchErr, domainBuilder, expect, preventStubsToBeCalledUnexpectedly, sinon } from '../../../../test-helper.js';
@@ -157,27 +158,56 @@ describe('Shared | Unit | Domain | Use Cases | get-next-challenge', function ()
       });
 
       context('when the latest challenge asked has not been answered yet', function () {
-        it('should return latest challenge', async function () {
-          const assessment = domainBuilder.buildAssessment({
-            state: Assessment.states.STARTED,
-            type: Assessment.types.PREVIEW,
-            lastChallengeId: 'previousChallengeId',
+        context('when challenge is operative', function () {
+          it('should return latest challenge', async function () {
+            const assessment = domainBuilder.buildAssessment({
+              state: Assessment.states.STARTED,
+              type: Assessment.types.PREVIEW,
+              lastChallengeId: 'previousChallengeId',
+            });
+            assessmentRepository_getStub.withArgs(assessmentId).resolves(assessment);
+            assessmentRepository_updateLastQuestionDateStub.resolves();
+            assessmentRepository_updateWhenNewChallengeIsAskedStub.resolves();
+            const previousChallenge = domainBuilder.buildChallenge({
+              id: 'previousChallengeId',
+              status: Statuses.VALIDATED,
+            });
+            answerRepository_findByAssessmentStub
+              .withArgs(assessment.id)
+              .resolves([
+                domainBuilder.buildAnswer({ challengeId: 'someChallengeId' }),
+                domainBuilder.buildAnswer({ challengeId: 'someOtherChallengeId' }),
+              ]);
+            challengeRepository_getStub.withArgs('previousChallengeId').resolves(previousChallenge);
+
+            const actualNextChallenge = await getNextChallenge(dependencies);
+
+            expect(actualNextChallenge).to.deepEqualInstance(previousChallenge);
           });
-          assessmentRepository_getStub.withArgs(assessmentId).resolves(assessment);
-          assessmentRepository_updateLastQuestionDateStub.resolves();
-          assessmentRepository_updateWhenNewChallengeIsAskedStub.resolves();
-          const previousChallenge = domainBuilder.buildChallenge({ id: 'previousChallengeId' });
-          answerRepository_findByAssessmentStub
-            .withArgs(assessment.id)
-            .resolves([
-              domainBuilder.buildAnswer({ challengeId: 'someChallengeId' }),
-              domainBuilder.buildAnswer({ challengeId: 'someOtherChallengeId' }),
-            ]);
-          challengeRepository_getStub.withArgs('previousChallengeId').resolves(previousChallenge);
+        });
+        context('when challenge is not operative', function () {
+          it('should compute next challenge', async function () {
+            const assessment = domainBuilder.buildAssessment({
+              state: Assessment.states.STARTED,
+              type: Assessment.types.PREVIEW,
+              lastChallengeId: 'previousChallengeId',
+            });
+            assessmentRepository_getStub.withArgs(assessmentId).resolves(assessment);
+            assessmentRepository_updateLastQuestionDateStub.resolves();
+            assessmentRepository_updateWhenNewChallengeIsAskedStub.resolves();
+            const challenge = domainBuilder.buildChallenge({ id: 'nextChallengeForPreview' });
+            const previousChallenge = domainBuilder.buildChallenge({
+              id: 'previousChallengeId',
+              status: Statuses.OBSOLETE,
+            });
+            evaluationUsecases_getNextChallengeForPreviewStub.withArgs({}).resolves(challenge);
+            answerRepository_findByAssessmentStub.withArgs(assessment.id).resolves([]);
+            challengeRepository_getStub.withArgs('previousChallengeId').resolves(previousChallenge);
 
-          const actualNextChallenge = await getNextChallenge(dependencies);
+            const actualNextChallenge = await getNextChallenge(dependencies);
 
-          expect(actualNextChallenge).to.deepEqualInstance(previousChallenge);
+            expect(actualNextChallenge).to.deepEqualInstance(challenge);
+          });
         });
       });
     });

Diff for: api/tests/unit/domain/models/Challenge_test.js

@@ -4,7 +4,7 @@ import { ValidatorQCU } from '../../../../src/evaluation/domain/models/Validator
 import { ValidatorQROC } from '../../../../src/evaluation/domain/models/ValidatorQROC.js';
 import { ValidatorQROCMDep } from '../../../../src/evaluation/domain/models/ValidatorQROCMDep.js';
 import { ValidatorQROCMInd } from '../../../../src/evaluation/domain/models/ValidatorQROCMInd.js';
-import { Accessibility, Challenge } from '../../../../src/shared/domain/models/Challenge.js';
+import { Accessibility, Challenge, Statuses } from '../../../../src/shared/domain/models/Challenge.js';
 import { Skill } from '../../../../src/shared/domain/models/Skill.js';
 import { domainBuilder, expect } from '../../../test-helper.js';
 
@@ -366,4 +366,39 @@ describe('Unit | Domain | Models | Challenge', function () {
       );
     });
   });
+
+  describe('#isOperative', function () {
+    it('should return true when challenge is validated', function () {
+      // given
+      const challenge = domainBuilder.buildChallenge({ status: Statuses.VALIDATED });
+
+      // when
+      const isOperative = challenge.isOperative;
+
+      // then
+      expect(isOperative).to.be.true;
+    });
+
+    it('should return true when challenge is archived', function () {
+      // given
+      const challenge = domainBuilder.buildChallenge({ status: Statuses.ARCHIVED });
+
+      // when
+      const isOperative = challenge.isOperative;
+
+      // then
+      expect(isOperative).to.be.true;
+    });
+
+    it('should return false when challenge is obsolete', function () {
+      // given
+      const challenge = domainBuilder.buildChallenge({ status: Statuses.OBSOLETE });
+
+      // when
+      const isOperative = challenge.isOperative;
+
+      // then
+      expect(isOperative).to.be.false;
+    });
+  });
 });