[BD-26][EDUCATOR-5791, EDUCATOR-5767] Add handling of exam API errors and support for js workers from provider

package.json

@@ -4,7 +4,9 @@
   "description": "Special exams lib",
   "main": "dist/index.js",
   "release": {
-    "branches": ["main"]
+    "branches": [
+      "main"
+    ]
   },
   "exports": {
     "import": "./dist/index.js"
@@ -65,6 +67,7 @@
     "@edx/frontend-build": "^5.6.11",
     "@edx/frontend-platform": "1.8.4",
     "@edx/paragon": "13.17.0",
+    "@testing-library/dom": "7.16.3",
     "@testing-library/jest-dom": "5.10.1",
     "@testing-library/react": "10.3.0",
     "axios-mock-adapter": "1.18.2",

src/constants.js

@@ -1,9 +1,12 @@
 /* eslint-disable import/prefer-default-export */
 export const ExamStatus = Object.freeze({
+  CREATED: 'created',
   STARTED: 'started',
   READY_TO_SUBMIT: 'ready_to_submit',
   SUBMITTED: 'submitted',
   TIMED_OUT: 'timed_out',
+  VERIFIED: 'verified',
+  REJECTED: 'rejected',
 });
 
 export const IS_STARTED_STATUS = (status) => [ExamStatus.STARTED, ExamStatus.READY_TO_SUBMIT].includes(status);

src/data/api.js

@@ -17,11 +17,12 @@ export async function pollExamAttempt(url) {
   return data;
 }
 
-export async function createExamAttempt(examId) {
+export async function createExamAttempt(examId, startClock = true, attemptProctored = false) {
   const url = new URL(`${getConfig().LMS_BASE_URL}${BASE_API_URL}`);
   const payload = {
     exam_id: examId,
-    start_clock: 'true',
+    start_clock: startClock.toString(),
+    attempt_proctored: attemptProctored.toString(),
   };
   const { data } = await getAuthenticatedHttpClient().post(url.href, payload);
   return data;
@@ -52,3 +53,9 @@ export async function submitAttempt(attemptId) {
 export async function endExamWithFailure(attemptId, error) {
   return updateAttemptStatus(attemptId, ExamAction.ERROR, error);
 }
+
+export async function fetchProctoringSettings(examId) {
+  const url = new URL(`${getConfig().LMS_BASE_URL}/api/edx_proctoring/v1/proctored_exam/settings/exam_id/${examId}/`);
+  const { data } = await getAuthenticatedHttpClient().get(url.href);
+  return data;
+}

src/data/index.js

@@ -1,11 +1,14 @@
 export {
   getExamAttemptsData,
+  getProctoringSettings,
   startExam,
+  startProctoringExam,
   stopExam,
   continueExam,
   submitExam,
   expireExam,
   pollAttempt,
+  pingAttempt,
 } from './thunks';
 
 export { default as store } from './store';

src/data/messages/constants.js

@@ -0,0 +1,25 @@
+const SUBMIT_MAP = Object.freeze({
+  promptEventName: 'endExamAttempt',
+  successEventName: 'examAttemptEnded',
+  failureEventName: 'examAttemptEndFailed',
+});
+
+const START_MAP = Object.freeze({
+  promptEventName: 'startExamAttempt',
+  successEventName: 'examAttemptStarted',
+  failureEventName: 'examAttemptStartFailed',
+});
+
+const PING_MAP = Object.freeze({
+  promptEventName: 'ping',
+  successEventName: 'echo',
+  failureEventName: 'pingFailed',
+});
+
+const actionToMessageTypesMap = Object.freeze({
+  submit: SUBMIT_MAP,
+  start: START_MAP,
+  ping: PING_MAP,
+});
+
+export default actionToMessageTypesMap;

src/data/messages/handlers.js

@@ -0,0 +1,44 @@
+import actionToMessageTypesMap from './constants';
+
+function createWorker(url) {
+  const blob = new Blob([`importScripts('${url}');`], { type: 'application/javascript' });
+  const blobUrl = window.URL.createObjectURL(blob);
+  return new Worker(blobUrl);
+}
+
+function workerTimeoutPromise(timeoutMilliseconds) {
+  const message = `worker failed to respond after ${timeoutMilliseconds} ms`;
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject(Error(message));
+    }, timeoutMilliseconds);
+  });
+}
+
+export function workerPromiseForEventNames(eventNames, workerUrl) {
+  return (timeout) => {
+    const proctoringBackendWorker = createWorker(workerUrl);
+    return new Promise((resolve, reject) => {
+      const responseHandler = (e) => {
+        if (e.data.type === eventNames.successEventName) {
+          proctoringBackendWorker.removeEventListener('message', responseHandler);
+          proctoringBackendWorker.terminate();
+          resolve();
+        } else {
+          reject(e.data.error);
+        }
+      };
+      proctoringBackendWorker.addEventListener('message', responseHandler);
+      proctoringBackendWorker.postMessage({ type: eventNames.promptEventName, timeout });
+    });
+  };
+}
+
+export function pingApplication(timeoutInSeconds, workerUrl) {
+  const TIMEOUT_BUFFER_SECONDS = 10;
+  const workerPingTimeout = timeoutInSeconds - TIMEOUT_BUFFER_SECONDS; // 10s buffer for worker to respond
+  return Promise.race([
+    workerPromiseForEventNames(actionToMessageTypesMap.ping, workerUrl)(workerPingTimeout * 1000),
+    workerTimeoutPromise(timeoutInSeconds * 1000),
+  ]);
+}

src/data/slice.js

@@ -7,7 +7,9 @@ export const examSlice = createSlice({
     isLoading: true,
     timeIsOver: false,
     activeAttempt: null,
+    proctoringSettings: {},
     exam: {},
+    apiErrorMsg: '',
   },
   reducers: {
     setIsLoading: (state, { payload }) => {
@@ -19,21 +21,24 @@ export const examSlice = createSlice({
     },
     setActiveAttempt: (state, { payload }) => {
       state.activeAttempt = payload.activeAttempt;
-      const examAttempt = state.exam.attempt;
-      if (examAttempt && examAttempt.attempt_id === payload.activeAttempt.attempt_id) {
-        state.exam.attempt = payload.activeAttempt;
-      }
+      state.apiErrorMsg = '';
+    },
+    setProctoringSettings: (state, { payload }) => {
+      state.proctoringSettings = payload.proctoringSettings;
     },
     expireExamAttempt: (state) => {
       state.timeIsOver = true;
     },
     getExamId: (state) => state.examId,
+    setApiError: (state, { payload }) => {
+      state.apiErrorMsg = payload.errorMsg;
+    },
   },
 });
 
 export const {
   setIsLoading, setExamState, getExamId, expireExamAttempt,
-  setActiveAttempt,
+  setActiveAttempt, setProctoringSettings, setApiError,
 } = examSlice.actions;
 
 export default examSlice.reducer;