wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/tests/models/test_assets.py

@@ -27,9 +27,13 @@ class TestAssetPositionModel:
         asset_position_factory.create(portfolio=portfolio, underlying_instrument=equity)
         assert AssetPosition.country_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 1
 
-    def test_exchange_group_by(self, asset_position_factory, portfolio, exchange):
-        asset_position_factory.create(portfolio=portfolio, exchange=exchange)
-        asset_position_factory.create(portfolio=portfolio, exchange=exchange)
+    def test_exchange_group_by(self, asset_position_factory, portfolio, exchange_factory, instrument):
+        asset_position_factory.create(
+            portfolio=portfolio, exchange=exchange_factory.create(), underlying_quote=instrument
+        )
+        asset_position_factory.create(
+            portfolio=portfolio, exchange=exchange_factory.create(), underlying_quote=instrument
+        )
         assert (
             AssetPosition.exchange_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 1
         )

wbportfolio/tests/models/test_imports.py

@@ -27,21 +27,19 @@ class TestImportMixinModel:
             data["currency"] = {"key": portfolio.currency.key}
             del data["id"]
             del data["import_source"]
-            del data["transaction_ptr"]
             return data
 
         trade = trade_factory.build()
         data = {"data": [serialize(trade)]}
-        handler = TradeImportHandler(import_source)
 
         # Import non existing data
-        handler.process(data)
+        TradeImportHandler(import_source).process(data)
         assert Trade.objects.count() == 1
 
         # Import already existing data
         # import_source.data['data'][0]['shares'] *= 2
 
-        handler.process(data)
+        TradeImportHandler(import_source).process(data)
         assert Trade.objects.count() == 1
 
     def test_import_price(self, import_source, product, instrument_price_factory, instrument):
@@ -76,16 +74,12 @@ class TestImportMixinModel:
 
         def serialize(fees):
             data = model_to_dict(fees)
-            data["transaction_date"] = fees.transaction_date.strftime("%Y-%m-%d")
-            data["value_date"] = fees.value_date.strftime("%Y-%m-%d")
-            data["portfolio"] = portfolio.id
-            data["linked_product"] = product.id
-            data["portfolio"] = portfolio.id
+            data["fee_date"] = fees.fee_date.strftime("%Y-%m-%d")
+            data["product"] = product.id
             data["currency"] = {"key": portfolio.currency.key}
             del data["calculated"]
             del data["id"]
             del data["import_source"]
-            del data["transaction_ptr"]
             return data
 
         fees = fees_factory.build(calculated=False)
