@3cr/viewer-browser 0.0.247 → 0.0.292

package/src/stores/__tests__/data-overlay.store.spec.ts

@@ -0,0 +1,92 @@
+import { useDataOverlayStore } from '@/stores/data-overlay.store';
+import { storeToRefs } from 'pinia';
+import { inflateInitialDataOverlayState } from '@/functions/modelHelper';
+import { DataOverlayDataFaker } from '@test/fakers/data-overlay-data.faker';
+import { InteractionType } from '@3cr/types-ts';
+import { mountAndFakePiniaWrapper } from '@test/plugins/pinia';
+import { parseDataOverlayData } from '@/functions/parsers/parseDataOverlayData';
+import { DataOverlayAnnotation, DataOverlayMeasurement } from '@3cr/viewer-types-ts';
+
+describe('data overlay store', () => {
+  beforeEach(() => {
+    mountAndFakePiniaWrapper();
+  });
+  it('should have defaults', () => {
+    const { state, event, annotations, annotationEvent, measurements, measurementEvent } =
+      storeToRefs(useDataOverlayStore());
+    expect(state.value).toEqual(inflateInitialDataOverlayState());
+    expect(event.value).toBe(null);
+    expect(annotations.value).toEqual([]);
+    expect(annotationEvent.value).toBe(null);
+    expect(measurements.value).toEqual([]);
+    expect(measurementEvent.value).toBe(null);
+  });
+
+  it('should handle annotation event', () => {
+    const { event, annotationEvent, measurementEvent } = storeToRefs(useDataOverlayStore());
+    event.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.POINTER_UP);
+    expect(annotationEvent.value).not.toBe(null);
+    expect(measurementEvent.value).toBe(null);
+  });
+
+  it('should handle measurement event', () => {
+    const { event, annotationEvent, measurementEvent } = storeToRefs(useDataOverlayStore());
+    event.value = DataOverlayDataFaker.lengthEventRaw(InteractionType.POINTER_UP);
+    expect(annotationEvent.value).toBe(null);
+    expect(measurementEvent.value).not.toBe(null);
+  });
+
+  it('should set Initial MCAD state', async () => {
+    const store = useDataOverlayStore();
+    const { state } = storeToRefs(store);
+
+    const stateString = JSON.stringify(state.value);
+
+    state.value.Version = '9.9.9.9';
+    store.setInitialDataOverlayState(stateString);
+    expect(JSON.stringify(state.value)).toEqual(stateString);
+  });
+
+  it('should set MCAD state', async () => {
+    const store = useDataOverlayStore();
+    const { state } = storeToRefs(store);
+
+    const stateString = JSON.stringify(state.value.DataOverlay);
+
+    state.value.DataOverlay.Version = '9.9.9.9';
+    store.setDataOverlayState(stateString);
+    expect(JSON.stringify(state.value.DataOverlay)).toEqual(stateString);
+  });
+
+  it('should set MCAD Event', async () => {
+    const store = useDataOverlayStore();
+    const { event } = storeToRefs(store);
+
+    expect(event.value).toEqual(null);
+
+    const y = DataOverlayDataFaker.lengthEventRaw(InteractionType.NONE);
+
+    store.setDataOverlayEvent(JSON.stringify(y));
+    expect(event.value).toEqual(y);
+  });
+
+  it('should set annotations map', async () => {
+    const store = useDataOverlayStore();
+    const { state, annotations } = storeToRefs(store);
+
+    const x = DataOverlayDataFaker.annotationRaw();
+    state.value.DataOverlay.DataOverlay.push(x);
+
+    expect(annotations.value).toStrictEqual([parseDataOverlayData<DataOverlayAnnotation>(x).Data]);
+  });
+
+  it('should set measurements map', async () => {
+    const store = useDataOverlayStore();
+    const { state, measurements } = storeToRefs(store);
+
+    const x = DataOverlayDataFaker.lengthRaw();
+    state.value.DataOverlay.DataOverlay.push(x);
+
+    expect(measurements.value).toStrictEqual([parseDataOverlayData<DataOverlayMeasurement>(x).Data]);
+  });
+});

package/src/stores/__tests__/demo.store.spec.ts

