@instructure/quiz-core 22.16.1 → 22.18.0

package/src/common/kinesis/__tests__/StreamQueue.test.js

@@ -0,0 +1,47 @@
+import {expect, vi} from 'vitest'
+import StreamQueue from '../StreamQueue'
+import {fakeKinesisClientCreator, fakeStreamConfigCreator} from './kinesisTests'
+
+describe('StreamQueue', () => {
+  const config = fakeStreamConfigCreator()
+  const kinesis = fakeKinesisClientCreator()
+  let subject = null
+
+  beforeEach(() => {
+    subject = new StreamQueue({config, kinesis})
+  })
+
+  it('accepts new events', () => {
+    expect(subject.push('EVENT', {})).toBe(true)
+  })
+
+  it('sends to kinesis when a page is full', () => {
+    kinesis.putRecords = vi.fn()
+    expect(kinesis.putRecords).not.toHaveBeenCalled()
+    subject.push('EVENT', {})
+    subject.push('EVENT', {})
+    subject.push('EVENT', {})
+    subject.push('EVENT', {})
+    expect(kinesis.putRecords).not.toHaveBeenCalled()
+    subject.push('EVENT', {})
+    // Page limit here is 5, don't expect an event until it is hit
+    expect(kinesis.putRecords).toHaveBeenCalled()
+  })
+
+  it('requires a known type of event', () => {
+    expect(() => subject.push('NOT_A_KNOWN_EVENT_TYPE', {})).toThrow()
+  })
+
+  describe('page size of 1', () => {
+    beforeEach(() => {
+      subject.config = {...config, maxPageSize: 1}
+    })
+
+    it('sends events to kinesis immediately', () => {
+      kinesis.putRecords = vi.fn()
+      subject.push('EVENT', {})
+      subject.push('EVENT', {})
+      expect(kinesis.putRecords).toHaveBeenCalledTimes(2)
+    })
+  })
+})

package/src/common/kinesis/__tests__/client.test.js

@@ -0,0 +1,106 @@
+import {expect, vi} from 'vitest'
+import {Credentials, config} from 'aws-sdk/global'
+import Kinesis from 'aws-sdk/clients/kinesis'
+import getKinesisConfig, {
+  buildCredentials,
+  buildKinesisClient,
+  buildKinesisConfiguration,
+} from '../client'
+
+describe('kinesis client helper', () => {
+  const fakeCreds = {
+    access_key_id: 'id',
+    expiration: 4000,
+    secret_access_key: 'secret',
+    session_token: 'token',
+  }
+
+  const fakeConfiguration = {
+    stream_identifiers: {
+      events: 'hi',
+      responses: 'bye',
+    },
+    server_time: Date.now(),
+  }
+
+  const fakeResponse = {
+    credentials: fakeCreds,
+    ...fakeConfiguration,
+  }
+
+  const credentials = buildCredentials(fakeCreds)
+
+  describe('buildCredentials', () => {
+    it('builds a credential', () => {
+      expect(credentials).toBeInstanceOf(Credentials)
+      expect(credentials.expireTime).toBe(Date.parse(fakeCreds.expiration))
+    })
+  })
+
+  describe('buildKinesisConfiguration', () => {
+    describe('creates global aws offset', () => {
+      it('works with client time > server time', () => {
+        const frozenNow = 1000000
+        const dateNowSpy = vi.spyOn(Date, 'now').mockReturnValue(frozenNow)
+        const configWithOffset = Object.assign({}, fakeConfiguration, {
+          server_time: new Date(frozenNow - 1000),
+        })
+        buildKinesisConfiguration({configuration: configWithOffset, credentials})
+        expect(config.systemClockOffset).toBe(-1000)
+        dateNowSpy.mockRestore()
+      })
+
+      it('works with client time < server time', () => {
+        const frozenNow = 1000000
+        const dateNowSpy = vi.spyOn(Date, 'now').mockReturnValue(frozenNow)
+        const configWithOffset = Object.assign({}, fakeConfiguration, {
+          server_time: new Date(frozenNow + 1000),
+        })
+        buildKinesisConfiguration({configuration: configWithOffset, credentials})
+        expect(config.systemClockOffset).toBe(1000)
+        dateNowSpy.mockRestore()
+      })
+    })
+
+    const kinesisConfig = buildKinesisConfiguration({configuration: fakeConfiguration, credentials})
+    it('returns a kinesisClient', () => {
+      expect(kinesisConfig.client).toBeInstanceOf(Kinesis)
+    })
+
+    it('returns some streamConfigs', () => {
+      expect(kinesisConfig.streamConfigs.length).toBe(2)
+    })
+  })
+
+  describe('buildKinesisClient', () => {
+    const client = buildKinesisClient({}, credentials)
+    it('builds a kinesis client', () => {
+      expect(client).toBeInstanceOf(Kinesis)
+    })
+  })
+
+  describe('getKinesisConfig', () => {
+    const fakeResolver = value => {
+      return {
+        then: function (callback) {
+          callback(value)
+        },
+      }
+    }
+    const fakeFetcher = {
+      post: vi.fn().mockReturnValue(fakeResolver(fakeResponse)),
+    }
+
+    it('calls for credentials for new data', () => {
+      getKinesisConfig('1', fakeFetcher)
+      expect(fakeFetcher.post).toHaveBeenCalled()
+    })
+
+    it('returns a kinesis client', () => {
+      const responsePromise = getKinesisConfig('1', fakeFetcher)
+      return responsePromise.then(config => {
+        expect(config.client).toBeInstanceOf(Kinesis)
+      })
+    })
+  })
+})

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

