@instructure/quiz-core 22.17.0 → 22.18.0

package/src/common/records/QuizSessionResult.ts

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import {is, List} from 'immutable'
+import ReduxRecord from './reduxRecord'
+
+import {QUIZ_SESSION_RESULT_FETCH_CALL} from '@instructure/quiz-common/constants'
+import {getSessionItemResultsByIds} from '../selectors/sessionItemResults'
+
+export class QuizSessionResult extends ReduxRecord({
+  createdAt: null,
+  fudgePoints: null,
+  gradingMethod: null,
+  id: '0',
+  percentage: null,
+  pointsPossible: null,
+  quizSession: null,
+  score: null,
+  sessionItemResults: List(),
+  status: null,
+  updatedAt: null,
+}) {
+  isGraded() {
+    return this.status === 'graded' || this.autogradingFailed()
+  }
+
+  autogradingFailed() {
+    return this.status === 'autograding_failed'
+  }
+
+  isLoaded() {
+    return this.id !== '0'
+  }
+
+  getSessionItemResults() {
+    return getSessionItemResultsByIds(this.getState(), this.sessionItemResults)
+  }
+
+  getWorkingInstance() {
+    const mods = this.getState().modifications.getIn(['quizSessionResults', this.id])
+    return QuizSessionResult.create(this.merge(mods))
+  }
+
+  hasModifications() {
+    return !is(this.getWorkingInstance(), this)
+  }
+
+  static fetcherTag(id) {
+    return `${QUIZ_SESSION_RESULT_FETCH_CALL}_${id}`
+  }
+}
+
+export default QuizSessionResult

package/src/common/records/Response.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import ReduxRecord from './reduxRecord'
+import {rule} from 'instructure-validations'
+import {TAKE_CHAR_LIMIT} from '@instructure/quiz-common/constants'
+import {getSessionItemById} from '../selectors/sessionItems'
+
+export class Response extends ReduxRecord({
+  attempt: null,
+  itemId: null,
+  largeFormatResponse: null,
+  position: null,
+  userResponse: null,
+  id: null,
+}) {
+  static validations() {
+    return {
+      userResponse: [rule('maxContent', {limit: TAKE_CHAR_LIMIT})],
+    }
+  }
+
+  getItem() {
+    if (this.itemId) {
+      return getSessionItemById(this.getState(), this.id).getItem()
+    }
+  }
+}
+
+export default Response

package/src/common/records/SessionItem.ts

@@ -0,0 +1,107 @@
+// @ts-nocheck
+import {List} from 'immutable'
+
+import ReduxRecord from './reduxRecord'
+import Item from './Item'
+import Stimulus from './Stimulus'
+import SessionItemResult from './SessionItemResult'
+
+export class SessionItem extends ReduxRecord({
+  id: null,
+  item: {},
+  pointsPossible: null,
+  position: null,
+  questionNumber: null,
+  quizEntryId: null,
+  quizSessionId: null,
+  scoringData: {},
+  calculatorType: 'none',
+  stimulus: null,
+  stimulusKey: null,
+  bolaPosition: null,
+  required: false,
+}) {
+  getItem() {
+    if (this.item) {
+      return Item.create(this.item)
+    }
+  }
+
+  getEntry() {
+    return {
+      Stimulus: this.stimulusRecord,
+      Item: this.itemRecord,
+    }[this.type]
+  }
+
+  getNestedEntries(fromState = false) {
+    if (this.stimulus) {
+      if (this.items && !fromState) {
+        return this.items
+      }
+
+      const stimulusIdFilter = si =>
+        si.get('quizSessionId') === this.quizSessionId &&
+        si.getIn(['stimulus', 'id']) === this.getIn(['stimulus', 'id'])
+
+      const stimulusKeyFilter = si =>
+        si.get('quizSessionId') === this.quizSessionId && si.get('stimulusKey') === this.stimulusKey
+
+      // fallback to use the stimulus id when stimulusKey is not present
+      const filter = this.stimulusKey === null ? stimulusIdFilter : stimulusKeyFilter
+
+      this.items = this.getState()
+        .sessionItems.filter(filter)
+        .map(si => SessionItem.create(si))
+        .sortBy(si => si.position)
+        .toList()
+      return this.items
+    }
+    return List()
+  }
+
+  get sessionItemResult() {
+    return SessionItemResult.create(this.getState().sessionItemResults.get(this.id))
+  }
+
+  get type() {
+    return this.stimulus !== null ? 'Stimulus' : 'Item'
+  }
+
+  get isStimulus() {
+    return this.type === 'Stimulus'
+  }
+
+  get isPassage() {
+    return this.isStimulus && this.stimulusRecord.isPassage
+  }
+
+  get stimulusRecord() {
+    return Stimulus.create(this.stimulus)
+  }
+
+  get itemRecord() {
+    return Item.create(this.item)
+  }
+
+  get hasNestedRecords() {
+    return this.isStimulus
+  }
+
+  get positionSlots() {
+    // decrement to account for stimulus not being its own sessionItem
+    // and the generateDisplayPositions assume each item with nested
+    // values does not count itself, but it can't be negative
+    const slots = this.displayPositionSlots - 1
+    return slots >= 0 ? slots : 0
+  }
+
+  get displayPositionSlots() {
+    if (this.isStimulus) {
+      return this.getNestedEntries().size
+    }
+    return 1
+  }
+}
+
+export default SessionItem

