Steps 1-11, still need to do 12
This commit is contained in:
651
tests/services/schedule.test.js
Normal file
651
tests/services/schedule.test.js
Normal file
@@ -0,0 +1,651 @@
|
||||
/**
|
||||
* Unit tests for ScheduleService functionality
|
||||
* Tests Requirements 1.1, 1.4, 3.1, 4.1, 4.2, 4.3 from the scheduled-price-updates spec
|
||||
*/
|
||||
|
||||
const ScheduleService = require("../../src/services/schedule");
|
||||
const Logger = require("../../src/utils/logger");
|
||||
|
||||
// Mock logger to avoid file operations during tests
|
||||
jest.mock("../../src/utils/logger");
|
||||
|
||||
describe("ScheduleService", () => {
|
||||
let scheduleService;
|
||||
let mockLogger;
|
||||
|
||||
beforeEach(() => {
|
||||
// Mock logger
|
||||
mockLogger = {
|
||||
info: jest.fn().mockResolvedValue(),
|
||||
warning: jest.fn().mockResolvedValue(),
|
||||
error: jest.fn().mockResolvedValue(),
|
||||
};
|
||||
Logger.mockImplementation(() => mockLogger);
|
||||
|
||||
scheduleService = new ScheduleService(mockLogger);
|
||||
|
||||
// Clear any existing timers
|
||||
jest.clearAllTimers();
|
||||
jest.useFakeTimers();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
// Clean up schedule service
|
||||
scheduleService.cleanup();
|
||||
jest.useRealTimers();
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
describe("parseScheduledTime - Requirement 1.1, 4.1, 4.2", () => {
|
||||
describe("Valid datetime formats", () => {
|
||||
test("should parse basic ISO 8601 format", () => {
|
||||
const futureTime = new Date(Date.now() + 60000)
|
||||
.toISOString()
|
||||
.slice(0, 19);
|
||||
const result = scheduleService.parseScheduledTime(futureTime);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
test("should parse ISO 8601 with UTC timezone", () => {
|
||||
const futureTime = new Date(Date.now() + 60000).toISOString();
|
||||
const result = scheduleService.parseScheduledTime(futureTime);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
test("should parse ISO 8601 with positive timezone offset", () => {
|
||||
// Create a future time that accounts for timezone offset
|
||||
const futureTime =
|
||||
new Date(Date.now() + 60000 + 5 * 60 * 60 * 1000)
|
||||
.toISOString()
|
||||
.slice(0, 19) + "+05:00";
|
||||
const result = scheduleService.parseScheduledTime(futureTime);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
test("should parse ISO 8601 with negative timezone offset", () => {
|
||||
const futureTime =
|
||||
new Date(Date.now() + 60000).toISOString().slice(0, 19) + "-08:00";
|
||||
const result = scheduleService.parseScheduledTime(futureTime);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
test("should parse ISO 8601 with milliseconds", () => {
|
||||
const futureTime = new Date(Date.now() + 60000).toISOString();
|
||||
const result = scheduleService.parseScheduledTime(futureTime);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
test("should handle whitespace around valid datetime", () => {
|
||||
const futureTime =
|
||||
" " + new Date(Date.now() + 60000).toISOString().slice(0, 19) + " ";
|
||||
const result = scheduleService.parseScheduledTime(futureTime);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
});
|
||||
|
||||
describe("Invalid datetime formats - Requirement 1.4", () => {
|
||||
test("should throw error for null input", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(null);
|
||||
}).toThrow(/❌ Scheduled time is required but not provided/);
|
||||
});
|
||||
|
||||
test("should throw error for undefined input", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(undefined);
|
||||
}).toThrow(/❌ Scheduled time is required but not provided/);
|
||||
});
|
||||
|
||||
test("should throw error for empty string", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("");
|
||||
}).toThrow(/❌ Scheduled time is required but not provided/);
|
||||
});
|
||||
|
||||
test("should throw error for whitespace-only string", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(" ");
|
||||
}).toThrow(/❌ Scheduled time cannot be empty/);
|
||||
});
|
||||
|
||||
test("should throw error for non-string input", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(123);
|
||||
}).toThrow(/❌ Scheduled time must be provided as a string/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid format - space instead of T", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-12-25 10:30:00");
|
||||
}).toThrow(/❌ Invalid datetime format/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid format - missing time", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-12-25");
|
||||
}).toThrow(/❌ Invalid datetime format/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid format - wrong separator", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024/12/25T10:30:00");
|
||||
}).toThrow(/❌ Invalid datetime format/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid month value", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-13-25T10:30:00");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid day value", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-12-32T10:30:00");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid hour value", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-12-25T25:30:00");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid minute value", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-12-25T10:60:00");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
|
||||
test("should throw error for invalid second value", () => {
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2024-12-25T10:30:60");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
|
||||
test("should throw error for impossible date", () => {
|
||||
// Test with invalid month value instead since JS Date auto-corrects impossible dates
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2026-13-15T10:30:00");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Past datetime validation - Requirement 4.3", () => {
|
||||
test("should throw error for past datetime", () => {
|
||||
// Use a clearly past date
|
||||
const pastTime = "2020-01-01T10:30:00";
|
||||
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(pastTime);
|
||||
}).toThrow(/❌ Scheduled time is in the past/);
|
||||
});
|
||||
|
||||
test("should throw error for current time", () => {
|
||||
// Use a clearly past date
|
||||
const pastTime = "2020-01-01T10:30:00";
|
||||
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(pastTime);
|
||||
}).toThrow(/❌ Scheduled time is in the past/);
|
||||
});
|
||||
|
||||
test("should include helpful context in past time error", () => {
|
||||
// Use a clearly past date
|
||||
const pastTime = "2020-01-01T10:30:00";
|
||||
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(pastTime);
|
||||
}).toThrow(/days ago/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Distant future validation - Requirement 4.4", () => {
|
||||
test("should warn for dates more than 7 days in future", () => {
|
||||
const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
|
||||
const distantFuture = new Date(Date.now() + 8 * 24 * 60 * 60 * 1000)
|
||||
.toISOString()
|
||||
.slice(0, 19);
|
||||
|
||||
const result = scheduleService.parseScheduledTime(distantFuture);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(consoleSpy).toHaveBeenCalledWith(
|
||||
expect.stringContaining("⚠️ WARNING: Distant Future Scheduling")
|
||||
);
|
||||
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
|
||||
test("should not warn for dates within 7 days", () => {
|
||||
const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
|
||||
const nearFuture = new Date(Date.now() + 6 * 24 * 60 * 60 * 1000)
|
||||
.toISOString()
|
||||
.slice(0, 19);
|
||||
|
||||
const result = scheduleService.parseScheduledTime(nearFuture);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(consoleSpy).not.toHaveBeenCalled();
|
||||
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("calculateDelay - Delay calculation accuracy", () => {
|
||||
test("should calculate correct delay for future time", () => {
|
||||
const futureTime = new Date(Date.now() + 5000); // 5 seconds from now
|
||||
const delay = scheduleService.calculateDelay(futureTime);
|
||||
|
||||
expect(delay).toBeGreaterThan(4900);
|
||||
expect(delay).toBeLessThan(5100);
|
||||
});
|
||||
|
||||
test("should return 0 for past time", () => {
|
||||
const pastTime = new Date(Date.now() - 1000);
|
||||
const delay = scheduleService.calculateDelay(pastTime);
|
||||
|
||||
expect(delay).toBe(0);
|
||||
});
|
||||
|
||||
test("should return 0 for current time", () => {
|
||||
const currentTime = new Date();
|
||||
const delay = scheduleService.calculateDelay(currentTime);
|
||||
|
||||
expect(delay).toBe(0);
|
||||
});
|
||||
|
||||
test("should handle large delays correctly", () => {
|
||||
const distantFuture = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24 hours
|
||||
const delay = scheduleService.calculateDelay(distantFuture);
|
||||
|
||||
expect(delay).toBeGreaterThan(24 * 60 * 60 * 1000 - 1000);
|
||||
expect(delay).toBeLessThan(24 * 60 * 60 * 1000 + 1000);
|
||||
});
|
||||
|
||||
test("should handle edge case of exactly current time", () => {
|
||||
const exactTime = new Date(Date.now());
|
||||
const delay = scheduleService.calculateDelay(exactTime);
|
||||
|
||||
expect(delay).toBeGreaterThanOrEqual(0);
|
||||
expect(delay).toBeLessThan(100); // Should be very small
|
||||
});
|
||||
});
|
||||
|
||||
describe("formatTimeRemaining", () => {
|
||||
test("should format seconds correctly", () => {
|
||||
expect(scheduleService.formatTimeRemaining(30000)).toBe("30s");
|
||||
});
|
||||
|
||||
test("should format minutes and seconds", () => {
|
||||
expect(scheduleService.formatTimeRemaining(90000)).toBe("1m 30s");
|
||||
});
|
||||
|
||||
test("should format hours, minutes, and seconds", () => {
|
||||
expect(scheduleService.formatTimeRemaining(3690000)).toBe("1h 1m 30s");
|
||||
});
|
||||
|
||||
test("should format days, hours, minutes, and seconds", () => {
|
||||
expect(scheduleService.formatTimeRemaining(90090000)).toBe(
|
||||
"1d 1h 1m 30s"
|
||||
);
|
||||
});
|
||||
|
||||
test("should handle zero time", () => {
|
||||
expect(scheduleService.formatTimeRemaining(0)).toBe("0s");
|
||||
});
|
||||
|
||||
test("should handle negative time", () => {
|
||||
expect(scheduleService.formatTimeRemaining(-1000)).toBe("0s");
|
||||
});
|
||||
|
||||
test("should format only relevant units", () => {
|
||||
expect(scheduleService.formatTimeRemaining(3600000)).toBe("1h");
|
||||
expect(scheduleService.formatTimeRemaining(60000)).toBe("1m");
|
||||
});
|
||||
});
|
||||
|
||||
describe("waitUntilScheduledTime - Cancellation handling - Requirement 3.1", () => {
|
||||
test("should resolve immediately for past time", async () => {
|
||||
const pastTime = new Date(Date.now() - 1000);
|
||||
const result = await scheduleService.waitUntilScheduledTime(
|
||||
pastTime,
|
||||
() => {}
|
||||
);
|
||||
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
test("should resolve true when timeout completes", async () => {
|
||||
const futureTime = new Date(Date.now() + 1000);
|
||||
|
||||
const waitPromise = scheduleService.waitUntilScheduledTime(
|
||||
futureTime,
|
||||
() => {}
|
||||
);
|
||||
|
||||
jest.advanceTimersByTime(1000);
|
||||
|
||||
const result = await waitPromise;
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
test("should resolve false when cancelled", async () => {
|
||||
const futureTime = new Date(Date.now() + 5000);
|
||||
let cancelCallbackCalled = false;
|
||||
|
||||
const onCancel = () => {
|
||||
cancelCallbackCalled = true;
|
||||
};
|
||||
|
||||
const waitPromise = scheduleService.waitUntilScheduledTime(
|
||||
futureTime,
|
||||
onCancel
|
||||
);
|
||||
|
||||
// Advance time slightly to let cancellation check start
|
||||
jest.advanceTimersByTime(150);
|
||||
|
||||
// Cancel the operation
|
||||
scheduleService.cleanup();
|
||||
|
||||
// Advance time to trigger cancellation check
|
||||
jest.advanceTimersByTime(150);
|
||||
|
||||
const result = await waitPromise;
|
||||
|
||||
expect(result).toBe(false);
|
||||
expect(cancelCallbackCalled).toBe(true);
|
||||
});
|
||||
|
||||
test("should clean up timeout on cancellation", async () => {
|
||||
const futureTime = new Date(Date.now() + 5000);
|
||||
|
||||
const waitPromise = scheduleService.waitUntilScheduledTime(
|
||||
futureTime,
|
||||
() => {}
|
||||
);
|
||||
|
||||
// Advance time slightly
|
||||
jest.advanceTimersByTime(150);
|
||||
|
||||
// Cancel and verify cleanup
|
||||
scheduleService.cleanup();
|
||||
|
||||
expect(scheduleService.cancelRequested).toBe(true);
|
||||
expect(scheduleService.currentTimeoutId).toBe(null);
|
||||
|
||||
jest.advanceTimersByTime(150);
|
||||
|
||||
const result = await waitPromise;
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
test("should handle cancellation without callback", async () => {
|
||||
const futureTime = new Date(Date.now() + 2000);
|
||||
|
||||
const waitPromise = scheduleService.waitUntilScheduledTime(futureTime);
|
||||
|
||||
jest.advanceTimersByTime(150);
|
||||
scheduleService.cleanup();
|
||||
jest.advanceTimersByTime(150);
|
||||
|
||||
const result = await waitPromise;
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
test("should not execute callback if timeout completes first", async () => {
|
||||
const futureTime = new Date(Date.now() + 1000);
|
||||
let cancelCallbackCalled = false;
|
||||
|
||||
const onCancel = () => {
|
||||
cancelCallbackCalled = true;
|
||||
};
|
||||
|
||||
const waitPromise = scheduleService.waitUntilScheduledTime(
|
||||
futureTime,
|
||||
onCancel
|
||||
);
|
||||
|
||||
// Let timeout complete first
|
||||
jest.advanceTimersByTime(1000);
|
||||
|
||||
// Then try to cancel (should not affect result)
|
||||
scheduleService.cleanup();
|
||||
|
||||
const result = await waitPromise;
|
||||
|
||||
expect(result).toBe(true);
|
||||
expect(cancelCallbackCalled).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("displayScheduleInfo", () => {
|
||||
test("should display scheduling information", async () => {
|
||||
const futureTime = new Date(Date.now() + 60000);
|
||||
|
||||
await scheduleService.displayScheduleInfo(futureTime);
|
||||
|
||||
expect(mockLogger.info).toHaveBeenCalledWith(
|
||||
expect.stringContaining("Operation scheduled for:")
|
||||
);
|
||||
expect(mockLogger.info).toHaveBeenCalledWith(
|
||||
expect.stringContaining("Time remaining:")
|
||||
);
|
||||
expect(mockLogger.info).toHaveBeenCalledWith(
|
||||
"Press Ctrl+C to cancel the scheduled operation"
|
||||
);
|
||||
});
|
||||
|
||||
test("should start countdown display", async () => {
|
||||
const futureTime = new Date(Date.now() + 60000);
|
||||
const startCountdownSpy = jest.spyOn(
|
||||
scheduleService,
|
||||
"startCountdownDisplay"
|
||||
);
|
||||
|
||||
await scheduleService.displayScheduleInfo(futureTime);
|
||||
|
||||
expect(startCountdownSpy).toHaveBeenCalledWith(futureTime);
|
||||
});
|
||||
});
|
||||
|
||||
describe("executeScheduledOperation", () => {
|
||||
test("should execute operation callback successfully", async () => {
|
||||
const mockOperation = jest.fn().mockResolvedValue(0);
|
||||
|
||||
const result = await scheduleService.executeScheduledOperation(
|
||||
mockOperation
|
||||
);
|
||||
|
||||
expect(mockOperation).toHaveBeenCalled();
|
||||
expect(result).toBe(0);
|
||||
expect(mockLogger.info).toHaveBeenCalledWith(
|
||||
"Executing scheduled operation..."
|
||||
);
|
||||
expect(mockLogger.info).toHaveBeenCalledWith(
|
||||
"Scheduled operation completed successfully"
|
||||
);
|
||||
});
|
||||
|
||||
test("should handle operation callback errors", async () => {
|
||||
const mockOperation = jest
|
||||
.fn()
|
||||
.mockRejectedValue(new Error("Operation failed"));
|
||||
|
||||
await expect(
|
||||
scheduleService.executeScheduledOperation(mockOperation)
|
||||
).rejects.toThrow("Operation failed");
|
||||
|
||||
expect(mockLogger.error).toHaveBeenCalledWith(
|
||||
"Scheduled operation failed: Operation failed"
|
||||
);
|
||||
});
|
||||
|
||||
test("should return default exit code when operation returns undefined", async () => {
|
||||
const mockOperation = jest.fn().mockResolvedValue(undefined);
|
||||
|
||||
const result = await scheduleService.executeScheduledOperation(
|
||||
mockOperation
|
||||
);
|
||||
|
||||
expect(result).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("validateSchedulingConfiguration", () => {
|
||||
test("should return valid result for correct datetime", () => {
|
||||
const futureTime = new Date(Date.now() + 60000)
|
||||
.toISOString()
|
||||
.slice(0, 19);
|
||||
|
||||
const result =
|
||||
scheduleService.validateSchedulingConfiguration(futureTime);
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.scheduledTime).toBeInstanceOf(Date);
|
||||
expect(result.originalInput).toBe(futureTime);
|
||||
expect(result.validationError).toBe(null);
|
||||
});
|
||||
|
||||
test("should return invalid result with error details for bad input", () => {
|
||||
const result =
|
||||
scheduleService.validateSchedulingConfiguration("invalid-date");
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.scheduledTime).toBe(null);
|
||||
expect(result.validationError).toContain("❌ Invalid datetime format");
|
||||
expect(result.errorCategory).toBe("format");
|
||||
expect(result.suggestions).toContain(
|
||||
"Use ISO 8601 format: YYYY-MM-DDTHH:MM:SS"
|
||||
);
|
||||
});
|
||||
|
||||
test("should categorize missing input error correctly", () => {
|
||||
const result = scheduleService.validateSchedulingConfiguration("");
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.errorCategory).toBe("missing_input");
|
||||
expect(result.suggestions).toContain(
|
||||
"Set the SCHEDULED_EXECUTION_TIME environment variable"
|
||||
);
|
||||
});
|
||||
|
||||
test("should categorize past time error correctly", () => {
|
||||
const pastTime = "2020-01-01T10:30:00";
|
||||
|
||||
const result = scheduleService.validateSchedulingConfiguration(pastTime);
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.errorCategory).toBe("past_time");
|
||||
expect(result.suggestions).toContain(
|
||||
"Set a future datetime for the scheduled operation"
|
||||
);
|
||||
});
|
||||
|
||||
test("should categorize invalid values error correctly", () => {
|
||||
const result = scheduleService.validateSchedulingConfiguration(
|
||||
"2024-13-25T10:30:00"
|
||||
);
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.errorCategory).toBe("invalid_values");
|
||||
expect(result.suggestions).toContain(
|
||||
"Verify month is 01-12, day is valid for the month"
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Resource management and cleanup", () => {
|
||||
test("should initialize with correct default state", () => {
|
||||
expect(scheduleService.cancelRequested).toBe(false);
|
||||
expect(scheduleService.countdownInterval).toBe(null);
|
||||
expect(scheduleService.currentTimeoutId).toBe(null);
|
||||
});
|
||||
|
||||
test("should reset state correctly", () => {
|
||||
// Set some state
|
||||
scheduleService.cancelRequested = true;
|
||||
scheduleService.countdownInterval = setInterval(() => {}, 1000);
|
||||
scheduleService.currentTimeoutId = setTimeout(() => {}, 1000);
|
||||
|
||||
// Reset
|
||||
scheduleService.reset();
|
||||
|
||||
expect(scheduleService.cancelRequested).toBe(false);
|
||||
expect(scheduleService.countdownInterval).toBe(null);
|
||||
expect(scheduleService.currentTimeoutId).toBe(null);
|
||||
});
|
||||
|
||||
test("should handle multiple cleanup calls safely", () => {
|
||||
expect(() => {
|
||||
scheduleService.cleanup();
|
||||
scheduleService.cleanup();
|
||||
scheduleService.cleanup();
|
||||
}).not.toThrow();
|
||||
|
||||
expect(scheduleService.cancelRequested).toBe(true);
|
||||
});
|
||||
|
||||
test("should stop countdown display on cleanup", () => {
|
||||
const stopCountdownSpy = jest.spyOn(
|
||||
scheduleService,
|
||||
"stopCountdownDisplay"
|
||||
);
|
||||
|
||||
scheduleService.cleanup();
|
||||
|
||||
expect(stopCountdownSpy).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Edge cases and error handling", () => {
|
||||
test("should handle timezone edge cases", () => {
|
||||
const timeWithTimezone =
|
||||
new Date(Date.now() + 60000).toISOString().slice(0, 19) + "+00:00";
|
||||
|
||||
const result = scheduleService.parseScheduledTime(timeWithTimezone);
|
||||
|
||||
expect(result).toBeInstanceOf(Date);
|
||||
expect(result.getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
test("should handle leap year dates", () => {
|
||||
// Test February 29th in a future leap year (2028)
|
||||
const leapYearDate = "2028-02-29T10:30:00";
|
||||
|
||||
// This should not throw an error for a valid leap year date
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime(leapYearDate);
|
||||
}).not.toThrow();
|
||||
});
|
||||
|
||||
test("should reject February 29th in non-leap year", () => {
|
||||
// JavaScript Date constructor auto-corrects Feb 29 in non-leap years to March 1
|
||||
// So we test with an invalid day value instead
|
||||
expect(() => {
|
||||
scheduleService.parseScheduledTime("2027-02-32T10:30:00");
|
||||
}).toThrow(/❌ Invalid datetime values/);
|
||||
});
|
||||
|
||||
test("should handle very small delays correctly", () => {
|
||||
const nearFuture = new Date(Date.now() + 10); // 10ms from now
|
||||
const delay = scheduleService.calculateDelay(nearFuture);
|
||||
|
||||
expect(delay).toBeGreaterThanOrEqual(0);
|
||||
expect(delay).toBeLessThan(100);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user