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

wbportfolio/tests/models/orders/test_order_proposals.py

@@ -1,7 +1,7 @@
 # Import necessary modules
 from datetime import date, timedelta
 from decimal import Decimal
-from unittest.mock import call, patch
+from unittest.mock import MagicMock, PropertyMock, call, patch
 
 import pytest
 from django.db.models import Sum
@@ -9,12 +9,20 @@ from faker import Faker
 from pandas._libs.tslibs.offsets import BDay, BusinessMonthEnd
 
 from wbportfolio.models import Order, OrderProposal, Portfolio, RebalancingModel
+from wbportfolio.order_routing import ExecutionInstruction, ExecutionStatus, RoutingException
+from wbportfolio.pms.typing import Order as OrderDTO
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position
 
 fake = Faker()
 
 
+@pytest.fixture
+def mock_adapter():
+    adapter = MagicMock()
+    return adapter
+
+
 # Mark tests to use Django's database
 @pytest.mark.django_db
 class TestOrderProposal:
@@ -36,45 +44,62 @@ class TestOrderProposal:
         assert order_proposal.check_evaluation_date == order_proposal.trade_date
 
     # Test the validated trading service functionality
-    def test_validated_trading_service(self, order_proposal, asset_position_factory, order_factory):
+    def test_validated_trading_service(
+        self, order_proposal, asset_position_factory, instrument_price_factory, instrument_factory, order_factory
+    ):
         """
         Validate that the effective and target portfolios are correctly calculated.
         """
         effective_date = (order_proposal.trade_date - BDay(1)).date()
 
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+
+        p10 = instrument_price_factory.create(instrument=i1, date=effective_date)
+        p11 = instrument_price_factory.create(instrument=i1, date=order_proposal.trade_date)
+
+        p20 = instrument_price_factory.create(instrument=i2, date=effective_date)
+        p21 = instrument_price_factory.create(instrument=i2, date=order_proposal.trade_date)
+
         # Create asset positions for testing
         a1 = asset_position_factory.create(
-            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
+            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.3"), underlying_instrument=i1
         )
         a2 = asset_position_factory.create(
-            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
+            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.7"), underlying_instrument=i2
         )
+        r1 = p11.net_value / p10.net_value - Decimal("1")
+        r2 = p21.net_value / p20.net_value - Decimal("1")
+        p_return = a1.weighting * (Decimal("1") + r1) + a2.weighting * (Decimal("1") + r2)
+        order_proposal.total_effective_portfolio_contribution = p_return
+        order_proposal.save()
 
         # Create orders for testing
         o1 = order_factory.create(
             order_proposal=order_proposal,
             weighting=Decimal("0.05"),
             portfolio=order_proposal.portfolio,
-            underlying_instrument=a1.underlying_quote,
+            underlying_instrument=i1,
         )
         o2 = order_factory.create(
             order_proposal=order_proposal,
             weighting=Decimal("-0.05"),
             portfolio=order_proposal.portfolio,
-            underlying_instrument=a2.underlying_quote,
+            underlying_instrument=i2,
         )
 
-        r1 = o1.price / a1.initial_price - Decimal("1")
-        r2 = o2.price / a2.initial_price - Decimal("1")
-        p_return = a1.weighting * (Decimal("1") + r1) + a2.weighting * (Decimal("1") + r2)
         # Get the validated trading service
-        trades = order_proposal.validated_trading_service.trades_batch.trades_map
+        trades = order_proposal.get_trades_batch().trades_map
         t1 = trades[a1.underlying_quote.id]
         t2 = trades[a2.underlying_quote.id]
 
         # Assert effective and target portfolios are as expected
-        assert t1.previous_weight == a1.weighting
-        assert t2.previous_weight == a2.weighting
+        assert t1.effective_weight == pytest.approx(
+            a1.weighting * ((r1 + Decimal("1")) / p_return), abs=Decimal("1e-8")
+        )
+        assert t2.effective_weight == pytest.approx(
+            a2.weighting * ((r2 + Decimal("1")) / p_return), abs=Decimal("1e-8")
+        )
         assert t1.target_weight == pytest.approx(
             a1.weighting * ((r1 + Decimal("1")) / p_return) + o1.weighting, abs=Decimal("1e-8")
         )