package/src/common/records/SessionItemResult.ts

@@ -0,0 +1,73 @@
+// @ts-nocheck
+import {is, Map} from 'immutable'
+import ReduxRecord from './reduxRecord'
+import {getSessionItemById} from '../selectors/sessionItems'
+
+export class SessionItemResult extends ReduxRecord({
+  answerFeedback: null,
+  attempt: null,
+  feedback: Map(),
+  gradedAt: null,
+  graderId: null,
+  gradingMethod: null,
+  id: null,
+  itemId: null,
+  regradeInfo: null,
+  pointsPossible: null,
+  position: null,
+  score: null,
+  scoredData: Map(),
+}) {
+  getItem() {
+    return getSessionItemById(this.getState(), this.id).getItem()
+  }
+
+  defaultResult(sessionItem) {
+    const defaultResultData = {
+      attempt: 1,
+      itemId: sessionItem.getItem().id,
+      position: sessionItem.position,
+      id: sessionItem.id,
+    }
+
+    return new SessionItemResult(defaultResultData, this.getState())
+  }
+
+  getWorkingInstance() {
+    const modificationData = this.merge(
+      this.getState().modifications.getIn(['sessionItemResults', this.id], Map()),
+    )
+
+    return new SessionItemResult(modificationData, this.getState())
+  }
+
+  hasModifications() {
+    return !is(this.getWorkingInstance(), this)
+  }
+
+  isLoaded() {
+    return this.itemId !== null
+  }
+
+  isGraded() {
+    return !!this.gradedAt
+  }
+
+  hasRegradeInfo() {
+    return this.regradeInfo && this.regradeInfo.size > 1
+  }
+
+  isUnscorable() {
+    return this.scoredData.get('unscorable')
+  }
+
+  isRegraded() {
+    return this.regradeInfo && this.regradeInfo.get('regraded')
+  }
+
+  interactionType() {
+    return this.interactionType || null
+  }
+}
+
+export default SessionItemResult

package/src/common/records/Stimulus.ts

