wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/tests/models/test_imports.py

@@ -0,0 +1,192 @@
+from decimal import Decimal
+
+import pytest
+from django.forms.models import model_to_dict
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbfdm.import_export.handlers.instrument_price import InstrumentPriceImportHandler
+from wbfdm.models import InstrumentPrice
+from wbportfolio.import_export.handlers.asset_position import AssetPositionImportHandler
+from wbportfolio.import_export.handlers.fees import FeesImportHandler
+from wbportfolio.import_export.handlers.trade import TradeImportHandler
+from wbportfolio.models import AssetPosition, Fees, Trade
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestImportMixinModel:
+    def test_import_trade(self, import_source, product, portfolio, trade_factory):
+        def serialize(trade):
+            data = model_to_dict(trade)
+            data["transaction_date"] = trade.transaction_date.strftime("%Y-%m-%d")
+            data["value_date"] = trade.value_date.strftime("%Y-%m-%d")
+            data["underlying_instrument"] = {"id": product.id}
+            data["portfolio"] = portfolio.id
+            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)
+        assert Trade.objects.count() == 1
+
+        # Import already existing data
+        # import_source.data['data'][0]['shares'] *= 2
+
+        handler.process(data)
+        assert Trade.objects.count() == 1
+
+    def test_import_price(self, import_source, product, instrument_price_factory, instrument):
+        def serialize(val):
+            data = model_to_dict(val)
+            for k, v in data.items():
+                if isinstance(v, Decimal):
+                    data[k] = float(v)
+            data["date"] = f"{val.date:%Y-%m-%d}"
+            data["instrument"] = {"instrument_type": "product", "id": product.id}
+            del data["id"]
+            del data["import_source"]
+            del data["currency_fx_rate_to_usd"]
+            return data
+
+        val = instrument_price_factory.build(instrument=instrument)
+        data = {"data": [serialize(val)]}
+        handler = InstrumentPriceImportHandler(import_source)
+        # Import non existing data
+        handler.process(data)
+        assert InstrumentPrice.objects.count() == 1
+
+        # Import already existing data
+        data["data"][0]["net_value"] *= 2
+        handler.process(data)
+        assert InstrumentPrice.objects.count() == 1
+
+    def test_import_fees(self, import_source, product_factory, portfolio, cash_factory, fees_factory):
+        product = product_factory.create()
+        portfolio = product.primary_portfolio
+        cash_factory.create(currency=portfolio.currency)
+
+        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["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)
+        data = {"data": [serialize(fees)]}
+        handler = FeesImportHandler(import_source)
+        # Import non existing data
+        handler.process(data)
+        assert Fees.objects.count() == 1
+
+        # Import already existing data
+        data["data"][0]["total_value"] *= 2
+        handler.process(data)
+        assert Fees.objects.count() == 1
+
+    def _serialize_position(self, pos, instrument, underlying):
+        return {
+            "date": f"{pos.date:%Y-%m-%d}",
+            "initial_shares": pos.initial_shares,
+            "initial_price": pos.initial_price,
+            "weighting": pos.weighting,
+            "initial_currency_fx_rate": Decimal(1),
+            "asset_valuation_date": f"{pos.asset_valuation_date:%Y-%m-%d}",
+            "currency": {"key": underlying.currency.key},
+            "portfolio": {"id": instrument.id, "instrument_type": instrument.security_instrument_type.key},
+            "underlying_instrument": {
+                "instrument_type": underlying.instrument_type.key,
+                "currency": {"key": underlying.currency.key},
+                "ticker": underlying.ticker,
+                "name": underlying.name,
+                "exchange": {"bbg_composite": "US"},
+            },
+        }
+
+    @pytest.mark.parametrize("val_date", [(fake.date_object())])
+    def test_import_assetposition_product(
+        self,
+        val_date,
+        import_source,
+        product_factory,
+        currency,
+        equity_factory,
+        index_factory,
+        cash_factory,
+        asset_position_factory,
+    ):
+        val_date = (val_date - BDay(0)).date()
+        product_portfolio = product_factory.create()
+        instruments = [
+            equity_factory.create(currency=currency, instrument_type__name="Equity"),
+            cash_factory.create(currency=currency, instrument_type__name="Cash"),
+            product_factory.create(currency=currency, instrument_type__name="Product"),
+            index_factory.create(currency=currency, instrument_type__name="Index"),
+        ]
+        data = {
+            "data": [
+                self._serialize_position(
+                    asset_position_factory.build(date=val_date, underlying_instrument=instrument),
+                    product_portfolio,
+                    instrument,
+                )
+                for instrument in instruments
+            ]
+        }
+        handler = AssetPositionImportHandler(import_source)
+
+        # Import non existing data
+        handler.process(data)
+        for instrument in instruments:
+            # we check that the position was created
+            a = AssetPosition.objects.get(
+                underlying_instrument=instrument, date=val_date, portfolio=product_portfolio.portfolio
+            )
+            assert a
+            # and as this is an import handle by the assetposition handler, we expect the underlying instrument price to be created from the position initial price
+            assert InstrumentPrice.objects.get(
+                instrument=instrument, date=val_date, calculated=False, net_value=a.initial_price
+            )
+
+        # Import already existing data
+        data["data"][0]["initial_price"] *= 2
+
+        handler.process(data)
+        assert AssetPosition.objects.count() == 4
+
+    def test_import_assetposition_product_group(
+        self, import_source, product_group, currency, equity, asset_position_factory
+    ):
+        positions = asset_position_factory.build(underlying_instrument=equity)
+        data = {"data": [self._serialize_position(positions, product_group, equity)]}
+
+        # Import non existing data
+        handler = AssetPositionImportHandler(import_source)
+
+        handler.process(data)
+        assert AssetPosition.objects.count() == 1
+
+    def test_import_assetposition_index(self, import_source, index, currency, equity, asset_position_factory):
+        positions = asset_position_factory.build(underlying_instrument=equity)
+        data = {"data": [self._serialize_position(positions, index, equity)]}
+
+        # Import non existing data
+        handler = AssetPositionImportHandler(import_source)
+
+        handler.process(data)
+        assert AssetPosition.objects.count() == 1

wbportfolio/tests/models/test_instrument_mixins.py

@@ -0,0 +1,48 @@
+from datetime import timedelta
+
+import pandas as pd
+import pytest
+from faker import Faker
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestInstrumentMixin:
+    def test_get_latest_valid_price(self, product, instrument_price_factory):
+        v1 = instrument_price_factory.create(instrument=product)
+        v2 = instrument_price_factory.create(instrument=product)
+        instrument_price_factory.create(instrument=product, calculated=True)
+
+        assert product.get_latest_valid_price() == v2
+        assert product.get_latest_valid_price(v1.date) == v1
+
+    def test_get_earliest_valid_price(self, product, instrument_price_factory):
+        instrument_price_factory.create(instrument=product, calculated=True)
+        v2 = instrument_price_factory.create(instrument=product)
+        v3 = instrument_price_factory.create(instrument=product)
+
+        assert product.get_earliest_valid_price() == v2
+        assert product.get_earliest_valid_price(v3.date) == v3
+
+    def test_get_price_range(self, product, instrument_price_factory):
+        v_low = instrument_price_factory.create(instrument=product, net_value=1)
+        instrument_price_factory.create(instrument=product, net_value=10)
+        v_high = instrument_price_factory.create(instrument=product, net_value=100)
+
+        res = product.get_price_range()
+        assert res["high"]["price"] == pytest.approx(float(v_high.net_value), rel=1e-4)
+        assert res["high"]["date"] == v_high.date
+        assert res["low"]["price"] == pytest.approx(float(v_low.net_value), rel=1e-4)
+        assert res["low"]["date"] == v_low.date
+        assert product.get_price_range(v_low.date - timedelta(days=1)) == dict()
+
+    def test_get_cumulative_shares(self, weekday, product, customer_trade_factory):
+        from_date = weekday
+        to_date = (weekday + pd.tseries.offsets.BDay(1)).date()
+        assert product.get_cumulative_shares(from_date, to_date).to_list() == [0.0, 0.0]
+
+        trade = customer_trade_factory.create(
+            transaction_date=weekday, underlying_instrument=product, portfolio=product.primary_portfolio
+        )
+        assert product.get_cumulative_shares(from_date, to_date).to_list() == [0.0, float(trade.shares)]

wbportfolio/tests/models/test_merge.py

@@ -0,0 +1,133 @@
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbfdm.factories import InstrumentFactory
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import (
+    Adjustment,
+    PortfolioInstrumentPreferredClassificationThroughModel,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestMergeInstrument:
+    @pytest.fixture()
+    def merged_instrument(self):
+        return InstrumentFactory.create()
+
+    @pytest.fixture()
+    def main_instrument(self):
+        return InstrumentFactory.create()
+
+    def test_assets(
+        self, main_instrument, merged_instrument, asset_position_factory, instrument_price_factory, weekday
+    ):
+        """
+        Test if the asset positions attached to the merged instrument are forwarded to the main instrument as well as the underlying instrument price
+        """
+        p1 = instrument_price_factory.create(instrument=main_instrument, calculated=False, date=weekday)
+        p2 = instrument_price_factory.create(instrument=merged_instrument, calculated=False, date=weekday)
+
+        a1 = asset_position_factory.create(underlying_instrument=main_instrument, date=weekday)
+        a2 = asset_position_factory.create(underlying_instrument=merged_instrument, date=weekday)
+
+        assert a1.underlying_instrument_price == p1
+        assert a2.underlying_instrument_price == p2
+        main_instrument.merge(merged_instrument)
+        a2.refresh_from_db()
+        a1.refresh_from_db()
+
+        assert a1.underlying_instrument == main_instrument  # Make sure this doesn't change
+        assert a1.underlying_instrument_price == p1  # Make sure this doesn't change
+        assert a2.underlying_instrument == main_instrument
+        assert a2.underlying_instrument_price == p1
+
+    def test_roles(self, main_instrument, merged_instrument, product_portfolio_role_factory):
+        """
+        Test if the role attached to the merged instrument are forwarded to the main instrument
+        """
+        role = product_portfolio_role_factory.create(instrument=merged_instrument)
+        main_instrument.merge(merged_instrument)
+        role.refresh_from_db()
+        assert role.instrument == main_instrument
+
+    def test_classifications(self, main_instrument, merged_instrument, portfolio_factory, classification_factory):
+        """
+        Test if preferred classification are forwarded to the main instrument
+        """
+        main_portfolio = portfolio_factory.create()
+        merged_portfolio = portfolio_factory.create()
+
+        PortfolioInstrumentPreferredClassificationThroughModel.objects.create(
+            instrument=main_instrument, portfolio=main_portfolio, classification=classification_factory.create()
+        )
+        PortfolioInstrumentPreferredClassificationThroughModel.objects.create(
+            instrument=merged_instrument, portfolio=merged_portfolio, classification=classification_factory.create()
+        )
+        main_instrument.merge(merged_instrument)
+
+        assert set(main_instrument.preferred_portfolio_classifications.all()) == set(
+            [main_portfolio, merged_portfolio]
+        )
+
+    def test_transactions(self, main_instrument, merged_instrument, trade_factory):
+        """
+        Test if the attached transactions to the merged instrument are forwarded to the main instrument
+        """
+        merged_t = trade_factory.create(underlying_instrument=merged_instrument)
+        main_t = trade_factory.create(underlying_instrument=main_instrument)
+
+        main_instrument.merge(merged_instrument)
+        merged_t.refresh_from_db()
+        main_t.refresh_from_db()
+
+        merged_t.underlying_instrument = main_instrument
+        main_t.underlying_instrument = main_instrument  # make sure this does not change
+
+    def test_instrument_prices(self, main_instrument, merged_instrument, instrument_price_factory, weekday):
+        """
+        Test if the attached prices to the merged instrument are forwarded to the main instrument but does not overlaps them (if price already exists, the overlapping merged price are simply deleted)
+        """
+        main_p1 = instrument_price_factory.create(instrument=main_instrument, calculated=False, date=weekday)
+
+        merged_p1 = instrument_price_factory.create(instrument=merged_instrument, calculated=False, date=weekday)
+        merged_p2 = instrument_price_factory.create(
+            instrument=merged_instrument, calculated=False, date=weekday + BDay(1)
+        )
+
+        assert main_instrument.valuations.count() == 1
+        main_instrument.merge(merged_instrument)
+
+        assert (
+            main_instrument.valuations.get(date=weekday).net_value == main_p1.net_value
+        )  # Check that the existing price was not overlaps by the merged instrument price at that day
+        assert (
+            main_instrument.valuations.get(date=weekday + BDay(1)).net_value == merged_p2.net_value
+        )  # Check that the price not existing from merged instrument was appended to the main instrument serie
+        with pytest.raises(InstrumentPrice.DoesNotExist):
+            merged_p1.refresh_from_db()
+
+    def test_adjustments(self, main_instrument, merged_instrument, adjustment_factory, weekday):
+        """
+        Test if the attached adjustments to the merged instrument are forwarded to the main instrument but does not overlaps them (if split already exists, the overlapping merged split are simply deleted)
+        """
+        main_s1 = adjustment_factory.create(instrument=main_instrument, date=weekday)
+
+        merged_s1 = adjustment_factory.create(instrument=merged_instrument, date=weekday)
+        merged_s2 = adjustment_factory.create(instrument=merged_instrument, date=weekday + BDay(1))
+        merged_s2.refresh_from_db()  # We refresh from db to cast the decimal factor to its proper number of decimal places (kind of stupid but..)
+        main_s1.refresh_from_db()
+
+        assert main_instrument.pms_adjustments.count() == 1
+        main_instrument.merge(merged_instrument)
+
+        assert (
+            main_instrument.pms_adjustments.get(date=weekday).factor == main_s1.factor
+        )  # Check that the existing split was not overlaps by the merged instrument split at that day
+        assert (
+            main_instrument.pms_adjustments.get(date=weekday + BDay(1)).factor == merged_s2.factor
+        )  # Check that the split not existing from merged instrument was appended to the main instrument serie
+        with pytest.raises(Adjustment.DoesNotExist):
+            merged_s1.refresh_from_db()

wbportfolio/tests/models/test_portfolio_cash_flow.py

@@ -0,0 +1,112 @@
+from datetime import date
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+import pytest
+from django.db.utils import IntegrityError
+
+if TYPE_CHECKING:
+    from wbportfolio.factories import DailyPortfolioCashFlowFactory
+    from wbportfolio.models.portfolio import Portfolio
+    from wbportfolio.models.portfolio_cash_flow import DailyPortfolioCashFlow
+    from wbportfolio.models.portfolio_cash_targets import PortfolioCashTarget
+
+
+@pytest.mark.django_db
+class TestDailyPortfolioCashFlowFactory:
+    def test_factory(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        assert daily_portfolio_cash_flow.pk is not None
+
+    def test_constraint_unique_value_date_portfolio(
+        self, portfolio: "Portfolio", daily_portfolio_cash_flow_factory: "DailyPortfolioCashFlowFactory"
+    ):
+        cf1 = daily_portfolio_cash_flow_factory.create(portfolio=portfolio)
+        cf2 = daily_portfolio_cash_flow_factory.create(portfolio=portfolio)
+
+        cf2.value_date = cf1.value_date
+        with pytest.raises(IntegrityError):
+            cf2.save()
+
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__pending", [False])
+    def test_estimated_total_assets(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpcf = daily_portfolio_cash_flow
+        assert dpcf.estimated_total_assets == dpcf.total_assets
+
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__pending", [True])
+    def test_estimated_total_assets_while_pending(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpcf = daily_portfolio_cash_flow
+        assert dpcf.estimated_total_assets == dpcf.total_assets + dpcf.cash_flow_forecast
+
+    def test_cash_flow_asset_ratio(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpcf = daily_portfolio_cash_flow
+        assert dpcf.cash_flow_asset_ratio == dpcf.cash_flow_forecast / dpcf.estimated_total_assets
+
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__total_assets", [Decimal(0)])
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__cash_flow_forecast", [Decimal(0)])
+    def test_cash_flow_asset_ratio_zero_assets(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        assert daily_portfolio_cash_flow.cash_flow_asset_ratio == Decimal(0)
+
+    def test_cash_pct(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpct = daily_portfolio_cash_flow
+        assert dpct.cash_pct == dpct.cash / dpct.estimated_total_assets
+
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__total_assets", [Decimal(0)])
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__cash_flow_forecast", [Decimal(0)])
+    def test_cash_pct_zero_assets(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        assert daily_portfolio_cash_flow.cash_pct == Decimal(0)
+
+    def test_true_cash(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpct = daily_portfolio_cash_flow
+        assert dpct.true_cash == dpct.cash + dpct.cash_flow_forecast
+
+    def test_true_cash_pct(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpct = daily_portfolio_cash_flow
+        assert dpct.true_cash_pct == dpct.true_cash / dpct.estimated_total_assets
+
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__total_assets", [Decimal(0)])
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__cash_flow_forecast", [Decimal(0)])
+    def test_true_cash_pct_zero_assets(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        assert daily_portfolio_cash_flow.true_cash_pct == Decimal(0)
+
+    def test_target_cash_no_target(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpct = daily_portfolio_cash_flow
+        assert dpct.target_cash == Decimal(0)
+
+    def test_target_cash(
+        self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow", portfolio_cash_target: "PortfolioCashTarget"
+    ):
+        dpct = daily_portfolio_cash_flow
+        portfolio_cash_target.portfolio = dpct.portfolio
+        portfolio_cash_target.valid_date = dpct.value_date
+        portfolio_cash_target.save()
+        dpct.save()
+        dpct.refresh_from_db()
+        assert dpct.target_cash == pytest.approx(portfolio_cash_target.target * dpct.estimated_total_assets)
+
+    def test_excess_cash(
+        self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow", portfolio_cash_target: "PortfolioCashTarget"
+    ):
+        dpct = daily_portfolio_cash_flow
+        portfolio_cash_target.portfolio = dpct.portfolio
+        portfolio_cash_target.valid_date = dpct.value_date
+        portfolio_cash_target.save()
+        dpct.save()
+        dpct.refresh_from_db()
+        assert dpct.excess_cash == dpct.true_cash - dpct.target_cash
+
+    def test_cash_from_yesterday(
+        self, portfolio: "Portfolio", daily_portfolio_cash_flow_factory: "DailyPortfolioCashFlowFactory"
+    ):
+        cf1 = daily_portfolio_cash_flow_factory.create(portfolio=portfolio, value_date=date(2020, 1, 1))
+        cf2 = daily_portfolio_cash_flow_factory.create(
+            portfolio=portfolio, value_date=date(2020, 1, 2), pending=True, rebalancing=Decimal(0)
+        )
+        cf1.refresh_from_db()
+        cf2.refresh_from_db()
+        assert cf2.cash == cf1.true_cash
+
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__cash", [Decimal(1_000_000)])
+    @pytest.mark.parametrize("daily_portfolio_cash_flow__pending", [True])
+    def test_rebalancing(self, daily_portfolio_cash_flow: "DailyPortfolioCashFlow"):
+        dpcf = daily_portfolio_cash_flow
+        assert dpcf.cash == Decimal(1_000_000) - dpcf.rebalancing

wbportfolio/tests/models/test_portfolio_cash_targets.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING
+
+import pytest
+from django.db.utils import IntegrityError
+
+if TYPE_CHECKING:
+    from wbportfolio.factories.portfolio_swing_pricings import (
+        PortfolioCashTargetFactory,
+    )
+    from wbportfolio.models.portfolio import Portfolio
+    from wbportfolio.models.portfolio_swing_pricings import PortfolioCashTarget
+
+
+@pytest.mark.django_db
+class TestPortfolioCashTarget:
+    def test_factory(self, portfolio_cash_target: "PortfolioCashTarget"):
+        assert portfolio_cash_target.pk is not None
+
+    def test_constraint_unique_valid_date_portfolio(
+        self, portfolio: "Portfolio", portfolio_cash_target_factory: "PortfolioCashTargetFactory"
+    ):
+        target1 = portfolio_cash_target_factory.create(portfolio=portfolio)
+        target2 = portfolio_cash_target_factory.create(portfolio=portfolio)
+
+        target2.valid_date = target1.valid_date
+        with pytest.raises(IntegrityError):
+            target2.save()

wbportfolio/tests/models/test_portfolio_swing_pricings.py

@@ -0,0 +1,42 @@
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+import pytest
+from django.db.utils import IntegrityError
+
+if TYPE_CHECKING:
+    from wbportfolio.factories.portfolio_swing_pricings import (
+        PortfolioSwingPricingFactory,
+    )
+    from wbportfolio.models.portfolio import Portfolio
+    from wbportfolio.models.portfolio_swing_pricings import PortfolioSwingPricing
+
+
+@pytest.mark.django_db
+class TestPortfolioSwingPricing:
+    def test_factory(self, portfolio_swing_pricing: "PortfolioSwingPricing"):
+        assert portfolio_swing_pricing.pk is not None
+
+    def test_constraint_negative_polarity(self, portfolio_swing_pricing: "PortfolioSwingPricing"):
+        portfolio_swing_pricing.negative_threshold = Decimal(0.1)
+        portfolio_swing_pricing.negative_swing_factor = Decimal(0.1)
+
+        with pytest.raises(IntegrityError):
+            portfolio_swing_pricing.save()
+
+    def test_constraint_positive_polarity(self, portfolio_swing_pricing: "PortfolioSwingPricing"):
+        portfolio_swing_pricing.positive_threshold = Decimal(-0.1)
+        portfolio_swing_pricing.positive_swing_factor = Decimal(-0.1)
+
+        with pytest.raises(IntegrityError):
+            portfolio_swing_pricing.save()
+
+    def test_constraint_unique_valid_date_portfolio(
+        self, portfolio: "Portfolio", portfolio_swing_pricing_factory: "PortfolioSwingPricingFactory"
+    ):
+        swing1 = portfolio_swing_pricing_factory.create(portfolio=portfolio)
+        swing2 = portfolio_swing_pricing_factory.create(portfolio=portfolio)
+
+        swing2.valid_date = swing1.valid_date
+        with pytest.raises(IntegrityError):
+            swing2.save()