@@ -0,0 +1,196 @@
+import { storeToRefs } from 'pinia';
+import { useDemoStore } from '@/stores/demo.store';
+import { DemoType, SaveState, ViewerOptions, ViewerPayload } from '@3cr/viewer-types-ts';
+import { flushPromises } from '@vue/test-utils';
+import { mountAndFakePiniaWrapper } from '@test/plugins/pinia';
+import { useUploadStore } from '@/stores/upload.store';
+import { deepClone } from '@vitest/utils';
+import { CurrentDataOverlayState, CurrentMcadState, CurrentScanState } from '@3cr/types-ts';
+
+describe('demo store tests', () => {
+  it('should call demo licence options', () => {
+    const { demoLicenceOptions } = storeToRefs(useDemoStore());
+    Object.keys(demoLicenceOptions.value).forEach((key) => {
+      const k = key as keyof ViewerOptions;
+      const fn = demoLicenceOptions.value[k];
+      if (typeof fn === 'function') {
+        if (k === 'onMCADUpload') {
+          expect(() => (fn as any)([])).not.toThrow();
+        } else if (k === 'onSaveSession') {
+          expect(() => (fn as any)({}, {}, {}, () => {})).not.toThrow();
+        } else {
+          expect(fn).not.toThrow();
+        }
+      }
+    });
+  });
+
+  it('should call basic demo patient options', () => {
+    const { demoPatientOptions } = storeToRefs(useDemoStore());
+    Object.keys(demoPatientOptions.value).forEach((key) => {
+      const k = key as keyof ViewerOptions;
+      const fn = demoPatientOptions.value[k];
+      if (typeof fn === 'function') {
+        if (k === 'onMCADUpload') {
+          expect(() => (fn as any)([])).not.toThrow();
+        } else if (k === 'onSaveSession') {
+          expect(() => (fn as any)({}, {}, {}, () => {})).not.toThrow();
+        } else {
+          expect(fn).not.toThrow();
+        }
+      }
+    });
+  });
+
+  it('should have demoType set to licence', async () => {
+    mountAndFakePiniaWrapper();
+    const { demoType } = storeToRefs(useDemoStore());
+    Object.defineProperty(window, 'location', {
+      value: {
+        search: '?demoType=licence'
+      },
+      writable: true // possibility to override
+    });
+    await flushPromises();
+
+    expect(demoType.value).toBe(DemoType.Licence);
+  });
+
+  it('should have demoType set to patient', async () => {
+    mountAndFakePiniaWrapper();
+
+    const { demoType } = storeToRefs(useDemoStore());
+    Object.defineProperty(window, 'location', {
+      value: {
+        search: '?demoType=patient'
+      },
+      writable: true // possibility to override
+    });
+    await flushPromises();
+
+    expect(demoType.value).toBe(DemoType.Patient);
+  });
+
+  it('should have demoOptions set to licence', async () => {
+    mountAndFakePiniaWrapper();
+    const { demoOptions, demoLicenceOptions } = storeToRefs(useDemoStore());
+    Object.defineProperty(window, 'location', {
+      value: {
+        search: '?demoType=licence'
+      },
+      writable: true // possibility to override
+    });
+    await flushPromises();
+
+    expect(demoOptions.value).toBe(demoLicenceOptions.value);
+  });
+
+  it('should have demoOptions set to patient', async () => {
+    mountAndFakePiniaWrapper();
+
+    const { demoOptions, demoPatientOptions } = storeToRefs(useDemoStore());
+    Object.defineProperty(window, 'location', {
+      value: {
+        search: '?demoType=patient'
+      },
+      writable: true // possibility to override
+    });
+    await flushPromises();
+
+    expect(demoOptions.value).toBe(demoPatientOptions.value);
+  });
+
+  it('should set demo to demo', async () => {
+    mountAndFakePiniaWrapper();
+    const store = useDemoStore();
+    const { isDemo } = storeToRefs(store);
+
+    store.setIsDemo({
+      Url: 'https://webgl-3dr.singular.health/demo'
+    } as ViewerPayload);
+
+    expect(isDemo.value).toBe(true);
+  });
+
+  it('should set demo to not demo', async () => {
+    mountAndFakePiniaWrapper();
+
+    const store = useDemoStore();
+    const { isDemo } = storeToRefs(store);
+
+    store.setIsDemo({
+      Url: 'https://singular.health'
+    } as ViewerPayload);
+
+    expect(isDemo.value).toBe(false);
+  });
+
+  it('should set patient onMCADUpload', async () => {
+    mountAndFakePiniaWrapper();
+
+    vi.useFakeTimers();
+    const store = useDemoStore();
+    const { demoPatientOptions } = storeToRefs(store);
+    const { uploads } = storeToRefs(useUploadStore());
+
+    demoPatientOptions.value.onMCADUpload!([new File([''], 'test.html')]);
+
+    expect(uploads.value.length).toBe(1);
+    let tempUploads = deepClone(uploads.value);
+
+    while (tempUploads[0].status !== 'completed') {
+      tempUploads = deepClone(uploads.value);
+
+      vi.advanceTimersByTime(100);
+
+      expect(uploads.value).not.toBe(tempUploads);
+    }
+
+    expect(tempUploads[0].status).toBe('completed');
+    expect(tempUploads[0].subtitle).toBe('Upload Complete');
+  });
+
+  it('should set patient onSaveSession', async () => {
+    mountAndFakePiniaWrapper();
+
+    vi.useFakeTimers();
+    const store = useDemoStore();
+    const { demoPatientOptions, demoTitle } = storeToRefs(store);
+
+    const updateStateCallback = vi.fn();
+    demoPatientOptions.value.onSaveSession!(
+      {} as CurrentScanState,
+      {} as CurrentDataOverlayState,
+      {} as CurrentMcadState,
+      updateStateCallback
+    );
+
+    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVING);
+    vi.advanceTimersByTime(1000);
+    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVED_TEMPORARY);
+    vi.advanceTimersByTime(500);
+    expect(demoTitle.value).toBe('texts.demo.patient.saveSession.title');
+  });
+
+  it('should set licence onSaveSession', async () => {
+    mountAndFakePiniaWrapper();
+
+    vi.useFakeTimers();
+    const store = useDemoStore();
+    const { demoLicenceOptions, demoTitle } = storeToRefs(store);
+
+    const updateStateCallback = vi.fn();
+    demoLicenceOptions.value.onSaveSession!(
+      {} as CurrentScanState,
+      {} as CurrentDataOverlayState,
+      {} as CurrentMcadState,
+      updateStateCallback
+    );
+
+    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVING);
+    vi.advanceTimersByTime(1000);
+    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVED_TEMPORARY);
+    vi.advanceTimersByTime(500);
+    expect(demoTitle.value).toBe('texts.demo.licence.saveSession.title');
+  });
+});

