@instructure/quiz-core 22.17.0 → 22.18.0

package/src/common/reducers/taking.js

@@ -0,0 +1,164 @@
+import {Map} from 'immutable'
+
+import {
+  ACTIVE_QUIZ_SESSION_CHANGE,
+  UPDATE_TIMER_INFO,
+  UPDATE_IS_TAKING,
+  UPDATE_QUIZ_SESSION_STATUS_ON_PAGE_LOAD,
+  UPDATE_TIMER_MINIMIZED,
+  LOAD_RESUME_DATA,
+  PREVIEW_RESPONSE,
+  PREVIOUS_QUESTION,
+  BACKTRACKING_NEXT_QUESTION,
+  RESPONSE,
+  SESSION_STARTED_OR_RESUMED_EVENT,
+  SET_CURRENT_SESSION_ITEM_POSITION,
+  CLEAR_FOCUS_CURRENT_SESSION_ITEM,
+  SET_FOCUS_TITLE_AND_INSTRUCTIONS,
+  UPDATE_QUIZ_SUBMIT_FLAG,
+  SET_WS_TOKEN,
+} from '@instructure/quiz-common/constants'
+
+const defaultResponse = payload => {
+  return Map({
+    position: payload.position,
+    itemId: payload.itemId,
+    userResponse: payload.userResponse || {},
+    clientTimestamp: Date.now(),
+    invalid: payload.invalid,
+  })
+}
+
+const cachedSessionIsCurrent = (state, payload) => {
+  return state.get('sessionIdForCurrentItem') === payload
+}
+
+const activeQuizSessionChange = (state, payload) => {
+  if (cachedSessionIsCurrent(state, payload)) {
+    return state
+  } else {
+    return state.clear()
+  }
+}
+
+const updateQuizSessionStatusOnPageLoad = (state, payload) => {
+  return state.set('quizSessionStatusOnPageLoad', payload.quizSessionStatusOnPageLoad)
+}
+
+const setCurrentSessionItemPosition = (state, payload) => {
+  return state
+    .set('currentSessionItemPosition', payload.position)
+    .set('focusCurrentSessionItem', true)
+}
+
+const clearFocusCurrentSessionItem = (state, payload) => {
+  return state.set('focusCurrentSessionItem', false)
+}
+
+const previousQuestion = (state, payload) => {
+  const currentPosition = state.get('currentSessionItemPosition')
+  return state.set('currentSessionItemPosition', currentPosition - 1)
+}
+
+const backtrackingNextQuestion = (state, payload) => {
+  const currentPosition = state.get('currentSessionItemPosition', 1)
+  return state.set('currentSessionItemPosition', currentPosition + 1)
+}
+
+const updateIsTaking = (state, payload) => {
+  return state.set('isTaking', payload.isTaking)
+}
+
+const updateTimerInfo = (state, payload) => {
+  return state.mergeIn(['timerData'], payload)
+}
+
+const setWSToken = (state, payload) => {
+  return state.set('wsToken', payload?.wsToken)
+}
+
+const updateTimerMinimized = (state, payload) => {
+  return state.setIn(['timerData', 'timerMinimized'], payload.timerMinimized)
+}
+
+const getResponse = (payload, state) => {
+  return state.getIn(['responses', payload.position]) || defaultResponse(payload)
+}
+
+const mergeModifiedResponse = (state, payload) => {
+  const responseMap = Map([[payload.get('position'), payload]])
+  return state.mergeIn(['responses'], responseMap)
+}
+
+const modifyResponse = (state, payload) => {
+  const response = getResponse(payload, state)
+  const responseWithMods = response.merge(payload)
+  return mergeModifiedResponse(state, responseWithMods)
+}
+
+const loadResponses = (state, payload) => {
+  if (payload.length === 0) {
+    return state.set('responses', Map())
+  }
+  return payload.reduce(modifyResponse, state)
+}
+
+const markSessionStartedIdentifier = (state, payload) => {
+  const needsUpdate =
+    state.get('browserSessionId') !== payload.browserSessionId ||
+    state.get('ipAddress') !== payload.ipAddress
+
+  return needsUpdate
+    ? state.merge({
+        browserSessionId: payload.browserSessionId,
+        ipAddress: payload.ipAddress,
+      })
+    : state
+}
+
+const updateQuizSubmitFlag = (state, payload) => {
+  return state.set('submitFlag', payload.value)
+}
+
+const setFocusTitleAndInstructions = (state, payload) => {
+  return state.set('focusTitleAndInstructions', payload.status)
+}
+
+export default (state = Map(), action) => {
+  switch (action.type) {
+    // two types for event logging differentiation
+    case RESPONSE:
+    case PREVIEW_RESPONSE:
+      return modifyResponse(state, action.payload)
+    case ACTIVE_QUIZ_SESSION_CHANGE:
+      return activeQuizSessionChange(state, action.payload)
+    case PREVIOUS_QUESTION:
+      return previousQuestion(state, action.payload)
+    case BACKTRACKING_NEXT_QUESTION:
+      return backtrackingNextQuestion(state, action.payload)
+    case LOAD_RESUME_DATA:
+      return loadResponses(state, action.payload)
+    case SESSION_STARTED_OR_RESUMED_EVENT:
+      return markSessionStartedIdentifier(state, action.payload)
+    case UPDATE_IS_TAKING:
+      return updateIsTaking(state, action.payload)
+    case UPDATE_TIMER_MINIMIZED:
+      return updateTimerMinimized(state, action.payload)
+    case UPDATE_TIMER_INFO:
+      return updateTimerInfo(state, action.payload)
+    case SET_WS_TOKEN:
+      return setWSToken(state, action.payload)
+    case SET_CURRENT_SESSION_ITEM_POSITION:
+      return setCurrentSessionItemPosition(state, action.payload)
+    case CLEAR_FOCUS_CURRENT_SESSION_ITEM:
+      return clearFocusCurrentSessionItem(state, action.payload)
+    case UPDATE_QUIZ_SESSION_STATUS_ON_PAGE_LOAD:
+      return updateQuizSessionStatusOnPageLoad(state, action.payload)
+    case UPDATE_QUIZ_SUBMIT_FLAG:
+      return updateQuizSubmitFlag(state, action.payload)
+    case SET_FOCUS_TITLE_AND_INSTRUCTIONS:
+      return setFocusTitleAndInstructions(state, action.payload)
+    default:
+      return state
+  }
+}

