@instructure/quiz-core 22.16.1 → 22.18.0

package/src/common/util/__tests__/printUtils.test.js

@@ -0,0 +1,77 @@
+import {expect, vi} from 'vitest'
+import {ensureImagesLoaded, printWithCss} from '../printUtils'
+
+describe('printWithCss', () => {
+  const className = 'PRINT_WITH_CSS_TEST'
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.spyOn(window, 'print')
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    window.print.mockRestore()
+    document.querySelector('html').classList.remove(className)
+  })
+
+  describe('passing a css class', () => {
+    it('applies a css class to the html element', () => {
+      printWithCss(className, 500)
+
+      expect(document.querySelector('html').classList.contains(className)).toBe(true)
+    })
+
+    it('prints after timeout', () => {
+      const p = printWithCss(className, 500).then(() => {
+        expect(window.print).toHaveBeenCalled()
+      })
+
+      expect(window.print).not.toHaveBeenCalled()
+      vi.advanceTimersByTime(501)
+      return p
+    })
+
+    it('removes the css class from the html element after the timeout', () => {
+      const p = printWithCss(className, 500).then(() => {
+        expect(document.querySelector('html').classList.contains(className)).toBe(false)
+      })
+
+      expect(document.querySelector('html').classList.contains(className)).toBe(true)
+      vi.advanceTimersByTime(501)
+      return p
+    })
+  })
+
+  it('functions when no timeout is passed', () => {
+    const p = printWithCss(className).then(() => {
+      expect(document.querySelector('html').classList.contains(className)).toBe(false)
+      expect(window.print).toHaveBeenCalledTimes(1)
+    })
+
+    expect(document.querySelector('html').classList.contains(className)).toBe(true)
+    expect(window.print).not.toHaveBeenCalled()
+
+    vi.advanceTimersByTime()
+    return p
+  })
+
+  it('functions when no cssClass is passed', () => {
+    const p = printWithCss().then(() => {
+      expect(window.print).toHaveBeenCalledTimes(1)
+    })
+
+    expect(window.print).not.toHaveBeenCalled()
+    vi.advanceTimersByTime()
+    return p
+  })
+})
+
+describe('ensureImagesLoaded', () => {
+  it('resolves when broken images are present', () => {
+    document.body.innerHTML = '<img src="" alt="empty" /><img src="" alt="empty" />'
+
+    const promise = ensureImagesLoaded()
+    expect(promise).resolves.toBeDefined()
+  })
+})

package/src/common/util/__tests__/rceChecker.test.js

@@ -0,0 +1,34 @@
+import {expect, vi} from 'vitest'
+import {ensureRCEContentIsLoaded} from '../rceChecker'
+
+vi.mock('../mathRenderingUtils', () => ({
+  ensureMathIsReady: vi.fn(() => Promise.resolve()),
+  ensureMathRendered: vi.fn(() => Promise.resolve()),
+}))
+
+vi.mock('../printUtils', () => ({
+  ensureImagesLoaded: vi.fn(() => Promise.resolve()),
+}))
+
+const {ensureMathIsReady, ensureMathRendered} = await import('../mathRenderingUtils')
+const {ensureImagesLoaded} = await import('../printUtils')
+
+describe('ensureRCEContentIsLoaded', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('calls all functions', async () => {
+    await ensureRCEContentIsLoaded()
+
+    expect(ensureMathIsReady.mock.calls).toHaveLength(1)
+    expect(ensureMathRendered.mock.calls).toHaveLength(1)
+    expect(ensureImagesLoaded.mock.calls).toHaveLength(1)
+  })
+
+  it('returns a Promise', () => {
+    const result = ensureRCEContentIsLoaded()
+
+    expect(result).toBeInstanceOf(Promise)
+  })
+})

package/src/common/util/__tests__/renderAlerts.test.js

@@ -0,0 +1,33 @@
+import {expect, vi} from 'vitest'
+import ReactDOM from 'react-dom'
+import {fromJS} from 'immutable'
+
+import renderAlerts from '../renderAlerts'
+import Alerts from '../../components/alerts'
+
+describe('renderAlerts', () => {
+  const alert = document.createElement('div')
+  alert.setAttribute('role', 'alert')
+  alert.setAttribute('aria-live', 'assertive')
+
+  beforeEach(() => {
+    document.body.appendChild(alert)
+    vi.spyOn(ReactDOM, 'render')
+  })
+
+  afterEach(() => {
+    document.body.removeChild(alert)
+    ReactDOM.render.mockRestore()
+  })
+
+  it('renders Alerts into the dom', () => {
+    const store = {getState: () => fromJS({}), subscribe: () => () => {}, dispatch: () => {}}
+    renderAlerts(store)
+    expect(ReactDOM.render).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: expect.objectContaining({children: expect.objectContaining({type: Alerts})}),
+      }),
+      alert,
+    )
+  })
+})

