wbportfolio 1.54.14__py2.py3-none-any.whl → 1.54.16__py2.py3-none-any.whl

wbportfolio/tests/models/{transactions/test_trade_proposals.py → orders/test_order_proposals.py}

@@ -7,7 +7,7 @@ import pytest
 from faker import Faker
 from pandas._libs.tslibs.offsets import BDay, BusinessMonthEnd
 
-from wbportfolio.models import Portfolio, RebalancingModel, Trade, TradeProposal
+from wbportfolio.models import Order, OrderProposal, Portfolio, RebalancingModel
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position
 
@@ -16,54 +16,55 @@ fake = Faker()
 
 # Mark tests to use Django's database
 @pytest.mark.django_db
-class TestTradeProposal:
+class TestOrderProposal:
+    def test_init(self, order_proposal):
+        assert order_proposal.id is not None
+
     # Test that the checked object is correctly set to the portfolio
-    def test_checked_object(self, trade_proposal):
+    def test_checked_object(self, order_proposal):
         """
-        Verify that the checked object is the portfolio associated with the trade proposal.
+        Verify that the checked object is the portfolio associated with the order proposal.
         """
-        assert trade_proposal.checked_object == trade_proposal.portfolio
+        assert order_proposal.checked_object == order_proposal.portfolio
 
     # Test that the evaluation date matches the trade date
-    def test_check_evaluation_date(self, trade_proposal):
+    def test_check_evaluation_date(self, order_proposal):
         """
         Ensure the evaluation date is the same as the trade date.
         """
-        assert trade_proposal.check_evaluation_date == trade_proposal.trade_date
+        assert order_proposal.check_evaluation_date == order_proposal.trade_date
 
     # Test the validated trading service functionality
-    def test_validated_trading_service(self, trade_proposal, asset_position_factory, trade_factory):
+    def test_validated_trading_service(self, order_proposal, asset_position_factory, order_factory):
         """
         Validate that the effective and target portfolios are correctly calculated.
         """
-        effective_date = (trade_proposal.trade_date - BDay(1)).date()
+        effective_date = (order_proposal.trade_date - BDay(1)).date()
 
         # Create asset positions for testing
         a1 = asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
+            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
         )
         a2 = asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
+            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
         )
 
-        # Create trades for testing
-        t1 = trade_factory.create(
-            trade_proposal=trade_proposal,
+        # Create orders for testing
+        t1 = order_factory.create(
+            order_proposal=order_proposal,
             weighting=Decimal("0.05"),
-            portfolio=trade_proposal.portfolio,
-            transaction_date=trade_proposal.trade_date,
+            portfolio=order_proposal.portfolio,
             underlying_instrument=a1.underlying_quote,
         )
-        t2 = trade_factory.create(
-            trade_proposal=trade_proposal,
+        t2 = order_factory.create(
+            order_proposal=order_proposal,
             weighting=Decimal("-0.05"),
-            portfolio=trade_proposal.portfolio,
-            transaction_date=trade_proposal.trade_date,
+            portfolio=order_proposal.portfolio,
             underlying_instrument=a2.underlying_quote,
         )
 
         # Get the validated trading service
-        validated_trading_service = trade_proposal.validated_trading_service
+        validated_trading_service = order_proposal.validated_trading_service
 
         # Assert effective and target portfolios are as expected
         assert validated_trading_service._effective_portfolio.to_dict() == {
@@ -76,116 +77,116 @@ class TestTradeProposal:
         }
 
     # Test the calculation of the last effective date
-    def test_last_effective_date(self, trade_proposal, asset_position_factory):
+    def test_last_effective_date(self, order_proposal, asset_position_factory):
         """
         Verify the last effective date is correctly determined based on asset positions.
         """
         # Without any positions, it should be the day before the trade date
         assert (
-            trade_proposal.last_effective_date == (trade_proposal.trade_date - BDay(1)).date()
+            order_proposal.last_effective_date == (order_proposal.trade_date - BDay(1)).date()
         ), "Last effective date without position should be t-1"
 
         # Create an asset position before the trade date
         a1 = asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=(trade_proposal.trade_date - BDay(5)).date()
+            portfolio=order_proposal.portfolio, date=(order_proposal.trade_date - BDay(5)).date()
         )
-        a_noise = asset_position_factory.create(portfolio=trade_proposal.portfolio, date=trade_proposal.trade_date)  # noqa
+        a_noise = asset_position_factory.create(portfolio=order_proposal.portfolio, date=order_proposal.trade_date)  # noqa
 
         # The last effective date should still be the day before the trade date due to caching
         assert (
-            trade_proposal.last_effective_date == (trade_proposal.trade_date - BDay(1)).date()
+            order_proposal.last_effective_date == (order_proposal.trade_date - BDay(1)).date()
         ), "last effective date is cached, so it won't change as is"
 
         # Reset the cache property to recalculate
-        del trade_proposal.last_effective_date
+        del order_proposal.last_effective_date
 
         # Now it should be the date of the latest position before the trade date
         assert (
-            trade_proposal.last_effective_date == a1.date
+            order_proposal.last_effective_date == a1.date
         ), "last effective date is the latest position strictly lower than trade date"
 
-    # Test finding the previous trade proposal
-    def test_previous_trade_proposal(self, trade_proposal_factory):
+    # Test finding the previous order proposal
+    def test_previous_order_proposal(self, order_proposal_factory):
         """
-        Ensure the previous trade proposal is correctly identified as the last approved proposal before the current one.
+        Ensure the previous order proposal is correctly identified as the last approved proposal before the current one.
         """
-        tp = trade_proposal_factory.create()
-        tp_previous_submit = trade_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=TradeProposal.Status.SUBMIT, trade_date=(tp.trade_date - BDay(1)).date()
+        tp = order_proposal_factory.create()
+        tp_previous_submit = order_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=OrderProposal.Status.SUBMIT, trade_date=(tp.trade_date - BDay(1)).date()
         )