@@ -0,0 +1,4 @@
+// Vitest: empty test file placeholder
+describe('kinesis config', () => {
+  it.skip('no tests yet', () => {})
+})

package/src/common/kinesis/__tests__/eventTypes.test.js

@@ -0,0 +1,62 @@
+import * as eventTypes from '../eventTypes'
+import {expect} from 'vitest'
+
+const {RESPONSE, ...otherEvents} = eventTypes
+
+const fakeData = {
+  accountUuid: 'uuid',
+  eventCreationToken: 'jwt_token',
+  quizSessionId: '1',
+}
+
+const fakeResponseData = Object.assign({}, fakeData, {
+  eventData: {
+    itemId: 'item_1',
+    position: 'position_1',
+    userResponse: 'response_1',
+  },
+})
+
+function testGenericEvent(type, data) {
+  it('has the correct root-level keys', () => {
+    expect(data).toEqual(
+      expect.objectContaining({Data: expect.anything(), PartitionKey: expect.anything()}),
+    )
+    expect(data.PartitionKey).toBe(`${fakeData.quizSessionId}|${fakeData.accountUuid}`)
+  })
+
+  it('has the correct payload', () => {
+    expect(JSON.parse(data.Data)).toEqual(
+      expect.objectContaining({
+        created_at: expect.anything(),
+        event_creation_token: expect.anything(),
+      }),
+    )
+  })
+}
+
+describe('eventTypes', () => {
+  Object.keys(otherEvents).forEach(type => {
+    const data = otherEvents[type](fakeData)
+    describe(type, () => {
+      testGenericEvent(type, data)
+    })
+  })
+
+  describe(RESPONSE.name, () => {
+    const data = RESPONSE(fakeResponseData)
+
+    testGenericEvent(RESPONSE, data)
+
+    it('modifies the payload correctly', () => {
+      expect(JSON.parse(data.Data)).toEqual(
+        expect.objectContaining({
+          event_data: expect.anything(),
+          item_id: expect.anything(),
+          position: expect.anything(),
+          user_response: expect.anything(),
+        }),
+      )
+    })
+  })
+})

package/src/common/kinesis/__tests__/kinesisTests.js

