Refactor coverage configuration and enhance CLI functionality

- Remove obsolete .coveragerc file and integrate coverage settings into pyproject.toml
- Update CLI main function to accept command line arguments and improve docstring
- Add tests for CLI functionality to ensure proper argument handling
- Enhance exception handling in planetarypy.exceptions with additional docstrings
- Introduce new tests for PDS index configuration and Spicer classes to improve test coverage

Author: michaelaye

.coveragerc

@@ -49,10 +49,10 @@ spice = [
 dev = [
     "pytest",
     "pytest-cov",
+    "pytest-xdist",  # For parallel test execution
     "build",
     "twine",
     "pip-tools",
-    "make",
 ]
 
 [project.scripts]
@@ -72,8 +72,23 @@ include = [
     "HISTORY.rst",
 ]
 
-[tool.pytest]
+[tool.pytest.ini_options]
 testpaths = ["tests"]
+addopts = "-xvs --import-mode=importlib --cov=planetarypy --cov-report=term --cov-report=html -n auto"
+
+[tool.coverage.run]
+source = ["planetarypy"]
+omit = ["*/tests/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "pass",
+    "raise ImportError",
+]
 
 [tool.flake8]
 exclude = ["docs"]

pyproject.toml

@@ -1,17 +1,24 @@
 """Console script for planetarypy."""
+
 import argparse
 import sys
 
 
-def main():
-    """Console script for planetarypy."""
+def main(args=None):
+    """Console script for planetarypy.
+
+    Args:
+        args: List of command line arguments. If None, sys.argv[1:] is used.
+
+    Returns:
+        int: Return code
+    """
     parser = argparse.ArgumentParser()
-    parser.add_argument('_', nargs='*')
-    args = parser.parse_args()
+    parser.add_argument("_", nargs="*")
+    args = parser.parse_args(args)
 
     print("Arguments: " + str(args._))
-    print("Replace this message by putting your code into "
-          "planetarypy.cli.main")
+    print("Replace this message by putting your code into planetarypy.cli.main")
     return 0
 
 

src/planetarypy/cli.py

@@ -1,11 +1,21 @@
 """PlanetarPy exceptions."""
 
-__all__ = ['Error', 'SomethingNotSetError', 'ProjectionNotSetError', 'GeoTransformNotSetError', 'SpicerError',
-           'SPointNotSetError', 'ObserverNotSetError', 'SpiceError', 'MissingParameterError']
+__all__ = [
+    "Error",
+    "SomethingNotSetError",
+    "ProjectionNotSetError",
+    "GeoTransformNotSetError",
+    "SpicerError",
+    "SPointNotSetError",
+    "ObserverNotSetError",
+    "SpiceError",
+    "MissingParameterError",
+]
 
 
 class Error(Exception):
     """Base class for exceptions in this module."""
+
     pass
 
 
@@ -26,20 +36,26 @@ def __str__(self):
 
 
 class ProjectionNotSetError(SomethingNotSetError):
-    what = "Projection"
+    """Exception raised when a projection is not set."""
+
+    def __init__(self, where):
+        super().__init__(where, "Projection")
 
 
 class GeoTransformNotSetError(SomethingNotSetError):
-    what = "GeoTransform"
+    """Exception raised when a GeoTransform is not set."""
+
+    def __init__(self, where):
+        super().__init__(where, "GeoTransform")
 
 
 class SpicerError(Exception):
     """Base class for exceptions in this module."""
+
     pass
 
 
 class SPointNotSetError(SpicerError):
-
     def __init__(self, txt):
         self.txt = txt
 
@@ -50,14 +66,12 @@ def __str__(self):
 
 
 class ObserverNotSetError(SpicerError):
-
     def __str__(self):
         return """The method you called requires an observer to be set.
                   This operation had no effect."""
 
 
 class SpiceError(SpicerError):
-
     def __init__(self, function):
         self.function = function
 
@@ -66,7 +80,6 @@ def __str__(self):
 
 
 class MissingParameterError(SpicerError):
-
     def __init__(self, txt):
         self.txt = txt
 

src/planetarypy/exceptions.py

@@ -4,6 +4,12 @@
 parsing index files, and converting them to convenient data structures.
 """
 
+# Temporarily suppress PendingDeprecationWarning from pvl.collections.Units
+# This can be removed once pvl version > 1.3.2 is used
+import warnings
+
+warnings.filterwarnings("ignore", category=PendingDeprecationWarning, module="pvl")
+
 __all__ = [
     "PVLColumn",
     "IndexLabel",
@@ -13,7 +19,6 @@
     "find_mixed_type_cols",
 ]
 
-import warnings
 from typing import Union
 
 import pandas as pd

src/planetarypy/pds/index_labels.py

@@ -0,0 +1,20 @@
+import pytest
+from planetarypy.cli import main
+
+def test_main_help(capsys):
+    """Test the CLI help output."""
+    with pytest.raises(SystemExit) as pytest_wrapped_e:
+        main(['-h'])
+    captured = capsys.readouterr()
+    assert 'usage:' in captured.out
+    assert pytest_wrapped_e.value.code == 0
+
+def test_main_default():
+    """Test the CLI with default arguments."""
+    result = main([])
+    assert result == 0
+
+def test_main_with_args():
+    """Test the CLI with some arguments."""
+    result = main(['arg1', 'arg2'])
+    assert result == 0

tests/test_cli.py

@@ -1,139 +1,61 @@
-"""Tests for config module."""
+"""Tests for basic configuration module."""
 
-import pytest
-from pathlib import Path
 import tempfile
-from planetarypy.config import config, Config, reset_non_urls
+from pathlib import Path
+
+from planetarypy.config import Config, config
 
 
 def test_config_loading():
+    """Test that the config is properly loaded."""
     assert isinstance(config.d, dict)
-    assert "missions" in config.d
-
-
-def test_config_missions():
-    assert "cassini" in config["missions"]
-    assert "iss" in config["missions"]["cassini"]
+    assert isinstance(config.storage_root, Path)
 
 
 def test_config_getitem():
-    # Test dictionary-like access
-    assert config["missions"] is not None
-    assert isinstance(config["missions"], dict)
+    """Test dictionary-like access to config values."""
+    result = config["storage_root"]
+    assert isinstance(result, str)
+    assert len(result) > 0
 
 
 def test_config_missing_key():
-    # Test that missing keys return empty string
+    """Test that missing keys return empty string."""
     assert config.get_value("nonexistent.key") == ""
 
 
-def test_config_nested_access():
-    cassini_config = config["missions"]["cassini"]
-    assert isinstance(cassini_config, dict)
-    assert "iss" in cassini_config
-
-
 def test_config_get_value():
+    """Test retrieving values with get_value method."""
     # Test with valid keys
-    assert config.get_value("cassini.iss") != ""
+    assert config.get_value("storage_root") != ""
     # Test with invalid key
     assert config.get_value("nonexistent.key") == ""
-    # Test with full path
-    assert config.get_value("missions.cassini.iss") != ""
 
 
 def test_config_set_value():
+    """Test setting values in the config."""
     with tempfile.TemporaryDirectory() as tmpdir:
         temp_config = Config(Path(tmpdir) / "test_config.toml")
-        
-        # Initialize the full path structure
-        temp_config.tomldoc["missions"] = {"test": {"instrument": {}}}
-        temp_config.save()
 
         # Test setting a new value
-        temp_config.set_value("missions.test.instrument.value", "test_value")
-        assert temp_config.get_value("test.instrument.value") == "test_value"
+        temp_config.set_value("test.nested.value", "test_value")
+        assert temp_config.get_value("test.nested.value") == "test_value"
 
         # Test overwriting an existing value
-        temp_config.set_value("missions.test.instrument.value", "new_value")
-        assert temp_config.get_value("test.instrument.value") == "new_value"
-
-
-def test_config_list_instruments():
-    instruments = config.list_instruments("cassini")
-    assert isinstance(instruments, list)
-    assert "iss" in instruments
-
-
-def test_config_get_datalevels():
-    datalevels = config.get_datalevels("cassini.iss")
-    assert isinstance(datalevels, list)
-
-
-def test_config_list_indexes():
-    indexes = config.list_indexes("cassini.iss")
-    assert isinstance(indexes, list)
-
-    # Test with missions prefix
-    indexes = config.list_indexes("missions.cassini.iss")
-    assert isinstance(indexes, list)
+        temp_config.set_value("test.nested.value", "new_value")
+        assert temp_config.get_value("test.nested.value") == "new_value"
 
 
 def test_config_storage_root():
+    """Test that storage_root is properly configured."""
     assert config.storage_root.is_dir()
     assert isinstance(config.storage_root, Path)
 
 
-
-def test_reset_non_urls():
-    test_dict = {
-        "url": "http://example.com",  # Should be preserved (key contains 'url')
-        "regular_key": "value",       # Should be reset
-        "nested": {
-            "download_url": "http://test.com",  # Should be preserved
-            "data_field": "other_value"         # Should be reset
-        },
-    }
-
-    # Create a deep copy to avoid modifying the original
-    import copy
-    test_dict_copy = copy.deepcopy(test_dict)
-    reset_dict = reset_non_urls(test_dict_copy, "")
-    
-    # Check that URL fields are preserved
-    assert reset_dict["url"] == "http://example.com"
-    assert reset_dict["nested"]["download_url"] == "http://test.com"
-    
-    # Check that non-URL fields are reset
-    assert reset_dict["regular_key"] == ""
-    assert reset_dict["nested"]["data_field"] == ""
-    
-    # Verify original dict wasn't modified
-    assert test_dict["regular_key"] == "value"
-    assert test_dict["nested"]["data_field"] == "other_value"
-
-
 def test_config_custom_path():
+    """Test creating a config with custom path."""
     with tempfile.TemporaryDirectory() as tmpdir:
         custom_path = Path(tmpdir) / "custom_config.toml"
         custom_config = Config(custom_path)
         assert custom_config.path == custom_path
         assert custom_path.exists()
-
-
-def test_config_missions_property():
-    missions = config.missions
-    assert isinstance(missions, list)
-    assert "cassini" in missions
-
-
-@pytest.mark.parametrize(
-    "mission,expected_instrument",
-    [
-        ("cassini", "iss"),
-        # Add more mission/instrument pairs as needed
-    ],
-)
-def test_config_instruments_for_mission(mission, expected_instrument):
-    instruments = config.list_instruments(mission)
-    assert expected_instrument in instruments

tests/test_config.py

@@ -0,0 +1,36 @@
+import pytest
+from planetarypy.exceptions import (
+    Error, SomethingNotSetError, ProjectionNotSetError,
+    GeoTransformNotSetError, SpicerError, SPointNotSetError,
+    ObserverNotSetError, SpiceError, MissingParameterError
+)
+
+def test_base_error():
+    """Test base Error class."""
+    with pytest.raises(Error):
+        raise Error()
+
+def test_something_not_set_error():
+    """Test SomethingNotSetError formatting."""
+    error = SomethingNotSetError("location", "parameter")
+    assert str(error) == "parameter not set in location"
+
+def test_projection_not_set_error():
+    """Test ProjectionNotSetError."""
+    error = ProjectionNotSetError("location")
+    assert "Projection" in str(error)
+
+def test_spoint_not_set_error():
+    """Test SPointNotSetError."""
+    error = SPointNotSetError("test message")
+    assert "spoint" in str(error).lower()
+
+def test_missing_parameter_error():
+    """Test MissingParameterError."""
+    error = MissingParameterError("required_param")
+    assert "required_param" in str(error)
+
+def test_geotransform_not_set_error():
+    """Test GeoTransformNotSetError."""
+    error = GeoTransformNotSetError("location")
+    assert "GeoTransform" in str(error)