@dotdo/postgres 0.1.0

package/src/iceberg/catalog-api.test.ts

@@ -0,0 +1,838 @@
+/**
+ * Iceberg Catalog REST API Tests
+ * Task: postgres-8gdz.1 - [RED] Audit source files vs test files for iceberg
+ *
+ * Tests for the Iceberg REST Catalog API specification implementation.
+ * Compatible with Apache Spark, Trino/Presto, DuckDB, PyIceberg, etc.
+ *
+ * @see catalog-api.ts
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { createCatalogApi, catalogApiMiddleware, type CatalogApiConfig } from './catalog-api'
+import { IcebergCatalog, createIcebergCatalog } from './catalog'
+import { IcebergMetadataBuilder } from './metadata'
+import type { IcebergSchema, IcebergPartitionSpec } from './types'
+
+/**
+ * Create a mock R2Bucket for testing
+ */
+function createMockBucket(): R2Bucket {
+  const storage = new Map<string, { data: string | ArrayBuffer; metadata?: Record<string, string> }>()
+
+  return {
+    put: vi.fn(async (key: string, data: string | ArrayBuffer | ReadableStream, options?: R2PutOptions) => {
+      storage.set(key, {
+        data: data as string | ArrayBuffer,
+        metadata: options?.customMetadata,
+      })
+      return {
+        key,
+        version: 'test-version',
+        size: typeof data === 'string' ? data.length : (data as ArrayBuffer).byteLength,
+        etag: 'test-etag',
+        httpEtag: '"test-etag"',
+        uploaded: new Date(),
+        httpMetadata: options?.httpMetadata || {},
+        customMetadata: options?.customMetadata || {},
+      } as R2Object
+    }),
+    get: vi.fn(async (key: string) => {
+      const item = storage.get(key)
+      if (!item) return null
+
+      return {
+        key,
+        version: 'test-version',
+        size: typeof item.data === 'string' ? item.data.length : (item.data as ArrayBuffer).byteLength,
+        etag: 'test-etag',
+        httpEtag: '"test-etag"',
+        uploaded: new Date(),
+        httpMetadata: {},
+        customMetadata: item.metadata || {},
+        text: async () => (typeof item.data === 'string' ? item.data : new TextDecoder().decode(item.data as ArrayBuffer)),
+        json: async () => JSON.parse(typeof item.data === 'string' ? item.data : new TextDecoder().decode(item.data as ArrayBuffer)),
+        arrayBuffer: async () => (typeof item.data === 'string' ? new TextEncoder().encode(item.data).buffer : item.data),
+        bytes: async () => (typeof item.data === 'string' ? new TextEncoder().encode(item.data) : new Uint8Array(item.data as ArrayBuffer)),
+        blob: async () => new Blob([item.data]),
+        body: null,
+        bodyUsed: false,
+        writeHttpMetadata: () => {},
+      } as R2ObjectBody
+    }),
+    head: vi.fn(async (key: string) => {
+      const item = storage.get(key)
+      if (!item) return null
+
+      return {
+        key,
+        version: 'test-version',
+        size: typeof item.data === 'string' ? item.data.length : (item.data as ArrayBuffer).byteLength,
+        etag: 'test-etag',
+        httpEtag: '"test-etag"',
+        uploaded: new Date(),
+        httpMetadata: {},
+        customMetadata: item.metadata || {},
+      } as R2Object
+    }),
+    delete: vi.fn(async (keys: string | string[]) => {
+      const keyList = Array.isArray(keys) ? keys : [keys]
+      for (const key of keyList) {
+        storage.delete(key)
+      }
+    }),
+    list: vi.fn(async (options?: R2ListOptions) => {
+      const prefix = options?.prefix || ''
+      const objects: R2Object[] = []
+
+      for (const [key, item] of storage) {
+        if (key.startsWith(prefix)) {
+          objects.push({
+            key,
+            version: 'test-version',
+            size: typeof item.data === 'string' ? item.data.length : (item.data as ArrayBuffer).byteLength,
+            etag: 'test-etag',
+            httpEtag: '"test-etag"',
+            uploaded: new Date(),
+            httpMetadata: {},
+            customMetadata: item.metadata || {},
+          } as R2Object)
+        }
+      }
+
+      return {
+        objects,
+        truncated: false,
+        cursor: undefined,
+        delimitedPrefixes: [],
+      } as R2Objects
+    }),
+    createMultipartUpload: vi.fn(),
+    resumeMultipartUpload: vi.fn(),
+  } as unknown as R2Bucket
+}
+
+/**
+ * Create a test schema
+ */
+function createTestSchema(): IcebergSchema {
+  return {
+    type: 'struct',
+    'schema-id': 0,
+    fields: [
+      { id: 1, name: 'id', required: true, type: 'long' },
+      { id: 2, name: 'data', required: false, type: 'string' },
+      { id: 3, name: 'ts', required: true, type: 'timestamptz' },
+    ],
+  }
+}
+
+/**
+ * Create a test partition spec
+ */
+function createTestPartitionSpec(): IcebergPartitionSpec {
+  return {
+    'spec-id': 0,
+    fields: [{ 'source-id': 3, 'field-id': 1000, name: 'ts_day', transform: 'day' }],
+  }
+}
+
+/**
+ * Helper to make requests to the API
+ */
+async function makeRequest(
+  app: ReturnType<typeof createCatalogApi>,
+  method: string,
+  path: string,
+  body?: unknown
+): Promise<Response> {
+  const request = new Request(`http://localhost${path}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  return app.fetch(request)
+}
+
+describe('Catalog REST API', () => {
+  let mockBucket: R2Bucket
+  let catalog: IcebergCatalog
+  let config: CatalogApiConfig
+
+  beforeEach(async () => {
+    mockBucket = createMockBucket()
+    catalog = createIcebergCatalog({
+      bucket: mockBucket,
+      basePath: 'iceberg-test',
+    })
+    await catalog.initialize()
+    config = { catalog }
+  })
+
+  describe('createCatalogApi', () => {
+    it('should create a Hono app with catalog routes', () => {
+      const app = createCatalogApi(config)
+      expect(app).toBeDefined()
+      expect(app.fetch).toBeDefined()
+    })
+
+    it('should support custom API prefix', async () => {
+      const customConfig = { ...config, prefix: '/v1/iceberg' }
+      const app = createCatalogApi(customConfig)
+
+      const response = await makeRequest(app, 'GET', '/v1/iceberg/config')
+      expect(response.status).toBe(200)
+    })
+
+    it('should enable CORS by default', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/config')
+      expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*')
+      expect(response.headers.get('Access-Control-Allow-Methods')).toContain('GET')
+    })
+
+    it('should support custom authentication handler', async () => {
+      const authHandler = vi.fn().mockResolvedValue(false)
+      const authConfig = { ...config, authenticate: authHandler }
+      const app = createCatalogApi(authConfig)
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/config')
+      expect(response.status).toBe(401)
+      expect(authHandler).toHaveBeenCalled()
+    })
+  })
+
+  describe('Config Endpoint', () => {
+    it('GET /config should return catalog configuration', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/config')
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('defaults')
+      expect(data).toHaveProperty('overrides')
+    })
+  })
+
+  describe('Namespace Endpoints', () => {
+    it('GET /namespaces should list all namespaces', async () => {
+      const app = createCatalogApi(config)
+
+      // Create a namespace first
+      await catalog.createNamespace({ levels: ['db1'] })
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces')
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('namespaces')
+      expect(data.namespaces).toContainEqual(['db1'])
+    })
+
+    it('GET /namespaces should filter by parent namespace', async () => {
+      const app = createCatalogApi(config)
+
+      // Create hierarchical namespaces
+      await catalog.createNamespace({ levels: ['tenant1'] })
+      await catalog.createNamespace({ levels: ['tenant1', 'app1'] })
+      await catalog.createNamespace({ levels: ['tenant2'] })
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces?parent=tenant1')
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.namespaces).toContainEqual(['tenant1', 'app1'])
+      expect(data.namespaces).not.toContainEqual(['tenant2'])
+    })
+
+    it('POST /namespaces should create a namespace', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces', {
+        namespace: ['mydb'],
+        properties: { owner: 'testuser' },
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.namespace).toEqual(['mydb'])
+      expect(data.properties).toEqual({ owner: 'testuser' })
+    })
+
+    it('POST /namespaces should return 400 for invalid namespace', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces', {
+        namespace: [],
+      })
+      expect(response.status).toBe(400)
+
+      const data = await response.json()
+      expect(data.error.type).toBe('BadRequestException')
+    })
+
+    it('GET /namespaces/:namespace should return namespace metadata', async () => {
+      const app = createCatalogApi(config)
+
+      await catalog.createNamespace({ levels: ['testns'] }, { description: 'Test namespace' })
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces/testns')
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.namespace).toEqual(['testns'])
+      expect(data.properties.description).toBe('Test namespace')
+    })
+
+    it('HEAD /namespaces/:namespace should return 200 or 204 if namespace exists', async () => {
+      const app = createCatalogApi(config)
+
+      await catalog.createNamespace({ levels: ['existingns'] })
+
+      const request = new Request('http://localhost/api/catalog/v1/namespaces/existingns', {
+        method: 'HEAD',
+      })
+      const response = await app.fetch(request)
+      // HEAD returns 200 (falling back to GET handler) or 204 (dedicated HEAD handler)
+      expect([200, 204]).toContain(response.status)
+    })
+
+    it('HEAD /namespaces/:namespace should return 404 if namespace does not exist', async () => {
+      const app = createCatalogApi(config)
+
+      const request = new Request('http://localhost/api/catalog/v1/namespaces/nonexistent', {
+        method: 'HEAD',
+      })
+      const response = await app.fetch(request)
+      expect(response.status).toBe(404)
+    })
+
+    it('POST /namespaces/:namespace/properties should update namespace properties', async () => {
+      const app = createCatalogApi(config)
+
+      await catalog.createNamespace({ levels: ['propns'] }, { key1: 'value1', key2: 'value2' })
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/propns/properties', {
+        updates: { key1: 'updated', key3: 'new' },
+        removals: ['key2'],
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.updated).toContain('key1')
+      expect(data.updated).toContain('key3')
+      expect(data.removed).toContain('key2')
+    })
+
+    it('DELETE /namespaces/:namespace should drop a namespace', async () => {
+      const app = createCatalogApi(config)
+
+      await catalog.createNamespace({ levels: ['dropme'] })
+
+      const response = await makeRequest(app, 'DELETE', '/api/catalog/v1/namespaces/dropme')
+      expect(response.status).toBe(204)
+
+      // Verify namespace is gone
+      const exists = await catalog.namespaceExists({ levels: ['dropme'] })
+      expect(exists).toBe(false)
+    })
+
+    it('should parse multipart namespace identifiers (URL encoded)', async () => {
+      const app = createCatalogApi(config)
+
+      // Create a multi-level namespace
+      await catalog.createNamespace({ levels: ['tenant', 'app'] })
+
+      // URL encode the namespace with unit separator (0x1F)
+      const encodedNs = encodeURIComponent('tenant\x1Fapp')
+      const response = await makeRequest(app, 'GET', `/api/catalog/v1/namespaces/${encodedNs}`)
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.namespace).toEqual(['tenant', 'app'])
+    })
+  })
+
+  describe('Table Endpoints', () => {
+    beforeEach(async () => {
+      // Create a namespace for table tests
+      await catalog.createNamespace({ levels: ['db'] })
+    })
+
+    it('GET /namespaces/:namespace/tables should list tables', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces/db/tables')
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('identifiers')
+      expect(Array.isArray(data.identifiers)).toBe(true)
+    })
+
+    it('POST /namespaces/:namespace/tables should create a table', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables', {
+        name: 'events',
+        schema: createTestSchema(),
+        'partition-spec': createTestPartitionSpec(),
+        properties: { 'write.format.default': 'parquet' },
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('metadata-location')
+      expect(data).toHaveProperty('metadata')
+      expect(data.metadata['format-version']).toBe(2)
+    })
+
+    it('POST /namespaces/:namespace/tables should return 400 if name is missing', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables', {
+        schema: createTestSchema(),
+      })
+      expect(response.status).toBe(400)
+
+      const data = await response.json()
+      expect(data.error.message).toContain('name')
+    })
+
+    it('POST /namespaces/:namespace/tables should return 400 if schema is missing', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables', {
+        name: 'mytable',
+      })
+      expect(response.status).toBe(400)
+
+      const data = await response.json()
+      expect(data.error.message).toContain('Schema')
+    })
+
+    it('GET /namespaces/:namespace/tables/:table should load a table', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first using catalog directly for setup
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'users' }, builder.build())
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces/db/tables/users')
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('metadata-location')
+      expect(data).toHaveProperty('metadata')
+    })
+
+    it('GET /namespaces/:namespace/tables/:table should return 404 if table not found', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces/db/tables/notfound')
+      expect(response.status).toBe(404)
+
+      const data = await response.json()
+      expect(data.error.type).toBe('NoSuchTableException')
+    })
+
+    it('HEAD /namespaces/:namespace/tables/:table should return 200 or 204 if table exists', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'existingtable' }, builder.build())
+
+      const request = new Request('http://localhost/api/catalog/v1/namespaces/db/tables/existingtable', {
+        method: 'HEAD',
+      })
+      const response = await app.fetch(request)
+      // HEAD returns 200 (falling back to GET handler) or 204 (dedicated HEAD handler)
+      expect([200, 204]).toContain(response.status)
+    })
+
+    it('HEAD /namespaces/:namespace/tables/:table should return 404 if table does not exist', async () => {
+      const app = createCatalogApi(config)
+
+      const request = new Request('http://localhost/api/catalog/v1/namespaces/db/tables/missing', {
+        method: 'HEAD',
+      })
+      const response = await app.fetch(request)
+      expect(response.status).toBe(404)
+    })
+
+    it('POST /namespaces/:namespace/tables/:table should commit table updates', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'commitable' }, builder.build())
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables/commitable', {
+        requirements: [],
+        updates: [{ action: 'set-properties', updates: { 'commit.retry.num-retries': '5' } }],
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('metadata')
+      expect(data.metadata.properties['commit.retry.num-retries']).toBe('5')
+    })
+
+    it('POST /namespaces/:namespace/tables/:table should handle add-snapshot update', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'snapshottable' }, builder.build())
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables/snapshottable', {
+        requirements: [],
+        updates: [
+          {
+            action: 'add-snapshot',
+            snapshot: {
+              'snapshot-id': 12345678901234,
+              'sequence-number': 1,
+              'timestamp-ms': Date.now(),
+              'manifest-list': 'manifests/snap-12345678901234.avro',
+              summary: { operation: 'append' },
+            },
+          },
+        ],
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.metadata.snapshots).toHaveLength(1)
+    })
+
+    it('POST /namespaces/:namespace/tables/:table should handle set-properties update', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'proptable' }, builder.build())
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables/proptable', {
+        requirements: [],
+        updates: [{ action: 'set-properties', updates: { 'write.format.default': 'orc', description: 'test' } }],
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.metadata.properties['write.format.default']).toBe('orc')
+      expect(data.metadata.properties['description']).toBe('test')
+    })
+
+    it('POST /namespaces/:namespace/tables/:table should handle add-schema update', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'schematable' }, builder.build())
+
+      const newSchema: IcebergSchema = {
+        type: 'struct',
+        'schema-id': 1,
+        fields: [
+          { id: 1, name: 'id', required: true, type: 'long' },
+          { id: 2, name: 'data', required: false, type: 'string' },
+          { id: 3, name: 'ts', required: true, type: 'timestamptz' },
+          { id: 4, name: 'new_field', required: false, type: 'string' },
+        ],
+      }
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables/schematable', {
+        requirements: [],
+        updates: [{ action: 'add-schema', schema: newSchema }],
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.metadata.schemas).toHaveLength(2)
+      expect(data.metadata['current-schema-id']).toBe(1)
+    })
+
+    it('POST /namespaces/:namespace/tables/:table should handle add-partition-spec update', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'partitiontable' }, builder.build())
+
+      const newSpec: IcebergPartitionSpec = {
+        'spec-id': 1,
+        fields: [{ 'source-id': 3, 'field-id': 1001, name: 'ts_month', transform: 'month' }],
+      }
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/db/tables/partitiontable', {
+        requirements: [],
+        updates: [{ action: 'add-partition-spec', spec: newSpec }],
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.metadata['partition-specs']).toHaveLength(2)
+      expect(data.metadata['default-spec-id']).toBe(1)
+    })
+
+    it('DELETE /namespaces/:namespace/tables/:table should drop a table', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'droptable' }, builder.build())
+
+      const response = await makeRequest(app, 'DELETE', '/api/catalog/v1/namespaces/db/tables/droptable')
+      expect(response.status).toBe(204)
+
+      // Verify table is gone
+      const exists = await catalog.tableExists({ namespace: { levels: ['db'] }, name: 'droptable' })
+      expect(exists).toBe(false)
+    })
+
+    it('DELETE /namespaces/:namespace/tables/:table should support purge option', async () => {
+      const app = createCatalogApi(config)
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'purgetable' }, builder.build())
+
+      const response = await makeRequest(app, 'DELETE', '/api/catalog/v1/namespaces/db/tables/purgetable?purgeRequested=true')
+      expect(response.status).toBe(204)
+
+      // Verify table is gone
+      const exists = await catalog.tableExists({ namespace: { levels: ['db'] }, name: 'purgetable' })
+      expect(exists).toBe(false)
+    })
+
+    it('POST /tables/rename should rename a table', async () => {
+      const app = createCatalogApi(config)
+
+      // Create both namespaces
+      await catalog.createNamespace({ levels: ['db2'] })
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['db'] }, name: 'oldname' }, builder.build())
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/tables/rename', {
+        source: { namespace: ['db'], name: 'oldname' },
+        destination: { namespace: ['db2'], name: 'newname' },
+      })
+      expect(response.status).toBe(204)
+
+      // Verify old table is gone and new one exists
+      const oldExists = await catalog.tableExists({ namespace: { levels: ['db'] }, name: 'oldname' })
+      const newExists = await catalog.tableExists({ namespace: { levels: ['db2'] }, name: 'newname' })
+      expect(oldExists).toBe(false)
+      expect(newExists).toBe(true)
+    })
+  })
+
+  describe('Metrics Endpoint', () => {
+    it('POST /namespaces/:namespace/tables/:table/metrics should accept metrics', async () => {
+      const app = createCatalogApi(config)
+
+      await catalog.createNamespace({ levels: ['metrics_db'] })
+
+      // Create table first
+      const schema = createTestSchema()
+      const partitionSpec = createTestPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace: { levels: ['metrics_db'] }, name: 'metricstable' }, builder.build())
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/metrics_db/tables/metricstable/metrics', {
+        'table-name': 'metricstable',
+        'snapshot-id': 123456789,
+        filter: null,
+        'schema-id': 0,
+        'projection-id': null,
+        metrics: {
+          'total-planning-duration': { count: 1, 'time-unit': 'nanoseconds', 'total-duration': 100000 },
+        },
+      })
+      expect(response.status).toBe(204)
+    })
+  })
+
+  describe('OAuth Endpoint', () => {
+    it('POST /oauth/tokens should return a token', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/oauth/tokens', {
+        grant_type: 'client_credentials',
+        scope: 'catalog',
+      })
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data).toHaveProperty('access_token')
+      expect(data).toHaveProperty('token_type')
+      expect(data.token_type).toBe('bearer')
+      expect(data).toHaveProperty('expires_in')
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should return 404 for NamespaceNotFoundError', async () => {
+      const app = createCatalogApi(config)
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces/nonexistent')
+      expect(response.status).toBe(404)
+
+      const data = await response.json()
+      expect(data.error.type).toBe('NoSuchNamespaceException')
+      expect(data.error.code).toBe(404)
+    })
+
+    it('should return 404 for TableNotFoundError', async () => {
+      const app = createCatalogApi(config)
+
+      await catalog.createNamespace({ levels: ['errordb'] })
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces/errordb/tables/nonexistent')
+      expect(response.status).toBe(404)
+
+      const data = await response.json()
+      expect(data.error.type).toBe('NoSuchTableException')
+      expect(data.error.code).toBe(404)
+    })
+
+    it('should return 409 for CommitConflictError', async () => {
+      // Import CommitConflictError to create a mock that throws it
+      const { CommitConflictError } = await import('./catalog')
+
+      // Create a mock catalog that throws CommitConflictError
+      const conflictCatalog = {
+        getCurrentVersion: vi.fn().mockResolvedValue(1),
+        loadTable: vi.fn().mockResolvedValue({
+          'format-version': 2,
+          'table-uuid': 'test-uuid',
+          location: 'test-location',
+          'last-sequence-number': 0,
+          'last-updated-ms': Date.now(),
+          'last-column-id': 3,
+          'current-schema-id': 0,
+          schemas: [createTestSchema()],
+          'default-spec-id': 0,
+          'partition-specs': [createTestPartitionSpec()],
+          'last-partition-id': 1000,
+          'default-sort-order-id': 0,
+          'sort-orders': [{ 'order-id': 0, fields: [] }],
+          properties: {},
+        }),
+        commitTableUpdate: vi.fn().mockRejectedValue(new CommitConflictError('Version conflict', 1, 2)),
+        getTableEntry: vi.fn(),
+      } as unknown as IcebergCatalog
+
+      const app = createCatalogApi({ catalog: conflictCatalog })
+
+      const response = await makeRequest(app, 'POST', '/api/catalog/v1/namespaces/conflictdb/tables/conflicttable', {
+        requirements: [],
+        updates: [{ action: 'set-properties', updates: { conflicting: 'update' } }],
+      })
+      expect(response.status).toBe(409)
+
+      const data = await response.json()
+      expect(data.error.type).toBe('CommitFailedException')
+      expect(data.error.code).toBe(409)
+    })
+
+    it('should return 500 for unexpected errors', async () => {
+      // Create a broken catalog that throws
+      const brokenCatalog = {
+        listNamespaces: vi.fn().mockRejectedValue(new Error('Unexpected database error')),
+      } as unknown as IcebergCatalog
+
+      const app = createCatalogApi({ catalog: brokenCatalog })
+
+      const response = await makeRequest(app, 'GET', '/api/catalog/v1/namespaces')
+      expect(response.status).toBe(500)
+
+      const data = await response.json()
+      expect(data.error.type).toBe('InternalServerError')
+      expect(data.error.code).toBe(500)
+    })
+  })
+
+  describe('catalogApiMiddleware', () => {
+    it('should create a Hono middleware with catalog API routes', async () => {
+      const middleware = catalogApiMiddleware(config)
+
+      expect(middleware).toBeDefined()
+      expect(middleware.fetch).toBeDefined()
+
+      // Test that it works the same as createCatalogApi
+      const response = await makeRequest(middleware, 'GET', '/api/catalog/v1/config')
+      expect(response.status).toBe(200)
+    })
+  })
+})