scorm-again/test/utilities.spec.js

import {expect} from 'chai';
import {describe, it} from 'mocha';
import * as Utilities from '../src/utilities';
import {scorm12_regex, scorm2004_regex} from '../src/regex';

describe('Utility Tests', () => {
  describe('getSecondsAsHHMMSS()', () => {
    it('10 returns 00:00:10', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(10),
      ).to.equal('00:00:10');
    });

    it('60 returns 00:01:00', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(60),
      ).to.equal('00:01:00');
    });

    it('3600 returns 01:00:00', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(3600),
      ).to.equal('01:00:00');
    });

    it('70 returns 00:01:10', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(70),
      ).to.equal('00:01:10');
    });

    it('3670 returns 01:01:10', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(3670),
      ).to.equal('01:01:10');
    });

    it('90000 returns 25:00:00, check for hours greater than 24', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(90000),
      ).to.equal('25:00:00');
    });

    it('-3600 returns 00:00:00, negative time not allowed in SCORM session times',
        () => {
          expect(
              Utilities.getSecondsAsHHMMSS(-3600),
          ).to.equal('00:00:00');
        });

    it('Empty seconds returns 00:00:00', () => {
      expect(
          Utilities.getSecondsAsHHMMSS(null),
      ).to.equal('00:00:00');
    });
  });

  describe('getSecondsAsISODuration()', () => {
    it('10 returns P10S', () => {
      expect(
          Utilities.getSecondsAsISODuration(10),
      ).to.equal('P10S');
    });

    it('60 returns P1M', () => {
      expect(
          Utilities.getSecondsAsISODuration(60),
      ).to.equal('P1M');
    });

    it('3600 returns P1H', () => {
      expect(
          Utilities.getSecondsAsISODuration(3600),
      ).to.equal('P1H');
    });

    it('70 returns P1M10S', () => {
      expect(
          Utilities.getSecondsAsISODuration(70),
      ).to.equal('P1M10S');
    });

    it('3670 returns P1H1M10S', () => {
      expect(
          Utilities.getSecondsAsISODuration(3670),
      ).to.equal('P1H1M10S');
    });

    it('90000 returns P1D1H', () => {
      expect(
          Utilities.getSecondsAsISODuration(90000),
      ).to.equal('P1D1H');
    });

    it('90061 returns P1D1H1M1S', () => {
      expect(
          Utilities.getSecondsAsISODuration(90061),
      ).to.equal('P1D1H1M1S');
    });

    it('-3600 returns P0S, negative time not allowed in SCORM session times',
        () => {
          expect(
              Utilities.getSecondsAsISODuration(-3600),
          ).to.equal('P0S');
        });

    it('Empty seconds returns P0S', () => {
      expect(
          Utilities.getSecondsAsISODuration(null),
      ).to.equal('P0S');
    });
  });

  describe('getTimeAsSeconds()', () => {
    it('00:00:10 returns 10', () => {
      expect(
          Utilities.getTimeAsSeconds('00:00:10', scorm12_regex.CMITimespan),
      ).to.equal(10);
    });

    it('00:01:10 returns 70', () => {
      expect(
          Utilities.getTimeAsSeconds('00:01:10', scorm12_regex.CMITimespan),
      ).to.equal(70);
    });

    it('01:01:10 returns 3670', () => {
      expect(
          Utilities.getTimeAsSeconds('01:01:10', scorm12_regex.CMITimespan),
      ).to.equal(3670);
    });

    it('100:00:00 returns 3670', () => {
      expect(
          Utilities.getTimeAsSeconds('100:00:00', scorm12_regex.CMITimespan),
      ).to.equal(360000);
    });

    it('-01:00:00 returns 0', () => {
      expect(
          Utilities.getTimeAsSeconds('-01:00:00', scorm12_regex.CMITimespan),
      ).to.equal(0);
    });

    it('Number value returns 0', () => {
      expect(
          Utilities.getTimeAsSeconds(999, scorm12_regex.CMITimespan),
      ).to.equal(0);
    });

    it('boolean value returns 0', () => {
      expect(
          Utilities.getTimeAsSeconds(true, scorm12_regex.CMITimespan),
      ).to.equal(0);
    });

    it('Empty value returns 0', () => {
      expect(
          Utilities.getTimeAsSeconds(null, scorm12_regex.CMITimespan),
      ).to.equal(0);
    });
  });

  describe('getDurationAsSeconds()', () => {
    it('P0S returns 0', () => {
      expect(
          Utilities.getDurationAsSeconds('P0S', scorm2004_regex.CMITimespan),
      ).to.equal(0);
    });

    it('P70S returns 70', () => {
      expect(
          Utilities.getDurationAsSeconds('P70S', scorm2004_regex.CMITimespan),
      ).to.equal(70);
    });

    it('PT1M10S returns 70', () => {
      expect(
          Utilities.getDurationAsSeconds('PT1M10S',
              scorm2004_regex.CMITimespan),
      ).to.equal(70);
    });

    it('P1D returns 86400', () => {
      expect(
          Utilities.getDurationAsSeconds('P1D', scorm2004_regex.CMITimespan),
      ).to.equal(86400);
    });

    it('P1M returns number of seconds for one month from now', () => {
      const now = new Date();
      const oneMonthFromNow = new Date(now);
      oneMonthFromNow.setMonth(oneMonthFromNow.getMonth() + 1);

      expect(
          Utilities.getDurationAsSeconds('P1M', scorm2004_regex.CMITimespan),
      ).to.equal((oneMonthFromNow - now) / 1000.0);
    });

    it('P1Y returns number of seconds for one year from now', () => {
      const now = new Date();
      const oneYearFromNow = new Date(now);
      oneYearFromNow.setFullYear(oneYearFromNow.getFullYear() + 1);

      expect(
          Utilities.getDurationAsSeconds('P1Y', scorm2004_regex.CMITimespan),
      ).to.equal((oneYearFromNow - now) / 1000.0);
    });

    it('Invalid duration returns 0', () => {
      expect(
          Utilities.getDurationAsSeconds('T1M10S', scorm2004_regex.CMITimespan),
      ).to.equal(0);
    });

    it('Empty duration returns 0', () => {
      expect(
          Utilities.getDurationAsSeconds(null, scorm2004_regex.CMITimespan),
      ).to.equal(0);
    });
  });

  describe('addTwoDurations()', () => {
    it('P1H5M30.5S plus PT15M10S equals P1H20M40.5S', () => {
      expect(
          Utilities.addTwoDurations('P1H5M30.5S', 'PT15M10S',
              scorm2004_regex.CMITimespan),
      ).to.equal('P1H20M40.5S');
    });
    it('P1Y364D plus P2D1H45M52S equals P732D1H45M52S', () => {
      expect(
          Utilities.addTwoDurations('P1Y364D', 'P2D1H45M52S',
              scorm2004_regex.CMITimespan),
      ).to.equal('P732D1H45M52S');
    });
    it('Invalid plus valid equals valid', () => {
      expect(
          Utilities.addTwoDurations('NOT A VALID DURATION', 'P1H30M45S',
              scorm2004_regex.CMITimespan),
      ).to.equal('P1H30M45S');
    });
    it('Valid plus invalid equals valid', () => {
      expect(
          Utilities.addTwoDurations('P1H30M45S', 'NOT A VALID DURATION',
              scorm2004_regex.CMITimespan),
      ).to.equal('P1H30M45S');
    });
  });

  describe('addHHMMSSTimeStrings()', () => {
    it('01:05:30.5 plus 00:15:10 equals 01:20:40.5', () => {
      expect(
          Utilities.addHHMMSSTimeStrings('01:05:30.5', '00:15:10',
              scorm12_regex.CMITimespan),
      ).to.equal('01:20:40.5');
    });
    it('17496:00:00 plus 49:35:52 equals 17545:35:52', () => {
      expect(
          Utilities.addHHMMSSTimeStrings('17496:00:00', '49:35:52',
              scorm12_regex.CMITimespan),
      ).to.equal('17545:35:52');
    });
    it('Invalid plus valid equals valid', () => {
      expect(
          Utilities.addHHMMSSTimeStrings('-00:15:10', '01:05:30.5',
              scorm12_regex.CMITimespan),
      ).to.equal('01:05:30.5');
    });
    it('Valid plus invalid equals valid', () => {
      expect(
          Utilities.addHHMMSSTimeStrings('01:05:30.5', 'NOT A VALID DURATION',
              scorm12_regex.CMITimespan),
      ).to.equal('01:05:30.5');
    });
  });
});