wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/tests/models/test_account_reconciliation.py

@@ -0,0 +1,191 @@
+from datetime import date
+from typing import TYPE_CHECKING
+
+import pytest
+from django.db import IntegrityError
+from wbcrm.models import Account
+from wbportfolio.models import AccountReconciliation, Claim
+from wbportfolio.models.products import Product
+from wbportfolio.models.reconciliations.account_reconciliation_lines import (
+    AccountReconciliationLine,
+)
+
+if TYPE_CHECKING:
+    from wbcore.contrib.authentication.models import User
+    from wbportfolio.factories import AccountReconciliationLineFactory, ClaimFactory
+
+
+class TestAccountReconciliation:
+    def test_str(self):
+        account = Account(computed_str="Test Account")
+        reconciliation = AccountReconciliation(account=account, reconciliation_date=date(2021, 1, 1))
+        assert str(reconciliation) == "Test Account (01.01.2021)"
+
+    def test_get_endpoint_basename(self):
+        assert AccountReconciliation.get_endpoint_basename() == "wbportfolio:accountreconciliation"
+
+    def test_get_representation_endpoint(self):
+        assert (
+            AccountReconciliation.get_representation_endpoint()
+            == "wbportfolio:accountreconciliationrepresentation-list"
+        )
+
+    def test_get_representation_value_key(self):
+        assert AccountReconciliation.get_representation_value_key() == "id"
+
+    def test_get_representation_label_key(self):
+        assert AccountReconciliation.get_representation_label_key() == "{{account}} {{reconciliation_date}}"
+
+    @pytest.mark.django_db
+    def test_create_for_date_and_account(self, claim_factory: "ClaimFactory", account: Account, user: "User"):
+        for _ in range(10):
+            claim_factory.create(account=account, date=date(2020, 12, 30), status=Claim.Status.APPROVED)
+
+        AccountReconciliation.objects.create(
+            reconciliation_date=date(2021, 1, 1),
+            account=account,
+            creator=user,
+        )
+
+        assert (
+            AccountReconciliationLine.objects.count() == Claim.objects.distinct("product").count()
+        ), "There should be as many lines as unique products for claims"
+
+
+class TestAccountReconciliationLine:
+    def test_str(self):
+        account = Account(computed_str="Test Account")
+        reconciliation = AccountReconciliation(account=account, reconciliation_date=date(2021, 1, 1))
+        product = Product(computed_str="Test Product")
+        line = AccountReconciliationLine(reconciliation=reconciliation, product=product, shares=100)
+
+        assert str(line) == "Test Account (01.01.2021): Test Product 100 shares"
+
+    def test_get_endpoint_basename(self):
+        assert AccountReconciliationLine.get_endpoint_basename() == "wbportfolio:accountreconciliationline"
+
+    def test_representation_endpoint(self):
+        assert (
+            AccountReconciliationLine.get_representation_endpoint()
+            == "wbportfolio:accountreconciliationlinerepresentation-list"
+        )
+
+    def test_representation_value_key(self):
+        assert AccountReconciliationLine.get_representation_value_key() == "id"
+
+    def test_representation_label_key(self):
+        assert AccountReconciliationLine.get_representation_label_key() == "{{reconciliation}}"
+
+    def test_save_calculate_nominal_value(self, mocker):
+        mocker.patch("django.db.models.Model.save")
+        product = Product(share_price=100)
+        line = AccountReconciliationLine(product=product, shares=100, nominal_value=None)
+        line.save()
+
+        assert line.nominal_value == 100 * 100
+
+    def test_save_calculate_shares(self, mocker):
+        mocker.patch("django.db.models.Model.save")
+        product = Product(share_price=100)
+        line = AccountReconciliationLine(product=product, nominal_value=10000, shares=None)
+        line.save()
+
+        assert line.shares == 100
+
+    def test_save_calculate_nominal_value_external(self, mocker):
+        mocker.patch("django.db.models.Model.save")
+        product = Product(share_price=100)
+        line = AccountReconciliationLine(product=product, shares_external=100, nominal_value_external=None)
+        line.save()
+
+        assert line.nominal_value_external == 100 * 100
+
+    def test_save_calculate_shares_external(self, mocker):
+        mocker.patch("django.db.models.Model.save")
+        product = Product(share_price=100)
+        line = AccountReconciliationLine(product=product, nominal_value_external=10000, shares_external=None)
+        line.save()
+
+        assert line.shares_external == 100
+
+    @pytest.mark.django_db
+    def test_unique_constraint(
+        self,
+        account_reconciliation: AccountReconciliation,
+        product: Product,
+        account_reconciliation_line_factory: "AccountReconciliationLineFactory",
+    ):
+        account_reconciliation_line_factory.create(reconciliation=account_reconciliation, product=product)
+        with pytest.raises(IntegrityError):
+            account_reconciliation_line_factory.create(reconciliation=account_reconciliation, product=product)
+
+    @pytest.mark.django_db
+    def test_currency_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all().annotate_currency().first().currency
+            == account_reconciliation_line.product.currency.symbol
+        )
+
+    @pytest.mark.django_db
+    def test_assets_under_management_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all().annotate_assets_under_management().first().assets_under_management
+            == account_reconciliation_line.shares * account_reconciliation_line.price
+        )
+
+    @pytest.mark.django_db
+    def test_assets_under_management_external_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all()
+            .annotate_assets_under_management_external()
+            .first()
+            .assets_under_management_external
+            == account_reconciliation_line.shares_external * account_reconciliation_line.price
+        )
+
+    @pytest.mark.django_db
+    @pytest.mark.parametrize("account_reconciliation_line__shares", [100])
+    @pytest.mark.parametrize("account_reconciliation_line__shares_external", [101])
+    def test_is_not_equal_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert not AccountReconciliationLine.objects.all().annotate_is_equal().first().is_equal
+
+    @pytest.mark.django_db
+    @pytest.mark.parametrize("account_reconciliation_line__shares", [100])
+    @pytest.mark.parametrize("account_reconciliation_line__shares_external", [100])
+    def test_is_equal_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert AccountReconciliationLine.objects.all().annotate_is_equal().first().is_equal
+
+    @pytest.mark.django_db
+    def test_shares_diff_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all().annotate_shares_diff().first().shares_diff
+            == account_reconciliation_line.shares_external - account_reconciliation_line.shares
+        )
+
+    @pytest.mark.django_db
+    def test_pct_diff_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all().annotate_pct_diff().first().pct_diff
+            == (account_reconciliation_line.shares_external - account_reconciliation_line.shares)
+            / account_reconciliation_line.shares
+        )
+
+    @pytest.mark.django_db
+    def test_nominal_value_diff_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all().annotate_nominal_value_diff().first().nominal_value_diff
+            == account_reconciliation_line.nominal_value_external - account_reconciliation_line.nominal_value
+        )
+
+    @pytest.mark.django_db
+    def test_assets_under_management_diff_annotation(self, account_reconciliation_line: AccountReconciliationLine):
+        assert (
+            AccountReconciliationLine.objects.all()
+            .annotate_assets_under_management()
+            .annotate_assets_under_management_external()
+            .annotate_assets_under_management_diff()
+            .first()
+            .assets_under_management_diff
+            == (account_reconciliation_line.shares_external * account_reconciliation_line.price)
+            - (account_reconciliation_line.shares * account_reconciliation_line.price)
+        )