@@ -121,10 +146,10 @@ class TestOrderProposal:
             portfolio=tp.portfolio, status=OrderProposal.Status.PENDING, trade_date=(tp.trade_date - BDay(1)).date()
         )
         tp_previous_approve = order_proposal_factory.create(
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date - BDay(2)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.CONFIRMED, trade_date=(tp.trade_date - BDay(2)).date()
         )
         tp_next_approve = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date + BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.CONFIRMED, trade_date=(tp.trade_date + BDay(1)).date()
         )
 
         # The previous valid order proposal should be the approved one strictly before the current proposal
@@ -139,13 +164,13 @@ class TestOrderProposal:
         """
         tp = order_proposal_factory.create()
         tp_previous_approve = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date - BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.CONFIRMED, trade_date=(tp.trade_date - BDay(1)).date()
         )
         tp_next_submit = order_proposal_factory.create(  # noqa
             portfolio=tp.portfolio, status=OrderProposal.Status.PENDING, trade_date=(tp.trade_date + BDay(1)).date()
         )
         tp_next_approve = order_proposal_factory.create(
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date + BDay(2)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.CONFIRMED, trade_date=(tp.trade_date + BDay(2)).date()
         )
 
         # The next valid order proposal should be the approved one strictly after the current proposal
@@ -218,12 +243,12 @@ class TestOrderProposal:
         t1 = order_factory.create(
             order_proposal=order_proposal,
             portfolio=order_proposal.portfolio,
-            weighting=Decimal(0.2),
+            weighting=Decimal(0.05),
         )
         t2 = order_factory.create(
             order_proposal=order_proposal,
             portfolio=order_proposal.portfolio,
-            weighting=Decimal(0.26),
+            weighting=Decimal(0.22),
         )
         t3 = order_factory.create(
             order_proposal=order_proposal,
@@ -232,26 +257,19 @@ class TestOrderProposal:
         )
 
         # Normalize orders
-        order_proposal.normalize_orders()
+        order_proposal.normalize_orders(Decimal("0.18"))
 
         # Refresh orders from the database
         t1.refresh_from_db()
         t2.refresh_from_db()
         t3.refresh_from_db()
+        cash = order_proposal.orders.get(underlying_instrument__is_cash=True)
 
         # Expected normalized weights
-        normalized_t1_weight = Decimal("0.33333333")
-        normalized_t2_weight = Decimal("0.43333333")
-        normalized_t3_weight = Decimal("0.23333333")
-
-        # Calculate quantization error
-        quantize_error = Decimal(1) - (normalized_t1_weight + normalized_t2_weight + normalized_t3_weight)
-
-        # Assert quantization error exists and weights are normalized correctly
-        assert quantize_error
-        assert t1.weighting == normalized_t1_weight
-        assert t2.weighting == normalized_t2_weight + quantize_error  # Add quantize error to the largest position
-        assert t3.weighting == normalized_t3_weight
+        assert t1.weighting == Decimal("0.10")
+        assert t2.weighting == Decimal("0.44")
+        assert t3.weighting == Decimal("0.28")
+        assert cash.weighting == Decimal("0.18")
 
     # Test resetting orders
     def test_reset_orders(
@@ -390,15 +408,15 @@ class TestOrderProposal:
         mock_fct.return_value = iter([])
 
         # Create approved order proposals for testing
-        tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPLIED)
+        tp0 = order_proposal_factory.create(status=OrderProposal.Status.CONFIRMED)
         tp1 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=OrderProposal.Status.APPLIED,
+            status=OrderProposal.Status.CONFIRMED,
             trade_date=(tp0.trade_date + BusinessMonthEnd(1)).date(),
         )
         tp2 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=OrderProposal.Status.APPLIED,
+            status=OrderProposal.Status.CONFIRMED,
             trade_date=(tp1.trade_date + BusinessMonthEnd(1)).date(),
         )
 
@@ -422,7 +440,7 @@ class TestOrderProposal:
         mock_fct.assert_has_calls(expected_calls)
 
     # Test estimating shares for a trade
-    @patch.object(Portfolio, "get_total_asset_value")
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
     def test_get_estimated_shares(
         self, mock_fct, order_proposal, order_factory, instrument_price_factory, instrument_factory
     ):
@@ -449,7 +467,7 @@ class TestOrderProposal:
             == Decimal(1_000_000) * trade.weighting / underlying_quote_price.net_value
         )
 
-    @patch.object(Portfolio, "get_total_asset_value")
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
     def test_get_estimated_target_cash(self, mock_fct, order_proposal, order_factory, cash_factory):
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
@@ -500,17 +518,25 @@ class TestOrderProposal:
         instrument.exchange.save()
         assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
 
-    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument_factory):
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
+    def test_submit_round_lot_size(self, mock_fct, order_proposal, instrument_price_factory, order_factory):
+        initial_shares = Decimal("70")
+        price = instrument_price_factory.create(date=order_proposal.trade_date)
+        net_value = round(price.net_value, 4)
+        portfolio_value = initial_shares * net_value
+        mock_fct.return_value = portfolio_value
+
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
-        instrument = instrument_factory.create()
+        instrument = price.instrument
         instrument.round_lot_size = 100
         instrument.save()
         trade = order_factory.create(
-            underlying_instrument=instrument,
-            shares=70,
+            shares=initial_shares,
             order_proposal=order_proposal,
             weighting=Decimal("1.0"),
+            underlying_instrument=price.instrument,
+            price=net_value,
         )
         warnings = order_proposal.submit()
         order_proposal.save()
@@ -520,18 +546,34 @@ class TestOrderProposal:
         trade.refresh_from_db()
         assert trade.shares == 100  # we expect the share to be transformed from 70 to 100 (lot size of 100)
 
-    def test_submit_round_fractional_shares(self, order_proposal, order_factory):
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
+    def test_submit_round_fractional_shares(
+        self, mock_fct, instrument_price_factory, order_proposal, order_factory, asset_position_factory
+    ):
+        initial_shares = Decimal("5.6")
+        price = instrument_price_factory.create(date=order_proposal.trade_date)
+        net_value = round(price.net_value, 4)
+        portfolio_value = initial_shares * net_value
+        mock_fct.return_value = portfolio_value
+
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
+
         trade = order_factory.create(
-            shares=5.6,
+            shares=Decimal("5.6"),
             order_proposal=order_proposal,
             weighting=Decimal("1.0"),
+            underlying_instrument=price.instrument,
+            price=net_value,
         )
         order_proposal.submit()
         order_proposal.save()
         trade.refresh_from_db()
         assert trade.shares == 6  # we expect the fractional share to be rounded
+        assert trade.weighting == round((trade.shares * net_value) / portfolio_value, 8)
+        assert trade.weighting == round(
+            Decimal("1") + ((Decimal("6") - initial_shares) * net_value) / portfolio_value, 8
+        )  # we expect the weighting to be updated accrodingly
 
     def test_ex_post(
         self, instrument_factory, asset_position_factory, instrument_price_factory, order_proposal_factory, portfolio
@@ -667,12 +709,11 @@ class TestOrderProposal:
         )
         order_proposal.submit()
         order_proposal.approve()
-        order_proposal.apply(replay=False)
+        order_proposal.confirm()
         order_proposal.save()
 
         draft_tp = order_proposal_factory.create(portfolio=order_proposal.portfolio, trade_date=date.today() - BDay(1))
         assert not Order.objects.filter(order_proposal=draft_tp).exists()
-
         order_proposal.replay()
 
         assert Order.objects.filter(order_proposal=draft_tp).count() == 1
@@ -695,6 +736,37 @@ class TestOrderProposal:
         assert order.shares == Decimal(0)
         assert order.weighting == Decimal(0)
 
+    def test_order_submit_bellow_minimum_weighting(self, order_factory, order_proposal):
+        o1 = order_factory.create(order_proposal=order_proposal, price=Decimal(1), weighting=Decimal("0.8"))
+        o2 = order_factory.create(order_proposal=order_proposal, price=Decimal(1), weighting=Decimal("0.2"))
+        order_proposal.submit()
+        order_proposal.save()
+
+        o1.refresh_from_db()
+        o2.refresh_from_db()
+        assert o1.weighting == Decimal("0.8")
+        assert o2.weighting == Decimal("0.2")
+
+        order_proposal.min_weighting = Decimal("0.21")
+        order_proposal.backtodraft()
+        order_proposal.submit()
+        order_proposal.save()
+
+        o1.refresh_from_db()
+        o2.refresh_from_db()
+        assert o1.weighting == Decimal("0.8")
+        assert o2.weighting == Decimal("0")
+
+        order_proposal.approve()
+        order_proposal.apply()
+        order_proposal.save()
+        assert order_proposal.portfolio.assets.get(
+            date=order_proposal.trade_date, underlying_quote=o1.underlying_instrument
+        ).weighting == Decimal("0.8")
+        assert order_proposal.portfolio.assets.get(
+            date=order_proposal.trade_date, underlying_quote=order_proposal.cash_component
+        ).weighting == Decimal("0.2")
+
     def test_reset_order_use_desired_target_weight(self, order_proposal, order_factory):
         order1 = order_factory.create(
             order_proposal=order_proposal, weighting=Decimal("0.5"), desired_target_weight=Decimal("0.7")
@@ -735,15 +807,240 @@ class TestOrderProposal:
         order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.2"))
 
         order_proposal.reset_orders()
-        assert order_proposal.get_orders().aggregate(s=Sum("target_weight"))["s"] == Decimal(
-            "0.98"
-        ), "The total target weight leftover does not equal the stored total cash weight"
+        assert order_proposal.get_orders().exclude(underlying_instrument__is_cash=True).aggregate(
+            s=Sum("target_weight")
+        )["s"] == Decimal("0.98"), "The total target weight leftover does not equal the stored total cash weight"
 
     def test_convert_to_portfolio_always_100percent(self, order_proposal, order_factory):
         o1 = order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.5"))
         o2 = order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.3"))
 
-        portfolio = order_proposal.convert_to_portfolio()
+        portfolio = order_proposal._get_default_effective_portfolio(include_delta_weight=True)
         assert portfolio.positions_map[o1.underlying_instrument.id].weighting == Decimal("0.5")
         assert portfolio.positions_map[o2.underlying_instrument.id].weighting == Decimal("0.3")
         assert portfolio.positions_map[order_proposal.cash_component.id].weighting == Decimal("0.2")
+
+    @patch.object(OrderProposal, "custodian_router", new_callable=PropertyMock)
+    @patch.object(OrderProposal, "has_non_successful_checks", new_callable=PropertyMock)
+    def test_can_execute(
+        self, mock_has_non_successful_checks, mock_router, order_proposal, user_factory, mock_adapter
+    ):
+        user = user_factory.create()
+        mock_router.return_value = mock_adapter
+        mock_has_non_successful_checks.return_value = False
+        order_proposal.status = OrderProposal.Status.APPROVED
+        order_proposal.execution_status = ""
+
+        assert order_proposal.can_execute(user) is True
+        order_proposal.approver = user.profile
+        assert order_proposal.can_execute(user) is False
+        user.is_superuser = True
+        assert order_proposal.can_execute(user) is True
+
+        mock_router.return_value = None
+        assert order_proposal.can_execute(user) is False
+
+        mock_router.return_value = mock_adapter
+        mock_has_non_successful_checks.return_value = True
+        assert order_proposal.can_execute(user) is False
+
+        mock_has_non_successful_checks.return_value = False
+        order_proposal.status = OrderProposal.Status.PENDING
+        assert order_proposal.can_execute(user) is False
+
+        order_proposal.status = OrderProposal.Status.APPROVED
+        order_proposal.execution_status = "something"
+        assert order_proposal.can_execute(user) is False
+
+    @patch.object(OrderProposal, "custodian_router", new_callable=PropertyMock)
+    def test_refresh_execution_status(self, mock_custodian_router, order_proposal, mock_adapter):
+        mock_custodian_router.return_value = mock_adapter
+        mock_adapter.get_rebalance_status.return_value = (ExecutionStatus.PENDING, "detail")
+
+        with patch.object(order_proposal, "save", wraps=order_proposal.save) as mock_save:
+            order_proposal.refresh_execution_status()
+            assert order_proposal.execution_status == ExecutionStatus.PENDING
+            assert order_proposal.execution_status_detail == "detail"
+            mock_save.assert_called_once()
+
+    @patch.object(OrderProposal, "custodian_router", new_callable=PropertyMock)
+    def test_cancel_rebalancing_success(self, mock_custodian_router, order_proposal, mock_adapter):
+        mock_custodian_router.return_value = mock_adapter
+        mock_adapter.cancel_rebalancing.return_value = True
+        with patch.object(order_proposal, "save", wraps=order_proposal.save) as mock_save:
+            result = order_proposal.cancel_rebalancing()
+            assert result is True
+            assert order_proposal.execution_status == ExecutionStatus.CANCELLED
+            assert order_proposal.execution_comment == ""
+            assert order_proposal.execution_status_detail == ""
+            mock_save.assert_called_once()
+
+    @patch.object(OrderProposal, "custodian_router", new_callable=PropertyMock)
+    def test_cancel_rebalancing_failure(self, mock_custodian_router, order_proposal, mock_adapter):
+        mock_custodian_router.return_value = mock_adapter
+        mock_adapter.cancel_rebalancing.return_value = False
+        with patch.object(order_proposal, "save", wraps=order_proposal.save) as mock_save:
+            result = order_proposal.cancel_rebalancing()
+            assert result is False
+            # No change in status or calls to save
+            mock_save.assert_not_called()
+
+    @patch.object(OrderProposal, "custodian_router", new_callable=PropertyMock)
+    @patch.object(OrderProposal, "prepare_orders_for_execution")
+    @patch.object(OrderProposal, "handle_orders")
+    def test_execute_orders_success(self, mock_handler_error, mock_fct, mock_router, order_proposal, mock_adapter):
+        mock_router.return_value = mock_adapter
+        # Arrange
+        orders = ["order1", "order2"]
+        mock_fct.return_value = orders
+        confirmed_orders = ["confirmed1", "confirmed2"]
+        status = ExecutionStatus.PENDING
+        comment = "Success"
+        mock_adapter.submit_rebalancing.return_value = (confirmed_orders, (status, comment))
+
+        # Act
+        with patch.object(order_proposal, "save") as mock_save:
+            order_proposal.execute_orders(prioritize_target_weight=True)
+
+            # Assert
+            mock_fct.assert_called_once_with(prioritize_target_weight=True)
+            mock_adapter.submit_rebalancing.assert_called_once_with(orders)
+            mock_handler_error.assert_called_once_with(confirmed_orders)
+            assert order_proposal.execution_status == status
+            assert order_proposal.execution_comment == comment
+            mock_save.assert_called_once()
+
+    @patch.object(OrderProposal, "custodian_router", new_callable=PropertyMock)
+    @patch.object(OrderProposal, "prepare_orders_for_execution")
+    @patch.object(OrderProposal, "handle_orders")
+    def test_execute_orders_on_failure(self, mock_handler_error, mock_fct, mock_router, order_proposal, mock_adapter):
+        mock_router.return_value = mock_adapter
+        # Arrange
+        orders = ["order1", "order2"]
+        mock_fct.return_value = orders
+        mock_adapter.submit_rebalancing.side_effect = RoutingException("Failure!")
+
+        # Act
+        with patch.object(order_proposal, "save") as mock_save:
+            order_proposal.execute_orders(prioritize_target_weight=True)
+
+            # Assert
+            mock_fct.assert_called_once_with(prioritize_target_weight=True)
+            mock_adapter.submit_rebalancing.assert_called_once_with(orders)
+            mock_handler_error.assert_not_called()
+            assert order_proposal.execution_status == ExecutionStatus.FAILED
+            assert order_proposal.execution_comment == "Failure!"
+            mock_save.assert_called_once()
+
+    def test_prepare_orders_for_execution(self, order_proposal, order_factory, instrument_factory, equity_factory):
+        invalid_equity = equity_factory.create(refinitiv_identifier_code=None, ticker=None, sedol=None)
+        exotic_instrument = instrument_factory.create()
+        cash_instrument = instrument_factory.create(is_cash=True)
+        order_valid = order_factory.create(
+            order_proposal=order_proposal,
+            weighting=Decimal(0.6),
+            shares=Decimal(800),
+            execution_instruction=ExecutionInstruction.LIMIT_ORDER,
+            underlying_instrument=equity_factory.create(),
+        )
+        order_valid_but_unsupported_asset_class = order_factory.create(
+            order_proposal=order_proposal,
+            weighting=Decimal(0.6),
+            shares=Decimal(800),
+            execution_instruction=ExecutionInstruction.LIMIT_ORDER,
+            underlying_instrument=exotic_instrument,
+        )
+        order_invalid_instrument = order_factory.create(
+            order_proposal=order_proposal,
+            weighting=Decimal(0.3),
+            shares=Decimal(800),
+            underlying_instrument=invalid_equity,
+        )
+        order_zero_delta = order_factory.create(
+            order_proposal=order_proposal,
+            weighting=Decimal(0),
+            shares=Decimal(0),
+            underlying_instrument=equity_factory.create(),
+        )
+        order_cash = order_factory.create(
+            order_proposal=order_proposal,
+            weighting=Decimal(0.1),
+            shares=Decimal(200),
+            underlying_instrument=cash_instrument,
+        )
+
+        orders_dto = order_proposal.prepare_orders_for_execution()
+        assert len(orders_dto) == 1
+        order = orders_dto[0]
+        assert order.refinitiv_identifier_code == order_valid.underlying_instrument.refinitiv_identifier_code
+        assert (
+            order.bloomberg_ticker
+            == order_valid.underlying_instrument.ticker
+            + " "
+            + order_valid.underlying_instrument.exchange.bbg_composite
+        )
+        assert order.sedol == order_valid.underlying_instrument.sedol
+        assert order.execution_instruction == ExecutionInstruction.LIMIT_ORDER
+        assert order.target_shares == order_valid.shares
+        assert order.shares == order_valid.shares
+        assert order.weighting == order_valid.weighting
+        assert order.target_weight == order_valid.weighting
+        assert order.trade_date == order_proposal.trade_date
+
+        order_invalid_instrument.refresh_from_db()
+        order_valid_but_unsupported_asset_class.refresh_from_db()
+        order_zero_delta.refresh_from_db()
+        order_cash.refresh_from_db()
+
+        assert order_zero_delta.execution_status == Order.ExecutionStatus.IGNORED
+        assert order_cash.execution_status == Order.ExecutionStatus.IGNORED
+        assert order_invalid_instrument.execution_status == Order.ExecutionStatus.FAILED
+        assert order_invalid_instrument.execution_comment == "Underlying instrument does not have a valid identifier."
+        assert order_valid_but_unsupported_asset_class.execution_status == Order.ExecutionStatus.FAILED
+        assert order_valid_but_unsupported_asset_class.execution_comment.startswith("Unsupported asset class")
+
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
+    def test_handle_orders(self, mock_fct, order_proposal, order_factory):
+        o1 = order_factory.create(
+            order_proposal=order_proposal, weighting=Decimal("0.8"), shares=Decimal(800), price=Decimal(2)
+        )
+        o2 = order_factory.create(
+            order_proposal=order_proposal, weighting=Decimal("0.2"), shares=Decimal(200), price=Decimal(2)
+        )
+        portfolio_value = Decimal(800) * Decimal(2) + Decimal(200) * Decimal(2)
+        mock_fct.return_value = portfolio_value
+
+        expected_shares = round(800 * 2 / 1.2)
+        order_proposal.handle_orders(
+            [
+                OrderDTO(
+                    id=o1.id,
+                    asset_class=OrderDTO.AssetType.EQUITY,
+                    target_weight=0.8,
+                    weighting=0.8,
+                    trade_date=o1.value_date,
+                    execution_price=1.2,
+                    shares=expected_shares,  # we simulate a market fluctuation
+                    target_shares=expected_shares,
+                    comment="some comment",
+                )
+            ]
+        )
+
+        o1.refresh_from_db()
+        with pytest.raises(Order.DoesNotExist):
+            o2.refresh_from_db()
+
+        assert o1.execution_status == Order.ExecutionStatus.CONFIRMED
+        assert o1.execution_comment == "some comment"
+
+        # We do not update these fields anymore, we keep the test around in case it comes back
+        # assert o1.price == Decimal("1.2")  # check the the new execution price was updated
+        # assert (
+        #     o1.shares == expected_shares
+        # )  # check that the new shares based on the execution price got updated as well
+        # assert (
+        #     o1.weighting == round(Decimal(expected_shares * 1.2), 2) / portfolio_value
+        # )  # weighting should change slightly as we round the number of shares
+
+        assert order_proposal.orders.get(underlying_instrument__is_cash=True).weighting == Decimal("1") - o1.weighting

wbportfolio/tests/models/test_portfolios.py

@@ -924,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)
@@ -1010,7 +1010,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         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 == pytest.approx(weights[instrument.id], abs=Decimal(10e-6))
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
@@ -1053,11 +1053,11 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert next(gen)[0] == middle_date, "Drifting weight with a non automatic rebalancer stops the iteration"
         try:
             next(gen)
-            assert False, "the next iteration should stop and return the rebalancing"
+            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 == "APPROVED"
+            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()
@@ -1066,10 +1066,10 @@ class TestPortfolioModel(PortfolioTestMixin):
             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"
-            rebalancing_order_proposal.apply(replay=False)
-            rebalancing_order_proposal.save()
 
         # check that the rebalancing was applied and position reflect that
         assert portfolio.assets.get(date=rebalancing_date, underlying_instrument=i1).weighting == Decimal("0.5")
@@ -1131,7 +1131,7 @@ 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)

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