solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.0__py3-none-any.whl

tests/solar_activity/lisird/test_lisird_id.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+"""Test LISIRD_ID class.
+
+This module tests the LISIRD_ID class from solar_activity.lisird.lisird:
+- URL mapping and key validation
+- Valid and invalid key handling
+- URL construction for LISIRD endpoints
+"""
+
+import pytest
+from unittest.mock import Mock, patch
+
+from solarwindpy.solar_activity.lisird.lisird import LISIRD_ID
+
+
+class TestLISIRD_ID:
+    """Test the LISIRD_ID class for URL mapping and key validation."""
+
+    def test_valid_key_initialization(self):
+        """Test LISIRD_ID initialization with valid keys."""
+        valid_keys = ["Lalpha", "CaK", "f107-noaa", "f107-penticton", "MgII"]
+
+        for key in valid_keys:
+            lisird_id = LISIRD_ID(key)
+            assert lisird_id.key == key
+
+    def test_url_base_property(self):
+        """Test that _url_base returns the correct LISIRD base URL."""
+        lisird_id = LISIRD_ID("Lalpha")
+        expected_url_base = "http://lasp.colorado.edu/lisird/latis/dap/"
+        assert lisird_id._url_base == expected_url_base
+
+    def test_trans_url_mapping(self):
+        """Test the _trans_url property provides correct URL mappings."""
+        lisird_id = LISIRD_ID("Lalpha")
+        trans_url_dict = lisird_id._trans_url
+
+        expected_mappings = {
+            "Lalpha": "composite_lyman_alpha.jsond",
+            "CaK": "cak.jsond",
+            "f107-penticton": "penticton_radio_flux.jsond",
+            "f107-noaa": "noaa_radio_flux.jsond",
+            "MgII": "composite_mg_index.jsond",
+        }
+
+        for key, expected_filename in expected_mappings.items():
+            assert trans_url_dict[key] == expected_filename
+
+    def test_url_construction_valid_keys(self):
+        """Test URL construction for valid LISIRD keys."""
+        test_cases = [
+            (
+                "Lalpha",
+                "http://lasp.colorado.edu/lisird/latis/dap/composite_lyman_alpha.jsond",
+            ),
+            ("CaK", "http://lasp.colorado.edu/lisird/latis/dap/cak.jsond"),
+            (
+                "f107-noaa",
+                "http://lasp.colorado.edu/lisird/latis/dap/noaa_radio_flux.jsond",
+            ),
+            (
+                "f107-penticton",
+                "http://lasp.colorado.edu/lisird/latis/dap/penticton_radio_flux.jsond",
+            ),
+            (
+                "MgII",
+                "http://lasp.colorado.edu/lisird/latis/dap/composite_mg_index.jsond",
+            ),
+        ]
+
+        for key, expected_url in test_cases:
+            lisird_id = LISIRD_ID(key)
+            assert lisird_id.url == expected_url
+
+    def test_invalid_key_error_handling(self):
+        """Test that invalid keys raise appropriate errors."""
+        # Test behavior with key not in _trans_url mapping
+        invalid_key = "invalid_key_not_in_mapping"
+
+        # LISIRD_ID raises NotImplementedError during initialization for invalid keys
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID(invalid_key)
+
+    def test_inheritance_from_id_base_class(self):
+        """Test that LISIRD_ID inherits from ID base class."""
+        from solarwindpy.solar_activity.base import ID
+
+        lisird_id = LISIRD_ID("Lalpha")
+        assert isinstance(lisird_id, ID)
+
+        # Test that it has the expected inherited properties
+        assert hasattr(lisird_id, "key")
+        assert hasattr(lisird_id, "url")
+
+    def test_key_case_sensitivity(self):
+        """Test that keys are case-sensitive."""
+        # Valid key
+        valid_id = LISIRD_ID("Lalpha")
+        assert valid_id.key == "Lalpha"
+
+        # Case variations should be treated as different keys
+        # They may not have URL mappings and should raise NotImplementedError during init
+        case_variant_key = "lalpha"  # lowercase
+
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID(case_variant_key)
+
+    def test_url_property_consistency(self):
+        """Test that url property is consistent and repeatable."""
+        lisird_id = LISIRD_ID("Lalpha")
+        url1 = lisird_id.url
+        url2 = lisird_id.url
+
+        # URL should be consistent across multiple accesses
+        assert url1 == url2
+        assert url1 is not None
+        assert isinstance(url1, str)
+        assert url1.startswith("http://")
+
+    def test_all_mapped_keys_produce_valid_urls(self):
+        """Test that all keys in the mapping produce valid URL strings."""
+        # Get all mapped keys by creating an instance and accessing _trans_url
+        sample_id = LISIRD_ID("Lalpha")
+        all_mapped_keys = sample_id._trans_url.keys()
+
+        for key in all_mapped_keys:
+            lisird_id = LISIRD_ID(key)
+            url = lisird_id.url
+
+            # Basic URL validation
+            assert isinstance(url, str)
+            assert url.startswith("http://lasp.colorado.edu/lisird/latis/dap/")
+            assert url.endswith(".jsond")
+            assert len(url) > len(lisird_id._url_base)
+
+
+class TestLISIRD_IDEdgeCases:
+    """Test edge cases and error conditions for LISIRD_ID."""
+
+    def test_empty_key_handling(self):
+        """Test behavior with empty or None keys."""
+        # Empty string key should raise NotImplementedError during init
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID("")
+
+        # None key also raises NotImplementedError during init
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID(None)
+
+    def test_whitespace_key_handling(self):
+        """Test behavior with whitespace in keys."""
+        whitespace_key = " Lalpha "
+
+        # Should not match the valid mapping due to whitespace, raises during init
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID(whitespace_key)
+
+    def test_numeric_key_handling(self):
+        """Test behavior with numeric keys."""
+        # String numeric key should raise NotImplementedError during init
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID("123")
+
+        # Integer key also raises NotImplementedError during init
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID(123)
+
+    def test_special_characters_in_key(self):
+        """Test behavior with special characters in keys."""
+        special_key = "f107-special!@#$%"
+
+        # Should not match any valid mapping, raises during init
+        with pytest.raises(NotImplementedError, match="key unavailable"):
+            LISIRD_ID(special_key)
+
+    def test_url_construction_consistency(self):
+        """Test that URL construction is deterministic and correct."""
+        key = "MgII"
+        id1 = LISIRD_ID(key)
+        id2 = LISIRD_ID(key)
+
+        # Both instances should produce the same URL
+        assert id1.url == id2.url
+
+        # URL should match expected pattern
+        expected = id1._url_base + id1._trans_url[key]
+        assert id1.url == expected

