@onereach/time-interpreter/test/formatTime.test.js

Convert dates, durations and time to canonical format (dates -> ISO 8601, durations -> milliseconds).

const jsonfile = require("jsonfile/index.js");
const assert = require("assert").strict;

const Interpreter = require("../index.js");
const converter = new Interpreter();

const objects = jsonfile.readFileSync("test/formatTime/objects.json");
const numbers = jsonfile.readFileSync("test/formatTime/numbers.json");
const stringNumbers = jsonfile.readFileSync(
  "test/formatTime/string-numbers.json"
);
const times = jsonfile.readFileSync("test/formatTime/times.json");
const invalid = jsonfile.readFileSync("test/formatTime/invalid.json");

const testFormatTime = (assert, describe, input, expected) => {
  const defResult = {
    "offsetNum": undefined,
    "time": undefined,
    "timezoneOffset": undefined,
    "zoneName": undefined
  };

  describe("test-1 #formatTime(time)", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else if (typeof date === "object") key = JSON.stringify(date);
      else key = date;

      let expectedResult = expected[key].time;
      const actualResult = converter.formatTime(date);
      if (actualResult) delete actualResult.timeWithFractSec;
      if (JSON.stringify(expectedResult) === "{}") expectedResult = defResult;

      it(key, function () {
        assert.deepEqual(actualResult, expectedResult);
      });
    });
  });
};

// TYPE OF NUMBER

describe("input number timestamp", function () {
  testFormatTime(
    assert,
    describe,
    [
      1234567,
      123456,
      34567890,
      169753368995,
      11234566744,
      1560211200000,
      1318874398,
      283142,
      583042,
    ],
    numbers
  );
});

// TYPE OF STRING NUMBER

describe("input string number timestamp", function () {
  testFormatTime(assert, describe, Object.keys(stringNumbers), stringNumbers);
});

// TYPE OF OBJECT

describe("input time object", function () {
  const obj = Object.keys(objects).map((k) => JSON.parse(k.replace(/\//g, "")));
  testFormatTime(assert, describe, obj, objects);
});

// TIMES

describe("input string", function () {
  testFormatTime(assert, describe, Object.keys(times), times);
});

// 1.0.15

it(`"3 10-01:00"`, function () {
  assert.deepEqual(
    converter.formatTime("3 10-01:00"),
    {
      time: '03:10:00-01:00',
      timeWithFractSec: "03:10:00.000-01:00",
      timezoneOffset: '-01:00',
      zoneName: '',
      offsetNum: -1
    }
  );
});
it(`"3:16+01:00"`, function () {
  assert.deepEqual(
    converter.formatTime("3:16+01:00"),
    {
      time: '03:16:00+01:00',
      timeWithFractSec: "03:16:00.000+01:00",
      timezoneOffset: '+01:00',
      zoneName: '',
      offsetNum: 1
    }
  );
});
it(`"3:16:00+01:00"`, function () {
  assert.deepEqual(
    converter.formatTime("3:16:00+01:00"),
    {
      time: '03:16:00+01:00',
      timeWithFractSec: "03:16:00.000+01:00",
      timezoneOffset: '+01:00',
      zoneName: '',
      offsetNum: 1
    }
  );
});
it(`"3:16"`, function () {
  assert.deepEqual(
    converter.formatTime("3:16"),
    {
      time: '03:16:00Z',
      timeWithFractSec: "03:16:00.000Z",
      timezoneOffset: 'Z',
      zoneName: '',
      offsetNum: 0
    }
  );
});
it(`"03:16:52 pm"`, function () {
  assert.deepEqual(
    converter.formatTime("03:16:52 pm"),
    {
      time: '15:16:52Z',
      timeWithFractSec: "15:16:52.000Z",
      timezoneOffset: 'Z',
      zoneName: '',
      offsetNum: 0
    }
  );
});
it(`"03 pm"`, function () {
  assert.deepEqual(
    converter.formatTime("03 pm"),
    {
      time: '15:00:00Z',
      timeWithFractSec: "15:00:00.000Z",
      timezoneOffset: 'Z',
      zoneName: '',
      offsetNum: 0
    }
  );
});

// 1.0.17
it(`"12 30 00.123Z"`, function () {
  assert.deepEqual(
    converter.formatTime("12 30 00.123Z"),
    {
      "time": "12:30:00Z",
      "timeWithFractSec": "12:30:00.123Z",
      "zoneName": "",
      "offsetNum": 0,
      "timezoneOffset": "Z"
    }
  ); 
});

// INVALID

describe("invalid input", function () {
  testFormatTime(assert, describe, Object.keys(invalid), invalid);
});