@@ -0,0 +1,44 @@
+import Kinesis from 'aws-sdk/clients/kinesis'
+import {Credentials} from 'aws-sdk/global'
+
+import StreamQueue from '../StreamQueue'
+
+export const numRecords = stream => {
+  return 1
+}
+
+export const fakeKinesisConfigCreator = (config = null) => {
+  return {
+    client: fakeKinesisClientCreator(),
+    streamConfigs: [fakeStreamConfigCreator()],
+  }
+}
+
+export const fakeKinesisClientCreator = (config = null) => {
+  const kinesisConfig = config || {
+    apiVersion: '2013-12-02',
+    region: 'us-west-2',
+    endpoint: 'kinesis.docker',
+    credentials: new Credentials('accessKeyId', 'secretAccessKey', 'sessionToken'),
+    client_configuration: {},
+  }
+
+  return new Kinesis(kinesisConfig)
+}
+
+export const fakeStreamConfigCreator = (config = {}) => {
+  return {
+    eventTypes: {EVENT: () => {}, PAGE_FOCUSED_EVENT: () => {}, PAGE_BLURRED_EVENT: () => {}},
+    maxPageSize: 5, // max number events sent at once
+    sendRecordsTimeout: 1000, // in milliseconds
+    stream: 'KinesisResponsesStreamName',
+    whiny: true,
+  }
+}
+
+export const fakeStreamQueueCreator = (
+  kinesis = fakeKinesisClientCreator(),
+  config = fakeStreamConfigCreator(),
+) => {
+  return new StreamQueue({config, kinesis})
+}

package/src/common/kinesis/client.js

@@ -0,0 +1,53 @@
+import {Credentials, config} from 'aws-sdk/global'
+import Kinesis from 'aws-sdk/clients/kinesis'
+import {safeDateParse} from '@instructure/quiz-common/safeDateParse'
+import {assembleKinesisConfig, assembleStreamConfigs} from './config'
+
+export const buildKinesisConfiguration = ({configuration, credentials}) => {
+  const serverTime = configuration.server_time
+  if (serverTime) config.systemClockOffset = safeDateParse(serverTime) - Date.now()
+  return {
+    client: buildKinesisClient(configuration, credentials),
+    proxyDomain: configuration.proxy_domain,
+    streamConfigs: assembleStreamConfigs(configuration),
+  }
+}
+
+export const buildKinesisClient = (configuration, credentials) => {
+  const kinesisConfig = Object.assign(
+    {},
+    assembleKinesisConfig(configuration.client_configuration),
+    {credentials},
+  )
+
+  return new Kinesis(kinesisConfig)
+}
+
+export const buildCredentials = credentialParams => {
+  const creds = new Credentials(
+    credentialParams.access_key_id,
+    credentialParams.secret_access_key,
+    credentialParams.session_token, // credentialParams
+  )
+  creds.expireTime = safeDateParse(credentialParams.expiration)
+  return creds
+}
+
+const getKinesisConfig = function (quizSessionId, fetcher) {
+  return new Promise((resolve, reject) => {
+    const url = `/api/quiz_sessions/${quizSessionId}/kinesis_credentials`
+    fetcher
+      .post(url)
+      .then(configuration => {
+        const config = buildKinesisConfiguration({
+          configuration,
+          credentials: buildCredentials(configuration.credentials),
+        })
+
+        resolve(config)
+      })
+      .then(err => reject(err))
+  })
+}
+
+export default getKinesisConfig

package/src/common/kinesis/config.js

