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

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

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

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

const dates = jsonfile.readFileSync("test/formatDatetime/dates/dates.json");
const dates_ordinalDay = jsonfile.readFileSync(
  "test/formatDatetime/dates/ordinal-day.json"
);
const dates_strDay = jsonfile.readFileSync(
  "test/formatDatetime/dates/str-day.json"
);
const dates_strMonth = jsonfile.readFileSync(
  "test/formatDatetime/dates/str-month.json"
);
const datetimes = jsonfile.readFileSync(
  "test/formatDatetime/datetimes/datetimes.json"
);
const datetimes_ordinalDay = jsonfile.readFileSync(
  "test/formatDatetime/datetimes/ordinal-day.json"
);
const datetimes_strDay = jsonfile.readFileSync(
  "test/formatDatetime/datetimes/str-day.json"
);
const datetimes_strMonth = jsonfile.readFileSync(
  "test/formatDatetime/datetimes/str-month.json"
);
const datetimes_dd_mm_yyyy = jsonfile.readFileSync(
  "test/formatDatetime/datetimes/dd-mm-yyyy-time.json"
);
const objects = jsonfile.readFileSync("test/formatDatetime/objects.json");
const numbers = jsonfile.readFileSync("test/formatDatetime/numbers.json");
const stringNumbers = jsonfile.readFileSync(
  "test/formatDatetime/string-numbers.json"
);
const invalid = jsonfile.readFileSync("test/formatDatetime/invalid.json");

const testFormatDatetimeMethod = (assert, describe, input, expected, type) => {
  describe("test-1 #formatDatetime(date)", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].datetime;
      const actualResult = converter.formatDatetime(date, false, "", "", "2021");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

  describe("test-2 #formatDatetime(date, true)", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].ignoreTime;
      const actualResult = converter.formatDatetime(date, true, "", "", "2021");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

  describe("test-3 #formatDatetime(date, false, 'America/Denver')", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].inZone;
      const actualResult = converter.formatDatetime(date, false, "America/Denver", "", "2021");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

  describe("test-4 #formatDatetime(date, false, '+01:00')", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].inOffset;
      const actualResult = converter.formatDatetime(date, false, "+01:00", "", "2021");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

  describe("test-5 #formatDatetime(date, false, '+01:00', 'GMT+0')", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].outZone;
      const actualResult = converter.formatDatetime(date, false, "+01:00", "GMT+0", "2021");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

  describe("test-6 #formatDatetime(date, false, 'America/Denver', '-04:00')", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].outOffset;
      const actualResult = converter.formatDatetime(date, false, "America/Denver", "-04:00", "2021");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

  describe("test-7 #formatDatetime(date, false, '', '', '2005')", function () {
    input.forEach((date, i) => {
      if (typeof date === "number") key = "input-" + date;
      else key = date;
      if (type === "object") date = JSON.parse(date);
      const expectedResult = expected[key].year;
      const actualResult = converter.formatDatetime(date, false, "", "", "2005");
      if (actualResult) delete actualResult.isoWithFractSec;
      if (_.isUndefined(expectedResult.offsetNum)) delete actualResult.offsetNum;
      if (_.isUndefined(expectedResult.timezoneOffset)) delete actualResult.timezoneOffset;
      if (_.isUndefined(expectedResult.zoneName)) delete actualResult.zoneName;

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

// TYPE OF DATE WITHOUT TIME
const ddmmyyyy = [
  "6-10-2020, Indian/Kerguelen",
  "1995-02-04",
  "2020-18-04",
  "04-18-2020",
  "1995 2 04",
  "2020/18/4",
  "4-18-2020",
  "6-1-2020",
  "16.10.2020",
];
describe("input dates in format 'dd-mm-yyyy'", function () {
  testFormatDatetimeMethod(assert, describe, ddmmyyyy, dates);
});


const ddmmyy = [
  "20-18-4 Indian/Kerguelen",
  "95-02-04",
  "20.18.04",
  "04-18-20",
  "06.10.20",
  "4 18 20",
  "6-10-20",
  "20/18/04",
  "10/06/20",
];
describe("input dates in format 'dd-mm-yy'", function () {
  testFormatDatetimeMethod(assert, describe, ddmmyy, dates);
});

describe("input dates in format '1st April 2020', '1999 sep 3rd' etc.", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(dates_ordinalDay),
    dates_ordinalDay
  );
});

describe("input dates in format 'mm-yyyy', 'yyyy/mm' etc.", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    ["12/1999", "10.2020"],
    dates
  );
});

describe("input dates in format 'first April 2020', '1999 sep twenty' etc.", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(dates_strDay),
    dates_strDay
  );
});