wbportfolio/tests/models/test_assets.py

@@ -0,0 +1,193 @@
+from decimal import Decimal
+
+import pytest
+from pandas.tseries.offsets import BDay
+from wbportfolio.models import AssetPosition, PortfolioRole
+
+
+@pytest.mark.django_db
+class TestAssetPositionModel:
+    def test_init(self, asset_position):
+        assert asset_position.id is not None
+
+    def test_currency_group_by(self, asset_position_factory, equity_factory, portfolio, currency):
+        asset_position_factory.create(
+            portfolio=portfolio, currency=currency, underlying_instrument=equity_factory.create()
+        )
+        asset_position_factory.create(
+            portfolio=portfolio, currency=currency, underlying_instrument=equity_factory.create()
+        )
+        assert (
+            AssetPosition.currency_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 1
+        )
+
+    def test_country_group_by(self, asset_position_factory, portfolio, equity):
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=equity)
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=equity)
+        assert AssetPosition.country_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 1
+
+    def test_exchange_group_by(self, asset_position_factory, portfolio, exchange):
+        asset_position_factory.create(portfolio=portfolio, exchange=exchange)
+        asset_position_factory.create(portfolio=portfolio, exchange=exchange)
+        assert (
+            AssetPosition.exchange_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 1
+        )
+
+    def test_cash_group_by(self, asset_position_factory, portfolio, cash, equity):
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=cash)
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=cash)
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=equity)
+        assert AssetPosition.cash_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 2
+
+    def test_equity_group_by(self, asset_position_factory, portfolio, equity):
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=equity)
+        asset_position_factory.create(portfolio=portfolio, underlying_instrument=equity)
+        assert AssetPosition.equity_group_by(AssetPosition.objects.all()).values("groupby_id").distinct().count() == 1
+
+    def test_marketcap_group_by(
+        self, asset_position_factory, equity_factory, portfolio, instrument_price_factory, currency_fx_rates_factory
+    ):
+        fx_rate = currency_fx_rates_factory.create(value=1)
+        i1 = instrument_price_factory.create(instrument=equity_factory.create(), market_capitalization=1000000000)
+        i2 = instrument_price_factory.create(instrument=equity_factory.create(), market_capitalization=30000000000)
+        asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_instrument_price=i1,
+            currency_fx_rate_instrument_to_usd=fx_rate,
+            currency_fx_rate_portfolio_to_usd=fx_rate,
+        )  # small
+        asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_instrument_price=i2,
+            currency_fx_rate_instrument_to_usd=fx_rate,
+            currency_fx_rate_portfolio_to_usd=fx_rate,
+        )  # larg
+
+        qs = AssetPosition.marketcap_group_by(AssetPosition.objects.all())
+        assert qs.values("aggregated_title").distinct().count() == 2
+        assert set(qs.distinct().values_list("aggregated_title", flat=True)) == {"10B to 50B", "< 2B"}
+
+    def test_liquidity_group_by(self, asset_position_factory, equity_factory, portfolio, instrument_price_factory):
+        a1 = asset_position_factory.create(
+            portfolio=portfolio, initial_shares=1, underlying_instrument=equity_factory.create()
+        )  # small
+        a2 = asset_position_factory.create(
+            portfolio=portfolio, initial_shares=1, underlying_instrument=equity_factory.create()
+        )  # larg
+
+        instrument_price_factory.create(instrument=a1.underlying_instrument, date=a1.date, volume_50d=1000000)
+        instrument_price_factory.create(instrument=a2.underlying_instrument, date=a2.date, volume_50d=3000000)
+
+        qs = AssetPosition.liquidity_group_by(AssetPosition.objects.all())
+        assert qs.values("aggregated_title").distinct().count() == 1
+
+    def test_get_shown_positions_superuser(self, portfolio, superuser, asset_position_factory):
+        superuser.is_superuser = True
+        superuser.save()
+        asset_position_factory.create_batch(10, portfolio=portfolio)
+        qs = AssetPosition.get_shown_positions(superuser.profile)
+        assert qs.count() == 10
+
+    def test_get_shown_positions_analyst(
+        self, portfolio_factory, product_factory, person, user, asset_position_factory, product_portfolio_role_factory
+    ):
+        user.profile = person
+        user.save()
+        p2 = portfolio_factory.create()
+        product = product_factory.create()
+        product_portfolio_role_factory.create(
+            person=person, instrument=product, role_type=PortfolioRole.RoleType.ANALYST
+        )
+        asset_position_factory.create_batch(10, portfolio=product.portfolio)
+        asset_position_factory.create_batch(10, portfolio=p2)
+        qs = AssetPosition.get_shown_positions(person)
+        assert qs.count() == 10
+
+    def test_analytical_objects(self, asset_position_factory, portfolio, equity_factory):
+        # Data creation
+        equity1 = equity_factory.create()
+        equity2 = equity_factory.create()
+        asset_position_factory.create_batch(5, underlying_instrument=equity1, portfolio=portfolio)
+        asset_position_factory.create_batch(5, underlying_instrument=equity2, portfolio=portfolio)
+
+        # We test calculation with equity1. equity2 allows to certify the temporal continuity of the portfolio.
+        qs_assets_equity1 = AssetPosition.analytical_objects.order_by("date").filter(underlying_instrument=equity1)
+        qs_prices_equity1 = equity1.prices.order_by("date")
+
+        # ap holds for AssetPosition and ep holds for Equity Price.
+        ap1, ap2 = qs_assets_equity1[:2]
+        ep1, ep2, ep3, ep4 = qs_prices_equity1[:4]
+
+        # Basic Performance
+        assert ap2.performance == float(ap2.price_fx_usd / ap1.price_fx_usd - 1)
+        assert ap2.performance == pytest.approx(float(ep2._net_value_usd / ep1._net_value_usd - Decimal(1)))
+
+        # We sell the equity (ap3 deleted) and then we buy it again (back in ap4).
+        # This is like having a missing data in between.
+        qs_assets_equity1.exclude(id__in=[ap1.id, ap2.id]).first().delete()  # ap3
+        ap4 = qs_assets_equity1.exclude(id__in=[ap1.id, ap2.id]).first()
+
+        assert ap4.performance is None
+        assert ep4._net_value_usd / ep3._net_value_usd is not None
+
+    def test_get_underlying_instrument_price(self, asset_position_factory, instrument_price_factory):
+        """
+        In this test, we confirm that an asset position with no matching real price for the same date and underlying instrument will result in an empty underlying_instrument_price
+        """
+        a1 = asset_position_factory.create(underlying_instrument_price=None)
+        a1.save()
+        assert a1.underlying_instrument_price is None
+        p2_calculated = instrument_price_factory.create(calculated=True)
+        a2 = asset_position_factory.create(
+            underlying_instrument_price=None, underlying_instrument=p2_calculated.instrument, date=p2_calculated.date
+        )
+        a2.save()
+        assert a2.underlying_instrument_price is None
+        p2_real = instrument_price_factory.create(
+            calculated=False, date=p2_calculated.date, instrument=p2_calculated.instrument
+        )
+        a2.save()
+        assert a2.underlying_instrument_price == p2_real
+
+    def test_change_currency_recompute_currency_fx_rate_for_price_and_assets(
+        self, weekday, instrument, currency_fx_rates_factory, instrument_price_factory, asset_position_factory
+    ):
+        fx_rate = currency_fx_rates_factory.create(currency=instrument.currency, date=weekday)
+        fx_rate_other = currency_fx_rates_factory.create(date=weekday)
+
+        p = instrument_price_factory.create(instrument=instrument, date=weekday)
+        a = asset_position_factory.create(underlying_instrument=instrument, date=weekday)
+
+        assert p.currency_fx_rate_to_usd == fx_rate
+        assert a.currency_fx_rate_instrument_to_usd == fx_rate
+
+        instrument.currency = fx_rate_other.currency
+        instrument.save()
+
+        p.refresh_from_db()
+        a.refresh_from_db()
+
+        assert p.currency_fx_rate_to_usd == fx_rate_other
+        assert a.currency_fx_rate_instrument_to_usd == fx_rate_other
+
+    def test_create_price_set_assetposition(self, asset_position_factory, instrument_price_factory):
+        p0 = instrument_price_factory.create()
+        d1 = (p0.date + BDay(1)).date()
+        a1 = asset_position_factory.create(
+            date=d1, underlying_instrument=p0.instrument, underlying_instrument_price=None
+        )
+
+        # check it is linked to the only price
+        assert a1.underlying_instrument_price == p0
+        p1 = instrument_price_factory.create(instrument=p0.instrument, date=d1)
+        a1.refresh_from_db()
+        assert a1.underlying_instrument_price == p1
+
+        d_1 = (p0.date - BDay(1)).date()
+        a_1 = asset_position_factory.create(
+            date=d_1, underlying_instrument=p1.instrument, underlying_instrument_price=None
+        )
+        assert a_1.underlying_instrument_price is None
+        p_1 = instrument_price_factory.create(instrument=p1.instrument, date=d_1)
+        a_1.refresh_from_db()
+        assert a_1.underlying_instrument_price == p_1

