repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by bugabinga
opencode/tests/time.test.ts
Rawimport { describe, expect, test } from "bun:test";
// Mock context for tool execution
const ctx = { directory: "/test" } as any;
/**
* Helper to parse JSON string responses from tools.
* Returns parsed object or throws on parse failure.
*/
function parseResult(result: string): Record<string, unknown> {
return JSON.parse(result);
}
// ============================================================================
// NOW - Get current time
// ============================================================================
describe("now", () => {
test("returns current time with default timezone", async () => {
const { now } = await import("../tools/time.ts");
const result = await now.execute({} as any, ctx);
const data = parseResult(result);
expect(data.iso).toBeDefined();
expect(data.unix_ms).toBeDefined();
expect(data.human).toBeDefined();
expect(data.timezone).toBe("Europe/Berlin");
expect(data.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
expect(data.time).toMatch(/^\d{2}:\d{2}:\d{2}$/);
});
test("returns current time in UTC timezone", async () => {
const { now } = await import("../tools/time.ts");
const result = await now.execute({ timezone: "UTC" } as any, ctx);
const data = parseResult(result);
expect(data.timezone).toBe("UTC");
expect(data.iso).toBeDefined();
});
test("returns current time with custom format", async () => {
const { now } = await import("../tools/time.ts");
const result = await now.execute({
timezone: "UTC",
format: "yyyy-MM-dd",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toMatch(/^\d{4}-\d{2}-\d{2}$/);
});
test("returns error for invalid timezone", async () => {
const { now } = await import("../tools/time.ts");
const result = await now.execute(
{ timezone: "Invalid/Timezone" } as any,
ctx,
);
expect(result).toContain("Invalid timezone");
});
});
// ============================================================================
// CONVERT - Convert between timezones
// ============================================================================
describe("convert", () => {
test("converts time between timezones", async () => {
const { convert } = await import("../tools/time.ts");
const result = await convert.execute({
time: "2024-03-15T12:00:00",
from_timezone: "UTC",
to_timezone: "America/New_York",
} as any, ctx);
const data = parseResult(result);
expect(data.original).toBeDefined();
expect(data.converted).toBeDefined();
expect(data.original.timezone).toBe("UTC");
expect(data.converted.timezone).toBe("America/New_York");
});
test("converts 'now' between timezones", async () => {
const { convert } = await import("../tools/time.ts");
const result = await convert.execute({
time: "now",
from_timezone: "Europe/Berlin",
to_timezone: "Asia/Tokyo",
} as any, ctx);
const data = parseResult(result);
expect(data.original.timezone).toBe("Europe/Berlin");
expect(data.converted.timezone).toBe("Asia/Tokyo");
});
test("returns error for invalid source timezone", async () => {
const { convert } = await import("../tools/time.ts");
const result = await convert.execute({
time: "2024-03-15T12:00:00",
from_timezone: "Invalid/Source",
to_timezone: "UTC",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
test("returns error for invalid target timezone", async () => {
const { convert } = await import("../tools/time.ts");
const result = await convert.execute({
time: "2024-03-15T12:00:00",
from_timezone: "UTC",
to_timezone: "Invalid/Target",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
test("returns error for invalid time format", async () => {
const { convert } = await import("../tools/time.ts");
const result = await convert.execute({
time: "not-a-valid-time",
from_timezone: "UTC",
to_timezone: "America/New_York",
} as any, ctx);
expect(result).toContain("Invalid time format");
});
});
// ============================================================================
// PARSE - Parse date/time strings
// ============================================================================
describe("parse", () => {
test("parses ISO 8601 date string", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "2024-03-15T14:30:00Z",
timezone: "UTC",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.iso).toBeDefined();
expect(data.parsed.date).toBe("2024-03-15");
expect(data.parsed.time).toBe("14:30:00");
});
test("parses Unix timestamp in milliseconds", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "1710511800000",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.unix_ms).toBe(1710511800000);
});
test("parses SQL format", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "2024-03-15 14:30:00",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.date).toBe("2024-03-15");
});
test("returns error for invalid input", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "completely invalid date",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(false);
expect(data.error).toBeDefined();
});
test("returns error for invalid timezone", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "2024-03-15T14:30:00",
timezone: "Invalid/Zone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
});
// ============================================================================
// FORMAT - Format timestamps
// ============================================================================
describe("format", () => {
test("formats as ISO by default", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
timezone: "UTC",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toContain("2024-03-15T14:30:00");
expect(data.format_used).toBe("ISO 8601");
});
test("formats with custom format string", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
format_type: "custom",
custom_format: "yyyy/MM/dd",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toBe("2024/03/15");
expect(data.format_used).toContain("Custom");
});
test("formats with locale", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
format_type: "locale_full",
locale: "de-DE",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toBeDefined();
expect(data.locale).toBe("de-DE");
});
test("returns error for custom format without custom_format arg", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
format_type: "custom",
} as any, ctx);
expect(result).toContain("Custom format requires");
});
test("returns error for invalid time", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "invalid-time",
} as any, ctx);
expect(result).toContain("Invalid time");
});
test("formats with locale_short", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
format_type: "locale_short",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toBeDefined();
expect(data.format_used).toBe("Locale short");
});
});
// ============================================================================
// RELATIVE - Relative time strings
// ============================================================================
describe("relative", () => {
test("returns relative time in the past", async () => {
const { relative } = await import("../tools/time.ts");
const pastTime = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
const result = await relative.execute({
time: pastTime,
} as any, ctx);
const data = parseResult(result);
expect(data.relative).toContain("ago");
expect(data.is_past).toBe(true);
expect(data.direction).toBe("past");
});
test("returns relative time in the future", async () => {
const { relative } = await import("../tools/time.ts");
const futureTime = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
const result = await relative.execute({
time: futureTime,
} as any, ctx);
const data = parseResult(result);
expect(data.relative).toContain("in");
expect(data.is_past).toBe(false);
expect(data.direction).toBe("future");
});
test("uses custom reference point", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T14:00:00",
reference: "2024-03-15T12:00:00",
} as any, ctx);
const data = parseResult(result);
expect(data.relative).toContain("in");
expect(data.breakdown.hours).toBe(2);
});
test("returns error for invalid target time", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "invalid-time",
} as any, ctx);
expect(result).toContain("Invalid target time");
});
test("returns error for invalid reference time", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T14:00:00",
reference: "invalid-reference",
} as any, ctx);
expect(result).toContain("Invalid reference time");
});
test("supports different styles", async () => {
const { relative } = await import("../tools/time.ts");
const pastTime = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
const result = await relative.execute({
time: pastTime,
style: "short",
} as any, ctx);
const data = parseResult(result);
expect(data.style).toBe("short");
expect(data.relative).toBeDefined();
});
});
// ============================================================================
// DURATION - Calculate duration between timestamps
// ============================================================================
describe("duration", () => {
test("calculates duration between two dates", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T12:00:00",
end: "2024-03-15T18:30:00",
} as any, ctx);
const data = parseResult(result);
expect(data.breakdown.days).toBe(14);
expect(data.breakdown.hours).toBe(6);
expect(data.breakdown.minutes).toBe(30);
expect(data.human).toBeDefined();
});
test("returns error when end is before start", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-15T18:30:00",
end: "2024-03-01T12:00:00",
} as any, ctx);
expect(result).toContain("Invalid interval");
});
test("returns duration in specific unit", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-08T00:00:00",
unit: "days",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_days).toBe(7);
});
test("returns error for invalid start time", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "invalid-start",
end: "2024-03-15T12:00:00",
} as any, ctx);
expect(result).toContain("Invalid start time");
});
test("returns error for invalid end time", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T12:00:00",
end: "invalid-end",
} as any, ctx);
expect(result).toContain("Invalid end time");
});
test("calculates duration with 'now'", async () => {
const { duration } = await import("../tools/time.ts");
const futureDate = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
.toISOString();
const result = await duration.execute({
start: "now",
end: futureDate,
} as any, ctx);
const data = parseResult(result);
expect(data.start.iso).toBeDefined();
expect(data.end.iso).toBeDefined();
expect(data.total_milliseconds).toBeDefined();
});
});
// ============================================================================
// ADD - Add/subtract time from a date
// ============================================================================
describe("add", () => {
test("adds days to a date", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
days: 7,
} as any, ctx);
const data = parseResult(result);
expect(data.result.date).toBe("2024-03-22");
expect(data.change_applied).toContain("7 day");
});
test("subtracts hours from a date", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T14:00:00",
hours: -2,
} as any, ctx);
const data = parseResult(result);
expect(data.result.time).toBe("12:00:00");
expect(data.change_applied).toContain("-2 hour");
});
test("adds multiple units", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
years: 1,
months: 2,
days: 3,
} as any, ctx);
const data = parseResult(result);
expect(data.result.date).toBe("2025-05-18");
expect(data.change_applied).toContain("1 year");
expect(data.change_applied).toContain("2 month");
expect(data.change_applied).toContain("3 day");
});
test("returns no change when no units provided", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
} as any, ctx);
const data = parseResult(result);
expect(data.change_applied).toBe("no change");
expect(data.difference_ms).toBe(0);
});
test("returns error for invalid time", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "invalid-time",
days: 1,
} as any, ctx);
expect(result).toContain("Invalid time");
});
test("adds weeks to a date", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
weeks: 2,
} as any, ctx);
const data = parseResult(result);
expect(data.result.date).toBe("2024-03-29");
expect(data.change_applied).toContain("2 week");
});
});
// ============================================================================
// COMPARE - Compare two timestamps
// ============================================================================
describe("compare", () => {
test("compares two dates - time1 before time2", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "2024-03-15T12:00:00",
time2: "2024-03-20T12:00:00",
} as any, ctx);
const data = parseResult(result);
expect(data.comparison).toBe("time1 is before time2");
expect(data.is_before).toBe(true);
expect(data.is_after).toBe(false);
expect(data.is_equal).toBe(false);
});
test("compares two dates - time1 after time2", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "2024-03-20T12:00:00",
time2: "2024-03-15T12:00:00",
} as any, ctx);
const data = parseResult(result);
expect(data.comparison).toBe("time1 is after time2");
expect(data.is_before).toBe(false);
expect(data.is_after).toBe(true);
});
test("compares equal dates", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "2024-03-15T12:00:00",
time2: "2024-03-15T12:00:00",
} as any, ctx);
const data = parseResult(result);
expect(data.comparison).toBe("time1 equals time2");
expect(data.is_equal).toBe(true);
expect(data.difference_ms).toBe(0);
});
test("returns error for invalid time1", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "invalid-time1",
time2: "2024-03-15T12:00:00",
} as any, ctx);
expect(result).toContain("Invalid time1");
});
test("returns error for invalid time2", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "2024-03-15T12:00:00",
time2: "invalid-time2",
} as any, ctx);
expect(result).toContain("Invalid time2");
});
test("provides difference breakdown", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "2024-03-15T10:00:00",
time2: "2024-03-16T14:30:30",
} as any, ctx);
const data = parseResult(result);
expect(data.difference_breakdown.days).toBe(1);
expect(data.difference_breakdown.hours).toBe(4);
expect(data.difference_breakdown.minutes).toBe(30);
expect(data.difference_breakdown.seconds).toBe(30);
});
});
// ============================================================================
// UNIX - Unix timestamp conversion
// ============================================================================
describe("unix", () => {
test("converts ISO to Unix milliseconds", async () => {
const { unix } = await import("../tools/time.ts");
const result = await unix.execute({
time: "2024-03-15T14:30:00Z",
} as any, ctx);
const data = parseResult(result);
expect(data.unix_ms).toBeDefined();
expect(data.output_value).toBe(data.unix_ms);
expect(data.note).toBeDefined();
});
test("converts to Unix seconds", async () => {
const { unix } = await import("../tools/time.ts");
const result = await unix.execute({
time: "2024-03-15T14:30:00Z",
output_unit: "seconds",
} as any, ctx);
const data = parseResult(result);
expect(data.unix_seconds).toBeDefined();
expect(data.output_value).toBe(data.unix_seconds);
});
test("converts Unix timestamp to ISO", async () => {
const { unix } = await import("../tools/time.ts");
const result = await unix.execute({
time: "1710511800000",
} as any, ctx);
const data = parseResult(result);
expect(data.iso).toBeDefined();
expect(data.human).toBeDefined();
expect(data.unix_ms).toBe(1710511800000);
});
test("returns error for invalid time", async () => {
const { unix } = await import("../tools/time.ts");
const result = await unix.execute({
time: "invalid-time",
} as any, ctx);
expect(result).toContain("Invalid time");
});
test("handles 'now' input", async () => {
const { unix } = await import("../tools/time.ts");
const before = Date.now();
const result = await unix.execute({
time: "now",
} as any, ctx);
const after = Date.now();
const data = parseResult(result);
expect(data.unix_ms).toBeGreaterThanOrEqual(before);
expect(data.unix_ms).toBeLessThanOrEqual(after);
});
});
// ============================================================================
// INFO - Timezone information
// ============================================================================
describe("info", () => {
test("returns timezone info for default timezone", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({} as any, ctx);
const data = parseResult(result);
expect(data.timezone).toBe("Europe/Berlin");
expect(data.iana_id).toBe("Europe/Berlin");
expect(data.current_offset).toBeDefined();
expect(data.dst).toBeDefined();
});
test("returns timezone info for specific timezone", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({
timezone: "America/New_York",
} as any, ctx);
const data = parseResult(result);
expect(data.timezone).toBe("America/New_York");
expect(data.current_offset).toBeDefined();
expect(data.dst.has_dst).toBe(true);
});
test("returns error for invalid timezone", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
test("lists common timezones", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({
list_timezones: true,
} as any, ctx);
const data = parseResult(result);
expect(data.timezones).toBeDefined();
expect(Array.isArray(data.timezones)).toBe(true);
expect(data.timezones).toContain("UTC");
expect(data.timezones).toContain("Europe/Berlin");
expect(data.timezones).toContain("America/New_York");
});
test("checks DST status at specific time", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({
timezone: "America/New_York",
time: "2024-07-15T12:00:00",
} as any, ctx);
const data = parseResult(result);
expect(data.dst.is_currently_observing).toBe(true);
});
test("returns timezone info for UTC", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({
timezone: "UTC",
} as any, ctx);
const data = parseResult(result);
expect(data.timezone).toBe("UTC");
expect(data.dst.has_dst).toBe(false);
});
test("returns error for invalid time parameter", async () => {
const { info } = await import("../tools/time.ts");
const result = await info.execute({
timezone: "UTC",
time: "not-a-valid-time",
} as any, ctx);
expect(result).toContain("Invalid time");
});
});
// ============================================================================
// COVERAGE - EDGE CASES
// ============================================================================
describe("coverage - edge cases", () => {
// ---------------------------------------------------------------------------
// parseInput format variations
// ---------------------------------------------------------------------------
describe("parse - additional formats", () => {
test("parses RFC 2822 format", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "Fri, 15 Mar 2024 14:30:00 GMT",
timezone: "UTC",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.date).toBe("2024-03-15");
expect(data.parsed.time).toBe("14:30:00");
});
test("parses HTTP date format", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "Fri, 15 Mar 2024 14:30:00 GMT",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.date).toBe("2024-03-15");
});
test("rejects Unix timestamp 0", async () => {
const { parse } = await import("../tools/time.ts");
const result = await parse.execute({
input: "0",
} as any, ctx);
const data = parseResult(result);
expect(data.valid).toBe(false);
expect(data.error).toBeDefined();
});
test("handles case-insensitive NOW", async () => {
const { parse } = await import("../tools/time.ts");
const before = Date.now();
const result = await parse.execute({
input: "NOW",
} as any, ctx);
const after = Date.now();
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.unix_ms).toBeGreaterThanOrEqual(before);
expect(data.parsed.unix_ms).toBeLessThanOrEqual(after);
});
test("handles case-insensitive Now", async () => {
const { parse } = await import("../tools/time.ts");
const before = Date.now();
const result = await parse.execute({
input: "Now",
} as any, ctx);
const after = Date.now();
const data = parseResult(result);
expect(data.valid).toBe(true);
expect(data.parsed.unix_ms).toBeGreaterThanOrEqual(before);
expect(data.parsed.unix_ms).toBeLessThanOrEqual(after);
});
});
// ---------------------------------------------------------------------------
// format tool additional branches
// ---------------------------------------------------------------------------
describe("format - additional format types", () => {
test("formats with locale (defaults to medium)", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
format_type: "locale",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toBeDefined();
expect(data.format_used).toBe("Locale medium");
});
test("formats with locale_medium explicitly", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
format_type: "locale_medium",
} as any, ctx);
const data = parseResult(result);
expect(data.formatted).toBeDefined();
expect(data.format_used).toBe("Locale medium");
});
test("returns error for invalid timezone", async () => {
const { format } = await import("../tools/time.ts");
const result = await format.execute({
time: "2024-03-15T14:30:00Z",
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
});
// ---------------------------------------------------------------------------
// relative tool additional options
// ---------------------------------------------------------------------------
describe("relative - additional options", () => {
test("supports style: long explicitly", async () => {
const { relative } = await import("../tools/time.ts");
const pastTime = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
const result = await relative.execute({
time: pastTime,
style: "long",
} as any, ctx);
const data = parseResult(result);
expect(data.style).toBe("long");
expect(data.relative).toBeDefined();
});
test("supports style: narrow", async () => {
const { relative } = await import("../tools/time.ts");
const pastTime = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
const result = await relative.execute({
time: pastTime,
style: "narrow",
} as any, ctx);
const data = parseResult(result);
expect(data.style).toBe("narrow");
expect(data.relative).toBeDefined();
});
test("supports unit: years", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2026-03-15T14:00:00",
reference: "2024-03-15T14:00:00",
unit: "years",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("years");
expect(data.relative).toBeDefined();
});
test("supports unit: months", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-05-15T14:00:00",
reference: "2024-03-15T14:00:00",
unit: "months",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("months");
expect(data.relative).toBeDefined();
});
test("supports unit: weeks", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-29T14:00:00",
reference: "2024-03-15T14:00:00",
unit: "weeks",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("weeks");
expect(data.relative).toBeDefined();
});
test("supports unit: days", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-20T14:00:00",
reference: "2024-03-15T14:00:00",
unit: "days",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("days");
expect(data.relative).toBeDefined();
});
test("supports unit: hours", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T18:00:00",
reference: "2024-03-15T14:00:00",
unit: "hours",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("hours");
expect(data.relative).toBeDefined();
});
test("supports unit: minutes", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T14:30:00",
reference: "2024-03-15T14:00:00",
unit: "minutes",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("minutes");
expect(data.relative).toBeDefined();
});
test("supports unit: seconds", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T14:00:30",
reference: "2024-03-15T14:00:00",
unit: "seconds",
} as any, ctx);
const data = parseResult(result);
expect(data.unit_used).toBe("seconds");
expect(data.relative).toBeDefined();
});
test("supports locale parameter", async () => {
const { relative } = await import("../tools/time.ts");
const pastTime = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
const result = await relative.execute({
time: pastTime,
locale: "de",
} as any, ctx);
const data = parseResult(result);
expect(data.relative).toBeDefined();
});
test("returns error for invalid timezone", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T14:00:00",
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
test("handles equal target and reference times", async () => {
const { relative } = await import("../tools/time.ts");
const result = await relative.execute({
time: "2024-03-15T14:00:00",
reference: "2024-03-15T14:00:00",
} as any, ctx);
const data = parseResult(result);
// Luxon returns "in 0 sec." for equal times
expect(data.relative).toBe("in 0 sec.");
});
});
// ---------------------------------------------------------------------------
// duration tool additional options
// ---------------------------------------------------------------------------
describe("duration - additional unit options", () => {
test("returns duration in milliseconds", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-01T00:00:01",
unit: "milliseconds",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_milliseconds).toBe(1000);
});
test("returns duration in seconds", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-01T00:01:00",
unit: "seconds",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_seconds).toBe(60);
});
test("returns duration in minutes", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-01T01:00:00",
unit: "minutes",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_minutes).toBe(60);
});
test("returns duration in hours", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-01T12:00:00",
unit: "hours",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_hours).toBe(12);
});
test("returns duration in weeks", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-15T00:00:00",
unit: "weeks",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_weeks).toBe(2);
});
test("returns duration in months", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-01-01T00:00:00",
end: "2024-04-01T00:00:00",
unit: "months",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_months).toBe(3);
});
test("returns duration in years", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2022-01-01T00:00:00",
end: "2024-01-01T00:00:00",
unit: "years",
} as any, ctx);
const data = parseResult(result);
expect(data.value_in_years).toBe(2);
});
test("returns error for invalid timezone", async () => {
const { duration } = await import("../tools/time.ts");
const result = await duration.execute({
start: "2024-03-01T00:00:00",
end: "2024-03-15T00:00:00",
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
});
// ---------------------------------------------------------------------------
// add tool additional units
// ---------------------------------------------------------------------------
describe("add - additional units", () => {
test("adds quarters to a date", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
quarters: 1,
} as any, ctx);
const data = parseResult(result);
expect(data.result.date).toBe("2024-06-15");
expect(data.change_applied).toContain("1 quarter");
});
test("adds months to a date (solo)", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
months: 2,
} as any, ctx);
const data = parseResult(result);
expect(data.result.date).toBe("2024-05-15");
expect(data.change_applied).toContain("2 month");
});
test("adds minutes to a time", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
minutes: 30,
} as any, ctx);
const data = parseResult(result);
expect(data.result.time).toBe("12:30:00");
expect(data.change_applied).toContain("30 minute");
});
test("adds seconds to a time", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
seconds: 45,
} as any, ctx);
const data = parseResult(result);
expect(data.result.time).toBe("12:00:45");
expect(data.change_applied).toContain("45 second");
});
test("adds milliseconds to a time", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
milliseconds: 500,
} as any, ctx);
const data = parseResult(result);
expect(data.change_applied).toContain("500 millisecond");
expect(data.difference_ms).toBe(500);
});
test("returns error for invalid timezone", async () => {
const { add } = await import("../tools/time.ts");
const result = await add.execute({
time: "2024-03-15T12:00:00",
days: 1,
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
test("returns error for invalid result (huge duration overflow)", async () => {
const { add } = await import("../tools/time.ts");
// Adding 1 million years causes an invalid date (outside Luxon's valid range)
const result = await add.execute({
time: "2024-01-01T00:00:00",
years: 1000000,
} as any, ctx);
expect(result).toContain("Result is invalid");
});
});
// ---------------------------------------------------------------------------
// compare tool invalid timezone
// ---------------------------------------------------------------------------
describe("compare - error paths", () => {
test("returns error for invalid timezone", async () => {
const { compare } = await import("../tools/time.ts");
const result = await compare.execute({
time1: "2024-03-15T12:00:00",
time2: "2024-03-20T12:00:00",
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
});
// ---------------------------------------------------------------------------
// convert tool conversion failure
// ---------------------------------------------------------------------------
describe("convert - conversion failure", () => {
test("returns error when conversion produces invalid date (edge of valid range)", async () => {
const { convert } = await import("../tools/time.ts");
// Max valid Unix timestamp (8639999999999999 ms = year 275760-09-12T23:59:59.999Z)
// is valid in UTC but becomes invalid when converted to timezones with positive offsets
// (like Asia/Tokyo with UTC+9) because the offset pushes it outside Luxon's valid range
const result = await convert.execute({
time: "8639999999999999",
from_timezone: "UTC",
to_timezone: "Asia/Tokyo",
} as any, ctx);
expect(result).toContain("Conversion failed");
});
});
// ---------------------------------------------------------------------------
// unix tool invalid timezone
// ---------------------------------------------------------------------------
describe("unix - error paths", () => {
test("returns error for invalid timezone", async () => {
const { unix } = await import("../tools/time.ts");
const result = await unix.execute({
time: "2024-03-15T14:30:00Z",
timezone: "Invalid/Timezone",
} as any, ctx);
expect(result).toContain("Invalid timezone");
});
});
// ---------------------------------------------------------------------------
// relative tool toRelative() null fallback
// ---------------------------------------------------------------------------
describe("relative - toRelative null fallback", () => {
test("returns 'unknown' when toRelative returns null (auto unit)", async () => {
const { DateTime } = await import("luxon");
const { relative } = await import("../tools/time.ts");
// Mock toRelative to return null
const originalToRelative = DateTime.prototype.toRelative;
DateTime.prototype.toRelative = function () {
return null;
};
try {
const result = await relative.execute({
time: "2024-03-15T14:00:00",
reference: "2024-03-15T12:00:00",
unit: "auto",
} as any, ctx);
const data = parseResult(result);
expect(data.relative).toBe("unknown");
expect(data.unit_used).toBe("auto");
} finally {
// Restore original method
DateTime.prototype.toRelative = originalToRelative;
}
});
test("returns 'unknown' when toRelative returns null (specific unit)", async () => {
const { DateTime } = await import("luxon");
const { relative } = await import("../tools/time.ts");
// Mock toRelative to return null
const originalToRelative = DateTime.prototype.toRelative;
DateTime.prototype.toRelative = function () {
return null;
};
try {
const result = await relative.execute({
time: "2024-03-15T14:00:00",
reference: "2024-03-15T12:00:00",
unit: "days",
} as any, ctx);
const data = parseResult(result);
expect(data.relative).toBe("unknown");
expect(data.unit_used).toBe("days");
} finally {
// Restore original method
DateTime.prototype.toRelative = originalToRelative;
}
});
});
});