@channel.io/app-sdk-server 0.2.0 → 0.3.0

package/dist/__tests__/token-manager.test.js

@@ -0,0 +1,624 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { TokenManager, TokenManagerError } from "../token/manager.js";
+import { InMemoryTokenCache } from "../token/cache.js";
+// ============================================
+// Helpers
+// ============================================
+function makeTokenResponse(overrides = {}) {
+    return {
+        accessToken: overrides.accessToken ?? "access-token-123",
+        refreshToken: overrides.refreshToken ?? "refresh-token-456",
+        expiresIn: overrides.expiresIn ?? 3600,
+        expiresAt: overrides.expiresAt ?? Date.now() + 3600 * 1000,
+        refreshTokenExpiresAt: overrides.refreshTokenExpiresAt ?? Date.now() + 604800 * 1000,
+        tokenType: overrides.tokenType ?? "Bearer",
+        scopes: overrides.scopes ?? [],
+    };
+}
+function makeApiResponse(token) {
+    return {
+        accessToken: token.accessToken,
+        refreshToken: token.refreshToken,
+        expiresIn: token.expiresIn,
+        expiresAt: token.expiresAt,
+        refreshTokenExpiresAt: token.refreshTokenExpiresAt,
+        tokenType: token.tokenType,
+        scopes: token.scopes,
+    };
+}
+function createMockFetch(responses) {
+    if (responses.length === 0) {
+        throw new Error("createMockFetch requires at least one response");
+    }
+    let callIndex = 0;
+    return vi.fn(async () => {
+        const resp = (responses[callIndex] ?? responses[responses.length - 1]);
+        callIndex++;
+        return {
+            ok: resp.ok,
+            status: resp.status,
+            statusText: resp.ok ? "OK" : "Error",
+            json: async () => resp.body,
+            text: async () => JSON.stringify(resp.body),
+        };
+    });
+}
+// ============================================
+// InMemoryTokenCache Tests
+// ============================================
+describe("InMemoryTokenCache", () => {
+    let cache;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        cache = new InMemoryTokenCache(60000);
+    });
+    afterEach(() => {
+        cache.destroy();
+        vi.useRealTimers();
+    });
+    it("should return null for missing key", async () => {
+        const result = await cache.get("nonexistent");
+        expect(result).toBeNull();
+    });
+    it("should store and retrieve a cached token", async () => {
+        const token = makeTokenResponse();
+        const cached = { token, cachedAt: Date.now(), key: "test-key" };
+        await cache.set("test-key", cached);
+        const result = await cache.get("test-key");
+        expect(result).not.toBeNull();
+        expect(result.token.accessToken).toBe("access-token-123");
+    });
+    it("should respect TTL and expire entries", async () => {
+        const token = makeTokenResponse();
+        const cached = { token, cachedAt: Date.now(), key: "ttl-key" };
+        await cache.set("ttl-key", cached, 5000); // 5 second TTL
+        expect(await cache.get("ttl-key")).not.toBeNull();
+        vi.advanceTimersByTime(6000); // Advance past TTL
+        expect(await cache.get("ttl-key")).toBeNull();
+    });
+    it("should delete a specific key", async () => {
+        const token = makeTokenResponse();
+        const cached = { token, cachedAt: Date.now(), key: "del-key" };
+        await cache.set("del-key", cached);
+        expect(await cache.get("del-key")).not.toBeNull();
+        await cache.delete("del-key");
+        expect(await cache.get("del-key")).toBeNull();
+    });
+    it("should clear all entries", async () => {
+        const token = makeTokenResponse();
+        await cache.set("key1", { token, cachedAt: Date.now(), key: "key1" });
+        await cache.set("key2", { token, cachedAt: Date.now(), key: "key2" });
+        expect(cache.getStats().size).toBe(2);
+        await cache.clear();
+        expect(cache.getStats().size).toBe(0);
+    });
+    it("should periodically cleanup expired entries", async () => {
+        const token = makeTokenResponse();
+        const cached = { token, cachedAt: Date.now(), key: "cleanup-key" };
+        await cache.set("cleanup-key", cached, 5000);
+        expect(cache.getStats().size).toBe(1);
+        vi.advanceTimersByTime(65000); // Past TTL + cleanup interval
+        expect(cache.getStats().size).toBe(0);
+    });
+    it("should report stats correctly", async () => {
+        const token = makeTokenResponse();
+        await cache.set("a", { token, cachedAt: Date.now(), key: "a" });
+        await cache.set("b", { token, cachedAt: Date.now(), key: "b" });
+        const stats = cache.getStats();
+        expect(stats.size).toBe(2);
+        expect(stats.keys).toContain("a");
+        expect(stats.keys).toContain("b");
+    });
+});
+// ============================================
+// TokenManager Tests
+// ============================================
+describe("TokenManager", () => {
+    let originalFetch;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        originalFetch = globalThis.fetch;
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.useRealTimers();
+    });
+    function createManager(overrides = {}) {
+        return new TokenManager({
+            appId: "test-app",
+            appSecret: "test-secret",
+            debug: true,
+            ...overrides,
+        });
+    }
+    // ----------------------------------------
+    // Token Issuance
+    // ----------------------------------------
+    describe("token issuance", () => {
+        it("should issue a channel token on cache miss", async () => {
+            const token = makeTokenResponse();
+            globalThis.fetch = createMockFetch([{ ok: true, status: 200, body: makeApiResponse(token) }]);
+            const manager = createManager();
+            const result = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(result.accessToken).toBe("access-token-123");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+            manager.destroy();
+        });
+        it("should issue a manager token", async () => {
+            const token = makeTokenResponse({ accessToken: "mgr-token" });
+            globalThis.fetch = createMockFetch([{ ok: true, status: 200, body: makeApiResponse(token) }]);
+            const manager = createManager();
+            const result = await manager.getManagerToken({ channelId: "ch-1", managerId: "mgr-1" });
+            expect(result.accessToken).toBe("mgr-token");
+            manager.destroy();
+        });
+        it("should issue a user token", async () => {
+            const token = makeTokenResponse({ accessToken: "user-token" });
+            globalThis.fetch = createMockFetch([{ ok: true, status: 200, body: makeApiResponse(token) }]);
+            const manager = createManager();
+            const result = await manager.getUserToken({ channelId: "ch-1", userId: "usr-1" });
+            expect(result.accessToken).toBe("user-token");
+            manager.destroy();
+        });
+        it("should issue an app token (no channelId)", async () => {
+            const token = makeTokenResponse({ accessToken: "app-token" });
+            globalThis.fetch = createMockFetch([{ ok: true, status: 200, body: makeApiResponse(token) }]);
+            const manager = createManager();
+            const result = await manager.getAppToken();
+            expect(result.accessToken).toBe("app-token");
+            // Verify the API was called with the correct URL (no channelId in path)
+            const fetchCall = globalThis.fetch.mock.calls[0];
+            const url = fetchCall[0];
+            expect(url).toBe("https://api.channel.io/app/v1/token");
+            manager.destroy();
+        });
+        it("should throw TokenManagerError on API failure", async () => {
+            globalThis.fetch = createMockFetch([
+                { ok: false, status: 401, body: { error: "Unauthorized" } },
+            ]);
+            const manager = createManager();
+            await expect(manager.getChannelToken({ channelId: "ch-1" })).rejects.toThrow(TokenManagerError);
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // Cache Hit
+    // ----------------------------------------
+    describe("cache hit", () => {
+        it("should return cached token on second call without API request", async () => {
+            const token = makeTokenResponse();
+            globalThis.fetch = createMockFetch([{ ok: true, status: 200, body: makeApiResponse(token) }]);
+            const manager = createManager();
+            // First call - cache miss
+            await manager.getChannelToken({ channelId: "ch-1" });
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+            // Second call - cache hit
+            const result = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(result.accessToken).toBe("access-token-123");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1); // No additional API call
+            manager.destroy();
+        });
+        it("should use separate cache entries for different channelIds", async () => {
+            const token1 = makeTokenResponse({ accessToken: "token-ch1" });
+            const token2 = makeTokenResponse({ accessToken: "token-ch2" });
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(token1) },
+                { ok: true, status: 200, body: makeApiResponse(token2) },
+            ]);
+            const manager = createManager();
+            const r1 = await manager.getChannelToken({ channelId: "ch-1" });
+            const r2 = await manager.getChannelToken({ channelId: "ch-2" });
+            expect(r1.accessToken).toBe("token-ch1");
+            expect(r2.accessToken).toBe("token-ch2");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            manager.destroy();
+        });
+        it("should cache app token separately from channel tokens", async () => {
+            const appToken = makeTokenResponse({ accessToken: "app-token" });
+            const channelToken = makeTokenResponse({ accessToken: "ch-token" });
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(appToken) },
+                { ok: true, status: 200, body: makeApiResponse(channelToken) },
+            ]);
+            const manager = createManager();
+            const r1 = await manager.getAppToken();
+            const r2 = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(r1.accessToken).toBe("app-token");
+            expect(r2.accessToken).toBe("ch-token");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            // Second call to getAppToken should be cached
+            const r3 = await manager.getAppToken();
+            expect(r3.accessToken).toBe("app-token");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            manager.destroy();
+        });
+        it("should use separate cache entries for different token types", async () => {
+            const channelToken = makeTokenResponse({ accessToken: "ch-token" });
+            const managerToken = makeTokenResponse({ accessToken: "mgr-token" });
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(channelToken) },
+                { ok: true, status: 200, body: makeApiResponse(managerToken) },
+            ]);
+            const manager = createManager();
+            const r1 = await manager.getChannelToken({ channelId: "ch-1" });
+            const r2 = await manager.getManagerToken({ channelId: "ch-1", managerId: "mgr-1" });
+            expect(r1.accessToken).toBe("ch-token");
+            expect(r2.accessToken).toBe("mgr-token");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // TTL Expiry & Auto-Refresh
+    // ----------------------------------------
+    describe("TTL expiry and auto-refresh", () => {
+        it("should auto-refresh token within refresh buffer period", async () => {
+            const now = Date.now();
+            // Token that expires in 4 minutes (within 5-minute buffer)
+            const expiringToken = makeTokenResponse({
+                accessToken: "old-token",
+                expiresAt: now + 4 * 60 * 1000,
+            });
+            const refreshedToken = makeTokenResponse({
+                accessToken: "refreshed-token",
+                expiresAt: now + 3600 * 1000,
+            });
+            let callCount = 0;
+            globalThis.fetch = vi.fn(async (url) => {
+                callCount++;
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (callCount === 1) {
+                    // Initial issue
+                    return {
+                        ok: true,
+                        status: 200,
+                        statusText: "OK",
+                        json: async () => makeApiResponse(expiringToken),
+                        text: async () => JSON.stringify(makeApiResponse(expiringToken)),
+                    };
+                }
+                if (urlStr.includes("/token/refresh")) {
+                    // Refresh call
+                    return {
+                        ok: true,
+                        status: 200,
+                        statusText: "OK",
+                        json: async () => makeApiResponse(refreshedToken),
+                        text: async () => JSON.stringify(makeApiResponse(refreshedToken)),
+                    };
+                }
+                // Fallback re-issue
+                return {
+                    ok: true,
+                    status: 200,
+                    statusText: "OK",
+                    json: async () => makeApiResponse(refreshedToken),
+                    text: async () => JSON.stringify(makeApiResponse(refreshedToken)),
+                };
+            });
+            const manager = createManager({ refreshBufferMs: 5 * 60 * 1000 });
+            // First call issues token
+            const first = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(first.accessToken).toBe("old-token");
+            // Second call should trigger refresh because token expires within buffer
+            const second = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(second.accessToken).toBe("refreshed-token");
+            manager.destroy();
+        });
+        it("should re-issue token when refresh fails", async () => {
+            const now = Date.now();
+            // Token that expires within buffer
+            const expiringToken = makeTokenResponse({
+                accessToken: "old-token",
+                expiresAt: now + 2 * 60 * 1000,
+            });
+            const newToken = makeTokenResponse({
+                accessToken: "new-token",
+                expiresAt: now + 3600 * 1000,
+            });
+            let callCount = 0;
+            globalThis.fetch = vi.fn(async (url) => {
+                callCount++;
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (callCount === 1) {
+                    // Initial issue
+                    return {
+                        ok: true,
+                        status: 200,
+                        statusText: "OK",
+                        json: async () => makeApiResponse(expiringToken),
+                        text: async () => JSON.stringify(makeApiResponse(expiringToken)),
+                    };
+                }
+                if (urlStr.includes("/token/refresh")) {
+                    // Refresh fails
+                    return {
+                        ok: false,
+                        status: 401,
+                        statusText: "Unauthorized",
+                        json: async () => ({}),
+                        text: async () => "Unauthorized",
+                    };
+                }
+                // Re-issue succeeds
+                return {
+                    ok: true,
+                    status: 200,
+                    statusText: "OK",
+                    json: async () => makeApiResponse(newToken),
+                    text: async () => JSON.stringify(makeApiResponse(newToken)),
+                };
+            });
+            const manager = createManager({ refreshBufferMs: 5 * 60 * 1000 });
+            await manager.getChannelToken({ channelId: "ch-1" });
+            const result = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(result.accessToken).toBe("new-token");
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // Thundering Herd Prevention
+    // ----------------------------------------
+    describe("thundering herd prevention", () => {
+        it("should deduplicate concurrent requests for the same token", async () => {
+            let resolvePromise;
+            const pendingPromise = new Promise((resolve) => {
+                resolvePromise = resolve;
+            });
+            const token = makeTokenResponse({ accessToken: "deduped-token" });
+            let callCount = 0;
+            globalThis.fetch = vi.fn(() => {
+                callCount++;
+                if (callCount === 1) {
+                    return pendingPromise;
+                }
+                // Should never reach here for the same key
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    statusText: "OK",
+                    json: async () => makeApiResponse(makeTokenResponse({ accessToken: "second-token" })),
+                    text: async () => "",
+                });
+            });
+            const manager = createManager();
+            // Fire 3 concurrent requests for the same channel
+            const p1 = manager.getChannelToken({ channelId: "ch-1" });
+            const p2 = manager.getChannelToken({ channelId: "ch-1" });
+            const p3 = manager.getChannelToken({ channelId: "ch-1" });
+            // Resolve the single pending fetch
+            resolvePromise({
+                ok: true,
+                status: 200,
+                statusText: "OK",
+                json: async () => makeApiResponse(token),
+                text: async () => JSON.stringify(makeApiResponse(token)),
+            });
+            const [r1, r2, r3] = await Promise.all([p1, p2, p3]);
+            // All should return the same token
+            expect(r1.accessToken).toBe("deduped-token");
+            expect(r2.accessToken).toBe("deduped-token");
+            expect(r3.accessToken).toBe("deduped-token");
+            // Only one fetch call should have been made
+            expect(callCount).toBe(1);
+            manager.destroy();
+        });
+        it("should not deduplicate requests for different keys", async () => {
+            const token1 = makeTokenResponse({ accessToken: "token-1" });
+            const token2 = makeTokenResponse({ accessToken: "token-2" });
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(token1) },
+                { ok: true, status: 200, body: makeApiResponse(token2) },
+            ]);
+            const manager = createManager();
+            const [r1, r2] = await Promise.all([
+                manager.getChannelToken({ channelId: "ch-1" }),
+                manager.getChannelToken({ channelId: "ch-2" }),
+            ]);
+            expect(r1.accessToken).toBe("token-1");
+            expect(r2.accessToken).toBe("token-2");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            manager.destroy();
+        });
+        it("should allow new requests after in-flight promise resolves", async () => {
+            const token1 = makeTokenResponse({ accessToken: "first" });
+            const token2 = makeTokenResponse({ accessToken: "second" });
+            let callCount = 0;
+            globalThis.fetch = vi.fn(async () => {
+                callCount++;
+                const token = callCount === 1 ? token1 : token2;
+                return {
+                    ok: true,
+                    status: 200,
+                    statusText: "OK",
+                    json: async () => makeApiResponse(token),
+                    text: async () => JSON.stringify(makeApiResponse(token)),
+                };
+            });
+            const manager = createManager();
+            // First request
+            const r1 = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(r1.accessToken).toBe("first");
+            // Invalidate cache to force new request
+            await manager.invalidateToken("channel", "ch-1");
+            // Second request should make a new API call
+            const r2 = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(r2.accessToken).toBe("second");
+            expect(callCount).toBe(2);
+            manager.destroy();
+        });
+        it("should clean up in-flight promise on error", async () => {
+            let callCount = 0;
+            const token = makeTokenResponse();
+            globalThis.fetch = vi.fn(async () => {
+                callCount++;
+                if (callCount === 1) {
+                    return {
+                        ok: false,
+                        status: 500,
+                        statusText: "Internal Server Error",
+                        json: async () => ({}),
+                        text: async () => "Server Error",
+                    };
+                }
+                return {
+                    ok: true,
+                    status: 200,
+                    statusText: "OK",
+                    json: async () => makeApiResponse(token),
+                    text: async () => JSON.stringify(makeApiResponse(token)),
+                };
+            });
+            const manager = createManager();
+            // First request fails
+            await expect(manager.getChannelToken({ channelId: "ch-1" })).rejects.toThrow(TokenManagerError);
+            // Second request should work (in-flight was cleaned up)
+            const result = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(result.accessToken).toBe("access-token-123");
+            expect(callCount).toBe(2);
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // Cache Invalidation
+    // ----------------------------------------
+    describe("cache invalidation", () => {
+        it("should invalidate a specific token", async () => {
+            const token = makeTokenResponse();
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(token) },
+                { ok: true, status: 200, body: makeApiResponse(token) },
+            ]);
+            const manager = createManager();
+            await manager.getChannelToken({ channelId: "ch-1" });
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+            await manager.invalidateToken("channel", "ch-1");
+            // Should issue new token after invalidation
+            await manager.getChannelToken({ channelId: "ch-1" });
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            manager.destroy();
+        });
+        it("should invalidate an app token", async () => {
+            const token1 = makeTokenResponse({ accessToken: "app-token-1" });
+            const token2 = makeTokenResponse({ accessToken: "app-token-2" });
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(token1) },
+                { ok: true, status: 200, body: makeApiResponse(token2) },
+            ]);
+            const manager = createManager();
+            const r1 = await manager.getAppToken();
+            expect(r1.accessToken).toBe("app-token-1");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+            await manager.invalidateToken("app");
+            // Should issue new token after invalidation
+            const r2 = await manager.getAppToken();
+            expect(r2.accessToken).toBe("app-token-2");
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            manager.destroy();
+        });
+        it("should clear all cached tokens", async () => {
+            const token = makeTokenResponse();
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(token) },
+                { ok: true, status: 200, body: makeApiResponse(token) },
+                { ok: true, status: 200, body: makeApiResponse(token) },
+                { ok: true, status: 200, body: makeApiResponse(token) },
+            ]);
+            const manager = createManager();
+            await manager.getChannelToken({ channelId: "ch-1" });
+            await manager.getChannelToken({ channelId: "ch-2" });
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+            await manager.clearCache();
+            // Both should require new API calls
+            await manager.getChannelToken({ channelId: "ch-1" });
+            await manager.getChannelToken({ channelId: "ch-2" });
+            expect(globalThis.fetch).toHaveBeenCalledTimes(4);
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // Manual Refresh
+    // ----------------------------------------
+    describe("manual refresh", () => {
+        it("should refresh a token manually", async () => {
+            const refreshed = makeTokenResponse({ accessToken: "manually-refreshed" });
+            globalThis.fetch = createMockFetch([
+                { ok: true, status: 200, body: makeApiResponse(refreshed) },
+            ]);
+            const manager = createManager();
+            const result = await manager.refreshToken("old-refresh-token");
+            expect(result.accessToken).toBe("manually-refreshed");
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // API Response Normalization
+    // ----------------------------------------
+    describe("API response normalization", () => {
+        it("should handle snake_case API responses", async () => {
+            globalThis.fetch = createMockFetch([
+                {
+                    ok: true,
+                    status: 200,
+                    body: {
+                        access_token: "snake-access",
+                        refresh_token: "snake-refresh",
+                        expires_in: 7200,
+                        token_type: "Bearer",
+                        scope: "read write",
+                    },
+                },
+            ]);
+            const manager = createManager();
+            const result = await manager.getChannelToken({ channelId: "ch-1" });
+            expect(result.accessToken).toBe("snake-access");
+            expect(result.refreshToken).toBe("snake-refresh");
+            expect(result.expiresIn).toBe(7200);
+            expect(result.tokenType).toBe("Bearer");
+            expect(result.scopes).toEqual(["read", "write"]);
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // Custom Cache Storage
+    // ----------------------------------------
+    describe("custom cache storage", () => {
+        it("should use custom cache storage when provided", async () => {
+            const storage = {
+                get: vi.fn().mockResolvedValue(null),
+                set: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+                clear: vi.fn().mockResolvedValue(undefined),
+            };
+            const token = makeTokenResponse();
+            globalThis.fetch = createMockFetch([{ ok: true, status: 200, body: makeApiResponse(token) }]);
+            const manager = createManager({ cacheStorage: storage });
+            await manager.getChannelToken({ channelId: "ch-1" });
+            expect(storage.get).toHaveBeenCalled();
+            expect(storage.set).toHaveBeenCalled();
+            manager.destroy();
+        });
+    });
+    // ----------------------------------------
+    // Destroy
+    // ----------------------------------------
+    describe("destroy", () => {
+        it("should cleanup resources on destroy", () => {
+            const manager = createManager();
+            // Should not throw
+            expect(() => manager.destroy()).not.toThrow();
+        });
+        it("should not throw when destroy is called with custom cache", () => {
+            const storage = {
+                get: vi.fn().mockResolvedValue(null),
+                set: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+                clear: vi.fn().mockResolvedValue(undefined),
+            };
+            const manager = createManager({ cacheStorage: storage });
+            // Should not throw even with custom storage (no destroy method)
+            expect(() => manager.destroy()).not.toThrow();
+        });
+    });
+});
+//# sourceMappingURL=token-manager.test.js.map