@dotdo/postgres 0.1.0

package/src/iceberg/catalog.test.ts

@@ -0,0 +1,680 @@
+/**
+ * Iceberg Catalog Tests
+ * Task: postgres-b44 - Iceberg metadata storage strategy
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  IcebergCatalog,
+  createIcebergCatalog,
+  NamespaceNotFoundError,
+  TableNotFoundError,
+  CommitConflictError,
+  type NamespaceIdentifier,
+  type TableIdentifier,
+} from './catalog'
+import { createWALSchema, createWALPartitionSpec, createWALSortOrder } from './schema'
+import { IcebergMetadataBuilder } from './metadata'
+import type { IcebergTableMetadata } from './types'
+
+/**
+ * Create a mock R2Bucket
+ */
+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) => {
+      const body = typeof data === 'string' ? data : data
+      storage.set(key, {
+        data: body as string | ArrayBuffer,
+        metadata: options?.customMetadata,
+      })
+      return {
+        key,
+        version: 'test-version',
+        size: typeof body === 'string' ? body.length : (body 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 mock DurableObjectState
+ */
+function createMockState(): DurableObjectState {
+  const storage = new Map<string, unknown>()
+
+  return {
+    storage: {
+      get: vi.fn(async <T>(key: string) => storage.get(key) as T | undefined),
+      put: vi.fn(async (keyOrEntries: string | Record<string, unknown>, value?: unknown) => {
+        if (typeof keyOrEntries === 'string') {
+          storage.set(keyOrEntries, value)
+        } else {
+          for (const [k, v] of Object.entries(keyOrEntries)) {
+            storage.set(k, v)
+          }
+        }
+      }),
+      delete: vi.fn(async (keys: string | string[]) => {
+        const keyList = Array.isArray(keys) ? keys : [keys]
+        let deleted = false
+        for (const key of keyList) {
+          if (storage.delete(key)) {
+            deleted = true
+          }
+        }
+        return deleted
+      }),
+      list: vi.fn(async () => storage),
+      deleteAll: vi.fn(async () => storage.clear()),
+      transaction: vi.fn(),
+      getAlarm: vi.fn(),
+      setAlarm: vi.fn(),
+      deleteAlarm: vi.fn(),
+      sync: vi.fn(),
+    },
+    id: { toString: () => 'test-do-id' } as DurableObjectId,
+    waitUntil: vi.fn(),
+    blockConcurrencyWhile: vi.fn(async (fn) => fn()),
+    acceptWebSocket: vi.fn(),
+    getWebSockets: vi.fn(() => []),
+    setWebSocketAutoResponse: vi.fn(),
+    getWebSocketAutoResponse: vi.fn(),
+    getWebSocketAutoResponseTimestamp: vi.fn(),
+    setHibernatableWebSocketEventTimeout: vi.fn(),
+    getHibernatableWebSocketEventTimeout: vi.fn(),
+    getTags: vi.fn(() => []),
+    abort: vi.fn(),
+  } as unknown as DurableObjectState
+}
+
+describe('IcebergCatalog', () => {
+  let catalog: IcebergCatalog
+  let mockBucket: R2Bucket
+  let mockState: DurableObjectState
+
+  beforeEach(async () => {
+    mockBucket = createMockBucket()
+    mockState = createMockState()
+
+    catalog = createIcebergCatalog({
+      bucket: mockBucket,
+      state: mockState,
+      prefix: 'test-iceberg/',
+    })
+
+    await catalog.initialize()
+  })
+
+  describe('Namespace Operations', () => {
+    it('should create a namespace', async () => {
+      const namespace: NamespaceIdentifier = { levels: ['tenant1'] }
+      const metadata = await catalog.createNamespace(namespace, { owner: 'test' })
+
+      expect(metadata.namespace).toEqual(namespace)
+      expect(metadata.properties.owner).toBe('test')
+      expect(metadata.createdAt).toBeGreaterThan(0)
+    })
+
+    it('should create nested namespaces', async () => {
+      await catalog.createNamespace({ levels: ['tenant1'] })
+      await catalog.createNamespace({ levels: ['tenant1', 'app1'] })
+      await catalog.createNamespace({ levels: ['tenant1', 'app1', 'module1'] })
+
+      const exists = await catalog.namespaceExists({ levels: ['tenant1', 'app1', 'module1'] })
+      expect(exists).toBe(true)
+    })
+
+    it('should list namespaces', async () => {
+      await catalog.createNamespace({ levels: ['tenant1'] })
+      await catalog.createNamespace({ levels: ['tenant2'] })
+      await catalog.createNamespace({ levels: ['tenant1', 'app1'] })
+
+      const namespaces = await catalog.listNamespaces()
+      expect(namespaces).toHaveLength(2) // Only top-level
+      expect(namespaces.map((ns) => ns.levels)).toContainEqual(['tenant1'])
+      expect(namespaces.map((ns) => ns.levels)).toContainEqual(['tenant2'])
+    })
+
+    it('should list child namespaces', async () => {
+      await catalog.createNamespace({ levels: ['tenant1'] })
+      await catalog.createNamespace({ levels: ['tenant1', 'app1'] })
+      await catalog.createNamespace({ levels: ['tenant1', 'app2'] })
+
+      const children = await catalog.listNamespaces({ levels: ['tenant1'] })
+      expect(children).toHaveLength(2)
+    })
+
+    it('should get namespace metadata', async () => {
+      const namespace: NamespaceIdentifier = { levels: ['tenant1'] }
+      await catalog.createNamespace(namespace, { description: 'Test tenant' })
+
+      const metadata = await catalog.getNamespace(namespace)
+      expect(metadata.properties.description).toBe('Test tenant')
+    })
+
+    it('should throw NamespaceNotFoundError for non-existent namespace', async () => {
+      const namespace: NamespaceIdentifier = { levels: ['nonexistent'] }
+
+      await expect(catalog.getNamespace(namespace)).rejects.toThrow(NamespaceNotFoundError)
+    })
+
+    it('should update namespace properties', async () => {
+      const namespace: NamespaceIdentifier = { levels: ['tenant1'] }
+      await catalog.createNamespace(namespace, { key1: 'value1', key2: 'value2' })
+
+      const updated = await catalog.updateNamespaceProperties(
+        namespace,
+        { key1: 'updated', key3: 'new' },
+        ['key2']
+      )
+
+      expect(updated.properties.key1).toBe('updated')
+      expect(updated.properties.key3).toBe('new')
+      expect(updated.properties.key2).toBeUndefined()
+    })
+
+    it('should drop empty namespace', async () => {
+      const namespace: NamespaceIdentifier = { levels: ['tenant1'] }
+      await catalog.createNamespace(namespace)
+
+      await catalog.dropNamespace(namespace)
+
+      const exists = await catalog.namespaceExists(namespace)
+      expect(exists).toBe(false)
+    })
+
+    it('should not drop namespace with tables', async () => {
+      const namespace: NamespaceIdentifier = { levels: ['tenant1'] }
+      await catalog.createNamespace(namespace)
+
+      // Create a table
+      const schema = createWALSchema()
+      const partitionSpec = createWALPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable({ namespace, name: 'test-table' }, builder.build())
+
+      await expect(catalog.dropNamespace(namespace)).rejects.toThrow('not empty')
+    })
+  })
+
+  describe('Table Operations', () => {
+    const testNamespace: NamespaceIdentifier = { levels: ['tenant1', 'app1'] }
+
+    beforeEach(async () => {
+      await catalog.createNamespace({ levels: ['tenant1'] })
+      await catalog.createNamespace(testNamespace)
+    })
+
+    function createTestMetadata(): IcebergTableMetadata {
+      const schema = createWALSchema()
+      const partitionSpec = createWALPartitionSpec()
+      const sortOrder = createWALSortOrder()
+
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+        sortOrder,
+      })
+
+      return builder.build()
+    }
+
+    it('should create a table', async () => {
+      const identifier: TableIdentifier = { namespace: testNamespace, name: 'events' }
+      const metadata = createTestMetadata()
+
+      const entry = await catalog.createTable(identifier, metadata)
+
+      expect(entry.identifier).toEqual(identifier)
+      expect(entry.metadataVersion).toBe(1)
+      expect(entry.tableUuid).toBeDefined()
+    })
+
+    it('should load table metadata', async () => {
+      const identifier: TableIdentifier = { namespace: testNamespace, name: 'events' }
+      const originalMetadata = createTestMetadata()
+
+      await catalog.createTable(identifier, originalMetadata)
+      const loadedMetadata = await catalog.loadTable(identifier)
+
+      expect(loadedMetadata['format-version']).toBe(2)
+      expect(loadedMetadata['table-uuid']).toBeDefined()
+      expect(loadedMetadata.schemas).toHaveLength(1)
+    })
+
+    it('should list tables in namespace', async () => {
+      const metadata = createTestMetadata()
+
+      await catalog.createTable({ namespace: testNamespace, name: 'table1' }, metadata)
+      await catalog.createTable({ namespace: testNamespace, name: 'table2' }, metadata)
+
+      const tables = await catalog.listTables(testNamespace)
+
+      expect(tables).toHaveLength(2)
+      expect(tables.map((t) => t.name)).toContain('table1')
+      expect(tables.map((t) => t.name)).toContain('table2')
+    })
+
+    it('should check table existence', async () => {
+      const identifier: TableIdentifier = { namespace: testNamespace, name: 'events' }
+
+      expect(await catalog.tableExists(identifier)).toBe(false)
+
+      await catalog.createTable(identifier, createTestMetadata())
+
+      expect(await catalog.tableExists(identifier)).toBe(true)
+    })
+
+    it('should drop a table', async () => {
+      const identifier: TableIdentifier = { namespace: testNamespace, name: 'events' }
+      await catalog.createTable(identifier, createTestMetadata())
+
+      await catalog.dropTable(identifier)
+
+      expect(await catalog.tableExists(identifier)).toBe(false)
+    })
+
+    it('should throw TableNotFoundError for non-existent table', async () => {
+      const identifier: TableIdentifier = { namespace: testNamespace, name: 'nonexistent' }
+
+      await expect(catalog.loadTable(identifier)).rejects.toThrow(TableNotFoundError)
+    })
+
+    it('should rename a table', async () => {
+      const from: TableIdentifier = { namespace: testNamespace, name: 'old-name' }
+      const to: TableIdentifier = { namespace: testNamespace, name: 'new-name' }
+
+      await catalog.createTable(from, createTestMetadata())
+      await catalog.renameTable(from, to)
+
+      expect(await catalog.tableExists(from)).toBe(false)
+      expect(await catalog.tableExists(to)).toBe(true)
+    })
+
+    it('should rename table to different namespace', async () => {
+      await catalog.createNamespace({ levels: ['tenant1', 'app2'] })
+
+      const from: TableIdentifier = { namespace: testNamespace, name: 'table1' }
+      const to: TableIdentifier = { namespace: { levels: ['tenant1', 'app2'] }, name: 'table1' }
+
+      await catalog.createTable(from, createTestMetadata())
+      await catalog.renameTable(from, to)
+
+      expect(await catalog.tableExists(from)).toBe(false)
+      expect(await catalog.tableExists(to)).toBe(true)
+    })
+  })
+
+  describe('Metadata Versioning', () => {
+    const testNamespace: NamespaceIdentifier = { levels: ['tenant1'] }
+    const testIdentifier: TableIdentifier = { namespace: testNamespace, name: 'test-table' }
+
+    beforeEach(async () => {
+      await catalog.createNamespace(testNamespace)
+
+      const schema = createWALSchema()
+      const partitionSpec = createWALPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable(testIdentifier, builder.build())
+    })
+
+    it('should track metadata version', async () => {
+      const version = await catalog.getCurrentVersion(testIdentifier)
+      expect(version).toBe(1)
+    })
+
+    it('should increment version on commit', async () => {
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder = IcebergMetadataBuilder.fromMetadata(metadata)
+
+      // Create a snapshot
+      builder.createSnapshot({
+        manifestListPath: 'test/manifest-list.avro',
+        summary: { operation: 'append' },
+      })
+
+      await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+
+      const newVersion = await catalog.getCurrentVersion(testIdentifier)
+      expect(newVersion).toBe(2)
+    })
+
+    it('should load specific metadata version', async () => {
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder = IcebergMetadataBuilder.fromMetadata(metadata)
+
+      builder.createSnapshot({
+        manifestListPath: 'test/manifest-list.avro',
+        summary: { operation: 'append' },
+      })
+
+      await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+
+      // Load version 1
+      const v1Metadata = await catalog.loadTableVersion(testIdentifier, 1)
+      expect(v1Metadata.snapshots).toBeUndefined()
+
+      // Load version 2
+      const v2Metadata = await catalog.loadTableVersion(testIdentifier, 2)
+      expect(v2Metadata.snapshots).toHaveLength(1)
+    })
+
+    it('should list all metadata versions', async () => {
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder = IcebergMetadataBuilder.fromMetadata(metadata)
+
+      builder.createSnapshot({
+        manifestListPath: 'test/manifest-list.avro',
+        summary: { operation: 'append' },
+      })
+
+      await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+
+      const versions = await catalog.listTableVersions(testIdentifier)
+      expect(versions).toEqual([1, 2])
+    })
+  })
+
+  describe('Optimistic Locking', () => {
+    const testNamespace: NamespaceIdentifier = { levels: ['tenant1'] }
+    const testIdentifier: TableIdentifier = { namespace: testNamespace, name: 'test-table' }
+
+    beforeEach(async () => {
+      await catalog.createNamespace(testNamespace)
+
+      const schema = createWALSchema()
+      const partitionSpec = createWALPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable(testIdentifier, builder.build())
+    })
+
+    it('should detect commit conflict with wrong base version', async () => {
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder = IcebergMetadataBuilder.fromMetadata(metadata)
+
+      builder.createSnapshot({
+        manifestListPath: 'test/manifest-list.avro',
+        summary: { operation: 'append' },
+      })
+
+      // First commit succeeds
+      await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+
+      // Second commit with old base version fails
+      await expect(
+        catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+      ).rejects.toThrow(CommitConflictError)
+    })
+
+    it('should include version info in conflict error', async () => {
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder = IcebergMetadataBuilder.fromMetadata(metadata)
+
+      builder.createSnapshot({
+        manifestListPath: 'test/manifest-list.avro',
+        summary: { operation: 'append' },
+      })
+
+      await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+
+      try {
+        await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+        expect.fail('Should have thrown CommitConflictError')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CommitConflictError)
+        const conflictError = error as CommitConflictError
+        expect(conflictError.expectedVersion).toBe(1)
+        expect(conflictError.actualVersion).toBe(2)
+      }
+    })
+
+    it('should allow retry with correct base version', async () => {
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder1 = IcebergMetadataBuilder.fromMetadata(metadata)
+      const builder2 = IcebergMetadataBuilder.fromMetadata(metadata)
+
+      builder1.createSnapshot({
+        manifestListPath: 'test/manifest-list-1.avro',
+        summary: { operation: 'append' },
+      })
+
+      builder2.createSnapshot({
+        manifestListPath: 'test/manifest-list-2.avro',
+        summary: { operation: 'append' },
+      })
+
+      // First commit succeeds
+      await catalog.commitTableUpdate(testIdentifier, builder1.build(), 1)
+
+      // Second commit fails
+      await expect(
+        catalog.commitTableUpdate(testIdentifier, builder2.build(), 1)
+      ).rejects.toThrow(CommitConflictError)
+
+      // Retry with correct base version succeeds
+      // Load fresh metadata first
+      const freshMetadata = await catalog.loadTable(testIdentifier)
+      const retryBuilder = IcebergMetadataBuilder.fromMetadata(freshMetadata)
+      retryBuilder.createSnapshot({
+        manifestListPath: 'test/manifest-list-2.avro',
+        summary: { operation: 'append' },
+      })
+
+      await catalog.commitTableUpdate(testIdentifier, retryBuilder.build(), 2)
+
+      const finalVersion = await catalog.getCurrentVersion(testIdentifier)
+      expect(finalVersion).toBe(3)
+    })
+  })
+
+  describe('Caching', () => {
+    const testNamespace: NamespaceIdentifier = { levels: ['tenant1'] }
+    const testIdentifier: TableIdentifier = { namespace: testNamespace, name: 'test-table' }
+
+    beforeEach(async () => {
+      await catalog.createNamespace(testNamespace)
+
+      const schema = createWALSchema()
+      const partitionSpec = createWALPartitionSpec()
+      const builder = new IcebergMetadataBuilder({
+        location: '',
+        schema,
+        partitionSpec,
+      })
+      await catalog.createTable(testIdentifier, builder.build())
+    })
+
+    it('should cache loaded metadata', async () => {
+      // First load
+      await catalog.loadTable(testIdentifier)
+
+      // Second load should use cache
+      await catalog.loadTable(testIdentifier)
+
+      // R2 get should only be called once for metadata (plus initial create)
+      const getCalls = (mockBucket.get as ReturnType<typeof vi.fn>).mock.calls
+      const metadataCalls = getCalls.filter((call) => (call[0] as string).includes('.metadata.json'))
+      expect(metadataCalls.length).toBe(1)
+    })
+
+    it('should invalidate cache on commit', async () => {
+      // First load
+      await catalog.loadTable(testIdentifier)
+
+      // Commit update
+      const metadata = await catalog.loadTable(testIdentifier)
+      const builder = IcebergMetadataBuilder.fromMetadata(metadata)
+      builder.createSnapshot({
+        manifestListPath: 'test/manifest-list.avro',
+        summary: { operation: 'append' },
+      })
+      await catalog.commitTableUpdate(testIdentifier, builder.build(), 1)
+
+      // Load again - should fetch fresh data
+      const freshMetadata = await catalog.loadTable(testIdentifier)
+      expect(freshMetadata.snapshots).toHaveLength(1)
+    })
+
+    it('should provide cache statistics', () => {
+      const stats = catalog.getStats()
+
+      expect(stats.namespaceCount).toBe(1)
+      expect(stats.tableCount).toBe(1)
+      expect(stats.cacheStats.maxEntries).toBe(1000)
+    })
+
+    it('should clear cache on request', async () => {
+      await catalog.loadTable(testIdentifier)
+
+      catalog.clearCache()
+
+      // Next load should hit R2 again
+      await catalog.loadTable(testIdentifier)
+
+      const getCalls = (mockBucket.get as ReturnType<typeof vi.fn>).mock.calls
+      const metadataCalls = getCalls.filter((call) => (call[0] as string).includes('.metadata.json'))
+      expect(metadataCalls.length).toBe(2)
+    })
+  })
+
+  describe('Catalog Initialization', () => {
+    it('should create catalog configuration on first init', async () => {
+      const calls = (mockBucket.put as ReturnType<typeof vi.fn>).mock.calls
+      const configCall = calls.find((call) => (call[0] as string).includes('catalog.json'))
+
+      expect(configCall).toBeDefined()
+    })
+
+    it('should not recreate catalog config if exists', async () => {
+      const newBucket = createMockBucket()
+      const newState = createMockState()
+
+      // Pre-create config
+      await newBucket.put('test-iceberg/catalog/catalog.json', '{"version":1}')
+
+      const newCatalog = createIcebergCatalog({
+        bucket: newBucket,
+        state: newState,
+        prefix: 'test-iceberg/',
+      })
+
+      await newCatalog.initialize()
+
+      // Should only have the pre-created put
+      const putCalls = (newBucket.put as ReturnType<typeof vi.fn>).mock.calls
+      const configPuts = putCalls.filter((call) => (call[0] as string).includes('catalog.json'))
+      expect(configPuts.length).toBe(1)
+    })
+
+    it('should restore state from DO storage', async () => {
+      // Create some state in first catalog
+      await catalog.createNamespace({ levels: ['restored-ns'] })
+
+      // Create new catalog with same state
+      const newCatalog = createIcebergCatalog({
+        bucket: mockBucket,
+        state: mockState,
+        prefix: 'test-iceberg/',
+      })
+
+      await newCatalog.initialize()
+
+      // Should have the namespace
+      const exists = await newCatalog.namespaceExists({ levels: ['restored-ns'] })
+      expect(exists).toBe(true)
+    })
+  })
+})