describe("input dates in format '6 April 2020', '1999 sep 20' etc.", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(dates_strMonth),
    dates_strMonth
  );
});

// TYPE OF DATE/TIME

describe("input dates in format 'dd-mm-yyyy'", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(datetimes_dd_mm_yyyy),
    datetimes_dd_mm_yyyy
  );
});

describe("input dates in format 'dd-mm-yy' + time, '20150930 212421 -0400', '1995-02-04T10:00+01:00' etc.", function () {
  testFormatDatetimeMethod(assert, describe, Object.keys(datetimes), datetimes);
});

describe("input dates in format '1st April 2020', '1999 sep 3rd' etc. + time", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(datetimes_ordinalDay),
    datetimes_ordinalDay
  );
});

describe("input dates in format 'first April 2020', '1999 sep twenty' etc. + time", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(datetimes_strDay),
    datetimes_strDay
  );
});

describe("input dates in format '6 April 2020', '1999 sep 20' etc. + time", function () {
  testFormatDatetimeMethod(
    assert,
    describe,
    Object.keys(datetimes_strMonth),
    datetimes_strMonth
  );
});

// TYPE OF NUMBER

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

// TYPE OF STRING NUMBER

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

// TYPE OF OBJECT

describe("input date/datetime object", function () {
  testFormatDatetimeMethod(assert, describe, Object.keys(objects), objects, 'object');
});

// INVALID

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

// OTHER