package/src/common/reducers/ui.js

@@ -0,0 +1,40 @@
+import {fromJS} from 'immutable'
+
+import {
+  ACTIVE_BANK_CHANGE,
+  ACTIVE_BANK_ENTRY_CHANGE,
+  CLEAR_UI,
+  MERGE_UI,
+  SET_UI,
+  TOGGLE_UI,
+  OCCLUDE_QUIZ_ENTRIES,
+  LOADED_API_FEATURES,
+} from '@instructure/quiz-common/constants'
+
+const toggle = function (state, key) {
+  return state.update(key, value => !value)
+}
+
+const defaultState = fromJS({})
+export default (state = defaultState, action) => {
+  switch (action.type) {
+    case CLEAR_UI:
+      return state.delete(action.payload)
+    case MERGE_UI:
+      return state.mergeDeepIn([action.payload.key], action.payload.value)
+    case SET_UI:
+      return state.setIn([action.payload.key].flat(), action.payload.value)
+    case TOGGLE_UI:
+      return toggle(state, action.payload)
+    case OCCLUDE_QUIZ_ENTRIES:
+      return state.set('quizEntriesOccluded', action.payload)
+    case ACTIVE_BANK_CHANGE:
+      return state.set('activeBankId', action.payload)
+    case ACTIVE_BANK_ENTRY_CHANGE:
+      return state.set('activeBankEntryId', action.payload)
+    case LOADED_API_FEATURES:
+      return state.set('loadedApiFeatures', action.payload)
+    default:
+      return state
+  }
+}

package/src/common/reducers/upload.js

