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

tests/solar_activity/sunspot_number/test_sidc_loader.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+"""Simplified test SIDCLoader class.
+
+This module tests the core SIDCLoader functionality from solar_activity.sunspot_number.sidc:
+- Data conversion and NaN handling
+- Basic inheritance and method existence
+- URL and key handling
+"""
+
+import pytest
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+
+from solarwindpy.solar_activity.sunspot_number.sidc import SIDCLoader, SIDC_ID
+
+
+class TestSIDCLoaderCore:
+    """Test core SIDCLoader functionality."""
+
+    def test_convert_nans_basic(self):
+        """Test convert_nans replaces -1 with np.nan."""
+        # Create a minimal loader instance for testing convert_nans method
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+
+        # Create test DataFrame with -1 values
+        test_data = pd.DataFrame(
+            {
+                "ssn": [10.5, -1, 25.3, -1, 8.7],
+                "std": [2.1, 3.4, -1, 5.6, -1],
+                "n_obs": [12, 15, -1, 18, 20],
+            }
+        )
+
+        loader.convert_nans(test_data)
+
+        # Check that -1 values are replaced with NaN
+        assert pd.isna(test_data.loc[1, "ssn"])
+        assert pd.isna(test_data.loc[3, "ssn"])
+        assert pd.isna(test_data.loc[2, "std"])
+        assert pd.isna(test_data.loc[4, "std"])
+        assert pd.isna(test_data.loc[2, "n_obs"])
+
+        # Check that other values remain unchanged
+        assert test_data.loc[0, "ssn"] == 10.5
+        assert test_data.loc[2, "ssn"] == 25.3
+        assert test_data.loc[4, "ssn"] == 8.7
+
+    def test_convert_nans_no_minus_ones(self):
+        """Test convert_nans when there are no -1 values."""
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+
+        test_data = pd.DataFrame({"ssn": [10.5, 20.3, 25.3], "std": [2.1, 3.4, 4.2]})
+        original_data = test_data.copy()
+
+        loader.convert_nans(test_data)
+
+        # Data should remain unchanged
+        pd.testing.assert_frame_equal(test_data, original_data)
+
+    def test_convert_nans_all_minus_ones(self):
+        """Test convert_nans when all values are -1."""
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+
+        test_data = pd.DataFrame({"ssn": [-1, -1, -1], "std": [-1, -1, -1]})
+
+        loader.convert_nans(test_data)
+
+        # All values should be NaN
+        assert test_data.isna().all().all()
+
+    def test_inheritance_from_data_loader(self):
+        """Test that SIDCLoader inherits from DataLoader."""
+        from solarwindpy.solar_activity.base import DataLoader
+
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+
+        assert isinstance(loader, DataLoader)
+        # Check that it has key properties from the base class
+        assert loader.key == "m"
+        assert loader.url == "http://example.com"
+
+    def test_data_path_property_structure(self):
+        """Test that data_path property creates correct path structure."""
+        # Mock the parent data_path to avoid filesystem dependencies
+        with patch.object(
+            SIDCLoader.__bases__[0], "data_path", new_callable=lambda: Path("/tmp/test")
+        ):
+            with patch.object(SIDCLoader, "_init_logger"):
+                loader = SIDCLoader("m", "http://example.com")
+
+                expected_path = Path("/tmp/test") / "sidc" / "m"
+                assert loader.data_path == expected_path
+
+    def test_data_path_with_different_keys(self):
+        """Test data_path property with different SIDC keys."""
+        test_keys = ["d", "m", "m13", "y", "hd", "hm", "hm13"]
+
+        for key in test_keys:
+            with patch.object(
+                SIDCLoader.__bases__[0],
+                "data_path",
+                new_callable=lambda: Path("/tmp/test"),
+            ):
+                with patch.object(SIDCLoader, "_init_logger"):
+                    loader = SIDCLoader(key, "http://example.com")
+                    expected_path = Path("/tmp/test") / "sidc" / key
+                    assert loader.data_path == expected_path
+
+    def test_method_existence(self):
+        """Test that required methods exist."""
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+
+        # Check that key methods exist
+        assert hasattr(loader, "convert_nans")
+        assert callable(loader.convert_nans)
+        assert hasattr(loader, "download_data")
+        assert callable(loader.download_data)
+        assert hasattr(loader, "load_data")
+        assert callable(loader.load_data)
+        assert hasattr(loader, "data_path")
+
+    @patch("pandas.read_csv")
+    def test_download_data_calls_read_csv(self, mock_read_csv, tmp_path):
+        """Test that download_data calls pandas.read_csv."""
+        # Create a simple mock CSV response
+        mock_csv = pd.DataFrame(
+            {
+                "year": [1996],
+                "month": [1],
+                "year_fraction": [1996.042],
+                "ssn": [17.5],
+                "std": [8.0],
+                "n_obs": [14],
+                "definitive": [True],
+            }
+        )
+        mock_read_csv.return_value = mock_csv
+
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com/snmtotcsv.php")
+            loader._logger = Mock()  # Mock the logger to avoid logging issues
+
+        new_data_path = tmp_path / "new_data"
+        old_data_path = tmp_path / "old_data"
+
+        loader.download_data(new_data_path, old_data_path)
+
+        # Verify that read_csv was called with the URL
+        mock_read_csv.assert_called_once()
+        args, kwargs = mock_read_csv.call_args
+        assert args[0] == "http://example.com/snmtotcsv.php"
+        assert kwargs["sep"] == ";"
+        assert kwargs["header"] is None
+
+    def test_download_data_invalid_key_raises_error(self, tmp_path):
+        """Test that invalid keys in download_data raise NotImplementedError."""
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("invalid_key", "http://example.com")
+            loader._logger = Mock()
+
+        new_data_path = tmp_path / "new_data"
+        old_data_path = tmp_path / "old_data"
+
+        with pytest.raises(
+            NotImplementedError, match="You have not yet used the SSN specified"
+        ):
+            loader.download_data(new_data_path, old_data_path)
+
+    @patch.object(SIDCLoader.__bases__[0], "load_data")  # Mock parent load_data
+    @patch("solarwindpy.solar_activity.sunspot_number.sidc.SSNExtrema")
+    def test_load_data_calls_parent_and_ssn_extrema(
+        self, mock_ssn_extrema_class, mock_parent_load_data
+    ):
+        """Test that load_data calls parent load_data and uses SSNExtrema."""
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+            loader._logger = Mock()
+
+        # Create mock data for the loader
+        test_dates = pd.date_range("2008-01-01", "2010-12-31", freq="MS")
+        test_data = pd.DataFrame(
+            {
+                "ssn": np.random.uniform(10, 100, len(test_dates)),
+                "std": np.random.uniform(5, 15, len(test_dates)),
+            },
+            index=test_dates,
+        )
+        loader._data = test_data
+
+        # Mock SSNExtrema
+        mock_extrema = Mock()
+        mock_intervals = pd.DataFrame(
+            {
+                "Cycle": [
+                    pd.Interval(pd.Timestamp("2008-01-01"), pd.Timestamp("2019-12-31")),
+                    pd.Interval(pd.Timestamp("2020-01-01"), pd.Timestamp("2030-12-31")),
+                ]
+            },
+            index=[24, 25],
+        )
+        mock_intervals.index.name = "Number"
+        mock_extrema.cycle_intervals = mock_intervals
+        mock_ssn_extrema_class.return_value = mock_extrema
+
+        loader.load_data()
+
+        # Verify parent load_data was called
+        mock_parent_load_data.assert_called_once()
+
+        # Verify SSNExtrema was instantiated
+        mock_ssn_extrema_class.assert_called_once()
+
+
+class TestSIDCLoaderEdgeCases:
+    """Test edge cases for SIDCLoader."""
+
+    def test_convert_nans_mixed_dtypes(self):
+        """Test convert_nans with mixed data types."""
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader("m", "http://example.com")
+
+        test_data = pd.DataFrame(
+            {
+                "ssn": [10.5, -1, 25.3],  # float
+                "n_obs": [12, -1, 18],  # int
+                "definitive": [True, False, True],  # bool, shouldn't change
+            }
+        )
+
+        loader.convert_nans(test_data)
+
+        # Check float column
+        assert pd.isna(test_data.loc[1, "ssn"])
+        assert test_data.loc[0, "ssn"] == 10.5
+
+        # Check int column
+        assert pd.isna(test_data.loc[1, "n_obs"])
+        assert test_data.loc[0, "n_obs"] == 12
+
+        # Check bool column (should remain unchanged)
+        assert test_data.loc[0, "definitive"] == True
+        assert test_data.loc[1, "definitive"] == False
+
+    def test_initialization_with_real_sidc_id(self):
+        """Test initialization with a real SIDC_ID object."""
+        sidc_id = SIDC_ID("m")
+
+        with patch.object(SIDCLoader, "_init_logger"):
+            loader = SIDCLoader(sidc_id.key, sidc_id.url)
+
+        assert loader.key == "m"
+        assert "snmtotcsv.php" in loader.url
+        assert isinstance(loader, SIDCLoader)
+
+    def test_path_creation_does_not_create_directories(self):
+        """Test that accessing data_path doesn't create actual directories."""
+        with patch.object(
+            SIDCLoader.__bases__[0],
+            "data_path",
+            new_callable=lambda: Path("/nonexistent/test"),
+        ):
+            with patch.object(SIDCLoader, "_init_logger"):
+                loader = SIDCLoader("m", "http://example.com")
+
+                path = loader.data_path
+                # Path object should be created but directory shouldn't exist
+                assert isinstance(path, Path)
+                assert not path.exists()  # Should not create actual directory

