updates tests for coverage reasons

Author: chalmerlowe

db_dtypes/__init__.py

@@ -21,15 +21,14 @@
 import warnings
 
 import numpy
-import packaging.version
 import pandas
 import pandas.api.extensions
 from pandas.errors import OutOfBoundsDatetime
 import pyarrow
 import pyarrow.compute
 
 from db_dtypes import core
-from db_dtypes.version import __version__
+from db_dtypes.json import JSONArray, JSONDtype, JSONArrowType  # noqa: F401
 
 from . import _versions_helpers
 
@@ -47,15 +46,6 @@
 _NP_BOX_DTYPE = "datetime64[us]"
 
 
-# To use JSONArray and JSONDtype, you'll need Pandas 1.5.0 or later. With the removal
-# of Python 3.7 compatibility, the minimum Pandas version will be updated to 1.5.0.
-if packaging.version.Version(pandas.__version__) >= packaging.version.Version("1.5.0"):
-    from db_dtypes.json import JSONArray, JSONArrowType, JSONDtype
-else:
-    JSONArray = None
-    JSONDtype = None
-
-
 @pandas.api.extensions.register_extension_dtype
 class TimeDtype(core.BaseDatetimeDtype):
     """
@@ -347,6 +337,22 @@ def __sub__(self, other):
         return super().__sub__(other)
 
 
+def _determine_all(json_array_type, json_dtype_type):
+    """Determines the list for __all__ based on JSON type availability."""
+    base_all = [
+        "__version__",
+        "DateArray",
+        "DateDtype",
+        "TimeArray",
+        "TimeDtype",
+    ]
+    # Check if both JSON types are available (truthy)
+    if json_array_type and json_dtype_type:
+        return base_all + ["JSONDtype", "JSONArray", "JSONArrowType"]
+    else:
+        return base_all
+
+
 def _check_python_version():
     """Checks the runtime Python version and issues a warning if needed."""
     sys_major, sys_minor, sys_micro = _versions_helpers.extract_runtime_version()
@@ -364,23 +370,4 @@ def _check_python_version():
 
 _check_python_version()
 
-
-if not JSONArray or not JSONDtype:
-    __all__ = [
-        "__version__",
-        "DateArray",
-        "DateDtype",
-        "TimeArray",
-        "TimeDtype",
-    ]
-else:
-    __all__ = [
-        "__version__",
-        "DateArray",
-        "DateDtype",
-        "JSONDtype",
-        "JSONArray",
-        "JSONArrowType",
-        "TimeArray",
-        "TimeDtype",
-    ]
+__all__ = _determine_all(JSONArray, JSONDtype)

tests/unit/test__init__.py

@@ -83,3 +83,62 @@ def test_check_python_version_does_not_warn_on_supported(mock_version_tuple):
 
         # Assert that warnings.warn was NOT called
         mock_warn_call.assert_not_called()
+
+
+def test_determine_all_includes_json_when_available():
+    """
+    Test that _determine_all includes JSON types when both are truthy.
+    """
+
+    from db_dtypes import _determine_all
+
+    # Simulate available types (can be any truthy object)
+    mock_json_array = object()
+    mock_json_dtype = object()
+
+    result = _determine_all(mock_json_array, mock_json_dtype)
+
+    expected_all = [
+        "__version__",
+        "DateArray",
+        "DateDtype",
+        "TimeArray",
+        "TimeDtype",
+        "JSONDtype",
+        "JSONArray",
+        "JSONArrowType",
+    ]
+    assert set(result) == set(expected_all)
+    assert "JSONDtype" in result
+    assert "JSONArray" in result
+    assert "JSONArrowType" in result
+
+
+@pytest.mark.parametrize(
+    "mock_array, mock_dtype",
+    [
+        (None, object()),  # JSONArray is None
+        (object(), None),  # JSONDtype is None
+        (None, None),  # Both are None
+    ],
+)
+def test_determine_all_excludes_json_when_unavailable(mock_array, mock_dtype):
+    """
+    Test that _determine_all excludes JSON types if either is falsy.
+    """
+
+    from db_dtypes import _determine_all
+
+    result = _determine_all(mock_array, mock_dtype)
+
+    expected_all = [
+        "__version__",
+        "DateArray",
+        "DateDtype",
+        "TimeArray",
+        "TimeDtype",
+    ]
+    assert set(result) == set(expected_all)
+    assert "JSONDtype" not in result
+    assert "JSONArray" not in result
+    assert "JSONArrowType" not in result

tests/unit/test_json.py

@@ -21,6 +21,7 @@
 import pytest
 
 import db_dtypes
+import db_dtypes.json
 
 # Check for minimum Pandas version.
 pytest.importorskip("pandas", minversion="1.5.0")
@@ -245,27 +246,45 @@ def cleanup_json_module_for_reload():
         # Explicitly register just in case it wasn't, or was cleaned up elsewhere.
         # This might raise ArrowKeyError itself if already registered, which is fine here.
         pa.register_extension_type(db_dtypes.json.JSONArrowType())
+
     except pa.ArrowKeyError:
         pass  # Already registered is the state we want before the test runs
 
     # Remove the module from sys.modules so importlib.reload re-executes it
-    if json_module_name in sys.modules:  # COVERAGE FAIL: 252->255
+    if json_module_name in sys.modules:
         del sys.modules[json_module_name]
 
     yield  # Run the test that uses this fixture
 
     # Cleanup: Put the original module back if it existed
     # This helps isolate from other tests that might import db_dtypes.json
-    if original_module:  # COVERAGE FAIL: 259-261
+    if original_module:
         sys.modules[json_module_name] = original_module
-    elif json_module_name in sys.modules:  # COVERAGE FAIL: 261->exit
+    elif json_module_name in sys.modules:
         # If the test re-imported it but it wasn't there originally, remove it
         del sys.modules[json_module_name]
 
     # Note: PyArrow doesn't have a public API to unregister types easily,
     # thus we are using the testing pattern of module isolation/reloading.
 
 
+# Test specifically for the fixture's pre-yield removal logic
+def test_fixture_removes_module_if_present(cleanup_json_module_for_reload):
+    """
+    Tests that the cleanup_json_module_for_reload fixture removes
+    db_dtypes.json from sys.modules before yielding to the test.
+    This specifically targets the 'if json_module_name in sys.modules:' block.
+    """
+    # This test runs *after* the fixture's `yield`.
+    # The fixture should have removed the module if it was present.
+
+    json_module_name = "db_dtypes.json"
+
+    assert (
+        json_module_name not in sys.modules
+    ), f"The fixture cleanup_json_module_for_reload should have removed {json_module_name}"
+
+
 def test_json_arrow_type_reregistration_is_handled(cleanup_json_module_for_reload):
     """
     Verify that attempting to re-register JSONArrowType via module reload
@@ -276,17 +295,6 @@ def test_json_arrow_type_reregistration_is_handled(cleanup_json_module_for_reloa
     # forces Python to execute the module's top-level code again.
     # This includes the pa.register_extension_type call.
 
-    assert "db_dtypes.json" not in sys.modules
-    try:
-        import db_dtypes.json  # noqa: F401
-
-        assert (
-            True
-        ), "Module re-import completed without error, except block likely worked."
-
-    except pa.ArrowKeyError:  # COVERAGE FAIL: 287-294
-        # If this exception escapes, the except block in db_dtypes/json.py failed.
-        pytest.fail(
-            "pa.ArrowKeyError was raised during module reload, "
-            "indicating the except block failed."
-        )
+    import db_dtypes.json  # noqa: F401
+
+    assert True, "Module re-import completed without error, except block likely worked."