@pie-element/image-cloze-association 3.5.0 → 3.5.1-beta.587

package/controller/src/__tests__/index.test.js

@@ -1,10 +1,4 @@
-import {
-  model,
-  outcome,
-  getPartialScore,
-  isResponseCorrect,
-  createCorrectResponseSession,
-} from '../index';
+import { model, outcome, getPartialScore, isResponseCorrect, createCorrectResponseSession } from '../index';
 
 jest.mock('../utils', () => ({
   ...jest.requireActual('../utils.js'),
@@ -45,8 +39,12 @@ describe('controller', () => {
         valid_response: {
           score: 1,
           value: [
-            [rhomb, square],
-            [rhomb, square, trapeze],
+            {
+              images: [rhomb, square],
+            },
+            {
+              images: [rhomb, square, trapeze],
+            },
           ],
         },
       },
@@ -61,11 +59,7 @@ describe('controller', () => {
   describe('outcome partialScoring test', () => {
     const assertOutcome = (message, extra, sessionValue, env, expected) => {
       it(message, async () => {
-        const result = await outcome(
-          { ...question, ...extra },
-          sessionValue,
-          env
-        );
+        const result = await outcome({ ...question, ...extra }, sessionValue, env);
 
         expect(result).toEqual(expect.objectContaining(expected));
       });
@@ -84,7 +78,7 @@ describe('controller', () => {
         ],
       },
       { mode: 'evaluate' },
-      { score: 0.2 }
+      { score: 0.2 },
     );
 
     assertOutcome(
@@ -100,7 +94,7 @@ describe('controller', () => {
         ],
       },
       { mode: 'evaluate' },
-      { score: 0 }
+      { score: 0 },
     );
 
     assertOutcome(
@@ -116,7 +110,7 @@ describe('controller', () => {
         ],
       },
       { mode: 'evaluate', partialScoring: true },
-      { score: 0 }
+      { score: 0 },
     );
 
     assertOutcome(
@@ -132,15 +126,13 @@ describe('controller', () => {
         ],
       },
       { mode: 'evaluate', partialScoring: false },
-      { score: 0 }
+      { score: 0 },
     );
   });
 
   describe('outcome', () => {
     const returnOutcome = (session) => {
-      it(`returns score of 0 and empty: true if session is ${JSON.stringify(
-        session
-      )}`, async () => {
+      it(`returns score of 0 and empty: true if session is ${JSON.stringify(session)}`, async () => {
         const result = await outcome(question, session);
         expect(result).toEqual({ score: 0, empty: true });
       });
@@ -170,6 +162,76 @@ describe('controller', () => {
       expect(result.score).toEqual(1);
     });
 
+    describe('returns score 0 for wrong validation format', () => {
+      it('returns 0 for old value format', async () => {
+        const result = await outcome(
+          {
+            ...question,
+            validation: {
+              valid_response: {
+                score: 1,
+                value: [
+                  [rhomb, square],
+                  [trapeze, hexagon],
+                ],
+              },
+            },
+          },
+          {
+            answers: [
+              { value: rhomb, containerIndex: 0 },
+              { value: square, containerIndex: 0 },
+              { value: trapeze, containerIndex: 1 },
+              { value: hexagon, containerIndex: 1 },
+            ],
+          },
+        );
+        expect(result.score).toEqual(0);
+      });
+
+      it('returns 0 for when images is null ', async () => {
+        const result = await outcome(
+          {
+            ...question,
+            validation: {
+              valid_response: {
+                score: 1,
+                value: [{ images: null }],
+              },
+            },
+          },
+          {
+            answers: [
+              { value: rhomb, containerIndex: 0 },
+              { value: hexagon, containerIndex: 1 },
+            ],
+          },
+        );
+        expect(result.score).toEqual(0);
+      });
+
+      it('returns 0 for when value is [{}]', async () => {
+        const result = await outcome(
+          {
+            ...question,
+            validation: {
+              valid_response: {
+                score: 1,
+                value: [{}],
+              },
+            },
+          },
+          {
+            answers: [
+              { value: rhomb, containerIndex: 0 },
+              { value: hexagon, containerIndex: 1 },
+            ],
+          },
+        );
+        expect(result.score).toEqual(0);
+      });
+    });
+
     describe('alternate correct answers', () => {
       describe('handles one option', async () => {
         it('returns score of 1', async () => {
@@ -181,7 +243,7 @@ describe('controller', () => {
                 alt_responses: [
                   {
                     score: 1,
-                    value: [[rhomb], [square], [trapeze], [hexagon]],
+                    value: [{ images: [rhomb] }, { images: [square] }, { images: [trapeze] }, { images: [hexagon] }],
                   },
                 ],
               },
@@ -193,7 +255,7 @@ describe('controller', () => {
                 { value: trapeze, containerIndex: 2 },
                 { value: hexagon, containerIndex: 3 },
               ],
-            }
+            },
           );
           expect(result.score).toEqual(1);
         });
@@ -207,7 +269,7 @@ describe('controller', () => {
                 alt_responses: [
                   {
                     score: 1,
-                    value: [[rhomb], [square], [trapeze], [hexagon]],
+                    value: [{ images: [rhomb] }, { images: [square] }, { images: [trapeze] }, { images: [hexagon] }],
                   },
                 ],
               },
@@ -219,7 +281,7 @@ describe('controller', () => {
                 { value: trapeze, containerIndex: 2 },
                 { value: hexagon, containerIndex: 0 },
               ],
-            }
+            },
           );
           expect(result.score).toEqual(0);
         });
@@ -235,11 +297,11 @@ describe('controller', () => {
                 alt_responses: [
                   {
                     score: 1,
-                    value: [[square], [rhomb], [hexagon], [trapeze]],
+                    value: [{ images: [square] }, { images: [rhomb] }, { images: [trapeze] }, { images: [hexagon] }],
                   },
                   {
                     score: 1,
-                    value: [[rhomb], [square], [trapeze], [hexagon]],
+                    value: [{ images: [rhomb] }, { images: [square] }, { images: [trapeze] }, { images: [hexagon] }],
                   },
                 ],
               },
@@ -251,7 +313,7 @@ describe('controller', () => {
                 { value: trapeze, containerIndex: 2 },
                 { value: hexagon, containerIndex: 3 },
               ],
-            }
+            },
           );
           expect(result.score).toEqual(1);
         });
@@ -265,11 +327,11 @@ describe('controller', () => {
                 alt_responses: [
                   {
                     score: 1,
-                    value: [[square], [rhomb], [hexagon], [trapeze]],
+                    value: [{ images: [square] }, { images: [rhomb] }, { images: [trapeze] }, { images: [hexagon] }],
                   },
                   {
                     score: 1,
-                    value: [[rhomb], [square], [trapeze], [hexagon]],
+                    value: [{ images: [rhomb] }, { images: [square] }, { images: [trapeze] }, { images: [hexagon] }],
                   },
                 ],
               },
@@ -281,7 +343,7 @@ describe('controller', () => {
                 { value: trapeze, containerIndex: 2 },
                 { value: hexagon, containerIndex: 0 },
               ],
-            }
+            },
           );
           expect(result.score).toEqual(0);
         });
@@ -322,19 +384,13 @@ describe('controller', () => {
         expect(result.validation).toEqual({
           validResponse: {
             score: 1,
-            value: [
-              [rhomb, square],
-              [rhomb, square, trapeze],
-            ],
+            value: [{ images: [rhomb, square] }, { images: [rhomb, square, trapeze] }],
           },
         });
       });
 
       it('returns responseContainers', () => {
-        expect(result.responseContainers).toEqual([
-          responseContainer1,
-          responseContainer2,
-        ]);
+        expect(result.responseContainers).toEqual([responseContainer1, responseContainer2]);
       });
 
       it('returns duplicateResponses', () => {
@@ -375,18 +431,12 @@ describe('controller', () => {
       });
 
       const returnModel = (sess) => {
-        it(`returns responseCorrect: false if session is ${JSON.stringify(
-          sess
-        )}`, async () => {
-          const result = await model(
-            question,
-            sess,
-            (env = { mode: 'evaluate' })
-          );
+        it(`returns responseCorrect: false if session is ${JSON.stringify(sess)}`, async () => {
+          const result = await model(question, sess, (env = { mode: 'evaluate' }));
           expect(result).toEqual(
             expect.objectContaining({
               responseCorrect: false,
-            })
+            }),
           );
         });
       };
@@ -462,12 +512,12 @@ describe('createCorrectResponseSession', () => {
       valid_response: {
         score: 1,
         value: [
-          [
-            '<img alt="" src="https://app.fluence.net/ia/image/729ca157d04c440ab7ae1c2abfb9c057"/>',
-          ],
-          [
-            '<img alt="" src="https://app.fluence.net/ia/image/9e5ed1d6762c4dac87b080e190af113d"/>',
-          ],
+          {
+            images: ['<img alt="" src="https://app.fluence.net/ia/image/729ca157d04c440ab7ae1c2abfb9c057"/>'],
+          },
+          {
+            images: ['<img alt="" src="https://app.fluence.net/ia/image/9e5ed1d6762c4dac87b080e190af113d"/>'],
+          },
         ],
       },
     },
@@ -482,13 +532,11 @@ describe('createCorrectResponseSession', () => {
     expect(sess).toEqual({
       answers: [
         {
-          value:
-            '<img alt="" src="https://app.fluence.net/ia/image/729ca157d04c440ab7ae1c2abfb9c057"/>',
+          value: '<img alt="" src="https://app.fluence.net/ia/image/729ca157d04c440ab7ae1c2abfb9c057"/>',
           containerIndex: 0,
         },
         {
-          value:
-            '<img alt="" src="https://app.fluence.net/ia/image/9e5ed1d6762c4dac87b080e190af113d"/>',
+          value: '<img alt="" src="https://app.fluence.net/ia/image/9e5ed1d6762c4dac87b080e190af113d"/>',
           containerIndex: 1,
         },
       ],
@@ -505,13 +553,11 @@ describe('createCorrectResponseSession', () => {
     expect(sess).toEqual({
       answers: [
         {
-          value:
-            '<img alt="" src="https://app.fluence.net/ia/image/729ca157d04c440ab7ae1c2abfb9c057"/>',
+          value: '<img alt="" src="https://app.fluence.net/ia/image/729ca157d04c440ab7ae1c2abfb9c057"/>',
           containerIndex: 0,
         },
         {
-          value:
-            '<img alt="" src="https://app.fluence.net/ia/image/9e5ed1d6762c4dac87b080e190af113d"/>',
+          value: '<img alt="" src="https://app.fluence.net/ia/image/9e5ed1d6762c4dac87b080e190af113d"/>',
           containerIndex: 1,
         },
       ],

package/controller/src/index.js

@@ -7,7 +7,7 @@ import { getAllUniqueCorrectness } from './utils';
 
 const log = debug('pie-elements:image-cloze-association:controller');
 
-export const normalize = question => ({
+export const normalize = (question) => ({
   rationaleEnabled: true,
   teacherInstructionsEnabled: true,
   studentInstructionsEnabled: true,
@@ -18,19 +18,18 @@ export function model(question, session, env) {
   const questionNormalized = normalize(question);
   const questionCamelized = camelizeKeys(questionNormalized);
 
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     const out = {
       disabled: env.mode !== 'gather',
       mode: env.mode,
       ...questionCamelized,
-      responseCorrect:
-        env.mode === 'evaluate'
-          ? getScore(questionCamelized, session) === 1
-          : undefined,
+      responseCorrect: env.mode === 'evaluate' ? getScore(questionCamelized, session) === 1 : undefined,
     };
 
     if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
-      out.teacherInstructions = questionCamelized.teacherInstructionsEnabled ? questionCamelized.teacherInstructions : null;
+      out.teacherInstructions = questionCamelized.teacherInstructionsEnabled
+        ? questionCamelized.teacherInstructions
+        : null;
     } else {
       out.teacherInstructions = null;
     }
@@ -47,11 +46,11 @@ export const isResponseCorrect = (responses, session) => {
     return false;
   }
 
-  responses.forEach(value => totalValidResponses += value.length);
+  responses.forEach((value) => (totalValidResponses += (value.images || []).length));
 
   if (session.answers && totalValidResponses === session.answers.length) {
-    session.answers.forEach(answer => {
-      if (!responses[answer.containerIndex].includes(answer.value)) {
+    session.answers.forEach((answer) => {
+      if (!(responses[answer.containerIndex].images || []).includes(answer.value)) {
         isCorrect = false;
       }
     });
@@ -63,13 +62,18 @@ export const isResponseCorrect = (responses, session) => {
 
 // This applies for items that don't support partial scoring.
 const isDefaultOrAltResponseCorrect = (question, session) => {
-  const { validation: { validResponse: { value }, altResponses } } = question;
+  const {
+    validation: {
+      validResponse: { value },
+      altResponses,
+    },
+  } = question;
 
   let isCorrect = isResponseCorrect(value, session);
 
   // Look for correct answers in alternate responses.
-  if (!isCorrect && (altResponses && altResponses.length)) {
-    altResponses.forEach(altResponse => {
+  if (!isCorrect && altResponses && altResponses.length) {
+    altResponses.forEach((altResponse) => {
       if (isResponseCorrect(altResponse.value, session)) {
         isCorrect = true;
       }
@@ -80,9 +84,9 @@ const isDefaultOrAltResponseCorrect = (question, session) => {
 
 // Deduct only the items that exceeded the maximum valid response per container.
 const getDeductionPerContainer = (containerIndex, answers, valid) => {
-  const totalStack = answers.filter(item => item.containerIndex === containerIndex);
-  const incorrectStack = totalStack.filter(item => !item.isCorrect);
-  const maxValid = valid.value[containerIndex].length;
+  const totalStack = answers.filter((item) => item.containerIndex === containerIndex);
+  const incorrectStack = totalStack.filter((item) => !item.isCorrect);
+  const maxValid = (valid.value[containerIndex].images || []).length;
 
   if (totalStack.length > maxValid) {
     const ignored = totalStack.length - maxValid;
@@ -92,7 +96,11 @@ const getDeductionPerContainer = (containerIndex, answers, valid) => {
 };
 
 export const getPartialScore = (question, session) => {
-  const { validation: { validResponse }, maxResponsePerZone, responseContainers } = question;
+  const {
+    validation: { validResponse },
+    maxResponsePerZone,
+    responseContainers,
+  } = question;
   let correctAnswers = 0;
   let possibleResponses = 0;
 
@@ -100,19 +108,19 @@ export const getPartialScore = (question, session) => {
     return 0;
   }
 
-  validResponse.value.forEach(value => possibleResponses += value.length);
+  validResponse.value.forEach((value) => (possibleResponses += (value.images || []).length));
 
   if (session.answers && session.answers.length) {
     const all = getAllUniqueCorrectness(session.answers, validResponse.value);
-    correctAnswers = all.filter(item => item.isCorrect).length;
+    correctAnswers = all.filter((item) => item.isCorrect).length;
 
     // deduction rules: https://docs.google.com/document/d/1Oprm8Qs5fg_Dwoj2pNpsfu4D63QgCZgvcqTgeaVel7I/edit
-    session.answers.forEach(answer => {
+    session.answers.forEach((answer) => {
       if (maxResponsePerZone > 1) {
         const deductionList = getDeductionPerContainer(answer.containerIndex, all, validResponse);
 
         if (deductionList.length) {
-          deductionList.forEach(item => {
+          deductionList.forEach((item) => {
             if (item.id === answer.id) {
               correctAnswers -= 1;
             }
@@ -136,11 +144,11 @@ const getScore = (config, session, env = {}) => {
   const isPartialScoring = partialScoring.enabled(config, env);
   const correct = isDefaultOrAltResponseCorrect(config, session);
 
-  return isPartialScoring ? getPartialScore(config, session) : (correct ? 1 : 0);
+  return isPartialScoring ? getPartialScore(config, session) : correct ? 1 : 0;
 };
 
 export function outcome(config, session, env = {}) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     log('outcome...');
     if (!session || isEmpty(session)) {
       resolve({ score: 0, empty: true });
@@ -156,17 +164,21 @@ export function outcome(config, session, env = {}) {
 }
 
 export const createCorrectResponseSession = (question, env) => {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     if (env.mode !== 'evaluate' && env.role === 'instructor') {
-      const { validation: { valid_response: { value } } } = question;
+      const {
+        validation: {
+          valid_response: { value },
+        },
+      } = question;
       const answers = [];
 
       if (value) {
         value.forEach((container, i) => {
-          container.forEach(v => {
+          (container.images || []).forEach((v) => {
             answers.push({
               value: v,
-              containerIndex: i
+              containerIndex: i,
             });
           });
         });
@@ -174,7 +186,7 @@ export const createCorrectResponseSession = (question, env) => {
 
       resolve({
         answers,
-        id: '1'
+        id: '1',
       });
     } else {
       resolve(null);

package/controller/src/utils.js

@@ -1,35 +1,35 @@
 const getAllCorrectness = (answers, responses) =>
-  answers.map(answer => ({
+  answers.map((answer) => ({
     ...answer,
-    isCorrect: responses[answer.containerIndex].includes(answer.value)
+    isCorrect: (responses[answer.containerIndex].images || []).includes(answer.value),
   }));
 
 const getValidAnswer = (answer, response) =>
-  response[answer.containerIndex].filter(res => res === answer.value);
+  (response[answer.containerIndex].images || []).filter((res) => res === answer.value);
 
 export const getAllUniqueCorrectness = (answers, validResponses) => {
   let allCorrectness = getAllCorrectness(answers, validResponses);
 
   answers.forEach((answer1) => {
-    const valuesToParse = answers.filter(answer2 =>
-      (answer2.value === answer1.value) && (answer2.containerIndex === answer1.containerIndex));
+    const valuesToParse = answers.filter(
+      (answer2) => answer2.value === answer1.value && answer2.containerIndex === answer1.containerIndex,
+    );
 
     if (valuesToParse.length > 1) {
       // point only to duplicates but first
       valuesToParse.shift();
       // mark duplicates as incorrect
       valuesToParse.forEach((value, index) => {
-        allCorrectness = allCorrectness.map(finalAnswer => {
+        allCorrectness = allCorrectness.map((finalAnswer) => {
           if (finalAnswer.id === value.id) {
             let valid = getValidAnswer(finalAnswer, validResponses);
-
             return {
               ...finalAnswer,
-              isCorrect: valid.length > index + 1
-            }
+              isCorrect: valid.length > index + 1,
+            };
           }
           return finalAnswer;
-        })
+        });
       });
     }
   });