-        tp_previous_approve = trade_proposal_factory.create(
-            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(2)).date()
+        tp_previous_approve = order_proposal_factory.create(
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(2)).date()
         )
-        tp_next_approve = trade_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(1)).date()
+        tp_next_approve = order_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(1)).date()
         )
 
-        # The previous valid trade proposal should be the approved one strictly before the current proposal
+        # The previous valid order proposal should be the approved one strictly before the current proposal
         assert (
-            tp.previous_trade_proposal == tp_previous_approve
-        ), "the previous valid trade proposal is the strictly before and approved trade proposal"
+            tp.previous_order_proposal == tp_previous_approve
+        ), "the previous valid order proposal is the strictly before and approved order proposal"
 
-    # Test finding the next trade proposal
-    def test_next_trade_proposal(self, trade_proposal_factory):
+    # Test finding the next order proposal
+    def test_next_order_proposal(self, order_proposal_factory):
         """
-        Verify the next trade proposal is correctly identified as the first approved proposal after the current one.
+        Verify the next order proposal is correctly identified as the first approved proposal after the current one.
         """
-        tp = trade_proposal_factory.create()
-        tp_previous_approve = trade_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(1)).date()
+        tp = order_proposal_factory.create()
+        tp_previous_approve = order_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(1)).date()
         )
-        tp_next_submit = trade_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=TradeProposal.Status.SUBMIT, trade_date=(tp.trade_date + BDay(1)).date()
+        tp_next_submit = order_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=OrderProposal.Status.SUBMIT, trade_date=(tp.trade_date + BDay(1)).date()
         )
-        tp_next_approve = trade_proposal_factory.create(
-            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(2)).date()
+        tp_next_approve = order_proposal_factory.create(
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(2)).date()
         )
 
-        # The next valid trade proposal should be the approved one strictly after the current proposal
+        # The next valid order proposal should be the approved one strictly after the current proposal
         assert (
-            tp.next_trade_proposal == tp_next_approve
-        ), "the next valid trade proposal is the strictly after and approved trade proposal"
+            tp.next_order_proposal == tp_next_approve
+        ), "the next valid order proposal is the strictly after and approved order proposal"
 
     # Test getting the default target portfolio
-    def test__get_default_target_portfolio(self, trade_proposal, asset_position_factory):
+    def test__get_default_target_portfolio(self, order_proposal, asset_position_factory):
         """
         Ensure the default target portfolio is set to the effective portfolio from the day before the trade date.
         """
-        effective_date = (trade_proposal.trade_date - BDay(1)).date()
+        effective_date = (order_proposal.trade_date - BDay(1)).date()
 
         # Create asset positions for testing
         a1 = asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
+            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
         )
         a2 = asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
+            portfolio=order_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
         )
-        asset_position_factory.create(portfolio=trade_proposal.portfolio, date=trade_proposal.trade_date)  # noise
+        asset_position_factory.create(portfolio=order_proposal.portfolio, date=order_proposal.trade_date)  # noise
 
         # The default target portfolio should match the effective portfolio