@@ -0,0 +1,30 @@
+import {fromJS} from 'immutable'
+
+import {
+  CLEAR_ALT_TEXT,
+  CLEAR_FILES,
+  FILE_RECEIVED,
+  FILE_UPLOAD_CALL,
+  FILE_UPLOAD_STATUS,
+  SET_ALT_TEXT,
+} from '@instructure/quiz-common/constants'
+
+export default (state = fromJS({}), action) => {
+  switch (action.type) {
+    case CLEAR_ALT_TEXT:
+      return state.delete('altText')
+    case CLEAR_FILES:
+      return state.delete('files')
+    case FILE_RECEIVED:
+      // TODO: Have an option for adding multiple files
+      return state.set('files', action.payload.file)
+    case FILE_UPLOAD_CALL:
+      return state.set('files', action.payload.file)
+    case FILE_UPLOAD_STATUS:
+      return state.set('status', action.payload.status)
+    case SET_ALT_TEXT:
+      return state.set('altText', action.payload.altText)
+    default:
+      return state
+  }
+}

package/src/common/selectors/__tests__/analyses.test.js

@@ -0,0 +1,95 @@
+import {fromJS} from 'immutable'
+import * as selectors from '../analyses'
+import {expect} from 'vitest'
+
+describe('analyses selector', () => {
+  const quizAnalysis = {id: 1}
+  const itemAnalyses = [{id: 1}, {id: 2}]
+  const fetchInProgress = true
+  const statusPollingInProgress = true
+  const generationInProgress = true
+  const analysisError = 'oh noes'
+
+  const state = {
+    analyses: fromJS({
+      quizAnalysis,
+      itemAnalyses,
+      fetchInProgress,
+      generationInProgress,
+      statusPollingInProgress,
+      analysisError,
+    }),
+  }
+
+  describe('getQuizAnalysis', () => {
+    it('returns quiz analysis from state', () => {
+      const retrieved = selectors.getQuizAnalysis(state)
+      expect(retrieved).toEqual(quizAnalysis)
+    })
+
+    it('defaults to undefined if not set in state', () => {
+      const retrieved = selectors.getQuizAnalysis({analyses: fromJS({})})
+      expect(retrieved).toBeUndefined()
+    })
+  })
+
+  describe('getItemAnalyses', () => {
+    it('returns item analyses from state', () => {
+      const retrieved = selectors.getItemAnalyses(state)
+      expect(retrieved).toEqual(itemAnalyses)
+    })
+
+    it('defaults to undefined if not set in state', () => {
+      const retrieved = selectors.getItemAnalyses({analyses: fromJS({})})
+      expect(retrieved).toBeUndefined()
+    })
+  })
+
+  describe('getFetchInProgress', () => {
+    it('returns fetch progression from state', () => {
+      const retrieved = selectors.getFetchInProgress(state)
+      expect(retrieved).toBe(fetchInProgress)
+    })
+
+    it('defaults to false if not set in state', () => {
+      const retrieved = selectors.getFetchInProgress({analyses: fromJS({})})
+      expect(retrieved).toBe(false)
+    })
+  })
+
+  describe('getStatusPollingInProgress', () => {
+    it('returns status polling progression from state', () => {
+      const retrieved = selectors.getStatusPollingInProgress(state)
+      expect(retrieved).toBe(statusPollingInProgress)
+    })
+
+    it('defaults to false if not set in state', () => {
+      const retrieved = selectors.getStatusPollingInProgress({analyses: fromJS({})})
+      expect(retrieved).toBe(false)
+    })
+  })
+
+  describe('getGenerationInProgress', () => {
+    it('returns generation progression from state', () => {
+      const retrieved = selectors.getGenerationInProgress(state)
+      expect(retrieved).toBe(generationInProgress)
+    })
+
+    it('defaults to false if not set in state', () => {
+      const retrieved = selectors.getGenerationInProgress({analyses: fromJS({})})
+      expect(retrieved).toBe(false)
+    })
+  })
+
+  describe('getAnalysisError', () => {
+    it('returns error from state', () => {
+      const retrieved = selectors.getAnalysisError(state)
+      expect(retrieved).toBe(analysisError)
+    })
+
+    it('defaults to undefined if not set in state', () => {
+      const retrieved = selectors.getAnalysisError({analyses: fromJS({})})
+      expect(retrieved).toBeUndefined()
+    })
+  })
+})

package/src/common/selectors/__tests__/calculator.test.js

