DWVv0.37.0
tests/app/loadController.test.jsjavascript
import {describe, test, assert, vi, beforeEach} from 'vitest';

const {MockLoader} = vi.hoisted(() => {
  /**
   * Test double for the IO loaders used by the load controller.
   * Callbacks are driven manually by the tests.
   */
  class HoistedMockLoader {
    static instances = [];
    static throwOnLoad = false;
    static hasTimeout = true;

    charset = undefined;
    loadArgs = null;
    abortCalled = false;

    /**
     * Create a mock loader and keep track of it.
     */
    constructor() {
      if (HoistedMockLoader.hasTimeout) {
        this.ontimeout = null;
      }
      HoistedMockLoader.instances.push(this);
    }

    /**
     * Reset static state between tests.
     */
    static reset() {
      HoistedMockLoader.instances = [];
      HoistedMockLoader.throwOnLoad = false;
      HoistedMockLoader.hasTimeout = true;
    }

    /**
     * Store the default character set.
     *
     * @param {string} charset The character set.
     */
    setDefaultCharacterSet(charset) {
      this.charset = charset;
    }

    /**
     * Store the load arguments, throw if configured to.
     *
     * @param {Array} data The data to load.
     * @param {object} [options] The load options.
     */
    load(data, options) {
      this.loadArgs = {data, options};
      if (HoistedMockLoader.throwOnLoad) {
        throw new Error('load failed');
      }
    }

    /**
     * Record abort.
     */
    abort() {
      this.abortCalled = true;
    }
  }
  return {MockLoader: HoistedMockLoader};
});

vi.mock('../../src/io/filesLoader.js', () => ({
  FilesLoader: class FilesLoader extends MockLoader {}
}));
vi.mock('../../src/io/urlsLoader.js', () => ({
  UrlsLoader: class UrlsLoader extends MockLoader {}
}));
vi.mock('../../src/io/memoryLoader.js', () => ({
  MemoryLoader: class MemoryLoader extends MockLoader {}
}));

import {LoadController, loadEventNames} from '../../src/app/loadController.js';

/**
 * Tests for the 'app/loadController.js' file.
 */
/** @module tests/app */

/**
 * Listen to all load events of a controller.
 *
 * @param {LoadController} controller The controller.
 * @returns {Array} The list of received {type, detail}, filled on the go.
 */
function recordEvents(controller) {
  const events = [];
  for (const name of loadEventNames) {
    controller.addEventListener(name, (event) => {
      events.push({
        type: event.type,
        detail: /** @type {CustomEvent} */ (event).detail
      });
    });
  }
  return events;
}

/**
 * Get the last created mock loader.
 *
 * @returns {MockLoader} The loader.
 */
function lastLoader() {
  return MockLoader.instances[MockLoader.instances.length - 1];
}