-        assert trade_proposal._get_default_target_portfolio().to_dict() == {
+        assert order_proposal._get_default_target_portfolio().to_dict() == {
             a1.underlying_quote.id: a1.weighting,
             a2.underlying_quote.id: a2.weighting,
         }
 
     # Test getting the default target portfolio with a rebalancing model
     @patch.object(RebalancingModel, "get_target_portfolio")
-    def test__get_default_target_portfolio_with_rebalancer_model(self, mock_fct, trade_proposal, rebalancer_factory):
+    def test__get_default_target_portfolio_with_rebalancer_model(self, mock_fct, order_proposal, rebalancer_factory):
         """
         Verify that the target portfolio is correctly obtained from a rebalancing model.
         """
         # Expected target portfolio from the rebalancing model
         expected_target_portfolio = PortfolioDTO(
-            positions=(Position(underlying_instrument=1, weighting=Decimal(1), date=trade_proposal.trade_date),)
+            positions=(Position(underlying_instrument=1, weighting=Decimal(1), date=order_proposal.trade_date),)
         )
         mock_fct.return_value = expected_target_portfolio
 
         # Create a rebalancer for testing
         rebalancer = rebalancer_factory.create(
-            portfolio=trade_proposal.portfolio, parameters={"rebalancer_parameter": "A"}
+            portfolio=order_proposal.portfolio, parameters={"rebalancer_parameter": "A"}
         )
-        trade_proposal.rebalancing_model = rebalancer.rebalancing_model
-        trade_proposal.save()
+        order_proposal.rebalancing_model = rebalancer.rebalancing_model
+        order_proposal.save()
 
         # Additional keyword arguments for the rebalancing model
         extra_kwargs = {"test": "test"}
@@ -196,41 +197,38 @@ class TestTradeProposal:
 
         # Assert the target portfolio matches the expected output from the rebalancing model
         assert (
-            trade_proposal._get_default_target_portfolio(**extra_kwargs) == expected_target_portfolio
+            order_proposal._get_default_target_portfolio(**extra_kwargs) == expected_target_portfolio
         ), "We expect the target portfolio to be whatever is returned by the rebalancer model"
         mock_fct.assert_called_once_with(
-            trade_proposal.portfolio, trade_proposal.trade_date, trade_proposal.last_effective_date, **expected_kwargs
+            order_proposal.portfolio, order_proposal.trade_date, order_proposal.last_effective_date, **expected_kwargs
         )
 
-    # Test normalizing trades
-    def test_normalize_trades(self, trade_proposal, trade_factory):
+    # Test normalizing orders
+    def test_normalize_orders(self, order_proposal, order_factory):
         """
-        Ensure trades are normalized to sum up to 1, handling quantization errors.
+        Ensure orders are normalized to sum up to 1, handling quantization errors.
         """
-        # Create trades for testing
-        t1 = trade_factory.create(
-            trade_proposal=trade_proposal,
-            transaction_date=trade_proposal.trade_date,
-            portfolio=trade_proposal.portfolio,
+        # Create orders for testing
+        t1 = order_factory.create(
+            order_proposal=order_proposal,
+            portfolio=order_proposal.portfolio,
             weighting=Decimal(0.2),
         )
-        t2 = trade_factory.create(
-            trade_proposal=trade_proposal,
-            transaction_date=trade_proposal.trade_date,
-            portfolio=trade_proposal.portfolio,
+        t2 = order_factory.create(
+            order_proposal=order_proposal,
+            portfolio=order_proposal.portfolio,
             weighting=Decimal(0.26),
         )
-        t3 = trade_factory.create(
-            trade_proposal=trade_proposal,
-            transaction_date=trade_proposal.trade_date,
-            portfolio=trade_proposal.portfolio,
+        t3 = order_factory.create(
+            order_proposal=order_proposal,
+            portfolio=order_proposal.portfolio,
             weighting=Decimal(0.14),
         )
 
-        # Normalize trades
-        trade_proposal.normalize_trades()
+        # Normalize orders
+        order_proposal.normalize_orders()
 
-        # Refresh trades from the database
+        # Refresh orders from the database
         t1.refresh_from_db()
         t2.refresh_from_db()
         t3.refresh_from_db()
@@ -249,23 +247,23 @@ class TestTradeProposal:
         assert t2.weighting == normalized_t2_weight + quantize_error  # Add quantize error to the largest position
         assert t3.weighting == normalized_t3_weight
 
-    # Test resetting trades
-    def test_reset_trades(self, trade_proposal, instrument_factory, instrument_price_factory, asset_position_factory):
+    # Test resetting orders
+    def test_reset_orders(self, order_proposal, instrument_factory, instrument_price_factory, asset_position_factory):
         """
-        Verify trades are correctly reset based on effective and target portfolios.
+        Verify orders are correctly reset based on effective and target portfolios.
         """
-        effective_date = trade_proposal.last_effective_date
+        effective_date = order_proposal.last_effective_date
 
         # Create instruments for testing
-        i1 = instrument_factory.create(currency=trade_proposal.portfolio.currency)
-        i2 = instrument_factory.create(currency=trade_proposal.portfolio.currency)
-        i3 = instrument_factory.create(currency=trade_proposal.portfolio.currency)
+        i1 = instrument_factory.create(currency=order_proposal.portfolio.currency)
+        i2 = instrument_factory.create(currency=order_proposal.portfolio.currency)
+        i3 = instrument_factory.create(currency=order_proposal.portfolio.currency)
         # Build initial effective portfolio constituting only from two positions of i1 and i2
         asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=effective_date, underlying_instrument=i1, weighting=Decimal("0.7")
+            portfolio=order_proposal.portfolio, date=effective_date, underlying_instrument=i1, weighting=Decimal("0.7")
         )
         asset_position_factory.create(
-            portfolio=trade_proposal.portfolio, date=effective_date, underlying_instrument=i2, weighting=Decimal("0.3")
+            portfolio=order_proposal.portfolio, date=effective_date, underlying_instrument=i2, weighting=Decimal("0.3")
         )
         p1 = instrument_price_factory.create(instrument=i1, date=effective_date)
         p2 = instrument_price_factory.create(instrument=i2, date=effective_date)
@@ -276,26 +274,26 @@ class TestTradeProposal:
             [
                 Position(
                     underlying_instrument=i2.id,
-                    date=trade_proposal.trade_date,
+                    date=order_proposal.trade_date,
                     weighting=Decimal("0.4"),
                     price=float(p2.net_value),
                 ),
                 Position(
                     underlying_instrument=i3.id,
-                    date=trade_proposal.trade_date,
+                    date=order_proposal.trade_date,
                     weighting=Decimal("0.6"),
                     price=float(p3.net_value),
                 ),
             ]
         )
 
-        # Reset trades
-        trade_proposal.reset_trades(target_portfolio=target_portfolio)
+        # Reset orders
+        order_proposal.reset_orders(target_portfolio=target_portfolio)
 
-        # Get trades for each instrument
-        t1 = trade_proposal.trades.get(underlying_instrument=i1)
-        t2 = trade_proposal.trades.get(underlying_instrument=i2)
-        t3 = trade_proposal.trades.get(underlying_instrument=i3)
+        # Get orders for each instrument
+        t1 = order_proposal.orders.get(underlying_instrument=i1)
+        t2 = order_proposal.orders.get(underlying_instrument=i2)
+        t3 = order_proposal.orders.get(underlying_instrument=i3)
 
         # Assert trade weights are correctly reset
         assert t1.weighting == Decimal("-0.7")
@@ -307,27 +305,27 @@ class TestTradeProposal:
             [
                 Position(
                     underlying_instrument=i1.id,
-                    date=trade_proposal.trade_date,
+                    date=order_proposal.trade_date,
                     weighting=Decimal("0.2"),
                     price=float(p1.net_value),
                 ),
                 Position(
                     underlying_instrument=i2.id,
-                    date=trade_proposal.trade_date,
+                    date=order_proposal.trade_date,
                     weighting=Decimal("0.3"),
                     price=float(p2.net_value),
                 ),
                 Position(
                     underlying_instrument=i3.id,
-                    date=trade_proposal.trade_date,
+                    date=order_proposal.trade_date,
                     weighting=Decimal("0.5"),
                     price=float(p3.net_value),
                 ),
             ]
         )
 
-        trade_proposal.reset_trades(target_portfolio=new_target_portfolio)
-        # Refetch the trades for each instrument
+        order_proposal.reset_orders(target_portfolio=new_target_portfolio)
+        # Refetch the orders for each instrument
         t1.refresh_from_db()
         t2.refresh_from_db()
         t3.refresh_from_db()
@@ -336,48 +334,44 @@ class TestTradeProposal:
         assert t2.weighting == Decimal("0")
         assert t3.weighting == Decimal("0.5")
 
-    def test_reset_trades_remove_invalid_trades(self, trade_proposal, trade_factory, instrument_price_factory):
+    def test_reset_orders_remove_invalid_orders(self, order_proposal, order_factory, instrument_price_factory):
         # create a invalid trade and its price
-        invalid_trade = trade_factory.create(trade_proposal=trade_proposal, weighting=0)
-        instrument_price_factory.create(
-            date=invalid_trade.transaction_date, instrument=invalid_trade.underlying_instrument
-        )
+        invalid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(0))
+        instrument_price_factory.create(date=invalid_trade.value_date, instrument=invalid_trade.underlying_instrument)
 
         # create a valid trade and its price
