Merge pull request #174 from johndoe6345789/codex/add-test-for-flaskbackendadapter.request

Handle empty/204 Flask backend responses and add Vitest for delete/clear

src/lib/unified-storage-adapters/__tests__/flask-backend-adapter.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import { FlaskBackendAdapter } from '../flask-backend-adapter'
+
+type MockResponse = {
+  ok: boolean
+  status: number
+  statusText: string
+  text: ReturnType<typeof vi.fn>
+}
+
+const createMockResponse = (status: number, body: string): MockResponse => ({
+  ok: status >= 200 && status < 300,
+  status,
+  statusText: status === 204 ? 'No Content' : 'OK',
+  text: vi.fn().mockResolvedValue(body),
+})
+
+describe('FlaskBackendAdapter.request', () => {
+  const baseUrl = 'http://example.test'
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    vi.resetAllMocks()
+  })
+
+  it('resolves delete/clear when response is 204 or empty body', async () => {
+    fetchMock
+      .mockResolvedValueOnce(createMockResponse(204, '') as unknown as Response)
+      .mockResolvedValueOnce(createMockResponse(200, '') as unknown as Response)
+
+    const adapter = new FlaskBackendAdapter(baseUrl)
+
+    await expect(adapter.delete('example-key')).resolves.toBeUndefined()
+    await expect(adapter.clear()).resolves.toBeUndefined()
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+})

src/lib/unified-storage-adapters/flask-backend-adapter.ts

@@ -25,11 +25,28 @@ export class FlaskBackendAdapter implements StorageAdapter {
       clearTimeout(timeoutId)
 
       if (!response.ok) {
-        const error = await response.json().catch(() => ({ error: response.statusText }))
-        throw new Error(error.error || `HTTP ${response.status}`)
+        let errorMessage = response.statusText
+        try {
+          const errorText = await response.text()
+          if (errorText) {
+            try {
+              const parsed = JSON.parse(errorText) as { error?: string }
+              errorMessage = parsed.error || errorText
+            } catch {
+              errorMessage = errorText
+            }
+          }
+        } catch {
+          // ignore error parsing failures
+        }
+        throw new Error(errorMessage || `HTTP ${response.status}`)
       }
 
-      return response.json()
+      const responseText = await response.text()
+      if (!responseText) {
+        return undefined as T
+      }
+      return JSON.parse(responseText) as T
     } catch (error: any) {
       clearTimeout(timeoutId)
       if (error.name === 'AbortError') {