package/src/common/util/__tests__/serializeEvent.test.js

@@ -0,0 +1,196 @@
+import serializeEvent from '../serializeEvent'
+import {RESPONSE, SESSION_STARTED_OR_RESUMED_EVENT} from '@instructure/quiz-common/constants'
+
+import fakeStore from '../../../../tests/util/minimalStore'
+import {setFakeStore, unsetFakeStore} from '../../../../tests/util/fakeStore'
+import {editResponse, sessionStartOrResumeEvent} from '../../actions/taking'
+
+describe('serializeEvent', () => {
+  // testrail test_id: C2954596, C2954597
+  const activeQuizSessionId = '3'
+  const fakeState = {
+    taking: {
+      browserSessionId: 'session_id_guid',
+    },
+    quizSessions: {
+      activeQuizSessionId,
+      [activeQuizSessionId]: {
+        accountUuid: 'accountUuid',
+        eventCreationToken: 'jwt_token',
+        id: activeQuizSessionId,
+        rootAccountUuid: 'somefakeduuid',
+      },
+    },
+  }
+
+  const store = fakeStore(fakeState)
+  beforeAll(() => {
+    setFakeStore(store.getState())
+  })
+
+  afterAll(() => {
+    unsetFakeStore()
+  })
+
+  describe(RESPONSE, () => {
+    describe('edit response', () => {
+      it('returns a well formed object', () => {
+        const sessionItem = {position: 1, getItem: () => ({id: '1'})}
+        const action = editResponse(sessionItem, 'bar')
+
+        const eventData = Object.assign({}, action.payload, {
+          browserSessionId: 'session_id_guid',
+          clientTimestamp: 'timestamp',
+        })
+        const serializedEvent = serializeEvent(action, store)
+
+        const expectedEvent = {
+          accountUuid: 'accountUuid',
+          eventCreationToken: 'jwt_token',
+          eventData,
+          eventType: RESPONSE,
+          quizSessionId: '3',
+          rootAccountUuid: 'somefakeduuid',
+        }
+
+        expect(Object.keys(serializedEvent).sort()).toEqual(Object.keys(expectedEvent).sort())
+        expect(serializedEvent).toHaveProperty('accountUuid', expectedEvent.accountUuid)
+        expect(serializedEvent).toHaveProperty('eventCreationToken')
+        expect(typeof serializedEvent.eventCreationToken).toBe('string')
+        expect(serializedEvent).toHaveProperty('eventType', expectedEvent.eventType)
+        expect(serializedEvent).toHaveProperty('quizSessionId', expectedEvent.quizSessionId)
+        expect(serializedEvent).toHaveProperty('rootAccountUuid', expectedEvent.rootAccountUuid)
+
+        expect(serializedEvent).toHaveProperty('eventData')
+        expect(typeof serializedEvent.eventData).toBe('object')
+        expect(serializedEvent.eventData).toHaveProperty(
+          'browserSessionId',
+          eventData.browserSessionId,
+        )
+        expect(serializedEvent.eventData).toHaveProperty('clientTimestamp')
+        expect(serializedEvent.eventData.clientTimestamp).toBeInstanceOf(Date)
+        expect(serializedEvent.eventData).toHaveProperty('userResponse', eventData.userResponse)
+        expect(serializedEvent.eventData).toHaveProperty('itemId', eventData.itemId)
+        expect(serializedEvent.eventData).toHaveProperty('position', eventData.position)
+      })
+    })
+  })
+
+  describe(SESSION_STARTED_OR_RESUMED_EVENT, () => {
+    describe('start a new taking session (or resume)', () => {
+      it('returns a well formed object', () => {
+        const userAgent = 'userAgent'
+        const action = sessionStartOrResumeEvent(userAgent)
+
+        const serializedEvent = serializeEvent(action, store)
+
+        const expectedEvent = {
+          accountUuid: 'accountUuid',
+          eventCreationToken: 'jwt_token',
+          eventData: {
+            browserSessionId: 'session_id_guid',
+            userAgent,
+          },
+          eventType: SESSION_STARTED_OR_RESUMED_EVENT,
+          quizSessionId: '3',
+          rootAccountUuid: 'somefakeduuid',
+        }
+
+        expect(Object.keys(serializedEvent).sort()).toEqual(Object.keys(expectedEvent).sort())
+        expect(serializedEvent).toHaveProperty('accountUuid', expectedEvent.accountUuid)
+        expect(serializedEvent).toHaveProperty('eventCreationToken')
+        expect(typeof serializedEvent.eventCreationToken).toBe('string')
+        expect(serializedEvent).toHaveProperty('eventType', expectedEvent.eventType)
+        expect(serializedEvent).toHaveProperty('quizSessionId', expectedEvent.quizSessionId)
+        expect(serializedEvent).toHaveProperty('rootAccountUuid', expectedEvent.rootAccountUuid)
+
+        expect(serializedEvent).toHaveProperty('eventData')
+        expect(typeof serializedEvent.eventData).toBe('object')
+        expect(serializedEvent.eventData).toHaveProperty('userAgent')
+        expect(typeof serializedEvent.eventData.userAgent).toBe('string')
+        expect(serializedEvent.eventData).toHaveProperty('browserSessionId', 'session_id_guid')
+        expect(serializedEvent.eventData).toHaveProperty('clientTimestamp')
+        expect(serializedEvent.eventData.clientTimestamp).toBeInstanceOf(Date)
+      })
+    })
+  })
+})
+
+describe('serializeEvent session lock', () => {
+  const activeQuizSessionId = '3'
+  const fakeState = {
+    taking: {
+      browserSessionId: 'session_id_guid',
+    },
+    quizSessions: {
+      activeQuizSessionId,
+      [activeQuizSessionId]: {
+        accountUuid: 'accountUuid',
+        eventCreationToken: 'jwt_token',
+        id: activeQuizSessionId,
+        rootAccountUuid: 'somefakeduuid',
+      },
+    },
+  }
+
+  const store = fakeStore(fakeState)
+  const storeWithFeature = fakeStore({...fakeState, features: ['detect_multiple_sessions']})
+
+  describe('when detect_multiple_sessions feature is enabled', () => {
+    beforeEach(() => {
+      setFakeStore(storeWithFeature.getState())
+    })
+
+    afterEach(() => {
+      sessionStorage.clear()
+      localStorage.clear()
+      unsetFakeStore()
+    })
+
+    it('includes sessionLock when feature flag is enabled and lock exists in local storage', () => {
+      sessionStorage.setItem('currentParticipantSessionId', 'session-1')
+      localStorage.setItem('sessionLocks', JSON.stringify({'session-1': 'lock-token-123'}))
+
+      const sessionItem = {position: 1, getItem: () => ({id: '1'})}
+      const action = editResponse(sessionItem, 'test response')
+
+      const serializedEvent = serializeEvent(action, storeWithFeature)
+
+      expect(serializedEvent.eventData).toHaveProperty('sessionLock', 'lock-token-123')
+    })
+
+    it('sets sessionLock to null when feature flag is enabled but lock does not exist', () => {
+      sessionStorage.setItem('currentParticipantSessionId', 'session-1')
+
+      const sessionItem = {position: 1, getItem: () => ({id: '1'})}
+      const action = editResponse(sessionItem, 'test response')
+
+      const serializedEvent = serializeEvent(action, storeWithFeature)
+
+      expect(serializedEvent.eventData).toHaveProperty('sessionLock', null)
+    })
+  })
+
+  describe('when detect_multiple_sessions feature is disabled', () => {
+    beforeEach(() => {
+      setFakeStore(store.getState())
+    })
+
+    afterEach(() => {
+      sessionStorage.clear()
+      localStorage.clear()
+      unsetFakeStore()
+    })
+
+    it('does not include sessionLock when feature flag is disabled', () => {
+      sessionStorage.setItem('currentParticipantSessionId', 'session-1')
+      localStorage.setItem('sessionLocks', JSON.stringify({'session-1': 'lock-token-123'}))
+
+      const sessionItem = {position: 1, getItem: () => ({id: '1'})}
+      const action = editResponse(sessionItem, 'test response')
+      const serializedEvent = serializeEvent(action, store)
+
+      expect(serializedEvent.eventData).not.toHaveProperty('sessionLock')
+    })
+  })
+})

