@lookit/record 3.0.1 → 4.1.0

package/src/index.spec.ts

@@ -1,4 +1,5 @@
 import { LookitWindow } from "@lookit/data/dist/types";
+import chsTemplates from "@lookit/templates";
 import { initJsPsych, PluginInfo, TrialType } from "jspsych";
 import { ExistingRecordingError, NoSessionRecordingError } from "./errors";
 import Rec from "./index";
@@ -6,15 +7,22 @@ import Recorder from "./recorder";
 
 declare const window: LookitWindow;
 
+let global_display_el: HTMLDivElement;
+
 jest.mock("./recorder");
 jest.mock("@lookit/data");
 jest.mock("jspsych", () => ({
   ...jest.requireActual("jspsych"),
-  initJsPsych: jest.fn().mockReturnValue({
-    finishTrial: jest.fn().mockImplementation(),
-    getCurrentTrial: jest
-      .fn()
-      .mockReturnValue({ type: { info: { name: "test-type" } } }),
+  initJsPsych: jest.fn().mockImplementation(() => {
+    // create a new display element for each jsPsych instance
+    global_display_el = document.createElement("div");
+    return {
+      finishTrial: jest.fn().mockImplementation(),
+      getCurrentTrial: jest
+        .fn()
+        .mockReturnValue({ type: { info: { name: "test-type" } } }),
+      getDisplayElement: jest.fn(() => global_display_el),
+    };
   }),
 }));
 
@@ -24,10 +32,10 @@ jest.mock("jspsych", () => ({
  * @param chs - Contents of chs storage.
  */
 const setCHSValue = (chs = {}) => {
-  Object.defineProperty(global, "window", {
-    value: {
-      chs,
-    },
+  Object.defineProperty(window, "chs", {
+    value: chs,
+    configurable: true,
+    writable: true,
   });
 };
 
@@ -36,6 +44,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  jest.restoreAllMocks();
   jest.clearAllMocks();
 });
 
@@ -57,15 +66,223 @@ test("Trial recording", () => {
   expect(getCurrentPluginNameSpy).toHaveBeenCalledTimes(1);
 });
 
-test("Trial recording's initialize does nothing", async () => {
+test("Trial recording's initialize with no parameters", async () => {
   const jsPsych = initJsPsych();
   const trialRec = new Rec.TrialRecordExtension(jsPsych);
 
   expect(await trialRec.initialize()).toBeUndefined();
+  expect(trialRec["uploadMsg"]).toBeNull;
+  expect(trialRec["locale"]).toBe("en-us");
+  expect(Recorder).toHaveBeenCalledTimes(0);
+});
+
+test("Trial recording's initialize with locale parameter", async () => {
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  expect(await trialRec.initialize({ locale: "fr" })).toBeUndefined();
+  expect(trialRec["locale"]).toBe("fr");
+  expect(trialRec["uploadMsg"]).toBeNull;
+  expect(Recorder).toHaveBeenCalledTimes(0);
+});
+
+test("Trial recording's initialize with wait_for_upload_message parameter", async () => {
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  expect(
+    await trialRec.initialize({ wait_for_upload_message: "Please wait..." }),
+  ).toBeUndefined();
+  expect(trialRec["uploadMsg"]).toBe("Please wait...");
+  expect(trialRec["locale"]).toBe("en-us");
+  expect(Recorder).toHaveBeenCalledTimes(0);
+});
+
+test("Trial recording start with locale parameter", async () => {
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  await trialRec.initialize();
+
+  expect(trialRec["uploadMsg"]).toBeNull;
+  expect(trialRec["locale"]).toBe("en-us");
+  expect(Recorder).toHaveBeenCalledTimes(0);
+
+  trialRec.on_start({ locale: "fr" });
+
+  expect(trialRec["uploadMsg"]).toBeNull;
+  expect(trialRec["locale"]).toBe("fr");
+  expect(Recorder).toHaveBeenCalledTimes(1);
+});
+
+test("Trial recording start with wait_for_upload_message parameter", async () => {
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  await trialRec.initialize();
+
+  expect(trialRec["uploadMsg"]).toBeNull;
+  expect(trialRec["locale"]).toBe("en-us");
   expect(Recorder).toHaveBeenCalledTimes(0);
+
+  trialRec.on_start({ wait_for_upload_message: "Please wait..." });
+
+  expect(trialRec["uploadMsg"]).toBe("Please wait...");
+  expect(trialRec["locale"]).toBe("en-us");
+  expect(Recorder).toHaveBeenCalledTimes(1);
+});
+
+test("Trial recording stop/finish with default uploading msg in English", async () => {
+  // control the recorder stop promise so that we can inspect the display before it resolves
+  let resolveStop!: () => void;
+  const stopPromise = new Promise<void>((res) => (resolveStop = res));
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  const params = {
+    locale: "en-us",
+    wait_for_upload_message: null,
+  };
+  await trialRec.initialize(params);
+  trialRec.on_start();
+  trialRec.on_load();
+
+  // call on_finish but don't await so that we can inspect before it resolves
+  trialRec.on_finish();
+
+  expect(global_display_el.innerHTML).toBe(
+    chsTemplates.uploadingVideo({
+      type: jsPsych.getCurrentTrial().type,
+      locale: params.locale,
+    } as TrialType<PluginInfo>),
+  );
+  expect(global_display_el.innerHTML).toBe(
+    "<div>uploading video, please wait...</div>",
+  );
+  //expect(Recorder.prototype.stop).toHaveBeenCalledTimes(1);
+
+  // resolve the stop promise
+  resolveStop();
+  await stopPromise;
+  await Promise.resolve();
+
+  // check the display cleanup
+  expect(global_display_el.innerHTML).toBe("");
+});
+
+test("Trial recording stop/finish with different locale should display default uploading msg in specified language", async () => {
+  // control the recorder stop promise so that we can inspect the display before it resolves
+  let resolveStop!: () => void;
+  const stopPromise = new Promise<void>((res) => (resolveStop = res));
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  const params = {
+    locale: "fr",
+    wait_for_upload_message: null,
+  };
+  await trialRec.initialize(params);
+  trialRec.on_start();
+  trialRec.on_load();
+
+  // call on_finish but don't await so that we can inspect before it resolves
+  trialRec.on_finish();
+
+  expect(global_display_el.innerHTML).toBe(
+    chsTemplates.uploadingVideo({
+      type: jsPsych.getCurrentTrial().type,
+      locale: params.locale,
+    } as TrialType<PluginInfo>),
+  );
+  expect(global_display_el.innerHTML).toBe(
+    "<div>téléchargement video en cours, veuillez attendre...</div>",
+  );
+  //expect(Recorder.prototype.stop).toHaveBeenCalledTimes(1);
+
+  // resolve the stop promise
+  resolveStop();
+  await stopPromise;
+  await Promise.resolve();
+
+  // check the display cleanup
+  expect(global_display_el.innerHTML).toBe("");
 });
 
-test("Start Recording", async () => {
+test("Trial recording stop/finish with custom uploading message", async () => {
+  // control the recorder stop promise so that we can inspect the display before it resolves
+  let resolveStop!: () => void;
+  const stopPromise = new Promise<void>((res) => (resolveStop = res));
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  const params = {
+    wait_for_upload_message: "Wait!",
+  };
+  await trialRec.initialize(params);
+  trialRec.on_start();
+  trialRec.on_load();
+
+  // call on_finish but don't await so that we can inspect before it resolves
+  trialRec.on_finish();
+
+  expect(global_display_el.innerHTML).toBe("Wait!");
+  //expect(Recorder.prototype.stop).toHaveBeenCalledTimes(1);
+
+  // resolve the stop promise
+  resolveStop();
+  await stopPromise;
+  await Promise.resolve();
+
+  // check the display cleanup
+  expect(global_display_el.innerHTML).toBe("");
+});
+
+test("Trial recording rejection path (failure during upload)", async () => {
+  // Create a controlled promise and capture the reject function
+  let rejectStop!: (err: unknown) => void;
+  const stopPromise = new Promise<void>((_, reject) => {
+    rejectStop = reject;
+  });
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+  const trialRec = new Rec.TrialRecordExtension(jsPsych);
+
+  await trialRec.initialize();
+  trialRec.on_start();
+  trialRec.on_load();
+
+  // call on_finish but don't await so that we can inspect before it resolves
+  trialRec.on_finish();
+
+  // Should show initial wait for upload message
+  expect(global_display_el.innerHTML).toBe(
+    "<div>uploading video, please wait...</div>",
+  );
+
+  // Reject stop
+  rejectStop(new Error("upload failed"));
+
+  // Wait for plugin's `.catch()` handler to run
+  await Promise.resolve();
+
+  // TO DO: modify the trial extension code to display translated error msg and/or researcher contact info
+  expect(global_display_el.innerHTML).toBe(
+    "<div>uploading video, please wait...</div>",
+  );
+});
+
+test("Start session recording", async () => {
   const mockRecStart = jest.spyOn(Recorder.prototype, "start");
   const jsPsych = initJsPsych();
   const startRec = new Rec.StartRecordPlugin(jsPsych);
@@ -81,7 +298,7 @@ test("Start Recording", async () => {
   }).toThrow(ExistingRecordingError);
 });
 
-test("Stop Recording", async () => {
+test("Stop session recording", async () => {
   const mockRecStop = jest.spyOn(Recorder.prototype, "stop");
   const jsPsych = initJsPsych();
 
@@ -112,3 +329,161 @@ test("Stop Recording", async () => {
     NoSessionRecordingError,
   );
 });
+
+test("Stop session recording should display default uploading msg in English", async () => {
+  // control the recorder stop promise so that we can inspect the display before it resolves
+  let resolveStop!: () => void;
+  const stopPromise = new Promise<void>((res) => (resolveStop = res));
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+
+  setCHSValue({
+    sessionRecorder: new Recorder(jsPsych),
+  });
+
+  const stop_rec_plugin = new Rec.StopRecordPlugin(jsPsych);
+  const display_element = document.createElement("div");
+
+  const trial = {
+    type: Rec.StopRecordPlugin.info.name,
+    locale: "en-us",
+    wait_for_upload_message: null,
+  } as unknown as TrialType<PluginInfo>; // need to cast here because the "type" param is a string and should be a class
+
+  // call trial but don't await so that we can inspect before it resolves
+  stop_rec_plugin.trial(display_element, trial);
+
+  expect(display_element.innerHTML).toBe(chsTemplates.uploadingVideo(trial));
+  expect(Recorder.prototype.stop).toHaveBeenCalledTimes(1);
+
+  // resolve the stop promise
+  resolveStop();
+  await stopPromise;
+  await Promise.resolve();
+
+  // check the cleanup tasks after the trial method has resolved
+  expect(display_element.innerHTML).toBe("");
+  expect(jsPsych.finishTrial).toHaveBeenCalledTimes(1);
+  expect(window.chs.sessionRecorder).toBeNull();
+});
+
+test("Stop session recording with different locale should display default uploading msg in specified language", async () => {
+  // control the recorder stop promise so that we can inspect the display before it resolves
+  let resolveStop!: () => void;
+  const stopPromise = new Promise<void>((res) => (resolveStop = res));
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+
+  setCHSValue({
+    sessionRecorder: new Recorder(jsPsych),
+  });
+
+  const stop_rec_plugin = new Rec.StopRecordPlugin(jsPsych);
+  const display_element = document.createElement("div");
+
+  // set locale to fr
+  const trial = {
+    type: Rec.StopRecordPlugin.info.name,
+    locale: "fr",
+    wait_for_upload_message: null,
+  } as unknown as TrialType<PluginInfo>; // need to cast here because the "type" param is a string and should be a class
+
+  // call trial but don't await so that we can inspect before it resolves
+  stop_rec_plugin.trial(display_element, trial);
+
+  const fr_uploading_msg = chsTemplates.uploadingVideo(trial);
+
+  // check that fr translation is used
+  expect(fr_uploading_msg).toBe(
+    "<div>téléchargement video en cours, veuillez attendre...</div>",
+  );
+  expect(display_element.innerHTML).toBe(fr_uploading_msg);
+  expect(Recorder.prototype.stop).toHaveBeenCalledTimes(1);
+
+  // resolve the stop promise
+  resolveStop();
+  await stopPromise;
+  await Promise.resolve();
+
+  // check the cleanup tasks after the trial method has resolved
+  expect(display_element.innerHTML).toBe("");
+  expect(jsPsych.finishTrial).toHaveBeenCalledTimes(1);
+  expect(window.chs.sessionRecorder).toBeNull();
+});
+
+test("Stop session recording with custom uploading message", async () => {
+  // control the recorder stop promise so that we can inspect the display before it resolves
+  let resolveStop!: () => void;
+  const stopPromise = new Promise<void>((res) => (resolveStop = res));
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+  setCHSValue({ sessionRecorder: new Recorder(jsPsych) });
+
+  const stop_rec_plugin = new Rec.StopRecordPlugin(jsPsych);
+  const display_element = document.createElement("div");
+
+  const trial = {
+    type: Rec.StopRecordPlugin.info.name,
+    locale: "en-us",
+    wait_for_upload_message: "<p>Custom message…</p>",
+  } as unknown as TrialType<PluginInfo>; // need to cast here because the "type" param is a string and should be a class
+
+  stop_rec_plugin.trial(display_element, trial);
+
+  // check display before stop is resolved
+  expect(display_element.innerHTML).toBe("<p>Custom message…</p>");
+
+  resolveStop();
+  await stopPromise;
+  await Promise.resolve();
+
+  // check the cleanup tasks after the trial method has resolved
+  expect(display_element.innerHTML).toBe("");
+  expect(jsPsych.finishTrial).toHaveBeenCalledTimes(1);
+  expect(window.chs.sessionRecorder).toBeNull();
+});
+
+test("Stop recording rejection path (failure during upload)", async () => {
+  // Create a controlled promise and capture the reject function
+  let rejectStop!: (err: unknown) => void;
+  const stopPromise = new Promise<void>((_, reject) => {
+    rejectStop = reject;
+  });
+
+  jest.spyOn(Recorder.prototype, "stop").mockReturnValue(stopPromise);
+
+  const jsPsych = initJsPsych();
+  setCHSValue({ sessionRecorder: new Recorder(jsPsych) });
+
+  const stop_rec_plugin = new Rec.StopRecordPlugin(jsPsych);
+  const display_element = document.createElement("div");
+
+  const trial = {
+    type: Rec.StopRecordPlugin.info.name,
+    locale: "en-us",
+    wait_for_upload_message: "Wait…",
+  } as unknown as TrialType<PluginInfo>; // need to cast here because the "type" param is a string and should be a class
+
+  stop_rec_plugin.trial(display_element, trial);
+
+  // Should show initial wait for upload message
+  expect(display_element.innerHTML).toBe("Wait…");
+
+  // Reject stop
+  rejectStop(new Error("upload failed"));
+
+  // Wait for plugin's `.catch()` handler to run
+  await Promise.resolve();
+
+  // Trial doesn't end and the cleanup tasks don't run.
+  // TO DO: modify the plugin code to display translated error msg and/or researcher contact info
+  expect(display_element.innerHTML).toBe("Wait…");
+  expect(jsPsych.finishTrial).not.toHaveBeenCalled();
+  expect(window.chs.sessionRecorder).not.toBeNull();
+});

package/src/recorder.spec.ts

@@ -1,7 +1,7 @@
 import Data from "@lookit/data";
 import { LookitWindow } from "@lookit/data/dist/types";
 import Handlebars from "handlebars";
-import { initJsPsych } from "jspsych";
+import { initJsPsych, JsPsych } from "jspsych";
 import playbackFeed from "../hbs/playback-feed.hbs";
 import recordFeed from "../hbs/record-feed.hbs";
 import webcamFeed from "../hbs/webcam-feed.hbs";
@@ -123,6 +123,7 @@ test("Recorder no stop promise", () => {
 
   expect(async () => await rec.stop()).rejects.toThrow(NoStopPromiseError);
 });
+
 test("Recorder initialize error", () => {
   const jsPsych = initJsPsych();
   const rec = new Recorder(jsPsych);
@@ -142,29 +143,73 @@ test("Recorder initialize error", () => {
 });
 
 test("Recorder handleStop", async () => {
-  const rec = new Recorder(initJsPsych());
+  // Define a custom mockStream so that we can dynamically modify active value
+  const mockStream = {
+    active: true,
+    clone: jest.fn(),
+    getTracks: jest.fn().mockReturnValue([{ stop: jest.fn() }]),
+  };
+  mockStream.clone = jest.fn().mockReturnValue(mockStream);
+  // We need a mock MediaRecorder object that uses the custom mockStream
+  const mockRecorder = {
+    addEventListener: jest.fn(),
+    mimeType: "video/webm",
+    start: jest.fn(),
+    stop: jest.fn(),
+    stream: mockStream,
+  };
+
+  // Minimal fake jsPsych object to pass to the Recorder constructor
+  const jsPsych = {
+    pluginAPI: {
+      getCameraRecorder: jest.fn().mockReturnValue(mockRecorder),
+      initializeCameraRecorder: jest.fn().mockReturnValue(mockRecorder),
+    },
+    data: {
+      getLastTrialData: jest.fn().mockReturnValue({
+        values: jest.fn().mockReturnValue([]),
+      }),
+    },
+  } as unknown as JsPsych;
+
+  const rec = new Recorder(jsPsych);
+
   const download = jest.fn();
   const resolve = jest.fn();
-  const handleStop = rec["handleStop"](resolve);
+  // This allows us to keep strict typing and avoid use of 'any'
+  const resetSpy = jest.spyOn(rec, "reset" satisfies keyof typeof rec);
 
-  // manual mock
+  // Manual mock
   rec["download"] = download;
   rec["blobs"] = ["some recorded data" as unknown as Blob];
   URL.createObjectURL = jest.fn();
 
-  // let's download the file locally
+  // Download the file locally
   rec["localDownload"] = true;
 
+  // Stream cannot be active when handleStop/reset is called
+  mockStream.active = false;
+
+  const handleStop = rec["handleStop"](resolve);
+
   await handleStop();
 
+  expect(download).toHaveBeenCalledTimes(1);
+  expect(resetSpy).toHaveBeenCalledTimes(1);
+
   // Upload the file to s3
   rec["localDownload"] = false;
   rec["_s3"] = new Data.LookitS3("some key");
 
+  // The first 'handleStop' resets the recorder, which resets blobs to [], so we need to fake the blob data again.
+  rec["blobs"] = ["some recorded data" as unknown as Blob];
+
   await handleStop();
 
-  expect(download).toHaveBeenCalledTimes(1);
   expect(Data.LookitS3.prototype.completeUpload).toHaveBeenCalledTimes(1);
+  expect(resetSpy).toHaveBeenCalledTimes(2);
+
+  resetSpy.mockRestore();
 });
 
 test("Recorder handleStop error with no url", () => {
@@ -274,6 +319,125 @@ test("Webcam feed is removed when stream access stops", async () => {
   document.body.innerHTML = "";
 });
 
+test("Webcam feed container maintains size with recorder.stop(true)", async () => {
+  // Add webcam container to document body.
+  const webcam_container_id = "webcam-container";
+  document.body.innerHTML = `<div id="${webcam_container_id}"></div>`;
+  const webcam_div = document.getElementById(
+    webcam_container_id,
+  ) as HTMLDivElement;
+
+  const jsPsych = initJsPsych();
+  const rec = new Recorder(jsPsych);
+  const stopPromise = Promise.resolve();
+
+  rec["stopPromise"] = stopPromise;
+  rec.insertWebcamFeed(webcam_div);
+
+  // Mock the return values for the video element's offsetHeight/offsetWidth, which are used to set the container size
+  jest
+    .spyOn(document.getElementsByTagName("video")[0], "offsetWidth", "get")
+    .mockImplementation(() => 400);
+  jest
+    .spyOn(document.getElementsByTagName("video")[0], "offsetHeight", "get")
+    .mockImplementation(() => 300);
+
+  await rec.stop(true);
+
+  // Container div's dimensions should match the video element dimensions
+  expect(
+    (document.getElementById(webcam_container_id) as HTMLDivElement).style
+      .width,
+  ).toBe("400px");
+  expect(
+    (document.getElementById(webcam_container_id) as HTMLDivElement).style
+      .height,
+  ).toBe("300px");
+
+  document.body.innerHTML = "";
+  // restore the offsetWidth/offsetHeight getters
+  jest.restoreAllMocks();
+});
+
+test("Webcam feed container size is not maintained with recorder.stop(false)", async () => {
+  // Add webcam container to document body.
+  const webcam_container_id = "webcam-container";
+  document.body.innerHTML = `<div id="${webcam_container_id}"></div>`;
+  const webcam_div = document.getElementById(
+    webcam_container_id,
+  ) as HTMLDivElement;
+
+  const jsPsych = initJsPsych();
+  const rec = new Recorder(jsPsych);
+  const stopPromise = Promise.resolve();
+
+  rec["stopPromise"] = stopPromise;
+  rec.insertWebcamFeed(webcam_div);
+
+  // Mock the return values for the video element offsetHeight/offsetWidth, which are used to set the container size
+  jest
+    .spyOn(document.getElementsByTagName("video")[0], "offsetWidth", "get")
+    .mockImplementation(() => 400);
+  jest
+    .spyOn(document.getElementsByTagName("video")[0], "offsetHeight", "get")
+    .mockImplementation(() => 300);
+
+  await rec.stop(false);
+
+  // Container div's dimensions should not be set
+  expect(
+    (document.getElementById(webcam_container_id) as HTMLDivElement).style
+      .width,
+  ).toBe("");
+  expect(
+    (document.getElementById(webcam_container_id) as HTMLDivElement).style
+      .height,
+  ).toBe("");
+
+  document.body.innerHTML = "";
+  // restore the offsetWidth/offsetHeight getters
+  jest.restoreAllMocks();
+});
+
+test("Webcam feed container size is not maintained with recorder.stop()", async () => {
+  // Add webcam container to document body.
+  const webcam_container_id = "webcam-container";
+  document.body.innerHTML = `<div id="${webcam_container_id}"></div>`;
+  const webcam_div = document.getElementById(
+    webcam_container_id,
+  ) as HTMLDivElement;
+
+  const jsPsych = initJsPsych();
+  const rec = new Recorder(jsPsych);
+  const stopPromise = Promise.resolve();
+
+  rec["stopPromise"] = stopPromise;
+  rec.insertWebcamFeed(webcam_div);
+
+  // Mock the return values for the video element offsetHeight/offsetWidth, which are used to set the container size
+  jest
+    .spyOn(document.getElementsByTagName("video")[0], "offsetWidth", "get")
+    .mockImplementation(() => 400);
+  jest
+    .spyOn(document.getElementsByTagName("video")[0], "offsetHeight", "get")
+    .mockImplementation(() => 300);
+
+  await rec.stop();
+
+  // Container div's dimensions should not be set
+  expect(
+    (document.getElementById(webcam_container_id) as HTMLDivElement).style
+      .width,
+  ).toBe("");
+  expect(
+    (document.getElementById(webcam_container_id) as HTMLDivElement).style
+      .height,
+  ).toBe("");
+
+  document.body.innerHTML = "";
+  jest.restoreAllMocks();
+});
+
 test("Recorder initializeRecorder", () => {
   const jsPsych = initJsPsych();
   const rec = new Recorder(jsPsych);