Replace Ruby tests with JS tests

Author: t-bowersox

README.md

@@ -2,6 +2,10 @@
 
 Returns the difference between two times.
 
+## System requirements
+
+Node.js >= 20.18.0
+
 ## Installation
 
 ```shell

bin/cli.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 import process from "node:process";
-import { main } from "../src/index.js";
+import { parseArgs } from "node:util";
+import { getTimeDiff } from "../src/index.js";
 
 try {
-  main();
+  const { positionals } = parseArgs({ allowPositionals: true });
+  console.log(getTimeDiff(positionals));
 } catch (error) {
   process.exitCode = 1;
   console.error(error.message);

package.json

@@ -13,7 +13,8 @@
   "scripts": {
     "format": "prettier . --write",
     "lint": "eslint . --fix",
-    "test": "node --test test/"
+    "test": "node --test test/",
+    "test:watch": "node --test --watch test/"
   },
   "repository": {
     "type": "git",

src/index.js

@@ -1,20 +1,19 @@
-import { parseArgs } from "node:util";
 import { stringToDate } from "./lib/normalize.js";
 import { TimeDiff } from "./lib/time-diff.js";
 
-export function main() {
-  const { positionals } = parseArgs({ allowPositionals: true });
-
-  switch (positionals.length) {
+/**
+ * Returns the difference between two times.
+ * @param {[string, string]} times The start and end times to compare.
+ * @returns {string} The difference between the start and end times.
+ */
+export function getTimeDiff(times) {
+  switch (times.length) {
     case 0:
       throw new Error("Usage: time-diff <start_time> <end_time>");
     case 1:
       throw new Error("An end time is required.");
   }
 
-  const startTime = stringToDate(positionals[0]);
-  const endTime = stringToDate(positionals[1]);
-  const diff = new TimeDiff(startTime, endTime);
-
-  console.log(diff.toString());
+  const [start, end] = times;
+  return new TimeDiff(stringToDate(start), stringToDate(end)).toString();
 }

src/lib/normalize.js

@@ -12,22 +12,24 @@
 //#region Constants
 
 const TIME_REGEX =
-  /^(?<hour>\d{1,2})?:?(?<min>\d{1,2})?:?(?<sec>\d{1,2})?\s?(?<ord>am|pm)?$/i;
+  /^(?<hour>\d{1,2})?:?(?<min>\d{1,2})?:?(?<sec>\d{1,2})?\s?(?<mer>am|pm)?$/i;
 
 //#endregion
 
 /**
  * Normalizes the provirded hour, min, sec, and ordinal values.
- * @param {string|undefined} hour
- * @param {string|undefined} min
- * @param {string|undefined} sec
- * @param {string|undefined} ord
+ * @param {string|undefined} hour The hour to normalize.
+ * @param {string|undefined} min The minute to normalize.
+ * @param {string|undefined} sec The second to normalize.
+ * @param {string|undefined} mer The meridiem (AM/PM), if using 12h format.
  * @returns {NormalizedTime} The time normalized on a 24h clock.
  */
-function getNormalizedTime(hour, min, sec, ord) {
+function getNormalizedTime(hour, min, sec, mer) {
   hour = hour ? parseInt(hour) : 0;
 
-  if (ord?.toLowerCase() == "pm" && hour < 12) {
+  if (mer?.toLowerCase() == "am" && hour == 12) {
+    hour -= 12;
+  } else if (mer?.toLowerCase() == "pm" && hour < 12) {
     hour += 12;
   }
 
@@ -43,15 +45,19 @@ function getNormalizedTime(hour, min, sec, ord) {
  * @returns {Date} A date parsed from the provided date-time string.
  */
 export function stringToDate(dateTimeStr) {
+  if (typeof dateTimeStr != "string") {
+    dateTimeStr = String(dateTimeStr);
+  }
+
   if (dateTimeStr.toLowerCase() == "now") {
     return new Date();
   }
 
   const timeMatch = dateTimeStr.match(TIME_REGEX);
 
   if (timeMatch != null) {
-    const { hour, min, sec, ord } = timeMatch.groups;
-    const normalized = getNormalizedTime(hour, min, sec, ord);
+    const { hour, min, sec, mer } = timeMatch.groups;
+    const normalized = getNormalizedTime(hour, min, sec, mer);
 
     const today = new Date();
     today.setHours(normalized.hour, normalized.min, normalized.sec);

src/lib/time-diff.js

@@ -70,7 +70,7 @@ export class TimeDiff {
   }
 
   toString() {
-    if (this.value == 0) {
+    if (this.seconds == 0) {
       return "No difference";
     }
 
@@ -81,7 +81,7 @@ export class TimeDiff {
   }
 
   /** The time difference rounded to the nearest second. */
-  get value() {
+  get seconds() {
     const diffMs = this.#endTime - this.#startTime;
     return Math.round(diffMs / 1000);
   }
@@ -118,7 +118,7 @@ export class TimeDiff {
    */
   #timeToUnits() {
     const units = {};
-    let diffSeconds = this.value;
+    let diffSeconds = this.seconds;
 
     this.#units.forEach((seconds, unit) => {
       units[unit] = 0;

test/index.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { getTimeDiff } from "../src/index.js";
+import { TimeDiff } from "../src/lib/time-diff.js";
+
+describe("getTimeDiff", () => {
+  it("Should throw usage instructions if no times provided", () => {
+    assert.throws(() => {
+      getTimeDiff([]);
+    }, new Error("Usage: time-diff <start_time> <end_time>"));
+  });
+
+  it("Should throw error if only one time provided", () => {
+    assert.throws(() => {
+      getTimeDiff(["8:00 am"]);
+    }, new Error("An end time is required."));
+  });
+
+  it("Should return the difference bweteen two times as a string", () => {
+    const start = new Date(2024, 0, 1, 12, 0, 0);
+    const end = new Date(2024, 0, 16, 14, 2, 2);
+    const diff = new TimeDiff(start, end);
+    const expectedString = "2 weeks, 1 day, 2 hours, 2 minutes, 2 seconds";
+
+    assert.equal(diff.toString(), expectedString);
+  });
+});

test/main.test.js

@@ -0,0 +1,93 @@
+import assert from "node:assert";
+import { afterEach, beforeEach, describe, it, mock } from "node:test";
+import { stringToDate } from "../src/lib/normalize.js";
+
+describe("stringToDate", () => {
+  beforeEach(() => {
+    mock.timers.enable({
+      apis: ["Date"],
+      now: new Date(2024, 0, 1, 0, 0, 0, 0),
+    });
+  });
+
+  afterEach(() => {
+    mock.timers.reset();
+  });
+
+  it('should return the current date if "now" is provided', () => {
+    assert.deepStrictEqual(stringToDate("now"), new Date());
+  });
+
+  it("should return a date when given only a time", () => {
+    const testSet = [
+      ["12:00 am", 0, 0],
+      ["12:00am", 0, 0],
+      ["12:00 AM", 0, 0],
+      ["12:00AM", 0, 0],
+      ["1:30 am", 1, 30],
+      ["1:30 AM", 1, 30],
+      ["1:30am", 1, 30],
+      ["1:30AM", 1, 30],
+      ["01:30AM", 1, 30],
+      ["01:30am", 1, 30],
+      ["01:30 am", 1, 30],
+      ["01:30 AM", 1, 30],
+      ["01:30", 1, 30],
+      ["12:00 pm", 12, 0],
+      ["12:00pm", 12, 0],
+      ["12:00 PM", 12, 0],
+      ["12:00PM", 12, 0],
+      ["1:30 pm", 13, 30],
+      ["1:30 PM", 13, 30],
+      ["1:30pm", 13, 30],
+      ["1:30PM", 13, 30],
+      ["01:30PM", 13, 30],
+      ["01:30pm", 13, 30],
+      ["01:30 pm", 13, 30],
+      ["01:30 PM", 13, 30],
+      ["13:30", 13, 30],
+    ];
+
+    for (const [time, hour, min] of testSet) {
+      const expectedDate = new Date();
+      expectedDate.setHours(hour, min);
+
+      assert.deepEqual(
+        stringToDate(time),
+        expectedDate,
+        `${time} should yield ${expectedDate.toISOString()}.`,
+      );
+    }
+  });
+
+  it("should return a date from the provided string", () => {
+    const expectedDate = new Date();
+    expectedDate.setFullYear(2024, 11, 31);
+    expectedDate.setHours(0, 0);
+
+    const testSet = [
+      "12/31/2024 12:00 am",
+      "2024-12-31T00:00:00",
+      "Dec 31, 2024 12:00 am",
+      "31 Dec, 2024 12:00 am",
+      "December 31, 2024 12:00 AM",
+    ];
+
+    for (const dateStr of testSet) {
+      assert.deepEqual(
+        stringToDate(dateStr),
+        expectedDate,
+        `${dateStr} should yield ${expectedDate}.`,
+      );
+    }
+  });
+
+  it("should handle invalid inputs", () => {
+    assert.doesNotThrow(() => stringToDate("foobar"));
+    assert.doesNotThrow(() => stringToDate());
+    assert.doesNotThrow(() => stringToDate(null));
+    assert.doesNotThrow(() => stringToDate(42));
+    assert.doesNotThrow(() => stringToDate(["foo,", "bar"]));
+    assert.doesNotThrow(() => stringToDate({ foo: "bar" }));
+  });
+});