wbcommission 2.2.1__py2.py3-none-any.whl

wbcommission/tests/analytics/test_marginality.py

@@ -0,0 +1,253 @@
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from rest_framework.reverse import reverse
+from rest_framework.test import APIClient, APIRequestFactory
+from wbcommission.analytics.marginality import MarginalityCalculator
+from wbcommission.factories import CommissionTypeFactory, RebateFactory
+from wbcommission.viewsets.rebate import RebateProductMarginalityViewSet
+from wbportfolio.factories import FeesFactory, InstrumentPriceFactory, ProductFactory
+from wbportfolio.models import Product
+
+fake = Faker()
+
+
+def _create_fixture(product, val_date, net_value=100, outstanding_shares=100):
+    management = CommissionTypeFactory.create(key="management")
+    perforance = CommissionTypeFactory.create(key="performance")
+    i1 = InstrumentPriceFactory.create(
+        instrument=product, net_value=net_value, outstanding_shares=outstanding_shares, calculated=False, date=val_date
+    ).net_value  # create a price of AUM 100*100
+    management_fees_1 = FeesFactory.create(
+        linked_product=product, transaction_date=val_date, transaction_subtype="MANAGEMENT", calculated=False
+    ).total_value
+    performance_fees_1 = FeesFactory.create(
+        linked_product=product, transaction_date=val_date, transaction_subtype="PERFORMANCE", calculated=False
+    ).total_value
+    performance_crys_fees_1 = FeesFactory.create(
+        linked_product=product,
+        transaction_date=val_date,
+        transaction_subtype="PERFORMANCE_CRYSTALIZED",
+        calculated=False,
+    ).total_value
+    management_rebate_1 = RebateFactory.create(product=product, date=val_date, commission_type=management).value
+    performance_rebate_1 = RebateFactory.create(product=product, date=val_date, commission_type=perforance).value
+    if val_date.weekday() == 0:
+        return (
+            i1,
+            management_fees_1 / 3.0,
+            performance_fees_1 / 3.0,
+            performance_crys_fees_1 / 3.0,
+            float(management_rebate_1) / 3.0,
+            float(performance_rebate_1) / 3.0,
+        )
+    else:
+        return (
+            i1,
+            management_fees_1,
+            performance_fees_1,
+            performance_crys_fees_1,
+            float(management_rebate_1),
+            float(performance_rebate_1),
+        )
+
+
+@pytest.mark.django_db
+class TestMarginalityCalculator:
+    @pytest.fixture
+    def marginality_calculator(self):
+        product = ProductFactory.create()
+        start = (fake.date_object() + BDay(0)).date()
+        end = (start + BDay(1)).date()
+
+        (
+            self.i1,
+            self.management_fees_1,
+            self.performance_fees_1,
+            self.performance_crys_fees_1,
+            self.management_rebate_1,
+            self.performance_rebate_1,
+        ) = _create_fixture(product, start)
+        self.product_id = product.id
+        self.start = start
+        self.end = end
+        return MarginalityCalculator(Product.objects.filter(id=product.id), start, end)
+
+    def test_fees(self, marginality_calculator):
+        assert marginality_calculator.management_fees.loc[self.product_id] == pytest.approx(
+            self.management_fees_1, rel=1e-4
+        )
+        assert marginality_calculator.performance_fees.loc[self.product_id] == pytest.approx(
+            self.performance_fees_1 + self.performance_crys_fees_1, rel=1e-4
+        )
+        assert marginality_calculator.total_fees.loc[self.product_id] == pytest.approx(
+            self.performance_fees_1 + self.performance_crys_fees_1 + self.management_fees_1, rel=1e-4
+        )
+
+    def test_rebates(self, marginality_calculator):
+        assert marginality_calculator.management_rebates.loc[self.product_id] == pytest.approx(
+            self.management_rebate_1, rel=1e-4
+        )
+        assert marginality_calculator.performance_rebates.loc[self.product_id] == pytest.approx(
+            self.performance_rebate_1, rel=1e-4
+        )
+        assert marginality_calculator.total_rebates.loc[self.product_id] == pytest.approx(
+            self.performance_rebate_1 + self.management_rebate_1, rel=1e-4
+        )
+
+    def test_fees_usd(self, marginality_calculator):
+        assert marginality_calculator.management_fees_usd.loc[self.product_id] == pytest.approx(
+            self.management_fees_1, rel=1e-4
+        )
+        assert marginality_calculator.performance_fees_usd.loc[self.product_id] == pytest.approx(
+            self.performance_fees_1 + self.performance_crys_fees_1, rel=1e-4
+        )
+        assert marginality_calculator.total_fees_usd.loc[self.product_id] == pytest.approx(
+            self.performance_fees_1 + self.performance_crys_fees_1 + self.management_fees_1, rel=1e-4
+        )
+
+    def test_rebates_usd(self, marginality_calculator):
+        assert marginality_calculator.management_rebates_usd.loc[self.product_id] == pytest.approx(
+            self.management_rebate_1, rel=1e-4
+        )
+        assert marginality_calculator.performance_rebates_usd.loc[self.product_id] == pytest.approx(
+            self.performance_rebate_1, rel=1e-4
+        )
+        assert marginality_calculator.total_rebates_usd.loc[self.product_id] == pytest.approx(
+            self.performance_rebate_1 + self.management_rebate_1, rel=1e-4
+        )
+
+    def test_marginality(self, marginality_calculator):
+        assert marginality_calculator.management_marginality.loc[self.product_id] == pytest.approx(
+            self.management_fees_1 - self.management_rebate_1, rel=1e-4
+        )
+        assert marginality_calculator.performance_marginality.loc[self.product_id] == pytest.approx(
+            self.performance_fees_1 + self.performance_crys_fees_1 - self.performance_rebate_1, rel=1e-4
+        )
+        assert marginality_calculator.total_marginality.loc[self.product_id] == pytest.approx(
+            (self.performance_fees_1 + self.performance_crys_fees_1 + self.management_fees_1)
+            - (self.performance_rebate_1 + self.management_rebate_1),
+            rel=1e-4,
+        )
+
+    def test_marginality_usd(self, marginality_calculator):
+        assert marginality_calculator.management_marginality_usd.loc[self.product_id] == pytest.approx(
+            marginality_calculator.management_marginality.loc[self.product_id], rel=1e-4
+        )
+        assert marginality_calculator.performance_marginality_usd.loc[self.product_id] == pytest.approx(
+            marginality_calculator.performance_marginality.loc[self.product_id], rel=1e-4
+        )
+        assert marginality_calculator.total_marginality_usd.loc[self.product_id] == pytest.approx(
+            marginality_calculator.total_marginality.loc[self.product_id], rel=1e-4
+        )
+
+    def test_marginality_percent(self, marginality_calculator):
+        assert marginality_calculator.management_marginality_percent.loc[self.product_id] == pytest.approx(
+            (self.management_fees_1 - float(self.management_rebate_1)) / self.management_fees_1, rel=1e-4
+        )
+        assert marginality_calculator.performance_marginality_percent.loc[self.product_id] == pytest.approx(
+            (self.performance_fees_1 + self.performance_crys_fees_1 - float(self.performance_rebate_1))
+            / (self.performance_fees_1 + self.performance_crys_fees_1),
+            rel=1e-4,
+        )
+        assert marginality_calculator.total_marginality_percent.loc[self.product_id] == pytest.approx(
+            (
+                (self.performance_fees_1 + self.performance_crys_fees_1 + self.management_fees_1)
+                - (float(self.performance_rebate_1) + float(self.management_rebate_1))
+            )
+            / (self.performance_fees_1 + self.performance_crys_fees_1 + self.management_fees_1),
+            rel=1e-4,
+        )
+
+    def test_marginality_percent_usd(self, marginality_calculator):
+        assert marginality_calculator.management_marginality_percent_usd.loc[self.product_id] == pytest.approx(
+            marginality_calculator.management_marginality_percent.loc[self.product_id], rel=1e-4
+        )
+        assert marginality_calculator.performance_marginality_percent_usd.loc[self.product_id] == pytest.approx(
+            marginality_calculator.performance_marginality_percent.loc[self.product_id], rel=1e-4
+        )
+        assert marginality_calculator.total_marginality_percent_usd.loc[self.product_id] == pytest.approx(
+            marginality_calculator.total_marginality_percent.loc[self.product_id], rel=1e-4
+        )
+
+    def test_get_net_marginality(self, marginality_calculator):
+        assert marginality_calculator.get_net_marginality("management").loc[self.product_id] == pytest.approx(
+            (self.management_fees_1 - float(self.management_rebate_1)) / (100 * 100) * 360, rel=1e-4
+        )
+
+    def test_get_aggregated_net_marginality(self, marginality_calculator):
+        product_1 = ProductFactory.create()
+        product_2 = ProductFactory.create()
+        start = (fake.date_object() + BDay(0)).date()
+        end = (start + BDay(1)).date()
+
+        (
+            i1,
+            management_fees_1,
+            performance_fees_1,
+            performance_crys_fees_1,
+            management_rebate_1,
+            performance_rebate_1,
+        ) = _create_fixture(product_1, start)
+        (
+            i2,
+            management_fees_2,
+            performance_fees_2,
+            performance_crys_fees_2,
+            management_rebate_2,
+            performance_rebate_2,
+        ) = _create_fixture(product_2, start, outstanding_shares=1000)
+        total_aum = 100 * 100 + 100 * 1000
+        calculator = MarginalityCalculator(Product.objects.filter(id__in=[product_1.id, product_2.id]), start, end)
+        assert calculator.get_aggregated_net_marginality("management") == pytest.approx(
+            ((management_fees_1 + management_fees_2) - (management_rebate_1 + management_rebate_2)) / total_aum * 360,
+            rel=1e-4,
+        )
+
+    def test_rebate_marginality_view(self, marginality_calculator, super_user):
+        request = APIRequestFactory().get("")
+        request.query_params = {}
+        request.GET = {"date_gte": self.start.strftime("%Y-%m-%d"), "date_lte": self.end.strftime("%Y-%m-%d")}
+        request.user = super_user
+        viewset = RebateProductMarginalityViewSet(request=request)
+        assert set(viewset._get_dataframe().columns) == {
+            "id",
+            "title",
+            "currency_symbol",
+            "base_management_fees_percent",
+            "management_fees",
+            "management_rebates",
+            "management_marginality",
+            "management_marginality_percent",
+            "base_performance_fees_percent",
+            "performance_fees",
+            "performance_rebates",
+            "performance_marginality",
+            "total_fees",
+            "total_rebates",
+            "total_marginality_percent",
+            "total_fees_usd",
+            "total_rebates_usd",
+            "total_marginality_usd",
+            "net_management_marginality",
+            "net_performance_marginality",
+        }
+
+        # regression tests to check that without date range the view doesn't break
+        url = reverse("wbcommission:rebatemarginalitytable-list", args=[])
+        api_client = APIClient()
+        api_client.force_authenticate(super_user)
+
+        response = api_client.options(url)
+        assert response.status_code == 200
+
+        response = api_client.get(url)
+        assert response.status_code == 200
+
+        # check that with proper date range the viewset return some content
+        response = api_client.options(url, data=request.GET)
+        assert response.status_code == 200
+
+        response = api_client.get(url, data=request.GET)
+        assert response.status_code == 200
+        assert response.json()["results"]