package/src/stores/__tests__/drawer.store.spec.ts

@@ -0,0 +1,27 @@
+import { storeToRefs } from 'pinia';
+import { useDrawerStore } from '@/stores/drawer.store';
+import { mountAndFakePiniaWrapper } from '@test/plugins/pinia';
+
+describe('drawer store', () => {
+  it('should be closed when home', () => {
+    mountAndFakePiniaWrapper();
+    const { activeDrawer, isOpen } = storeToRefs(useDrawerStore());
+    expect(activeDrawer.value).toBe('home');
+    expect(isOpen.value).toBeFalsy();
+  });
+
+  it('should be open when not home', () => {
+    mountAndFakePiniaWrapper();
+    const { activeDrawer, isOpen } = storeToRefs(useDrawerStore());
+    activeDrawer.value = 'annotations';
+    expect(isOpen.value).toBeTruthy();
+    expect(activeDrawer.value).toBe('annotations');
+  });
+
+  it('should be home when not set', () => {
+    mountAndFakePiniaWrapper();
+    const { activeDrawer } = storeToRefs(useDrawerStore());
+    activeDrawer.value = '';
+    expect(activeDrawer.value).toBe('home');
+  });
+});

package/src/stores/__tests__/intro.store.spec.ts

@@ -0,0 +1,102 @@
+import { useIntroStore } from '@/stores/intro.store';
+import { storeToRefs } from 'pinia';
+import { beforeEach } from '@vitest/runner';
+import { mountAndFakePiniaWrapper } from '@test/plugins/pinia';
+import { flushPromises } from '@vue/test-utils';
+import { MockImportOriginal } from '@test/MockImportOriginal';
+import { onMounted } from 'vue';
+
+vi.mock('vue', async (importOriginal: MockImportOriginal<typeof import('vue')>) => {
+  return {
+    ...(await importOriginal()),
+    onMounted: vi.fn()
+  };
+});
+describe('intro store', () => {
+  const localStorageMock = (() => {
+    let store: { [key: string]: string } = {};
+
+    return {
+      getItem: vi.fn().mockReturnValue((key: string) => store[key] || null),
+      setItem: vi.fn().mockImplementation((key: string, value: string) => {
+        store[key] = value.toString();
+      })
+    };
+  })();
+
+  Object.defineProperty(window, 'localStorage', {
+    value: localStorageMock
+  });
+
+  beforeEach(() => {
+    localStorageMock.getItem.mockClear();
+    localStorageMock.setItem.mockClear();
+  });
+  it('should show intro by default', () => {
+    const { dontShowAgain } = storeToRefs(useIntroStore());
+    expect(dontShowAgain.value).toBeFalsy();
+  });
+
+  it('should persist to local storage', async () => {
+    mountAndFakePiniaWrapper();
+    const { dontShowAgain } = storeToRefs(useIntroStore());
+
+    await flushPromises();
+    dontShowAgain.value = true;
+    dontShowAgain.value = false;
+    await flushPromises();
+    expect(localStorageMock.setItem).toHaveBeenCalledWith(expect.any(String), 'true');
+  });
+
+  it('should mount and set from storage true', () => {
+    localStorageMock.getItem.mockReturnValue(true);
+    const spy = vi.mocked(onMounted).mockImplementation((fn: any) => {
+      fn();
+    });
+    mountAndFakePiniaWrapper();
+    const { dontShowAgain } = storeToRefs(useIntroStore());
+
+    expect(spy).toHaveBeenCalled();
+    expect(dontShowAgain.value).toBe(true);
+  });
+
+  it('should mount and set from storage false', () => {
+    localStorageMock.getItem.mockReturnValue(false);
+    const spy = vi.mocked(onMounted).mockImplementation((fn: any) => {
+      fn();
+    });
+    mountAndFakePiniaWrapper();
+    const { dontShowAgain } = storeToRefs(useIntroStore());
+
+    expect(spy).toHaveBeenCalled();
+    expect(dontShowAgain.value).toBe(false);
+  });
+
+  it('should mount and set from storage fail', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    localStorageMock.getItem.mockReturnValue('not a json');
+    const spy = vi.mocked(onMounted).mockImplementation((fn: any) => {
+      fn();
+    });
+    mountAndFakePiniaWrapper();
+    const { dontShowAgain } = storeToRefs(useIntroStore());
+
+    expect(spy).toHaveBeenCalled();
+    expect(consoleWarnSpy).toHaveBeenCalledWith('Error parsing stored value:', expect.anything());
+    expect(dontShowAgain.value).toBe(false);
+  });
+
+  it('should mount and set from storage empty', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    localStorageMock.getItem.mockReturnValue(null);
+    const spy = vi.mocked(onMounted).mockImplementation((fn: any) => {
+      fn();
+    });
+    mountAndFakePiniaWrapper();
+    const { dontShowAgain } = storeToRefs(useIntroStore());
+
+    expect(spy).toHaveBeenCalled();
+    expect(consoleWarnSpy).not.toHaveBeenCalledWith('Error parsing stored value:', expect.anything());
+    expect(dontShowAgain.value).toBe(false);
+  });
+});