tests/solar_activity/sunspot_number/test_ssn_extrema.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python
+"""Test SSNExtrema class.
+
+This module tests the SSNExtrema class from solar_activity.sunspot_number.sidc:
+- CSV parsing and data loading
+- Error handling for invalid arguments
+- Data format validation
+"""
+
+import pytest
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from unittest.mock import Mock, patch, mock_open
+
+from solarwindpy.solar_activity.sunspot_number.sidc import SSNExtrema
+
+
+class TestSSNExtrema:
+    """Test the SSNExtrema class for solar cycle extrema data."""
+
+    @pytest.fixture
+    def sample_ssn_extrema_csv(self):
+        """Sample SSN extrema CSV content for testing."""
+        # Simulate the format of ssn_extrema.csv with header rows and data
+        csv_content = (
+            """# Solar Cycle Extrema Data
+# Source: SIDC - Royal Observatory of Belgium
+# Data format: Cycle Number, Minimum Date, Maximum Date
+# 
+# Additional header lines (total 45 lines to skip)
+"""
+            + "\n" * 40
+            + """Number,Min,Max
+20,1964-10-01,1968-11-01
+21,1976-03-01,1979-12-01
+22,1986-09-01,1989-07-01
+23,1996-05-01,2000-03-01
+24,2008-12-01,2014-04-01
+25,2019-12-01,2025-07-01"""
+        )
+        return csv_content
+
+    def test_initialization_no_args(self):
+        """Test SSNExtrema initialization with no arguments."""
+        # This should work without raising errors
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Mock the CSV data
+            mock_data = pd.DataFrame(
+                {
+                    "Min": ["1964-10-01", "1976-03-01", "1986-09-01"],
+                    "Max": ["1968-11-01", "1979-12-01", "1989-07-01"],
+                },
+                index=[20, 21, 22],
+            )
+            mock_read_csv.return_value = mock_data
+
+            extrema = SSNExtrema()
+
+            # Verify that the load_or_set_data method was called implicitly
+            assert hasattr(extrema, "_data")
+
+    def test_load_or_set_data_empty_args(self, sample_ssn_extrema_csv):
+        """Test load_or_set_data with empty args and kwargs."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        # Mock file reading
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Create mock DataFrame that simulates the CSV structure
+            raw_data = pd.DataFrame(
+                {
+                    "Min": ["1964-10-01", "1976-03-01", "1986-09-01"],
+                    "Max": ["1968-11-01", "1979-12-01", "1989-07-01"],
+                },
+                index=[20, 21, 22],
+            )
+
+            # Mock the stack/unstack operations
+            stacked = pd.Series(
+                [
+                    "1964-10-01",
+                    "1968-11-01",
+                    "1976-03-01",
+                    "1979-12-01",
+                    "1986-09-01",
+                    "1989-07-01",
+                ]
+            )
+            unstacked = pd.DataFrame(
+                {
+                    "Min": [
+                        pd.Timestamp("1964-10-01"),
+                        pd.Timestamp("1976-03-01"),
+                        pd.Timestamp("1986-09-01"),
+                    ],
+                    "Max": [
+                        pd.Timestamp("1968-11-01"),
+                        pd.Timestamp("1979-12-01"),
+                        pd.Timestamp("1989-07-01"),
+                    ],
+                },
+                index=[20, 21, 22],
+            )
+            unstacked.columns.names = ["kind"]
+
+            mock_read_csv.return_value = raw_data
+
+            with (
+                patch.object(pd.DataFrame, "stack", return_value=stacked),
+                patch("pandas.to_datetime", return_value=stacked),
+                patch.object(pd.Series, "unstack", return_value=unstacked),
+            ):
+
+                extrema.load_or_set_data()
+
+                # Verify CSV was read with correct parameters
+                mock_read_csv.assert_called_once()
+                args, kwargs = mock_read_csv.call_args
+                assert kwargs["header"] == 0
+                assert kwargs["skiprows"] == 45
+                assert kwargs["index_col"] == 0
+
+                # Verify data was set
+                assert hasattr(extrema, "_data")
+                assert extrema._data.columns.names == ["kind"]
+
+    def test_load_or_set_data_with_args_raises_error(self):
+        """Test that passing args/kwargs raises ValueError."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        # Should raise ValueError when passing arguments
+        with pytest.raises(
+            ValueError, match="SSNExtrema expects empty args and kwargs"
+        ):
+            extrema.load_or_set_data("some_arg")
+
+    def test_load_or_set_data_with_kwargs_raises_error(self):
+        """Test that passing kwargs raises ValueError."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        # Should raise ValueError when passing keyword arguments
+        with pytest.raises(
+            ValueError, match="SSNExtrema expects empty args and kwargs"
+        ):
+            extrema.load_or_set_data(some_kwarg="value")
+
+    def test_load_or_set_data_with_both_args_and_kwargs_raises_error(self):
+        """Test that passing both args and kwargs raises ValueError."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        # Should raise ValueError when passing both
+        with pytest.raises(
+            ValueError, match="SSNExtrema expects empty args and kwargs"
+        ):
+            extrema.load_or_set_data("arg", kwarg="value")
+
+    def test_inheritance_from_indicator_extrema(self):
+        """Test that SSNExtrema inherits from IndicatorExtrema."""
+        from solarwindpy.solar_activity.base import IndicatorExtrema
+
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Mock the CSV data
+            mock_data = pd.DataFrame(
+                {"Min": ["1964-10-01"], "Max": ["1968-11-01"]}, index=[20]
+            )
+            mock_read_csv.return_value = mock_data
+
+            extrema = SSNExtrema()
+            assert isinstance(extrema, IndicatorExtrema)
+
+    def test_csv_file_path_resolution(self):
+        """Test that the CSV file path is resolved correctly."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            mock_data = pd.DataFrame(
+                {"Min": ["1964-10-01"], "Max": ["1968-11-01"]}, index=[20]
+            )
+            mock_read_csv.return_value = mock_data
+
+            extrema.load_or_set_data()
+
+            # Check that read_csv was called with the expected path
+            args, kwargs = mock_read_csv.call_args
+            called_path = args[0]
+
+            # The path should end with ssn_extrema.csv
+            assert str(called_path).endswith("ssn_extrema.csv")
+            assert "sunspot_number" in str(called_path)
+
+    def test_data_format_after_loading(self):
+        """Test that data has correct format after loading."""
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Mock the CSV reading and processing
+            raw_data = pd.DataFrame(
+                {
+                    "Min": ["2008-12-01", "2019-12-01"],
+                    "Max": ["2014-04-01", "2025-07-01"],
+                },
+                index=[24, 25],
+            )
+
+            processed_data = pd.DataFrame(
+                {
+                    "Min": [pd.Timestamp("2008-12-01"), pd.Timestamp("2019-12-01")],
+                    "Max": [pd.Timestamp("2014-04-01"), pd.Timestamp("2025-07-01")],
+                },
+                index=[24, 25],
+            )
+            processed_data.columns.names = ["kind"]
+
+            mock_read_csv.return_value = raw_data
+
+            # Mock the datetime conversion process
+            with patch("solarwindpy.solar_activity.sunspot_number.sidc.pd.to_datetime") as mock_to_datetime:
+                # Mock stack operation
+                stacked_data = pd.Series(
+                    ["2008-12-01", "2014-04-01", "2019-12-01", "2025-07-01"]
+                )
+
+                # Mock to_datetime to return datetime series
+                datetime_series = pd.Series(
+                    [
+                        pd.Timestamp("2008-12-01"),
+                        pd.Timestamp("2014-04-01"),
+                        pd.Timestamp("2019-12-01"),
+                        pd.Timestamp("2025-07-01"),
+                    ]
+                )
+                mock_to_datetime.return_value = datetime_series
+
+                with (
+                    patch.object(pd.DataFrame, "stack", return_value=stacked_data),
+                    patch.object(pd.Series, "unstack", return_value=processed_data),
+                    patch.object(SSNExtrema, "calculate_intervals"),  # Skip interval calculation that uses "today"
+                ):
+
+                    extrema = SSNExtrema()
+
+                    # Verify data structure
+                    assert hasattr(extrema, "_data")
+                    assert extrema._data.columns.names == ["kind"]
+                    assert "Min" in extrema._data.columns
+                    assert "Max" in extrema._data.columns
+
+
+class TestSSNExtremaEdgeCases:
+    """Test edge cases and error conditions for SSNExtrema."""
+
+    def test_file_not_found_handling(self):
+        """Test behavior when CSV file doesn't exist."""
+        with (
+            patch("pathlib.Path.exists", return_value=False),
+            patch("pandas.read_csv") as mock_read_csv,
+        ):
+
+            # read_csv should still be called even if file check fails
+            # (pandas will handle the FileNotFoundError)
+            mock_read_csv.side_effect = FileNotFoundError("File not found")
+
+            with pytest.raises(FileNotFoundError):
+                SSNExtrema()
+
+    def test_malformed_csv_handling(self):
+        """Test behavior with malformed CSV data."""
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Simulate malformed CSV that causes parsing error
+            mock_read_csv.side_effect = pd.errors.ParserError("Malformed CSV")
+
+            with pytest.raises(pd.errors.ParserError):
+                SSNExtrema()
+
+    def test_empty_csv_handling(self):
+        """Test behavior with empty CSV data."""
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Empty DataFrame
+            empty_data = pd.DataFrame()
+            mock_read_csv.return_value = empty_data
+
+            extrema = SSNExtrema.__new__(SSNExtrema)
+
+            # Should handle empty data gracefully (might raise error in stack/unstack)
+            try:
+                extrema.load_or_set_data()
+            except (ValueError, IndexError):
+                # These are acceptable errors for empty data
+                pass
+
+    def test_invalid_date_format_handling(self):
+        """Test behavior with invalid date formats in CSV."""
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Data with invalid date formats
+            invalid_data = pd.DataFrame(
+                {
+                    "Min": ["invalid-date", "1976-03-01"],
+                    "Max": ["1968-11-01", "another-invalid-date"],
+                },
+                index=[20, 21],
+            )
+            mock_read_csv.return_value = invalid_data
+
+            extrema = SSNExtrema.__new__(SSNExtrema)
+
+            # pandas.to_datetime should handle invalid dates (might raise error or coerce)
+            with patch("solarwindpy.solar_activity.sunspot_number.sidc.pd.to_datetime") as mock_to_datetime:
+                mock_to_datetime.side_effect = ValueError("Invalid date format")
+
+                with pytest.raises(ValueError):
+                    extrema.load_or_set_data()
+
+    def test_class_name_in_error_message(self):
+        """Test that class name appears correctly in error messages."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        # Test that the error message contains the correct class name
+        with pytest.raises(ValueError) as exc_info:
+            extrema.load_or_set_data("arg")
+
+        assert "SSNExtrema" in str(exc_info.value)
+
+    def test_method_signature_validation(self):
+        """Test that method accepts various argument patterns for validation."""
+        extrema = SSNExtrema.__new__(SSNExtrema)
+
+        # Test different argument patterns that should all raise errors
+        error_cases = [
+            (["arg1"], {}),
+            ([], {"key": "value"}),
+            (["arg1", "arg2"], {}),
+            (["arg"], {"key": "value"}),
+            ([], {"key1": "value1", "key2": "value2"}),
+        ]
+
+        for args, kwargs in error_cases:
+            with pytest.raises(
+                ValueError, match="SSNExtrema expects empty args and kwargs"
+            ):
+                extrema.load_or_set_data(*args, **kwargs)
+
+    def test_successful_initialization_creates_expected_attributes(self):
+        """Test that successful initialization creates expected attributes."""
+        with (
+            patch("pandas.read_csv") as mock_read_csv,
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+
+            # Mock successful CSV loading
+            mock_data = pd.DataFrame(
+                {"Min": ["2008-12-01"], "Max": ["2014-04-01"]}, index=[24]
+            )
+
+            processed_data = pd.DataFrame(
+                {
+                    "Min": [pd.Timestamp("2008-12-01")],
+                    "Max": [pd.Timestamp("2014-04-01")],
+                },
+                index=[24],
+            )
+            processed_data.columns.names = ["kind"]
+
+            mock_read_csv.return_value = mock_data
+
+            with (
+                patch("pandas.to_datetime"),
+                patch.object(pd.DataFrame, "stack"),
+                patch.object(pd.Series, "unstack", return_value=processed_data),
+            ):
+
+                extrema = SSNExtrema()
+
+                # Check that the object has expected attributes from parent class
+                assert hasattr(extrema, "_data")
+                # IndicatorExtrema parent should provide additional attributes
+                assert hasattr(extrema, "data")  # Property from parent