-        valid_trade = trade_factory.create(trade_proposal=trade_proposal, weighting=1.0)
-        instrument_price_factory.create(
-            date=valid_trade.transaction_date, instrument=valid_trade.underlying_instrument
-        )
+        valid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(1))
+        instrument_price_factory.create(date=valid_trade.value_date, instrument=valid_trade.underlying_instrument)
 
-        trade_proposal.reset_trades()
-        assert trade_proposal.trades.get(underlying_instrument=valid_trade.underlying_instrument).weighting == Decimal(
+        order_proposal.reset_orders()
+        assert order_proposal.orders.get(underlying_instrument=valid_trade.underlying_instrument).weighting == Decimal(
             "1"
         )
-        with pytest.raises(Trade.DoesNotExist):
-            trade_proposal.trades.get(underlying_instrument=invalid_trade.underlying_instrument)
+        with pytest.raises(Order.DoesNotExist):
+            order_proposal.orders.get(underlying_instrument=invalid_trade.underlying_instrument)
 
-    # Test replaying trade proposals
+    # Test replaying order proposals
     @patch.object(Portfolio, "drift_weights")
-    def test_replay(self, mock_fct, trade_proposal_factory):
+    def test_replay(self, mock_fct, order_proposal_factory):
         """
-        Ensure replaying trade proposals correctly calls drift_weights for each period.
+        Ensure replaying order proposals correctly calls drift_weights for each period.
         """
         mock_fct.return_value = None, None
 
-        # Create approved trade proposals for testing
-        tp0 = trade_proposal_factory.create(status=TradeProposal.Status.APPROVED)
-        tp1 = trade_proposal_factory.create(
+        # Create approved order proposals for testing
+        tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPROVED)
+        tp1 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=TradeProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPROVED,
             trade_date=(tp0.trade_date + BusinessMonthEnd(1)).date(),
         )