@@ -0,0 +1,60 @@
+// @ts-nocheck
+import {is} from 'immutable'
+import ReduxRecord from './reduxRecord'
+import {TEMPORARY_STIMULUS_ID} from '@instructure/quiz-common/constants'
+import t from '@instructure/quiz-i18n/format-message'
+import {rule} from 'instructure-validations'
+import {presenceMessage} from '@instructure/quiz-interactions/util/validationHelpers'
+
+export class Stimulus extends ReduxRecord({
+  id: '0',
+  stimulusType: 'text',
+  title: '',
+  instructions: '',
+  body: '',
+  sourceUrl: '',
+  status: 'mutable',
+  orientation: 'left',
+  passage: false,
+}) {
+  static validations() {
+    return {
+      title: [rule('presence', {message: presenceMessage(t('Title'))})],
+      body: [rule('presence', {message: presenceMessage(t('Content'))})],
+      onSelf: [rule('maxContent')],
+    }
+  }
+
+  get isStimulus() {
+    return true
+  }
+
+  get isPassage() {
+    return this.passage
+  }
+
+  isLoaded() {
+    return this.id !== '0'
+  }
+
+  isTemporary() {
+    return this.id === TEMPORARY_STIMULUS_ID
+  }
+
+  hasModifications() {
+    return !is(this.getWorkingInstance(), this)
+  }
+
+  getWorkingInstance() {
+    // The record created by .merge() somehow bypasses calling the constructor where
+    // methods created by the `() => {` pattern get created/set. So we feed the result
+    // through the constructor manually.
+    return Stimulus.create(this.merge(this.getState().modifications.getIn(['stimuli', this.id])))
+  }
+
+  isImmutable() {
+    return this.status === 'immutable'
+  }
+}
+
+export default Stimulus

package/src/common/records/__tests__/Bank.test.js

@@ -0,0 +1,76 @@
+import {fromJS} from 'immutable'
+import {TEMPORARY_BANK_ID, CAN_EDIT, READ_ONLY} from '@instructure/quiz-common/constants'
+import {singleRelationCheck} from '../../../../tests/util/recordTests'
+import QtiImport from '../QtiImport'
+
+import Bank from '../Bank'
+import {expect} from 'vitest'
+
+describe('Bank record', () => {
+  it('converts string timestamps to Date', () => {
+    const bank = new Bank({
+      createdAt: '2017-02-12T17:36:00.000Z',
+      updatedAt: '2017-03-13T17:36:00.000Z',
+    })
+    expect(bank.createdAt()).toEqual(new Date('2017-02-12T17:36:00.000Z'))
+    expect(bank.updatedAt()).toEqual(new Date('2017-03-13T17:36:00.000Z'))
+  })
+
+  it('uses default id to indicate not loaded', () => {
+    expect(new Bank().isLoaded()).toBe(false)
+    expect(new Bank({id: 123}).isLoaded()).toBe(true)
+  })
+
+  describe('#isTemporary', () => {
+    it('returns true if temporary id', () => {
+      expect(new Bank({id: TEMPORARY_BANK_ID}).isTemporary()).toBe(true)
+    })
+  })
+
+  describe('#canImport', () => {
+    it('returns true if status is "waiting" and there are no bankEntries', () => {
+      const bank = new Bank({status: 'waiting', entryCount: 0, bankEntries: new Set()})
+      expect(bank.canImport()).toBe(true)
+    })
+
+    it('returns false if status is not "waiting"', () => {
+      const bank = new Bank({status: 'importing', entryCount: 0, bankEntries: new Set()})
+      expect(bank.canImport()).toBe(false)
+    })
+
+    it('returns false a bankEntry is associated to it', () => {
+      const bank = new Bank({status: 'waiting', entryCount: 1, bankEntries: new Set('1')})
+      expect(bank.canImport()).toBe(false)
+    })
+  })
+
+  describe('#getLatestImport', () => {
+    const bankId = '2'
+    const laterImportData = {parentId: bankId, parentType: 'Bank', id: '2'}
+    const exampleState = {
+      qtiImports: {
+        1: {parentId: bankId, parentType: 'Bank', id: '1'},
+        2: laterImportData,
+      },
+    }
+
+    const options = {
+      RelationRecordType: QtiImport,
+      relationAttrs: laterImportData,
+      recordAttributes: {id: bankId},
+      necessaryState: fromJS(exampleState),
+    }
+
+    singleRelationCheck(Bank, 'getLatestImport', options)
+  })
+
+  describe('#canEdit', () => {
+    it('returns true if permission is CAN_EDIT', () => {
+      expect(new Bank({permission: CAN_EDIT}).canEdit()).toBe(true)
+    })
+
+    it('returns false if permission is not CAN_EDIT', () => {
+      expect(new Bank({permission: READ_ONLY}).canEdit()).toBe(false)
+    })
+  })
+})