@@ -142,7 +136,9 @@ class TestImportMixinModel:
         data = {
             "data": [
                 self._serialize_position(
-                    asset_position_factory.build(date=val_date, underlying_instrument=instrument),
+                    asset_position_factory.build(
+                        date=val_date, underlying_instrument=instrument, weighting=Decimal("0.25")
+                    ),
                     product_portfolio,
                     instrument,
                 )
@@ -176,7 +172,7 @@ class TestImportMixinModel:
     def test_import_assetposition_product_group(
         self, import_source, product_group, currency, equity, asset_position_factory
     ):
-        positions = asset_position_factory.build(underlying_instrument=equity)
+        positions = asset_position_factory.build(underlying_instrument=equity, weighting=Decimal("1"))
         data = {"data": [self._serialize_position(positions, product_group, equity)]}
 
         # Import non existing data
@@ -188,7 +184,7 @@ class TestImportMixinModel:
     def test_import_assetposition_index(
         self, import_source, index, portfolio, currency, equity, asset_position_factory
     ):
-        positions = asset_position_factory.build(underlying_instrument=equity)
+        positions = asset_position_factory.build(underlying_instrument=equity, weighting=Decimal("1"))
         index.portfolios.add(portfolio)
         data = {"data": [self._serialize_position(positions, index, equity)]}
 

wbportfolio/tests/models/test_portfolios.py

@@ -5,12 +5,12 @@ 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.currency.factories import CurrencyFactory
 from wbcore.contrib.geography.factories import CountryFactory
 
 from wbportfolio.models import (
@@ -20,9 +20,8 @@ from wbportfolio.models import (
     PortfolioPortfolioThroughModel,
     Trade,
 )
-from wbportfolio.models.asset import AssetPositionIterator
 
-from ...models.portfolio import get_returns, update_portfolio_after_investable_universe
+from ...models.portfolio import update_portfolio_after_investable_universe
 from .utils import PortfolioTestMixin
 
 fake = Faker()
@@ -108,11 +107,10 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         assert portfolio.get_geographical_breakdown(weekday).shape[0] == 2
 
-    def test_get_currency_exposure(self, portfolio, asset_position_factory, currency_factory, equity_factory, weekday):
+    def test_get_currency_exposure(self, portfolio, asset_position_factory, equity_factory, weekday):
         a1 = asset_position_factory.create(
             portfolio=portfolio,
-            underlying_instrument=equity_factory.create(),
-            currency=currency_factory.create(),
+            underlying_instrument=equity_factory.create(currency=CurrencyFactory.create()),
             date=weekday,
         )
         asset_position_factory.create(
@@ -120,8 +118,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         asset_position_factory.create(
             portfolio=portfolio,
-            underlying_instrument=equity_factory.create(),
-            currency=currency_factory.create(),
+            underlying_instrument=equity_factory.create(currency=CurrencyFactory.create()),
             date=weekday,
         )
         assert portfolio.get_currency_exposure(weekday).shape[0] == 2
@@ -255,16 +252,18 @@ class TestPortfolioModel(PortfolioTestMixin):
 
     @patch.object(Portfolio, "estimate_net_asset_values", autospec=True)
     def test_change_at_date(self, mock_estimate_net_asset_values, asset_position_factory, portfolio, weekday):
-        asset_position_factory.create_batch(10, portfolio=portfolio, date=weekday)
+        a1 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.1"))
+        a2 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.3"))
+        a3 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.5"))
 
-        portfolio.change_at_date(weekday, recompute_weighting=True)
+        portfolio.change_at_date(weekday, fix_quantization=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)
+        cash_pos = portfolio.assets.get(date=weekday, portfolio=portfolio, underlying_quote=portfolio.cash_component)
+        assert cash_pos.weighting == Decimal("1.0") - (a1.weighting + a2.weighting + a3.weighting)
 
-        mock_estimate_net_asset_values.assert_called_once_with(portfolio, (weekday + BDay(1)).date(), weights=None)
+        mock_estimate_net_asset_values.assert_called_once_with(
+            portfolio, (weekday + BDay(1)).date(), analytic_portfolio=None
+        )
 
     @patch.object(Portfolio, "compute_lookthrough", autospec=True)
     def test_change_at_date_with_dependent_portfolio(
@@ -282,7 +281,10 @@ class TestPortfolioModel(PortfolioTestMixin):
         dependent_portfolio.depends_on.add(base_portfolio)
         base_portfolio.change_at_date(weekday)
 
-        mock_compute_lookthrough.assert_called_once_with(dependent_portfolio, weekday)
+        mock_compute_lookthrough.assert_called_once_with(
+            dependent_portfolio,
+            weekday,
+        )
 
     def test_is_active_at_date(
         self,
@@ -527,8 +529,9 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert res1
 
     def test_get_total_asset_under_management(
-        self, portfolio, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
+        self, portfolio_factory, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
     ):
+        portfolio = portfolio_factory.create()
         i1 = instrument_factory.create()
         i2 = instrument_factory.create()
         previous_day = (weekday - BDay(5)).date()
@@ -921,13 +924,13 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         analytic_portfolio = portfolio.get_analytic_portfolio(weekday)
         assert analytic_portfolio.weights.tolist() == [float(a1.weighting), float(a2.weighting)]
-        expected_X = pd.DataFrame(
+        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 + BDay(1)).date()],
         )
-        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)
+        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)
@@ -998,20 +1001,18 @@ class TestPortfolioModel(PortfolioTestMixin):
         fx_portfolio = currency_fx_rates_factory.create(currency=portfolio.currency, date=weekday)
         fx_instrument = currency_fx_rates_factory.create(currency=instrument.currency, date=weekday)
         instrument_id: int = instrument.id
-        weights = {instrument_id: random.random()}
-        positions = AssetPositionIterator(
-            portfolio, prices={weekday: {instrument_id: p.net_value}}, infer_underlying_quote_price=False
-        )
-        positions.add((weekday, weights))
+        weights = {instrument_id: Decimal(random.random())}
+        portfolio.builder.prices = {weekday: {instrument_id: p.net_value}}
+        portfolio.builder.add((weekday, weights), infer_underlying_quote_price=False)
 
-        res = list(positions)
+        res = list(portfolio.builder.get_positions())
         a = res[0]
         assert len(res) == 1
         assert a.date == weekday
         assert a.underlying_quote == instrument
-        assert a.underlying_quote_price == None
+        assert a.underlying_quote_price is None
         assert a.initial_price == p.net_value
-        assert a.weighting == weights[instrument.id]
+        assert a.weighting == pytest.approx(weights[instrument.id], abs=Decimal(10e-6))
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
         assert a.currency_fx_rate_instrument_to_usd == fx_instrument
 
@@ -1033,45 +1034,48 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         i1 = instrument_factory.create(currency=portfolio.currency)
         i2 = instrument_factory.create(currency=portfolio.currency)
+
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=weekday)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=middle_date)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=rebalancing_date)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=weekday)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=middle_date)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=rebalancing_date)
+
         asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i1, weighting=0.7)
         asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i2, weighting=0.3)
 
