deltacat 2.0.0b10__py3-none-any.whl → 2.0.0b11__py3-none-any.whl

deltacat/tests/catalog/test_catalogs.py

@@ -1,23 +1,24 @@
 import unittest
 import pytest
-import ray
 import tempfile
 import shutil
 import uuid
 from unittest import mock
 import os
 
-from deltacat.catalog import CatalogProperties
-from pyiceberg.catalog import Catalog as IcebergCatalog
-
-from deltacat.catalog.model.catalog import (
+from deltacat.catalog import (
+    CatalogProperties,
     Catalog,
-    init,
+    clear_catalogs,
     get_catalog,
-    put_catalog,
+    init,
     is_initialized,
+    put_catalog,
 )
-from deltacat.catalog.iceberg.iceberg_catalog_config import IcebergCatalogConfig
+from deltacat.experimental.catalog.iceberg import impl as IcebergCatalog
+from pyiceberg.catalog import Catalog as PyIcebergCatalog
+
+from deltacat.experimental.catalog.iceberg import IcebergCatalogConfig
 
 from pyiceberg.catalog import CatalogType
 
@@ -25,41 +26,19 @@ from pyiceberg.catalog import CatalogType
 # Test module to mock a catalog implementation
 class MockCatalogImpl:
     @staticmethod
-    def initialize(*args, **kwargs):
+    def initialize(config, *args, **kwargs):
         # Return some state that the catalog would normally maintain
-        return {"initialized": True, "args": args, "kwargs": kwargs}
+        return {
+            "initialized": True,
+            "config": config,
+            "args": args,
+            "kwargs": kwargs,
+        }
 
 
 @pytest.fixture(scope="function")
-def reset_catalogs_ray_actor():
-    """
-    Setup and teardown for Ray environment for tests.
-
-    This will kill the actor all_catalogs, essentially wiping global state for catalogs
-
-    NOTE: tests using this fixture must be run serially. As of April 7 2025, the unit test suite had various
-      failures if run in parallel, in part because the state of all_catalogs in ray is shared across tests.
-
-    NOTE: when using this fixture, ensure you pass ray_init_args={"ignore_reinit_error": True} into all
-        functions which may re-initialize ray. This is because the production code checks the all_catalogs actor
-        in order to determine whether it needs to initialize Ray
-    """
-    # Reset the global catalog_actor state before each test
-    import deltacat.catalog.model.catalog as catalog_module
-
-    # Initialize Ray if not already initialized
-    if not ray.is_initialized():
-        ray.init(ignore_reinit_error=True)
-    yield
-
-    # Clean up the actor if it exists
-    if catalog_module.all_catalogs is not None:
-        try:
-            ray.kill(catalog_module.all_catalogs)
-        except Exception:
-            pass
-        finally:
-            catalog_module.all_catalogs = None
+def reset_catalogs():
+    clear_catalogs()
 
 
 class TestCatalog(unittest.TestCase):
@@ -74,6 +53,7 @@ class TestCatalog(unittest.TestCase):
         # Check that inner state was correctly initialized
         # This just asserts that kwargs were plumbed through from Catalog constructor
         self.assertTrue(catalog.inner["initialized"])
+        self.assertIsNone(catalog.inner["config"])
         self.assertEqual(catalog.inner["args"], ())
         self.assertEqual(catalog.inner["kwargs"], {})
 
@@ -81,16 +61,18 @@ class TestCatalog(unittest.TestCase):
         """Test the iceberg factory method correctly creates an Iceberg catalog."""
         # Create a mock for the Iceberg catalog module
         with mock.patch(
-            "deltacat.catalog.model.catalog.IcebergCatalog"
+            "deltacat.experimental.catalog.iceberg.impl.IcebergCatalog"
         ) as mock_iceberg_catalog:
             # Configure the mock to return a known value when initialize is called
             mock_iceberg_catalog.initialize.return_value = {"iceberg": True}
 
             # Create an Iceberg catalog config and invoke iceberg factory method
             config = IcebergCatalogConfig(type=CatalogType.IN_MEMORY, properties={})
-            catalog = Catalog.iceberg(config)
+            catalog = IcebergCatalog.from_config(config)
 
             # Check that the implementation is set to iceberg_catalog
+            print(f"catalog.impl: {catalog.impl}")
+            print(f"mock_iceberg_catalog: {mock_iceberg_catalog}")
             self.assertEqual(catalog.impl, mock_iceberg_catalog)
             # Check that the inner state is set to the output of initialize
             self.assertEqual(catalog.inner, {"iceberg": True})
@@ -109,8 +91,7 @@ class TestCatalogsIntegration:
         catalog = Catalog(impl=MockCatalogImpl)
         init(
             catalog,
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
+            force=True,
         )
 
     @classmethod
@@ -118,17 +99,13 @@ class TestCatalogsIntegration:
         if cls.temp_dir and os.path.exists(cls.temp_dir):
             shutil.rmtree(cls.temp_dir)
 
-    def test_init_single_catalog(self, reset_catalogs_ray_actor):
+    def test_init_single_catalog(self, reset_catalogs):
         """Test initializing a single catalog."""
 
         catalog = Catalog(impl=MockCatalogImpl)
 
         # Initialize with a single catalog and Ray init args including the namespace
-        init(
-            catalog,
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
-        )
+        init(catalog, force=True)
 
         assert is_initialized()
 
@@ -137,7 +114,7 @@ class TestCatalogsIntegration:
         assert retrieved_catalog.impl == MockCatalogImpl
         assert retrieved_catalog.inner["initialized"]
 
-    def test_init_multiple_catalogs(self, reset_catalogs_ray_actor):
+    def test_init_multiple_catalogs(self, reset_catalogs):
         """Test initializing multiple catalogs."""
         # Create catalogs
         catalog1 = Catalog(impl=MockCatalogImpl, id=1)
@@ -145,11 +122,7 @@ class TestCatalogsIntegration:
 
         # Initialize with multiple catalogs and Ray init args including the namespace
         catalogs_dict = {"catalog1": catalog1, "catalog2": catalog2}
-        init(
-            catalogs_dict,
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
-        )
+        init(catalogs_dict, force=True)
 
         assert is_initialized()
 
@@ -162,7 +135,7 @@ class TestCatalogsIntegration:
         assert retrieved_catalog2.impl == MockCatalogImpl
         assert retrieved_catalog2.inner["kwargs"]["id"] == 2
 
-    def test_init_with_default_catalog_name(self, reset_catalogs_ray_actor):
+    def test_init_with_default_catalog_name(self, reset_catalogs):
         """Test initializing with a specified default catalog name."""
         # Create catalogs
         catalog1 = Catalog(impl=MockCatalogImpl, id=1)
@@ -173,8 +146,7 @@ class TestCatalogsIntegration:
         init(
             catalogs_dict,
             default="catalog2",
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
+            force=True,
         )
 
         # Get the default catalog and check it's catalog2
@@ -182,16 +154,12 @@ class TestCatalogsIntegration:
         assert default_catalog.impl == MockCatalogImpl
         assert default_catalog.inner["kwargs"]["id"] == 2
 
-    def test_put_catalog(self, reset_catalogs_ray_actor):
+    def test_put_catalog(self, reset_catalogs):
         """Test adding a catalog after initialization."""
         # Initialize with a single catalog
         catalog1 = Catalog(impl=MockCatalogImpl, id=1)
         catalog2 = Catalog(impl=MockCatalogImpl, id=2)
-        init(
-            {"catalog1": catalog1},
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
-        )
+        init({"catalog1": catalog1}, force=True)
 
         # Add a second catalog
         put_catalog("catalog2", catalog2)
@@ -203,21 +171,19 @@ class TestCatalogsIntegration:
         retrieved_catalog2 = get_catalog("catalog2")
         assert retrieved_catalog2.inner["kwargs"]["id"] == 2
 
-    def test_put_catalog_that_already_exists(self, reset_catalogs_ray_actor):
+    def test_put_catalog_that_already_exists(self, reset_catalogs):
         catalog = Catalog(impl=MockCatalogImpl, id=1)
         catalog2 = Catalog(impl=MockCatalogImpl, id=2)
         put_catalog(
             "test_catalog",
             catalog,
             id=1,
-            ray_init_args={"ignore_reinit_error": True},
         )
 
         # Try to add another catalog with the same name. Should not error
         put_catalog(
             "test_catalog",
             catalog2,
-            ray_init_args={"ignore_reinit_error": True},
         )
 
         retrieved_catalog = get_catalog("test_catalog")
@@ -228,40 +194,31 @@ class TestCatalogsIntegration:
             put_catalog(
                 "test_catalog",
                 catalog,
-                ray_init_args={"ignore_reinit_error": True},
                 fail_if_exists=True,
             )
 
-    def test_get_catalog_nonexistent(self, reset_catalogs_ray_actor):
+    def test_get_catalog_nonexistent(self, reset_catalogs):
         """Test that trying to get a nonexistent catalog raises an error."""
         # Initialize with a catalog
         catalog = Catalog(impl=MockCatalogImpl)
-        init(
-            {"test_catalog": catalog},
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
-        )
+        init({"test_catalog": catalog}, force=True)
 
         # Try to get a nonexistent catalog
         with pytest.raises(ValueError):
             get_catalog("nonexistent")
 
-    def test_get_catalog_no_default(self, reset_catalogs_ray_actor):
+    def test_get_catalog_no_default(self, reset_catalogs):
         """Test that trying to get the default catalog when none is set raises an error."""
         # Initialize with multiple catalogs but no default
         catalog1 = Catalog(impl=MockCatalogImpl, id=1)
         catalog2 = Catalog(impl=MockCatalogImpl, id=2)
-        init(
-            {"catalog1": catalog1, "catalog2": catalog2},
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
-        )
+        init({"catalog1": catalog1, "catalog2": catalog2}, force=True)
 
         # Try to get the default catalog
         with pytest.raises(ValueError):
             get_catalog()
 
-    def test_default_catalog_initialization(self, reset_catalogs_ray_actor):
+    def test_default_catalog_initialization(self, reset_catalogs):
         """Test that a Default catalog can be initialized and accessed using the factory method."""
         from deltacat.catalog.model.properties import CatalogProperties
 
@@ -270,15 +227,11 @@ class TestCatalogsIntegration:
         # Create the catalog properties
         config = CatalogProperties(root=self.temp_dir)
 
-        # Create the catalog using the factory method
-        catalog = Catalog.default(config)
+        # Create the catalog
+        catalog = Catalog(config)
 
         # Initialize DeltaCAT with this catalog
-        init(
-            {catalog_name: catalog},
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
-        )
+        init({catalog_name: catalog}, force=True)
 
         # Retrieve the catalog and verify it's the same one
         retrieved_catalog = get_catalog(catalog_name)
@@ -286,16 +239,14 @@ class TestCatalogsIntegration:
         assert isinstance(retrieved_catalog.inner, CatalogProperties)
         assert retrieved_catalog.inner.root == self.temp_dir
 
-    def test_default_catalog_initialization_from_kwargs(self, reset_catalogs_ray_actor):
+    def test_default_catalog_initialization_from_kwargs(self, reset_catalogs):
 
         catalog_name = str(uuid.uuid4())
-        # Initialize DeltaCAT with this catalog
-        from deltacat.catalog.main import impl as DeltacatCatalog
 
+        # Initialize DeltaCAT with this catalog
         put_catalog(
             catalog_name,
-            Catalog(DeltacatCatalog, **{"root": "test_root"}),
-            ray_init_args={"ignore_reinit_error": True},
+            Catalog(root="test_root"),
         )
 
         # Retrieve the catalog and verify it's the same one
@@ -304,7 +255,7 @@ class TestCatalogsIntegration:
         assert isinstance(retrieved_catalog.inner, CatalogProperties)
         assert retrieved_catalog.inner.root == "test_root"
 
-    def test_iceberg_catalog_initialization(self, reset_catalogs_ray_actor):
+    def test_iceberg_catalog_initialization(self, reset_catalogs):
         """Test that an Iceberg catalog can be initialized and accessed."""
         catalog_name = str(uuid.uuid4())
 
@@ -314,11 +265,14 @@ class TestCatalogsIntegration:
         )
 
         # Create the catalog using the factory method
