renusify 3.1.3 → 3.1.5

package/tests/DateTime.test.js

@@ -0,0 +1,596 @@
+import DateTime from "../plugins/trans/DateTime.js";
+
+// Simple test utilities
+const colors = {
+  reset: "\x1b[0m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  gray: "\x1b[90m",
+};
+
+let testCount = 0;
+let passCount = 0;
+let failCount = 0;
+let currentSuite = "";
+
+function suite(name, fn) {
+  currentSuite = name;
+  console.log(`\n${colors.blue}${name}${colors.reset}`);
+  fn();
+}
+
+function test(description, fn) {
+  testCount++;
+  try {
+    fn();
+    passCount++;
+    console.log(`  ${colors.green}✓${colors.reset} ${description}`);
+  } catch (error) {
+    failCount++;
+    console.log(`  ${colors.red}✗${colors.reset} ${description}`);
+    console.log(`    ${colors.red}${error.message}${colors.reset}`);
+    if (error.stack) {
+      console.log(
+        `    ${colors.gray}${error.stack.split("\n").slice(1, 3).join("\n    ")}${colors.reset}`,
+      );
+    }
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failed");
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(
+      message ||
+        `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`,
+    );
+  }
+}
+
+function assertDeepEqual(actual, expected, message) {
+  const actualStr = JSON.stringify(actual);
+  const expectedStr = JSON.stringify(expected);
+  if (actualStr !== expectedStr) {
+    throw new Error(message || `Expected ${expectedStr}, but got ${actualStr}`);
+  }
+}
+
+function assertMatch(actual, pattern, message) {
+  if (!pattern.test(actual)) {
+    throw new Error(
+      message || `Expected "${actual}" to match pattern ${pattern}`,
+    );
+  }
+}
+
+function assertUndefined(actual, message) {
+  if (actual !== undefined) {
+    throw new Error(
+      message || `Expected undefined, but got ${JSON.stringify(actual)}`,
+    );
+  }
+}
+
+function assertDefined(actual, message) {
+  if (actual === undefined) {
+    throw new Error(message || "Expected value to be defined");
+  }
+}
+
+function assertGreaterThan(actual, expected, message) {
+  if (actual <= expected) {
+    throw new Error(
+      message || `Expected ${actual} to be greater than ${expected}`,
+    );
+  }
+}
+
+// Mock console methods
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+let consoleErrorCalled = false;
+let consoleWarnCalled = false;
+
+function mockConsoleError() {
+  consoleErrorCalled = false;
+  console.error = () => {
+    consoleErrorCalled = true;
+  };
+}
+
+function mockConsoleWarn() {
+  consoleWarnCalled = false;
+  console.warn = () => {
+    consoleWarnCalled = true;
+  };
+}
+
+function restoreConsole() {
+  console.error = originalConsoleError;
+  console.warn = originalConsoleWarn;
+}
+
+// Test setup
+function createDateTime() {
+  const mockR = {
+    lang: "en",
+  };
+
+  const langs = {
+    en: {
+      localizeName: "en-US",
+      timeZone: "America/Los_Angeles",
+      first_day: 0,
+      time_zone_offset: -480,
+    },
+    fa: {
+      first_day: 6,
+      time_zone_offset: 210,
+      localizeName: "fa-IR",
+      timeZone: "Asia/Tehran",
+      calendar: "persian",
+    },
+  };
+
+  return new DateTime(mockR, langs);
+}
+function createDateTimeFa() {
+  const mockR = {
+    lang: "fa",
+  };
+
+  const langs = {
+    en: {
+      localizeName: "en-US",
+      timeZone: "America/Los_Angeles",
+      first_day: 0,
+      time_zone_offset: -480,
+    },
+    fa: {
+      first_day: 6,
+      time_zone_offset: 210,
+      localizeName: "fa-IR",
+      timeZone: "Asia/Tehran",
+      calendar: "persian",
+    },
+  };
+
+  return new DateTime(mockR, langs);
+}
+
+// Run tests
+console.log(`${colors.yellow}\n=== DateTime Tests ===${colors.reset}\n`);
+
+suite("Constructor", () => {
+  test("should initialize with $r and langs", () => {
+    const mockR = { lang: "en" };
+    const langs = { en: { localizeName: "en-US" } };
+    const dateTime = new DateTime(mockR, langs);
+
+    assertEqual(dateTime.$r, mockR, "$r should be set");
+    assertEqual(dateTime.langs, langs, "langs should be set");
+  });
+
+  test("should have predefined format options", () => {
+    const dateTime = createDateTime();
+
+    assertDeepEqual(dateTime.format.narrow, { weekday: "narrow" });
+    assertDeepEqual(dateTime.format.day, { day: "numeric" });
+    assertDeepEqual(dateTime.format.month, { month: "short" });
+    assertDeepEqual(dateTime.format.year, { year: "numeric" });
+    assertDeepEqual(dateTime.format.short, {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+    });
+    assertDeepEqual(dateTime.format.medium, {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+    });
+    assertDeepEqual(dateTime.format.weekday, { weekday: "short" });
+    assertDeepEqual(dateTime.format.long, {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      weekday: "short",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+    });
+    assertDeepEqual(dateTime.format["date-latin"], {
+      month: "numeric",
+      day: "numeric",
+      numberingSystem: "latn",
+    });
+  });
+});
+
+suite("set_lang", () => {
+  test("should add a new language with valid config", () => {
+    const dateTime = createDateTime();
+    const newLang = {
+      localizeName: "de-DE",
+      timeZone: "Europe/Berlin",
+      first_day: 1,
+      time_zone_offset: 60,
+    };
+
+    dateTime.set_lang("de", newLang);
+    assertDeepEqual(dateTime.langs.de, newLang);
+  });
+
+  test("should log error and return early if localizeName is missing", () => {
+    const dateTime = createDateTime();
+    mockConsoleError();
+
+    const invalidLang = {
+      timeZone: "Europe/Berlin",
+    };
+
+    dateTime.set_lang("de", invalidLang);
+
+    assert(consoleErrorCalled, "console.error should have been called");
+    assertUndefined(dateTime.langs.de, "lang should not be added");
+
+    restoreConsole();
+  });
+});
+
+suite("set_format", () => {
+  test("should merge custom format options", () => {
+    const dateTime = createDateTime();
+    const customFormat = {
+      custom: {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+      },
+    };
+
+    dateTime.set_format(customFormat);
+    assertDeepEqual(dateTime.format.custom, customFormat.custom);
+  });
+
+  test("should preserve existing format options", () => {
+    const dateTime = createDateTime();
+    const customFormat = {
+      custom: {
+        year: "numeric",
+      },
+    };
+
+    dateTime.set_format(customFormat);
+    assertDefined(dateTime.format.short, "short format should still exist");
+    assertDefined(dateTime.format.long, "long format should still exist");
+  });
+});
+
+suite("formatLocal", () => {
+  const testDate = new Date("2024-03-15T10:30:00Z");
+
+  test("should format date with default locale from $r.lang", () => {
+    const dateTime = createDateTime();
+    const result = dateTime.formatLocal(testDate, "short");
+
+    assert(typeof result === "string", "result should be a string");
+    assert(
+      result.includes("2024") || result.includes("24"),
+      "result should contain year",
+    );
+  });
+
+  test("should format date with specified locale", () => {
+    const dateTime = createDateTime();
+    const result = dateTime.formatLocal(testDate, "short", "en");
+
+    assert(typeof result === "string", "result should be a string");
+    assertGreaterThan(result.length, 0, "result should not be empty");
+  });
+
+  test("should format date with different format types", () => {
+    const dateTime = createDateTime();
+
+    const dayResult = dateTime.formatLocal(testDate, "day", "en");
+    assert(dayResult.includes("15"), "day format should include day number");
+
+    const yearResult = dateTime.formatLocal(testDate, "year", "en");
+    assert(yearResult.includes("2024"), "year format should include year");
+  });
+
+  test("should warn and create default lang config if locale not found", () => {
+    const dateTime = createDateTime();
+    mockConsoleWarn();
+
+    const result = dateTime.formatLocal(testDate, "short", "unknown");
+
+    assert(consoleWarnCalled, "console.warn should have been called");
+    assertDefined(dateTime.langs.unknown, "unknown lang should be created");
+    assertEqual(dateTime.langs.unknown.localizeName, "unknown");
+
+    restoreConsole();
+  });
+
+  test("should format with date-latin format", () => {
+    const dateTime = createDateTime();
+    const result = dateTime.formatLocal(testDate, "date-latin", "en");
+
+    assertMatch(result, /\d+\/\d+/, "result should match date pattern");
+  });
+
+  test("should handle formatting errors gracefully", () => {
+    const dateTime = createDateTime();
+    mockConsoleError();
+
+    const invalidDate = "not a date";
+    const result = dateTime.formatLocal(invalidDate, "short", "en");
+
+    assertEqual(result, invalidDate, "should return original value on error");
+
+    restoreConsole();
+  });
+});
+
+suite("add_days", () => {
+  test("should add positive days to a date", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-03-15");
+    const result = dateTime.add_days(date, 5);
+
+    assertEqual(result.getDate(), 20);
+    assertEqual(result.getMonth(), 2); // March (0-indexed)
+    assertEqual(result.getFullYear(), 2024);
+  });
+
+  test("should subtract days with negative value", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-03-15");
+    const result = dateTime.add_days(date, -5);
+
+    assertEqual(result.getDate(), 10);
+    assertEqual(result.getMonth(), 2);
+    assertEqual(result.getFullYear(), 2024);
+  });
+
+  test("should handle month boundary when adding days", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-03-30");
+    const result = dateTime.add_days(date, 5);
+
+    assertEqual(result.getDate(), 4);
+    assertEqual(result.getMonth(), 3); // April
+    assertEqual(result.getFullYear(), 2024);
+  });
+
+  test("should handle year boundary when adding days", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-12-30");
+    const result = dateTime.add_days(date, 5);
+
+    assertEqual(result.getDate(), 4);
+    assertEqual(result.getMonth(), 0); // January
+    assertEqual(result.getFullYear(), 2025);
+  });
+
+  test("should not mutate the original date", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-03-15");
+    const originalDate = date.getDate();
+
+    dateTime.add_days(date, 5);
+
+    assertEqual(
+      date.getDate(),
+      originalDate,
+      "original date should not change",
+    );
+  });
+
+  test("should handle leap year", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-02-28");
+    const result = dateTime.add_days(date, 1);
+
+    assertEqual(result.getDate(), 29);
+    assertEqual(result.getMonth(), 1); // February
+  });
+});
+
+suite("add_months", () => {
+  test("should add one month to a date", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-01-15");
+    const result = dateTime.add_months(date, 1);
+
+    assertEqual(result.getMonth(), 1, "should be February (month 1)");
+    assertEqual(result.getDate(), 15, "should be day 15");
+    assertEqual(result.getFullYear(), 2024, "should be year 2024");
+  });
+
+  test("should add multiple months", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-01-15");
+    const result = dateTime.add_months(date, 3);
+
+    assertEqual(result.getMonth(), 3, "should be April (month 3)");
+    assertEqual(result.getDate(), 15, "should be day 15");
+    assertEqual(result.getFullYear(), 2024, "should be year 2024");
+  });
+
+  test("should handle month-end dates (31st to 29-day leap month)", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-01-31");
+    const result = dateTime.add_months(date, 1);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(formattedResult, /2\/29/, "should be Feb 29th (leap year)");
+  });
+
+  test("should handle month-end dates (31st to 30-day month)", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-03-31");
+    const result = dateTime.add_months(date, 1);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(formattedResult, /4\/30/, "should be April 30th");
+  });
+
+  test("should handle year boundary", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-11-15");
+    const result = dateTime.add_months(date, 3);
+
+    assertEqual(result.getMonth(), 1, "should be February (month 1)");
+    assertEqual(result.getDate(), 15, "should be day 15");
+    assertEqual(result.getFullYear(), 2025, "should be year 2025");
+  });
+
+  test("should handle adding 0 months", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-03-15");
+    const result = dateTime.add_months(date, 0);
+
+    assertEqual(result.getTime(), date.getTime(), "date should be unchanged");
+  });
+
+  test("should preserve the day of month when possible", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-01-15");
+    const result1 = dateTime.add_months(date, 1);
+    const result2 = dateTime.add_months(date, 2);
+
+    assertEqual(result1.getDate(), 15, "should preserve day 15 after 1 month");
+    assertEqual(result2.getDate(), 15, "should preserve day 15 after 2 months");
+  });
+
+  test("should handle leap year to non-leap year transition", () => {
+    const dateTime = createDateTime();
+    const date = new Date("2024-02-29");
+    const result = dateTime.add_months(date, 12);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(formattedResult, /2\/28/, "should be Feb 28th (non-leap year)");
+    assertEqual(result.getFullYear(), 2025);
+  });
+});
+
+suite("add_months_fa", () => {
+  test("should add one month to a date", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2024-01-15");
+    const result = dateTime.add_months(date, 1);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(
+      formattedResult,
+      /11\/25/,
+      "should be month 11, day 25 in Persian calendar",
+    );
+  });
+
+  test("should add multiple months", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2024-01-15");
+    const result = dateTime.add_months(date, 3);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(
+      formattedResult,
+      /1\/25/,
+      "should be month 1, day 25 in Persian calendar (year boundary crossed)",
+    );
+  });
+
+  test("should handle month-end dates (31st to 29-day leap month)", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2027-02-18");
+    const result = dateTime.add_months(date, 1);
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(
+      formattedResult,
+      /12\/29/,
+      "should be month 12, day 29 in Persian calendar",
+    );
+  });
+
+  test("should handle month-end dates (31st to 30-day month)", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2024-09-21");
+    const result = dateTime.add_months(date, 1);
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    console.log(formattedResult);
+    assertMatch(
+      formattedResult,
+      /7\/30/,
+      "should be month 7, day 30 in Persian calendar",
+    );
+  });
+
+  test("should handle year boundary", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2024-11-15");
+    const result = dateTime.add_months(date, 3);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(
+      formattedResult,
+      /11\/25/,
+      "should be month 11, day 25 in Persian calendar",
+    );
+  });
+
+  test("should handle adding 0 months", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2024-03-15");
+    const result = dateTime.add_months(date, 0);
+
+    assertEqual(result.getTime(), date.getTime(), "date should be unchanged");
+  });
+
+  test("should preserve the day of month when possible", () => {
+    const dateTime = createDateTimeFa();
+    let date = new Date("2024-01-15");
+    for (let i = 0; i < 100; i++) {
+      date = dateTime.add_months(date, 1);
+
+      const formattedResult = dateTime.formatLocal(date, "day");
+      assertEqual(
+        formattedResult,
+        "۲۵",
+        "should preserve day 25 after 1 month",
+      );
+    }
+  });
+
+  test("should handle leap year to non-leap year transition", () => {
+    const dateTime = createDateTimeFa();
+    const date = new Date("2024-03-29");
+    const result = dateTime.add_months(date, 12);
+
+    const formattedResult = dateTime.formatLocal(result, "date-latin");
+    assertMatch(
+      formattedResult,
+      /1\/10/,
+      "should be month 1, day 10 in Persian calendar",
+    );
+  });
+});
+
+// Summary
+console.log(`\n${colors.yellow}=== Test Summary ===${colors.reset}`);
+console.log(`Total: ${testCount} tests`);
+console.log(`${colors.green}Passed: ${passCount}${colors.reset}`);
+if (failCount > 0) {
+  console.log(`${colors.red}Failed: ${failCount}${colors.reset}`);
+  process.exit(1);
+} else {
+  console.log(`${colors.green}\n✓ All tests passed!${colors.reset}\n`);
+  process.exit(0);
+}