Improve test coverage

Author: ghanse

tests/test_constraints.py

@@ -60,6 +60,10 @@ def test_simple_constraints2(self, generationSpec1):
         rowCount = testDataDF.count()
         assert rowCount == 100
 
+    def test_sql_expr_requires_non_empty_expression(self):
+        with pytest.raises(ValueError, match="Expression must be a valid non-empty SQL string"):
+            SqlExpr("")
+
     def test_multiple_constraints(self, generationSpec1):
         testDataSpec = generationSpec1.withConstraints([SqlExpr("id < 100"), SqlExpr("id > 0")])
 

tests/test_quick_tests.py

@@ -465,37 +465,55 @@ def test_empty_range(self):
         assert empty_range.isEmpty()
 
     def test_nrange_legacy_min_and_minvalue_conflict(self):
-        """Ensure conflicting legacy 'min' and 'minValue' arguments raise a clear error."""
         with pytest.raises(ValueError, match="Only one of 'minValue' and legacy 'min' may be specified"):
             NRange(minValue=0.0, min=1.0)
 
     def test_nrange_legacy_min_must_be_numeric(self):
-        """Ensure legacy 'min' argument must be numeric."""
         with pytest.raises(ValueError, match=r"Legacy 'min' argument must be an integer or float\."):
             NRange(min="not-a-number")
 
+    def test_nrange_legacy_max_and_maxvalue_conflict(self):
+        with pytest.raises(ValueError, match="Only one of 'maxValue' and legacy 'max' may be specified"):
+            NRange(maxValue=10.0, max=11.0)
+
+    def test_nrange_legacy_max_must_be_numeric(self):
+        with pytest.raises(ValueError, match=r"Legacy 'max' argument must be an integer or float\."):
+            NRange(max="not-a-number")
+
     def test_nrange_unexpected_kwargs_error_message(self):
-        """Ensure unexpected keyword arguments produce a helpful error."""
         with pytest.raises(ValueError, match=r"Unexpected keyword arguments for NRange: .*"):
             NRange(foo=1)
 
     def test_nrange_maxvalue_and_until_conflict(self):
-        """Ensure conflicting 'maxValue' and 'until' arguments raise a clear error."""
         with pytest.raises(ValueError, match="Only one of 'maxValue' or 'until' may be specified."):
             NRange(maxValue=10, until=20)
 
     def test_nrange_discrete_range_requires_min_max_step(self):
-        """Ensure getDiscreteRange validates required attributes."""
         rng = NRange(minValue=0.0, maxValue=10.0)
         with pytest.raises(ValueError, match="Range must have 'minValue', 'maxValue', and 'step' defined\\."):
             _ = rng.getDiscreteRange()
 
     def test_nrange_discrete_range_step_must_be_non_zero(self):
-        """Ensure getDiscreteRange validates non-zero step."""
         rng = NRange(minValue=0.0, maxValue=10.0, step=0)
         with pytest.raises(ValueError, match="Parameter 'step' must be non-zero when computing discrete range\\."):
             _ = rng.getDiscreteRange()
 
+    def test_nrange_adjust_for_byte_type_maxvalue_out_of_range(self):
+        rng = NRange(maxValue=300)  # above allowed ByteType max of 256
+        with pytest.raises(
+            ValueError,
+            match=r"`maxValue` must be within the valid range \(0 - 256\) for ByteType\.",
+        ):
+            rng.adjustForColumnDatatype(ByteType())
+
+    def test_nrange_get_continuous_range_requires_min_and_max(self):
+        rng = NRange(minValue=None, maxValue=10.0)
+        with pytest.raises(
+            ValueError,
+            match=r"Range must have 'minValue' and 'maxValue' defined\.",
+        ):
+            _ = rng.getContinuousRange()
+
     def test_reversed_ranges(self):
         testDataSpec = (
             dg.DataGenerator(sparkSession=spark, name="ranged_data", rows=100000, partitions=4)
@@ -561,8 +579,6 @@ def test_date_time_ranges(self):
         rowCount = rangedDF.count()
         assert rowCount == 100000
 
-        # TODO: add additional validation statement
-
     @pytest.mark.parametrize("asHtml", [True, False])
     def test_script_table(self, asHtml):
         testDataSpec = (

tests/test_utils.py

@@ -2,6 +2,8 @@
 from datetime import timedelta
 
 import pytest
+from pyspark.sql import Column
+from pyspark.sql.functions import current_date
 
 from dbldatagen import (
     ensure,
@@ -18,6 +20,8 @@
     system_time_millis,
 )
 
+from dbldatagen.utils import ensure_column
+
 spark = SparkSingleton.getLocalInstance("unit tests")
 
 
@@ -225,3 +229,8 @@ def test_topological_sort_cycle_error_message(self):
         deps = [("a", {"b"}), ("b", {"a"})]
         with pytest.raises(ValueError, match="cyclic or missing dependency detected"):
             topologicalSort(deps)
+
+    @pytest.mark.parametrize("col", ["col1", current_date()])
+    def test_ensure_column(self, col):
+        ensured = ensure_column(col)
+        assert isinstance(ensured, Column)