chore: import upstream snapshot with attribution

tests/unit/batch-processor-expiration.test.ts

@@ -0,0 +1,152 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+
+// Helper functions from batchProcessor.ts
+function parseBatchWindowSeconds(window: string | null | undefined): number {
+  const DEFAULT = 24 * 60 * 60;
+  if (!window) return DEFAULT;
+  const match = /^(\d+)([hdm])$/.exec(window);
+  if (!match) return DEFAULT;
+
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "h") return value * 3600;
+  if (unit === "d") return value * 86400;
+  if (unit === "m") return value * 60;
+  return DEFAULT;
+}
+
+describe("Batch Processor - File Expiration", () => {
+  describe("getBatchOutputExpiresAt logic", () => {
+    it("should calculate output expiration as 30 days from batch completion", () => {
+      const completedAt = Math.floor(Date.now() / 1000) - 5 * 24 * 60 * 60; // 5 days ago
+      const expectedExpiresAt = completedAt + 30 * 24 * 60 * 60;
+
+      // Simulate the logic from getBatchOutputExpiresAt
+      const thirtyDaysInSeconds = 30 * 24 * 60 * 60;
+      const expiresAt = completedAt + thirtyDaysInSeconds;
+
+      assert(expiresAt === expectedExpiresAt);
+    });
+
+    it("should use custom expires_after if provided", () => {
+      const createdAt = Math.floor(Date.now() / 1000);
+      const customSeconds = 7 * 24 * 60 * 60; // 7 days
+      const expiresAt = createdAt + customSeconds;
+
+      assert(expiresAt === createdAt + 7 * 24 * 60 * 60);
+    });
+
+    it("should handle failed batch expiration", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const failedAt = now - 10 * 24 * 60 * 60; // 10 days ago
+      const expiresAt = failedAt + 30 * 24 * 60 * 60;
+
+      const expectedExpiresAt = now + 20 * 24 * 60 * 60;
+      assert.strictEqual(expiresAt, expectedExpiresAt);
+    });
+
+    it("should handle cancelled batch expiration", () => {
+      const cancelledAt = Math.floor(Date.now() / 1000) - 2 * 24 * 60 * 60; // 2 days ago
+      const expiresAt = cancelledAt + 30 * 24 * 60 * 60;
+
+      assert(expiresAt > Math.floor(Date.now() / 1000)); // Should still be in future
+    });
+  });
+
+  describe("File cleanup expiration logic", () => {
+    it("should identify expired input files", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const completionTime = now - 31 * 24 * 60 * 60; // Completed 31 days ago
+      const inputExpiresAt = completionTime + 30 * 24 * 60 * 60;
+
+      // File should be expired
+      assert(now > inputExpiresAt, "File should be past expiration");
+    });
+
+    it("should NOT delete input files within 30 days", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const completionTime = now - 15 * 24 * 60 * 60; // Completed 15 days ago
+      const inputExpiresAt = completionTime + 30 * 24 * 60 * 60;
+
+      // File should NOT be expired yet
+      assert(now < inputExpiresAt, "File should not be expired yet");
+    });
+
+    it("should identify expired output files", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const completionTime = now - 35 * 24 * 60 * 60; // Completed 35 days ago
+      const outputExpiresAt = completionTime + 30 * 24 * 60 * 60;
+
+      assert(now > outputExpiresAt, "Output file should be expired");
+    });
+
+    it("should NOT delete output files within 30 days of completion", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const completionTime = now - 25 * 24 * 60 * 60; // Completed 25 days ago
+      const outputExpiresAt = completionTime + 30 * 24 * 60 * 60;
+
+      assert(now < outputExpiresAt, "Output file should still be valid");
+    });
+  });
+
+  describe("Completion window parsing", () => {
+    it("should parse hours format", () => {
+      const seconds = parseBatchWindowSeconds("24h");
+      assert(seconds === 24 * 3600);
+    });
+
+    it("should parse days format", () => {
+      const seconds = parseBatchWindowSeconds("2d");
+      assert(seconds === 2 * 86400);
+    });
+
+    it("should parse minutes format", () => {
+      const seconds = parseBatchWindowSeconds("30m");
+      assert(seconds === 30 * 60);
+    });
+
+    it("should default to 24h for invalid format", () => {
+      const seconds = parseBatchWindowSeconds("invalid");
+      assert(seconds === 24 * 60 * 60);
+    });
+
+    it("should default to 24h for null", () => {
+      const seconds = parseBatchWindowSeconds(null);
+      assert(seconds === 24 * 60 * 60);
+    });
+
+    it("should default to 24h for undefined", () => {
+      const seconds = parseBatchWindowSeconds(undefined);
+      assert(seconds === 24 * 60 * 60);
+    });
+  });
+
+  describe("Orphan file cleanup", () => {
+    it("should identify orphan batch files stuck in validating after 48h", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const fortyNineHoursAgo = now - 49 * 60 * 60;
+
+      const isOrphan = now - fortyNineHoursAgo > 48 * 60 * 60;
+      assert(isOrphan, "File should be identified as orphan");
+    });
+
+    it("should NOT delete batch files in validating under 48h", () => {
+      const now = Math.floor(Date.now() / 1000);
+      const fortyHoursAgo = now - 40 * 60 * 60;
+
+      const isOrphan = now - fortyHoursAgo > 48 * 60 * 60;
+      assert(!isOrphan, "File should not be orphan yet");
+    });
+
+    it("should identify old batch files regardless of status", () => {
+      const now = Math.floor(Date.now() / 1000);
+
+      const createdAt = now - 3 * 24 * 60 * 60;
+      const threshold = 48 * 60 * 60; // 48 hours
+      const isOldBatchFile = now - createdAt > threshold;
+
+      assert(isOldBatchFile, "File older than 48h should be flagged");
+    });
+  });
+});