@dotdo/postgres 0.1.0

package/src/worker/routes.test.ts

@@ -0,0 +1,795 @@
+/**
+ * RED PHASE: PostgresDO Hono Routes Tests
+ * Task: postgres-6u6.4 - PostgresDO Hono Routes (/ping, /query, /batch, /transaction, /config, /schema)
+ *
+ * These tests verify the Hono-based HTTP API routes.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createRoutes, PostgresRoutes } from './routes'
+import type { QueryRequest, QueryResponse, BatchRequest, PostgresConfig } from './types'
+
+// Mock query result type
+interface MockQueryResult {
+  rows: Record<string, unknown>[]
+  fields: { name: string; dataTypeID: number }[]
+  rowCount: number
+  durationMs: number
+}
+
+// Mock PostgresDO-like context
+const createMockContext = () => {
+  const stats = {
+    queryCount: 0,
+    totalDurationMs: 0,
+    avgDurationMs: 0,
+    lastQueryAt: undefined as Date | undefined,
+  }
+
+  return {
+    executeQuery: vi.fn(async (_req: QueryRequest): Promise<MockQueryResult> => ({
+      rows: [{ id: 1 }],
+      fields: [{ name: 'id', dataTypeID: 23 }],
+      rowCount: 1,
+      durationMs: 1.5,
+    })),
+    executeBatch: vi.fn(async (req: BatchRequest) => ({
+      results: req.queries.map(() => ({
+        rows: [],
+        fields: [],
+        rowCount: 0,
+        durationMs: 0.5,
+      })),
+      durationMs: req.queries.length * 0.5,
+    })),
+    getConfig: vi.fn((): PostgresConfig => ({
+      database: 'postgres',
+      extensions: [],
+      preserveCase: false,
+    })),
+    getStats: vi.fn(() => stats),
+    isInitialized: vi.fn(() => true),
+    getUptime: vi.fn(() => 12345),
+    checkLiveness: vi.fn(async () => true),
+  }
+}
+
+describe('PostgresDO Hono Routes', () => {
+  describe('createRoutes', () => {
+    it('should create a Hono app', () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+      expect(app).toBeDefined()
+    })
+  })
+
+  describe('GET /ping', () => {
+    it('should return pong with 200 status', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/ping')
+      expect(res.status).toBe(200)
+      expect(await res.text()).toBe('pong')
+    })
+  })
+
+  describe('POST /query', () => {
+    it('should execute a query and return results', async () => {
+      const context = createMockContext()
+      context.executeQuery.mockResolvedValue({
+        rows: [{ id: 1, name: 'Alice' }],
+        fields: [
+          { name: 'id', dataTypeID: 23 },
+          { name: 'name', dataTypeID: 25 },
+        ],
+        rowCount: 1,
+        durationMs: 2.3,
+      })
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/query', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sql: 'SELECT * FROM users' }),
+      })
+
+      expect(res.status).toBe(200)
+      const data = await res.json() as QueryResponse
+      expect(data.rows).toEqual([{ id: 1, name: 'Alice' }])
+      expect(data.rowCount).toBe(1)
+      expect(data.durationMs).toBe(2.3)
+    })
+
+    it('should pass parameters to query', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      await app.request('/query', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sql: 'SELECT * FROM users WHERE id = $1',
+          params: [42],
+        }),
+      })
+
+      expect(context.executeQuery).toHaveBeenCalledWith({
+        sql: 'SELECT * FROM users WHERE id = $1',
+        params: [42],
+      })
+    })
+
+    it('should pass preserveCase option', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      await app.request('/query', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sql: 'SELECT userId FROM users',
+          preserveCase: true,
+        }),
+      })
+
+      expect(context.executeQuery).toHaveBeenCalledWith(
+        expect.objectContaining({ preserveCase: true })
+      )
+    })
+
+    it('should return 400 for missing sql', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/query', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      })
+
+      expect(res.status).toBe(400)
+      const data = await res.json() as { error: boolean; message: string }
+      expect(data.error).toBe(true)
+      expect(data.message).toContain('sql')
+    })
+
+    it('should return 500 for query errors', async () => {
+      const context = createMockContext()
+      context.executeQuery.mockRejectedValue(new Error('syntax error'))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/query', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sql: 'SELEC * FROM users' }),
+      })
+
+      expect(res.status).toBe(500)
+      const data = await res.json() as { error: boolean; message: string }
+      expect(data.error).toBe(true)
+      expect(data.message).toContain('syntax error')
+    })
+  })
+
+  describe('POST /batch', () => {
+    it('should execute multiple queries', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/batch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          queries: [
+            { sql: 'SELECT 1' },
+            { sql: 'SELECT 2' },
+          ],
+        }),
+      })
+
+      expect(res.status).toBe(200)
+      const data = await res.json() as { results: QueryResponse[] }
+      expect(data.results).toHaveLength(2)
+    })
+
+    it('should support transaction mode', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      await app.request('/batch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          queries: [{ sql: 'INSERT INTO users (name) VALUES ($1)', params: ['Alice'] }],
+          transaction: true,
+        }),
+      })
+
+      expect(context.executeBatch).toHaveBeenCalledWith(
+        expect.objectContaining({ transaction: true })
+      )
+    })
+
+    it('should return 400 for missing queries', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/batch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      })
+
+      expect(res.status).toBe(400)
+      const data = await res.json() as { error: boolean }
+      expect(data.error).toBe(true)
+    })
+
+    it('should return 400 for empty queries array', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/batch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ queries: [] }),
+      })
+
+      expect(res.status).toBe(400)
+    })
+  })
+
+  describe('GET /config', () => {
+    it('should return current configuration', async () => {
+      const context = createMockContext()
+      context.getConfig.mockReturnValue({
+        database: 'mydb',
+        extensions: ['vector'],
+        preserveCase: true,
+      })
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/config')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as PostgresConfig
+      expect(data.database).toBe('mydb')
+      expect(data.extensions).toContain('vector')
+      expect(data.preserveCase).toBe(true)
+    })
+  })
+
+  describe('GET /stats', () => {
+    it('should return query statistics', async () => {
+      const context = createMockContext()
+      context.getStats.mockReturnValue({
+        queryCount: 100,
+        totalDurationMs: 500,
+        avgDurationMs: 5,
+        lastQueryAt: new Date(),
+      })
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/stats')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { queryCount: number }
+      expect(data.queryCount).toBe(100)
+    })
+  })
+
+  describe('GET /health', () => {
+    it('should return health status when initialized', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/health')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { status: string; initialized: boolean }
+      expect(data.status).toBe('healthy')
+      expect(data.initialized).toBe(true)
+    })
+
+    it('should return degraded status when not initialized', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(false)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/health')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { status: string; initialized: boolean }
+      expect(data.status).toBe('initializing')
+      expect(data.initialized).toBe(false)
+    })
+
+    it('should return uptime in response', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      context.getUptime.mockReturnValue(60000)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/health')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { uptime: number }
+      expect(data.uptime).toBe(60000)
+    })
+
+    it('should return query count in response', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      context.getStats.mockReturnValue({
+        queryCount: 150,
+        totalDurationMs: 300,
+        avgDurationMs: 2,
+        lastQueryAt: new Date('2024-01-15T10:30:00Z'),
+      })
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/health')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { queryCount: number; lastQueryTime: string }
+      expect(data.queryCount).toBe(150)
+      expect(data.lastQueryTime).toBe('2024-01-15T10:30:00.000Z')
+    })
+
+    it('should return null lastQueryTime when no queries have been executed', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      context.getStats.mockReturnValue({
+        queryCount: 0,
+        totalDurationMs: 0,
+        avgDurationMs: 0,
+        lastQueryAt: undefined,
+      })
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/health')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { lastQueryTime: string | null }
+      expect(data.lastQueryTime).toBeNull()
+    })
+  })
+
+  describe('GET /liveness', () => {
+    it('should return healthy when PGLite is responsive', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      context.checkLiveness.mockResolvedValue(true)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/liveness')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { status: string; pglite: string }
+      expect(data.status).toBe('healthy')
+      expect(data.pglite).toBe('responsive')
+    })
+
+    it('should return 503 when not initialized', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(false)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/liveness')
+      expect(res.status).toBe(503)
+
+      const data = await res.json() as { status: string; reason: string }
+      expect(data.status).toBe('unhealthy')
+      expect(data.reason).toBe('PGLite not initialized')
+    })
+
+    it('should return 503 when PGLite is not responsive', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      context.checkLiveness.mockResolvedValue(false)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/liveness')
+      expect(res.status).toBe(503)
+
+      const data = await res.json() as { status: string; reason: string }
+      expect(data.status).toBe('unhealthy')
+      expect(data.reason).toBe('PGLite not responsive')
+    })
+
+    it('should return 503 when liveness check throws an error', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      context.checkLiveness.mockRejectedValue(new Error('Database connection lost'))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/liveness')
+      expect(res.status).toBe(503)
+
+      const data = await res.json() as { status: string; reason: string }
+      expect(data.status).toBe('unhealthy')
+      expect(data.reason).toBe('Database connection lost')
+    })
+  })
+
+  describe('GET /readiness', () => {
+    it('should return ready when initialized', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(true)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/readiness')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { status: string }
+      expect(data.status).toBe('ready')
+    })
+
+    it('should return 503 when not initialized', async () => {
+      const context = createMockContext()
+      context.isInitialized.mockReturnValue(false)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/readiness')
+      expect(res.status).toBe(503)
+
+      const data = await res.json() as { status: string; reason: string }
+      expect(data.status).toBe('not_ready')
+      expect(data.reason).toBe('PGLite initializing')
+    })
+  })
+
+  describe('POST /schema', () => {
+    it('should execute schema migration', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/schema', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sql: 'CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)',
+        }),
+      })
+
+      expect(res.status).toBe(200)
+      expect(context.executeQuery).toHaveBeenCalled()
+    })
+  })
+
+  // ==========================================================================
+  // Plugin Management Routes Tests
+  // ==========================================================================
+
+  describe('GET /plugins', () => {
+    it('should return list of all plugins', async () => {
+      const context = createMockContext()
+      context.listPlugins = vi.fn(async () => [
+        {
+          name: 'vector',
+          displayName: 'pgvector',
+          description: 'Vector similarity search',
+          category: 'search',
+          available: true,
+          enabled: true,
+          created: false,
+          extensionName: 'vector',
+        },
+        {
+          name: 'pg_trgm',
+          displayName: 'pg_trgm',
+          description: 'Trigram text similarity',
+          category: 'search',
+          available: true,
+          enabled: false,
+          created: false,
+          extensionName: 'pg_trgm',
+        },
+      ])
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { plugins: unknown[]; enabledCount: number; availableCount: number }
+      expect(data.plugins).toHaveLength(2)
+      expect(data.enabledCount).toBe(1)
+      expect(data.availableCount).toBe(2)
+    })
+
+    it('should handle errors in listPlugins', async () => {
+      const context = createMockContext()
+      context.listPlugins = vi.fn(async () => {
+        throw new Error('Database error')
+      })
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins')
+      expect(res.status).toBe(500)
+
+      const data = await res.json() as { error: boolean; message: string }
+      expect(data.error).toBe(true)
+      expect(data.message).toContain('Database error')
+    })
+  })
+
+  describe('GET /plugins/:name', () => {
+    it('should return status of a specific plugin', async () => {
+      const context = createMockContext()
+      context.getPluginStatus = vi.fn(async (name: string) => ({
+        name,
+        displayName: 'pgvector',
+        description: 'Vector similarity search',
+        category: 'search',
+        available: true,
+        enabled: true,
+        created: true,
+        extensionName: 'vector',
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector')
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { name: string; enabled: boolean; created: boolean }
+      expect(data.name).toBe('vector')
+      expect(data.enabled).toBe(true)
+      expect(data.created).toBe(true)
+    })
+
+    it('should return 404 for unknown plugin', async () => {
+      const context = createMockContext()
+      context.getPluginStatus = vi.fn(async () => null)
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/unknown')
+      expect(res.status).toBe(404)
+
+      const data = await res.json() as { error: boolean; message: string }
+      expect(data.error).toBe(true)
+      expect(data.message).toContain('not found')
+    })
+  })
+
+  describe('POST /plugins/:name/enable', () => {
+    it('should enable a plugin', async () => {
+      const context = createMockContext()
+      context.enablePlugin = vi.fn(async (name: string, autoCreate?: boolean) => ({
+        success: true,
+        name,
+        enabled: true,
+        created: autoCreate ?? false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector/enable', { method: 'POST' })
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { success: boolean; name: string; enabled: boolean }
+      expect(data.success).toBe(true)
+      expect(data.name).toBe('vector')
+      expect(data.enabled).toBe(true)
+    })
+
+    it('should enable a plugin with autoCreate', async () => {
+      const context = createMockContext()
+      context.enablePlugin = vi.fn(async (name: string, autoCreate?: boolean) => ({
+        success: true,
+        name,
+        enabled: true,
+        created: autoCreate ?? false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector/enable', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ autoCreate: true }),
+      })
+      expect(res.status).toBe(200)
+
+      expect(context.enablePlugin).toHaveBeenCalledWith('vector', true)
+    })
+
+    it('should return 400 for unavailable plugin', async () => {
+      const context = createMockContext()
+      context.enablePlugin = vi.fn(async (name: string) => ({
+        success: false,
+        name,
+        enabled: false,
+        error: 'Plugin not available',
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/postgis/enable', { method: 'POST' })
+      expect(res.status).toBe(400)
+
+      const data = await res.json() as { success: boolean; error: string }
+      expect(data.success).toBe(false)
+      expect(data.error).toBe('Plugin not available')
+    })
+  })
+
+  describe('POST /plugins/:name/disable', () => {
+    it('should disable a plugin', async () => {
+      const context = createMockContext()
+      context.disablePlugin = vi.fn(async (name: string) => ({
+        success: true,
+        name,
+        enabled: false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector/disable', { method: 'POST' })
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { success: boolean; name: string; enabled: boolean }
+      expect(data.success).toBe(true)
+      expect(data.name).toBe('vector')
+      expect(data.enabled).toBe(false)
+    })
+  })
+
+  describe('POST /plugins/:name/create', () => {
+    it('should create extension for a plugin', async () => {
+      const context = createMockContext()
+      context.createExtension = vi.fn(async (name: string) => ({
+        success: true,
+        name,
+        enabled: true,
+        created: true,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector/create', { method: 'POST' })
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { success: boolean; created: boolean }
+      expect(data.success).toBe(true)
+      expect(data.created).toBe(true)
+    })
+
+    it('should return 400 when extension creation fails', async () => {
+      const context = createMockContext()
+      context.createExtension = vi.fn(async (name: string) => ({
+        success: false,
+        name,
+        enabled: false,
+        error: 'Extension not available',
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/postgis/create', { method: 'POST' })
+      expect(res.status).toBe(400)
+
+      const data = await res.json() as { success: boolean; error: string }
+      expect(data.success).toBe(false)
+    })
+  })
+
+  describe('POST /plugins/:name/drop', () => {
+    it('should drop extension for a plugin', async () => {
+      const context = createMockContext()
+      context.dropExtension = vi.fn(async (name: string) => ({
+        success: true,
+        name,
+        enabled: false,
+        created: false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector/drop', { method: 'POST' })
+      expect(res.status).toBe(200)
+
+      const data = await res.json() as { success: boolean; created: boolean }
+      expect(data.success).toBe(true)
+      expect(data.created).toBe(false)
+    })
+
+    it('should drop extension with cascade option', async () => {
+      const context = createMockContext()
+      context.dropExtension = vi.fn(async (name: string, cascade?: boolean) => ({
+        success: true,
+        name,
+        enabled: false,
+        created: false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector/drop', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ cascade: true }),
+      })
+      expect(res.status).toBe(200)
+
+      expect(context.dropExtension).toHaveBeenCalledWith('vector', true)
+    })
+  })
+
+  describe('PUT /plugins/:name', () => {
+    it('should enable plugin via toggle endpoint', async () => {
+      const context = createMockContext()
+      context.enablePlugin = vi.fn(async (name: string, autoCreate?: boolean) => ({
+        success: true,
+        name,
+        enabled: true,
+        created: autoCreate ?? false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ enabled: true, autoCreate: true }),
+      })
+      expect(res.status).toBe(200)
+
+      expect(context.enablePlugin).toHaveBeenCalledWith('vector', true)
+    })
+
+    it('should disable plugin via toggle endpoint', async () => {
+      const context = createMockContext()
+      context.disablePlugin = vi.fn(async (name: string) => ({
+        success: true,
+        name,
+        enabled: false,
+        timestamp: new Date().toISOString(),
+      }))
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ enabled: false }),
+      })
+      expect(res.status).toBe(200)
+
+      expect(context.disablePlugin).toHaveBeenCalledWith('vector')
+    })
+
+    it('should return 400 when enabled field is missing', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/plugins/vector', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      })
+      expect(res.status).toBe(400)
+
+      const data = await res.json() as { error: boolean; message: string }
+      expect(data.error).toBe(true)
+      expect(data.message).toContain('enabled')
+    })
+  })
+
+  describe('Error handling', () => {
+    it('should return 404 for unknown routes', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/unknown')
+      expect(res.status).toBe(404)
+    })
+
+    it('should return 405 for wrong HTTP method', async () => {
+      const context = createMockContext()
+      const app = createRoutes(context as any)
+
+      const res = await app.request('/query', { method: 'GET' })
+      expect(res.status).toBe(405)
+    })
+  })
+})