tests/solar_activity/sunspot_number/__init__.py

@@ -0,0 +1 @@
+"""Tests for sunspot_number package."""

tests/solar_activity/sunspot_number/test_init.py

@@ -0,0 +1,399 @@
+#!/usr/bin/env python
+"""Test sunspot_number package initialization.
+
+This module tests the sunspot_number package __init__.py functionality:
+- Package structure and imports
+- Module accessibility
+- SIDC module integration
+- Import patterns and error handling
+- Namespace management
+"""
+
+import pytest
+import sys
+import importlib
+from unittest.mock import patch, Mock
+
+# Import patterns testing
+import solarwindpy.solar_activity.sunspot_number
+from solarwindpy.solar_activity import sunspot_number
+from solarwindpy.solar_activity.sunspot_number import sidc
+
+
+class TestSunspotNumberPackageStructure:
+    """Test the basic package structure and recognition."""
+
+    def test_package_recognition(self):
+        """Test that sunspot_number is recognized as a Python package."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should be a module (package)
+        assert hasattr(ssn_package, "__file__")
+        assert hasattr(ssn_package, "__path__")
+
+        # Package path should end with sunspot_number
+        assert str(ssn_package.__path__[0]).endswith("sunspot_number")
+
+    def test_init_file_presence(self):
+        """Test that __init__.py file exists and is valid Python."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should have a valid __file__ pointing to __init__.py
+        assert ssn_package.__file__.endswith("__init__.py")
+
+    def test_package_hierarchy(self):
+        """Test proper nesting within solar_activity parent package."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+        import solarwindpy.solar_activity as sa_package
+
+        # Should be accessible from parent package
+        assert hasattr(sa_package, "sunspot_number")
+        assert sa_package.sunspot_number is ssn_package
+
+    def test_package_docstring(self):
+        """Test that package has descriptive docstring."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        assert hasattr(ssn_package, "__doc__")
+        assert ssn_package.__doc__ is not None
+        assert len(ssn_package.__doc__.strip()) > 0
+        assert "sunspot" in ssn_package.__doc__.lower()
+
+
+class TestSIDCModuleImport:
+    """Test SIDC module import and accessibility."""
+
+    def test_sidc_module_import(self):
+        """Test that 'from .
+
+        import sidc' executes successfully.
+        """
+        # This test passes if the import in the setup doesn't raise an exception
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # sidc should be accessible as an attribute
+        assert hasattr(ssn_package, "sidc")
+
+    def test_sidc_module_accessibility(self):
+        """Test sidc module accessible after package import."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # sidc should be a module
+        import types
+
+        assert isinstance(ssn_package.sidc, types.ModuleType)
+
+        # Should have expected SIDC classes
+        assert hasattr(ssn_package.sidc, "SIDC")
+        assert hasattr(ssn_package.sidc, "SIDC_ID")
+        assert hasattr(ssn_package.sidc, "SIDCLoader")
+        assert hasattr(ssn_package.sidc, "SSNExtrema")
+
+    def test_relative_import_syntax(self):
+        """Test that relative import syntax works correctly."""
+        # The actual import is in the __init__.py file
+        # If we can import the package, the relative import worked
+        import solarwindpy.solar_activity.sunspot_number
+
+        # Should not raise ImportError
+        assert solarwindpy.solar_activity.sunspot_number is not None
+
+    def test_no_import_errors(self):
+        """Test that import statement doesn't raise ImportError."""
+        # Re-import to test for any import errors
+        try:
+            importlib.reload(solarwindpy.solar_activity.sunspot_number)
+        except ImportError:
+            pytest.fail("Package import raised ImportError")
+
+
+class TestImportPatterns:
+    """Test various import patterns for the package."""
+
+    def test_full_package_import(self):
+        """Test import solarwindpy.solar_activity.sunspot_number."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        assert ssn_package is not None
+        assert hasattr(ssn_package, "sidc")
+
+    def test_from_import(self):
+        """Test from solarwindpy.solar_activity import sunspot_number."""
+        from solarwindpy.solar_activity import sunspot_number as ssn_package
+
+        assert ssn_package is not None
+        assert hasattr(ssn_package, "sidc")
+
+    def test_submodule_import(self):
+        """Test from solarwindpy.solar_activity.sunspot_number import sidc."""
+        from solarwindpy.solar_activity.sunspot_number import sidc as sidc_module
+
+        assert sidc_module is not None
+        assert hasattr(sidc_module, "SIDC")
+
+    def test_aliased_imports(self):
+        """Test import with aliases works correctly."""
+        import solarwindpy.solar_activity.sunspot_number as ssn
+        from solarwindpy.solar_activity.sunspot_number import sidc as sidc_mod
+
+        assert ssn is not None
+        assert sidc_mod is not None
+        assert ssn.sidc is sidc_mod
+
+
+class TestNamespaceManagement:
+    """Test namespace management and symbol exposure."""
+
+    def test_sidc_exposure(self):
+        """Test SIDC module properly exposed through package."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should be able to access SIDC classes through package
+        assert hasattr(ssn_package.sidc, "SIDC")
+        assert callable(ssn_package.sidc.SIDC)
+
+    def test_no_namespace_pollution(self):
+        """Test no unnecessary namespace pollution."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should only have expected attributes
+        expected_attrs = {
+            "__doc__",
+            "__file__",
+            "__loader__",
+            "__name__",
+            "__package__",
+            "__path__",
+            "__spec__",
+            "sidc",
+        }
+
+        actual_attrs = set(dir(ssn_package))
+
+        # sidc should be present
+        assert "sidc" in actual_attrs
+
+        # Should not have unexpected attributes (allowing for some Python internals)
+        unexpected = actual_attrs - expected_attrs
+        # Filter out Python internal attributes
+        unexpected = {attr for attr in unexpected if not attr.startswith("_")}
+
+        assert len(unexpected) == 0, f"Unexpected attributes: {unexpected}"
+
+    def test_clean_imports(self):
+        """Test clean import behavior without side effects."""
+        # Count modules before import
+        modules_before = len(sys.modules)
+
+        import solarwindpy.solar_activity.sunspot_number
+
+        # Should not import excessive modules
+        modules_after = len(sys.modules)
+
+        # Some new modules are expected (the package and its dependencies)
+        # but it shouldn't be excessive
+        assert modules_after - modules_before < 20  # Reasonable threshold
+
+    def test_symbol_accessibility(self):
+        """Test required symbols accessible through package."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Key SIDC functionality should be accessible
+        assert hasattr(ssn_package.sidc, "SIDC")
+        assert hasattr(ssn_package.sidc, "SIDC_ID")
+        assert hasattr(ssn_package.sidc, "SIDCLoader")
+        assert hasattr(ssn_package.sidc, "SSNExtrema")
+
+
+class TestIntegrationWithParentPackage:
+    """Test integration with parent solar_activity package."""
+
+    def test_parent_package_access(self):
+        """Test accessible from parent solar_activity package."""
+        import solarwindpy.solar_activity as sa_package
+
+        # Should be accessible through parent
+        assert hasattr(sa_package, "sunspot_number")
+        assert sa_package.sunspot_number is not None
+
+    def test_namespace_consistency(self):
+        """Test consistent with parent package namespace."""
+        import solarwindpy.solar_activity as sa_package
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should be the same object
+        assert sa_package.sunspot_number is ssn_package
+
+    def test_package_hierarchy_integrity(self):
+        """Test maintains proper package hierarchy."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Package name should reflect hierarchy
+        assert ssn_package.__name__ == "solarwindpy.solar_activity.sunspot_number"
+        assert "solar_activity" in ssn_package.__name__
+
+    def test_cross_module_compatibility(self):
+        """Test compatibility with other solar activity modules."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should be able to import other solar activity modules
+        try:
+            import solarwindpy.solar_activity.base
+            import solarwindpy.solar_activity.plots
+
+            # These should not conflict with sunspot_number
+        except ImportError:
+            # If these modules don't exist, that's fine for this test
+            pass
+
+
+class TestErrorHandlingAndEdgeCases:
+    """Test error handling and edge cases."""
+
+    def test_multiple_imports(self):
+        """Test behavior with repeated imports."""
+        import solarwindpy.solar_activity.sunspot_number as ssn1
+        import solarwindpy.solar_activity.sunspot_number as ssn2
+
+        # Should be the same object (cached)
+        assert ssn1 is ssn2
+
+    def test_import_from_different_contexts(self):
+        """Test imports from different execution contexts."""
+
+        # Test import in function scope
+        def import_in_function():
+            import solarwindpy.solar_activity.sunspot_number as ssn_func
+
+            return ssn_func
+
+        ssn_func = import_in_function()
+
+        # Test import in module scope
+        import solarwindpy.solar_activity.sunspot_number as ssn_module
+
+        # Should be the same object
+        assert ssn_func is ssn_module
+
+    def test_sidc_module_unavailable(self):
+        """Test behavior when SIDC module unavailable."""
+        # Since the current implementation imports sidc successfully,
+        # this test validates that the import works as expected
+        # In a real scenario where sidc was unavailable, the import would fail
+
+        # Test that the package can handle the current working state
+        try:
+            import solarwindpy.solar_activity.sunspot_number as ssn
+
+            # If import succeeds, sidc should be available
+            assert hasattr(ssn, "sidc")
+        except ImportError:
+            # This would be the expected behavior if sidc was truly unavailable
+            pytest.skip("SIDC module is not available in this environment")
+
+
+class TestPerformanceConsiderations:
+    """Test performance considerations for package imports."""
+
+    def test_import_speed(self):
+        """Test package imports quickly."""
+        import time
+
+        start_time = time.time()
+        import solarwindpy.solar_activity.sunspot_number
+
+        end_time = time.time()
+
+        import_time = end_time - start_time
+
+        # Should import in reasonable time (less than 1 second)
+        assert import_time < 1.0
+
+    def test_minimal_overhead(self):
+        """Test minimal package initialization overhead."""
+        # Import should not create excessive objects
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Package should have minimal attributes
+        attrs = dir(ssn_package)
+
+        # Should not have excessive attributes
+        assert len(attrs) < 20  # Reasonable threshold
+
+
+class TestQualityAssurance:
+    """Test code quality and validation."""
+
+    def test_import_style(self):
+        """Test import statements follow recommended style."""
+        # This is verified by the fact that the relative import works
+        # and follows PEP 8 guidelines
+        import solarwindpy.solar_activity.sunspot_number
+
+        # If import works, style is correct
+        assert True
+
+    def test_package_validation(self):
+        """Test validation of package structure."""
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should have all required package attributes
+        required_attrs = ["__name__", "__file__", "__path__", "__doc__"]
+
+        for attr in required_attrs:
+            assert hasattr(ssn_package, attr), f"Missing required attribute: {attr}"
+
+    def test_integration_validation(self):
+        """Test validation of integration with other modules."""
+        # Should be able to use SIDC functionality through package
+        import solarwindpy.solar_activity.sunspot_number as ssn_package
+
+        # Should be able to instantiate SIDC_ID
+        try:
+            sidc_id = ssn_package.sidc.SIDC_ID("m")
+            assert sidc_id is not None
+        except Exception as e:
+            pytest.fail(f"Integration validation failed: {e}")
+
+
+class TestUsagePatterns:
+    """Test common usage patterns for the package."""
+
+    def test_direct_sidc_access(self):
+        """Test direct access to SIDC functionality."""
+        from solarwindpy.solar_activity.sunspot_number import sidc
+
+        # Should be able to use SIDC classes directly
+        assert hasattr(sidc, "SIDC")
+        assert hasattr(sidc, "SIDC_ID")
+
+    def test_package_level_access(self):
+        """Test access through package level."""
+        import solarwindpy.solar_activity.sunspot_number as ssn
+
+        # Should be able to access SIDC through package
+        assert hasattr(ssn.sidc, "SIDC")
+        assert hasattr(ssn.sidc, "SIDC_ID")
+
+    def test_full_import_path(self):
+        """Test using full import path."""
+        from solarwindpy.solar_activity.sunspot_number.sidc import SIDC_ID
+
+        # Should be able to import specific classes
+        assert SIDC_ID is not None
+        assert callable(SIDC_ID)
+
+    def test_compatibility_with_solar_activity_functions(self):
+        """Test compatibility with solar_activity level functions."""
+        # Test that sunspot_number integrates well with solar_activity
+        try:
+            import solarwindpy.solar_activity as sa
+            import solarwindpy.solar_activity.sunspot_number as ssn
+
+            # Should coexist without conflicts
+            assert hasattr(sa, "sunspot_number")
+            assert sa.sunspot_number is ssn
+
+        except ImportError:
+            # If solar_activity doesn't have expected structure, that's fine
+            pass