-        instrument_price_factory.create(instrument=i1, date=(weekday - BDay(1)).date())
-        instrument_price_factory.create(instrument=i1, date=weekday)
-        instrument_price_factory.create(instrument=i1, date=middle_date)
-        instrument_price_factory.create(instrument=i1, date=rebalancing_date)
-        instrument_price_factory.create(instrument=i2, date=(weekday - BDay(1)).date())
-        instrument_price_factory.create(instrument=i2, date=weekday)
-        instrument_price_factory.create(instrument=i2, date=middle_date)
-        instrument_price_factory.create(instrument=i2, date=rebalancing_date)
-
         rebalancer_factory.create(portfolio=portfolio, frequency="RRULE:FREQ=DAILY;", activation_date=rebalancing_date)
-        positions, rebalancing_trade_proposal = portfolio.drift_weights(weekday, (rebalancing_date + BDay(1)).date())
-        assert rebalancing_trade_proposal.trade_date == rebalancing_date
-        assert rebalancing_trade_proposal.status == "SUBMIT"
-        assert set(positions.get_weights().keys()) == {
-            middle_date,
-        }, "Drifting weight with a non automatic rebalancer stops the iteration"
-
-        # 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=i1)
-        t2 = rebalancing_trade_proposal.trades.get(transaction_date=rebalancing_date, underlying_instrument=i2)
-        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(no_replay=True)
-        rebalancing_trade_proposal.save()
+        portfolio.load_builder_returns(weekday, rebalancing_date)
+        gen = portfolio.drift_weights(weekday, (rebalancing_date + BDay(1)).date(), stop_at_rebalancing=True)
+        assert next(gen)[0] == middle_date, "Drifting weight with a non automatic rebalancer stops the iteration"
+        try:
+            next(gen)
+            raise AssertionError("the next iteration should stop and return the rebalancing")
+        except StopIteration as e:
+            rebalancing_order_proposal = e.value
+            assert rebalancing_order_proposal.trade_date == rebalancing_date
+            assert rebalancing_order_proposal.status == "PENDING"
+
+            # we expect a equally rebalancing (default) so both orders needs to be created
+            orders = rebalancing_order_proposal.get_orders()
+            t1 = orders.get(value_date=rebalancing_date, underlying_instrument=i1)
+            t2 = orders.get(value_date=rebalancing_date, underlying_instrument=i2)
+            assert t1._target_weight == Decimal("0.5")
+            assert t2._target_weight == Decimal("0.5")
+
+            rebalancing_order_proposal.approve()
+            rebalancing_order_proposal.save()
+            # we approve the rebalancing order proposal
+            assert rebalancing_order_proposal.status == "APPROVED"
 
         # check that the rebalancing was applied and position reflect that
         assert portfolio.assets.get(date=rebalancing_date, underlying_instrument=i1).weighting == Decimal("0.5")
         assert portfolio.assets.get(date=rebalancing_date, underlying_instrument=i2).weighting == Decimal("0.5")
 