-        catalog = Catalog.iceberg(config)
+        catalog = IcebergCatalog.from_config(config)
 
-        put_catalog(catalog_name, catalog, ray_init_args={"ignore_reinit_error": True})
+        put_catalog(catalog_name, catalog)
 
         # Retrieve the catalog and verify it's the same one
         retrieved_catalog = get_catalog(catalog_name)
-        assert retrieved_catalog.impl.__name__ == "deltacat.catalog.iceberg.impl"
-        assert isinstance(retrieved_catalog.inner, IcebergCatalog)
+        assert (
+            retrieved_catalog.impl.__name__
+            == "deltacat.experimental.catalog.iceberg.impl"
+        )
+        assert isinstance(retrieved_catalog.inner, PyIcebergCatalog)

deltacat/tests/catalog/test_default_catalog_impl.py

@@ -38,8 +38,7 @@ class TestReadTable(unittest.TestCase):
         catalog_config = CatalogProperties(storage=ds)
         dc.put_catalog(
             cls.catalog_name,
-            catalog=Catalog.default(config=catalog_config),
-            ray_init_args={"ignore_reinit_error": True},
+            catalog=Catalog(catalog_config),
         )
         super().setUpClass()
 

deltacat/tests/daft/test_model.py

@@ -0,0 +1,97 @@
+import pytest
+import pyarrow as pa
+from daft import DataType, TimeUnit
+from daft.logical.schema import Field as DaftField
+
+from deltacat.storage.model.transform import IdentityTransform
+from deltacat.storage.model.partition import PartitionKey
+from deltacat.utils.daft import DaftFieldMapper, DaftPartitionKeyMapper
+
+from deltacat.storage.model.schema import Field, Schema
+
+
+class TestDaftFieldMapper:
+    def test_field_mapper_basic_types(self):
+        """Test mapping basic data types between Daft and PyArrow fields"""
+        test_cases = [
+            (DataType.int32(), pa.int32()),
+            (DataType.int64(), pa.int64()),
+            (DataType.float32(), pa.float32()),
+            (DataType.float64(), pa.float64()),
+            (DataType.string(), pa.large_string()),
+            (DataType.bool(), pa.bool_()),
+            (DataType.binary(), pa.large_binary()),
+            (DataType.date(), pa.date32()),
+            (DataType.timestamp(TimeUnit.ns()), pa.timestamp("ns")),
+        ]
+
+        for daft_type, pa_type in test_cases:
+            # Create test fields
+            daft_field = DaftField.create(
+                name="test_field",
+                dtype=daft_type,
+            )
+
+            # Daft to PyArrow
+            pa_field = DaftFieldMapper.map(daft_field)
+            assert pa_field is not None
+            assert pa_field.name == "test_field"
+            assert pa_field.type == pa_type  # type: ignore
+            assert pa_field.nullable is True
+
+            # PyArrow to Daft
+            daft_field_back = DaftFieldMapper.unmap(pa_field)
+            assert daft_field_back is not None
+            assert daft_field_back.name == daft_field.name
+            assert daft_field_back.dtype == daft_field.dtype
+
+
+class TestDaftPartitionKeyMapper:
+    def test_unmap(self):
+        """
+        Test unmap method of DaftPartitionKeyMapper when obj is not None, schema is provided,
+        len(obj.key) is 1, and dc_field is found in the schema.
+
+        This test verifies that the method correctly converts a PartitionKey to a DaftPartitionField
+        when all conditions are met and the field exists in the schema.
+        """
+        # Create a mock schema
+        schema = Schema.of(schema=[Field.of(pa.field("test_field", pa.int32()))])
+        # Create a PartitionKey object
+        partition_key = PartitionKey(
+            key=["test_field"], transform=IdentityTransform(), name="partition_field"
+        )
+
+        result = DaftPartitionKeyMapper.unmap(obj=partition_key, schema=schema)
+        assert result is not None
+        assert result.field.name() == "partition_field"
+        assert DataType._from_pydatatype(result.field.dtype()) == DataType.int32()
+
+    def test_unmap_no_field_locator(self):
+        schema = Schema.of(schema=[Field.of(pa.field("test_field", pa.int32()))])
+        partition_key = PartitionKey(key=[], name="partition_field")
+
+        with pytest.raises(ValueError) as excinfo:
+            DaftPartitionKeyMapper.unmap(partition_key, schema)
+
+        assert "At least 1 PartitionKey FieldLocator is expected" in str(excinfo.value)
+
+    def test_unmap_partition_key_not_found(self):
+        schema = Schema.of(schema=[Field.of(pa.field("test_field", pa.int32()))])
+        partition_key = PartitionKey(
+            key=["test_field_2"], transform=IdentityTransform(), name="partition_field"
+        )
+
+        with pytest.raises(KeyError) as excinfo:
+            DaftPartitionKeyMapper.unmap(partition_key, schema)
+
+        assert "Column test_field_2 does not exist in schema" in str(excinfo.value)
+
+    def test_unmap_partition_name_not_defined(self):
+        schema = Schema.of(schema=[Field.of(pa.field("test_field", pa.int32()))])
+        partition_key = PartitionKey(key=[])
+
+        with pytest.raises(ValueError) as excinfo:
+            DaftPartitionKeyMapper.unmap(partition_key, schema)
+
+        assert "Name is required for PartitionKey conversion" in str(excinfo.value)