describe("examples", function () {
  it(`"1995-02-04 10:00", false, "Europe/Kiev"`, function () {
    assert.deepEqual(
      converter.formatDatetime("1995-02-04 10:00", false, "Europe/Kiev", "", "2021"),
      {
        date: "1995-02-04T10:00:00+02:00",
        isoWithFractSec: '1995-02-04T10:00:00.000+02:00',
        timezoneOffset: "+02:00",
        zoneName: "Europe/Kiev",
        offsetNum: 2,
      }
    );
  });
  it(`"12-12-2020 10:20+06:00", false, "Europe/Kiev"`, function () {
    assert.deepEqual(
      converter.formatDatetime("12-12-2020 10:20+06:00", false, "Europe/Kiev", "", "2021"),
      {
        date: "2020-12-12T10:20:00+06:00",
        isoWithFractSec: '2020-12-12T10:20:00.000+06:00',
        timezoneOffset: "+06:00",
        zoneName: "",
        offsetNum: 6,
      }
    );
  });
  it(`"1995-02-04 10:00", false, "Europe/Kiev", "-03:00"`, function () {
    assert.deepEqual(
      converter.formatDatetime(
        "1995-02-04 10:00",
        false,
        "Europe/Kiev",
        "-03:00", "2021"
      ),
      {
        date: "1995-02-04T05:00:00-03:00",
        isoWithFractSec: '1995-02-04T05:00:00.000-03:00',
        timezoneOffset: "-03:00",
        zoneName: "",
        offsetNum: -3,
      }
    );
  });
  it(`"1995-02-04 10:00", true`, function () {
    assert.deepEqual(converter.formatDatetime("1995-02-04 10:00", true, "", "", "2021"), {
      date: "1995-02-04T10:00:00Z",
      isoWithFractSec: '1995-02-04T10:00:00.000Z',
      timezoneOffset: undefined,
      zoneName: undefined,
      offsetNum: undefined,
    });
  });
  it(`28OCT1990`, function () {
    assert.deepEqual(converter.formatDatetime("28OCT1990", false, "", "", "2021"), {
      date: "1990-10-28T00:00:00Z",
      isoWithFractSec: '1990-10-28T00:00:00.000Z',
      timezoneOffset: "Z",
      zoneName: "",
      offsetNum: 0,
    });
  });
  it(`PT444037H35M28S`, function () {
    assert.deepEqual(converter.formatDatetime("PT444037H35M28S", false, "", "", "2021"), {
      date: "2020-08-27T13:35:28Z",
      isoWithFractSec: '2020-08-27T13:35:28.000Z',
      timezoneOffset: "Z",
      zoneName: "",
      offsetNum: 0,
    });
  });

  it(`1560211200000`, function () {
    assert.deepEqual(converter.formatDatetime(1560211200000, false, "", "", "2021"), {
      date: "2019-06-11T00:00:00Z",
      isoWithFractSec: '2019-06-11T00:00:00.000Z',
      timezoneOffset: "Z",
      zoneName: "",
      offsetNum: 0,
    });
  });
  it(`1318874398`, function () {
    assert.deepEqual(converter.formatDatetime(1318874398, false, "", "", "2021"), {
      date: "2011-10-17T17:59:58Z",
      isoWithFractSec: '2011-10-17T17:59:58.000Z',
      timezoneOffset: "Z",
      zoneName: "",
      offsetNum: 0,
    });
  });
  it(`object`, function () {
    assert.deepEqual(
      converter.formatDatetime(
        {
          year: 2010,
          month: 3,
          day: 5,
          hour: 15,
          minute: 10,
          second: 3,
          millisecond: 123,
        },
        false,
        "UTC", "", "2021"
      ),
      {
        date: "2010-04-05T15:10:03+00:00",
        isoWithFractSec: '2010-04-05T15:10:03.123+00:00',
        timezoneOffset: "+00:00",
        zoneName: "UTC",
        offsetNum: 0,
      }
    );
  });
  it(`"2005-08-09T18:31:42/P3Y6M4DT12H30M17S",
    false,
    "+02:00"`, function () {
    assert.deepEqual(
      converter.formatDatetime(
        "2005-08-09T18:31:42/P3Y6M4DT12H30M17S",
        false,
        "+02:00", "", "2021"
      ),
      {
        date: "2009-02-12T07:01:59+02:00",
        isoWithFractSec: '2009-02-12T07:01:59.000+02:00',
        timezoneOffset: "+02:00",
        zoneName: "",
        offsetNum: 2,
      }
    );
  });
  it(`"1995-02-04 10:00", false, "Europe/Kiev"`, function () {
    assert.deepEqual(
      converter.formatDatetime("1995-02-04 10:00", false, "Europe/Kiev", "", "2021"),
      {
        date: "1995-02-04T10:00:00+02:00",
        isoWithFractSec: '1995-02-04T10:00:00.000+02:00',
        timezoneOffset: "+02:00",
        zoneName: "Europe/Kiev",
        offsetNum: 2,
      }
    );
  });
  it(`"11 August", true, "", "Europe/Kiev", 1999`, function () {
    assert.deepEqual(
      converter.formatDatetime("11 August", true, "", "Europe/Kiev", 1999),
      {
        date: "1999-08-11",
        isoWithFractSec: '1999-08-11T00:00:00.000Z',
        timezoneOffset: undefined,
        zoneName: undefined,
        offsetNum: undefined,
      }
    );
  });
  it(`"September 23rd", false, "GMT+0", ""`, function () {
    assert.deepEqual(
      converter.formatDatetime("September 23rd", false, "GMT+0", "", "2021"),
      {
        date: "2021-09-23T00:00:00+00:00",
        isoWithFractSec: '2021-09-23T00:00:00.000+00:00',
        timezoneOffset: "+00:00",
        zoneName: "GMT+0",
        offsetNum: 0,
      }
    );
  });
  it(`"sixteenth December",
    false,
    "Europe/Kiev",
    "GMT+0"`, function () {
    assert.deepEqual(
      converter.formatDatetime(
        "sixteenth December",
        false,
        "Europe/Kiev",
        "GMT+0",
        2020
      ),
      {
        date: "2020-12-15T22:00:00+00:00",
        isoWithFractSec: '2020-12-15T22:00:00.000+00:00',
        timezoneOffset: "+00:00",
        zoneName: "GMT+0",
        offsetNum: 0,
      }
    );
  });

  // v1.0.14

  it(`"2021-06-10T10:24:19Z+03:00", "GMT+0", "GMT+0"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-06-10T10:24:19Z+03:00", false, "GMT+0", "GMT+0", "2021"),
      {
        date: '2021-06-10T07:24:19+00:00',
        isoWithFractSec: '2021-06-10T07:24:19.000+00:00',
        timezoneOffset: '+00:00',
        zoneName: 'GMT+0',
        offsetNum: 0
      }
    );
  });
  it(`"2021-06-10T10:24:19Z+03:00", true`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-06-10T10:24:19Z+03:00", false, "", "", "2021"),
      {
        date: '2021-06-10T10:24:19+03:00',
        isoWithFractSec: '2021-06-10T10:24:19.000+03:00',
        timezoneOffset: '+03:00',
        zoneName: '',
        offsetNum: 3
      }
    );
  });

  // 1.0.15

  it(`"2021-September-29 3 10-01:00"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-September-29 3 10-01:00", false, "", "", "2021"),
      {
        date: '2021-09-29T03:10:00-01:00',
        isoWithFractSec: '2021-09-29T03:10:00.000-01:00',
        timezoneOffset: '-01:00',
        zoneName: '',
        offsetNum: -1
      }
    );
  });
  it(`"2021-September-29 3:16+01:00"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-September-29 3:16+01:00", false, "", "", "2021"),
      {
        date: '2021-09-29T03:16:00+01:00',
        isoWithFractSec: '2021-09-29T03:16:00.000+01:00',
        timezoneOffset: '+01:00',
        zoneName: '',
        offsetNum: 1
      }
    );
  });
  it(`"2021-September-29 3:16:00+01:00"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-September-29 3:16:00+01:00", false, "", "", "2021"),
      {
        date: '2021-09-29T03:16:00+01:00',
        isoWithFractSec: '2021-09-29T03:16:00.000+01:00',
        timezoneOffset: '+01:00',
        zoneName: '',
        offsetNum: 1
      }
    );
  });
  it(`"2021-September-29 3:16"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-September-29 3:16", false, "", "", "2021"),
      {
        date: '2021-09-29T03:16:00Z',
        isoWithFractSec: '2021-09-29T03:16:00.000Z',
        timezoneOffset: 'Z',
        zoneName: '',
        offsetNum: 0
      }
    );
  });
  it(`"2021-September-29 03:16:52 pm"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-September-29 03:16:52 pm", false, "", "", "2021"),
      {
        date: '2021-09-29T15:16:52Z',
        isoWithFractSec: '2021-09-29T15:16:52.000Z',
        timezoneOffset: 'Z',
        zoneName: '',
        offsetNum: 0
      }
    );
  });
  it(`"2021-September-29 03 pm"`, function () {
    assert.deepEqual(
      converter.formatDatetime("2021-September-29 03 pm", false, "", "", "2021"),
      {
        date: '2021-09-29T15:00:00Z',
        isoWithFractSec: '2021-09-29T15:00:00.000Z',
        timezoneOffset: 'Z',
        zoneName: '',
        offsetNum: 0
      }
    );
  });
});

