Add load tests

Author: MDUYN

tests/domain/models/backtesting/test_backtest.py

@@ -61,12 +61,12 @@ def test_save_and_open(self):
                 (0.5, datetime(2020, 6, 30)),
                 (0.2, datetime(2020, 3, 31))
             ],
-            growth=0.0,
-            growth_percentage=0.0,
-            total_net_gain=0.0,
-            total_net_gain_percentage=0.0,
-            final_value=0.0,
-            cagr=0.0,
+            growth=1.0,
+            growth_percentage=1.0,
+            total_net_gain=1.0,
+            total_net_gain_percentage=1.0,
+            final_value=1.0,
+            cagr=1.0,
             sharpe_ratio=0.0,
             rolling_sharpe_ratio=[
                 (0.0, datetime(2020, 1, 1)),
@@ -280,24 +280,79 @@ def test_save_and_open(self):
         backtest = Backtest(
             backtest_runs=[backtest_run],
             backtest_permutation_tests=[permutation_test_metrics],
-            backtest_summary=backtest_metrics
+            backtest_summary=backtest_metrics,
+            metadata={"strategy": "test_strategy"},
+            risk_free_rate=0.02
         )
 
         # Save the backtest
         backtest.save(self.dir_path)
         self.assertTrue((self.dir_path / "runs").exists())
 
-        # Check that there is atleast one results file
+        # Check that there is at least one results file
         results_dir = (self.dir_path / "runs")
         self.assertEqual(1, (len(os.listdir(results_dir))))
 
+        # Get the first run
+        first_run_dir = results_dir / os.listdir(results_dir)[0]
+        self.assertTrue((first_run_dir / "run.json").exists())
+        self.assertTrue((first_run_dir / "metrics.json").exists())
+
         # Check that there is a permutation tests directory
         self.assertTrue((self.dir_path / "permutation_tests").exists())
 
         # Check if there are 2 permutated_metrics folders
         permutated_metrics_dir = (self.dir_path / "permutation_tests")
 
         self.assertEqual(1, (len(os.listdir(permutated_metrics_dir))))
+        self.assertTrue((self.dir_path / "metadata.json").exists())
+        self.assertTrue((self.dir_path / "summary.json").exists())
+
+        loaded_backtest = Backtest.open(self.dir_path)
+        self.assertEqual(
+            len(loaded_backtest.get_all_backtest_runs()), 1
+        )
+        self.assertEqual(
+            len(loaded_backtest.get_all_backtest_permutation_tests()),
+            1
+        )
+
+        first_backtest_run = loaded_backtest.get_all_backtest_runs()[0]
+        self.assertEqual(
+            first_backtest_run.trading_symbol, "EUR"
+        )
+        self.assertEqual(
+            first_backtest_run.backtest_start_date,
+            datetime(2020, 1, 1)
+        )
+        self.assertEqual(
+            first_backtest_run.backtest_end_date,
+            datetime(2020, 12, 31)
+        )
+        self.assertEqual(
+            first_backtest_run.initial_unallocated, 1000.0
+        )
+        self.assertEqual(
+            len(first_backtest_run.portfolio_snapshots), 2
+        )
+        self.assertEqual(
+            len(first_backtest_run.trades), 1
+        )
+        self.assertEqual(
+            len(first_backtest_run.orders), 1
+        )
+        self.assertEqual(
+            len(first_backtest_run.positions), 1
+        )
+
+        backtest_metrics = first_backtest_run.backtest_metrics
+        self.assertIsInstance(backtest_metrics, BacktestMetrics)
+        self.assertEqual(backtest_metrics.cagr, 1.0)
+        self.assertEqual(backtest_metrics.sharpe_ratio, 0.0)
+        self.assertEqual(backtest_metrics.sortino_ratio, 0.0)
+        self.assertEqual(backtest_metrics.calmar_ratio, 0.0)
+        self.assertEqual(backtest_metrics.profit_factor, 0.0)
+        self.assertEqual(backtest_metrics.annual_volatility, 0.0)
 
     def test_get_backtest_run(self):
         pass

tests/domain/models/portfolio/__init__.py

@@ -0,0 +1,91 @@
+from datetime import datetime, timezone
+from unittest import TestCase
+
+from investing_algorithm_framework.domain import PortfolioSnapshot
+
+
+class Test(TestCase):
+
+    def test_to_dict(self):
+        snapshot = PortfolioSnapshot(
+            portfolio_id="portfolio_1",
+            trading_symbol="BTC/USDT",
+            pending_value=5000,
+            unallocated=2000,
+            net_size=3000,
+            total_net_gain=1500,
+            total_revenue=7000,
+            total_cost=5500,
+            total_value=8000,
+            cash_flow=1000,
+            created_at=datetime(
+                2023,
+                10,
+                1,
+                12,
+                0,
+                0,
+                tzinfo=timezone.utc
+            ),
+            metadata={"strategy": "mean_reversion"},
+        )
+        snapshot_dict = snapshot.to_dict()
+        self.assertEqual(snapshot_dict["portfolio_id"], "portfolio_1")
+        self.assertEqual(snapshot_dict["trading_symbol"], "BTC/USDT")
+        self.assertEqual(snapshot_dict["pending_value"], 5000)
+        self.assertEqual(snapshot_dict["unallocated"], 2000)
+        self.assertEqual(snapshot_dict["net_size"], 3000)
+        self.assertEqual(snapshot_dict["total_net_gain"], 1500)
+        self.assertEqual(snapshot_dict["total_revenue"], 7000)
+        self.assertEqual(snapshot_dict["total_cost"], 5500)
+        self.assertEqual(snapshot_dict["total_value"], 8000)
+        self.assertEqual(snapshot_dict["cash_flow"], 1000)
+        self.assertEqual(
+            snapshot_dict["created_at"],
+            "2023-10-01 12:00:00"
+        )
+        self.assertEqual(
+            snapshot_dict["metadata"], {"strategy": "mean_reversion"}
+        )
+
+    def test_from_dict(self):
+        snapshot_data = {
+            "portfolio_id": "portfolio_1",
+            "trading_symbol": "BTC/USDT",
+            "pending_value": 5000,
+            "unallocated": 2000,
+            "net_size": 3000,
+            "total_net_gain": 1500,
+            "total_revenue": 7000,
+            "total_cost": 5500,
+            "total_value": 8000,
+            "cash_flow": 1000,
+            "created_at": "2023-10-01T12:00:00+00:00",
+            "metadata": {"strategy": "mean_reversion"},
+        }
+        snapshot = PortfolioSnapshot.from_dict(snapshot_data)
+        self.assertEqual(snapshot.get_portfolio_id(), "portfolio_1")
+        self.assertEqual(snapshot.get_trading_symbol(), "BTC/USDT")
+        self.assertEqual(snapshot.get_pending_value(), 5000)
+        self.assertEqual(snapshot.unallocated, 2000)
+        self.assertEqual(snapshot.net_size, 3000)
+        self.assertEqual(snapshot.total_net_gain, 1500)
+        self.assertEqual(snapshot.total_revenue, 7000)
+        self.assertEqual(snapshot.total_cost, 5500)
+        self.assertEqual(snapshot.total_value, 8000)
+        self.assertEqual(snapshot.cash_flow, 1000)
+        self.assertEqual(
+            snapshot.created_at,
+            datetime(
+                2023,
+                10,
+                1,
+                12,
+                0,
+                0,
+                tzinfo=timezone.utc
+            )
+        )
+        self.assertEqual(
+            snapshot.metadata, {"strategy": "mean_reversion"}
+        )