deltacat/tests/experimental/catalog/iceberg/test_iceberg_catalog.py

@@ -0,0 +1,71 @@
+import tempfile
+import shutil
+import uuid
+import deltacat
+import pytest
+from deltacat import Field, Schema
+from pyiceberg.catalog import CatalogType
+
+import pyarrow as pa
+
+from deltacat.experimental.catalog.iceberg import IcebergCatalogConfig
+
+
+@pytest.fixture
+def schema_a():
+    return Schema.of(
+        [
+            Field.of(
+                field=pa.field("col1", pa.int32(), nullable=False),
+                field_id=1,
+                is_merge_key=True,
+            )
+        ]
+    )
+
+
+class TestIcebergCatalogInitialization:
+    temp_dir = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.temp_dir = tempfile.mkdtemp()
+
+    @classmethod
+    def teardown_class(cls):
+        shutil.rmtree(cls.temp_dir)
+
+    def test_iceberg_catalog_and_table_create(self, schema_a):
+
+        # Register a random catalog name to avoid concurrent test conflicts
+        catalog_name = str(uuid.uuid4())
+
+        config = IcebergCatalogConfig(
+            type=CatalogType.SQL,
+            properties={
+                "warehouse": self.temp_dir,
+                "uri": f"sqlite:////{self.temp_dir}/sql-catalog.db",
+            },
+        )
+
+        # Initialize with the PyIceberg catalog
+        catalog = deltacat.IcebergCatalog.from_config(config)
+        deltacat.init(
+            {catalog_name: catalog},
+            force=True,
+        )
+
+        table_def = deltacat.create_table(
+            "test_table", catalog=catalog_name, schema=schema_a
+        )
+
+        # Fetch table we just created
+        fetched_table_def = deltacat.get_table("test_table", catalog=catalog_name)
+        assert table_def.table_version == fetched_table_def.table_version
+
+        # For now, just check that we created a table version with an equivalent schema
+        assert table_def.table_version.schema.equivalent_to(schema_a)
+
+        # Sanity check that list namespaces works
+        namespaces = deltacat.list_namespaces(catalog=catalog_name).all_items()
+        assert table_def.table.namespace in [n.namespace for n in namespaces]