@@ -0,0 +1,51 @@
+import {
+  EVENT_RESPONSE,
+  QUIZ_SUBMISSION_EVENT,
+  RESPONSE,
+  SESSION_STARTED_OR_RESUMED_EVENT,
+  RCE_EVENT,
+  PAGE_BLURRED_EVENT,
+  PAGE_FOCUSED_EVENT,
+} from './eventTypes'
+
+export const assembleKinesisConfig = apiConfig => {
+  return Object.assign({apiVersion: '2013-12-02'}, apiConfig)
+}
+
+// We don't really want to delay sending events for this queue.
+export const responseStreamConfig = (defaultStreamConfig, stream) => {
+  return Object.assign({}, defaultStreamConfig, {
+    eventTypes: {RESPONSE},
+    maxPageSize: 1,
+    stream,
+  })
+}
+
+export const eventStreamConfig = (defaultStreamConfig, stream) => {
+  return Object.assign({}, defaultStreamConfig, {
+    eventTypes: {
+      RESPONSE: EVENT_RESPONSE,
+      SESSION_STARTED_OR_RESUMED_EVENT,
+      QUIZ_SUBMISSION_EVENT,
+      RCE_EVENT,
+      PAGE_BLURRED_EVENT,
+      PAGE_FOCUSED_EVENT,
+    },
+    stream,
+  })
+}
+
+export const assembleStreamConfigs = config => {
+  const defaultStreamConfig = Object.assign(
+    {
+      maxPageSize: 25, // max number events sent at once
+      sendRecordsTimeout: 5000, // in milliseconds
+    },
+    config.stream_configuration,
+  )
+
+  return [
+    eventStreamConfig(defaultStreamConfig, config.stream_identifiers.events),
+    responseStreamConfig(defaultStreamConfig, config.stream_identifiers.responses),
+  ]
+}

package/src/common/kinesis/eventTypes.js

@@ -0,0 +1,43 @@
+import {decamelizeKeys} from 'humps'
+
+function eventType(eventTransform = data => data) {
+  return function (data) {
+    const {quizSessionId, accountUuid} = data
+
+    const createdAt = `${new Date().toISOString()}|${window.performance.now()}`
+    const quizSessionKey = `${quizSessionId}|${accountUuid}`
+
+    const serializedData = JSON.stringify(
+      decamelizeKeys(Object.assign(eventTransform(data), {createdAt})),
+    )
+
+    // AWS-SDK uses capitalized properties :\
+    return {
+      Data: serializedData,
+      PartitionKey: quizSessionKey,
+    }
+  }
+}
+
+export const RESPONSE = eventType(data => {
+  // The resume (response_events) stream doesn't care about eventData contents
+  // Clean them up!
+
+  // Required to prevent modification of the source data
+  const adjustedData = Object.assign({}, data)
+  adjustedData.eventData = Object.assign({}, data.eventData)
+
+  'position userResponse itemId'.split(' ').forEach(prop => {
+    adjustedData[prop] = adjustedData.eventData[prop]
+    delete adjustedData.eventData[prop]
+  })
+
+  return adjustedData
+})
+
+export const EVENT_RESPONSE = eventType()
+export const SESSION_STARTED_OR_RESUMED_EVENT = eventType()
+export const QUIZ_SUBMISSION_EVENT = eventType()
+export const RCE_EVENT = eventType()
+export const PAGE_BLURRED_EVENT = eventType()
+export const PAGE_FOCUSED_EVENT = eventType()

package/src/common/middleware/__tests__/alertTimerMiddleware.test.js

