wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/tests/models/transactions/test_claim.py

@@ -0,0 +1,129 @@
+import random
+from datetime import timedelta
+from decimal import Decimal
+
+import pytest
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Permission
+from faker import Faker
+from wbportfolio.models import Claim, Trade
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestClaimModel:
+    def test_init(self, claim):
+        assert claim.id is not None
+
+    def test_filter_claims_for_user(self, user, claim_factory, account_factory, account_role_factory):
+        from wbcore.permissions.registry import user_registry
+
+        no_account_claims = claim_factory.create(account=None)
+        private_claim = claim_factory.create(account=account_factory.create(is_public=False))
+        public_claim = claim_factory.create(account=account_role_factory.create(entry=user.profile.entry_ptr).account)
+        # if normal user, can only see its own claim, with an attached account
+        assert set(Claim.objects.filter_for_user(user)) == {public_claim}
+        user.user_permissions.add(
+            Permission.objects.get(content_type__app_label="authentication", codename="is_internal_user")
+        )
+        user_registry.reset_cache()
+        user = get_user_model().objects.get(
+            id=user.id
+        )  # we refetch user to clear perm cache, doesn't happen with refresh_from_db
+        # if insternal user, they can also see claim without account
+        assert set(Claim.objects.filter_for_user(user)) == {no_account_claims, public_claim}
+        user.user_permissions.add(
+            Permission.objects.get(content_type__app_label="wbcrm", codename="administrate_account")
+        )
+        user = get_user_model().objects.get(
+            id=user.id
+        )  # we refetch user to clear perm cache, doesn't happen with refresh_from_db
+        # administrator can see everything
+        assert set(Claim.objects.filter_for_user(user)) == {no_account_claims, public_claim, private_claim}
+
+    def test_account_merging(self, account_factory, claim):
+        base_account = account_factory.create()
+        merged_account = claim.account
+        assert base_account.reference_id != merged_account.reference_id
+        base_account.merge(merged_account)
+        claim.refresh_from_db()
+        assert claim.account == base_account
+        assert claim.reference == str(merged_account.reference_id)
+
+    @pytest.mark.parametrize(
+        "shares,unvalid_status",
+        [
+            (
+                Decimal(50),
+                random.choice(
+                    [Claim.Status.WITHDRAWN, Claim.Status.AUTO_MATCHED, Claim.Status.PENDING, Claim.Status.APPROVED]
+                ),
+            )
+        ],
+    )
+    def test_auto_match_on_claim_save(
+        self, weekday, shares, unvalid_status, product, claim_factory, customer_trade_factory
+    ):
+        valid_trade = customer_trade_factory.create(
+            underlying_instrument=product,
+            portfolio=product.primary_portfolio,
+            transaction_date=fake.date_between(
+                weekday - timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+                weekday + timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+            ),
+            shares=fake.pydecimal(min_value=int(shares - 1), max_value=int(shares + 1)),
+        )
+        claim = claim_factory.create(product=product, date=weekday, shares=shares, trade=None, status=unvalid_status)
+        assert claim.status == unvalid_status
+        assert claim.trade is None
+
+        claim = claim_factory.create(
+            product=product, date=weekday, shares=shares, trade=None, status=Claim.Status.DRAFT
+        )
+        assert claim.status == Claim.Status.AUTO_MATCHED
+        assert claim.trade == valid_trade
+
+    @pytest.mark.parametrize(
+        "shares,unvalid_status",
+        [
+            (
+                Decimal(50),
+                random.choice(
+                    [Claim.Status.WITHDRAWN, Claim.Status.AUTO_MATCHED, Claim.Status.PENDING, Claim.Status.APPROVED]
+                ),
+            )
+        ],
+    )
+    def test_claim_auto_match_on_trade_creation(
+        self, weekday, shares, unvalid_status, product, claim_factory, customer_trade_factory
+    ):
+        claim = claim_factory.create(product=product, date=weekday, shares=shares, trade=None, status=unvalid_status)
+        trade = customer_trade_factory.create(
+            underlying_instrument=product,
+            portfolio=product.primary_portfolio,
+            transaction_date=fake.date_between(
+                weekday - timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+                weekday + timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+            ),
+            shares=fake.pydecimal(min_value=int(shares - 1), max_value=int(shares + 1)),
+        )
+        assert claim.status == unvalid_status
+        assert claim.trade is None
+
+        # we delete the trade and set the claim status to draft, where we expect a newly created trade to be automatch
+        trade.delete()
+        claim.status = Claim.Status.DRAFT
+        claim.save()
+        trade = customer_trade_factory.create(
+            underlying_instrument=product,
+            portfolio=product.primary_portfolio,
+            transaction_date=fake.date_between(
+                weekday - timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+                weekday + timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+            ),
+            shares=fake.pydecimal(min_value=int(shares - 1), max_value=int(shares + 1)),
+        )
+        claim.refresh_from_db()
+        assert claim.status == Claim.Status.AUTO_MATCHED
+        assert claim.trade == trade