// v1.0.16

it(`"6 April, 3456", "GMT+0", "GMT+0"`, function () {
  assert.deepEqual(
    converter.formatDatetime("6 April, 3456", false, "GMT+0", "GMT+0", "2021"),
    {
      date: '3456-04-06T00:00:00+00:00',
      isoWithFractSec: '3456-04-06T00:00:00.000+00:00',
      timezoneOffset: '+00:00',
      zoneName: 'GMT+0',
      offsetNum: 0
    }
  );
});

it(`"5432-06-10T10:24:19Z+03:00"`, function () {
  assert.deepEqual(
    converter.formatDatetime("5432-06-10T10:24:19Z+03:00", false, "", "", "2021"),
    {
      date: '5432-06-10T10:24:19+03:00',
      isoWithFractSec: '5432-06-10T10:24:19.000+03:00',
      timezoneOffset: '+03:00',
      zoneName: '',
      offsetNum: 3
    }
  ); 
});

it(`"6 April", "GMT+0", "GMT+0"`, function () {
    assert.deepEqual(
      converter.formatDatetime("6 April", false, "GMT+0", "GMT+0", 5555),
      {
        date: '5555-04-06T00:00:00+00:00',
        isoWithFractSec: '5555-04-06T00:00:00.000+00:00',
        timezoneOffset: '+00:00',
        zoneName: 'GMT+0',
        offsetNum: 0
      }
    ); 
});

it(`"4567-September-29 3 10-01:00"`, function () {
  assert.deepEqual(
    converter.formatDatetime("4567-September-29 3 10-01:00", false, "", "", "2021"),
    {
      date: '4567-09-29T03:10:00-01:00',
      isoWithFractSec: '4567-09-29T03:10:00.000-01:00',
      timezoneOffset: '-01:00',
      zoneName: '',
      offsetNum: -1
    }
  );
});

// 1.0.17

it(`"2010-04-05T15:10:03+00:00"`, function () {
  assert.deepEqual(
    converter.formatDatetime("2010-04-05T15:10:03+00:00", false, "", "", "2021"),
      {
        "date": "2010-04-05T15:10:03+00:00",
        "isoWithFractSec": "2010-04-05T15:10:03.000+00:00",
        "zoneName": "",
        "offsetNum": 0,
        "timezoneOffset": "+00:00"
      }
  ); 
});
it(`"12 Apr 12-30-00.123Z"`, function () {
  assert.deepEqual(
    converter.formatDatetime("12 Apr 12-30-00.123Z", false, "GMT+0", "", "2021"),
    {
      "date": "2021-04-12T12:30:00+00:00",
      "isoWithFractSec": "2021-04-12T12:30:00.123+00:00",
      "zoneName": "",
      "offsetNum": 0,
      "timezoneOffset": "+00:00"
    }
  ); 
});