-    @patch("wbportfolio.models.portfolio.compute_metrics_as_task.delay")
-    def test_bulk_create_positions(
-        self, mock_compute_metrics, portfolio, weekday, asset_position_factory, instrument_factory
-    ):
+    def test_bulk_create_positions(self, portfolio, weekday, asset_position_factory, instrument_factory):
         portfolio.is_manageable = False
         portfolio.save()
         i1 = instrument_factory.create()
@@ -1080,21 +1084,17 @@ class TestPortfolioModel(PortfolioTestMixin):
         a1 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i1)
 
         # check initial creation
-        portfolio.bulk_create_positions(AssetPositionIterator(portfolio).add([a1]))
+        portfolio.builder.add([a1]).bulk_create_positions(fix_quantization=False, compute_metrics=True)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a1.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i1
 
-        mock_compute_metrics.assert_called_once_with(
-            weekday, basket_id=portfolio.id, basket_content_type_id=ContentType.objects.get_for_model(Portfolio).id
-        )
-
-        # check that if we change key value, an already exising position will be updated accordingly
+        # check that if we change key value, an already existing position will be updated accordingly
         a1.weighting = Decimal(0.5)
-        portfolio.bulk_create_positions(AssetPositionIterator(portfolio).add([a1]))
+        portfolio.builder.add([a1]).bulk_create_positions(fix_quantization=False)
         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(AssetPositionIterator(portfolio).add([a2]))
+        portfolio.builder.add([a2]).bulk_create_positions(fix_quantization=False)
         assert (
             AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i1).weighting
             == a1.weighting
@@ -1105,7 +1105,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
 
         a3 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i3)
-        portfolio.bulk_create_positions(AssetPositionIterator(portfolio).add([a3]), delete_leftovers=True)
+        portfolio.builder.add([a3]).bulk_create_positions(delete_leftovers=True, fix_quantization=False)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a3.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i3
 
@@ -1124,33 +1124,6 @@ class TestPortfolioModel(PortfolioTestMixin):
         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, asset_position_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)
-        asset_position_factory.create(date=v1, portfolio=portfolio, underlying_instrument=i1)
-        asset_position_factory.create(date=v3, portfolio=portfolio, underlying_instrument=i2)
-        i11.refresh_from_db()
-        i12.refresh_from_db()
-        i13.refresh_from_db()
-        returns = get_returns([i1.id, i2.id], from_date=v1, to_date=v3)
-
-        expected_returns = pd.DataFrame(
-            [[i12.net_value / i11.net_value - 1, 0.0], [i13.net_value / i12.net_value - 1, 0.0]],
-            index=[v2, v3],
-            columns=[i1.id, i2.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)
-
     @patch.object(Portfolio, "compute_lookthrough", autospec=True)
     def test_handle_controlling_portfolio_change_at_date(self, mock_compute_lookthrough, weekday, portfolio_factory):
         primary_portfolio = portfolio_factory.create(only_weighting=True)
@@ -1158,8 +1131,42 @@ class TestPortfolioModel(PortfolioTestMixin):
         PortfolioPortfolioThroughModel.objects.create(
             portfolio=lookthrough_portfolio,
             dependency_portfolio=primary_portfolio,
-            type=PortfolioPortfolioThroughModel.Type.PRIMARY,
+            type=PortfolioPortfolioThroughModel.Type.LOOK_THROUGH,
         )
 
         primary_portfolio.handle_controlling_portfolio_change_at_date(weekday)
         mock_compute_lookthrough.assert_called_once_with(lookthrough_portfolio, weekday)
+
+    def test_get_model_portfolio_relationships(self, portfolio_factory, asset_position_factory, weekday):
+        model_portfolio = portfolio_factory.create()
+        model_index = model_portfolio.get_or_create_index()
+        dependent_portfolio = portfolio_factory.create()
+        re1 = PortfolioPortfolioThroughModel.objects.create(
+            portfolio=dependent_portfolio,
+            dependency_portfolio=model_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re1,
+        }
+        parent_portfolio = portfolio_factory.create()
+        child_portfolio = portfolio_factory.create()
+        re2 = PortfolioPortfolioThroughModel.objects.create(
+            portfolio=child_portfolio,
+            dependency_portfolio=parent_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re1,
+        }  # child portfolio is not considered in the tree because there is no position yet
+
+        asset_position_factory.create(portfolio=parent_portfolio, underlying_instrument=model_index, date=weekday)
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {re1, re2}
+
+        dependent_portfolio.is_active = False  # disable this portfolio
+        dependent_portfolio.deletion_datetime = weekday - timedelta(days=1)
+        dependent_portfolio.save()
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re2,
+        }