wbportfolio/tests/models/transactions/test_fees.py

@@ -0,0 +1,65 @@
+from datetime import timedelta
+from decimal import Decimal
+
+import pytest
+from wbfdm.factories import CashFactory
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import FeeCalculation, Fees, Product
+
+
+def fees_calculation(price_id):
+    price = InstrumentPrice.objects.get(id=price_id)
+    product = Product.objects.get(id=price.instrument.id)
+    cash = CashFactory.create(currency=product.currency)
+    yield {
+        "portfolio": product.primary_portfolio,
+        "linked_product": product,
+        "transaction_date": price.date,
+        "transaction_subtype": Fees.Type.MANAGEMENT,
+        "underlying_instrument": cash,
+        "currency": product.currency,
+        "calculated": True,
+        "total_value": price.net_value,
+        "total_value_fx_portfolio": price.net_value,
+        "total_value_gross": price.net_value,
+        "total_value_gross_fx_portfolio": price.net_value,
+    }
+
+
+@pytest.mark.django_db
+class TestFeesModel:
+    def test_init(self, fees):
+        assert fees.id is not None
+
+    def test_filter_only_valid_fees(self, fees_factory):
+        fees_d0 = (
+            fees_factory.create()
+        )  # no matter if estimated or not, we expect this fee to be on the resulting queryset
+        calculated_fees_d1 = fees_factory.create(  # there will be a real fee for that date, type and product, so this will be filtered out
+            calculated=True,
+            linked_product=fees_d0.linked_product,
+            transaction_date=(fees_d0.transaction_date + timedelta(days=1)),
+            transaction_subtype=fees_d0.transaction_subtype,
+        )
+        real_fees_d1 = fees_factory.create(
+            calculated=False,
+            linked_product=calculated_fees_d1.linked_product,
+            transaction_date=calculated_fees_d1.transaction_date,
+            transaction_subtype=calculated_fees_d1.transaction_subtype,
+        )
+
+        assert set(Fees.valid_objects.all()) == {fees_d0, real_fees_d1}
+        assert set(Fees.objects.filter_only_valid_fees()) == {fees_d0, real_fees_d1}
+
+    def test_compute_fee_from_price(self, product_factory, instrument_price_factory):
+        # we check the mechanism of computing fees on valuation creation
+        fee_calculation = FeeCalculation.objects.create(
+            name="base computation", import_path="wbportfolio.tests.models.transactions.test_fees"
+        )
+        product = product_factory.create(fee_calculation=fee_calculation)
+        price = instrument_price_factory.create(instrument=product)  # post save must be called to compute fees
+
+        fees = Fees.objects.get(
+            linked_product=product, fee_date=price.date, calculated=True, transaction_subtype=Fees.Type.MANAGEMENT
+        )
+        assert fees.total_value == pytest.approx(price.net_value, rel=Decimal(1e-4))

wbportfolio/tests/models/transactions/test_trades.py