describe('app', () => {

  beforeEach(() => {
    MockLoader.reset();
  });

  /**
   * Tests for {@link LoadController} loader selection.
   */
  describe('LoadController loaders', () => {

    test('loadFiles - uses FilesLoader with charset', () => {
      const controller = new LoadController('ISO_IR 100');
      const files = [{name: 'a.dcm'}];
      controller.loadFiles(files, '0');

      assert.equal(MockLoader.instances.length, 1);
      const loader = lastLoader();
      assert.equal(loader.constructor.name, 'FilesLoader');
      assert.equal(loader.charset, 'ISO_IR 100');
      assert.equal(loader.loadArgs.data, files);
      assert.isUndefined(loader.loadArgs.options);
    });

    test('loadURLs - uses UrlsLoader with charset and options', () => {
      const controller = new LoadController('ISO_IR 192');
      const urls = ['http://host/a.dcm'];
      const options = {withCredentials: true};
      controller.loadURLs(urls, '0', options);

      const loader = lastLoader();
      assert.equal(loader.constructor.name, 'UrlsLoader');
      assert.equal(loader.charset, 'ISO_IR 192');
      assert.equal(loader.loadArgs.data, urls);
      assert.equal(loader.loadArgs.options, options);
    });

    test('loadImageObject - uses MemoryLoader', () => {
      const controller = new LoadController('ISO_IR 100');
      const data = [{name: 'a', filename: 'a.dcm', data: new ArrayBuffer(1)}];
      controller.loadImageObject(data, '0');

      const loader = lastLoader();
      assert.equal(loader.constructor.name, 'MemoryLoader');
      // memory loader does not get the default charset
      assert.isUndefined(loader.charset);
      assert.equal(loader.loadArgs.data, data);
    });

    test('each load creates a new loader', () => {
      const controller = new LoadController();
      controller.loadFiles([], '0');
      controller.loadFiles([], '1');
      assert.equal(MockLoader.instances.length, 2);
      assert.notEqual(MockLoader.instances[0], MockLoader.instances[1]);
    });

  });

  /**
   * Tests for {@link LoadController} events.
   */
  describe('LoadController events', () => {

    test('loadEventNames', () => {
      assert.deepEqual(loadEventNames, [
        'loadstart',
        'loadprogress',
        'loaditem',
        'load',
        'loadend',
        'error',
        'abort',
        'timeout'
      ]);
    });

    test('forwards loader callbacks as tagged events', () => {
      const controller = new LoadController();
      const events = recordEvents(controller);
      controller.loadFiles([], 'id0');
      const loader = lastLoader();

      loader.onloadstart({source: 'src'});
      loader.onprogress({loaded: 50, total: 100});
      loader.onloaditem({data: 'item'});
      loader.onload({source: 'src'});
      loader.onerror({error: 'err'});
      loader.onabort({});
      loader.ontimeout({});
      loader.onloadend({source: 'src'});

      assert.deepEqual(events.map((e) => e.type), [
        'loadstart',
        'loadprogress',
        'loaditem',
        'load',
        'error',
        'abort',
        'timeout',
        'loadend'
      ]);
      for (const event of events) {
        assert.equal(event.detail.dataid, 'id0', `${event.type} dataid`);
        assert.isUndefined(event.detail.loadtype, `${event.type} loadtype`);
      }
      // original event content is kept
      assert.equal(events[0].detail.source, 'src');
      assert.equal(events[1].detail.loaded, 50);
      assert.equal(events[1].detail.total, 100);
      assert.equal(events[2].detail.data, 'item');
      assert.equal(events[4].detail.error, 'err');
    });

    test('local info overrides loader event info', () => {
      const controller = new LoadController();
      const events = recordEvents(controller);
      controller.loadFiles([], 'id0');
      lastLoader().onload({dataid: 'other'});
      assert.equal(events[0].detail.dataid, 'id0');
    });

    test('no timeout callback if loader does not support it', () => {
      MockLoader.hasTimeout = false;
      const controller = new LoadController();
      controller.loadFiles([], 'id0');
      assert.isUndefined(lastLoader().ontimeout);
    });

    test('loaditem isfirstitem flag', () => {
      const controller = new LoadController();
      const events = recordEvents(controller);
      controller.loadFiles([], 'id0');
      const loader = lastLoader();

      loader.onloadstart({});
      loader.onloaditem({});
      loader.onloaditem({});
      loader.onloaditem({});
      loader.onloadend({});
      // item after end: no current loader, no flag
      loader.onloaditem({});

      const items = events.filter((e) => e.type === 'loaditem');
      assert.equal(items.length, 4);
      assert.isTrue(items[0].detail.isfirstitem);
      assert.isFalse(items[1].detail.isfirstitem);
      assert.isFalse(items[2].detail.isfirstitem);
      assert.isUndefined(items[3].detail.isfirstitem);
    });

    test('isfirstitem is per data id', () => {
      const controller = new LoadController();
      const events = recordEvents(controller);
      controller.loadFiles([], 'id0');
      const loader0 = lastLoader();
      controller.loadURLs([], 'id1');
      const loader1 = lastLoader();

      loader0.onloadstart({});
      loader1.onloadstart({});
      loader0.onloaditem({});
      loader1.onloaditem({});
      loader0.onloaditem({});

      const items = events.filter((e) => e.type === 'loaditem');
      assert.equal(items[0].detail.dataid, 'id0');
      assert.isTrue(items[0].detail.isfirstitem);
      assert.equal(items[1].detail.dataid, 'id1');
      assert.isTrue(items[1].detail.isfirstitem);
      assert.equal(items[2].detail.dataid, 'id0');
      assert.isFalse(items[2].detail.isfirstitem);
    });

    test('load throw sends error and loadend', () => {
      MockLoader.throwOnLoad = true;
      const controller = new LoadController();
      const events = recordEvents(controller);
      assert.doesNotThrow(() => {
        controller.loadFiles([], 'id0');
      });

      assert.deepEqual(events.map((e) => e.type), ['error', 'loadend']);
      assert.equal(events[0].detail.dataid, 'id0');
      assert.instanceOf(events[0].detail.error, Error);
      assert.equal(events[0].detail.error.message, 'load failed');
      assert.equal(events[1].detail.dataid, 'id0');
      assert.deepEqual(controller.getLoadingDataIds(), []);
    });

  });

  /**
   * Tests for {@link LoadController} loading state and abort.
   */
  describe('LoadController loading state', () => {

    test('getLoadingDataIds', () => {
      const controller = new LoadController();
      assert.deepEqual(controller.getLoadingDataIds(), []);

      controller.loadFiles([], 'id0');
      const loader0 = lastLoader();
      // not stored before loadstart
      assert.deepEqual(controller.getLoadingDataIds(), []);
      loader0.onloadstart({});
      assert.deepEqual(controller.getLoadingDataIds(), ['id0']);

      controller.loadURLs([], 'id1');
      const loader1 = lastLoader();
      loader1.onloadstart({});
      assert.deepEqual(controller.getLoadingDataIds(), ['id0', 'id1']);

      loader0.onloadend({});
      assert.deepEqual(controller.getLoadingDataIds(), ['id1']);
      loader1.onloadend({});
      assert.deepEqual(controller.getLoadingDataIds(), []);
    });

    test('abort', () => {
      const controller = new LoadController();
      controller.loadFiles([], 'id0');
      const loader0 = lastLoader();
      loader0.onloadstart({});
      controller.loadFiles([], 'id1');
      const loader1 = lastLoader();
      loader1.onloadstart({});

      controller.abort('id0');
      assert.isTrue(loader0.abortCalled);
      assert.isFalse(loader1.abortCalled);
      assert.deepEqual(controller.getLoadingDataIds(), ['id1']);

      // second abort is a no-op
      loader0.abortCalled = false;
      controller.abort('id0');
      assert.isFalse(loader0.abortCalled);
    });

    test('abort unknown or finished data id', () => {
      const controller = new LoadController();
      assert.doesNotThrow(() => {
        controller.abort('unknown');
      });

      controller.loadFiles([], 'id0');
      const loader = lastLoader();
      loader.onloadstart({});
      loader.onloadend({});
      controller.abort('id0');
      assert.isFalse(loader.abortCalled);
    });

  });

});