@pie-element/ebsr 14.1.1-next.2 → 14.2.0-next.1

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

@@ -0,0 +1,591 @@
+import { model, outcome, createCorrectResponseSession } from '../index';
+import { isResponseCorrect } from '../utils';
+
+const PART_A = 'partA';
+const PART_B = 'partB';
+
+jest.mock('../utils', () => ({
+  isResponseCorrect: jest.fn(),
+}));
+
+describe('controller', () => {
+  let result, question, session, env;
+
+  beforeEach(() => {
+    question = {
+      partA: {
+        choiceMode: 'checkbox',
+        feedbackEnabled: true,
+        choices: [
+          {
+            value: 'yellow',
+            label: 'Yellow',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'green',
+            label: 'Green',
+            feedback: {
+              type: 'default',
+            },
+          },
+        ],
+        choicePrefix: 'numbers',
+        prompt: `prompt ${PART_A}`,
+        promptEnabled: true,
+        lockChoiceOrder: true,
+        partialScoring: false,
+      },
+      partB: {
+        choiceMode: 'checkbox',
+        feedbackEnabled: true,
+        choices: [
+          {
+            value: 'orange',
+            label: 'Orange',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'purple',
+            label: 'Purple',
+            feedback: {
+              type: 'default',
+            },
+          },
+          {
+            value: 'c',
+            correct: true,
+          },
+        ],
+        choicePrefix: 'numbers',
+        prompt: `prompt ${PART_B}`,
+        promptEnabled: true,
+        lockChoiceOrder: true,
+        partialScoring: false,
+      },
+    };
+  });
+
+  describe('outcome partialScoring test', () => {
+    const mkQuestion = (extra) => ({
+      partA: {
+        choiceMode: 'radio',
+        feedbackEnabled: true,
+        choices: [
+          {
+            value: 'yellow',
+            label: 'Yellow',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'blue',
+            label: 'Blue',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'green',
+            label: 'Green',
+            feedback: {
+              type: 'default',
+            },
+          },
+        ],
+        choicePrefix: 'numbers',
+        prompt: `prompt ${PART_A}`,
+        promptEnabled: true,
+        lockChoiceOrder: true,
+      },
+      partB: {
+        choiceMode: 'radio',
+        feedbackEnabled: true,
+        choices: [
+          {
+            value: 'orange',
+            label: 'Orange',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'red',
+            label: 'Red',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'purple',
+            label: 'Purple',
+            feedback: {
+              type: 'default',
+            },
+          },
+        ],
+        choicePrefix: 'numbers',
+        prompt: `prompt ${PART_B}`,
+        promptEnabled: true,
+        lockChoiceOrder: true,
+      },
+      partialScoring: false,
+      ...extra,
+    });
+
+    const assertOutcome = (message, extra, value1, value2, env, expected, expectedMax) => {
+      it(message, async () => {
+        const question = mkQuestion(extra);
+        const result = await outcome(question, { value: { partA: { value: value1 }, partB: { value: value2 } } }, env);
+        expect(result.score).toEqual(expected);
+        expect(result.max).toEqual(expectedMax);
+      });
+    };
+
+    assertOutcome(
+      'element.partialScoring = true, partA correct, partB correct',
+      { partialScoring: true },
+      ['yellow', 'blue'],
+      ['orange', 'red'],
+      { mode: 'evaluate' },
+      2,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = true, partA correct, partB partially correct',
+      { partialScoring: true },
+      ['yellow', 'blue'],
+      ['orange'],
+      { mode: 'evaluate' },
+      1,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = true, partA correct, partB incorrect',
+      { partialScoring: true },
+      ['yellow', 'blue'],
+      [],
+      { mode: 'evaluate' },
+      1,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = true, partA incorrect, partB correct',
+      { partialScoring: true },
+      [],
+      ['orange', 'red'],
+      { mode: 'evaluate' },
+      0,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = true, partA partially correct, partB partially correct',
+      { partialScoring: true },
+      ['yellow'],
+      ['orange'],
+      { mode: 'evaluate' },
+      0,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = true, partA incorrect, partB partially correct',
+      { partialScoring: true },
+      ['yellow'],
+      ['orange'],
+      { mode: 'evaluate' },
+      0,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = true, partA incorrect, partB incorrect',
+      { partialScoring: true },
+      ['yellow'],
+      ['orange'],
+      { mode: 'evaluate' },
+      0,
+      2,
+    );
+
+    assertOutcome(
+      'element.partialScoring = false, partA correct, partB correct',
+      { partialScoring: false },
+      ['yellow', 'blue'],
+      ['orange', 'red'],
+      { mode: 'evaluate' },
+      1,
+      1,
+    );
+
+    assertOutcome(
+      'element.partialScoring = false, partA incorrect, partB correct',
+      { partialScoring: false },
+      ['yellow'],
+      ['orange', 'red'],
+      { mode: 'evaluate' },
+      0,
+      1,
+    );
+
+    assertOutcome(
+      'element.partialScoring = false, partA correct, partB incorrect',
+      { partialScoring: false },
+      ['yellow', 'blue'],
+      ['orange'],
+      { mode: 'evaluate' },
+      0,
+      1,
+    );
+
+    assertOutcome(
+      'element.partialScoring = false, partA incorrect, partB incorrect',
+      { partialScoring: false },
+      [],
+      [],
+      { mode: 'evaluate' },
+      0,
+      1,
+    );
+  });
+
+  describe('outcome', () => {
+    describe('dichotomous', () => {
+      const returnsScoreOf = (message, values1, values2, score) => {
+        it(`${message} => ${score}`, async () => {
+          const result = await outcome(
+            { ...question, partialScoring: false },
+            { value: { partA: { value: values1 }, partB: { value: values2 } } },
+          );
+          expect(result.score).toEqual(score);
+          expect(result.max).toEqual(1);
+        });
+      };
+
+      returnsScoreOf('both correct', ['yellow'], ['orange', 'c'], 1); // both correct
+      returnsScoreOf('both incorrect', ['green'], ['purple'], 0); // both wrong
+      returnsScoreOf('partA incorrect, partB correct', ['green'], ['orange', 'c'], 0); // first wrong, second correct
+      returnsScoreOf('partA correct, partB incorrect', ['yellow'], ['purple'], 0); // first correct, second wrong
+    });
+
+    describe('partial scoring', () => {
+      const returnsScoreOf = (message, values1, values2, score) => {
+        it(`${message} => ${score}`, async () => {
+          const result = await outcome(
+            { ...question, partialScoring: true },
+            { value: { partA: { value: values1 }, partB: { value: values2 } } },
+          );
+          expect(result.score).toBeCloseTo(score);
+          expect(result.max).toEqual(2);
+        });
+      };
+
+      returnsScoreOf('both correct', ['yellow'], ['orange', 'c'], 2);
+      returnsScoreOf('both incorrect', [], [], 0);
+      returnsScoreOf('partA correct, partB incorrect', ['yellow'], [], 1);
+      returnsScoreOf('partA correct, partB partially correct', ['yellow'], ['c'], 1);
+      returnsScoreOf('partA incorrect, partB correct', ['green'], ['orange', 'c'], 0);
+      returnsScoreOf('partA partially correct, partB correct', ['green', 'yellow'], ['orange', 'c'], 0);
+    });
+
+    const returnsScoreWhen = (session) => {
+      it(`returns empty: true if session is ${JSON.stringify(session)}`, async () => {
+        const result = await outcome(question, session);
+        expect(result).toEqual({ score: 0, scoreA: 0, scoreB: 0, empty: true, logTrace: ['Student did not answer the question.'] });
+      });
+    };
+
+    returnsScoreWhen(undefined);
+    returnsScoreWhen(null);
+    returnsScoreWhen({});
+  });
+
+  describe('model', () => {
+    const capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+
+    describe('mode: gather', () => {
+      beforeEach(async () => {
+        session = {};
+        env = { mode: 'gather' };
+        result = await model(question, session, env);
+      });
+
+      it('returns disabled', () => {
+        expect(result.disabled).toEqual(false);
+      });
+
+      it('returns mode', () => {
+        expect(result.mode).toEqual('gather');
+      });
+
+      const returnsPrompt = (part) => {
+        it(`returns ${part} prompt`, () => {
+          expect(result[part].prompt).toEqual(`prompt ${part}`);
+        });
+      };
+
+      const returnsChoiceMode = (part) => {
+        it(`returns ${part} choiceMode`, () => {
+          expect(result[part].choiceMode).toEqual('checkbox');
+        });
+      };
+
+      const returnsKeyMode = (part) => {
+        it(`returns ${part} choicePrefix`, () => {
+          expect(result[part].choicePrefix).toEqual('numbers');
+        });
+      };
+
+      const returnsComplete = (part, min) => {
+        it(`returns ${part} complete`, () => {
+          expect(result[part].complete).toEqual({ min });
+        });
+      };
+
+      const doesNotReturnCorrect = (part) => {
+        it(`does not return ${part} responseCorrect`, () => {
+          expect(result[part].responseCorrect).toBe(undefined);
+        });
+      };
+
+      const returnsChoices = (part, value1, value2) => {
+        it(`returns ${part} choices`, () => {
+          expect(result[part].choices).toEqual(
+            expect.arrayContaining([
+              { value: value1, label: capitalize(value1), rationale: null },
+              { value: value2, label: capitalize(value2), rationale: null },
+            ]),
+          );
+        });
+      };
+
+      returnsPrompt(PART_A);
+      returnsPrompt(PART_B);
+
+      returnsChoiceMode(PART_A);
+      returnsChoiceMode(PART_B);
+
+      returnsKeyMode(PART_A);
+      returnsKeyMode(PART_B);
+
+      returnsComplete(PART_A, 1);
+      returnsComplete(PART_B, 2);
+
+      returnsChoices(PART_A, 'yellow', 'green');
+      returnsChoices(PART_B, 'orange', 'purple');
+
+      doesNotReturnCorrect(PART_A);
+      doesNotReturnCorrect(PART_B);
+    });
+
+    describe('model - with updateSession', () => {
+      it('calls updateSession', async () => {
+        session = { id: '1', element: 'ebsr-element' };
+        env = { mode: 'gather' };
+        const updateSession = jest.fn().mockResolvedValue();
+        await model(
+          {
+            ...question,
+            partA: {
+              ...question.partA,
+              lockChoiceOrder: false,
+            },
+            partB: {
+              ...question.partB,
+              lockChoiceOrder: false,
+            },
+          },
+          session,
+          env,
+          updateSession,
+        );
+        expect(updateSession).toHaveBeenCalledWith('1', 'ebsr-element', {
+          shuffledValues: {
+            partA: expect.arrayContaining(['yellow', 'green']),
+            partB: expect.arrayContaining(['orange', 'purple']),
+          },
+        });
+      });
+    });
+
+    describe('model - without valid updateSession', () => {
+      const assertModel = (updateSession) => {
+        it(`does not throw error if updateSession is ${updateSession}`, async () => {
+          session = {
+            id: '1',
+            element: 'ebsr-element',
+            shuffledValues: { partA: [], partB: [] },
+          };
+          env = { mode: 'gather' };
+
+          await model(
+            {
+              ...question,
+              partA: {
+                ...question.partA,
+                lockChoiceOrder: false,
+              },
+              partB: {
+                ...question.partB,
+                lockChoiceOrder: false,
+              },
+            },
+            session,
+            env,
+          );
+        });
+      };
+
+      assertModel(undefined);
+      assertModel(null);
+      assertModel('text');
+    });
+
+    describe('mode: view', () => {
+      beforeEach(async () => {
+        session = {};
+        env = { mode: 'view' };
+        result = await model(question, session, env);
+      });
+
+      it('returns disabled', () => {
+        expect(result.disabled).toEqual(true);
+      });
+    });
+
+    describe('mode: evaluate', () => {
+      beforeEach(async () => {
+        session = {};
+        env = { mode: 'evaluate' };
+        isResponseCorrect.mockReturnValue(false);
+        result = await model(question, session, env);
+        return result;
+      });
+
+      const returnsChoicesWCorrect = (part, value1, value2) => {
+        it(`returns ${part} choices w/ correct`, () => {
+          expect(result[part].choices).toEqual(
+            expect.arrayContaining([
+              {
+                value: value1,
+                label: capitalize(value1),
+                correct: true,
+                feedback: 'foo',
+                rationale: null,
+              },
+              {
+                value: value2,
+                label: capitalize(value2),
+                correct: false,
+                feedback: 'Incorrect',
+                rationale: null,
+              },
+            ]),
+          );
+        });
+      };
+
+      const returnsChoicesWCorrectFeedbackDisabled = (part, value1, value2) => {
+        // feedback enabled for partB and disabled for partA
+        it(`returns ${part} choices w/ correct even if feedbackEnabled is false`, async () => {
+          let res = await model(
+            {
+              ...question,
+              partA: {
+                ...question.partA,
+                feedbackEnabled: false,
+              },
+              partB: {
+                ...question.partB,
+                feedbackEnabled: false,
+              },
+            },
+            session,
+            env,
+          );
+
+          expect(result[part].choices).toEqual(
+            expect.arrayContaining([
+              {
+                value: value1,
+                label: capitalize(value1),
+                correct: true,
+                feedback: 'foo',
+                rationale: null,
+              },
+              {
+                value: value2,
+                label: capitalize(value2),
+                correct: false,
+                feedback: 'Incorrect',
+                rationale: null,
+              },
+            ]),
+          );
+        });
+      };
+
+      const returnsIsResponseCorrect = (part) => {
+        it(`returns ${part} is response correct`, () => {
+          expect(result[part].responseCorrect).toEqual(false);
+        });
+      };
+
+      // Second param will be correct (yellow for A; orange for B)
+      returnsChoicesWCorrect(PART_A, 'yellow', 'green');
+      returnsChoicesWCorrect(PART_B, 'orange', 'purple');
+
+      // Second param will be correct (yellow for A; orange for B)
+      returnsChoicesWCorrectFeedbackDisabled(PART_A, 'yellow', 'green');
+      returnsChoicesWCorrectFeedbackDisabled(PART_B, 'orange', 'purple');
+
+      returnsIsResponseCorrect(PART_A);
+      returnsIsResponseCorrect(PART_B);
+    });
+
+    describe('correct response', () => {
+      it('returns correct response if env is correct', async () => {
+        const sess = await createCorrectResponseSession(question, {
+          mode: 'gather',
+          role: 'instructor',
+        });
+        expect(sess).toEqual({
+          id: '1',
+          value: {
+            partA: { id: 'partA', value: ['yellow'] },
+            partB: { id: 'partB', value: ['orange', 'c'] },
+          },
+        });
+      });
+
+      it('returns null env is student', async () => {
+        const noResult = await createCorrectResponseSession(question, {
+          mode: 'gather',
+          role: 'student',
+        });
+        expect(noResult).toBeNull();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+import { isResponseCorrect } from '../utils';
+
+describe('isResponseCorrect', () => {
+  let question;
+
+  beforeEach(() => {
+    question = {
+      partA: {
+        choiceMode: 'radio',
+        feedbackEnabled: true,
+        choices: [
+          {
+            value: 'yellow',
+            label: 'Yellow',
+            correct: true,
+            feedback: {
+              type: 'custom',
+              value: 'foo',
+            },
+          },
+          {
+            value: 'green',
+            label: 'Green',
+            feedback: {
+              type: 'default',
+            },
+          },
+        ],
+        choicePrefix: 'numbers',
+        prompt: `prompt partA`,
+      },
+    };
+  });
+
+  const returnsIsResponseCorrect = (session) => {
+    it(`response is not correct if session is ${JSON.stringify(session)}`, () => {
+      expect(isResponseCorrect(question.partA, 'partA', session)).toEqual(false);
+    });
+  };
+
+  returnsIsResponseCorrect(undefined);
+  returnsIsResponseCorrect(null);
+  returnsIsResponseCorrect({});
+
+  it('response is correct if session is defined', () => {
+    expect(isResponseCorrect(question.partA, 'partA', { value: { partA: { value: ['yellow'] } } })).toEqual(true);
+  });
+});

package/{src/controller/defaults.ts → controller/src/defaults.js}

@@ -1,13 +1,3 @@
-// @ts-nocheck
-/**
- * @synced-from pie-elements/packages/ebsr/controller/src/defaults.js
- * @auto-generated
- *
- * This file is automatically synced from pie-elements and converted to TypeScript.
- * Manual edits will be overwritten on next sync.
- * To make changes, edit the upstream JavaScript file and run sync again.
- */
-
 const partModel = (base) => ({
   choiceMode: 'radio',
   choicePrefix: 'letters',

package/{src/controller/index.ts → controller/src/index.js}

@@ -1,16 +1,6 @@
-// @ts-nocheck
-/**
- * @synced-from pie-elements/packages/ebsr/controller/src/index.js
- * @auto-generated
- *
- * This file is automatically synced from pie-elements and converted to TypeScript.
- * Manual edits will be overwritten on next sync.
- * To make changes, edit the upstream JavaScript file and run sync again.
- */
-
-import defaults from './defaults.js';
-import { lockChoices, getShuffledChoices, partialScoring } from '@pie-element/shared-controller-utils';
-import { isResponseCorrect } from './utils.js';
+import defaults from './defaults';
+import { lockChoices, getShuffledChoices, partialScoring } from '@pie-lib/controller-utils';
+import { isResponseCorrect } from './utils';
 import { get, isEmpty } from 'lodash-es';
 import Translator from '@pie-lib/translator';
 

package/{src/controller/utils.ts → controller/src/utils.js}

@@ -1,13 +1,3 @@
-// @ts-nocheck
-/**
- * @synced-from pie-elements/packages/ebsr/controller/src/utils.js
- * @auto-generated
- *
- * This file is automatically synced from pie-elements and converted to TypeScript.
- * Manual edits will be overwritten on next sync.
- * To make changes, edit the upstream JavaScript file and run sync again.
- */
-
 import { isEqual } from 'lodash-es';
 
 export const getCorrectResponse = (choices) =>