wbportfolio/tests/models/test_custodians.py

@@ -0,0 +1,12 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestCustodianModel:
+    def test_init(self, custodian_factory):
+        custodian = custodian_factory.create()
+        assert custodian.id is not None
+
+    def test_str(self, custodian_factory):
+        custodian = custodian_factory.create()
+        assert str(custodian) == f"{custodian.name}"

wbportfolio/tests/models/test_customer_trades.py

@@ -0,0 +1,113 @@
+import random
+from datetime import timedelta
+
+import pytest
+from django.db.models import ProtectedError
+from faker import Faker
+from wbportfolio.models import Trade
+from wbportfolio.models.transactions.claim import Claim
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestCustomerTradeModel:
+    def test_delete_without_claims(self, trade):
+        """
+        Simple test to check if a trade without claim is properly deleted
+        """
+        trade.delete()
+        with pytest.raises(Trade.DoesNotExist):
+            trade.refresh_from_db()
+
+    @pytest.mark.parametrize("claim_status", Claim.Status.names)
+    def test_delete_trade_with_claim(self, customer_trade_factory, claim_factory, claim_status):
+        """
+        Simple test to check if a trade with claim a valid claim (Pending or Approved9 can't be deleted but
+        a trade with a draft, withdrawn or auto approved claim can.
+        """
+        customer_trade = customer_trade_factory.create()
+        claim = claim_factory.create(trade=customer_trade, status=claim_status)
+
+        # If claim is among the non approved type, we expect the deletion to succeed and the claim to be unlinked
+        if claim.status in [Claim.Status.DRAFT, Claim.Status.AUTO_MATCHED, Claim.Status.WITHDRAWN]:
+            customer_trade.delete()
+            claim.refresh_from_db()
+            assert not claim.trade
+            with pytest.raises(Trade.DoesNotExist):
+                customer_trade.refresh_from_db()
+        else:
+            # If the claim is approved or pending, and in absence of any other similar trades to reassign the claim to, we expect the deletion to failed
+            with pytest.raises(ProtectedError):
+                customer_trade.delete()
+
+    def test_delete_trade_with_approved_claims_but_similar_trades_summing_0(
+        self, customer_trade_factory, claim_factory
+    ):
+        """
+        A test to check that even trade with approved claims attach can be deleted if the sum of the shares of the similar trades the same date equals to 0
+        """
+        trade1 = customer_trade_factory.create()
+        claim1 = claim_factory.create(trade=trade1, status=Claim.Status.APPROVED)
+        trade1.marked_for_deletion = True
+        trade1.save()
+
+        # Claims is attached, no other similar trade is present, we don't expect the deletion to be possible
+        with pytest.raises(ProtectedError):
+            trade1.delete()
+
+        # We create a negative trade that will annihilate trade1
+        trade2 = customer_trade_factory.create(
+            underlying_instrument=trade1.underlying_instrument,
+            portfolio=trade1.portfolio,
+            transaction_date=trade1.transaction_date,
+            shares=-trade1.shares,
+        )
+        # That we claim
+        claim2 = claim_factory.create(trade=trade2, status=Claim.Status.APPROVED)
+        trade2.marked_for_deletion = True
+        trade2.save()
+
+        # Now, sum of all trades linked to this product at that date sums to 0, we can destroy all trades and unliked the associated claims
+        trade1.delete()
+        claim1.refresh_from_db()
+        claim2.refresh_from_db()
+        assert not claim1.trade
+        assert claim1.status == Claim.Status.DRAFT
+        assert not claim2.trade
+        assert claim2.status == Claim.Status.DRAFT
+
+        # trade2 is unclaimed and can be safely deleted
+        trade2.delete()
+        with pytest.raises(Trade.DoesNotExist):
+            trade2.refresh_from_db()
+
+    @pytest.mark.parametrize(
+        "allowed_timedeltda", [random.randint(-Trade.TRADE_WINDOW_INTERVAL, Trade.TRADE_WINDOW_INTERVAL)]
+    )
+    def test_trade_delete_shift_claims(self, customer_trade_factory, claim_factory, allowed_timedeltda):
+        """
+        Test main functionality: when a trade is linked to an approved claim and is marked for deletion, we try to find the closest trade non marked for deletion or pending and unclaimed.
+
+        If this succeed, the claim is forwarded to this other trade. Otherwise, it will fail.
+        """
+        trade1 = customer_trade_factory.create()
+        claim1 = claim_factory.create(trade=trade1, status=Claim.Status.APPROVED)
+        trade1.marked_for_deletion = True
+        trade1.save()
+
+        # We expect the claim to be reassigned to this similar "non marked for deletion" trade
+        similar_unclaimed_trade = customer_trade_factory.create(
+            marked_for_deletion=False,
+            pending=False,
+            underlying_instrument=trade1.underlying_instrument,
+            portfolio=trade1.portfolio,
+            transaction_subtype=trade1.transaction_subtype,
+            transaction_date=trade1.transaction_date + timedelta(days=allowed_timedeltda),
+            shares=trade1.shares,
+        )
+        trade1.delete()
+        with pytest.raises(Trade.DoesNotExist):
+            trade1.refresh_from_db()
+        claim1.refresh_from_db()
+        assert claim1.trade == similar_unclaimed_trade

wbportfolio/tests/models/test_dividends.py

@@ -0,0 +1,7 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestDividendModel:
+    def test_init(self, dividend_transaction):
+        assert dividend_transaction.id is not None