package/src/common/records/__tests__/BankEntry.test.js

@@ -0,0 +1,102 @@
+import {expect, vi, beforeEach, afterEach} from 'vitest'
+import {fromJS} from 'immutable'
+import BankEntry from '../BankEntry'
+import {setStoreProvider} from '../reduxRecord'
+
+import {TEMPORARY_ITEM_ID, TEMPORARY_STIMULUS_ID} from '@instructure/quiz-common/constants'
+
+beforeEach(() => {
+  const state = {
+    items: fromJS({}),
+    stimuli: fromJS({}),
+    bankEntries: fromJS({}),
+    modifications: fromJS({items: {}, stimuli: {}}),
+  }
+  setStoreProvider({getAppState: () => state})
+})
+afterEach(() => setStoreProvider(null))
+
+describe('BankEntry Record', () => {
+  describe('#getEntry', () => {
+    const returnsEntryOfType = (constructorType, entryId) => {
+      it('returns correct entry', () => {
+        const bankEntry = new BankEntry({entryType: constructorType, entry: {get: () => {}}})
+        expect(bankEntry.getEntry().constructor.name).toBe(constructorType)
+      })
+
+      it('returns correct temporary entry', () => {
+        const tempBankEntry = new BankEntry({entryType: constructorType, entry: entryId})
+        expect(tempBankEntry.getEntry().constructor.name).toBe(constructorType)
+      })
+    }
+
+    describe('item', () => {
+      returnsEntryOfType('Item', TEMPORARY_ITEM_ID)
+    })
+
+    describe('stimulus', () => {
+      returnsEntryOfType('Stimulus', TEMPORARY_STIMULUS_ID)
+    })
+  })
+
+  describe('#isStimulus', () => {
+    it('returns true when stimulus entry type', () => {
+      const bankEntry = new BankEntry({entryType: 'Stimulus'})
+      expect(bankEntry.isStimulus).toBe(true)
+    })
+
+    it('returns false when item entry type', () => {
+      const bankEntry = new BankEntry({entryType: 'Item'})
+      expect(bankEntry.isStimulus).toBe(false)
+    })
+  })
+
+  describe('#isStimulus', () => {
+    it('returns true when stimulus entry type', () => {
+      const bankEntry = new BankEntry({entryType: 'Stimulus'})
+      expect(bankEntry.isStimulus).toBe(true)
+    })
+
+    it('returns false when item entry type', () => {
+      const bankEntry = new BankEntry({entryType: 'Item'})
+      expect(bankEntry.isStimulus).toBe(false)
+    })
+  })
+
+  describe('#isStimulusEntry', () => {
+    it('returns true when entry is stimulus and not passage', () => {
+      const entry = new BankEntry({entryType: 'Stimulus', isPassage: false})
+      expect(entry.isStimulusEntry).toBe(true)
+    })
+
+    it('returns false when entry is null', () => {
+      const entry = new BankEntry({})
+      vi.spyOn(entry, 'getEntry').mockReturnValue(null)
+      expect(entry.isStimulusEntry).toBe(false)
+    })
+
+    it('returns false when not a stimulus', () => {
+      const entry = new BankEntry({entryType: 'Item', isPassage: false})
+      expect(entry.isStimulusEntry).toBe(false)
+    })
+  })
+
+  describe('#isPassageEntry', () => {
+    it('returns true when entry is stimulus and passage', () => {
+      const entry = new BankEntry({entryType: 'Stimulus'})
+      vi.spyOn(entry, 'getEntry').mockReturnValue({isStimulus: true, isPassage: true})
+      expect(entry.isPassageEntry).toBe(true)
+    })
+
+    it('returns false when entry is not stimulus', () => {
+      const entry = new BankEntry({entryType: 'Item', isPassage: true})
+      expect(entry.isPassageEntry).toBe(false)
+    })
+
+    it('returns false when entry is null', () => {
+      const entry = new BankEntry({})
+      vi.spyOn(entry, 'getEntry').mockReturnValue(null)
+      expect(entry.isPassageEntry).toBe(false)
+    })
+  })
+})