package/src/common/util/__tests__/sessionStore.test.js

@@ -0,0 +1,45 @@
+import {expect, vi} from 'vitest'
+import {SessionStore} from '../sessionStore'
+
+describe('SessionStore', () => {
+  describe('with a storage that raises on set', () => {
+    const errorOnSetStorage = {
+      set: () => {
+        throw new Error('no!')
+      },
+    }
+
+    it('is not enabled', () => {
+      const sessionStore = new SessionStore(errorOnSetStorage)
+      expect(sessionStore.enabled).toBe(false)
+    })
+  })
+
+  describe('with a storage that can be set', () => {
+    let setValue
+    const removeStub = vi.fn()
+    const setableStorage = {
+      setItem: (key, value) => {
+        setValue = value
+      },
+      getItem: () => {
+        return setValue
+      },
+      removeItem: removeStub,
+    }
+    const sessionStore = new SessionStore(setableStorage)
+
+    it('is enabled', () => {
+      expect(sessionStore.enabled).toBe(true)
+    })
+
+    describe('value is empty', () => {
+      it('removes the stored value', () => {
+        const key = 'key'
+        removeStub.mockClear()
+        sessionStore.set(key)
+        expect(removeStub).toHaveBeenCalledWith(key)
+      })
+    })
+  })
+})

