fix: add regression tests for error codes (#990)

Author: ferhatelmas

src/test/iceberg.test.ts

@@ -210,6 +210,34 @@ describe('Iceberg Catalog', () => {
       })
     })
 
+    it('returns InvalidParameter for invalid namespace names', async () => {
+      const bucketName = t.random.name('ice-bucket')
+      await t.storage.createIcebergBucket({
+        name: bucketName,
+      })
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/iceberg/v1/${bucketName}/namespaces`,
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${await serviceKeyAsync}`,
+        },
+        payload: {
+          namespace: 'awsnamespace',
+        },
+      })
+
+      expect(response.statusCode).toBe(400)
+      expect(await response.json()).toEqual({
+        error: {
+          code: 400,
+          message: 'Resource name must not start with the reserved prefix "aws"',
+          type: 'InvalidParameter',
+        },
+      })
+    })
+
     it('can list namespaces', async () => {
       const bucketName = t.random.name('ice-bucket')
 

src/test/s3-error-code.test.ts

@@ -0,0 +1,107 @@
+import { randomUUID } from 'node:crypto'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { ListPartsCommand, S3Client } from '@aws-sdk/client-s3'
+import { KnexMetastore } from '@storage/protocols/iceberg/knex'
+import { FastifyInstance } from 'fastify'
+import { getConfig } from '../config'
+import { useStorage } from './utils/storage'
+
+const {
+  icebergBucketDetectionSuffix,
+  s3ProtocolAccessKeyId,
+  s3ProtocolAccessKeySecret,
+  storageS3Region,
+} = getConfig()
+
+async function createFileBackedApp(fileBackendPath: string) {
+  jest.resetModules()
+
+  const configModule = await import('../config')
+
+  configModule.getConfig({ reload: true })
+  configModule.mergeConfig({
+    storageBackendType: 'file',
+    storageFilePath: fileBackendPath,
+  })
+
+  return (await import('../app')).default()
+}
+
+describe('S3 protocol error code', () => {
+  const t = useStorage()
+
+  let testApp: FastifyInstance
+  let client: S3Client
+  let icebergMetastore: KnexMetastore
+  let fileBackendPath: string
+
+  beforeAll(async () => {
+    fileBackendPath = await mkdtemp(join(tmpdir(), 'storage-file-backend-'))
+    testApp = await createFileBackedApp(fileBackendPath)
+    icebergMetastore = new KnexMetastore(t.database.connection.pool.acquire(), {
+      multiTenant: false,
+      schema: 'storage',
+    })
+
+    const listener = await testApp.listen()
+
+    client = new S3Client({
+      endpoint: `${listener.replace('[::1]', 'localhost')}/s3`,
+      forcePathStyle: true,
+      region: storageS3Region,
+      credentials: {
+        accessKeyId: s3ProtocolAccessKeyId!,
+        secretAccessKey: s3ProtocolAccessKeySecret!,
+      },
+    })
+  })
+
+  afterAll(async () => {
+    client?.destroy()
+    await testApp?.close()
+
+    jest.resetModules()
+    await rm(fileBackendPath, { recursive: true, force: true })
+  })
+
+  it('returns NotSupported for iceberg list-parts on non-S3 backends', async () => {
+    const nonce = randomUUID().replaceAll('-', '')
+    const analyticsBucket = await t.storage.createIcebergBucket({
+      name: `ice_bucket_${nonce}`,
+    })
+    const namespaceName = `namespace${nonce}`
+    const tableName = `table${nonce}`
+    const internalBucketName = `internal-${nonce}${icebergBucketDetectionSuffix}`
+
+    const namespace = await icebergMetastore.createNamespace({
+      name: namespaceName,
+      bucketName: analyticsBucket.name,
+      bucketId: analyticsBucket.id,
+      tenantId: '',
+      metadata: {},
+    })
+
+    await icebergMetastore.createTable({
+      name: tableName,
+      bucketName: analyticsBucket.name,
+      bucketId: analyticsBucket.id,
+      location: `s3://${internalBucketName}`,
+      namespaceId: namespace.id,
+    })
+
+    await expect(
+      client.send(
+        new ListPartsCommand({
+          Bucket: internalBucketName,
+          Key: `${namespaceName}/${tableName}/data.parquet`,
+          UploadId: 'upload-id',
+        })
+      )
+    ).rejects.toMatchObject({
+      $metadata: expect.objectContaining({ httpStatusCode: 409 }),
+      name: 'NotSupported',
+    })
+  })
+})

src/test/vectors.test.ts

@@ -283,24 +283,52 @@ describe('Vectors API', () => {
     })
 
     it('should handle vector service not configured', async () => {
-      // Mock app without s3Vector service
-      const appWithoutVector = app()
       mergeConfig({ vectorEnabled: false })
 
-      const response = await appWithoutVector.inject({
-        method: 'POST',
-        url: '/vector/CreateIndex',
-        headers: {
-          authorization: `Bearer ${serviceToken}`,
-        },
-        payload: validCreateIndexRequest,
-      })
+      const appWithoutVector = app()
 
-      expect(response.statusCode).toBe(404)
-      const body = JSON.parse(response.body)
-      expect(body.error).toBe('Not Found')
+      try {
+        const response = await appWithoutVector.inject({
+          method: 'POST',
+          url: '/vector/CreateIndex',
+          headers: {
+            authorization: `Bearer ${serviceToken}`,
+          },
+          payload: validCreateIndexRequest,
+        })
+
+        expect(response.statusCode).toBe(404)
+        const body = JSON.parse(response.body)
+        expect(body.error).toBe('Not Found')
+      } finally {
+        await appWithoutVector.close()
+      }
+    })
 
-      await appWithoutVector.close()
+    it('should return FeatureNotEnabled when the vector backend is not configured', async () => {
+      mergeConfig({ vectorEnabled: true, vectorS3Buckets: [] })
+
+      const appWithoutVector = app()
+
+      try {
+        const response = await appWithoutVector.inject({
+          method: 'POST',
+          url: '/vector/CreateIndex',
+          headers: {
+            authorization: `Bearer ${serviceToken}`,
+          },
+          payload: validCreateIndexRequest,
+        })
+
+        expect(response.statusCode).toBe(409)
+        expect(JSON.parse(response.body)).toMatchObject({
+          statusCode: '409',
+          code: 'FeatureNotEnabled',
+          error: 'FeatureNotEnabled',
+        })
+      } finally {
+        await appWithoutVector.close()
+      }
     })
 
     it('should handle S3Vector service errors', async () => {