package/src/common/records/__tests__/Item.test.js

@@ -0,0 +1,96 @@
+import {fromJS} from 'immutable'
+import {expect, vi} from 'vitest'
+import {RICH_FILL_BLANK_SLUG} from '@instructure/quiz-common/constants'
+import {default as InteractionType} from '@instructure/quiz-interactions/records/InteractionType'
+
+import {setFakeStore, unsetFakeStore} from '../../../../tests/util/fakeStore'
+import Item from '../Item'
+
+describe('Item Record', () => {
+  describe('#hasModifications', () => {
+    it('returns false if it has no modifications', () => {
+      const item = new Item()
+      const unmodifiedItem = item.merge({})
+      vi.spyOn(item, 'getWorkingInstance').mockReturnValue(unmodifiedItem)
+      expect(item.hasModifications()).toBe(false)
+    })
+
+    it('returns true if modifications exist', () => {
+      const item = new Item()
+      const unmodifiedItem = item.merge({title: 'Some new title'})
+      vi.spyOn(item, 'getWorkingInstance').mockReturnValue(unmodifiedItem)
+      expect(item.hasModifications()).toBe(true)
+    })
+  })
+
+  describe('#getItemBody', () => {
+    it('adds underscores at all blank locations', () => {
+      const intType = new InteractionType({slug: RICH_FILL_BLANK_SLUG})
+      const item = new Item({
+        itemBody:
+          'Roses are <span id="blank_1234-abcd"></span> Violets are <span id="blank_9876-zyxw"></span>',
+      })
+      vi.spyOn(item, 'getInteractionType').mockReturnValue(intType)
+      expect(item.getItemBody()).toBe(
+        'Roses are _____<span id="blank_1234-abcd"></span> Violets are _____<span id="blank_9876-zyxw"></span>',
+      )
+    })
+  })
+
+  describe('#getWorkingInstance', () => {
+    const fakeState = {
+      modifications: fromJS({
+        items: {
+          4: {title: 'some updated title'},
+        },
+      }),
+    }
+
+    beforeAll(() => setFakeStore(fakeState))
+
+    afterAll(() => unsetFakeStore())
+
+    it('merges modifications from state', () => {
+      const item = new Item({id: '4', title: 'some title'})
+      expect(item.getWorkingInstance().title).toBe('some updated title')
+    })
+
+    it('merges passed overrides', () => {
+      const item = new Item({scoringData: {value: 'origValue'}})
+      const overrides = {scoringData: {value: 'overrideValue'}}
+      expect(item.getWorkingInstance(overrides).scoringData.get('value')).toBe('overrideValue')
+    })
+  })
+
+  describe('#hasFeedback', () => {
+    it('returns false if it has no feedback', () => {
+      const item = new Item()
+      expect(item.hasFeedback()).toBeFalsy()
+    })
+
+    it('returns true if feedback exists', () => {
+      const item = new Item().merge({
+        feedback: {
+          neutral: 'neutral feedback',
+        },
+      })
+      expect(item.hasFeedback()).toBeTruthy()
+    })
+  })
+
+  describe('#getChoice', () => {
+    it('returns the proper choice', () => {
+      const choiceToFindId = '23'
+      const choiceToFind = fromJS({id: choiceToFindId})
+      const item = new Item(
+        fromJS({
+          interactionData: {
+            choices: [{id: '239'}, choiceToFind, {id: '34'}],
+          },
+        }),
+      )
+
+      expect(item.getChoice(choiceToFindId)).toBe(choiceToFind)
+    })
+  })
+})