@rebasepro/server-core 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/test/rate-limiter.test.ts

@@ -9,7 +9,7 @@ describe("Rate Limiter", () => {
         const limiter = createRateLimiter({
             windowMs: options.windowMs ?? 60 * 1000, // 1 minute
             limit: options.limit ?? 3,
-            keyGenerator: (c) => c.req.header("x-forwarded-for") || "test-ip",
+            keyGenerator: (c) => c.req.header("x-forwarded-for") || "test-ip"
         });
         app.use("/api/*", limiter);
         app.get("/api/test", (c) => c.json({ ok: true }));
@@ -20,7 +20,7 @@ describe("Rate Limiter", () => {
         const app = createTestApp({ limit: 5 });
 
         const res = await app.request("/api/test", {
-            headers: { "x-forwarded-for": "1.2.3.4" },
+            headers: { "x-forwarded-for": "1.2.3.4" }
         });
 
         expect(res.status).toBe(200);
@@ -37,7 +37,7 @@ describe("Rate Limiter", () => {
 
         // Third should be rate limited
         const res = await app.request("/api/test", {
-            headers: { "x-forwarded-for": "10.0.0.1" },
+            headers: { "x-forwarded-for": "10.0.0.1" }
         });
 
         expect(res.status).toBe(429);
@@ -50,7 +50,7 @@ describe("Rate Limiter", () => {
 
         await app.request("/api/test", { headers: { "x-forwarded-for": "10.0.0.2" } });
         const res = await app.request("/api/test", {
-            headers: { "x-forwarded-for": "10.0.0.2" },
+            headers: { "x-forwarded-for": "10.0.0.2" }
         });
 
         expect(res.headers.get("Retry-After")).toBeDefined();
@@ -61,10 +61,10 @@ describe("Rate Limiter", () => {
         const app = createTestApp({ limit: 1 });
 
         const res1 = await app.request("/api/test", {
-            headers: { "x-forwarded-for": "ip-a" },
+            headers: { "x-forwarded-for": "ip-a" }
         });
         const res2 = await app.request("/api/test", {
-            headers: { "x-forwarded-for": "ip-b" },
+            headers: { "x-forwarded-for": "ip-b" }
         });
 
         expect(res1.status).toBe(200);
@@ -90,7 +90,7 @@ describe("Rate Limiter", () => {
         const limiter = createRateLimiter({
             limit: 0,
             message: "Slow down!",
-            keyGenerator: () => "always-same",
+            keyGenerator: () => "always-same"
         });
         app.use("/api/*", limiter);
         app.get("/api/test", (c) => c.json({ ok: true }));

package/test/safe-compare.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Tests for the safeCompare function used in auth middleware.
+ *
+ * Since safeCompare is not exported, we test it indirectly through
+ * the createAuthMiddleware behavior with service keys. However, for
+ * unit-level verification we replicate the logic here.
+ */
+import { timingSafeEqual } from "crypto";
+
+// Replicate the safeCompare implementation to test in isolation
+function safeCompare(a: string, b: string): boolean {
+    const maxLen = Math.max(a.length, b.length);
+    const bufA = Buffer.alloc(maxLen);
+    const bufB = Buffer.alloc(maxLen);
+    bufA.write(a);
+    bufB.write(b);
+    try {
+        const isEqual = timingSafeEqual(bufA, bufB);
+        return isEqual && a.length === b.length;
+    } catch {
+        return false;
+    }
+}
+
+describe("safeCompare", () => {
+    it("should return true for identical strings", () => {
+        expect(safeCompare("my-secret-key-12345678901234567890", "my-secret-key-12345678901234567890")).toBe(true);
+    });
+
+    it("should return false for different strings of same length", () => {
+        expect(safeCompare("aaaa", "bbbb")).toBe(false);
+    });
+
+    it("should return false for different length strings", () => {
+        expect(safeCompare("short", "a-much-longer-string")).toBe(false);
+    });
+
+    it("should return false when one string is a prefix of the other", () => {
+        // This is the critical case: "abc" vs "abc\0\0\0" would match
+        // without the length check, since Buffer.alloc zero-fills
+        expect(safeCompare("abc", "abc\0\0\0")).toBe(false);
+    });
+
+    it("should return false for empty string vs non-empty", () => {
+        expect(safeCompare("", "something")).toBe(false);
+    });
+
+    it("should return true for two empty strings", () => {
+        expect(safeCompare("", "")).toBe(true);
+    });
+
+    it("should handle unicode strings", () => {
+        expect(safeCompare("café", "café")).toBe(true);
+        expect(safeCompare("café", "cafe")).toBe(false);
+    });
+
+    it("should not leak length information via early return", () => {
+        // Both comparisons should take similar time (constant-time)
+        // We can't easily assert timing, but we verify they both
+        // go through the same code path
+        const result1 = safeCompare("a", "bb");
+        const result2 = safeCompare("aa", "bb");
+        expect(result1).toBe(false);
+        expect(result2).toBe(false);
+    });
+});

package/test/singleton.test.ts

@@ -0,0 +1,59 @@
+import { rebase, _initRebase, _setRebaseMock, _resetRebaseMock } from "../src/singleton";
+import type { RebaseClient } from "@rebasepro/types";
+
+describe("rebase singleton", () => {
+    afterEach(() => {
+        // Reset after each test to avoid interference
+        process.env.NODE_ENV = "test";
+        _resetRebaseMock();
+    });
+
+    it("should throw when accessing properties before initialization", () => {
+        expect(() => rebase.data).toThrowError(/server not initialized yet/);
+    });
+
+    it("should allow property access after initialization", () => {
+        const mockData = { find: jest.fn() };
+        _setRebaseMock({ data: mockData } as Partial<RebaseClient>);
+
+        expect(rebase.data).toBe(mockData);
+    });
+
+    it("should throw on property assignment (set trap)", () => {
+        _setRebaseMock({ data: {} } as Partial<RebaseClient>);
+
+        expect(() => {
+            (rebase as Record<string, unknown>).data = "overwritten";
+        }).toThrowError(/Cannot set rebase\.data directly/);
+    });
+
+    it("should reset properly with _resetRebaseMock", () => {
+        _setRebaseMock({ data: {} } as Partial<RebaseClient>);
+        expect(() => rebase.data).not.toThrow();
+
+        _resetRebaseMock();
+        expect(() => rebase.data).toThrowError(/server not initialized yet/);
+    });
+
+    it("should throw if _setRebaseMock is called outside test env", () => {
+        const originalEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "production";
+
+        expect(() => _setRebaseMock({} as Partial<RebaseClient>)).toThrowError(
+            /can only be called in a test environment/
+        );
+
+        process.env.NODE_ENV = originalEnv;
+    });
+
+    it("should throw if _resetRebaseMock is called outside test env", () => {
+        const originalEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "production";
+
+        expect(() => _resetRebaseMock()).toThrowError(
+            /can only be called in a test environment/
+        );
+
+        process.env.NODE_ENV = originalEnv;
+    });
+});

package/test/storage-local.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -17,7 +18,8 @@ describe("LocalStorageController", () => {
 
     afterEach(async () => {
         // Clean up temporary directory
-        await fs.promises.rm(tempDir, { recursive: true, force: true });
+        await fs.promises.rm(tempDir, { recursive: true,
+force: true });
     });
 
     describe("constructor", () => {
@@ -30,19 +32,18 @@ describe("LocalStorageController", () => {
         });
     });
 
-    describe("uploadFile", () => {
+    describe("putObject", () => {
         it("should upload a file and return metadata", async () => {
             const content = Buffer.from("Hello, World!");
             const file = new File([content], "test.txt", { type: "text/plain" });
 
-            const result = await controller.uploadFile({
+            const result = await controller.putObject({
                 file,
-                fileName: "test.txt",
-                path: "uploads"
+                key: "uploads/test.txt"
             });
 
-            expect(result.path).toContain("uploads");
-            expect(result.path).toContain("test.txt");
+            expect(result.key).toContain("uploads");
+            expect(result.key).toContain("test.txt");
 
             // Verify file exists on disk (uses default bucket)
             const filePath = path.join(tempDir, "default", "uploads", "test.txt");
@@ -54,10 +55,9 @@ describe("LocalStorageController", () => {
             const content = Buffer.from("Nested content");
             const file = new File([content], "nested.txt", { type: "text/plain" });
 
-            await controller.uploadFile({
+            await controller.putObject({
                 file,
-                fileName: "nested.txt",
-                path: "level1/level2/level3"
+                key: "level1/level2/level3/nested.txt"
             });
 
             const filePath = path.join(tempDir, "default", "level1", "level2", "level3", "nested.txt");
@@ -69,10 +69,9 @@ describe("LocalStorageController", () => {
             const content = Buffer.from("Bucket content");
             const file = new File([content], "bucket.txt", { type: "text/plain" });
 
-            await controller.uploadFile({
+            await controller.putObject({
                 file,
-                fileName: "bucket.txt",
-                path: "files",
+                key: "files/bucket.txt",
                 bucket: "custom-bucket"
             });
 
@@ -85,10 +84,9 @@ describe("LocalStorageController", () => {
             const content = Buffer.from("With metadata");
             const file = new File([content], "meta.txt", { type: "text/plain" });
 
-            await controller.uploadFile({
+            await controller.putObject({
                 file,
-                fileName: "meta.txt",
-                path: "uploads",
+                key: "uploads/meta.txt",
                 metadata: { customField: "customValue" }
             });
 
@@ -99,39 +97,37 @@ describe("LocalStorageController", () => {
         });
     });
 
-    describe("getFile", () => {
+    describe("getObject", () => {
         it("should retrieve an uploaded file using local:// URL format", async () => {
             const content = Buffer.from("Retrieve me");
             const file = new File([content], "retrieve.txt", { type: "text/plain" });
 
-            const uploadResult = await controller.uploadFile({
+            const uploadResult = await controller.putObject({
                 file,
-                fileName: "retrieve.txt",
-                path: "uploads"
+                key: "uploads/retrieve.txt"
             });
 
             // Use the storageUrl from upload result (local:// format)
-            const retrieved = await controller.getFile(uploadResult.storageUrl!);
+            const retrieved = await controller.getObject(uploadResult.storageUrl!);
 
             expect(retrieved).not.toBeNull();
             expect(retrieved?.name).toBe("retrieve.txt");
         });
 
         it("should return null for non-existent file", async () => {
-            const result = await controller.getFile("local://default/nonexistent/file.txt");
+            const result = await controller.getObject("local://default/nonexistent/file.txt");
             expect(result).toBeNull();
         });
     });
 
-    describe("deleteFile", () => {
+    describe("deleteObject", () => {
         it("should delete an uploaded file using local:// URL format", async () => {
             const content = Buffer.from("Delete me");
             const file = new File([content], "delete.txt", { type: "text/plain" });
 
-            const uploadResult = await controller.uploadFile({
+            const uploadResult = await controller.putObject({
                 file,
-                fileName: "delete.txt",
-                path: "uploads"
+                key: "uploads/delete.txt"
             });
 
             // Verify file exists
@@ -140,7 +136,7 @@ describe("LocalStorageController", () => {
             expect(exists).toBe(true);
 
             // Delete the file using local:// URL format
-            await controller.deleteFile(uploadResult.storageUrl!);
+            await controller.deleteObject(uploadResult.storageUrl!);
 
             // Verify file no longer exists
             exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
@@ -148,21 +144,20 @@ describe("LocalStorageController", () => {
         });
 
         it("should not throw when deleting non-existent file", async () => {
-            await expect(controller.deleteFile("local://default/nonexistent/file.txt")).resolves.not.toThrow();
+            await expect(controller.deleteObject("local://default/nonexistent/file.txt")).resolves.not.toThrow();
         });
 
         it("should also delete metadata file", async () => {
             const content = Buffer.from("Delete with metadata");
             const file = new File([content], "withmeta.txt", { type: "text/plain" });
 
-            const uploadResult = await controller.uploadFile({
+            const uploadResult = await controller.putObject({
                 file,
-                fileName: "withmeta.txt",
-                path: "uploads",
+                key: "uploads/withmeta.txt",
                 metadata: { key: "value" }
             });
 
-            await controller.deleteFile(uploadResult.storageUrl!);
+            await controller.deleteObject(uploadResult.storageUrl!);
 
             const metadataPath = path.join(tempDir, "default", "uploads", "withmeta.txt.metadata.json");
             const exists = await fs.promises.access(metadataPath).then(() => true).catch(() => false);
@@ -175,48 +170,46 @@ describe("LocalStorageController", () => {
             // Upload some test files
             for (let i = 1; i <= 5; i++) {
                 const file = new File([`Content ${i}`], `file${i}.txt`, { type: "text/plain" });
-                await controller.uploadFile({
+                await controller.putObject({
                     file,
-                    fileName: `file${i}.txt`,
-                    path: "listtest"
+                    key: `listtest/file${i}.txt`
                 });
             }
         });
 
         it("should list files in a directory", async () => {
-            const result = await controller.list("listtest", { bucket: "default" });
+            const result = await controller.listObjects("listtest", { bucket: "default" });
 
             // Items should be the actual files (not metadata files)
             expect(result.items.length).toBeGreaterThanOrEqual(5);
         });
 
         it("should return empty list for non-existent directory", async () => {
-            const result = await controller.list("nonexistent", { bucket: "default" });
+            const result = await controller.listObjects("nonexistent", { bucket: "default" });
 
             expect(result.items).toHaveLength(0);
         });
     });
 
-    describe("getDownloadURL", () => {
+    describe("getSignedUrl", () => {
         it("should return download URL for existing file", async () => {
             const content = Buffer.from("Download me");
             const file = new File([content], "download.txt", { type: "text/plain" });
 
-            const uploadResult = await controller.uploadFile({
+            const uploadResult = await controller.putObject({
                 file,
-                fileName: "download.txt",
-                path: "uploads"
+                key: "uploads/download.txt"
             });
 
             // Use the storageUrl from upload result
-            const result = await controller.getDownloadURL(uploadResult.storageUrl!);
+            const result = await controller.getSignedUrl(uploadResult.storageUrl!);
 
             expect(result.url).toBeTruthy();
             expect(result.fileNotFound).toBeFalsy();
         });
 
         it("should return fileNotFound for non-existent file", async () => {
-            const result = await controller.getDownloadURL("local://default/nonexistent/file.txt");
+            const result = await controller.getSignedUrl("local://default/nonexistent/file.txt");
 
             expect(result.fileNotFound).toBe(true);
         });

package/test/storage-registry.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
 import {
     StorageRegistry,
     DefaultStorageRegistry,
@@ -8,14 +9,15 @@ import { StorageController } from "../src/storage/types";
 /**
  * Mock StorageController for testing
  */
-function createMockStorageController(type: 'local' | 's3'): StorageController {
+function createMockStorageController(type: "local" | "s3"): StorageController {
     return {
-        uploadFile: jest.fn().mockResolvedValue({ path: "test/file.txt" }),
-        getDownloadURL: jest.fn().mockResolvedValue({ url: "http://example.com/file.txt" }),
-        getFile: jest.fn().mockResolvedValue(null),
-        deleteFile: jest.fn().mockResolvedValue(undefined),
-        list: jest.fn().mockResolvedValue({ items: [], prefixes: [] }),
-        getType: jest.fn().mockReturnValue(type)
+        putObject: vi.fn().mockResolvedValue({ path: "test/file.txt" }),
+        getSignedUrl: vi.fn().mockResolvedValue({ url: "http://example.com/file.txt" }),
+        getObject: vi.fn().mockResolvedValue(null),
+        deleteObject: vi.fn().mockResolvedValue(undefined),
+        listObjects: vi.fn().mockResolvedValue({ items: [],
+prefixes: [] }),
+        getType: vi.fn().mockReturnValue(type)
     };
 }
 
@@ -36,7 +38,7 @@ describe("StorageRegistry", () => {
 
             it("should register a storage controller", () => {
                 const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController('local');
+                const mockController = createMockStorageController("local");
 
                 registry.register("test-storage", mockController);
 
@@ -47,7 +49,7 @@ describe("StorageRegistry", () => {
 
             it("should get a registered storage controller", () => {
                 const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController('s3');
+                const mockController = createMockStorageController("s3");
 
                 registry.register("my-storage", mockController);
 
@@ -64,7 +66,7 @@ describe("StorageRegistry", () => {
         describe("default storage handling", () => {
             it("should get default storage with get(undefined)", () => {
                 const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController('local');
+                const mockController = createMockStorageController("local");
 
                 registry.register(DEFAULT_STORAGE_ID, mockController);
 
@@ -74,7 +76,7 @@ describe("StorageRegistry", () => {
 
             it("should get default storage with getDefault()", () => {
                 const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController('local');
+                const mockController = createMockStorageController("local");
 
                 registry.register(DEFAULT_STORAGE_ID, mockController);
 
@@ -85,7 +87,7 @@ describe("StorageRegistry", () => {
                 const registry = new DefaultStorageRegistry();
 
                 expect(() => registry.getDefault()).toThrow(
-                    `[StorageRegistry] No default storage registered.`
+                    "[StorageRegistry] No default storage registered."
                 );
             });
         });
@@ -97,8 +99,8 @@ describe("StorageRegistry", () => {
 
             beforeEach(() => {
                 registry = new DefaultStorageRegistry();
-                defaultController = createMockStorageController('local');
-                mediaController = createMockStorageController('s3');
+                defaultController = createMockStorageController("local");
+                mediaController = createMockStorageController("s3");
 
                 registry.register(DEFAULT_STORAGE_ID, defaultController);
                 registry.register("media", mediaController);
@@ -117,7 +119,7 @@ describe("StorageRegistry", () => {
             });
 
             it("should fallback to default when id not found", () => {
-                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+                const consoleSpy = vi.spyOn(console, "warn").mockImplementation();
 
                 expect(registry.getOrDefault("non-existent")).toBe(defaultController);
                 expect(consoleSpy).toHaveBeenCalledWith(
@@ -137,10 +139,10 @@ describe("StorageRegistry", () => {
         describe("overwriting storages", () => {
             it("should overwrite existing storage with same id", () => {
                 const registry = new DefaultStorageRegistry();
-                const original = createMockStorageController('local');
-                const replacement = createMockStorageController('s3');
+                const original = createMockStorageController("local");
+                const replacement = createMockStorageController("s3");
 
-                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+                const consoleSpy = vi.spyOn(console, "warn").mockImplementation();
 
                 registry.register("my-storage", original);
                 registry.register("my-storage", replacement);
@@ -158,9 +160,9 @@ describe("StorageRegistry", () => {
             it("should list all registered storages", () => {
                 const registry = new DefaultStorageRegistry();
 
-                registry.register("storage-1", createMockStorageController('local'));
-                registry.register("storage-2", createMockStorageController('s3'));
-                registry.register(DEFAULT_STORAGE_ID, createMockStorageController('local'));
+                registry.register("storage-1", createMockStorageController("local"));
+                registry.register("storage-2", createMockStorageController("s3"));
+                registry.register(DEFAULT_STORAGE_ID, createMockStorageController("local"));
 
                 const list = registry.list();
                 expect(list).toHaveLength(3);
@@ -174,10 +176,10 @@ describe("StorageRegistry", () => {
 
                 expect(registry.size()).toBe(0);
 
-                registry.register("storage-1", createMockStorageController('local'));
+                registry.register("storage-1", createMockStorageController("local"));
                 expect(registry.size()).toBe(1);
 
-                registry.register("storage-2", createMockStorageController('s3'));
+                registry.register("storage-2", createMockStorageController("s3"));
                 expect(registry.size()).toBe(2);
             });
         });
@@ -186,7 +188,7 @@ describe("StorageRegistry", () => {
     describe("DefaultStorageRegistry.create() factory", () => {
         describe("with single StorageController", () => {
             it('should register single controller as "(default)"', () => {
-                const mockController = createMockStorageController('local');
+                const mockController = createMockStorageController("local");
 
                 const registry = DefaultStorageRegistry.create(mockController);
 
@@ -198,8 +200,8 @@ describe("StorageRegistry", () => {
 
         describe("with map of StorageControllers", () => {
             it("should register all controllers from map", () => {
-                const defaultController = createMockStorageController('local');
-                const mediaController = createMockStorageController('s3');
+                const defaultController = createMockStorageController("local");
+                const mediaController = createMockStorageController("s3");
 
                 const registry = DefaultStorageRegistry.create({
                     [DEFAULT_STORAGE_ID]: defaultController,
@@ -212,10 +214,10 @@ describe("StorageRegistry", () => {
             });
 
             it("should use first entry as default if no explicit default provided", () => {
-                const local = createMockStorageController('local');
-                const s3 = createMockStorageController('s3');
+                const local = createMockStorageController("local");
+                const s3 = createMockStorageController("s3");
 
-                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+                const consoleSpy = vi.spyOn(console, "warn").mockImplementation();
 
                 const registry = DefaultStorageRegistry.create({
                     "primary": local,
@@ -243,7 +245,7 @@ describe("StorageRegistry", () => {
 
     describe("type detection (isStorageController)", () => {
         it("should correctly identify a StorageController", () => {
-            const mockController = createMockStorageController('local');
+            const mockController = createMockStorageController("local");
 
             // The factory should recognize it as a single controller
             const registry = DefaultStorageRegistry.create(mockController);
@@ -253,8 +255,8 @@ describe("StorageRegistry", () => {
 
         it("should correctly identify a map of StorageControllers", () => {
             const controllers = {
-                [DEFAULT_STORAGE_ID]: createMockStorageController('local'),
-                "other": createMockStorageController('s3')
+                [DEFAULT_STORAGE_ID]: createMockStorageController("local"),
+                "other": createMockStorageController("s3")
             };
 
             // The factory should recognize it as a map
@@ -265,16 +267,16 @@ describe("StorageRegistry", () => {
 
     describe("integration with storage types", () => {
         it("should correctly report storage types", () => {
-            const localController = createMockStorageController('local');
-            const s3Controller = createMockStorageController('s3');
+            const localController = createMockStorageController("local");
+            const s3Controller = createMockStorageController("s3");
 
             const registry = DefaultStorageRegistry.create({
                 [DEFAULT_STORAGE_ID]: localController,
                 "media": s3Controller
             });
 
-            expect(registry.getDefault().getType()).toBe('local');
-            expect(registry.get("media")?.getType()).toBe('s3');
+            expect(registry.getDefault().getType()).toBe("local");
+            expect(registry.get("media")?.getType()).toBe("s3");
         });
     });
 });

package/test/storage-routes.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
 /**
  * Tests for storage routes — specifically the sub-router wildcard extraction
  * that broke when Hono's c.req.param('*') stopped working in mounted sub-routers.
@@ -96,21 +97,23 @@ describe("Storage routes (sub-router integration)", () => {
         // Upload a test file so we have something to serve
         const content = Buffer.from("Hello test file");
         const file = new File([content], "test.txt", { type: "text/plain" });
-        await controller.uploadFile({ file, fileName: "test.txt", path: "photos" });
+        await controller.putObject({ file,
+key: "photos/test.txt" });
 
         // Create the Hono app with storage routes mounted as a SUB-ROUTER
         // (this is the exact pattern that caused the bug)
         app = new Hono<HonoEnv>();
-        app.onError(errorHandler);  // required to convert ApiError throws to proper HTTP responses
+        app.onError(errorHandler); // required to convert ApiError throws to proper HTTP responses
         const storageRoutes = createStorageRoutes({
             controller,
-            requireAuth: false  // skip auth for tests
+            requireAuth: false // skip auth for tests
         });
         app.route("/api/storage", storageRoutes);
     });
 
     afterEach(async () => {
-        await fs.promises.rm(tempDir, { recursive: true, force: true });
+        await fs.promises.rm(tempDir, { recursive: true,
+force: true });
     });
 
     describe("GET /metadata/*", () => {
@@ -192,7 +195,8 @@ describe("Storage routes (sub-router integration)", () => {
         it("should delete an existing file", async () => {
             // Upload another file to delete
             const file = new File([Buffer.from("delete me")], "deleteme.txt", { type: "text/plain" });
-            await controller.uploadFile({ file, fileName: "deleteme.txt", path: "photos" });
+            await controller.putObject({ file,
+key: "photos/deleteme.txt" });
 
             const res = await app.fetch(
                 new Request("http://localhost/api/storage/file/default/photos/deleteme.txt", { method: "DELETE" })