@@ -0,0 +1,121 @@
+import {fromJS} from 'immutable'
+import * as calculator from '../calculator'
+import {setFakeStore} from '../../../../tests/util/fakeStore'
+import {expect} from 'vitest'
+
+// helper: merge plain top-level state with deep-merged Immutable slices
+const mergeState = (base, overrides) => {
+  const out = {...base}
+  for (const key of Object.keys(overrides)) {
+    out[key] = base[key] ? base[key].mergeDeep(fromJS(overrides[key])) : fromJS(overrides[key])
+  }
+  return out
+}
+
+describe('calculator selectors', () => {
+  const fakeState = {
+    quizSessions: fromJS({
+      activeQuizSessionId: '1',
+      1: {
+        oneAtATimeType: 'question',
+      },
+    }),
+    taking: fromJS({
+      currentSessionItemPosition: 3,
+    }),
+    sessionItems: fromJS({
+      1: {
+        position: 1,
+        quizSessionId: '1',
+        calculatorType: 'none',
+        id: '1',
+      },
+      2: {
+        position: 2,
+        quizSessionId: '1',
+        calculatorType: 'none',
+        id: '2',
+      },
+      3: {
+        position: 3,
+        quizSessionId: '1',
+        calculatorType: 'basic',
+        id: '3',
+      },
+      4: {
+        position: 4,
+        quizSessionId: '1',
+        calculatorType: 'none',
+        id: '4',
+      },
+      // calc in wrong session, should not interfere
+      5: {
+        position: 2,
+        quizSessionId: '2',
+        calculatorType: 'basic',
+        id: '5',
+      },
+    }),
+  }
+  describe('hasVisibleQuestionCalculator', () => {
+    describe('with calculator per question', () => {
+      describe('One question at a time', () => {
+        it('returns true when current question has calculator', () => {
+          setFakeStore(fakeState)
+
+          const result = calculator.hasVisibleQuestionCalculator(fakeState)
+
+          expect(result).toBe(true)
+        })
+
+        it('returns false when current question calculator state is "none"', () => {
+          const merged = mergeState(fakeState,{taking: {currentSessionItemPosition: 2}})
+          setFakeStore(merged)
+
+          const result = calculator.hasVisibleQuestionCalculator(merged)
+
+          expect(result).toBe(false)
+        })
+      })
+
+      describe('More than one question at a time', () => {
+        it('returns true when any question in current session has a calculator', () => {
+          const merged = mergeState(fakeState,{
+            quizSessions: {
+              activeQuizSessionId: '1',
+              1: {
+                oneAtATimeType: null,
+              },
+            },
+          })
+          setFakeStore(merged)
+
+          const result = calculator.hasVisibleQuestionCalculator(merged)
+
+          expect(result).toBe(true)
+        })
+
+        it('returns false when no questions in current session have a calculator', () => {
+          const merged = mergeState(fakeState,{
+            quizSessions: {
+              1: {
+                oneAtATimeType: null,
+              },
+            },
+            sessionItems: {
+              3: {
+                calculatorType: 'none',
+              },
+            },
+          })
+          setFakeStore(merged)
+          expect(merged.quizSessions.get('activeQuizSessionId')).toBe('1')
+
+          const result = calculator.hasVisibleQuestionCalculator(merged)
+
+          expect(result).toBe(false)
+        })
+      })
+    })
+  })
+})

package/src/common/selectors/__tests__/calls.test.js

@@ -0,0 +1,30 @@
+import {fromJS} from 'immutable'
+import {fileUploading} from '../calls'
+import {FILE_UPLOAD_URL_CALL, FILE_UPLOAD_CALL} from '@instructure/quiz-common/constants'
+import {expect} from 'vitest'
+
+describe('calls selectors', () => {
+  describe('fileUploading', () => {
+    it('returns true if either call has status calling', () => {
+      const state = {
+        calls: {
+          [FILE_UPLOAD_URL_CALL]: {requestStatus: 'calling'},
+          [FILE_UPLOAD_CALL]: {requestStatus: 'success'},
+        },
+      }
+
+      expect(fileUploading({calls: fromJS(state.calls)})).toBe(true)
+    })
+
+    it('returns false if neither call has status calling', () => {
+      const state = {
+        calls: {
+          [FILE_UPLOAD_URL_CALL]: {requestStatus: 'success'},
+          [FILE_UPLOAD_CALL]: {requestStatus: 'success'},
+        },
+      }
+
+      expect(fileUploading({calls: fromJS(state.calls)})).toBe(false)
+    })
+  })
+})

package/src/common/selectors/__tests__/config.test.js