wbportfolio/tests/models/test_products.py

@@ -215,3 +215,14 @@ class TestProductModel(PortfolioTestMixin):
             body=f"The product {product} will be terminated on the {product.delisted_date:%Y-%m-%d}",
             user=internal_user,
         )
+
+    def test_delist_product_disable_report(self, product, report_factory):
+        report = report_factory.create(content_object=product, is_active=True)
+        assert product.delisted_date is None
+        assert report.is_active
+
+        product.delisted_date = datetime.date.today()
+        product.save()
+
+        report.refresh_from_db()
+        assert report.is_active is False

wbportfolio/tests/models/test_splits.py

@@ -14,10 +14,6 @@ fake = Faker()
 
 @pytest.mark.django_db
 class TestAdjustmentModel:
-    @pytest.fixture()
-    def applied_adjustment(self):
-        return AdjustmentFactory.create(status=Adjustment.Status.APPLIED)
-
     @pytest.fixture()
     def old_adjustment(self):
         return AdjustmentFactory.create(status=Adjustment.Status.PENDING, date=fake.past_date())
@@ -205,7 +201,7 @@ class TestAdjustmentModel:
         post_adjustment_on_prices(adjustment.id)
         a1.refresh_from_db()
         adjustment.refresh_from_db()
-        a1.applied_adjustment == adjustment
+        assert a1.applied_adjustment == adjustment
         assert adjustment.status == Adjustment.Status.APPLIED
 
     @patch("wbportfolio.models.adjustments.send_notification")
@@ -230,5 +226,4 @@ class TestAdjustmentModel:
         mock_check_fct.return_value = False
         post_adjustment_on_prices(adjustment.id)
         adjustment.refresh_from_db()
-        mock_delay_fct.call_args[0] == user_porftolio_manager.id
         assert adjustment.status == Adjustment.Status.PENDING

wbportfolio/tests/models/test_utils.py

