add more unit tests to ensure the timezone handling works as expected

noxify · noxify · commit 095237c18bb8 · 2025-07-18T15:15:38.000+02:00
diff --git a/packages/adapter-drizzle/tests/timezone-edge-cases.test.ts b/packages/adapter-drizzle/tests/timezone-edge-cases.test.ts
@@ -0,0 +1,218 @@
+import { PGlite } from "@electric-sql/pglite"
+import { drizzle } from "drizzle-orm/pglite"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+
+import { DrizzleQueueAdapter } from "~/index"
+import * as schema from "~/schema"
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/consistent-type-imports
+const { pushSchema } = require("drizzle-kit/api") as typeof import("drizzle-kit/api")
+
+describe("Timezone Edge Cases", () => {
+  let db: ReturnType<typeof drizzle<typeof schema>>
+  let adapter: DrizzleQueueAdapter
+  let client: PGlite
+
+  beforeEach(async () => {
+    client = new PGlite()
+    db = drizzle(client, { schema })
+
+    const { apply } = await pushSchema(schema, db as never)
+    await apply()
+
+    adapter = new DrizzleQueueAdapter(db, "timezone-edge-test")
+    await adapter.connect()
+  })
+
+  afterEach(async () => {
+    await adapter.disconnect()
+    await client.close()
+  })
+
+  it("should handle dates with explicit timezone offsets", async () => {
+    // User passes date with timezone offset
+    const dateWithOffset = new Date("2024-01-15T14:00:00+02:00") // 2 PM in +2 timezone = 12 PM UTC
+    
+    const job = await adapter.addJob({
+      name: "offset-test",
+      payload: { test: "data" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: dateWithOffset,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Should store the UTC equivalent (12 PM UTC, not 2 PM UTC)
+    expect(job.processAt.toISOString()).toBe("2024-01-15T12:00:00.000Z")
+    expect(job.processAt.getTime()).toBe(dateWithOffset.getTime())
+  })
+
+  it("should handle negative timezone offsets", async () => {
+    // User passes date with negative timezone offset
+    const dateWithNegativeOffset = new Date("2024-01-15T14:00:00-05:00") // 2 PM EST = 7 PM UTC
+    
+    const job = await adapter.addJob({
+      name: "negative-offset-test",
+      payload: { test: "data" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: dateWithNegativeOffset,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Should store the UTC equivalent (7 PM UTC)
+    expect(job.processAt.toISOString()).toBe("2024-01-15T19:00:00.000Z")
+    expect(job.processAt.getTime()).toBe(dateWithNegativeOffset.getTime())
+  })
+
+  it("should handle server in different timezone", async () => {
+    // Simulate server running in different timezone by creating dates in different ways
+    const utcDate = new Date("2024-01-15T14:00:00Z") // Explicit UTC
+    const localDate = new Date("2024-01-15T14:00:00") // Local time (depends on server timezone)
+    
+    const utcJob = await adapter.addJob({
+      name: "utc-job",
+      payload: { type: "utc" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: utcDate,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    const localJob = await adapter.addJob({
+      name: "local-job", 
+      payload: { type: "local" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: localDate,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // UTC date should be stored exactly as provided
+    expect(utcJob.processAt.toISOString()).toBe("2024-01-15T14:00:00.000Z")
+    
+    // Local date gets stored as whatever the server interprets it as
+    // This is the key test - we store whatever Date object represents in UTC
+    expect(localJob.processAt).toBeInstanceOf(Date)
+    expect(localJob.processAt.getTime()).toBe(localDate.getTime())
+  })
+
+  it("should handle daylight saving time transitions", async () => {
+    // Spring forward: March 10, 2024 in America/New_York
+    const springForwardDate = new Date("2024-03-10T07:00:00Z") // 2 AM EST becomes 3 AM EDT
+    
+    // Fall back: November 3, 2024 in America/New_York  
+    const fallBackDate = new Date("2024-11-03T06:00:00Z") // 2 AM EDT becomes 1 AM EST
+
+    const springJob = await adapter.addJob({
+      name: "spring-job",
+      payload: { dst: "spring" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: springForwardDate,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    const fallJob = await adapter.addJob({
+      name: "fall-job",
+      payload: { dst: "fall" },
+      status: "pending", 
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: fallBackDate,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Both should store exact UTC timestamps regardless of DST
+    expect(springJob.processAt.toISOString()).toBe("2024-03-10T07:00:00.000Z")
+    expect(fallJob.processAt.toISOString()).toBe("2024-11-03T06:00:00.000Z")
+  })
+
+  it("should handle various date formats consistently", async () => {
+    const testCases = [
+      {
+        name: "ISO with Z",
+        date: new Date("2024-01-15T14:00:00Z"),
+        expected: "2024-01-15T14:00:00.000Z"
+      },
+      {
+        name: "ISO with +00:00",
+        date: new Date("2024-01-15T14:00:00+00:00"),
+        expected: "2024-01-15T14:00:00.000Z"
+      },
+      {
+        name: "ISO with +02:00",
+        date: new Date("2024-01-15T14:00:00+02:00"),
+        expected: "2024-01-15T12:00:00.000Z" // 2 hours earlier in UTC
+      },
+      {
+        name: "ISO with -05:00",
+        date: new Date("2024-01-15T14:00:00-05:00"),
+        expected: "2024-01-15T19:00:00.000Z" // 5 hours later in UTC
+      },
+      {
+        name: "Timestamp",
+        date: new Date(1705327200000), // 2024-01-15T14:00:00Z
+        expected: "2024-01-15T14:00:00.000Z"
+      }
+    ]
+
+    for (const testCase of testCases) {
+      const job = await adapter.addJob({
+        name: `format-test-${testCase.name}`,
+        payload: { format: testCase.name },
+        status: "pending",
+        priority: 2,
+        attempts: 0,
+        maxAttempts: 3,
+        processAt: testCase.date,
+        progress: 0,
+        repeatCount: 0,
+      })
+
+      expect(job.processAt.toISOString()).toBe(testCase.expected)
+    }
+  })
+
+  it("should maintain timestamp consistency across retrieval", async () => {
+    // Test that what goes in comes out exactly the same
+    const originalTimestamp = 1705327200000 // 2024-01-15T14:00:00Z
+    const originalDate = new Date(originalTimestamp)
+    
+    const job = await adapter.addJob({
+      name: "consistency-test",
+      payload: { test: "data" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: originalDate,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Retrieve the job
+    const retrievedJob = await adapter.getNextJob()
+    
+    expect(retrievedJob).toBeTruthy()
+    expect(retrievedJob?.processAt.getTime()).toBe(originalTimestamp)
+    expect(retrievedJob?.processAt.toISOString()).toBe(originalDate.toISOString())
+  })
+})
diff --git a/packages/adapter-drizzle/tests/utc-storage.test.ts b/packages/adapter-drizzle/tests/utc-storage.test.ts
@@ -0,0 +1,157 @@
+import { PGlite } from "@electric-sql/pglite"
+import { drizzle } from "drizzle-orm/pglite"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+
+import { DrizzleQueueAdapter } from "~/index"
+import * as schema from "~/schema"
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/consistent-type-imports
+const { pushSchema } = require("drizzle-kit/api") as typeof import("drizzle-kit/api")
+
+describe("UTC Storage Verification", () => {
+  let db: ReturnType<typeof drizzle<typeof schema>>
+  let adapter: DrizzleQueueAdapter
+  let client: PGlite
+
+  beforeEach(async () => {
+    client = new PGlite()
+    db = drizzle(client, { schema })
+
+    const { apply } = await pushSchema(schema, db as never)
+    await apply()
+
+    adapter = new DrizzleQueueAdapter(db, "utc-test-queue")
+    await adapter.connect()
+  })
+
+  afterEach(async () => {
+    await adapter.disconnect()
+    await client.close()
+  })
+
+  it("should store all timestamps as UTC in database", async () => {
+    const now = new Date()
+    
+    // Add job with timezone context
+    const job = await adapter.addJob({
+      name: "timezone-test",
+      payload: { test: "data" },
+      status: "pending",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: new Date("2024-01-15T14:00:00Z"), // 9 AM EST = 2 PM UTC
+      progress: 0,
+      cron: "0 9 * * *",
+      repeatEvery: undefined,
+      repeatLimit: undefined,
+      repeatCount: 0,
+    })
+
+    // Verify the job was stored
+    expect(job.processAt).toBeInstanceOf(Date)
+    
+    // The key test: processAt should be the exact UTC time we provided
+    expect(job.processAt.toISOString()).toBe("2024-01-15T14:00:00.000Z")
+    
+    // Verify no timezone field exists
+    expect(job).not.toHaveProperty("timezone")
+    
+    // Verify createdAt is also UTC
+    expect(job.createdAt.getTimezoneOffset()).toBe(new Date().getTimezoneOffset()) // Should be system UTC
+  })
+
+  it("should handle cron jobs with timezone conversion at creation", async () => {
+    // This simulates what happens when user adds a cron job with timezone
+    const processAt = new Date("2024-01-15T14:00:00Z") // Pre-converted to UTC
+    
+    const job = await adapter.addJob({
+      name: "cron-timezone-test", 
+      payload: { timezone: "America/New_York" }, // Timezone info in payload only
+      status: "delayed",
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt, // Already UTC
+      progress: 0,
+      cron: "0 9 * * *", // Original cron expression
+      repeatEvery: undefined,
+      repeatLimit: undefined,
+      repeatCount: 0,
+    })
+
+    // Database should store exact UTC timestamp
+    expect(job.processAt.toISOString()).toBe("2024-01-15T14:00:00.000Z")
+    expect(job.cron).toBe("0 9 * * *")
+    expect(job).not.toHaveProperty("timezone")
+  })
+
+  it("should retrieve jobs with UTC timestamps", async () => {
+    // Add a job
+    await adapter.addJob({
+      name: "retrieval-test",
+      payload: { test: "data" },
+      status: "pending", 
+      priority: 2,
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: new Date("2024-01-15T14:00:00Z"),
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Retrieve the job
+    const job = await adapter.getNextJob()
+    
+    expect(job).toBeTruthy()
+    expect(job?.processAt.toISOString()).toBe("2024-01-15T14:00:00.000Z")
+    expect(job).not.toHaveProperty("timezone")
+  })
+
+  it("should handle delayed jobs with UTC timestamps", async () => {
+    const futureUTC = new Date(Date.now() + 3600000) // 1 hour from now in UTC
+    
+    const job = await adapter.addJob({
+      name: "delayed-test",
+      payload: { test: "data" },
+      status: "delayed",
+      priority: 2, 
+      attempts: 0,
+      maxAttempts: 3,
+      processAt: futureUTC,
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Should store exact UTC timestamp
+    expect(job.processAt.getTime()).toBe(futureUTC.getTime())
+    expect(job.status).toBe("delayed")
+  })
+
+  it("should verify database schema has no timezone columns", async () => {
+    // This is more of a schema verification test
+    const job = await adapter.addJob({
+      name: "schema-test",
+      payload: { test: "data" },
+      status: "pending",
+      priority: 2,
+      attempts: 0, 
+      maxAttempts: 3,
+      processAt: new Date(),
+      progress: 0,
+      repeatCount: 0,
+    })
+
+    // Verify the job object structure
+    const jobKeys = Object.keys(job)
+    expect(jobKeys).not.toContain("timezone")
+    
+    // Verify required UTC fields exist
+    expect(jobKeys).toContain("createdAt")
+    expect(jobKeys).toContain("processAt")
+    
+    // All date fields should be Date objects (UTC)
+    expect(job.createdAt).toBeInstanceOf(Date)
+    expect(job.processAt).toBeInstanceOf(Date)
+  })
+})
