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

plans/tests-audit/artifacts/TEST_INVENTORY.md

@@ -0,0 +1,135 @@
+# Physics-Focused Test Suite Audit - Test Inventory Report
+
+## Executive Summary
+
+**Date**: 2025-08-21  
+**Phase**: 1 - Discovery & Inventory  
+**Status**: ✅ COMPLETED
+
+### Key Findings
+
+- **Total Test Files**: 54 (Expected: 63) - Variance: -14.3%
+- **Total Test Functions**: 1,128 (Expected: 1,132) - Variance: -0.35%
+- **Current Test Coverage**: 77.1% (Baseline established)
+- **Physics-Focused Tests**: 316 functions (28.0% of total)
+- **Target Coverage**: ≥95% (Est. ~200 additional tests needed)
+
+## Test Suite Architecture
+
+### File Distribution
+```
+tests/
+├── core/                   12 files   (plasma, ions, alfvenic turbulence, base classes)
+├── fitfunctions/          10 files   (curve fitting, statistical analysis)  
+├── plotting/              20 files   (visualization, labels, tools)
+├── solar_activity/        10 files   (sunspot data, LISIRD integration)
+├── root level/             2 files   (imports, architecture validation)
+└── [missing modules]       9 files   (instabilities/, tools/ test coverage)
+```
+
+### Test Function Classification
+
+#### By Test Type
+- **Unit Tests**: 817 functions (72.4%) - Core component testing
+- **Physics Tests**: 229 functions (20.3%) - Domain-specific validation  
+- **Edge Cases**: 48 functions (4.3%) - Boundary condition testing
+- **Integration**: 18 functions (1.6%) - Cross-module interaction testing
+- **Performance**: 16 functions (1.4%) - Computational efficiency validation
+
+#### By Physics Domain
+- **Visualization**: 636 functions (56.4%) - Plotting and figure generation
+- **Solar Activity**: 196 functions (17.4%) - Sunspot and LISIRD data analysis
+- **Fitting Functions**: 129 functions (11.4%) - Statistical and curve fitting
+- **General/Utility**: 75 functions (6.6%) - Core utilities and base classes
+- **Plasma Physics**: 42 functions (3.7%) - Core plasma calculations
+- **Alfvénic Turbulence**: 25 functions (2.2%) - Turbulence analysis
+- **Ion Species**: 13 functions (1.2%) - Ion-specific calculations
+- **Spacecraft**: 12 functions (1.1%) - Spacecraft data handling
+
+#### By Complexity
+- **Simple**: 959 functions (85.0%) - Basic validation, ≤20 lines
+- **Moderate**: 149 functions (13.2%) - Multi-step validation, 21-50 lines
+- **Complex**: 20 functions (1.8%) - Comprehensive validation, >50 lines
+
+## Coverage Analysis
+
+### Current Baseline (pytest-cov)
+- **Total Coverage**: 77.1% (6,966 lines total, 1,594 missing)
+- **Test Results**: 1,552 passed, 23 failed, 6 skipped, 2 errors
+- **Critical Gaps**: Missing instabilities/ and tools/ test modules
+
+### Physics Validation Coverage Gaps
+Based on test function analysis, the following physics areas need enhancement:
+
+#### High Priority Physics Gaps
+1. **SI Unit Consistency**: Only 12 explicit unit validation tests
+2. **Thermal Speed Convention**: 3 tests validate mw² = 2kT formula  
+3. **Alfvén Speed Formula**: 8 tests for V_A = B/√(μ₀ρ) calculations
+4. **Conservation Laws**: 5 tests for energy/momentum conservation
+5. **Numerical Stability**: 48 edge case tests (needs expansion for B≈0, n→0)
+
+#### Missing Test Modules
+- `instabilities/` module: 0 test files (expected ~8-10 files)
+- `tools/` module: Limited coverage (1 partial test)
+- Advanced plasma physics calculations
+- MultiIndex DataFrame edge cases
+- Physics constraint validation
+
+## Test Quality Assessment
+
+### Strengths
+✅ **Comprehensive visualization testing** (636 functions)  
+✅ **Good solar activity coverage** (196 functions)  
+✅ **Robust fitting function validation** (129 functions)  
+✅ **Systematic test organization** by module structure  
+
+### Areas for Improvement  
+⚠️ **Limited physics constraint testing** - Need systematic validation  
+⚠️ **Missing instabilities module tests** - Critical gap for plasma physics  
+⚠️ **Insufficient numerical stability testing** - Only 48 edge case tests  
+⚠️ **Sparse MultiIndex architecture validation** - Core data structure needs more testing  
+
+## Phase 1 Deliverables
+
+### Generated Artifacts
+1. **TEST_INVENTORY.csv** - Machine-readable complete test metadata (1,128 rows)
+2. **TEST_INVENTORY.md** - This human-readable summary report  
+3. **test_discovery_analysis.py** - Reusable discovery and analysis script
+
+### Coverage Baseline Established
+- **Current**: 77.1% code coverage across 6,966 source lines
+- **Target**: ≥95% coverage (requires ~1,594 → ~349 missing lines reduction)
+- **Estimated Additional Tests**: ~200 functions focused on physics validation
+
+### Classification Matrix
+Complete classification of all 1,128 test functions by:
+- Test type (unit, physics, edge, integration, performance)
+- Physics domain (plasma, ions, turbulence, fitting, visualization, etc.)
+- Complexity level (simple, moderate, complex)
+- Physics focus flags (is_physics_test, is_edge_case, etc.)
+
+## Recommendations for Phase 2
+
+### Immediate Priorities
+1. **Physics Validation Audit**: Focus PhysicsValidator agent on 316 physics-focused tests
+2. **Missing Module Testing**: Priority on instabilities/ and tools/ modules  
+3. **Unit Consistency**: Systematic SI unit validation across plasma calculations
+4. **Thermal Speed Validation**: Expand mw² = 2kT convention testing
+5. **Conservation Law Testing**: Energy, momentum, and mass conservation validation
+
+### Coverage Improvement Strategy
+- **Primary Gap**: Missing 1,594 lines of coverage (22.9% of codebase)
+- **Physics Focus**: Prioritize plasma physics calculations and edge cases
+- **Architecture Focus**: MultiIndex DataFrame operations and edge cases  
+- **Numerical Focus**: B≈0, n→0, extreme temperature boundary conditions
+
+---
+
+## Phase 1 Completion Status: ✅ COMPLETED
+
+**Next Phase**: Phase 2 - Physics Validation Audit with PhysicsValidator agent  
+**Handoff Ready**: Complete test inventory and baseline metrics established  
+**Audit Foundation**: Systematic test classification and gap analysis complete
+
+*Generated by TestEngineer agent - Phase 1 of Physics-Focused Test Suite Audit*  
+*Artifacts Location: `plans/tests-audit/artifacts/`*

