deltacat 1.1.38__py3-none-any.whl → 2.0.0__py3-none-any.whl

deltacat/tests/storage/model/test_shard.py

@@ -0,0 +1,24 @@
+import pytest
+
+from deltacat.storage.model.shard import ShardingStrategy
+
+
+def test_sharding_strategy_from_string_range():
+    """
+    Tests that from_string('range') returns an instance of RangeShardingStrategy.
+    """
+    from deltacat.experimental.storage.rivulet.shard.range_shard import (
+        RangeShardingStrategy,
+    )
+
+    strategy = ShardingStrategy.from_string("range")
+    assert isinstance(strategy, RangeShardingStrategy)
+
+
+def test_sharding_strategy_from_string_invalid():
+    """
+    Tests that from_string(...) raises ValueError for an unknown strategy string.
+    """
+    with pytest.raises(ValueError) as exc_info:
+        ShardingStrategy.from_string("unknown_strategy")
+    assert "Unsupported sharding strategy type: unknown_strategy" in str(exc_info.value)

deltacat/tests/storage/model/test_sort_scheme.py

@@ -0,0 +1,90 @@
+import pytest
+
+from deltacat.storage import (
+    SortKey,
+    SortScheme,
+    SortOrder,
+    NullOrder,
+)
+
+
+def test_sort_scheme_validates_empty_keys():
+    # When creating a sort scheme with empty keys list
+    with pytest.raises(ValueError, match="Sort scheme cannot have empty keys list"):
+        SortScheme.of(
+            keys=[],
+            name="test_sort_scheme",
+            scheme_id="test_sort_scheme_id",
+        )
+
+
+def test_sort_scheme_validates_duplicate_keys():
+    # When creating a sort scheme with duplicate keys
+    with pytest.raises(ValueError, match="Duplicate sort key found: col1"):
+        SortScheme.of(
+            keys=[
+                SortKey.of(
+                    key=["col1"],
+                    sort_order=SortOrder.ASCENDING,
+                    null_order=NullOrder.AT_END,
+                ),
+                SortKey.of(
+                    key=["col1"],  # Duplicate key
+                    sort_order=SortOrder.DESCENDING,
+                    null_order=NullOrder.AT_START,
+                ),
+            ],
+            name="test_sort_scheme",
+            scheme_id="test_sort_scheme_id",
+        )
+
+
+def test_sort_scheme_allows_valid_keys():
+    # When creating a sort scheme with valid keys
+    sort_scheme = SortScheme.of(
+        keys=[
+            SortKey.of(
+                key=["col1"],
+                sort_order=SortOrder.ASCENDING,
+                null_order=NullOrder.AT_END,
+            ),
+            SortKey.of(
+                key=["col2"],
+                sort_order=SortOrder.DESCENDING,
+                null_order=NullOrder.AT_END,
+            ),
+        ],
+        name="test_sort_scheme",
+        scheme_id="test_sort_scheme_id",
+    )
+
+    # Then it should succeed
+    assert sort_scheme is not None
+    assert len(sort_scheme.keys) == 2
+    assert sort_scheme.name == "test_sort_scheme"
+    assert sort_scheme.id == "test_sort_scheme_id"
+
+
+def test_sort_scheme_validates_null_order_consistency():
+    # When creating a sort scheme with inconsistent null orders
+    with pytest.raises(
+        ValueError, match="All arrow sort keys must use the same null order"
+    ):
+        sort_scheme = SortScheme.of(
+            keys=[
+                SortKey.of(
+                    key=["col1"],
+                    sort_order=SortOrder.ASCENDING,
+                    null_order=NullOrder.AT_END,
+                ),
+                SortKey.of(
+                    key=["col2"],
+                    sort_order=SortOrder.DESCENDING,
+                    null_order=NullOrder.AT_START,  # Different null order
+                ),
+            ],
+            name="test_sort_scheme",
+            scheme_id="test_sort_scheme_id",
+        )
+        # Access arrow property to trigger validation
+        sort_scheme.arrow

deltacat/tests/storage/model/test_table_version.py

@@ -0,0 +1,110 @@
+import pytest
+
+from deltacat.constants import BYTES_PER_KIBIBYTE
+from deltacat.storage.model.table_version import TableVersion, TableVersionLocator
+
+
+@pytest.mark.parametrize(
+    "previous_version, expected_next_version",
+    [
+        (None, "1"),
+        ("v.1", "v.2"),
+        ("1", "2"),
+        ("1.0", "1.1"),
+        ("v.999", "v.1000"),
+    ],
+)
+def test_next_version(previous_version, expected_next_version):
+    new_version = TableVersion.next_version(previous_version)
+    assert isinstance(new_version, str)
+    assert new_version == expected_next_version
+
+
+@pytest.mark.parametrize(
+    "table_version, expected_parsed_version",
+    [
+        ("v.1", ("v.", 1)),
+        ("1", (None, 1)),
+        ("1.0", ("1.", 0)),
+        ("v.999", ("v.", 999)),
+    ],
+)
+def test_parse_version(table_version, expected_parsed_version):
+    prefix, version_number = TableVersion.parse_table_version(table_version)
+    if prefix is not None:
+        assert isinstance(prefix, str)
+    assert isinstance(version_number, int)
+    assert (prefix, version_number) == expected_parsed_version
+
+
+def test_version_validation_invalid():
+    with pytest.raises(ValueError):
+        TableVersionLocator.at(
+            namespace="test_namespace",
+            table_name="test_table",
+            table_version="invalid_version",
+        )
+
+
+def test_version_validation_valid_to_invalid():
+    valid_tv_locator = TableVersionLocator.at(
+        namespace="test_namespace",
+        table_name="test_table",
+        table_version="1",
+    )
+    assert valid_tv_locator.table_version == "1"
+    tv = TableVersion.of(
+        locator=valid_tv_locator,
+        schema=None,
+    )
+    assert tv.current_version_number() == 1
+    with pytest.raises(ValueError):
+        valid_tv_locator.table_version = "invalid_version"
+
+
+def test_version_validation_numeric_name():
+    valid_tv_locator = TableVersionLocator.at(
+        namespace="test_namespace",
+        table_name="test_table",
+        table_version="1.0",
+    )
+    assert valid_tv_locator.table_version == "1.0"
+    tv = TableVersion.of(
+        locator=valid_tv_locator,
+        schema=None,
+    )
+    assert tv.current_version_number() == 0
+
+
+def test_version_validation_truncate_leading_zeros():
+    valid_tv_locator = TableVersionLocator.at(
+        namespace="test_namespace",
+        table_name="test_table",
+        table_version="1.00002",
+    )
+    # ensure that leading 0's are truncated
+    assert valid_tv_locator.table_version == "1.2"
+    tv = TableVersion.of(
+        locator=valid_tv_locator,
+        schema=None,
+    )
+    assert tv.current_version_number() == 2
+
+
+def test_version_validation_version_id_length_limits():
+    # ensure that long version identifiers are accepted
+    long_tv_id = "a" * (BYTES_PER_KIBIBYTE - 2) + ".1"
+    valid_tv_locator = TableVersionLocator.at(
+        namespace="test_namespace",
+        table_name="test_table",
+        table_version=long_tv_id,
+    )
+    assert valid_tv_locator.table_version == long_tv_id
+    tv = TableVersion.of(
+        locator=valid_tv_locator,
+        schema=None,
+    )
+    assert tv.current_version_number() == 1
+    # ensure that an excessively long version identifier is rejected
+    with pytest.raises(ValueError):
+        valid_tv_locator.table_version = "0" * (BYTES_PER_KIBIBYTE + 1)