@@ -0,0 +1,46 @@
+import {expect, vi} from 'vitest'
+import alertTimerMiddleware from '../alertTimerMiddleware'
+import {ADD_ALERT} from '@instructure/quiz-common/constants'
+
+import {removeAlert} from '../../actions/alerts'
+
+const dispatchStub = vi.fn()
+const fakeStore = {
+  dispatch: dispatchStub,
+}
+
+describe('alertTimerMiddleware', () => {
+  it('sets a timeout to remove an alert', () => {
+    const timeToWait = 1000
+    const alertID = '12345'
+    const fakeAction = {type: ADD_ALERT, payload: {uuid: alertID, removeIn: timeToWait}}
+    const expectedAction = removeAlert(alertID)
+
+    const callSyncAndAssertTime = (fn, time) => {
+      fn()
+      expect(time).toBe(timeToWait)
+    }
+    alertTimerMiddleware(fakeStore)(() => {})(fakeAction, callSyncAndAssertTime)
+
+    expect(dispatchStub).toHaveBeenCalledWith(expectedAction)
+
+    dispatchStub.mockClear()
+  })
+
+  it('does not call the remove alert action if error variant is sticky', () => {
+    const timeToWait = 1000
+    const alertID = '12345'
+    const fakeAction = {
+      type: ADD_ALERT,
+      payload: {uuid: alertID, removeIn: timeToWait, variant: 'stickyError'},
+    }
+    const expectedAction = removeAlert(alertID)
+
+    const callRemoveAlertAction = () => {
+      expect(dispatchStub).not.toHaveBeenCalledWith(expectedAction)
+    }
+    alertTimerMiddleware(fakeStore)(() => {})(fakeAction, callRemoveAlertAction)
+
+    dispatchStub.mockClear()
+  })
+})

package/src/common/middleware/__tests__/eventLoggerMiddleware.test.js

@@ -0,0 +1,64 @@
+import {expect, vi} from 'vitest'
+import {fromJS} from 'immutable'
+
+import eventLoggerMiddlewareCreator from '../eventLoggerMiddleware'
+
+const fakeLoggerFetch = vi.fn().mockReturnValue({
+  then: () => {},
+})
+
+const createFakeStore = fakeData => ({
+  getState() {
+    return Object.fromEntries(
+      Object.entries({quizSessions: {}, ...fakeData}).map(([k, v]) => [k, fromJS(v)]),
+    )
+  },
+})
+
+const fakeSerializer = vi.fn()
+
+const fakeAction = {type: 'STRING'}
+
+const fakeDispatchWithDefaults = (storeData = {}, action, serializer = fakeSerializer) => {
+  let dispatched = null
+  const eventLoggerMiddleware = eventLoggerMiddlewareCreator(fakeLoggerFetch, serializer)
+
+  const fakeActionTrigger = actionAttempt => {
+    dispatched = actionAttempt
+    return actionAttempt
+  }
+
+  const dispatch = eventLoggerMiddleware(createFakeStore(storeData))(fakeActionTrigger)
+
+  dispatch(action)
+  return dispatched
+}
+
+describe('eventLoggerMiddleware', () => {
+  it('calls for the kinesis client when serializer returns data', () => {
+    fakeSerializer.mockReturnValue({})
+    fakeDispatchWithDefaults({}, fakeAction, fakeSerializer)
+    expect(fakeLoggerFetch).toHaveBeenCalled()
+    fakeLoggerFetch.mockClear()
+  })
+
+  it('does not call for kinesis client when serializer returns no data', () => {
+    fakeSerializer.mockReturnValue(null)
+    fakeDispatchWithDefaults({}, fakeAction, fakeSerializer)
+    expect(fakeLoggerFetch).not.toHaveBeenCalled()
+    fakeLoggerFetch.mockClear()
+  })
+
+  it('does not call loggerFetch when quizSessionId is null', () => {
+    fakeSerializer.mockReturnValue({})
+    // Provide a state where activeQuizSessionId is null so getActiveQuizSessionId returns null
+    fakeDispatchWithDefaults(
+      {quizSessions: {activeQuizSessionId: null}},
+      fakeAction,
+      fakeSerializer,
+    )
+    expect(fakeLoggerFetch).not.toHaveBeenCalled()
+
+    fakeLoggerFetch.mockClear()
+  })
+})

package/src/common/middleware/__tests__/persistedStorageMiddleware.test.js