-        tp2 = trade_proposal_factory.create(
+        tp2 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=TradeProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPROVED,
             trade_date=(tp1.trade_date + BusinessMonthEnd(1)).date(),
         )
 
-        # Replay trade proposals
+        # Replay order proposals
         tp0.replay()
 
         # Expected calls to drift_weights
@@ -391,7 +385,7 @@ class TestTradeProposal:
         mock_fct.assert_has_calls(expected_calls)
 
         # Test stopping replay on a non-approved proposal
-        tp1.status = TradeProposal.Status.FAILED
+        tp1.status = OrderProposal.Status.FAILED
         tp1.save()
         expected_calls = [call(tp0.trade_date, tp1.trade_date - timedelta(days=1), stop_at_rebalancing=True)]
         mock_fct.assert_has_calls(expected_calls)
@@ -399,18 +393,18 @@ class TestTradeProposal:
     # Test estimating shares for a trade
     @patch.object(Portfolio, "get_total_asset_value")
     def test_get_estimated_shares(
-        self, mock_fct, trade_proposal, trade_factory, instrument_price_factory, instrument_factory
+        self, mock_fct, order_proposal, order_factory, instrument_price_factory, instrument_factory
     ):
         """
         Verify shares estimation based on trade weighting and instrument price.
         """
-        portfolio = trade_proposal.portfolio
+        portfolio = order_proposal.portfolio
         instrument = instrument_factory.create(currency=portfolio.currency)
-        underlying_quote_price = instrument_price_factory.create(instrument=instrument, date=trade_proposal.trade_date)
+        underlying_quote_price = instrument_price_factory.create(instrument=instrument, date=order_proposal.trade_date)
         mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