wbcommission/tests/conftest.py

@@ -0,0 +1,89 @@
+from wbcore.tests.conftest import *  # isort: skip # type: ignore
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import (
+    AuthenticatedPersonFactory,
+    SuperUserFactory,
+    UserFactory,
+)
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories.entries import (
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EntryFactory,
+    PersonFactory,
+)
+from wbcore.contrib.geography.factories import (
+    CityFactory,
+    ContinentFactory,
+    CountryFactory,
+    StateFactory,
+)
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcrm.factories import AccountFactory, AccountRoleFactory, AccountRoleTypeFactory
+from wbfdm.factories import ExchangeFactory, InstrumentFactory, InstrumentTypeFactory
+from wbportfolio.factories import (
+    ClaimFactory,
+    CustomerTradeFactory,
+    FeesFactory,
+    InstrumentPriceFactory,
+    PortfolioFactory,
+    ProductFactory,
+    ProductPortfolioRoleFactory,
+)
+
+from ..factories import (
+    AccountTypeRoleCommissionFactory,
+    CommissionExclusionRuleFactory,
+    CommissionFactory,
+    CommissionRoleFactory,
+    CommissionTypeFactory,
+    PortfolioRoleCommissionFactory,
+    RebateFactory,
+)
+
+register(AccountFactory)
+register(AccountRoleFactory)
+register(AccountRoleTypeFactory)
+
+register(InstrumentFactory)
+register(InstrumentTypeFactory)
+register(ExchangeFactory)
+register(ProductFactory)
+register(ProductPortfolioRoleFactory)
+register(FeesFactory)
+register(PortfolioFactory)
+register(InstrumentPriceFactory)
+register(ClaimFactory)
+register(CustomerTradeFactory)
+register(CurrencyFXRatesFactory)
+
+register(CurrencyFactory)
+register(CityFactory)
+register(StateFactory)
+register(CountryFactory)
+register(ContinentFactory)
+
+register(CompanyFactory)
+register(EntryFactory)
+register(PersonFactory)
+register(CustomerStatusFactory)
+register(CompanyTypeFactory)
+
+register(AuthenticatedPersonFactory, "authenticated_person")
+register(UserFactory)
+register(SuperUserFactory, "superuser")
+
+register(RebateFactory)
+register(CommissionTypeFactory)
+register(CommissionFactory)
+register(CommissionExclusionRuleFactory)
+register(AccountTypeRoleCommissionFactory, "account_role_type_commission")
+register(CommissionRoleFactory)
+register(PortfolioRoleCommissionFactory, "portfolio_role_commission")
+from .signals import *
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbportfolio"))
+from .signals import *  # noqa: F401