@@ -0,0 +1,204 @@
+from datetime import timedelta
+from decimal import Decimal
+
+import pytest
+from faker import Faker
+from wbportfolio.models import Product, Trade
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestTradeModel:
+    def test_init(self, trade):
+        assert trade.id is not None
+
+    def test_str(self, product, trade_factory):
+        trade = trade_factory.create(underlying_instrument=product)
+        assert str(trade) == f"{trade.product.ticker}:{trade.shares} ({trade.bank})"
+
+    def test_save_with_price(self, trade_factory):
+        trade = trade_factory(price=150)
+        assert trade.price == 150
+
+    def test_subquery_net_money(self, trade_factory, instrument_price_factory, product):
+        v = instrument_price_factory.create(instrument=product)
+        c2 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=v.date - timedelta(days=1),
+            shares=-1,
+            transaction_subtype=Trade.Type.REDEMPTION,
+        )
+        c1 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=v.date - timedelta(days=1),
+            shares=1,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create(  # noise
+            underlying_instrument=product,
+            transaction_date=v.date,
+            shares=1,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        products_pos = Product.objects.annotate(value=Trade.subquery_net_money(v.date, v.date))
+        assert products_pos.first().value == pytest.approx(c2.shares * c2.price + c1.shares * c1.price)
+
+        products_pos = Product.objects.annotate(value=Trade.subquery_net_money(v.date, v.date, only_positive=True))
+        assert products_pos.first().value == pytest.approx(c1.shares * c1.price)
+
+        products_neg = Product.objects.annotate(value=Trade.subquery_net_money(v.date, v.date, only_negative=True))
+        assert products_neg.first().value == pytest.approx(c2.shares * c2.price)
+
+    @pytest.mark.parametrize("date", [(fake.date_object())])
+    def test_subquery_shares_per_product(self, trade_factory, product, date):
+        a1 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create(  # noise
+            underlying_instrument=product, transaction_date=date, transaction_subtype=Trade.Type.SUBSCRIPTION
+        )
+        qs = Product.objects.annotate(total_shares=Trade.subquery_shares_per_underlying_instrument(date))
+        assert qs.first().total_shares == a1.shares
+
+    @pytest.mark.parametrize("date", [(fake.date_object())])
+    def test_subquery_shares_per_product_per_date(self, trade_factory, product, date):
+        a1 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create(  # noise
+            underlying_instrument=product, transaction_date=date, transaction_subtype=Trade.Type.SUBSCRIPTION
+        )
+        qs = Product.objects.annotate(total_shares=Trade.subquery_shares_per_underlying_instrument(date))
+        assert qs.first().total_shares == a1.shares
+
+    @pytest.mark.parametrize("date", [(fake.date_object())])
+    def test_subquery_net_new_money(self, trade_factory, product, date):
+        a1 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create(  # noise
+            underlying_instrument=product,
+            transaction_date=date,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        qs = Product.objects.annotate(total_shares=Trade.subquery_shares_per_underlying_instrument(date))
+        assert qs.first().total_shares == a1.shares
+
+    def test_claim_update_claimed_shares(self, customer_trade_factory, claim_factory):
+        customer_trade = customer_trade_factory.create()
+        claim_factory.create(status="PENDING", trade=customer_trade)
+        customer_trade.refresh_from_db()
+        assert customer_trade.claimed_shares == 0
+        c2 = claim_factory.create(status="APPROVED", trade=customer_trade)
+        customer_trade.refresh_from_db()
+        assert customer_trade.claimed_shares == c2.shares
+
+
+@pytest.mark.django_db
+class TestTradeProposalModel:
+    def test_init(self, trade_proposal):
+        assert trade_proposal.id is not None
+
+
+@pytest.mark.django_db
+class TestTradeInstrumentPrice:
+    def test_shares(self, portfolio, product_factory, trade_factory, instrument_price_factory):
+        product = product_factory.create()
+        price = instrument_price_factory.create(instrument=product)
+        trade1 = trade_factory.create(
+            portfolio=product.primary_portfolio,
+            underlying_instrument=product,
+            transaction_date=price.date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade2 = trade_factory.create(
+            portfolio=product.primary_portfolio,
+            underlying_instrument=product,
+            transaction_date=price.date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create(  # noise
+            portfolio=product.primary_portfolio,
+            underlying_instrument=product,
+            transaction_date=price.date,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        assert price.shares == pytest.approx(trade1.shares + trade2.shares)
+
+    def test_nominal_value(self, portfolio, product_factory, trade_factory, instrument_price_factory):
+        product = product_factory.create()
+        price = instrument_price_factory.create(instrument=product)
+        trade1 = trade_factory.create(
+            portfolio=product.primary_portfolio,
+            underlying_instrument=product,
+            transaction_date=price.date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade2 = trade_factory.create(
+            portfolio=product.primary_portfolio,
+            underlying_instrument=product,
+            transaction_date=price.date - timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create(  # noise
+            portfolio=product.primary_portfolio,
+            underlying_instrument=product,
+            transaction_date=price.date,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        assert price.nominal_value == pytest.approx(Decimal(product.share_price * (trade1.shares + trade2.shares)))
+
+    def test_subscription_link_to_internal_trade(self, weekday, trade_factory, product):
+        shares = 100
+        trade_factory.create(shares=shares, transaction_subtype=Trade.Type.BUY, transaction_date=weekday)  # noise 1
+        trade_factory.create(
+            shares=shares,
+            transaction_subtype=Trade.Type.BUY,
+            transaction_date=weekday + timedelta(days=Trade.TRADE_WINDOW_INTERVAL + 1),
+            underlying_instrument=product,
+        )  # noise 2
+        subscription_trade1 = trade_factory.create(
+            shares=shares,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+            transaction_date=weekday,
+            underlying_instrument=product,
+        )  # noise 3
+        internal_trade = trade_factory.create(
+            shares=shares, transaction_subtype=Trade.Type.BUY, transaction_date=weekday, underlying_instrument=product
+        )
+        subscription_trade2 = trade_factory.create(
+            shares=shares,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+            transaction_date=weekday,
+            underlying_instrument=product,
+        )
+
+        subscription_trade1.link_to_internal_trade()
+        assert subscription_trade1.internal_trade == internal_trade
+        assert subscription_trade1.marked_as_internal is True
+
+        # Reset attribute to test the other side
+        subscription_trade1.internal_trade = None
+        subscription_trade1.marked_as_internal = False
+        subscription_trade1.save()
+
+        # Check that linking from the other site but with two similar subscriptions won't link
+        internal_trade.link_to_internal_trade()
+        subscription_trade1.refresh_from_db()
+        subscription_trade2.refresh_from_db()
+        assert subscription_trade1.internal_trade is None
+        assert subscription_trade2.internal_trade is None
+
+        # Check that with now only one subscription, the linking is successful
+        subscription_trade2.delete()
+        internal_trade.link_to_internal_trade()
+        subscription_trade1.refresh_from_db()
+        assert subscription_trade1.internal_trade == internal_trade
+        assert subscription_trade1.marked_as_internal is True

wbportfolio/tests/models/utils.py

@@ -0,0 +1,13 @@
+from datetime import timedelta
+
+import pytest
+from faker import Faker
+from wbportfolio.factories import ProductFactory
+
+fake = Faker()
+
+
+class PortfolioTestMixin:
+    @pytest.fixture
+    def active_product(self, weekday):
+        return ProductFactory.create(inception_date=weekday - timedelta(days=30), delisted_date=None)

wbportfolio/tests/serializers/test_claims.py

@@ -0,0 +1,21 @@
+import pytest
+from wbportfolio.serializers import ClaimModelSerializer
+
+
+@pytest.mark.django_db
+class TestClaimModelSerializer:
+    def test_serialize(self, claim):
+        claim.trade_type = True
+        claim.quantity = 1000
+        serializer = ClaimModelSerializer(claim)
+        assert serializer.data
+
+    def test_validate(self):
+        data = {
+            "trade_type": True,
+            "quantity": 1000,
+            "as_shares": True,
+            "date": "2024-01-01",
+        }
+        serializer = ClaimModelSerializer(data=data)
+        assert serializer.is_valid()

wbportfolio/tests/signals.py

@@ -0,0 +1,151 @@
+from django.dispatch import receiver
+from wbcore.contrib.currency.factories import CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories import CompanyFactory
+from wbcore.test.signals import custom_update_kwargs, get_custom_factory
+from wbportfolio.factories import (
+    CustomerTradeFactory,
+    InstrumentPriceFactory,
+    ModelPortfolioFactory,
+    ProductFactory,
+    ProductPortfolioRoleFactory,
+    TradeProposalFactory,
+)
+from wbportfolio.viewsets import (
+    AssetPositionInstrumentModelViewSet,
+    AssetPositionUnderlyingInstrumentChartViewSet,
+    AUMProductChartView,
+    ClaimEntryModelViewSet,
+    CustodianDistributionInstrumentChartViewSet,
+    CustomerDistributionInstrumentChartViewSet,
+    DistributionChartViewSet,
+    DistributionTableViewSet,
+    ModelPortfolioModelViewSet,
+    NominalProductChartView,
+    PortfolioRoleInstrumentModelViewSet,
+    ProductCustomerModelViewSet,
+    ProductPerformanceFeesModelViewSet,
+    SubscriptionRedemptionInstrumentModelViewSet,
+    SubscriptionRedemptionModelViewSet,
+    TradeInstrumentModelViewSet,
+    TradeProposalPortfolioModelViewSet,
+    TradeTradeProposalModelViewSet,
+)
+
+# =================================================================================================================
+#                                              CUSTOM FACTORY
+# =================================================================================================================
+
+
+@receiver(get_custom_factory, sender=SubscriptionRedemptionModelViewSet)
+@receiver(get_custom_factory, sender=SubscriptionRedemptionInstrumentModelViewSet)
+def receive_factory_subscription_redemption_instrument(sender, *args, **kwargs):
+    return CustomerTradeFactory
+
+
+@receiver(get_custom_factory, sender=ModelPortfolioModelViewSet)
+def receive_factory_model_portfolio(sender, *args, **kwargs):
+    return ModelPortfolioFactory
+
+
+@receiver(get_custom_factory, sender=PortfolioRoleInstrumentModelViewSet)
+def receive_factory_product_portfolio_role(sender, *args, **kwargs):
+    return ProductPortfolioRoleFactory
+
+
+# =================================================================================================================
+#                                              UPDATE DATA
+# =================================================================================================================
+
+
+# =================================================================================================================
+#                                              UPDATE KWARGS
+# =================================================================================================================
+@receiver(custom_update_kwargs, sender=TradeTradeProposalModelViewSet)
+def receive_kwargs_trade_trade_proposal_product(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        trade_proposal = TradeProposalFactory.create()
+        obj.trade_proposal = trade_proposal
+        obj.save()
+        return {"trade_proposal_id": trade_proposal.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=TradeProposalPortfolioModelViewSet)
+def receive_kwargs_trade_trade_proposal_portfolio(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        return {"portfolio_id": obj.portfolio.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=TradeInstrumentModelViewSet)
+@receiver(custom_update_kwargs, sender=AssetPositionInstrumentModelViewSet)
+@receiver(custom_update_kwargs, sender=SubscriptionRedemptionInstrumentModelViewSet)
+@receiver(custom_update_kwargs, sender=AssetPositionUnderlyingInstrumentChartViewSet)
+def receive_kwargs_instrument(sender, *args, **kwargs):
+    if kwargs.get("underlying_instrument_id"):
+        return {"instrument_id": kwargs.get("underlying_instrument_id")}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=ProductCustomerModelViewSet)
+def receive_kwargs_product_customer_instrument(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        InstrumentPriceFactory.create(instrument=obj, calculated=False)
+        obj.update_last_valuation_date()
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=PortfolioRoleInstrumentModelViewSet)
+def receive_kwargs_portfolio_role_instrument(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        return {"instrument_id": obj.instrument.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=DistributionChartViewSet)
+@receiver(custom_update_kwargs, sender=DistributionTableViewSet)
+def receive_kwargs_distribution_chart_instrument_id(sender, *args, **kwargs):
+    if instrument_id := kwargs.get("underlying_instrument_id"):
+        return {"instrument_id": instrument_id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=ProductPerformanceFeesModelViewSet)
+def receive_kwargs_product_performance_fees(sender, *args, **kwargs):
+    CurrencyFXRatesFactory()
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=CustodianDistributionInstrumentChartViewSet)
+def receive_kwargs_custodian_distribution_instrument(sender, *args, **kwargs):
+    if instrument_id := kwargs.get("underlying_instrument_id"):
+        return {"instrument_id": instrument_id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=NominalProductChartView)
+@receiver(custom_update_kwargs, sender=AUMProductChartView)
+def receive_kwargs_aum_product(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        product = ProductFactory()
+        obj.instrument = product
+        obj.save()
+        return {"product_id": product.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=ClaimEntryModelViewSet)
+def receive_kwargs_claim_entry(sender, *args, **kwargs):
+    if claim := kwargs.get("obj_factory"):
+        owner = CompanyFactory.create()
+        claim.account.owner = owner
+        claim.account.save()
+        return {"entry_id": owner.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=CustomerDistributionInstrumentChartViewSet)
+def receive_kwargs_customer_distribution(sender, *args, **kwargs):
+    if trade := kwargs.get("obj_factory"):
+        return {"instrument_id": trade.underlying_instrument.id}
+    return {}

wbportfolio/tests/tests.py

@@ -0,0 +1,31 @@
+import pytest
+from wbcore.test import GenerateTest, default_config
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(
+        filter(
+            lambda x: x.__module__.startswith("wbportfolio")
+            and x.__name__
+            not in [
+                "AggregatedAssetPositionLiquidityPandasView",
+                "TradeTradeProposalModelViewSet",
+                "PortfolioSwingPricing",
+                "PortfolioCashTarget",
+                "PortfolioSwingPricingModelViewSet",
+                "AccountReconciliationModelViewSet",
+                "AccountReconciliationLineModelViewSet",
+                "AccountReconciliation",
+                "AccountReconciliationLine",
+                # "ClaimModelViewSet",
+                # "ClaimModelSerializer",
+            ],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass