wbportfolio 1.44.5__py2.py3-none-any.whl → 1.45.1__py2.py3-none-any.whl

wbportfolio/tests/models/test_portfolios.py

@@ -1,23 +1,27 @@
-from datetime import date
+import random
+from datetime import date, timedelta
 from decimal import Decimal
 from unittest.mock import patch
 
+import pandas as pd
 import pytest
+from django.contrib.contenttypes.models import ContentType
 from django.db.models import F, Sum
 from django.forms.models import model_to_dict
 from faker import Faker
 from pandas.tseries.offsets import BDay
 from psycopg.types.range import DateRange
 from wbcore.contrib.geography.factories import CountryFactory
+
 from wbportfolio.models import (
     AssetPosition,
     Portfolio,
     PortfolioInstrumentPreferredClassificationThroughModel,
-    PortfolioSynchronization,
+    PortfolioPortfolioThroughModel,
+    Trade,
 )
-from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 
-from .test_synchronization import callback
+from ...models.portfolio import update_portfolio_after_investable_universe
 from .utils import PortfolioTestMixin
 
 fake = Faker()
@@ -210,10 +214,12 @@ class TestPortfolioModel(PortfolioTestMixin):
         portfolio = portfolio_factory.create()
 
         ind1 = index_factory.create(is_cash=False)
-        short_underlying_portfolio = ind1.portfolio
+        short_underlying_portfolio = portfolio_factory.create()
+        ind1.portfolios.add(short_underlying_portfolio)
 
         ind2 = index_factory.create(is_cash=False)
-        long_underlying_portfolio = ind2.portfolio
+        long_underlying_portfolio = portfolio_factory.create()
+        ind2.portfolios.add(long_underlying_portfolio)
 
         asset_position_factory.create(date=weekday, portfolio=portfolio, weighting=-1.0, underlying_instrument=ind1)
         short_p1 = asset_position_factory.create(
@@ -246,59 +252,52 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         assert Decimal(res.weighting[1]) == pytest.approx((abs(short_p2.weighting)) / total_weight, rel=Decimal(1e-4))
 
-    def test_change_at_date(self, asset_position_factory, portfolio, weekday):
+    @patch.object(Portfolio, "estimate_net_asset_values", autospec=True)
+    @patch("wbportfolio.models.portfolio.compute_metrics_as_task.delay")
+    def test_change_at_date(
+        self, mock_compute_metrics, mock_estimate_net_asset_values, asset_position_factory, portfolio, weekday
+    ):
         asset_position_factory.create_batch(10, portfolio=portfolio, date=weekday)
 
-        portfolio.change_at_date(weekday)
+        portfolio.change_at_date(weekday, compute_metrics=True)
+
+        # test that change at date normalize the weighting
         total_value = AssetPosition.objects.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
         for pos in AssetPosition.objects.all():
             assert float(pos.weighting) == pytest.approx(float(pos.total_value_fx_portfolio / total_value), rel=1e-2)
 
-    @patch.object(PortfolioSynchronization, "synchronize_as_task_si")
+        mock_estimate_net_asset_values.assert_called_once_with(portfolio, weekday)
+        mock_compute_metrics.assert_called_once_with(
+            weekday, basket_id=portfolio.id, basket_content_type_id=ContentType.objects.get_for_model(Portfolio).id
+        )
+
+    @patch.object(Portfolio, "get_total_asset_under_management")
+    @patch.object(Portfolio, "compute_lookthrough", autospec=True)
     def test_change_at_date_with_dependent_portfolio(
-        self, mock_synchronize, asset_position_factory, portfolio_factory, portfolio_synchronization, weekday
+        self,
+        mock_compute_lookthrough,
+        mock_get_total_asset_under_management,
+        portfolio_factory,
+        product_factory,
+        instrument_price_factory,
+        customer_trade_factory,
+        weekday,
     ):
-        mock_synchronize.return_value = callback
         base_portfolio = portfolio_factory.create()
-        asset_position_factory.create_batch(10, portfolio=base_portfolio, date=weekday)
+        base_portfolio_total_asset_under_management = fake.pydecimal()
+        mock_get_total_asset_under_management.return_value = base_portfolio_total_asset_under_management
 
-        dependent_portfolio1 = portfolio_factory.create(portfolio_synchronization=portfolio_synchronization)
-        dependent_portfolio2 = portfolio_factory.create(portfolio_synchronization=portfolio_synchronization)
-        asset_position_factory.create_batch(10, portfolio=dependent_portfolio1, date=weekday)
-        asset_position_factory.create_batch(10, portfolio=dependent_portfolio2, date=weekday)
-
-        dependent_portfolio1.depends_on.add(base_portfolio)
-        dependent_portfolio2.depends_on.add(base_portfolio)
-        base_portfolio.change_at_date(weekday)
-
-        assert mock_synchronize.call_count == 2
-
-    @patch.object(PortfolioSynchronization, "synchronize_as_task_si")
-    @pytest.mark.parametrize("portfolio_synchronization__propagate_history", [True])
-    def test_change_at_date_with_dependent_portfolio_and_history(
-        self, mock_synchronize, portfolio_synchronization, asset_position_factory, portfolio_factory, weekday
-    ):
-        mock_synchronize.return_value = callback
-        base_portfolio = portfolio_factory.create()
-        asset_position_factory.create_batch(10, portfolio=base_portfolio, date=weekday)
-
-        dependent_portfolio1 = portfolio_factory.create(portfolio_synchronization=portfolio_synchronization)
-        dependent_portfolio2 = portfolio_factory.create(portfolio_synchronization=portfolio_synchronization)
-        asset_position_factory.create_batch(10, portfolio=dependent_portfolio1, date=weekday)
-        asset_position_factory.create_batch(10, portfolio=dependent_portfolio2, date=weekday)
-        asset_position_factory.create_batch(10, portfolio=dependent_portfolio1, date=weekday + BDay(6))
-        asset_position_factory.create_batch(10, portfolio=dependent_portfolio2, date=weekday + BDay(6))
-        total_nb_days = ((weekday + BDay(6)).date() - weekday).days
-        dependent_portfolio1.depends_on.add(base_portfolio)
-        dependent_portfolio2.depends_on.add(base_portfolio)
+        dependent_portfolio = portfolio_factory.create(is_lookthrough=True)
+        dependent_portfolio.depends_on.add(base_portfolio)
         base_portfolio.change_at_date(weekday)
 
-        assert mock_synchronize.call_count == 2 * (total_nb_days + 1)
+        mock_compute_lookthrough.assert_called_once_with(
+            dependent_portfolio, weekday, portfolio_total_asset_value=base_portfolio_total_asset_under_management
+        )
 
     def test_is_active_at_date(
         self,
         portfolio,
-        instrument_factory,
     ):
         # a portfolio is active at a date if it is active or the deletion time is greater than that date AND if there is instruments attached, at least one instrument is still active as well
 
@@ -339,12 +338,15 @@ class TestPortfolioModel(PortfolioTestMixin):
         next_day = (weekday + BDay(1)).date()
 
         i1 = instrument_factory.create(currency=portfolio.currency)
+        price1_0 = instrument_price_factory.create(instrument=i1, date=(weekday - BDay(1)).date())  # noqa
         price1_1 = instrument_price_factory.create(instrument=i1, date=weekday)
         price1_2 = instrument_price_factory.create(instrument=i1, date=next_day)
         i2 = instrument_factory.create(currency=portfolio.currency)
+        price2_0 = instrument_price_factory.create(instrument=i2, date=(weekday - BDay(1)).date())  # noqa
         price2_1 = instrument_price_factory.create(instrument=i2, date=weekday)
         price2_2 = instrument_price_factory.create(instrument=i2, date=next_day)
         i3 = instrument_factory.create(currency=portfolio.currency)
+        price3_0 = instrument_price_factory.create(instrument=i3, date=(weekday - BDay(1)).date())  # noqa
         price3_1 = instrument_price_factory.create(instrument=i3, date=weekday)
         price3_2 = instrument_price_factory.create(instrument=i3, date=next_day)
         i4 = instrument_factory.create(currency=portfolio.currency)
@@ -352,34 +354,34 @@ class TestPortfolioModel(PortfolioTestMixin):
         a1_1 = asset_position_factory.create(
             portfolio=portfolio,
             underlying_instrument=i1,
-            underlying_instrument_price=price1_1,
+            underlying_quote_price=price1_1,
             date=weekday,
             weighting=Decimal(0.4),
         )
         a2_1 = asset_position_factory.create(
             portfolio=portfolio,
             underlying_instrument=i2,
-            underlying_instrument_price=price2_1,
+            underlying_quote_price=price2_1,
             date=weekday,
             weighting=Decimal(0.3),
         )
         a3_1 = asset_position_factory.create(
             portfolio=portfolio,
             underlying_instrument=i3,
-            underlying_instrument_price=price3_1,
+            underlying_quote_price=price3_1,
             date=weekday,
             weighting=Decimal(0.2),
         )
         a4_1 = asset_position_factory.create(  # noqa
             portfolio=portfolio,
             underlying_instrument=i4,
-            underlying_instrument_price=None,  # the price won't be created automatically by the fixture, we expect this position to be removed from the propagated portfolio
+            underlying_quote_price=None,  # the price won't be created automatically by the fixture, we expect this position to be removed from the propagated portfolio
             date=weekday,
             weighting=Decimal(0.1),
         )
 
         # Test basic output
-        portfolio.propagate_or_update_assets(weekday, next_day, delete_existing_assets=False)
+        portfolio.propagate_or_update_assets(weekday, next_day)
         a1_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i1)
         a2_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i2)
         a3_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i3)
@@ -397,16 +399,16 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert a2_2.weighting == pytest.approx(contrib_2 / (contrib_1 + contrib_2 + contrib_3), rel=Decimal(1e4))
         assert a3_2.weighting == pytest.approx(contrib_3 / (contrib_1 + contrib_2 + contrib_3), rel=Decimal(1e4))
 
