Test coverage

Author: martijnrusschen

package.json

@@ -65,6 +65,7 @@
     "babel-jest": "^30.0.2",
     "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
     "core-js": "^3.46.0",
+    "date-fns-tz": "^3.2.0",
     "eslint": "^9.19.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-import": "^2.31.0",
@@ -96,9 +97,9 @@
     "typescript-eslint": "^8.22.0"
   },
   "peerDependencies": {
+    "date-fns-tz": "^3.0.0",
     "react": "^16.9.0 || ^17 || ^18 || ^19 || ^19.0.0-rc",
-    "react-dom": "^16.9.0 || ^17 || ^18 || ^19 || ^19.0.0-rc",
-    "date-fns-tz": "^3.0.0"
+    "react-dom": "^16.9.0 || ^17 || ^18 || ^19 || ^19.0.0-rc"
   },
   "peerDependenciesMeta": {
     "date-fns-tz": {

src/test/timezone_test.test.tsx

@@ -6,6 +6,7 @@ import {
 } from "../date_utils";
 
 describe("Timezone utility functions", () => {
+  // Use a fixed UTC date for consistent testing
   const testDate = new Date("2024-06-15T12:00:00Z");
 
   describe("toZonedTime", () => {
@@ -19,20 +20,36 @@ describe("Timezone utility functions", () => {
       expect(result).toBe(testDate);
     });
 
-    it("should return the original date when date-fns-tz is not installed", () => {
-      // Suppress console.warn for this test
-      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-      // Since date-fns-tz is not installed, it should return the original date
+    it("should convert UTC date to specified timezone", () => {
+      // 2024-06-15T12:00:00Z in America/New_York (EDT, UTC-4) should be 08:00
       const result = toZonedTime(testDate, "America/New_York");
-      expect(result).toBe(testDate);
+      expect(result).toBeInstanceOf(Date);
+      // The result should represent 08:00 in New York time
+      expect(result.getHours()).toBe(8);
+      expect(result.getMinutes()).toBe(0);
+    });
 
-      // Should have warned about missing date-fns-tz
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("date-fns-tz"),
-      );
+    it("should handle UTC timezone", () => {
+      const result = toZonedTime(testDate, "UTC");
+      expect(result).toBeInstanceOf(Date);
+      // toZonedTime returns a date that represents the time in the target timezone
+      // When displayed locally, it should show 12:00 (the UTC time)
+      expect(result.getHours()).toBe(12);
+      expect(result.getMinutes()).toBe(0);
+    });
 
-      warnSpy.mockRestore();
+    it("should handle different timezones", () => {
+      // Test with Europe/London (BST in June, UTC+1)
+      const londonResult = toZonedTime(testDate, "Europe/London");
+      expect(londonResult).toBeInstanceOf(Date);
+      // 12:00 UTC should be 13:00 in London during BST
+      expect(londonResult.getHours()).toBe(13);
+
+      // Test with Asia/Tokyo (JST, UTC+9)
+      const tokyoResult = toZonedTime(testDate, "Asia/Tokyo");
+      expect(tokyoResult).toBeInstanceOf(Date);
+      // 12:00 UTC should be 21:00 in Tokyo
+      expect(tokyoResult.getHours()).toBe(21);
     });
   });
 
@@ -47,15 +64,28 @@ describe("Timezone utility functions", () => {
       expect(result).toBe(testDate);
     });
 
-    it("should return the original date when date-fns-tz is not installed", () => {
-      // Suppress console.warn for this test
-      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    it("should convert zoned time to UTC", () => {
+      // Create a date representing 08:00 in New York (which is 12:00 UTC in June)
+      const nyDate = new Date("2024-06-15T08:00:00");
+      const result = fromZonedTime(nyDate, "America/New_York");
+      expect(result).toBeInstanceOf(Date);
+      // The result should be 12:00 UTC
+      expect(result.getUTCHours()).toBe(12);
+    });
 
-      // Since date-fns-tz is not installed, it should return the original date
-      const result = fromZonedTime(testDate, "America/New_York");
-      expect(result).toBe(testDate);
+    it("should handle UTC timezone", () => {
+      const utcDate = new Date("2024-06-15T12:00:00");
+      const result = fromZonedTime(utcDate, "UTC");
+      expect(result).toBeInstanceOf(Date);
+      expect(result.getUTCHours()).toBe(12);
+    });
 
-      warnSpy.mockRestore();
+    it("should be inverse of toZonedTime", () => {
+      const timezone = "America/Los_Angeles";
+      const zonedTime = toZonedTime(testDate, timezone);
+      const backToUtc = fromZonedTime(zonedTime, timezone);
+      // The round-trip should give us back the original UTC time
+      expect(backToUtc.getTime()).toBe(testDate.getTime());
     });
   });
 
@@ -66,19 +96,38 @@ describe("Timezone utility functions", () => {
       expect(result).toBe("2024-06-15");
     });
 
-    it("should use standard format when date-fns-tz is not installed", () => {
-      // Suppress console.warn for this test
-      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-      // Since date-fns-tz is not installed, it should fall back to standard format
+    it("should format date in specified timezone", () => {
+      // 2024-06-15T12:00:00Z formatted in America/New_York should show 08:00
       const result = formatInTimeZone(
         testDate,
-        "yyyy-MM-dd",
+        "yyyy-MM-dd HH:mm",
         "America/New_York",
       );
-      expect(result).toBe("2024-06-15");
+      expect(result).toBe("2024-06-15 08:00");
+    });
+
+    it("should format date in UTC timezone", () => {
+      const result = formatInTimeZone(testDate, "yyyy-MM-dd HH:mm", "UTC");
+      expect(result).toBe("2024-06-15 12:00");
+    });
+
+    it("should format date in different timezones", () => {
+      // Europe/London (BST in June, UTC+1)
+      const londonResult = formatInTimeZone(testDate, "HH:mm", "Europe/London");
+      expect(londonResult).toBe("13:00");
 
-      warnSpy.mockRestore();
+      // Asia/Tokyo (JST, UTC+9)
+      const tokyoResult = formatInTimeZone(testDate, "HH:mm", "Asia/Tokyo");
+      expect(tokyoResult).toBe("21:00");
+    });
+
+    it("should handle complex format strings", () => {
+      const result = formatInTimeZone(
+        testDate,
+        "EEEE, MMMM d, yyyy 'at' h:mm a",
+        "America/New_York",
+      );
+      expect(result).toBe("Saturday, June 15, 2024 at 8:00 AM");
     });
   });
 
@@ -92,20 +141,17 @@ describe("Timezone utility functions", () => {
       expect(result.getTime()).toBeLessThanOrEqual(after.getTime());
     });
 
-    it("should return current date when date-fns-tz is not installed", () => {
-      // Suppress console.warn for this test
-      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-      const before = new Date();
+    it("should return current date in specified timezone", () => {
       const result = nowInTimeZone("America/New_York");
-      const after = new Date();
-
-      // The result should be a Date object within the expected range
       expect(result).toBeInstanceOf(Date);
-      expect(result.getTime()).toBeGreaterThanOrEqual(before.getTime());
-      expect(result.getTime()).toBeLessThanOrEqual(after.getTime());
+      // We can't test exact time, but we can verify it's a valid date
+      expect(result.getTime()).not.toBeNaN();
+    });
 
-      warnSpy.mockRestore();
+    it("should return current date in UTC", () => {
+      const result = nowInTimeZone("UTC");
+      expect(result).toBeInstanceOf(Date);
+      expect(result.getTime()).not.toBeNaN();
     });
   });
 });
@@ -130,4 +176,88 @@ describe("Timezone utility functions - edge cases", () => {
       expect(result).toBe(date);
     });
   });
+
+  it("should handle DST transitions", () => {
+    // Test a date during DST (summer)
+    const summerDate = new Date("2024-07-15T12:00:00Z");
+    const summerResult = formatInTimeZone(
+      summerDate,
+      "HH:mm",
+      "America/New_York",
+    );
+    expect(summerResult).toBe("08:00"); // EDT (UTC-4)
+
+    // Test a date outside DST (winter)
+    const winterDate = new Date("2024-01-15T12:00:00Z");
+    const winterResult = formatInTimeZone(
+      winterDate,
+      "HH:mm",
+      "America/New_York",
+    );
+    expect(winterResult).toBe("07:00"); // EST (UTC-5)
+  });
+
+  it("should handle dates at midnight", () => {
+    const midnightUtc = new Date("2024-06-15T00:00:00Z");
+    const result = formatInTimeZone(
+      midnightUtc,
+      "yyyy-MM-dd HH:mm",
+      "America/New_York",
+    );
+    // Midnight UTC is 8 PM previous day in New York (EDT)
+    expect(result).toBe("2024-06-14 20:00");
+  });
+
+  it("should handle dates at end of day", () => {
+    const endOfDayUtc = new Date("2024-06-15T23:59:59Z");
+    const result = formatInTimeZone(
+      endOfDayUtc,
+      "yyyy-MM-dd HH:mm",
+      "Asia/Tokyo",
+    );
+    // 23:59 UTC is 08:59 next day in Tokyo (JST, UTC+9)
+    expect(result).toBe("2024-06-16 08:59");
+  });
+});
+
+describe("Timezone utility functions - integration", () => {
+  it("should correctly round-trip dates through timezone conversions", () => {
+    const originalDate = new Date("2024-06-15T15:30:00Z");
+    const timezones = [
+      "America/New_York",
+      "America/Los_Angeles",
+      "Europe/London",
+      "Europe/Paris",
+      "Asia/Tokyo",
+      "Australia/Sydney",
+      "UTC",
+    ];
+
+    timezones.forEach((tz) => {
+      const zoned = toZonedTime(originalDate, tz);
+      const backToUtc = fromZonedTime(zoned, tz);
+      expect(backToUtc.getTime()).toBe(originalDate.getTime());
+    });
+  });
+
+  it("should format consistently across different timezones", () => {
+    const utcDate = new Date("2024-06-15T00:00:00Z");
+
+    // All these should represent the same moment in time
+    const utcFormatted = formatInTimeZone(utcDate, "yyyy-MM-dd HH:mm", "UTC");
+    const nyFormatted = formatInTimeZone(
+      utcDate,
+      "yyyy-MM-dd HH:mm",
+      "America/New_York",
+    );
+    const tokyoFormatted = formatInTimeZone(
+      utcDate,
+      "yyyy-MM-dd HH:mm",
+      "Asia/Tokyo",
+    );
+
+    expect(utcFormatted).toBe("2024-06-15 00:00");
+    expect(nyFormatted).toBe("2024-06-14 20:00"); // Previous day in NY
+    expect(tokyoFormatted).toBe("2024-06-15 09:00"); // Same day, later in Tokyo
+  });
 });