package/src/common/util/__tests__/valMap.test.js

@@ -0,0 +1,22 @@
+import {fromJS} from 'immutable'
+import values from 'lodash/values'
+import valMap from '../valMap'
+import {expect} from 'vitest'
+
+describe('valMap', () => {
+  it('applies the given function to the values of a hash without mutation', () => {
+    const someHash = {1: 'a', 2: 'b', 3: 'c'}
+    const testFn = s => {
+      return s.toUpperCase()
+    }
+
+    const mappedHash = valMap(someHash, testFn)
+    const mappedVals = values(mappedHash)
+    // check for function application
+    expect(fromJS(mappedVals)).toEqual(fromJS(['A', 'B', 'C']))
+
+    // check for no mutation
+    const originalVals = values(someHash)
+    expect(fromJS(originalVals)).toEqual(fromJS(['a', 'b', 'c']))
+  })
+})

package/src/common/util/__tests__/windowChecks.test.js

@@ -0,0 +1,48 @@
+import {expect, vi} from 'vitest'
+import {media, onPhone, onTablet} from '../windowChecks'
+
+describe('windowChecks', () => {
+  const phoneQueryString = media['phone-break-point']
+  const tabletQueryString = media['tablet-break-point']
+  const matchingReturn = {matches: true}
+  const notMatchingReturn = {matches: false}
+  const windowMatching = matches => {
+    const matchMediaStub = vi.fn(query => {
+      if (query === phoneQueryString) return matches.phone ? matchingReturn : notMatchingReturn
+      if (query === tabletQueryString) return matches.tablet ? matchingReturn : notMatchingReturn
+      return notMatchingReturn
+    })
+    return {matchMedia: matchMediaStub}
+  }
+
+  describe('onPhone', () => {
+    it('returns true if window matches with phone break point query string', () => {
+      const fakeWindow = windowMatching({phone: true})
+      const isOnPhone = onPhone(fakeWindow)
+      expect(isOnPhone).toBe(true)
+    })
+    it('returns false if window does not match phone break point query string', () => {
+      const fakeWindow = windowMatching({phone: false})
+      const isOnPhone = onPhone(fakeWindow)
+      expect(isOnPhone).toBe(false)
+    })
+  })
+
+  describe('onTablet', () => {
+    it('returns true if window matches tablet query string and not phone query string', () => {
+      const fakeWindow = windowMatching({phone: false, tablet: true})
+      const isOnTablet = onTablet(fakeWindow)
+      expect(isOnTablet).toBe(true)
+    })
+    it('returns false if window matches phone query string and tablet query string', () => {
+      const fakeWindow = windowMatching({phone: true, tablet: true})
+      const isOnTablet = onTablet(fakeWindow)
+      expect(isOnTablet).toBe(false)
+    })
+    it('returns false if window matches neither phone or tablet query string', () => {
+      const fakeWindow = windowMatching({phone: false, tablet: false})
+      const isOnTablet = onTablet(fakeWindow)
+      expect(isOnTablet).toBe(false)
+    })
+  })
+})

package/src/common/util/__tests__/withCachedArguments.test.js