-        # Test if a deleted assets is kept if delete_existing_assets is set to True
-        a1_1.delete()
-        portfolio.propagate_or_update_assets(weekday, next_day, delete_existing_assets=True)
-        with pytest.raises(AssetPosition.DoesNotExist):
-            a1_2.refresh_from_db()
+        # # Test if a deleted assets is kept if delete_existing_assets is set to True
+        # a1_1.delete()
+        # portfolio.propagate_or_update_assets(weekday, next_day, delete_existing_assets=True)
+        # with pytest.raises(AssetPosition.DoesNotExist):
+        #     a1_2.refresh_from_db()
 
-        a2_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i2)
-        a3_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i3)
-        assert a2_2
-        assert a3_2
+        # a2_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i2)
+        # a3_2 = AssetPosition.objects.get(portfolio=portfolio, date=next_day, underlying_instrument=i3)
+        # assert a2_2
+        # assert a3_2
 
         # Test that we don't do anything on target portfolio because there is a non estimated position
         a2_2.is_estimated = False
@@ -421,23 +423,26 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert a3_2.weighting == a3_2_weighting
 
     def test_propagate_or_update_assets_active_states(
-        self, weekday, active_product, asset_position_factory, instrument
+        self, weekday, active_product, asset_position_factory, instrument_price_factory, instrument
     ):
         next_day = (weekday + BDay(1)).date()
 
         portfolio = active_product.portfolio
+        instrument_price_factory.create(date=(weekday - BDay(1)).date(), instrument=instrument)
 
         a1 = asset_position_factory.create(
             portfolio=portfolio, date=weekday, underlying_instrument=instrument, currency=instrument.currency
         )
-        asset_position_factory.create(
-            portfolio=portfolio,
-            date=next_day,
-            underlying_instrument=instrument,
-            currency=instrument.currency,
-            exchange=a1.exchange,
-            portfolio_created=a1.portfolio_created,
-        )
+        instrument_price_factory.create(date=next_day, instrument=instrument)
+
+        # asset_position_factory.create(
+        #     portfolio=portfolio,
+        #     date=next_day,
+        #     underlying_instrument=instrument,
+        #     currency=instrument.currency,
+        #     exchange=a1.exchange,
+        #     portfolio_created=a1.portfolio_created,
+        # )
         active_product.delisted_date = weekday
         active_product.save()
         # Test1: test if unactive portfolio keep having the to date assets. (asset found at next day are suppose to be deleted when the portfolio is non active at the from date)
@@ -461,7 +466,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         a1.initial_shares *= 2
         a1.save()
         portfolio.propagate_or_update_assets(weekday, next_day)
-        a_future.refresh_from_db()
+        a_future = AssetPosition.objects.get(portfolio=portfolio, date=next_day)
         assert a_future.initial_shares == initial_shares * 2
 
         # Test that non-estimated shares are not being updated
@@ -484,22 +489,9 @@ class TestPortfolioModel(PortfolioTestMixin):
         a_future.is_estimated = True
         a_future.save()
         portfolio.propagate_or_update_assets(weekday, next_day)
-        a_future.refresh_from_db()
+        a_future = AssetPosition.objects.get(portfolio=portfolio, date=next_day)
         assert a_future.weighting == 0
 
-    @patch.object(PortfolioSynchronization, "synchronize")
-    @pytest.mark.parametrize("timedelta_days", [fake.pyint(min_value=1, max_value=10)])
-    def test_resynchronize_history(
-        self, mock_fct, portfolio, asset_position_factory, weekday, timedelta_days, portfolio_synchronization
-    ):
-        portfolio.portfolio_synchronization = portfolio_synchronization
-        portfolio.save()
-        asset_position_factory.create(portfolio=portfolio, date=weekday)
-        portfolio.resynchronize_history(weekday, (weekday + BDay(timedelta_days)).date())
-        mock_fct.call_count == timedelta_days
-        with pytest.raises(ValueError):
-            portfolio.resynchronize_history((weekday + BDay(timedelta_days)).date(), weekday)
-
     def test_update_preferred_classification_per_instrument(
         self, portfolio, asset_position_factory, equity_factory, classification_factory, classification_group_factory
     ):
@@ -548,76 +540,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         res1.refresh_from_db()
         assert res1
 