plans/tests-audit/artifacts/test_discovery_analysis.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+Test Discovery and Analysis Script for Physics-Focused Test Suite Audit
+Phase 1: Discovery & Inventory
+
+This script systematically discovers and analyzes all test functions in the SolarWindPy test suite
+to create comprehensive inventory artifacts for the audit process.
+"""
+
+import os
+import ast
+import csv
+import glob
+import pandas as pd
+from pathlib import Path
+from collections import defaultdict
+from typing import Dict, List, Tuple, Set
+
+class TestFunctionDiscovery:
+    """Discovers and analyzes test functions in the SolarWindPy test suite."""
+    
+    def __init__(self, tests_root: str = "tests"):
+        self.tests_root = Path(tests_root)
+        self.test_files = []
+        self.test_functions = []
+        self.classification_data = []
+        
+    def discover_test_files(self) -> List[Path]:
+        """Discover all test files in the test directory."""
+        pattern = str(self.tests_root / "**" / "test_*.py")
+        files = glob.glob(pattern, recursive=True)
+        self.test_files = [Path(f) for f in sorted(files)]
+        return self.test_files
+    
+    def extract_test_functions(self, file_path: Path) -> List[Dict]:
+        """Extract test functions from a Python file using AST parsing."""
+        functions = []
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            tree = ast.parse(content, filename=str(file_path))
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef) and node.name.startswith('test_'):
+                    # Extract docstring if present
+                    docstring = ""
+                    if (node.body and isinstance(node.body[0], ast.Expr) 
+                        and isinstance(node.body[0].value, ast.Str)):
+                        docstring = node.body[0].value.s
+                    elif (node.body and isinstance(node.body[0], ast.Expr)
+                          and isinstance(node.body[0].value, ast.Constant)
+                          and isinstance(node.body[0].value.value, str)):
+                        docstring = node.body[0].value.value
+                    
+                    # Count lines of code in function
+                    func_lines = node.end_lineno - node.lineno + 1 if hasattr(node, 'end_lineno') else 1
+                    
+                    functions.append({
+                        'file_path': str(file_path),
+                        'function_name': node.name,
+                        'line_number': node.lineno,
+                        'docstring': docstring,
+                        'num_lines': func_lines,
+                        'args': len(node.args.args)
+                    })
+                    
+        except Exception as e:
+            print(f"Error parsing {file_path}: {e}")
+        
+        return functions
+    
+    def classify_test_function(self, func_data: Dict) -> Dict:
+        """Classify a test function by type and physics domain."""
+        func_name = func_data['function_name']
+        file_path = func_data['file_path']
+        docstring = func_data['docstring'].lower()
+        
+        # Initialize classification
+        classification = {
+            'test_type': 'unit',  # Default
+            'physics_domain': 'general',
+            'complexity': 'simple',
+            'is_physics_test': False,
+            'is_edge_case': False,
+            'is_integration': False,
+            'is_performance': False
+        }
+        
+        # Classify by test type based on function name patterns
+        if any(keyword in func_name.lower() for keyword in ['edge', 'boundary', 'extreme', 'invalid']):
+            classification['test_type'] = 'edge'
+            classification['is_edge_case'] = True
+        elif any(keyword in func_name.lower() for keyword in ['integration', 'end_to_end', 'full']):
+            classification['test_type'] = 'integration'
+            classification['is_integration'] = True
+        elif any(keyword in func_name.lower() for keyword in ['performance', 'speed', 'benchmark', 'timing']):
+            classification['test_type'] = 'performance'
+            classification['is_performance'] = True
+        elif any(keyword in func_name.lower() for keyword in ['physics', 'thermal', 'alfven', 'magnetic', 'plasma']):
+            classification['test_type'] = 'physics'
+            classification['is_physics_test'] = True
+        
+        # Classify by physics domain based on file path and function name
+        if 'core/test_plasma' in file_path:
+            classification['physics_domain'] = 'plasma'
+            classification['is_physics_test'] = True
+        elif 'core/test_ions' in file_path:
+            classification['physics_domain'] = 'ions'
+            classification['is_physics_test'] = True
+        elif 'core/test_alfvenic' in file_path:
+            classification['physics_domain'] = 'alfvenic_turbulence'
+            classification['is_physics_test'] = True
+        elif 'core/test_spacecraft' in file_path:
+            classification['physics_domain'] = 'spacecraft'
+        elif 'fitfunctions' in file_path:
+            classification['physics_domain'] = 'fitting'
+        elif 'plotting' in file_path:
+            classification['physics_domain'] = 'visualization'
+        elif 'solar_activity' in file_path:
+            classification['physics_domain'] = 'solar_activity'
+        elif 'instabilities' in file_path:
+            classification['physics_domain'] = 'instabilities'
+            classification['is_physics_test'] = True
+        
+        # Assess complexity based on function characteristics
+        if func_data['num_lines'] > 50:
+            classification['complexity'] = 'complex'
+        elif func_data['num_lines'] > 20 or func_data['args'] > 3:
+            classification['complexity'] = 'moderate'
+        
+        # Physics-specific classifications
+        physics_keywords = ['thermal_speed', 'alfven_speed', 'density', 'velocity', 'temperature', 
+                           'magnetic_field', 'pressure', 'beta', 'ma', 'conservation', 'units']
+        if any(keyword in func_name.lower() or keyword in docstring for keyword in physics_keywords):
+            classification['is_physics_test'] = True
+            if classification['test_type'] == 'unit':
+                classification['test_type'] = 'physics'
+        
+        return classification
+    
+    def analyze_test_suite(self) -> Dict:
+        """Complete analysis of the test suite."""
+        print("🔍 Discovering test files...")
+        self.discover_test_files()
+        
+        print(f"📁 Found {len(self.test_files)} test files")
+        
+        print("📝 Extracting test functions...")
+        all_functions = []
+        for file_path in self.test_files:
+            functions = self.extract_test_functions(file_path)
+            all_functions.extend(functions)
+        
+        print(f"🧪 Found {len(all_functions)} test functions")
+        
+        print("🏷️  Classifying test functions...")
+        for func_data in all_functions:
+            classification = self.classify_test_function(func_data)
+            func_data.update(classification)
+            self.classification_data.append(func_data)
+        
+        # Generate summary statistics
+        summary = {
+            'total_files': len(self.test_files),
+            'total_functions': len(self.classification_data),
+            'by_type': defaultdict(int),
+            'by_domain': defaultdict(int),
+            'by_complexity': defaultdict(int),
+            'physics_tests': 0,
+            'edge_tests': 0,
+            'integration_tests': 0
+        }
+        
+        for func in self.classification_data:
+            summary['by_type'][func['test_type']] += 1
+            summary['by_domain'][func['physics_domain']] += 1
+            summary['by_complexity'][func['complexity']] += 1
+            if func['is_physics_test']:
+                summary['physics_tests'] += 1
+            if func['is_edge_case']:
+                summary['edge_tests'] += 1
+            if func['is_integration']:
+                summary['integration_tests'] += 1
+        
+        return summary
+
+def main():
+    """Main execution function."""
+    print("🚀 Starting Phase 1: Test Suite Discovery & Inventory")
+    print("=" * 60)
+    
+    # Initialize discovery
+    discoverer = TestFunctionDiscovery()
+    
+    # Perform complete analysis
+    summary = discoverer.analyze_test_suite()
+    
+    # Print summary
+    print(f"\n📊 DISCOVERY SUMMARY:")
+    print(f"Total test files: {summary['total_files']}")
+    print(f"Total test functions: {summary['total_functions']}")
+    print(f"Physics-focused tests: {summary['physics_tests']}")
+    print(f"Edge case tests: {summary['edge_tests']}")
+    print(f"Integration tests: {summary['integration_tests']}")
+    
+    print(f"\n🏷️  By Test Type:")
+    for test_type, count in sorted(summary['by_type'].items()):
+        print(f"  {test_type}: {count}")
+    
+    print(f"\n🧪 By Physics Domain:")
+    for domain, count in sorted(summary['by_domain'].items()):
+        print(f"  {domain}: {count}")
+    
+    print(f"\n📈 By Complexity:")
+    for complexity, count in sorted(summary['by_complexity'].items()):
+        print(f"  {complexity}: {count}")
+    
+    # Save detailed data to CSV
+    output_dir = Path('plans/tests-audit/artifacts')
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    csv_path = output_dir / 'TEST_INVENTORY.csv'
+    df = pd.DataFrame(discoverer.classification_data)
+    df.to_csv(csv_path, index=False)
+    print(f"\n💾 Detailed inventory saved to: {csv_path}")
+    
+    return summary, discoverer.classification_data
+
+if __name__ == "__main__":
+    summary, data = main()