@@ -0,0 +1,140 @@
+from decimal import Decimal
+from unittest.mock import patch
+
+import pytest
+from pandas._libs.tslibs.offsets import BDay
+
+from wbportfolio.models import AssetPosition, Order, OrderProposal, Portfolio
+from wbportfolio.models.utils import adjust_assets, adjust_orders, adjust_quote, get_adjusted_shares
+
+
+def test_get_adjusted_shares():
+    assert get_adjusted_shares(Decimal("150"), Decimal("100"), Decimal("200")) == Decimal("75")
+
+
+@pytest.mark.django_db
+@patch.object(Order, "_get_price")
+def test_adjust_orders(mock_get_price, weekday, order_factory, instrument_factory):
+    mock_get_price.return_value = (Decimal("100"), Decimal("0"))
+    old_quote = instrument_factory.create()
+    new_quote = instrument_factory.create()
+    o1 = order_factory.create(
+        underlying_instrument=old_quote, order_proposal__trade_date=weekday, price=Decimal("100"), shares=Decimal("10")
+    )
+    o2 = order_factory.create(
+        underlying_instrument=old_quote, order_proposal__trade_date=weekday, price=Decimal("100"), shares=Decimal("20")
+    )
+    adjust_orders(Order.objects.filter(underlying_instrument=old_quote), new_quote)
+
+    o1.refresh_from_db()
+    o2.refresh_from_db()
+
+    assert o1.underlying_instrument == new_quote
+    assert o2.underlying_instrument == new_quote
+    assert o1.price == Decimal("100")
+    assert o2.price == Decimal("100")
+    assert o1.shares == Decimal("10")
+    assert o2.shares == Decimal("20")
+
+    mock_get_price.return_value = (Decimal("200"), Decimal("0"))
+    adjust_orders(Order.objects.filter(underlying_instrument=new_quote), old_quote)
+
+    o1.refresh_from_db()
+    o2.refresh_from_db()
+
+    assert o1.underlying_instrument == old_quote
+    assert o2.underlying_instrument == old_quote
+    assert o1.price == Decimal("200")
+    assert o2.price == Decimal("200")
+    assert o1.shares == Decimal("5")
+    assert o2.shares == Decimal("10")
+
+
+@pytest.mark.django_db
+def test_adjust_assets(weekday, asset_position_factory, instrument_factory, instrument_price_factory):
+    old_quote = instrument_factory.create()
+    new_quote = instrument_factory.create()
+    old_quote_price = instrument_price_factory.create(
+        instrument=old_quote, net_value=Decimal("100"), date=weekday, calculated=False
+    )
+    new_quote_price = instrument_price_factory.create(
+        instrument=new_quote, net_value=Decimal("100"), date=weekday, calculated=False
+    )
+
+    a1 = asset_position_factory.create(
+        underlying_quote=old_quote, date=weekday, initial_price=Decimal("100"), initial_shares=Decimal("10")
+    )
+    a2 = asset_position_factory.create(
+        underlying_quote=old_quote, date=weekday, initial_price=Decimal("100"), initial_shares=Decimal("20")
+    )
+    adjust_assets(AssetPosition.objects.filter(underlying_quote=old_quote), new_quote)
+
+    a1.refresh_from_db()
+    a2.refresh_from_db()
+
+    assert a1.underlying_quote == new_quote
+    assert a2.underlying_quote == new_quote
+    assert a1.underlying_quote_price == new_quote_price
+    assert a2.underlying_quote_price == new_quote_price
+    assert a1.initial_price == Decimal("100")
+    assert a2.initial_price == Decimal("100")
+    assert a1.initial_shares == Decimal("10")
+    assert a2.initial_shares == Decimal("20")
+
+    old_quote_price.net_value = new_quote_price.net_value = Decimal("200")
+    old_quote_price.save()
+    new_quote_price.save()
+
+    adjust_assets(AssetPosition.objects.filter(underlying_quote=new_quote), old_quote)
+
+    a1.refresh_from_db()
+    a2.refresh_from_db()
+
+    assert a1.underlying_quote == old_quote
+    assert a2.underlying_quote == old_quote
+    assert a1.underlying_quote_price == old_quote_price
+    assert a2.underlying_quote_price == old_quote_price
+    assert a1.initial_price == Decimal("200")
+    assert a2.initial_price == Decimal("200")
+    assert a1.initial_shares == Decimal("5")
+    assert a2.initial_shares == Decimal("10")
+
+
+@pytest.mark.django_db
+@patch("wbportfolio.models.utils.adjust_assets")
+@patch("wbportfolio.models.utils.adjust_orders")
+@patch.object(OrderProposal, "replay")
+def test_adjust_quote(mock_replay, mock_adjust_orders, mock_adjust_assets, weekday, order_factory, instrument_factory):
+    old_quote = instrument_factory.create()
+    new_quote = instrument_factory.create()
+    o1 = order_factory.create(  # noqa: F841
+        underlying_instrument=old_quote, order_proposal__trade_date=weekday, price=Decimal("100"), shares=Decimal("10")
+    )
+    o2 = order_factory.create(  # noqa: F841
+        underlying_instrument=old_quote,
+        order_proposal__trade_date=(weekday + BDay(1)),
+        price=Decimal("100"),
+        shares=Decimal("10"),
+    )
+    o3 = order_factory.create(
+        underlying_instrument=old_quote,
+        order_proposal__trade_date=(weekday + BDay(1)),
+        price=Decimal("100"),
+        shares=Decimal("10"),
+    )
+    adjust_quote(
+        old_quote,
+        new_quote,
+        adjust_after=weekday,
+        only_portfolios=Portfolio.objects.filter(id=o3.order_proposal.portfolio.id),
+    )
+
+    mock_adjust_assets.asser_called_once()
+    assert set(mock_adjust_assets.call_args[0][0]) == set(AssetPosition.objects.none())
+    assert mock_adjust_assets.call_args[0][1] == new_quote
+
+    mock_adjust_orders.assert_called_once()
+    assert set(mock_adjust_orders.call_args[0][0]) == set(Order.objects.filter(id=o3.id))
+    assert mock_adjust_orders.call_args[0][1] == new_quote
+
+    mock_replay.assert_called_once_with(reapply_order_proposal=True)