@@ -0,0 +1,30 @@
+import jwt from 'jwt-simple'
+import {fromJS} from 'immutable'
+import {getConfigTokenScope} from '../config'
+import {expect} from 'vitest'
+
+describe('config selectors', () => {
+  describe('getConfigTokenScope', () => {
+    describe('with a valid userToken', () => {
+      const state = {
+        config: fromJS({
+          userToken: jwt.encode({scope: 'some.scope'}, 'some-secret'),
+        }),
+      }
+
+      it('returns the token scope', () => {
+        expect(getConfigTokenScope(state)).toBe('some.scope')
+      })
+    })
+
+    describe('without a valid userToken', () => {
+      const state = {
+        config: fromJS({}),
+      }
+
+      it('returns undefined without errors', () => {
+        expect(getConfigTokenScope(state)).toBeUndefined()
+      })
+    })
+  })
+})

package/src/common/selectors/__tests__/interactionTypes.test.js

@@ -0,0 +1,77 @@
+import {vi, expect} from 'vitest'
+
+vi.mock('../../util/featureCheck', () => ({
+  featureOn: () => false,
+  ifFeature: (_n, _w, without) => without,
+}))
+import {fromJS} from 'immutable'
+import {default as FillBlankInteractionType} from '@instructure/quiz-interactions/records/interactions/fill_blank'
+import {default as MultipleChoiceInteractionType} from '@instructure/quiz-interactions/records/interactions/multiple_choice'
+import {default as TrueFalseInteractionType} from '@instructure/quiz-interactions/records/interactions/true_false'
+import {getInteractionType, getInteractionTypes} from '../interactionTypes'
+
+// Must match everywhere else the interaction types redux selector is used or else tests will fail. This will be fixed
+// by switching to a less naive caching solution (i.e. reselect)
+const interactionTypes = {
+  1: {
+    defaultProperties: {},
+    getDefaultInteractionData: () => {},
+    getDefaultScoringData: () => {},
+    getReadableResponseText: () => {},
+    getRenderedResponse: () => {},
+    hideResultStem: false,
+    id: '1',
+    itemBody: 'Question Stem',
+    isSubjective: false,
+    rawName: 'Choice',
+    scoringAlgorithmDefault: null,
+    scoringAlgorithmOptions: [],
+    slug: 'choice',
+    translatedName: 'Multiple Choice',
+    userResponseTypeOptions: [],
+  },
+  2: {
+    defaultProperties: {},
+    getDefaultInteractionData: null,
+    getDefaultScoringData: null,
+    getRenderedResponse: () => {},
+    getReadableResponseText: () => {},
+    hideResultStem: false,
+    id: '2',
+    itemBody: 'Question Stem',
+    isSubjective: false,
+    rawName: 'True or False',
+    scoringAlgorithmDefault: null,
+    scoringAlgorithmOptions: [],
+    slug: 'true-false',
+    translatedName: null,
+    userResponseTypeOptions: [],
+  },
+  3: {id: '3', slug: 'fill-blank'},
+  4: {id: '4', slug: 'rich-fill-blank'},
+}
+
+const state = {
+  interactionTypes: fromJS(interactionTypes),
+}
+
+describe('interaction type selectors', () => {
+  it('getInteractionType returns the correct interaction type', () => {
+    expect(getInteractionType(state, '2')).toBeInstanceOf(TrueFalseInteractionType)
+  })
+
+  it('getInteractionTypes returns all of the interaction types', () => {
+    const interactionTypes = getInteractionTypes(state)
+    expect(interactionTypes.size).toBe(3)
+    expect(interactionTypes.get(0)).toBeInstanceOf(MultipleChoiceInteractionType)
+    expect(interactionTypes.get(1)).toBeInstanceOf(TrueFalseInteractionType)
+  })
+
+  it('excludes rich-fill-blank when rich_fill_blank is disabled', () => {
+    const interactionTypes = getInteractionTypes(state)
+    expect(interactionTypes.size).toBe(3)
+    expect(interactionTypes.get(0)).toBeInstanceOf(MultipleChoiceInteractionType)
+    expect(interactionTypes.get(1)).toBeInstanceOf(TrueFalseInteractionType)
+    expect(interactionTypes.get(2)).toBeInstanceOf(FillBlankInteractionType)
+  })
+})