-    def test_import_positions_at_date(self, portfolio_factory, asset_position_factory, instrument_factory, weekday):
-        def _serialize(obj):
-            return {
-                "portfolio": obj.portfolio.id,
-                "portfolio_created": obj.portfolio_created.id if obj.portfolio_created else None,
-                "underlying_instrument": obj.underlying_instrument.id,
-                "date": obj.date,
-                "currency": obj.currency.id,
-                "weighting": obj.weighting,
-                "initial_currency_fx_rate": obj.initial_currency_fx_rate,
-                "initial_shares": obj.initial_shares,
-                "initial_price": obj.initial_price,
-                "is_estimated": obj.is_estimated,
-                "exchange": obj.exchange.id if obj.exchange else None,
-                "asset_valuation_date": obj.asset_valuation_date,
-            }
-
-        portfolio = portfolio_factory.create()
-
-        i1 = instrument_factory.create()
-        i2 = instrument_factory.create()
-        a1 = asset_position_factory.build(
-            portfolio=portfolio, date=weekday, underlying_instrument=i1, currency=i1.currency, weighting=0.5
-        )
-        a2 = asset_position_factory.build(
-            portfolio=portfolio, date=weekday, underlying_instrument=i2, currency=i2.currency, weighting=0.25
-        )
-        a3 = asset_position_factory.build(
-            portfolio=portfolio,
-            currency=i2.currency,
-            underlying_instrument=i2,
-            initial_price=a2.initial_price,
-            date=weekday,
-            weighting=0.25,
-        )
-
-        portfolio.import_positions_at_date(
-            PortfolioDTO([a1._build_dto(), a2._build_dto(), a3._build_dto()]),
-            weekday,
-        )
-
-        res1 = AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i1)
-        res2 = AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i2)
-
-        assert portfolio.assets.filter(date=weekday).count() == 2
-
-        assert res1.initial_shares == a1.initial_shares
-        assert res1.weighting == a1.weighting / (a1.weighting + a2.weighting + a3.weighting)
-        assert res1.initial_currency_fx_rate == a1.initial_currency_fx_rate
-        assert res1.initial_price == a1.initial_price
-
-        assert res2.initial_shares == a2.initial_shares + a3.initial_shares
-        assert res2.weighting == a2.weighting + a3.weighting
-        assert res2.initial_currency_fx_rate == (a2.initial_currency_fx_rate + a3.initial_currency_fx_rate) / 2
-        assert res2.initial_price == (a2.initial_price + a3.initial_price) / 2
-
-        assert portfolio.assets.filter(date=weekday, underlying_instrument=a2.underlying_instrument).count() == 1
-        assert not portfolio.assets.filter(
-            date=weekday, underlying_instrument=a2.underlying_instrument, initial_shares=a3.initial_shares
-        ).exists()
-
-        portfolio.import_positions_at_date(
-            PortfolioDTO([a1._build_dto()]),
-            weekday,
-        )
-        res1.refresh_from_db()
-        with pytest.raises(AssetPosition.DoesNotExist):
-            res2.refresh_from_db()
-
-    def test_get_total_value(
+    def test_get_total_asset_under_management(
         self, portfolio, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
     ):
         i1 = instrument_factory.create()
@@ -647,11 +570,11 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
 
         assert (
-            portfolio.get_total_value(weekday)
+            portfolio.get_total_asset_under_management(weekday)
             == price11.net_value * (trade_11.shares + trade_12.shares) + price2.net_value * trade_2.shares
         )
-        assert portfolio.get_total_value(previous_day) == price12.net_value * trade_12.shares
-        assert portfolio.get_total_value(previous_day - BDay(1)) == Decimal(0)
+        assert portfolio.get_total_asset_under_management(previous_day) == price12.net_value * trade_12.shares
+        assert portfolio.get_total_asset_under_management(previous_day - BDay(1)) == Decimal(0)
 
     def test_tracked_object(self, portfolio, asset_position_factory):
         assert not Portfolio.tracked_objects.exists()
@@ -674,3 +597,545 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert set(Portfolio.objects.filter_invested_at_date(date(2024, 1, 1))) == set()
         assert set(Portfolio.objects.filter_invested_at_date(date(2024, 1, 2))) == {portfolio}
         assert set(Portfolio.objects.filter_invested_at_date(date(2024, 1, 1))) == set()
+
+    def test_compute_lookthrough(
+        self,
+        active_product,
+        weekday,
+        portfolio_factory,
+        index_factory,
+        equity_factory,
+        asset_position_factory,
+        trade_factory,
+        instrument_price_factory,
+        instrument_portfolio_through_model_factory,
+    ):
+        root_index = index_factory.create()
+        root_index_portfolio = portfolio_factory.create()
+        root_index.portfolios.add(root_index_portfolio)
+
+        index1 = index_factory.create()
+        index1_portfolio = portfolio_factory.create()
+        index1.portfolios.add(index1_portfolio)
+
+        a1 = asset_position_factory.create(
+            underlying_instrument=index1,
+            portfolio=root_index_portfolio,
+            weighting=0.6,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+
+        index2 = index_factory.create()
+        index2_portfolio = portfolio_factory.create()
+        index2.portfolios.add(index2_portfolio)
+
+        a2 = asset_position_factory.create(
+            underlying_instrument=index2,
+            portfolio=root_index_portfolio,
+            weighting=0.4,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+
+        a1_1 = asset_position_factory.create(
+            underlying_instrument=equity_factory.create(),
+            portfolio=index1_portfolio,
+            weighting=0.2,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+        a2_1 = asset_position_factory.create(
+            underlying_instrument=equity_factory.create(),
+            portfolio=index1_portfolio,
+            weighting=0.3,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+        a3_1 = asset_position_factory.create(
+            underlying_instrument=equity_factory.create(),
+            portfolio=index1_portfolio,
+            weighting=0.5,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+
+        a1_2 = asset_position_factory.create(
+            underlying_instrument=equity_factory.create(),
+            portfolio=index2_portfolio,
+            weighting=0.7,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+        a2_2 = asset_position_factory.create(
+            underlying_instrument=equity_factory.create(),
+            portfolio=index2_portfolio,
+            weighting=0.3,
+            initial_shares=None,
+            initial_price=100,
+            date=weekday,
+        )
+
+        product_base_portfolio = active_product.primary_portfolio
+        product_portfolio = portfolio_factory.create(is_lookthrough=True)
+        instrument_portfolio_through_model_factory.create(instrument=active_product, portfolio=product_portfolio)
+        trade_factory.create(
+            underlying_instrument=active_product,
+            transaction_date=weekday,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+            shares=100,
+        )
+
+        product_portfolio.depends_on.add(root_index_portfolio)
+
+        instrument_portfolio_through_model_factory.create(instrument=active_product, portfolio=product_portfolio)
+
+        instrument_price_factory.create(instrument=active_product, date=weekday)
+        trade_factory.create(
+            underlying_instrument=active_product,
+            portfolio=product_base_portfolio,
+            transaction_date=weekday,
+            shares=1000,
+            transaction_subtype="SUBSCRIPTION",
+        )
+
+        product_portfolio.compute_lookthrough(weekday)
+        assert product_portfolio.assets.filter(date=weekday).count() == 5
+        assert float(a1_1.weighting) * float(a1.weighting) == pytest.approx(
+            float(
+                product_portfolio.assets.filter(
+                    portfolio_created=index1_portfolio,
+                    underlying_instrument=a1_1.underlying_instrument,
+                    date=weekday,
+                )
+                .first()
+                .weighting
+            )
+        )
+        assert float(a2_1.weighting) * float(a1.weighting) == pytest.approx(
+            float(
+                product_portfolio.assets.filter(
+                    portfolio_created=index1_portfolio,
+                    underlying_instrument=a2_1.underlying_instrument,
+                    date=weekday,
+                )
+                .first()
+                .weighting
+            )
+        )
+        assert float(a3_1.weighting) * float(a1.weighting) == pytest.approx(
+            float(
+                product_portfolio.assets.filter(
+                    portfolio_created=index1_portfolio,
+                    underlying_instrument=a3_1.underlying_instrument,
+                    date=weekday,
+                )
+                .first()
+                .weighting
+            )
+        )
+        assert float(a1_2.weighting) * float(a2.weighting) == pytest.approx(
+            float(
+                product_portfolio.assets.filter(
+                    portfolio_created=index2_portfolio,
+                    underlying_instrument=a1_2.underlying_instrument,
+                    date=weekday,
+                )
+                .first()
+                .weighting
+            )
+        )
+        assert float(a2_2.weighting) * float(a2.weighting) == pytest.approx(
+            float(
+                product_portfolio.assets.filter(
+                    portfolio_created=index2_portfolio,
+                    underlying_instrument=a2_2.underlying_instrument,
+                    date=weekday,
+                )
+                .first()
+                .weighting
+            )
+        )
+        assert Decimal(1.0) == pytest.approx(product_portfolio.assets.aggregate(s=Sum("weighting"))["s"])
+
+    def test_estimate_net_asset_values(
+        self,
+        weekday,
+        equity_factory,
+        product_factory,
+        asset_position_factory,
+        instrument_price_factory,
+        trade_factory,
+    ):
+        while weekday.weekday() in [5, 6]:
+            weekday += timedelta(days=1)
+
+        previous_sync_date = weekday - timedelta(days=1)
+        while previous_sync_date.weekday() in [5, 6]:
+            previous_sync_date -= timedelta(days=1)
+
+        product = product_factory.create(inception_date=weekday - timedelta(days=1), delisted_date=None)
+        portfolio = product.portfolio
+
+        trade_factory.create(
+            underlying_instrument=product,
+            portfolio=portfolio,
+            transaction_date=previous_sync_date,
+            shares=1000,
+            transaction_subtype="SUBSCRIPTION",
+        )
+
+        e1 = equity_factory.create()
+        pe1_1 = instrument_price_factory.create(instrument=e1, date=previous_sync_date)
+        pe1_2 = instrument_price_factory.create(instrument=e1, date=weekday)
+        e2 = equity_factory.create()
+        pe2_1 = instrument_price_factory.create(instrument=e2, date=previous_sync_date)
+        pe2_2 = instrument_price_factory.create(instrument=e2, date=weekday)
+        e3 = equity_factory.create()
+        pe3_1 = instrument_price_factory.create(instrument=e3, date=previous_sync_date)
+        pe3_2 = instrument_price_factory.create(instrument=e3, date=weekday)
+
+        a1_1 = asset_position_factory.create(
+            underlying_instrument=e1,
+            underlying_quote_price=pe1_1,
+            portfolio=portfolio,
+            date=previous_sync_date,
+            weighting=Decimal(0.3),
+            initial_price=Decimal(100),
+            initial_shares=300,
+        )
+        a2_1 = asset_position_factory.create(
+            underlying_instrument=e2,
+            underlying_quote_price=pe2_1,
+            portfolio=portfolio,
+            date=previous_sync_date,
+            weighting=Decimal(0.5),
+            initial_price=Decimal(100),
+            initial_shares=500,
+        )
+        a3_1 = asset_position_factory.create(
+            underlying_instrument=e3,
+            underlying_quote_price=pe3_1,
+            portfolio=portfolio,
+            date=previous_sync_date,
+            weighting=Decimal(0.2),
+            initial_price=Decimal(100),
+            initial_shares=200,
+        )
+
+        a1_2 = asset_position_factory.create(
+            underlying_instrument=e1,
+            underlying_quote_price=pe1_2,
+            portfolio=portfolio,
+            date=weekday,
+            weighting=Decimal(0.3719),
+            initial_price=Decimal(150),
+            initial_shares=300,
+        )
+        a2_2 = asset_position_factory.create(
+            underlying_instrument=e2,
+            underlying_quote_price=pe2_2,
+            portfolio=portfolio,
+            date=weekday,
+            weighting=Decimal(0.4959),
+            initial_price=Decimal(120),
+            initial_shares=500,
+        )
+        a3_2 = asset_position_factory.create(
+            underlying_instrument=e3,
+            underlying_quote_price=pe3_2,
+            portfolio=portfolio,
+            date=weekday,
+            weighting=Decimal(0.1322),
+            initial_price=Decimal(80),
+            initial_shares=200,
+        )
+
+        price = instrument_price_factory.create(instrument=product, date=previous_sync_date, net_value=100)
+        portfolio.estimate_net_asset_values(weekday)
+
+        total_perf = (
+            (a1_2._price / a1_1._price - 1) * a1_1.weighting
+            + (a2_2._price / a2_1._price - 1) * a2_1.weighting
+            + (a3_2._price / a3_1._price - 1) * a3_1.weighting
+        )
+        assert product.prices.count() == 2
+        assert float(price.net_value * (Decimal(1.0) + total_perf)) == pytest.approx(
+            float(product.prices.filter(date=weekday).first().net_value)
+        )
+
+    def test_pms_instrument(self, product_group, index, product, portfolio):
+        product_group.portfolios.set([portfolio])
+        product.portfolios.set([portfolio])
+        index.portfolios.set([portfolio])
+        assert set(portfolio.pms_instruments) == {product_group, product, index}
+
+    @pytest.mark.parametrize(
+        "portfolio__is_tracked, portfolio__is_manageable, portfolio__is_lookthrough",
+        [
+            (True, True, True),
+            (True, False, True),
+            (True, False, False),
+            (False, True, True),
+            (False, True, False),
+            (False, False, True),
+            (False, False, False),
+        ],
+    )
+    def test_cannot_be_rebalanced(self, portfolio):
+        assert portfolio.can_be_rebalanced is False
+
+    @pytest.mark.parametrize(
+        "portfolio__is_tracked, portfolio__is_manageable, portfolio__is_lookthrough",
+        [
+            (True, True, False),
+        ],
+    )
+    def test_can_be_rebalanced(self, portfolio):
+        assert portfolio.can_be_rebalanced is True
+
+    def test_get_analytic_portfolio(
+        self, weekday, portfolio, asset_position_factory, instrument_factory, instrument_price_factory
+    ):
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+        p10 = instrument_price_factory.create(instrument=i1, date=(weekday - BDay(1)).date())
+        p11 = instrument_price_factory.create(instrument=i1, date=weekday)
+        p20 = instrument_price_factory.create(instrument=i2, date=(weekday - BDay(1)).date())
+        p21 = instrument_price_factory.create(instrument=i2, date=weekday)
+
+        a1 = asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i1)
+        a1.refresh_from_db()
+        a2 = asset_position_factory.create(
+            date=weekday, portfolio=portfolio, underlying_instrument=i2, weighting=Decimal(1.0) - a1.weighting
+        )
+        a2.refresh_from_db()
+
+        analytic_portfolio = portfolio.get_analytic_portfolio(weekday)
+        assert analytic_portfolio.weights.tolist() == [float(a1.weighting), float(a2.weighting)]
+        expected_X = pd.DataFrame(
+            [[float(p11.net_value / p10.net_value - Decimal(1)), float(p21.net_value / p20.net_value - Decimal(1))]],
+            columns=[i1.id, i2.id],
+            index=[weekday],
+        )
+        expected_X.index = pd.to_datetime(expected_X.index)
+        pd.testing.assert_frame_equal(analytic_portfolio.X, expected_X, check_names=False, check_freq=False)
+
+    def test_get_total_asset_value(self, weekday, portfolio, asset_position_factory):
+        a1 = asset_position_factory.create(date=weekday, portfolio=portfolio)
+        a2 = asset_position_factory.create(date=weekday, portfolio=portfolio)
+        a3 = asset_position_factory.create(date=weekday, portfolio=portfolio)
+        assert (
+            portfolio.get_total_asset_value(weekday)
+            == a1.initial_price * a1.initial_shares * a1.initial_currency_fx_rate
+            + a2.initial_price * a2.initial_shares * a2.initial_currency_fx_rate
+            + a3.initial_price * a3.initial_shares * a3.initial_currency_fx_rate
+        )
+
+    @pytest.mark.parametrize("name", fake.word())
+    def test_create_model_portfolio(self, name, currency):
+        portfolio = Portfolio.create_model_portfolio(name, currency)
+        assert portfolio.name == name
+        assert portfolio.currency == currency
+        assert portfolio.is_manageable is True
+        pms_instruments = list(portfolio.pms_instruments)
+        assert len(pms_instruments) == 1
+        assert pms_instruments[0].instrument_type.key == "index"
+        assert pms_instruments[0].name == name
+        assert pms_instruments[0].currency == currency
+
+    @patch.object(Portfolio, "propagate_or_update_assets", autospec=True)
+    def test_update_portfolio_after_investable_universe(
+        self, mock_fct, weekday, portfolio_factory, asset_position_factory
+    ):
+        untracked_portfolio = portfolio_factory.create(is_tracked=False)  # noqa
+        asset_position_factory.create(portfolio=untracked_portfolio)
+        tracked_lookthrough_portfolio = portfolio_factory.create(is_tracked=True, is_lookthrough=True)  # noqa
+        asset_position_factory.create(portfolio=tracked_lookthrough_portfolio)
+
+        update_portfolio_after_investable_universe(end_date=weekday)
+        mock_fct.assert_not_called()
+
+        tracked_portfolio = portfolio_factory.create(is_tracked=True)
+        asset_position_factory.create(portfolio=tracked_portfolio)
+
+        update_portfolio_after_investable_universe(end_date=weekday)
+        mock_fct.assert_called_once_with(tracked_portfolio, (weekday - BDay(1)).date(), weekday)
+
+    def test_get_weights(
+        self, weekday, portfolio_factory, asset_position_factory, instrument_factory, instrument_price_factory
+    ):
+        portfolio = portfolio_factory.create()
+        portfolio_created = portfolio_factory.create()
+
+        a1 = asset_position_factory.create(date=weekday, portfolio=portfolio)
+        a2 = asset_position_factory.create(date=weekday, portfolio=portfolio)
+        a3 = asset_position_factory.create(
+            date=weekday,
+            portfolio=portfolio,
+            underlying_instrument=a2.underlying_instrument,
+            portfolio_created=portfolio_created,
+        )
+        a1.refresh_from_db()
+        a2.refresh_from_db()
+        a3.refresh_from_db()
+        weights = portfolio.get_weights(weekday)
+        assert weights[a1.underlying_quote.id] == float(a1.weighting)
+        assert weights[a2.underlying_quote.id] == float(a2.weighting + a3.weighting)
+
+    def test_get_estimated_portfolio_from_weights(
+        self, weekday, portfolio, instrument, instrument_price_factory, currency_fx_rates_factory
+    ):
+        p = instrument_price_factory.create(instrument=instrument, date=weekday)
+        fx_portfolio = currency_fx_rates_factory.create(currency=portfolio.currency, date=weekday)
+        fx_instrument = currency_fx_rates_factory.create(currency=instrument.currency, date=weekday)
+
+        weights = {instrument.id: random.random()}
+        prices = {}
+
+        res = list(portfolio.get_estimated_portfolio_from_weights(weekday, weights, prices))
+        a = res[0]
+        assert len(res) == 1
+        assert a.date == weekday
+        assert a.underlying_quote == instrument
+        assert a.underlying_quote_price == p
+        assert a.initial_price == p.net_value
+        assert a.weighting == weights[instrument.id]
+        assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
+        assert a.currency_fx_rate_instrument_to_usd == fx_instrument
+
+        # ensure saving the unsave assetposition do not lead to exception
+        a.save()
+        assert a
+
+    def test_batch_portfolio_with_rebalancer(
+        self, weekday, rebalancer_factory, portfolio, asset_position_factory, instrument_price_factory
+    ):
+        middle_date = (weekday + BDay(1)).date()
+        rebalancing_date = (middle_date + BDay(1)).date()
+
+        a1 = asset_position_factory.create(date=weekday, portfolio=portfolio, weighting=0.7)
+        a2 = asset_position_factory.create(date=weekday, portfolio=portfolio, weighting=0.3)
+
+        instrument_price_factory.create(instrument=a1.underlying_instrument, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(instrument=a1.underlying_instrument, date=weekday)
+        instrument_price_factory.create(instrument=a1.underlying_instrument, date=middle_date)
+        instrument_price_factory.create(instrument=a1.underlying_instrument, date=rebalancing_date)
+        instrument_price_factory.create(instrument=a2.underlying_instrument, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(instrument=a2.underlying_instrument, date=weekday)
+        instrument_price_factory.create(instrument=a2.underlying_instrument, date=middle_date)
+        instrument_price_factory.create(instrument=a2.underlying_instrument, date=rebalancing_date)
+
+        rebalancer_factory.create(portfolio=portfolio, frequency="RRULE:FREQ=DAILY;", activation_date=rebalancing_date)
+        rebalancing_trade_proposal = portfolio.batch_portfolio(weekday, rebalancing_date)
+
+        # check that the position before the rebalancing date were created
+        assert portfolio.assets.get(date=middle_date, underlying_instrument=a1.underlying_instrument)
+        assert portfolio.assets.get(date=middle_date, underlying_instrument=a2.underlying_instrument)
+        with pytest.raises(
+            AssetPosition.DoesNotExist
+        ):  # there is no asset position because the rebalancing stopped it:
+            portfolio.assets.get(date=rebalancing_date)
+
+        # we expect a equally rebalancing (default) so both trades needs to be created
+        t1 = rebalancing_trade_proposal.trades.get(
+            transaction_date=rebalancing_date, underlying_instrument=a1.underlying_instrument
+        )
+        t2 = rebalancing_trade_proposal.trades.get(
+            transaction_date=rebalancing_date, underlying_instrument=a2.underlying_instrument
+        )
+        assert t1._target_weight == Decimal("0.5")
+        assert t2._target_weight == Decimal("0.5")
+
+        # we approve the rebalancing trade proposal
+        assert rebalancing_trade_proposal.status == "SUBMIT"
+        rebalancing_trade_proposal.approve()
+        rebalancing_trade_proposal.save()
+
+        # check that the rebalancing was applied and position reflect that
+        assert portfolio.assets.get(
+            date=rebalancing_date, underlying_instrument=a1.underlying_instrument
+        ).weighting == Decimal("0.5")
+        assert portfolio.assets.get(
+            date=rebalancing_date, underlying_instrument=a2.underlying_instrument
+        ).weighting == Decimal("0.5")
+
+    def test_bulk_create_positions(self, portfolio, weekday, asset_position_factory, instrument_factory):
+        portfolio.is_manageable = False
+        portfolio.save()
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+        i3 = instrument_factory.create()
+        a1 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i1)
+
+        # check initial creation
+        portfolio.bulk_create_positions([a1])
+        assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a1.weighting
+        assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i1
+
+        # check that if we change key value, an already exising position will be updated accordingly
+        a1.weighting = Decimal(0.5)
+        portfolio.bulk_create_positions([a1])
+        assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == Decimal(0.5)
+
+        a2 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i2)
+        portfolio.bulk_create_positions([a2])
+        assert (
+            AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i1).weighting
+            == a1.weighting
+        )
+        assert (
+            AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i2).weighting
+            == a2.weighting
+        )
+
+        a3 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i3)
+        portfolio.bulk_create_positions([a3], delete_leftovers=True)
+        assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a3.weighting
+        assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i3
+
+    def test_to_dependency_iterator(self, portfolio_factory, asset_position_factory, index, weekday):
+        Portfolio.objects.all().delete()  # ensure no portfolio remains
+        dependant_portfolio = portfolio_factory.create(name="dependant portfolio", id=1)
+        dependency_portfolio = portfolio_factory.create(name="dependency portfolio", id=2)
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=dependant_portfolio, dependency_portfolio=dependency_portfolio
+        )
+        index_portfolio = portfolio_factory.create(name="Index portfolio", id=3)
+        index.portfolios.add(index_portfolio)
+        asset_position_factory.create(portfolio=dependency_portfolio, underlying_instrument=index, date=weekday)
+
+        undependant_portfolio = portfolio_factory.create(name="undependant portfolio", id=4)
+        res = list(Portfolio.objects.all().to_dependency_iterator(weekday))
+        assert res == [index_portfolio, dependency_portfolio, dependant_portfolio, undependant_portfolio]
+
+    def test_get_returns(self, instrument_factory, instrument_price_factory, portfolio):
+        v1 = date(2025, 1, 1)
+        v2 = date(2025, 1, 2)
+        v3 = date(2025, 1, 3)
+
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+
+        i11 = instrument_price_factory.create(date=v1, instrument=i1)
+        i12 = instrument_price_factory.create(date=v2, instrument=i1)
+        i13 = instrument_price_factory.create(date=v3, instrument=i1)
+        i11.refresh_from_db()
+        i12.refresh_from_db()
+        i13.refresh_from_db()
+        returns, _ = portfolio.get_returns([i1.id, i2.id], from_date=v1, to_date=v3)
+
+        expected_returns = pd.DataFrame(
+            [[i12.net_value / i11.net_value - 1], [i13.net_value / i12.net_value - 1]],
+            index=[v2, v3],
+            columns=[i1.id],
+            dtype="float64",
+        )
+        expected_returns.index = pd.to_datetime(expected_returns.index)
+        pd.testing.assert_frame_equal(returns, expected_returns, check_names=False, check_freq=False, atol=1e-6)