wbportfolio/tests/models/transactions/test_fees.py

@@ -2,7 +2,6 @@ from datetime import timedelta
 from decimal import Decimal
 
 import pytest
-from wbfdm.factories import CashFactory
 from wbfdm.models import InstrumentPrice
 
 from wbportfolio.models import FeeCalculation, Fees, Product
@@ -11,19 +10,14 @@ from wbportfolio.models import FeeCalculation, Fees, Product
 def fees_calculation(price_id):
     price = InstrumentPrice.objects.get(id=price_id)
     product = Product.objects.get(id=price.instrument.id)
-    cash = CashFactory.create(currency=product.currency)
     yield {
-        "portfolio": product.primary_portfolio,
-        "linked_product": product,
-        "transaction_date": price.date,
+        "product": product,
+        "fee_date": price.date,
         "transaction_subtype": Fees.Type.MANAGEMENT,
-        "underlying_instrument": cash,
         "currency": product.currency,
         "calculated": True,
         "total_value": price.net_value,
-        "total_value_fx_portfolio": price.net_value,
         "total_value_gross": price.net_value,
-        "total_value_gross_fx_portfolio": price.net_value,
     }
 
 
@@ -38,14 +32,14 @@ class TestFeesModel:
         )  # no matter if estimated or not, we expect this fee to be on the resulting queryset
         calculated_fees_d1 = fees_factory.create(  # there will be a real fee for that date, type and product, so this will be filtered out
             calculated=True,
-            linked_product=fees_d0.linked_product,
-            transaction_date=(fees_d0.transaction_date + timedelta(days=1)),
+            product=fees_d0.product,
+            fee_date=(fees_d0.fee_date + timedelta(days=1)),
             transaction_subtype=fees_d0.transaction_subtype,
         )
         real_fees_d1 = fees_factory.create(
             calculated=False,
-            linked_product=calculated_fees_d1.linked_product,
-            transaction_date=calculated_fees_d1.transaction_date,
+            product=calculated_fees_d1.product,
+            fee_date=calculated_fees_d1.fee_date,
             transaction_subtype=calculated_fees_d1.transaction_subtype,
         )
 
@@ -61,6 +55,6 @@ class TestFeesModel:
         price = instrument_price_factory.create(instrument=product)  # post save must be called to compute fees
 
         fees = Fees.objects.get(
-            linked_product=product, fee_date=price.date, calculated=True, transaction_subtype=Fees.Type.MANAGEMENT
+            product=product, fee_date=price.date, calculated=True, transaction_subtype=Fees.Type.MANAGEMENT
         )
         assert fees.total_value == pytest.approx(price.net_value, rel=Decimal(1e-4))