@@ -0,0 +1,53 @@
+import {expect, vi} from 'vitest'
+import withCachedArguments from '../withCachedArguments'
+
+describe('withCachedArguments', () => {
+  const stub = vi.fn()
+
+  class TestObject {
+    @withCachedArguments
+    myMethod(arg1, arg2) {
+      stub.call()
+      return arg1.value + arg2.value
+    }
+  }
+  let testObject
+
+  beforeEach(() => {
+    testObject = new TestObject()
+  })
+
+  afterEach(() => {
+    stub.mockClear()
+  })
+
+  it('calls through to the original method', () => {
+    const obj1 = {value: 1}
+    const obj2 = {value: 2}
+    expect(testObject.myMethod(obj1, obj2)).toBe(3)
+  })
+
+  it('caches results of previously seen arguments', () => {
+    const obj1 = {value: 1}
+    const obj2 = {value: 2}
+    testObject.myMethod(obj1, obj2)
+    expect(testObject.myMethod(obj1, obj2)).toBe(3)
+    expect(stub.mock.calls.length).toBe(1)
+  })
+
+  it('calls the original method more times for cache misses', () => {
+    const obj1 = {value: 1}
+    const obj2 = {value: 2}
+    testObject.myMethod(obj1, obj2)
+    expect(testObject.myMethod(obj2, obj1)).toBe(3)
+    expect(stub.mock.calls.length).toBe(2)
+  })
+
+  it('blows up if too many or too few arguments were provided', () => {
+    const obj1 = {value: 1}
+    const obj2 = {value: 2}
+    const obj3 = {value: 3}
+    expect(() => testObject.myMethod(obj1)).toThrow()
+    expect(() => testObject.myMethod(obj1, obj2, obj3)).toThrow()
+  })
+})

package/src/common/util/__tests__/withDynamoPagination.test.js

@@ -0,0 +1,95 @@
+import {expect, vi} from 'vitest'
+import withDynamoPagination from '../withDynamoPagination'
+
+describe('withDynamoPagination', () => {
+  class Klazz {}
+  const PaginatedKlazz = withDynamoPagination(Klazz)
+
+  it('exports a function', () => {
+    expect(withDynamoPagination).toBeTypeOf('function')
+  })
+
+  it('returns a function', () => {
+    expect(PaginatedKlazz).toBeTypeOf('function')
+  })
+
+  it('returns a function that is bound to the correct prototype chains', () => {
+    expect(Object.getPrototypeOf(PaginatedKlazz)).toBe(Klazz)
+    expect(Object.getPrototypeOf(PaginatedKlazz.prototype)).toBe(Klazz.prototype)
+  })
+
+  it('assigns a default "pass thru" asyncResponseHandler instance method', () => {
+    const instance = new PaginatedKlazz()
+    const double = {}
+    expect(instance.asyncResponseHandler(double)).toBe(double)
+  })
+
+  describe('paginatedGet', () => {
+    it('is an available method', () => {
+      const instance = new PaginatedKlazz()
+      expect(instance.paginatedGet).toBeTypeOf('function')
+    })
+
+    it('returns a promise', () => {
+      const responseDouble = {
+        json() {
+          return Promise.resolve({})
+        },
+        headers: {get() {}},
+      }
+
+      const instance = new PaginatedKlazz()
+      instance.get = () => Promise.resolve(responseDouble)
+      instance.dispatch = () => {}
+
+      expect(instance.paginatedGet('lol', {actionCreator() {}})).toBeInstanceOf(Promise)
+    })
+
+    it('captures async errors for ancillary work and rejects appropriately', () => {
+      const responseDouble = {
+        json() {
+          return Promise.resolve({})
+        },
+        headers: {get() {}},
+      }
+
+      const instance = new PaginatedKlazz()
+      instance.get = () => Promise.resolve(responseDouble)
+      instance.dispatch = vi.fn().mockImplementation(() => {
+        throw new Error('oops!')
+      })
+
+      return instance.paginatedGet('zomg', {actionCreator() {}}).catch(err => {
+        expect(instance.dispatch.mock.calls.length).toBe(1)
+        expect(err.message).toBe('oops!')
+      })
+    })
+
+    it('fetches so long as pagination headers are available, resolves with responses', () => {
+      const callCounts = {}
+      const get = vi.fn(key => {
+        callCounts[key] = (callCounts[key] || 0) + 1
+        if (callCounts[key] <= 1) return 'lol'
+        if (callCounts[key] <= 2) return 'wut'
+        return undefined
+      })
+
+      const responseDouble = {
+        json() {
+          return Promise.resolve({})
+        },
+        headers: {get},
+      }
+
+      const instance = new PaginatedKlazz()
+      instance.get = () => Promise.resolve(responseDouble)
+      instance.dispatch = vi.fn()
+
+      return instance.paginatedGet('zomg', {actionCreator() {}}).then(result => {
+        expect(result).toEqual([responseDouble, responseDouble, responseDouble])
+        expect(get.mock.calls.length).toBe(6)
+        expect(instance.dispatch.mock.calls.length).toBe(3)
+      })
+    })
+  })
+})