| """ |
| Unit tests for notebook-based portfolio optimization methods. |
| Tests Hybrid, QUBO-SA, VQE, and classical optimizers via run_optimization. |
| """ |
| import pytest |
| import numpy as np |
|
|
| from services.portfolio_optimizer import run_optimization, OBJECTIVES |
| from core.quantum_inspired.quantum_annealing import ( |
| QuantumAnnealingOptimizer, |
| run_quantum_annealing_comparison, |
| QAConfig, |
| ) |
|
|
|
|
| class TestNotebookOptimizers: |
|
|
| def setup_method(self): |
| """Set up test fixtures.""" |
| self.n_assets = 10 |
| np.random.seed(42) |
| self.returns = np.random.randn(self.n_assets) * 0.1 + 0.05 |
| self.covariance = self._generate_valid_covariance(self.n_assets) |
|
|
| def _generate_valid_covariance(self, n): |
| """Generate a valid positive semi-definite covariance matrix.""" |
| A = np.random.randn(n, n) |
| return np.dot(A.T, A) / n |
|
|
| @pytest.mark.parametrize("objective", ["hybrid", "qubo_sa", "vqe", "markowitz", "min_variance", "hrp"]) |
| def test_objective_produces_valid_result(self, objective): |
| """Test each objective produces valid portfolio.""" |
| result = run_optimization(self.returns, self.covariance, objective=objective) |
| assert result.weights is not None |
| assert len(result.weights) == self.n_assets |
| assert np.abs(np.sum(result.weights) - 1.0) < 1e-5 |
| assert np.all(result.weights >= -1e-6) |
| assert np.isfinite(result.sharpe_ratio) |
| assert result.expected_return is not None |
| assert result.volatility > 0 |
|
|
| def test_quantum_annealing_optimizer(self): |
| """Test quantum annealing optimizer (legacy, still in core).""" |
| qa_optimizer = QuantumAnnealingOptimizer() |
| result = qa_optimizer.optimize(self.returns, self.covariance) |
| assert result['weights'] is not None |
| assert len(result['weights']) == self.n_assets |
| assert np.abs(np.sum(result['weights']) - 1.0) < 1e-6 |
| assert np.all(result['weights'] >= 0) |
| assert np.isfinite(result['sharpe_ratio']) |
|
|
| def test_quantum_annealing_comparison(self): |
| """Test quantum annealing vs classical comparison.""" |
| comparison = run_quantum_annealing_comparison(self.returns, self.covariance) |
| assert 'quantum_annealing' in comparison |
| assert 'classical' in comparison |
| assert np.isfinite(comparison['quantum_annealing']['sharpe_ratio']) |
| assert np.isfinite(comparison['classical']['sharpe_ratio']) |
|
|
| def test_equal_weight_baseline(self): |
| """Test equal weight baseline.""" |
| result = run_optimization(self.returns, self.covariance, objective='equal_weight') |
| expected = np.ones(self.n_assets) / self.n_assets |
| np.testing.assert_array_almost_equal(result.weights, expected) |
|
|
| def test_large_portfolio(self): |
| """Test performance on larger portfolios.""" |
| large_n = 50 |
| large_returns = np.random.randn(large_n) * 0.1 + 0.05 |
| A = np.random.randn(large_n, large_n) |
| large_covariance = np.dot(A.T, A) / large_n |
| result = run_optimization(large_returns, large_covariance, objective='hybrid') |
| assert np.isfinite(result.sharpe_ratio) |
| assert abs(np.sum(result.weights) - 1.0) < 1e-6 |
| assert len(result.weights) == large_n |
|
|
| def test_qa_configurations(self): |
| """Test different quantum annealing configurations.""" |
| for config in [ |
| QAConfig(initial_temperature=50.0, final_temperature=0.05), |
| QAConfig(quantum_fluctuation_strength=0.05), |
| ]: |
| qa_optimizer = QuantumAnnealingOptimizer(config) |
| result = qa_optimizer.optimize(self.returns, self.covariance) |
| assert len(result['weights']) == self.n_assets |
| assert abs(np.sum(result['weights']) - 1.0) < 1e-6 |
|
|
|
|
| class TestIntegration: |
|
|
| def setup_method(self): |
| """Set up test fixtures.""" |
| self.n_assets = 8 |
| np.random.seed(123) |
| self.returns = np.random.randn(self.n_assets) * 0.1 + 0.05 |
| A = np.random.randn(self.n_assets, self.n_assets) |
| self.covariance = np.dot(A.T, A) / self.n_assets |
|
|
| def test_all_methods_produce_valid_results(self): |
| """Test complete workflow with all available methods.""" |
| objectives = ['hybrid', 'qubo_sa', 'vqe', 'markowitz', 'min_variance', 'hrp', 'equal_weight'] |
| for obj in objectives: |
| result = run_optimization(self.returns, self.covariance, objective=obj) |
| assert np.isfinite(result.sharpe_ratio) |
| assert abs(np.sum(result.weights) - 1.0) < 1e-6 |
|
|
| def test_objectives_config(self): |
| """Test OBJECTIVES contains expected keys.""" |
| expected = {'hybrid', 'qubo_sa', 'vqe', 'markowitz', 'min_variance', 'hrp', 'equal_weight'} |
| assert expected.issubset(set(OBJECTIVES.keys())) |
|
|