@@ -0,0 +1,111 @@
+import {expect, vi} from 'vitest'
+import {fromJS} from 'immutable'
+
+import persistedStorageMiddlewareCreator from '../persistedStorageMiddleware'
+
+import {
+  ACTIVE_QUESTION,
+  CACHED_SESSION_ID,
+  ACTIVE_QUIZ_SESSION_CHANGE,
+  BACKTRACKING_NEXT_QUESTION,
+  PREVIOUS_QUESTION,
+  SET_CURRENT_SESSION_ITEM_POSITION,
+  PERSIST_PRINT_FONT_SIZE_PREFERENCE,
+  QUIZ_PRINT_FONT_SIZE_PREFERENCE,
+} from '@instructure/quiz-common/constants'
+
+describe('persistedStorageMiddleware', () => {
+  const stubNext = vi.fn()
+
+  const testNextAction = function (dispatch, action) {
+    it('returns the result of next(action)', () => {
+      stubNext.mockClear()
+      stubNext.mockReturnValue(action)
+      const returned = dispatch(action)
+      expect(stubNext).toHaveBeenCalledWith(action)
+      expect(returned).toBe(action)
+    })
+  }
+
+  describe('storing in local storage', () => {
+    const setStub = vi.fn()
+    const fakeLocalStore = {
+      enabled: true,
+      set: setStub,
+    }
+    const currentSessionItemPosition = 22
+    const activeQuizSessionId = '44'
+    const fontSizePreference = 'xLarge'
+    const fakeAppStore = {
+      getState: () => ({
+        taking: fromJS({currentSessionItemPosition}),
+        quizSessions: fromJS({activeQuizSessionId}),
+        printing: fromJS({fontSizePreference}),
+      }),
+    }
+    const persistedStorageMiddleware = persistedStorageMiddlewareCreator(void 0, fakeLocalStore)
+    const dispatch = persistedStorageMiddleware(fakeAppStore)(stubNext)
+
+    describe('action needs to persistTakingInfo', () => {
+      const checkTakingDataPersisted = type => {
+        describe(`action of type: ${type}`, () => {
+          it('saves activeQuizSessionId', () => {
+            const action = {type}
+            setStub.mockClear()
+            dispatch(action)
+            expect(setStub).toHaveBeenCalledWith(CACHED_SESSION_ID, activeQuizSessionId)
+          })
+
+          it('saves currentSessionItemPosition', () => {
+            const action = {type}
+            setStub.mockClear()
+            dispatch(action)
+            expect(setStub).toHaveBeenCalledWith(ACTIVE_QUESTION, currentSessionItemPosition)
+          })
+        })
+      }
+
+      const actionTypes = [
+        ACTIVE_QUIZ_SESSION_CHANGE,
+        BACKTRACKING_NEXT_QUESTION,
+        PREVIOUS_QUESTION,
+        SET_CURRENT_SESSION_ITEM_POSITION,
+      ]
+
+      actionTypes.forEach(checkTakingDataPersisted)
+    })
+
+    describe('action needs to persistPrintFonSizePreference', () => {
+      it('saves the font size preference', () => {
+        const action = {type: PERSIST_PRINT_FONT_SIZE_PREFERENCE}
+        dispatch(action)
+        expect(setStub).toHaveBeenCalledWith(QUIZ_PRINT_FONT_SIZE_PREFERENCE, fontSizePreference)
+      })
+    })
+  })
+
+  describe('storage is not enabled', () => {
+    const fakeSessionStore = {
+      enabled: false,
+    }
+    const fakeLocalStore = {
+      enable: false,
+    }
+    const persistedStorageMiddleware = persistedStorageMiddlewareCreator(
+      fakeSessionStore,
+      fakeLocalStore,
+    )
+    const dispatch = persistedStorageMiddleware()(stubNext)
+
+    testNextAction(dispatch)
+  })
+
+  describe('action type is unknown', () => {
+    const persistedStorageMiddleware = persistedStorageMiddlewareCreator()
+    const dispatch = persistedStorageMiddleware()(stubNext)
+
+    const dummyAction = {type: 'dummy action'}
+
+    testNextAction(dispatch, dummyAction)
+  })
+})