-        trade = trade_factory.create(
-            trade_proposal=trade_proposal,
-            transaction_date=trade_proposal.trade_date,
+        trade = order_factory.create(
+            order_proposal=order_proposal,
+            value_date=order_proposal.trade_date,
             portfolio=portfolio,
             underlying_instrument=instrument,
         )
@@ -418,105 +412,95 @@ class TestTradeProposal:
 
         # Assert estimated shares are correctly calculated
         assert (
-            trade_proposal.get_estimated_shares(
+            order_proposal.get_estimated_shares(
                 trade.weighting, trade.underlying_instrument, underlying_quote_price.net_value
             )
             == Decimal(1_000_000) * trade.weighting / underlying_quote_price.net_value
         )
 
     @patch.object(Portfolio, "get_total_asset_value")
-    def test_get_estimated_target_cash(self, mock_fct, trade_proposal, trade_factory, cash_factory):
-        trade_proposal.portfolio.only_weighting = False
-        trade_proposal.portfolio.save()
+    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()
         mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
-        cash = cash_factory.create(currency=trade_proposal.portfolio.currency)
-        trade_factory.create(  # equity trade
-            trade_proposal=trade_proposal,
-            transaction_date=trade_proposal.trade_date,
-            portfolio=trade_proposal.portfolio,
+        order_factory.create(  # equity trade
+            order_proposal=order_proposal,
+            value_date=order_proposal.trade_date,
+            portfolio=order_proposal.portfolio,
             weighting=Decimal("0.7"),
         )
-        trade_factory.create(  # cash trade
-            trade_proposal=trade_proposal,
-            transaction_date=trade_proposal.trade_date,
-            portfolio=trade_proposal.portfolio,
-            underlying_instrument=cash,
-            weighting=Decimal("0.2"),
-        )
 
-        target_cash_position = trade_proposal.get_estimated_target_cash(trade_proposal.portfolio.currency)
-        assert target_cash_position.weighting == Decimal("0.2") + Decimal("1.0") - (Decimal("0.7") + Decimal("0.2"))
+        target_cash_position = order_proposal.get_estimated_target_cash()
+        assert target_cash_position.weighting == Decimal("0.3")
         assert target_cash_position.initial_shares == Decimal(1_000_000) * Decimal("0.3")
 
-    def test_trade_proposal_update_inception_date(self, trade_proposal_factory, portfolio, instrument_factory):
-        # Check that if we create a prior trade proposal, the instrument inception date is updated accordingly
+    def test_order_proposal_update_inception_date(self, order_proposal_factory, portfolio, instrument_factory):
+        # Check that if we create a prior order proposal, the instrument inception date is updated accordingly
         instrument = instrument_factory.create(inception_date=None)
         instrument.portfolios.add(portfolio)
-        tp = trade_proposal_factory.create(portfolio=portfolio)
+        tp = order_proposal_factory.create(portfolio=portfolio)
         instrument.refresh_from_db()
         assert instrument.inception_date == (tp.trade_date + BDay(1)).date()
 
-        tp2 = trade_proposal_factory.create(portfolio=portfolio, trade_date=tp.trade_date - BDay(1))
+        tp2 = order_proposal_factory.create(portfolio=portfolio, trade_date=tp.trade_date - BDay(1))
         instrument.refresh_from_db()
         assert instrument.inception_date == (tp2.trade_date + BDay(1)).date()
 
-    def test_get_round_lot_size(self, trade_proposal, instrument):
+    def test_get_round_lot_size(self, order_proposal, instrument):
         # without a round lot size, we expect no normalization of shares
-        assert trade_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
+        assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
         instrument.round_lot_size = 100
         instrument.save()
 
         # if instrument has a round lot size different than 1, we expect different behavior based on whether shares is positive or negative
-        assert trade_proposal.get_round_lot_size(Decimal(66.0), instrument) == Decimal("100")
-        assert trade_proposal.get_round_lot_size(Decimal(-66.0), instrument) == Decimal(-66.0)
-        assert trade_proposal.get_round_lot_size(Decimal(-120), instrument) == Decimal(-200)
+        assert order_proposal.get_round_lot_size(Decimal(66.0), instrument) == Decimal("100")
+        assert order_proposal.get_round_lot_size(Decimal(-66.0), instrument) == Decimal(-66.0)
+        assert order_proposal.get_round_lot_size(Decimal(-120), instrument) == Decimal(-200)
 
         # exchange can disable rounding based on the lot size
         instrument.exchange.apply_round_lot_size = False
         instrument.exchange.save()
-        assert trade_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
+        assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
 
-    def test_submit_round_lot_size(self, trade_proposal, trade_factory, instrument):
-        trade_proposal.portfolio.only_weighting = False
-        trade_proposal.portfolio.save()
+    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument):
+        order_proposal.portfolio.only_weighting = False
+        order_proposal.portfolio.save()
         instrument.round_lot_size = 100
         instrument.save()
-        trade = trade_factory.create(
-            status="DRAFT",
+        trade = order_factory.create(
             underlying_instrument=instrument,
             shares=70,
-            trade_proposal=trade_proposal,
+            order_proposal=order_proposal,
             weighting=Decimal("1.0"),
         )
-        warnings = trade_proposal.submit()
-        trade_proposal.save()
+        warnings = order_proposal.submit()
+        order_proposal.save()
         assert (
             len(warnings) == 1
         )  # ensure that submit returns a warning concerning the rounded trade based on the lot size
         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, trade_proposal, trade_factory, instrument):
-        trade_proposal.portfolio.only_weighting = False
-        trade_proposal.portfolio.save()
-        trade = trade_factory.create(
-            status="DRAFT",
+    def test_submit_round_fractional_shares(self, order_proposal, order_factory, instrument):
+        order_proposal.portfolio.only_weighting = False
+        order_proposal.portfolio.save()
+        trade = order_factory.create(
             underlying_instrument=instrument,
             shares=5.6,
-            trade_proposal=trade_proposal,
+            order_proposal=order_proposal,
             weighting=Decimal("1.0"),
         )
-        trade_proposal.submit()
-        trade_proposal.save()
+        order_proposal.submit()
+        order_proposal.save()
         trade.refresh_from_db()
         assert trade.shares == 6  # we expect the fractional share to be rounded
 
     def test_ex_post(
-        self, instrument_factory, asset_position_factory, instrument_price_factory, trade_proposal_factory, portfolio
+        self, instrument_factory, asset_position_factory, instrument_price_factory, order_proposal_factory, portfolio
     ):
         """
         Tests the ex-post rebalancing mechanism of a portfolio with two instruments.
-        Verifies that weights are correctly recalculated after submitting and approving a trade proposal.
+        Verifies that weights are correctly recalculated after submitting and approving a order proposal.
         """
 
         # --- Create instruments ---
@@ -575,102 +559,82 @@ class TestTradeProposal:
         )
 
         # --- Create positions on d3 with weights adjusted for returns ---
-        msft_a3 = asset_position_factory.create(
-            portfolio=portfolio,
-            underlying_quote=msft,
-            date=d3,
-            initial_shares=10,
-            weighting=msft_a2.weighting * (Decimal("1.0") + msft_r3) / portfolio_r3,
-        )
-        apple_a3 = asset_position_factory.create(
-            portfolio=portfolio,
-            underlying_quote=apple,
-            date=d3,
-            initial_shares=1,
-            weighting=apple_a2.weighting * (Decimal("1.0") + apple_r3) / portfolio_r3,
-        )
 
-        # Check that weights on d3 sum to 1
-        total_weight_d3 = msft_a3.weighting + apple_a3.weighting
-        assert total_weight_d3 == pytest.approx(Decimal("1.0"), abs=Decimal("1e-6"))
+        # Check that weights on d2 sum to 1
+        total_weight_d2 = msft_a2.weighting + apple_a2.weighting
+        assert total_weight_d2 == pytest.approx(Decimal("1.0"), abs=Decimal("1e-6"))
 
-        # --- Create a trade proposal on d3 ---
-        trade_proposal = trade_proposal_factory.create(portfolio=portfolio, trade_date=d3)
-        trade_proposal.reset_trades()
-        # Retrieve trades for each instrument
-        trade_msft = trade_proposal.trades.get(underlying_instrument=msft)
-        trade_apple = trade_proposal.trades.get(underlying_instrument=apple)
+        # --- Create a order proposal on d3 ---
+        order_proposal = order_proposal_factory.create(portfolio=portfolio, trade_date=d3)
+        order_proposal.reset_orders()
+        # Retrieve orders for each instrument
+        orders = order_proposal.get_orders()
+        trade_msft = orders.get(underlying_instrument=msft)
+        trade_apple = orders.get(underlying_instrument=apple)
         # Check that trade weights are initially zero
         assert trade_msft.weighting == Decimal("0")
         assert trade_apple.weighting == Decimal("0")
 
+        msft_drifted = msft_a2.weighting * (Decimal("1.0") + msft_r3) / portfolio_r3
+        apple_drifted = apple_a2.weighting * (Decimal("1.0") + apple_r3) / portfolio_r3
         # --- Adjust trade weights to target 50% each ---
         target_weight = Decimal("0.5")
-        trade_msft.weighting = target_weight - msft_a3.weighting
+        trade_msft.weighting = target_weight - msft_drifted
         trade_msft.save()
 
-        trade_apple.weighting = target_weight - apple_a3.weighting
+        trade_apple.weighting = target_weight - apple_drifted
         trade_apple.save()
+        orders = order_proposal.get_orders()
+        trade_msft = orders.get(underlying_instrument=msft)
+        trade_apple = orders.get(underlying_instrument=apple)
 
         # --- Check drift factors and effective weights ---
-        assert trade_msft.drift_factor == pytest.approx(msft_a3.weighting / msft_a2.weighting, abs=Decimal("1e-6"))
-        assert trade_apple.drift_factor == pytest.approx(apple_a3.weighting / apple_a2.weighting, abs=Decimal("1e-6"))
+        assert trade_msft.daily_return == pytest.approx(msft_r3, abs=Decimal("1e-6"))
+        assert trade_apple.daily_return == pytest.approx(apple_r3, abs=Decimal("1e-6"))
 
-        assert trade_msft._effective_weight == pytest.approx(msft_a3.weighting, abs=Decimal("1e-6"))
-        assert trade_apple._effective_weight == pytest.approx(apple_a3.weighting, abs=Decimal("1e-6"))
+        assert trade_msft._effective_weight == pytest.approx(msft_drifted, abs=Decimal("1e-6"))
+        assert trade_apple._effective_weight == pytest.approx(apple_drifted, abs=Decimal("1e-6"))
 
         # Check that the target weight is the sum of drifted weight and adjustment
-        assert trade_msft._target_weight == pytest.approx(
-            msft_a2.weighting * trade_msft.drift_factor + trade_msft.weighting,
-            abs=Decimal("1e-6"),
-        )
         assert trade_msft._target_weight == pytest.approx(target_weight, abs=Decimal("1e-6"))
-
-        assert trade_apple._target_weight == pytest.approx(
-            apple_a2.weighting * trade_apple.drift_factor + trade_apple.weighting,
-            abs=Decimal("1e-6"),
-        )
         assert trade_apple._target_weight == pytest.approx(target_weight, abs=Decimal("1e-6"))
 
-        # --- Submit and approve the trade proposal ---
-        trade_proposal.submit()
-        trade_proposal.save()
-        trade_proposal.approve()
-        trade_proposal.save()
-
-        # --- Refresh positions after ex-post rebalancing ---
-        msft_a3.refresh_from_db()
-        apple_a3.refresh_from_db()
+        # --- Submit and approve the order proposal ---
+        order_proposal.submit()
+        order_proposal.save()
+        order_proposal.approve()
+        order_proposal.save()
 
         # Final check that weights have been updated to 50%
-        assert msft_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))
-        assert apple_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))
+        assert order_proposal.portfolio.assets.get(underlying_instrument=msft).weighting == pytest.approx(
+            target_weight, abs=Decimal("1e-6")
+        )
+        assert order_proposal.portfolio.assets.get(underlying_instrument=apple).weighting == pytest.approx(
+            target_weight, abs=Decimal("1e-6")
+        )
 