package/src/stores/__tests__/language.store.spec.ts

@@ -0,0 +1,83 @@
+import { storeToRefs } from 'pinia';
+import { useLanguageStore } from '@/stores/language.store';
+import OtaClient from '@crowdin/ota-client';
+import { flushPromises } from '@vue/test-utils';
+import { MockInstance } from '@vitest/spy';
+import { mountAndFakePiniaWrapper } from '@test/plugins/pinia';
+
+describe('language store', () => {
+  let getStringsByLocaleSpy: MockInstance;
+  let listLanguagesSpy: MockInstance;
+
+  beforeEach(() => {
+    getStringsByLocaleSpy = vi.spyOn(OtaClient.prototype, 'getStringsByLocale').mockResolvedValue({});
+    listLanguagesSpy = vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);
+  });
+
+  afterEach(() => {
+    getStringsByLocaleSpy.mockRestore();
+    listLanguagesSpy.mockRestore();
+  });
+
+  it('should have preference default to english', () => {
+    const { preference } = storeToRefs(useLanguageStore());
+    expect(preference.value).toBe('en-US');
+  });
+
+  it('should have preference default to english', () => {
+    Object.defineProperty(window, 'navigator', {
+      value: {
+        languages: []
+      },
+      writable: true // possibility to override
+    });
+    const { preference } = storeToRefs(useLanguageStore());
+    expect(preference.value).toBe('en');
+  });
+
+  it('should have preference default to english', () => {
+    Object.defineProperty(window, 'navigator', {
+      value: {
+        languages: undefined,
+        language: 'en-US'
+      },
+      writable: true // possibility to override
+    });
+
+    const { preference } = storeToRefs(useLanguageStore());
+    expect(preference.value).toBe('en');
+  });
+
+  it('should have preference default to english', () => {
+    Object.defineProperty(window, 'navigator', {
+      value: {
+        languages: undefined,
+        language: undefined
+      },
+      writable: true // possibility to override
+    });
+    const { preference } = storeToRefs(useLanguageStore());
+    expect(preference.value).toBe('en');
+  });
+
+  it('should have language default to preference', () => {
+    const { language } = storeToRefs(useLanguageStore());
+    expect(language.value).toBe('en-US');
+  });
+
+  it('should query crowdin for locale messages', async () => {
+    const { language } = storeToRefs(useLanguageStore());
+    language.value = 'xyz';
+    await flushPromises();
+    expect(getStringsByLocaleSpy).toHaveBeenCalledWith('xyz');
+  });
+
+  it('should query crowdin for locale messages', async () => {
+    mountAndFakePiniaWrapper();
+    const { getLanguages } = useLanguageStore();
+    await flushPromises();
+
+    const langs = await getLanguages();
+    expect(langs).toStrictEqual([]);
+  });
+});