deltacat/tests/experimental/daft/test_deltacat_daft_integration.py

@@ -0,0 +1,136 @@
+import daft
+from daft import Table, Identifier
+import pytest
+import uuid
+
+from deltacat.catalog import Catalog as DeltaCATCatalog
+from deltacat.catalog import CatalogProperties
+from deltacat.experimental.daft.daft_catalog import DaftCatalog
+import shutil
+import tempfile
+
+from deltacat.experimental.catalog.iceberg import impl as IcebergCatalog
+from deltacat.experimental.catalog.iceberg import IcebergCatalogConfig
+
+from pyiceberg.catalog import CatalogType
+
+
+class TestCatalogIntegration:
+    @classmethod
+    def setup_method(cls):
+        cls.tmpdir = tempfile.mkdtemp()
+
+    @classmethod
+    def teardown_method(cls):
+        shutil.rmtree(cls.tmpdir)
+
+    def test_create_table(self):
+        """Demonstrate DeltaCAT-Daft integration."""
+        # Create a DeltaCAT catalog
+        catalog_props = CatalogProperties(root=self.tmpdir)
+        dc_catalog = DeltaCATCatalog(catalog_props)
+
+        # Use a random catalog name to prevent namespacing conflicts with other tests
+        # Convert the DeltaCAT catalog to a Daft catalog
+        catalog_name = f"deltacat_{uuid.uuid4().hex[:8]}"
+
+        daft_catalog = DaftCatalog(catalog=dc_catalog, name=catalog_name)
+
+        # Register the catalog with Daft's catalog system
+        daft.attach_catalog(daft_catalog, catalog_name)
+
+        # Create a sample DataFrame
+        df = daft.from_pydict({"id": [1, 2, 3], "value": ["a", "b", "c"]})
+        # Create then get table
+        daft_catalog.create_table(Identifier("example_table"), df)
+        table: Table = daft_catalog.get_table(Identifier("example_table"))
+        assert table.name == "example_table"
+
+    def test_get_table(self):
+        """Test getting a table from the DeltaCAT-Daft catalog."""
+        # Create a DeltaCAT catalog using the existing tmpdir
+        catalog_props = CatalogProperties(root=self.tmpdir)
+        dc_catalog = DeltaCATCatalog(catalog_props)
+
+        # Convert to DaftCatalog and attach to Daft
+        catalog_name = f"deltacat_{uuid.uuid4().hex[:8]}"
+        daft_catalog = DaftCatalog(dc_catalog, catalog_name)
+        daft.attach_catalog(daft_catalog, catalog_name)
+
+        # Create a sample DataFrame and table
+        df = daft.from_pydict({"id": [1, 2, 3], "value": ["a", "b", "c"]})
+        table_name = "test_get_table"
+        daft_catalog.create_table(Identifier(table_name), df)
+
+        # Get the table using different forms of identifiers
+        table2 = daft_catalog.get_table(Identifier(table_name))
+        assert table2 is not None
+        assert table2.name == table_name
+
+        # 3. With namespace. DeltaCAT used the default namespace since it was not provided
+        table3 = daft_catalog.get_table(Identifier("default", table_name))
+        assert table3 is not None
+        assert table3.name == table_name
+
+        # Test non-existent table raises an appropriate error
+        with pytest.raises(ValueError, match="Table nonexistent_table not found"):
+            daft_catalog.get_table(Identifier("nonexistent_table"))
+
+
+class TestIcebergCatalogIntegration:
+    @classmethod
+    def setup_method(cls):
+        cls.tmpdir = tempfile.mkdtemp()
+
+    @classmethod
+    def teardown_method(cls):
+        shutil.rmtree(cls.tmpdir)
+
+    def test_iceberg_catalog_integration(self):
+        # Create a unique warehouse path for this test
+        warehouse_path = self.tmpdir
+
+        # Configure an Iceberg catalog with the warehouse path
+        config = IcebergCatalogConfig(
+            type=CatalogType.SQL,
+            properties={
+                "warehouse": warehouse_path,
+                "uri": f"sqlite:////{warehouse_path}/sql-catalog.db",
+            },
+        )
+        dc_catalog = IcebergCatalog.from_config(config)
+
+        # Convert the DeltaCAT catalog to a Daft catalog
+        catalog_name = f"deltacat_iceberg_{uuid.uuid4().hex[:8]}"
+        daft_catalog = DaftCatalog(dc_catalog, catalog_name)
+        daft.attach_catalog(daft_catalog, catalog_name)
+
+        # Create a sample DataFrame
+        df = daft.from_pydict({"id": [1, 2, 3], "value": ["a", "b", "c"]})
+
+        # Create a table with the Daft catalog
+        table_name = "example_table"
+        namespace = "example_namespace"
+        daft_catalog.create_table(Identifier(namespace, table_name), df)
+
+        # Query that Iceberg table exists using PyIceberg
+        iceberg_catalog = dc_catalog.inner
+
+        # Verify the table exists in the Iceberg catalog
+        tables = iceberg_catalog.list_tables(namespace)
+
+        assert any(
+            t[0] == namespace and t[1] == table_name for t in tables
+        ), f"Table {table_name} not found in Iceberg catalog"
+
+        # Load the table from Iceberg catalog and verify its properties
+        iceberg_table = iceberg_catalog.load_table(f"{namespace}.{table_name}")
+
+        # Check that the schema matches our DataFrame
+        schema = iceberg_table.schema()
+        assert (
+            schema.find_field("id") is not None
+        ), "Field 'id' not fcound in table schema"
+        assert (
+            schema.find_field("value") is not None
+        ), "Field 'value' not found in table schema"

deltacat/tests/{storage → experimental/storage}/rivulet/conftest.py

@@ -3,9 +3,9 @@ import io
 import pytest
 from faker import Faker
 
-from deltacat.storage.rivulet.schema.datatype import Datatype
-from deltacat.storage.rivulet.mvp.Table import MvpTable
-from deltacat.storage.rivulet.schema.schema import Schema
+from deltacat.experimental.storage.rivulet.schema.datatype import Datatype
+from deltacat.experimental.storage.rivulet.mvp.Table import MvpTable
+from deltacat.experimental.storage.rivulet.schema.schema import Schema
 import random
 import string
 from PIL import Image