-    def test_replay_reset_draft_trade_proposal(
-        self, instrument, instrument_price_factory, trade_factory, trade_proposal_factory
+    def test_replay_reset_draft_order_proposal(
+        self, instrument, instrument_price_factory, order_factory, order_proposal_factory
     ):
-        trade_proposal = trade_proposal_factory.create(
-            status=TradeProposal.Status.DRAFT, trade_date=date.today() - BDay(2)
-        )
+        order_proposal = order_proposal_factory.create(trade_date=date.today() - BDay(2))
         instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(2))
         instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(1))
         instrument_price_factory.create(instrument=instrument, date=date.today())
-        trade = trade_factory.create(
+        trade = order_factory.create(
             underlying_instrument=instrument,
-            trade_proposal=trade_proposal,
+            order_proposal=order_proposal,
             weighting=1,
-            status=TradeProposal.Status.DRAFT,
         )
-        trade_proposal.submit()
-        trade_proposal.approve(replay=False)
-        trade_proposal.save()
+        order_proposal.submit()
+        order_proposal.approve(replay=False)
+        order_proposal.save()
 
-        draft_tp = trade_proposal_factory.create(portfolio=trade_proposal.portfolio, trade_date=date.today() - BDay(1))
-        assert not Trade.objects.filter(trade_proposal=draft_tp).exists()
+        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()
 
-        trade_proposal.replay()
+        order_proposal.replay()
 
-        assert Trade.objects.filter(trade_proposal=draft_tp).count() == 1
-        assert Trade.objects.get(
-            trade_proposal=draft_tp, underlying_instrument=trade.underlying_instrument
+        assert Order.objects.filter(order_proposal=draft_tp).count() == 1
+        assert Order.objects.get(
+            order_proposal=draft_tp, underlying_instrument=trade.underlying_instrument
         ).weighting == Decimal("0")