wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/tests/models/test_product_groups.py

@@ -0,0 +1,80 @@
+from datetime import timedelta
+
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbportfolio.models import Trade
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestProductGroupModel:
+    def test_init(self, product_group):
+        assert product_group.id is not None
+
+    def test_get_total_fund_aum(
+        self,
+        portfolio_factory,
+        product_factory,
+        instrument_price_factory,
+        trade_factory,
+        product_group,
+        currency_fx_rates_factory,
+        weekday,
+    ):
+        p1 = product_factory.create(parent=product_group, inception_date=weekday)
+        p2 = product_factory.create(parent=product_group, inception_date=weekday)
+        portfolio1 = p1.portfolio
+        portfolio2 = p2.portfolio
+        shares1 = 1000
+        v1 = instrument_price_factory.create(date=weekday, instrument=p1, outstanding_shares=shares1)
+        c11 = trade_factory.create(
+            portfolio=portfolio1,
+            shares=shares1,
+            value_date=weekday,
+            underlying_instrument=p1,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        fx_rate1 = p1.currency.fx_rates.get(date=v1.date)
+
+        c21 = trade_factory.create(
+            portfolio=portfolio2,
+            value_date=weekday,
+            underlying_instrument=p2,
+            transaction_subtype=Trade.Type.REDEMPTION,
+        )
+        v2 = instrument_price_factory.create(instrument=p2, date=weekday, outstanding_shares=c21.shares)
+        fx_rate2 = p2.currency.fx_rates.get(date=weekday)
+        p1.update_last_valuation_date()
+        p2.update_last_valuation_date()
+        assert float(product_group.get_total_fund_aum(weekday)) == pytest.approx(
+            float(v1.net_value) * float(c11.shares) / float(fx_rate1.value)
+            + float(v2.net_value) * float(c21.shares) / float(fx_rate2.value)
+        )
+        # test: get only trade at value_date
+        trade_factory.create(portfolio=portfolio1, transaction_date=weekday, value_date=weekday + timedelta(days=1))
+        assert float(product_group.get_total_fund_aum(weekday)) == pytest.approx(
+            float(v1.net_value) * float(c11.shares) / float(fx_rate1.value)
+            + float(v2.net_value) * float(c21.shares) / float(fx_rate2.value)
+        )
+
+    @pytest.mark.parametrize("val_date", [fake.date_object()])
+    def test_get_fund_product_table(self, product_group, product_factory, instrument_price_factory, val_date):
+        val_date = (val_date + BDay(1)).date()
+        p1 = product_factory.create(parent=product_group, inception_date=val_date)
+        p2 = product_factory.create(parent=product_group, inception_date=val_date)
+
+        v1 = instrument_price_factory.create(instrument=p1, date=val_date, calculated=False)
+        v2 = instrument_price_factory.create(instrument=p2, date=val_date, calculated=False)
+        df = product_group.get_fund_product_table(v2.date)
+        dfp1 = df[df["share class"] == p1.name]
+        assert dfp1["share class"].iloc[0] == p1.name
+        assert dfp1["launch date"].iloc[0] == f"{v1.date:%Y-%m-%d}"
+        assert dfp1["price"].iloc[0] == f"{v1.net_value:,.2f}"
+
+
+@pytest.mark.django_db
+class TestProductGroupRepresentantModel:
+    def test_init(self, product_group_representant):
+        assert product_group_representant.id is not None

wbportfolio/tests/models/test_products.py

@@ -0,0 +1,187 @@
+import datetime
+from decimal import Decimal
+
+import pytest
+from faker import Faker
+from wbfdm.models import Instrument
+from wbportfolio.models import Product, Trade
+
+from .utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestProductModel(PortfolioTestMixin):
+    def test_init(self, product):
+        assert product.id is not None
+
+    def test_white_label(self, white_label_product):
+        assert white_label_product.white_label_product
+
+    def test_total_value(self, product_factory, trade_factory, instrument_price_factory):
+        product = product_factory.create()
+        t1 = trade_factory.create(
+            shares=100,
+            underlying_instrument=product,
+            transaction_date=datetime.date(2010, 1, 1) - datetime.timedelta(days=2),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        t2 = trade_factory.create(
+            shares=50,
+            underlying_instrument=product,
+            transaction_date=datetime.date(2010, 1, 1) - datetime.timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        t3 = trade_factory.create(  # noise
+            shares=10,
+            underlying_instrument=product,
+            transaction_date=datetime.date(2010, 1, 1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        p1 = instrument_price_factory.create(
+            instrument=Instrument.objects.get(id=product.id), date=t1.transaction_date
+        )
+        p2 = instrument_price_factory.create(
+            instrument=Instrument.objects.get(id=product.id), date=t2.transaction_date
+        )
+        p3 = instrument_price_factory.create(
+            instrument=Instrument.objects.get(id=product.id), date=t3.transaction_date
+        )
+        assert product.total_value(p1.date) == pytest.approx(Decimal(0), rel=Decimal("1e-4"))
+        assert product.total_value(p2.date) == pytest.approx(Decimal(p2.net_value * (t1.shares)), rel=Decimal("1e-4"))
+        assert product.total_value(p3.date) == pytest.approx(
+            Decimal(p3.net_value * (t1.shares + t2.shares)), rel=Decimal("1e-4")
+        )
+
+    def test_total_shares_with_date(self, product_factory, trade_factory):
+        date1 = datetime.date(2010, 1, 1)
+        date2 = datetime.date(2010, 1, 2)
+        product = product_factory.create()
+        sub1 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date1 - datetime.timedelta(days=1),
+            value_date=date1,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        sub2 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date2 - datetime.timedelta(days=1),
+            value_date=date2,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        red1 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date1 - datetime.timedelta(days=1),
+            value_date=date1,
+            transaction_subtype=Trade.Type.REDEMPTION,
+        )
+        red2 = trade_factory.create(
+            underlying_instrument=product,
+            transaction_date=date2 - datetime.timedelta(days=1),
+            value_date=date2,
+            transaction_subtype=Trade.Type.REDEMPTION,
+        )
+        assert product.total_shares(date1 - datetime.timedelta(days=1)) == 0
+        assert product.total_shares(date1) == red1.shares + sub1.shares
+        assert product.total_shares(date2) == red1.shares + red2.shares + sub1.shares + sub2.shares
+
+    def test_nominal_value_with_date(self, product_factory, trade_factory):
+        product = product_factory.create()
+        trade_factory.create_batch(
+            5,
+            shares=100,
+            underlying_instrument=product,
+            transaction_date=datetime.date(2010, 1, 1) - datetime.timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        trade_factory.create_batch(
+            5,
+            shares=100,
+            underlying_instrument=product,
+            transaction_date=datetime.date(2010, 1, 2) - datetime.timedelta(days=1),
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+        )
+        assert product.nominal_value(datetime.date(2010, 1, 1)) == (500 * product.share_price)
+        assert product.nominal_value(datetime.date(2010, 1, 2)) == (1000 * product.share_price)
+
+    def test_get_title(self, product, user):
+        assert product.get_title()
+
+    def test_compute_str(self, product, user):
+        assert product.compute_str()
+
+    def test_urlify_title(self, product):
+        assert product.name.lower() in product.urlify_title
+
+    def test_get_products_internal_user(self, product, white_label_product, internal_user_factory):
+        assert set(Product.get_products(internal_user_factory.create().profile)) == {product, white_label_product}
+
+    def test_get_products_normal_user(self, product_factory, user, company):
+        public_product = product_factory.create()
+        assert set(Product.get_products(user.profile)) == {public_product}
+
+        white_label_product_profile = product_factory.create()
+        white_label_product_profile.white_label_customers.add(user.profile)
+
+        white_label_product_employer = product_factory.create()
+        user.profile.employers.add(company)
+        white_label_product_employer.white_label_customers.add(company)
+
+        assert set(Product.get_products(user.profile)) == {
+            white_label_product_employer,
+            white_label_product_profile,
+            public_product,
+        }
+
+    def test_subquery_is_white_label_product(self, product, white_label_product):
+        product_queryset = Product.objects.all().annotate(is_white_label=Product.subquery_is_white_label_product())
+        # for product in product_queryset:
+        #     print(product, product.is_white_label)
+
+        # print(product_queryset.filter(is_white_label=True).count())
+
+        assert product_queryset.filter(is_white_label=True).count() == 1
+
+    def test_annotate_aum(
+        self, portfolio, product_factory, instrument_price_factory, trade_factory, currency_fx_rates_factory
+    ):
+        p1 = product_factory.create()
+        d = datetime.date(2021, 1, 1)
+        c1 = trade_factory.create(
+            portfolio=p1.portfolio,
+            underlying_instrument=p1,
+            transaction_subtype=Trade.Type.SUBSCRIPTION,
+            value_date=d,
+            transaction_date=d,
+        )
+        v1 = instrument_price_factory.create(instrument=p1, date=d, outstanding_shares=c1.shares)
+        fx_rate = p1.currency.fx_rates.get(date=d)
+        qs = Product.annotate_last_aum(Product.objects.all(), val_date=d)
+        p1.update_last_valuation_date()
+        assert float(qs.first().assets_under_management_usd) == pytest.approx(
+            float(v1.net_value) * float(c1.shares) / float(fx_rate.value)
+        )
+
+    def test_account_merging(self, account_factory, product):
+        base_account = account_factory.create()
+        merged_account = account_factory.create()
+        product.default_account = merged_account
+        product.save()
+        base_account.merge(merged_account)
+        product.refresh_from_db()
+        assert product.default_account == base_account
+
+    def test_high_water_mark(self, product, instrument_price_factory):
+        initial_price = instrument_price_factory.create(instrument=product, net_value=100)
+        p1 = instrument_price_factory.create(instrument=product, net_value=200)
+        p2 = instrument_price_factory.create(instrument=product, net_value=100)
+        p3 = instrument_price_factory.create(instrument=product, net_value=300)
+        p4 = instrument_price_factory.create(instrument=product, net_value=100)
+        assert product.get_high_water_mark(p1.date) == initial_price.net_value
+        assert product.get_high_water_mark(p2.date) == p1.net_value
+        assert product.get_high_water_mark(p3.date) == p1.net_value
+        assert product.get_high_water_mark(p4.date) == p3.net_value
+        product.initial_high_water_mark = 400
+        product.save()
+        assert product.get_high_water_mark(p4.date) == 400

wbportfolio/tests/models/test_roles.py

@@ -0,0 +1,82 @@
+import pytest
+from wbportfolio.factories import (
+    ManagerPortfolioRoleFactory,
+    ProductPortfolioRoleFactory,
+)
+from wbportfolio.models import PortfolioRole
+from wbportfolio.permissions import is_analyst, is_manager, is_portfolio_manager
+
+
+@pytest.mark.django_db
+class TestPortfolioRoleModel:
+    def test_init_product_portfolio_role(self, product_portfolio_role):
+        assert product_portfolio_role.id is not None
+
+    def test_init_manager_portfolio_role(self, manager_portfolio_role):
+        assert manager_portfolio_role.id is not None
+
+    def test_str(self, product_portfolio_role):
+        assert (
+            str(product_portfolio_role)
+            == f"{product_portfolio_role.role_type} {product_portfolio_role.person.computed_str}"
+        )
+
+    # test is_manager
+
+    def test_is_manager_portfolio_role(self, user):
+        ManagerPortfolioRoleFactory.create(person=user.profile)
+        assert PortfolioRole.is_manager(user.profile)
+
+    def test_is_not_manager_portfolio_role(self, user):
+        assert not PortfolioRole.is_manager(user.profile)
+
+    def test_is_manager_portfolio_role_superuser(self, superuser):
+        superuser.is_superuser = True
+        superuser.save()
+        assert PortfolioRole.is_manager(superuser.profile)
+
+    # test is_portfolio_manager
+
+    def test_is_portfolio_manager_portfolio_role(self, user, product):
+        ProductPortfolioRoleFactory.create(
+            person=user.profile, instrument=product, role_type=PortfolioRole.RoleType.PORTFOLIO_MANAGER
+        )
+        assert PortfolioRole.is_portfolio_manager(user.profile, product)
+
+    def test_is_portfolio_manager_portfolio_role_manager(self, user, product):
+        ManagerPortfolioRoleFactory.create(person=user.profile)
+        assert PortfolioRole.is_portfolio_manager(user.profile, product)
+
+    def test_is_not_portfolio_manager_portfolio_role(self, user, product):
+        assert not PortfolioRole.is_portfolio_manager(user.profile, product)
+
+    def test_is_portfolio_manager_portfolio_role_superuser(self, superuser, product):
+        assert PortfolioRole.is_portfolio_manager(superuser.profile, product)
+
+    # test is_analyst
+
+    def test_is_analyst_portfolio_role(self, user, product):
+        ProductPortfolioRoleFactory.create(
+            person=user.profile, instrument=product, role_type=PortfolioRole.RoleType.ANALYST
+        )
+        assert PortfolioRole.is_analyst(user.profile, product)
+
+    def test_is_analyst_portfolio_role_manager(self, user, product):
+        ManagerPortfolioRoleFactory.create(person=user.profile)
+        assert PortfolioRole.is_analyst(user.profile, product)
+
+    def test_is_not_analyst_portfolio_role(self, user, product):
+        assert not PortfolioRole.is_analyst(user.profile, product)
+
+    def test_is_analyst_portfolio_role_superuser(self, superuser, product):
+        assert PortfolioRole.is_analyst(superuser.profile, product)
+
+    def test_permissions(self, user):
+        class Request:
+            def __init__(self, user):
+                self.user = user
+
+        request = Request(user)
+        assert is_manager(request) == PortfolioRole.is_manager(user.profile)
+        assert is_analyst(request) == PortfolioRole.is_analyst(user.profile)
+        assert is_portfolio_manager(request) == PortfolioRole.is_portfolio_manager(user.profile)

wbportfolio/tests/models/test_splits.py

@@ -0,0 +1,233 @@
+from decimal import Decimal
+from unittest.mock import patch
+
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbportfolio.factories import AdjustmentFactory
+from wbportfolio.models import Adjustment, PortfolioRole
+from wbportfolio.models.adjustments import post_adjustment_on_prices
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestAdjustmentModel:
+    @pytest.fixture()
+    def applied_adjustment(self):
+        return AdjustmentFactory.create(status=Adjustment.Status.APPLIED)
+
+    @pytest.fixture()
+    def old_adjustment(self):
+        return AdjustmentFactory.create(status=Adjustment.Status.PENDING, date=fake.past_date())
+
+    # Test utilities function
+    @patch("wbportfolio.models.adjustments.chain")
+    def test_adjustment_creation(
+        self,
+        mock_fct,
+        user_factory,
+        adjustment_factory,
+        product_portfolio_role_factory,
+        asset_position_factory,
+        instrument,
+    ):
+        user_factory.create()  # User without permission
+        user_porftolio_manager = user_factory.create()
+        product_portfolio_role_factory.create(
+            person=user_porftolio_manager.profile, role_type=PortfolioRole.RoleType.PORTFOLIO_MANAGER
+        )
+        asset_position_factory.create(underlying_instrument=instrument)
+        adjustment2 = adjustment_factory.create(instrument=instrument, date=fake.past_date())
+        assert mock_fct.call_count == 1
+        assert adjustment2.status == Adjustment.Status.PENDING
+
+        # If newly created instrument's adjustment happens in the future, its state becomes pending and an import task is triggered
+        adjustment1 = adjustment_factory.create(instrument=instrument)
+        assert adjustment1.status == Adjustment.Status.PENDING
+        assert mock_fct.call_count == 2
+
+    def test_cumulative_factor(self, adjustment_factory):
+        """
+        s1 -> s2 -> s3
+        """
+        s3 = adjustment_factory.create(status=Adjustment.Status.APPLIED)
+        s3.refresh_from_db()
+        assert s3.cumulative_factor == Decimal(1.0)
+
+        s2 = adjustment_factory.create(
+            status=Adjustment.Status.APPLIED, instrument=s3.instrument, date=s3.date - BDay(1)
+        )
+        s1 = adjustment_factory.create(
+            instrument=s3.instrument, date=s3.date - BDay(2)
+        )  # This adjustment is not applied and shouldn't be accounted for in the cumulative factor of the futures adjustments
+        s3.refresh_from_db()
+        s2.refresh_from_db()
+        s1.refresh_from_db()
+        assert s2.cumulative_factor == pytest.approx(
+            s3.factor, rel=Decimal(1e-3)
+        )  # Normal case, applied adjustment cumulative factor should reflect the parent factors
+        assert s1.cumulative_factor == pytest.approx(
+            s2.factor * s3.factor, rel=Decimal(1e-3)
+        )  # even if not applied, cumulative factor is computed normally
+
+    def test_apply_adjustment_on_assets(self, adjustment, asset_position_factory):
+        a1 = asset_position_factory.create(
+            underlying_instrument=adjustment.instrument, date=adjustment.adjustment_date
+        )
+        a2 = asset_position_factory.create(underlying_instrument=adjustment.instrument, date=adjustment.date)
+        adjustment.apply_adjustment_on_assets()
+        a1.refresh_from_db()
+        a2.refresh_from_db()
+        assert a1.applied_adjustment == adjustment
+        assert not a2.applied_adjustment
+
+    def test_future_adjustment_not_applied_on_assets(self, adjustment, asset_position_factory):
+        p = asset_position_factory.create(
+            underlying_instrument=adjustment.instrument, date=(adjustment.date + BDay(1)).date()
+        )
+
+        adjustment.apply_adjustment_on_assets()
+        p.refresh_from_db()
+        assert not p.applied_adjustment
+
+    def test_adjustment_played_out_of_order(self, adjustment_factory, asset_position_factory):
+        s1 = adjustment_factory.create()
+        s2 = adjustment_factory.create(instrument=s1.instrument, date=(s1.date + BDay(2)).date())
+
+        a0 = asset_position_factory.create(underlying_instrument=s1.instrument, date=s2.adjustment_date - BDay(3))
+        a1 = asset_position_factory.create(
+            underlying_instrument=s1.instrument, date=s2.adjustment_date - BDay(2), applied_adjustment=s2
+        )
+        a2 = asset_position_factory.create(
+            underlying_instrument=s1.instrument, date=s2.adjustment_date - BDay(1), applied_adjustment=s2
+        )
+        a3 = asset_position_factory.create(
+            underlying_instrument=s1.instrument, date=s2.adjustment_date, applied_adjustment=s2
+        )
+
+        s1.apply_adjustment_on_assets()
+        a0.refresh_from_db()
+        a1.refresh_from_db()
+        a2.refresh_from_db()
+        a3.refresh_from_db()
+
+        assert a0.applied_adjustment == s1
+        assert a1.applied_adjustment == s1
+        assert a2.applied_adjustment == s2
+        assert a3.applied_adjustment == s2
+
+    # Test Basic FSM workflow
+    @patch("wbportfolio.models.adjustments.apply_adjustment_on_assets_as_task.delay")
+    def test_apply(self, mock_fct, old_adjustment):
+        assert mock_fct.call_count == 0
+        old_adjustment.apply()
+        old_adjustment.save()
+        assert old_adjustment.status == Adjustment.Status.APPLIED
+        mock_fct.assert_called()
+
+    def test_deny(self, old_adjustment, user):
+        assert old_adjustment.status == Adjustment.Status.PENDING
+        old_adjustment.deny(by=user)
+        old_adjustment.save()
+        assert old_adjustment.last_handler == user.profile
+        assert old_adjustment.status == Adjustment.Status.DENIED
+
+    @patch("wbportfolio.models.adjustments.revert_adjustment_on_assets_as_task.delay")
+    def test_revert(self, mock_fct, adjustment_factory):
+        adjustment = adjustment_factory.create(status=Adjustment.Status.APPLIED)
+        assert mock_fct.call_count == 0
+        adjustment.revert()
+        adjustment.save()
+        assert adjustment.status == Adjustment.Status.PENDING
+        mock_fct.assert_called_with(adjustment.id)
+
+    def test_revert_adjustment_on_assets(self, adjustment_factory, asset_position_factory):
+        s1 = adjustment_factory.create(status=Adjustment.Status.APPLIED)
+        s2 = adjustment_factory.create(
+            date=s1.date + BDay(1), instrument=s1.instrument, status=Adjustment.Status.APPLIED
+        )
+        s3 = adjustment_factory.create(
+            date=s2.date + BDay(1), instrument=s1.instrument, status=Adjustment.Status.APPLIED
+        )
+
+        a1 = asset_position_factory.create(
+            underlying_instrument=s1.instrument, date=s1.adjustment_date, applied_adjustment=s1
+        )
+        a2 = asset_position_factory.create(
+            underlying_instrument=s1.instrument, date=s2.adjustment_date, applied_adjustment=s2
+        )
+        a3 = asset_position_factory.create(
+            underlying_instrument=s1.instrument, date=s3.adjustment_date, applied_adjustment=s3
+        )
+
+        s1.revert_adjustment_on_assets()
+        a1.refresh_from_db()
+        a2.refresh_from_db()
+        a3.refresh_from_db()
+        assert a1.applied_adjustment == s2
+        assert a2.applied_adjustment == s2
+        assert a3.applied_adjustment == s3
+
+        s2.revert_adjustment_on_assets()
+        a1.refresh_from_db()
+        a2.refresh_from_db()
+        a3.refresh_from_db()
+        assert a1.applied_adjustment == s3
+        assert a2.applied_adjustment == s3
+        assert a3.applied_adjustment == s3
+
+        s3.revert_adjustment_on_assets()
+        a1.refresh_from_db()
+        a2.refresh_from_db()
+        a3.refresh_from_db()
+        assert not a1.applied_adjustment
+        assert not a2.applied_adjustment
+        assert not a3.applied_adjustment
+
+    def test_post_adjustment_on_prices_without_assets(self, adjustment):
+        post_adjustment_on_prices(adjustment.id)
+        adjustment.refresh_from_db()
+        assert adjustment.status == Adjustment.Status.APPLIED
+
+    @patch.object(Adjustment, "automatically_applied_adjustments_on_assets")
+    def test_post_adjustment_automatically_approve_on_prices_with_assets(
+        self,
+        mock_check_fct,
+        adjustment,
+        asset_position_factory,
+    ):
+        a1 = asset_position_factory.create(
+            underlying_instrument=adjustment.instrument, date=adjustment.adjustment_date
+        )
+        mock_check_fct.return_value = True
+        post_adjustment_on_prices(adjustment.id)
+        a1.refresh_from_db()
+        adjustment.refresh_from_db()
+        a1.applied_adjustment == adjustment
+        assert adjustment.status == Adjustment.Status.APPLIED
+
+    @patch("wbportfolio.models.adjustments.send_notification")
+    @patch.object(Adjustment, "automatically_applied_adjustments_on_assets")
+    def test_post_adjustment_not_automatically_approve_on_prices_with_assets(
+        self,
+        mock_check_fct,
+        mock_delay_fct,
+        adjustment,
+        asset_position_factory,
+        user_factory,
+        product_portfolio_role_factory,
+    ):
+        asset_position_factory.create(
+            underlying_instrument=adjustment.instrument, date=(adjustment.date - BDay(1)).date()
+        )
+        user_factory.create()  # User without permission
+        user_porftolio_manager = user_factory.create()
+        product_portfolio_role_factory.create(
+            person=user_porftolio_manager.profile, role_type=PortfolioRole.RoleType.PORTFOLIO_MANAGER
+        )
+        mock_check_fct.return_value = False
+        post_adjustment_on_prices(adjustment.id)
+        adjustment.refresh_from_db()
+        mock_delay_fct.call_args[0] == user_porftolio_manager.id
+        assert adjustment.status == Adjustment.Status.PENDING