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

deltacat/tests/catalog/model/test_table_definition.py

@@ -0,0 +1,16 @@
+import unittest
+from unittest.mock import MagicMock
+
+from deltacat import TableDefinition
+
+
+class TestTableDefinition(unittest.TestCase):
+    def test_create_scan_plan_not_initialized(self):
+        mock_table = MagicMock()
+        mock_table.table_name = "mock_table_name"
+        mock_table.namespace = "mock_namespace"
+
+        table_definition = TableDefinition({"table": mock_table})
+        with self.assertRaises(RuntimeError) as context:
+            table_definition.create_scan_plan()
+        self.assertIn("ScanPlanner is not initialized", str(context.exception))

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,
+    init_local,
     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,75 +26,54 @@ 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.
+def reset_catalogs():
+    clear_catalogs()
 
-    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
 
-
-class TestCatalog(unittest.TestCase):
+class TestCatalog:
     """Tests for the Catalog class itself, without Ray initialization."""
 
     def test_catalog_constructor(self):
         """Test that the Catalog constructor correctly initializes with the given implementation."""
         catalog = Catalog(impl=MockCatalogImpl)
 
-        self.assertEqual(catalog.impl, MockCatalogImpl)
+        assert catalog.impl == MockCatalogImpl
 
         # Check that inner state was correctly initialized
         # This just asserts that kwargs were plumbed through from Catalog constructor
-        self.assertTrue(catalog.inner["initialized"])
-        self.assertEqual(catalog.inner["args"], ())
-        self.assertEqual(catalog.inner["kwargs"], {})
+        assert catalog.inner["initialized"]
+        assert catalog.inner["config"] is None
+        assert catalog.inner["args"] == ()
+        assert catalog.inner["kwargs"] == {}
 
     def test_iceberg_factory_method(self):
         """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
-            self.assertEqual(catalog.impl, mock_iceberg_catalog)
+            assert catalog.impl == mock_iceberg_catalog
             # Check that the inner state is set to the output of initialize
-            self.assertEqual(catalog.inner, {"iceberg": True})
+            assert catalog.inner == {"iceberg": True}
 
 
 class TestCatalogsIntegration:
@@ -109,8 +89,7 @@ class TestCatalogsIntegration:
         catalog = Catalog(impl=MockCatalogImpl)
         init(
             catalog,
-            ray_init_args={"ignore_reinit_error": True},
-            **{"force_reinitialize": True},
+            force=True,
         )
 
     @classmethod
@@ -118,17 +97,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 +112,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 +120,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 +133,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 +144,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 +152,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 +169,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 +192,76 @@ 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_init_local(self, reset_catalogs):
+        """Test that init_local() creates a default local catalog."""
+        # Initialize with default local catalog
+        init_local(force=True)
+
+        assert is_initialized()
+
+        # Should be able to get the default catalog
+        default_catalog = get_catalog()
+        assert default_catalog is not None
+
+        # The default catalog should be accessible by name "default"
+        named_catalog = get_catalog("default")
+        assert named_catalog is not None
+        assert named_catalog.impl.__name__ == "deltacat.catalog.main.impl"
+
+    def test_init_local_with_path(self, reset_catalogs):
+        """Test that init_local(path) creates a default local catalog with specified path."""
+        # Create a temporary directory for the test
+        custom_path = tempfile.mkdtemp()
+
+        try:
+            # Initialize with custom path
+            init_local(path=custom_path, force=True)
+
+            assert is_initialized()
+
+            # Should be able to get the default catalog
+            default_catalog = get_catalog()
+            assert default_catalog is not None
+
+            # The default catalog should be accessible by name "default"
+            named_catalog = get_catalog("default")
+            assert named_catalog is not None
+            assert named_catalog.impl.__name__ == "deltacat.catalog.main.impl"
+
+            # Verify the catalog is using the custom path
+            catalog_properties = named_catalog.inner
+            assert catalog_properties.root == custom_path
+
+        finally:
+            # Clean up the temporary directory
+            if os.path.exists(custom_path):
+                shutil.rmtree(custom_path)
+
+    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 +270,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 +282,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 +298,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 +308,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)