package/src/common/selectors/__tests__/items.test.js

@@ -0,0 +1,37 @@
+import {fromJS} from 'immutable'
+import {TEMPORARY_ITEM_ID} from '@instructure/quiz-common/constants'
+import {getItemById} from '../items'
+import Item from '../../records/Item'
+import {expect} from 'vitest'
+
+const items = {
+  3: {id: '3', interactionType: '1', errors: {itemBody: ['Cannot be blank']}},
+  4: {id: '4', interactionType: '1'},
+  7: {id: '7', interactionType: '2'},
+  8: {id: '8', interactionType: '2'},
+}
+
+const state = {
+  items: fromJS(items),
+  modifications: fromJS({
+    items: {
+      [TEMPORARY_ITEM_ID]: {id: TEMPORARY_ITEM_ID, itemBody: 'the temp item'},
+    },
+  }),
+}
+
+describe('item selectors', () => {
+  describe('getItemById', () => {
+    it('returns the correct session item', () => {
+      const quizSessionResult = getItemById(state, '8')
+
+      const expected = Item.create(fromJS(items['8']))
+      expect(quizSessionResult.equals(expected)).toBe(true)
+    })
+
+    it('returns the temporary item if ID matches', () => {
+      const item = getItemById(state, TEMPORARY_ITEM_ID)
+      expect(item.itemBody).toBe('the temp item')
+    })
+  })
+})

package/src/common/selectors/__tests__/qtiImports.test.js

@@ -0,0 +1,24 @@
+import {fromJS} from 'immutable'
+import {getLatestQtiImportForParentWithType} from '../qtiImports'
+import QtiImport from '../../records/QtiImport'
+import {expect} from 'vitest'
+
+const qtiImports = {
+  1: {id: '1', status: 'completed', parentId: '1', parentType: 'Quiz'},
+  2: {id: '2', status: 'completed', parentId: '2', parentType: 'Bank'},
+  9: {id: '9', status: 'started', parentId: '1', parentType: 'Quiz'},
+  11: {id: '11', status: 'started', parentId: '2', parentType: 'Bank'},
+}
+
+const state = {
+  qtiImports: fromJS(qtiImports),
+}
+
+describe('qti import selectors', () => {
+  it('getLatestQtiImportForParentWithType returns the correct qti import', () => {
+    const qtiImport = getLatestQtiImportForParentWithType(state, '2', 'Bank')
+
+    const expected = QtiImport.create(fromJS(qtiImports['11']))
+    expect(qtiImport.equals(expected)).toBe(true)
+  })
+})

package/src/common/selectors/__tests__/quizSessionResults.test.js

@@ -0,0 +1,41 @@
+import {fromJS} from 'immutable'
+import {getQuizSessionResultById, getQuizSessionResultsByIds} from '../quizSessionResults'
+import QuizSessionResult from '../../records/QuizSessionResult'
+import {expect} from 'vitest'
+
+const quizSessionResults = {
+  1: {id: '1', fudgePoints: 2, score: '3'},
+  3: {id: '3', fudgePoints: 0, score: '5'},
+}
+
+const state = {
+  quizSessionResults: fromJS(quizSessionResults),
+}
+
+describe('quiz session results selectors', () => {
+  it('getQuizSessionResultById returns the correct session item', () => {
+    const quizSessionResult = getQuizSessionResultById(state, '1')
+
+    const expected = QuizSessionResult.create(fromJS(quizSessionResults['1']))
+    expect(quizSessionResult.equals(expected)).toBe(true)
+  })
+
+  describe('getQuizSessionResultsByIds', () => {
+    it('returns an empty collection without ids', () => {
+      const {size} = getQuizSessionResultsByIds(state)
+      expect(size).toBe(0)
+    })
+
+    it('returns the requested quiz session results for ids', () => {
+      const list = getQuizSessionResultsByIds(state, ['3', '1'])
+
+      expect(list.size).toBe(2)
+      expect(list.get(0).equals(QuizSessionResult.create(fromJS(quizSessionResults['3'])))).toBe(
+        true,
+      )
+      expect(list.get(1).equals(QuizSessionResult.create(fromJS(quizSessionResults['1'])))).toBe(
+        true,
+      )
+    })
+  })
+})