wbcommission/tests/models/mixins.py

@@ -0,0 +1,22 @@
+import pytest
+from wbcommission.factories import CommissionTypeFactory
+from wbcommission.models.account_service import AccountRebateManager
+from wbcrm.factories import AccountFactory
+
+
+class AccountManagerFixture:
+    @pytest.fixture()
+    def performance_account_manager(self):
+        commission_type = CommissionTypeFactory.create(name="PERFORMANCE")
+        account_manager = AccountRebateManager(AccountFactory.create(), commission_type.key)
+        account_manager.initialize()
+
+        return account_manager
+
+    @pytest.fixture()
+    def management_account_manager(self):
+        commission_type = CommissionTypeFactory.create(name="MANAGEMENT")
+        account_manager = AccountRebateManager(AccountFactory.create(), commission_type.key)
+        account_manager.initialize()
+
+        return account_manager

wbcommission/tests/models/test_account_service.py

@@ -0,0 +1,293 @@
+import random
+from decimal import Decimal
+
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbcommission.models.account_service import AccountRebateManager
+from wbportfolio.models import Claim
+
+from .mixins import AccountManagerFixture
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestAccountService(AccountManagerFixture):
+    def test_get_commission_pool(
+        self, management_account_manager, fees_factory, claim_factory, customer_trade_factory
+    ):
+        mngt_fees = fees_factory.create(transaction_subtype="MANAGEMENT")
+        perf_fees = fees_factory.create(  # noqa
+            transaction_subtype="PERFORMANCE",
+            transaction_date=mngt_fees.transaction_date,
+            linked_product=mngt_fees.linked_product,
+        )  # noqa
+        claim_factory.create(
+            account=management_account_manager.root_account,
+            trade=customer_trade_factory.create(underlying_instrument=mngt_fees.linked_product),
+            status="APPROVED",
+        )
+        management_account_manager.initialize()
+
+        assert (
+            management_account_manager.get_commission_pool(mngt_fees.linked_product, mngt_fees.transaction_date)
+            == mngt_fees.total_value
+        )
+
+    def test_get_commission_pool_performance(
+        self, performance_account_manager, fees_factory, claim_factory, customer_trade_factory
+    ):
+        mngt_fees = fees_factory.create(transaction_subtype="MANAGEMENT")
+        perf_fees = fees_factory.create(
+            transaction_subtype="PERFORMANCE",
+            transaction_date=mngt_fees.transaction_date,
+            linked_product=mngt_fees.linked_product,
+        )
+        perf2_fees = fees_factory.create(
+            transaction_subtype="PERFORMANCE_CRYSTALIZED",
+            transaction_date=mngt_fees.transaction_date,
+            linked_product=mngt_fees.linked_product,
+        )
+
+        claim_factory.create(
+            account=performance_account_manager.root_account,
+            trade=customer_trade_factory.create(underlying_instrument=mngt_fees.linked_product),
+            status="APPROVED",
+        )
+        performance_account_manager.initialize()
+
+        assert (
+            performance_account_manager.get_commission_pool(mngt_fees.linked_product, mngt_fees.transaction_date)
+            == perf_fees.total_value + perf2_fees.total_value
+        )
+
+    def test_get_commission_pool_with_calculated(
+        self, management_account_manager, fees_factory, claim_factory, customer_trade_factory
+    ):
+        # check that in case there is only calculate, we return the calculated fees value, but in case there is calculated and real fees, we use the real fees value
+        calculated_fees = fees_factory.create(calculated=True, transaction_subtype="MANAGEMENT")
+        claim_factory.create(
+            account=management_account_manager.root_account,
+            trade=customer_trade_factory.create(underlying_instrument=calculated_fees.linked_product),
+            status="APPROVED",
+        )
+        management_account_manager.initialize()
+
+        assert (
+            management_account_manager.get_commission_pool(
+                calculated_fees.linked_product, calculated_fees.transaction_date
+            )
+            == calculated_fees.total_value
+        )
+        # Check that is there is a non calculated fees, it is used instead of the calculated one
+        fees = fees_factory.create(transaction_subtype=calculated_fees.transaction_subtype, calculated=False)
+        claim_factory.create(
+            account=management_account_manager.root_account,
+            trade=customer_trade_factory.create(underlying_instrument=fees.linked_product),
+            status="APPROVED",
+        )
+        management_account_manager.initialize()
+
+        assert (
+            management_account_manager.get_commission_pool(fees.linked_product, fees.transaction_date)
+            == fees.total_value
+        )
+
+    @pytest.mark.parametrize("val_date", [fake.past_date()])
+    def test_get_terminal_account_holding_ratio(
+        self, account_factory, claim_factory, instrument_price_factory, product_factory, val_date, commission_type
+    ):
+        product1 = product_factory.create()
+        product2 = product_factory.create()
+        val_date = (val_date + BDay(0)).date()
+        next_val_date = (val_date + BDay(1)).date()
+
+        product1_price_val_date = instrument_price_factory.create(
+            date=val_date, instrument=product1, outstanding_shares=Decimal(2e4), calculated=True
+        )
+
+        product1_price_next_val_date = instrument_price_factory.create(
+            date=next_val_date, instrument=product1, outstanding_shares=Decimal(2e4), calculated=True
+        )
+
+        product2_price_val_date = instrument_price_factory.create(
+            date=val_date, instrument=product2, outstanding_shares=Decimal(2e4), calculated=True
+        )
+        product2_price_next_val_date = instrument_price_factory.create(
+            date=next_val_date, instrument=product2, outstanding_shares=Decimal(2e4), calculated=True
+        )
+
+        parent_account = account_factory.create(is_terminal_account=False, is_active=True)
+        claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=parent_account,
+        )  # ignore this claim because it's attached to a non terminal account
+
+        child_terminal_account = account_factory.create(
+            parent=parent_account, is_terminal_account=True, is_active=True
+        )
+        claim_factory.create(  # ignore this claim because it's not approved
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            account=child_terminal_account,
+            trade__underlying_instrument=product1,
+            status=random.choice([Claim.Status.DRAFT, Claim.Status.WITHDRAWN, Claim.Status.PENDING]),
+        )
+        unvalid_child_terminal_account = account_factory.create(parent=parent_account, is_active=False)
+        claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=unvalid_child_terminal_account,
+        )  # ignore this claim as the attached account is not active
+
+        valid_claim1 = claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=child_terminal_account,
+        )
+        valid_claim2 = claim_factory.create(
+            trade__value_date=next_val_date,
+            trade__transaction_date=(next_val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=child_terminal_account,
+        )
+        valid_claim3 = claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product2,
+            status=Claim.Status.APPROVED,
+            account=child_terminal_account,
+        )
+        product1_price_val_date.refresh_from_db()
+        product1_price_next_val_date.refresh_from_db()
+        product2_price_val_date.refresh_from_db()
+        product2_price_next_val_date.refresh_from_db()
+
+        account_manager = AccountRebateManager(parent_account, commission_type.key)
+        account_manager.initialize()
+        assert account_manager.get_terminal_account_holding_ratio(
+            child_terminal_account, product1, val_date
+        ) == pytest.approx((valid_claim1.shares / product1_price_val_date.outstanding_shares), rel=Decimal(1e-6))
+        assert account_manager.get_terminal_account_holding_ratio(
+            child_terminal_account, product1, next_val_date
+        ) == pytest.approx(
+            (valid_claim1.shares + valid_claim2.shares) / product1_price_next_val_date.outstanding_shares,
+            rel=Decimal(1e-6),
+        )
+        assert account_manager.get_terminal_account_holding_ratio(
+            child_terminal_account, product2, val_date
+        ) == pytest.approx((valid_claim3.shares / product2_price_val_date.outstanding_shares), rel=Decimal(1e-6))
+        assert account_manager.get_terminal_account_holding_ratio(
+            child_terminal_account, product2, next_val_date
+        ) == pytest.approx((valid_claim3.shares / product2_price_next_val_date.outstanding_shares), rel=Decimal(1e-6))
+
+    @pytest.mark.parametrize("val_date", [fake.date_object()])
+    def test_get_root_account_total_holding(
+        self, account_factory, claim_factory, product_factory, instrument_price_factory, val_date, commission_type
+    ):
+        product1 = product_factory.create()
+        product2 = product_factory.create()
+        val_date = (val_date + BDay(0)).date()
+        next_val_date = (val_date + BDay(1)).date()
+        product1_price_val_date = instrument_price_factory.create(date=val_date, instrument=product1, calculated=False)
+        product1_price_next_val_date = instrument_price_factory.create(
+            date=next_val_date, instrument=product1, calculated=False
+        )
+        product2_price_val_date = instrument_price_factory.create(date=val_date, instrument=product2, calculated=False)
+        product2_price_next_val_date = instrument_price_factory.create(
+            date=next_val_date, instrument=product2, calculated=False
+        )
+
+        parent_account = account_factory.create(is_terminal_account=False, is_active=True)
+        claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=parent_account,
+        )  # ignore this claim because it's attached to a non terminal account
+
+        child_terminal_account = account_factory.create(
+            parent=parent_account, is_terminal_account=True, is_active=True
+        )
+        claim_factory.create(  # ignore this claim because it's not approved
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            account=child_terminal_account,
+            trade__underlying_instrument=product1,
+            status=random.choice([Claim.Status.DRAFT, Claim.Status.WITHDRAWN, Claim.Status.PENDING]),
+        )
+        unvalid_child_terminal_account = account_factory.create(parent=parent_account, is_active=False)
+        claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=unvalid_child_terminal_account,
+        )  # ignore this claim as the attached account is not active
+
+        valid_claim1 = claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=child_terminal_account,
+        )
+        valid_claim2 = claim_factory.create(
+            trade__value_date=next_val_date,
+            trade__transaction_date=(next_val_date - BDay(1)).date(),
+            trade__underlying_instrument=product1,
+            status=Claim.Status.APPROVED,
+            account=child_terminal_account,
+        )
+        valid_claim3 = claim_factory.create(
+            trade__value_date=val_date,
+            trade__transaction_date=(val_date - BDay(1)).date(),
+            trade__underlying_instrument=product2,
+            status=Claim.Status.APPROVED,
+            account=child_terminal_account,
+        )
+
+        account_manager = AccountRebateManager(parent_account, commission_type.key)
+        account_manager.initialize()
+
+        valid_claim1_aum = (  # noqa
+            valid_claim1.shares
+            * product1_price_val_date.net_value
+            * product1_price_val_date.currency_fx_rate_to_usd.value
+        )
+        valid_claim2_aum = (  # noqa
+            valid_claim2.shares
+            * product1_price_next_val_date.net_value
+            * product1_price_next_val_date.currency_fx_rate_to_usd.value
+        )
+        valid_claim3_aum = (  # noqa
+            valid_claim3.shares
+            * product2_price_val_date.net_value
+            * product2_price_val_date.currency_fx_rate_to_usd.value
+        )
+        assert account_manager.get_root_account_total_holding(val_date) == (
+            pytest.approx(
+                (
+                    valid_claim1.shares * product1_price_val_date._net_value_usd
+                    + valid_claim3.shares * product2_price_val_date._net_value_usd
+                ),
+                rel=Decimal(1e-6),
+            )
+        )
+        assert account_manager.get_root_account_total_holding(next_val_date) == (
+            pytest.approx(
+                (valid_claim1.shares + valid_claim2.shares) * product1_price_next_val_date._net_value_usd
+                + valid_claim3.shares * product2_price_next_val_date._net_value_usd,
+                rel=Decimal(1e-8),
+            )
+        )