wip loan update

backend/tests/test_crud.py

@@ -56,7 +56,9 @@ def make_exchange(session: Session, user_id: int, name: str = "NASDAQ") -> int:
     return cast("int", exchange.id)
 
 
-def make_cycle(session: Session, user_id: int, exchange_id: int, friendly_name: str = "Test Cycle") -> int:
+def make_cycle(
+    session: Session, user_id: int, exchange_id: int, friendly_name: str = "Test Cycle"
+) -> int:
     cycle = models.Cycles(
         user_id=user_id,
         friendly_name=friendly_name,
@@ -72,7 +74,9 @@ def make_cycle(session: Session, user_id: int, exchange_id: int, friendly_name:
     return cast("int", cycle.id)
 
 
-def make_trade(session: Session, user_id: int, cycle_id: int, friendly_name: str = "Test Trade") -> int:
+def make_trade(
+    session: Session, user_id: int, cycle_id: int, friendly_name: str = "Test Trade"
+) -> int:
     cycle: models.Cycles | None = session.get(models.Cycles, cycle_id)
     assert cycle is not None
     exchange_id = cycle.exchange_id
@@ -137,13 +141,17 @@ def _ensure_utc_aware(dt: datetime | None) -> datetime | None:
     return dt.astimezone(timezone.utc)
 
 
-def _validate_timestamp(actual: datetime, expected: datetime, tolerance: timedelta) -> None:
+def _validate_timestamp(
+    actual: datetime, expected: datetime, tolerance: timedelta
+) -> None:
     actual_utc = _ensure_utc_aware(actual)
     expected_utc = _ensure_utc_aware(expected)
     assert actual_utc is not None
     assert expected_utc is not None
     delta = abs(actual_utc - expected_utc)
-    assert delta <= tolerance, f"Timestamps differ by {delta}, which exceeds tolerance of {tolerance}"
+    assert delta <= tolerance, (
+        f"Timestamps differ by {delta}, which exceeds tolerance of {tolerance}"
+    )
 
 
 # Trades
@@ -470,7 +478,9 @@ def test_update_trade_friendly_name(session: Session) -> None:
     trade_id = make_trade(session, user_id, cycle_id)
 
     new_friendly_name = "Updated Trade Name"
-    updated_trade = crud.update_trade_friendly_name(session, trade_id, new_friendly_name)
+    updated_trade = crud.update_trade_friendly_name(
+        session, trade_id, new_friendly_name
+    )
     assert updated_trade is not None
     assert updated_trade.id == trade_id
     assert updated_trade.friendly_name == new_friendly_name
@@ -624,7 +634,9 @@ def test_get_cycles_by_user_id(session: Session) -> None:
 def test_update_cycle(session: Session) -> None:
     user_id = make_user(session)
     exchange_id = make_exchange(session, user_id)
-    cycle_id = make_cycle(session, user_id, exchange_id, friendly_name="Initial Cycle Name")
+    cycle_id = make_cycle(
+        session, user_id, exchange_id, friendly_name="Initial Cycle Name"
+    )
 
     update_data = {
         "friendly_name": "Updated Cycle Name",
@@ -646,14 +658,20 @@ def test_update_cycle(session: Session) -> None:
 def test_update_cycle_immutable_fields(session: Session) -> None:
     user_id = make_user(session)
     exchange_id = make_exchange(session, user_id)
-    cycle_id = make_cycle(session, user_id, exchange_id, friendly_name="Initial Cycle Name")
+    cycle_id = make_cycle(
+        session, user_id, exchange_id, friendly_name="Initial Cycle Name"
+    )
 
     # Attempt to update immutable fields
     update_data = {
         "id": cycle_id + 1,  # Trying to change the ID
         "user_id": user_id + 1,  # Trying to change the user_id
-        "start_date": datetime(2020, 1, 1, tzinfo=timezone.utc).date(),  # Trying to change start_date
-        "created_at": datetime(2020, 1, 1, tzinfo=timezone.utc),  # Trying to change created_at
+        "start_date": datetime(
+            2020, 1, 1, tzinfo=timezone.utc
+        ).date(),  # Trying to change start_date
+        "created_at": datetime(
+            2020, 1, 1, tzinfo=timezone.utc
+        ),  # Trying to change created_at
         "friendly_name": "Valid Update",  # Valid field to update
     }
 
@@ -685,7 +703,10 @@ def test_create_cycle_loan_event(session: Session) -> None:
     assert loan_event.id is not None
     assert loan_event.cycle_id == cycle_id
     assert loan_event.loan_amount_cents == loan_data["loan_amount_cents"]
-    assert loan_event.loan_interest_rate_tenth_bps == loan_data["loan_interest_rate_tenth_bps"]
+    assert (
+        loan_event.loan_interest_rate_tenth_bps
+        == loan_data["loan_interest_rate_tenth_bps"]
+    )
     assert loan_event.notes == loan_data["notes"]
     assert loan_event.effective_date == now.date()
     _validate_timestamp(loan_event.created_at, now, timedelta(seconds=1))
@@ -695,12 +716,41 @@ def test_create_cycle_loan_event(session: Session) -> None:
     assert actual_loan_event is not None
     assert actual_loan_event.cycle_id == cycle_id
     assert actual_loan_event.loan_amount_cents == loan_data["loan_amount_cents"]
-    assert actual_loan_event.loan_interest_rate_tenth_bps == loan_data["loan_interest_rate_tenth_bps"]
+    assert (
+        actual_loan_event.loan_interest_rate_tenth_bps
+        == loan_data["loan_interest_rate_tenth_bps"]
+    )
     assert actual_loan_event.notes == loan_data["notes"]
     assert actual_loan_event.effective_date == now.date()
     _validate_timestamp(actual_loan_event.created_at, now, timedelta(seconds=1))
 
 
+def test_create_cycle_loan_event_same_date_error(session: Session) -> None:
+    user_id = make_user(session)
+    exchange_id = make_exchange(session, user_id)
+    cycle_id = make_cycle(session, user_id, exchange_id)
+
+    loan_data_1 = {
+        "cycle_id": cycle_id,
+        "loan_amount_cents": 100000,
+        "loan_interest_rate_tenth_bps": 5000,
+        "effective_date": datetime(2023, 1, 1, tzinfo=timezone.utc).date(),
+        "notes": "First loan event",
+    }
+    loan_data_2 = {
+        "cycle_id": cycle_id,
+        "loan_amount_cents": 150000,
+        "loan_interest_rate_tenth_bps": 4500,
+        "effective_date": datetime(2023, 1, 1, tzinfo=timezone.utc).date(),
+        "notes": "Second loan event same date",
+    }
+
+    crud.create_cycle_loan_event(session, loan_data_1)
+    with pytest.raises(ValueError) as excinfo:
+        crud.create_cycle_loan_event(session, loan_data_2)
+    assert "create_cycle_loan_event integrity error" in str(excinfo.value)
+
+
 def test_get_cycle_loan_events_by_cycle_id(session: Session) -> None:
     user_id = make_user(session)
     exchange_id = make_exchange(session, user_id)
@@ -729,34 +779,77 @@ def test_get_cycle_loan_events_by_cycle_id(session: Session) -> None:
     notes = [event.notes for event in loan_events]
     assert loan_events[0].notes == loan_data_2["notes"]
     assert loan_events[0].effective_date == yesterday
-    assert notes == ["Second loan event", "First loan event"]  # Ordered by effective_date desc
+    assert notes == [
+        "Second loan event",
+        "First loan event",
+    ]  # Ordered by effective_date desc
 
 
-def test_get_cycle_loan_events_by_cycle_id_same_date(session: Session) -> None:
+def test_get_cycle_loan_event_by_cycle_id_and_effective_date(session: Session) -> None:
     user_id = make_user(session)
     exchange_id = make_exchange(session, user_id)
     cycle_id = make_cycle(session, user_id, exchange_id)
 
-    loan_data_1 = {
+    effective_date = datetime(2023, 1, 1, tzinfo=timezone.utc).date()
+    loan_data = {
         "cycle_id": cycle_id,
         "loan_amount_cents": 100000,
         "loan_interest_rate_tenth_bps": 5000,
-        "notes": "First loan event",
+        "effective_date": effective_date,
+        "notes": "Loan event for specific date",
     }
-    loan_data_2 = {
+
+    crud.create_cycle_loan_event(session, loan_data)
+    loan_event = crud.get_loan_event_by_cycle_id_and_effective_date(
+        session, cycle_id, effective_date
+    )
+    assert loan_event is not None
+    assert loan_event.cycle_id == cycle_id
+    assert loan_event.effective_date == effective_date
+    assert loan_event.notes == loan_data["notes"]
+
+
+def test_update_cycle_loan_event(session: Session) -> None:
+    user_id = make_user(session)
+    exchange_id = make_exchange(session, user_id)
+    cycle_id = make_cycle(session, user_id, exchange_id)
+
+    loan_data = {
         "cycle_id": cycle_id,
-        "loan_amount_cents": 150000,
-        "loan_interest_rate_tenth_bps": 4500,
-        "notes": "Second loan event",
+        "loan_amount_cents": 100000,
+        "loan_interest_rate_tenth_bps": 5000,
+        "notes": "Initial loan event",
     }
 
-    crud.create_cycle_loan_event(session, loan_data_1)
-    crud.create_cycle_loan_event(session, loan_data_2)
+    loan_event = crud.create_cycle_loan_event(session, loan_data)
+    assert loan_event is not None
 
-    loan_events = crud.get_loan_events_by_cycle_id(session, cycle_id)
-    assert len(loan_events) == 2
-    notes = [event.notes for event in loan_events]
-    assert notes == ["First loan event", "Second loan event"]  # Ordered by id desc when effective_date is same
+    update_data = {
+        "loan_amount_cents": 120000,
+        "loan_interest_rate_tenth_bps": 4500,
+        "notes": "Updated loan event",
+    }
+    event_id = loan_event.id or 0
+
+    updated_loan_event = crud.update_cycle_loan_event(session, event_id, update_data)
+    assert updated_loan_event is not None
+    assert updated_loan_event.id == loan_event.id
+    assert updated_loan_event.loan_amount_cents == update_data["loan_amount_cents"]
+    assert (
+        updated_loan_event.loan_interest_rate_tenth_bps
+        == update_data["loan_interest_rate_tenth_bps"]
+    )
+    assert updated_loan_event.notes == update_data["notes"]
+
+    session.refresh(updated_loan_event)
+    actual_loan_event = session.get(models.CycleLoanChangeEvents, loan_event.id)
+    assert actual_loan_event is not None
+    assert actual_loan_event.loan_amount_cents == update_data["loan_amount_cents"]
+    assert (
+        actual_loan_event.loan_interest_rate_tenth_bps
+        == update_data["loan_interest_rate_tenth_bps"]
+    )
+    assert actual_loan_event.notes == update_data["notes"]
 
 
 def test_create_cycle_loan_event_single_field(session: Session) -> None:
@@ -802,7 +895,12 @@ def test_create_cycle_daily_accrual(session: Session) -> None:
         "notes": "Daily interest accrual",
     }
 
-    accrual = crud.create_cycle_daily_accrual(session, cycle_id, accrual_data["accrual_date"], accrual_data["accrued_interest_cents"])
+    accrual = crud.create_cycle_daily_accrual(
+        session,
+        cycle_id,
+        accrual_data["accrual_date"],
+        accrual_data["accrued_interest_cents"],
+    )
     assert accrual.id is not None
     assert accrual.cycle_id == cycle_id
     assert accrual.accrual_date == accrual_data["accrual_date"]
@@ -835,8 +933,18 @@ def test_get_cycle_daily_accruals_by_cycle_id(session: Session) -> None:
         "accrued_interest_cents": 150,
     }
 
-    crud.create_cycle_daily_accrual(session, cycle_id, accrual_data_1["accrual_date"], accrual_data_1["accrued_interest_cents"])
-    crud.create_cycle_daily_accrual(session, cycle_id, accrual_data_2["accrual_date"], accrual_data_2["accrued_interest_cents"])
+    crud.create_cycle_daily_accrual(
+        session,
+        cycle_id,
+        accrual_data_1["accrual_date"],
+        accrual_data_1["accrued_interest_cents"],
+    )
+    crud.create_cycle_daily_accrual(
+        session,
+        cycle_id,
+        accrual_data_2["accrual_date"],
+        accrual_data_2["accrued_interest_cents"],
+    )
 
     accruals = crud.get_cycle_daily_accruals_by_cycle_id(session, cycle_id)
     assert len(accruals) == 2
@@ -863,18 +971,37 @@ def test_get_cycle_daily_accruals_by_cycle_id_and_date(session: Session) -> None
         "accrued_interest_cents": 150,
     }
 
-    crud.create_cycle_daily_accrual(session, cycle_id, accrual_data_1["accrual_date"], accrual_data_1["accrued_interest_cents"])
-    crud.create_cycle_daily_accrual(session, cycle_id, accrual_data_2["accrual_date"], accrual_data_2["accrued_interest_cents"])
+    crud.create_cycle_daily_accrual(
+        session,
+        cycle_id,
+        accrual_data_1["accrual_date"],
+        accrual_data_1["accrued_interest_cents"],
+    )
+    crud.create_cycle_daily_accrual(
+        session,
+        cycle_id,
+        accrual_data_2["accrual_date"],
+        accrual_data_2["accrued_interest_cents"],
+    )
 
-    accruals_today = crud.get_cycle_daily_accrual_by_cycle_id_and_date(session, cycle_id, today)
+    accruals_today = crud.get_cycle_daily_accrual_by_cycle_id_and_date(
+        session, cycle_id, today
+    )
     assert accruals_today is not None
     assert accruals_today.accrual_date == today
-    assert accruals_today.accrual_amount_cents == accrual_data_2["accrued_interest_cents"]
+    assert (
+        accruals_today.accrual_amount_cents == accrual_data_2["accrued_interest_cents"]
+    )
 
-    accruals_yesterday = crud.get_cycle_daily_accrual_by_cycle_id_and_date(session, cycle_id, yesterday)
+    accruals_yesterday = crud.get_cycle_daily_accrual_by_cycle_id_and_date(
+        session, cycle_id, yesterday
+    )
     assert accruals_yesterday is not None
     assert accruals_yesterday.accrual_date == yesterday
-    assert accruals_yesterday.accrual_amount_cents == accrual_data_1["accrued_interest_cents"]
+    assert (
+        accruals_yesterday.accrual_amount_cents
+        == accrual_data_1["accrued_interest_cents"]
+    )
 
 
 # Exchanges
@@ -1031,7 +1158,9 @@ def test_update_user_immutable_fields(session: Session) -> None:
     update_data = {
         "id": user_id + 1,  # Trying to change the ID
         "username": "newusername",  # Trying to change the username
-        "created_at": datetime(2020, 1, 1, tzinfo=timezone.utc),  # Trying to change created_at
+        "created_at": datetime(
+            2020, 1, 1, tzinfo=timezone.utc
+        ),  # Trying to change created_at
         "password_hash": "validupdate",  # Valid field to update
     }
 
@@ -1065,7 +1194,9 @@ def test_create_login_session_with_invalid_user(session: Session) -> None:
 def test_get_login_session_by_token_and_user_id(session: Session) -> None:
     now = datetime.now(timezone.utc)
     created_session = make_login_session(session, now)
-    fetched_session = crud.get_login_session_by_token_hash_and_user_id(session, created_session.session_token_hash, created_session.user_id)
+    fetched_session = crud.get_login_session_by_token_hash_and_user_id(
+        session, created_session.session_token_hash, created_session.user_id
+    )
     assert fetched_session is not None
     assert fetched_session.id == created_session.id
     assert fetched_session.user_id == created_session.user_id
@@ -1075,7 +1206,9 @@ def test_get_login_session_by_token_and_user_id(session: Session) -> None:
 def test_get_login_session_by_token(session: Session) -> None:
     now = datetime.now(timezone.utc)
     created_session = make_login_session(session, now)
-    fetched_session = crud.get_login_session_by_token_hash(session, created_session.session_token_hash)
+    fetched_session = crud.get_login_session_by_token_hash(
+        session, created_session.session_token_hash
+    )
     assert fetched_session is not None
     assert fetched_session.id == created_session.id
     assert fetched_session.user_id == created_session.user_id
@@ -1090,9 +1223,13 @@ def test_update_login_session(session: Session) -> None:
         "last_seen_at": now + timedelta(hours=1),
         "last_used_ip": "192.168.1.1",
     }
-    updated_session = crud.update_login_session(session, created_session.session_token_hash, update_data)
+    updated_session = crud.update_login_session(
+        session, created_session.session_token_hash, update_data
+    )
     assert updated_session is not None
-    assert _ensure_utc_aware(updated_session.last_seen_at) == update_data["last_seen_at"]
+    assert (
+        _ensure_utc_aware(updated_session.last_seen_at) == update_data["last_seen_at"]
+    )
     assert updated_session.last_used_ip == update_data["last_used_ip"]
 
 
@@ -1101,5 +1238,7 @@ def test_delete_login_session(session: Session) -> None:
     created_session = make_login_session(session, now)
 
     crud.delete_login_session(session, created_session.session_token_hash)
-    deleted_session = crud.get_login_session_by_token_hash_and_user_id(session, created_session.session_token_hash, created_session.user_id)
+    deleted_session = crud.get_login_session_by_token_hash_and_user_id(
+        session, created_session.session_token_hash, created_session.user_id
+    )
     assert deleted_session is None

backend/tests/test_service.py

@@ -25,9 +25,15 @@ class FakeDBFactory:
         yield fake_session
 
 
-def verify_json_response(response: Response, expected_status: int, expected_detail: str) -> None:
+def verify_json_response(
+    response: Response, expected_status: int, expected_detail: str
+) -> None:
     assert response.status_code == expected_status
-    body_bytes = response.body.tobytes() if isinstance(response.body, memoryview) else response.body
+    body_bytes = (
+        response.body.tobytes()
+        if isinstance(response.body, memoryview)
+        else response.body
+    )
     body_text = body_bytes.decode("utf-8")
     body_json = json.loads(body_text)
     assert body_json.get("detail") == expected_detail
@@ -93,7 +99,9 @@ def test_auth_middleware_no_db() -> None:
         pytest.fail("call_next should not be called for invalid token")
 
     response = asyncio.run(middleware.dispatch(request, call_next))
-    verify_json_response(response, status.HTTP_500_INTERNAL_SERVER_ERROR, "db factory not configured")
+    verify_json_response(
+        response, status.HTTP_500_INTERNAL_SERVER_ERROR, "db factory not configured"
+    )
 
 
 def test_auth_middleware_rejects_invalid_token() -> None:
@@ -114,7 +122,9 @@ def test_auth_middleware_rejects_invalid_token() -> None:
     async def call_next(req: Request) -> Response:  # noqa: ARG001
         pytest.fail("call_next should not be called for invalid token")
 
-    with patch("trading_journal.crud.get_login_session_by_token_hash", return_value=None):
+    with patch(
+        "trading_journal.crud.get_login_session_by_token_hash", return_value=None
+    ):
         response = asyncio.run(middleware.dispatch(request, call_next))
     verify_json_response(response, status.HTTP_401_UNAUTHORIZED, "Unauthorized")
 
@@ -147,8 +157,14 @@ def test_auth_middleware_rejects_expired_token() -> None:
     )
 
     with (
-        patch("trading_journal.security.hash_session_token_sha256", return_value=expired_session.session_token_hash) as mock_hash,
-        patch("trading_journal.crud.get_login_session_by_token_hash", return_value=expired_session),
+        patch(
+            "trading_journal.security.hash_session_token_sha256",
+            return_value=expired_session.session_token_hash,
+        ) as mock_hash,
+        patch(
+            "trading_journal.crud.get_login_session_by_token_hash",
+            return_value=expired_session,
+        ),
         patch("trading_journal.crud.delete_login_session") as mock_delete,
     ):
         response = asyncio.run(middleware.dispatch(request, call_next))
@@ -192,8 +208,14 @@ def test_auth_middleware_reject_inactive_user() -> None:
     )
 
     with (
-        patch("trading_journal.security.hash_session_token_sha256", return_value=valid_session.session_token_hash),
-        patch("trading_journal.crud.get_login_session_by_token_hash", return_value=valid_session),
+        patch(
+            "trading_journal.security.hash_session_token_sha256",
+            return_value=valid_session.session_token_hash,
+        ),
+        patch(
+            "trading_journal.crud.get_login_session_by_token_hash",
+            return_value=valid_session,
+        ),
     ):
         response = asyncio.run(middleware.dispatch(request, call_next))
 
@@ -210,7 +232,10 @@ def test_auth_middleware_allows_valid_token_and_no_update_expires() -> None:
         "type": "http",
         "method": "GET",
         "path": f"/{settings.api_base}/protected",
-        "headers": [(b"cookie", f"session_token={fake_token_orig}".encode()), (b"user-agent", b"test-agent")],
+        "headers": [
+            (b"cookie", f"session_token={fake_token_orig}".encode()),
+            (b"user-agent", b"test-agent"),
+        ],
         "client": ("testclient", 50000),
         "app": app,
     }
@@ -236,8 +261,14 @@ def test_auth_middleware_allows_valid_token_and_no_update_expires() -> None:
     )
 
     with (
-        patch("trading_journal.security.hash_session_token_sha256", return_value=valid_session.session_token_hash),
-        patch("trading_journal.crud.get_login_session_by_token_hash", return_value=valid_session),
+        patch(
+            "trading_journal.security.hash_session_token_sha256",
+            return_value=valid_session.session_token_hash,
+        ),
+        patch(
+            "trading_journal.crud.get_login_session_by_token_hash",
+            return_value=valid_session,
+        ),
         patch("trading_journal.crud.update_login_session") as mock_update,
     ):
         response = asyncio.run(middleware.dispatch(request, call_next))
@@ -259,7 +290,10 @@ def test_auth_middleware_allows_valid_token_and_updates_expires() -> None:
         "type": "http",
         "method": "GET",
         "path": f"/{settings.api_base}/protected",
-        "headers": [(b"cookie", f"session_token={fake_token_orig}".encode()), (b"user-agent", b"test-agent")],
+        "headers": [
+            (b"cookie", f"session_token={fake_token_orig}".encode()),
+            (b"user-agent", b"test-agent"),
+        ],
         "client": ("testclient", 50000),
         "app": app,
     }
@@ -285,8 +319,14 @@ def test_auth_middleware_allows_valid_token_and_updates_expires() -> None:
     )
 
     with (
-        patch("trading_journal.security.hash_session_token_sha256", return_value=valid_session.session_token_hash),
-        patch("trading_journal.crud.get_login_session_by_token_hash", return_value=valid_session),
+        patch(
+            "trading_journal.security.hash_session_token_sha256",
+            return_value=valid_session.session_token_hash,
+        ),
+        patch(
+            "trading_journal.crud.get_login_session_by_token_hash",
+            return_value=valid_session,
+        ),
         patch("trading_journal.crud.update_login_session") as mock_update,
     ):
         response = asyncio.run(middleware.dispatch(request, call_next))
@@ -295,8 +335,12 @@ def test_auth_middleware_allows_valid_token_and_updates_expires() -> None:
     _, kwargs = mock_update.call_args
     update_session = kwargs.get("update_session")
     assert update_session is not None
-    assert (update_session.expires_at - datetime.now(timezone.utc)).total_seconds() > settings.session_expiry_seconds - 1
-    assert (update_session.last_seen_at - datetime.now(timezone.utc)).total_seconds() < 1
+    assert (
+        update_session.expires_at - datetime.now(timezone.utc)
+    ).total_seconds() > settings.session_expiry_seconds - 1
+    assert (
+        update_session.last_seen_at - datetime.now(timezone.utc)
+    ).total_seconds() < 1
     assert update_session.last_used_ip == "testclient"
     assert update_session.user_agent == "test-agent"
 
@@ -310,12 +354,19 @@ def test_register_user_success() -> None:
     }
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_user_by_username", return_value=None) as mock_get,
+        patch(
+            "trading_journal.crud.get_user_by_username", return_value=None
+        ) as mock_get,
         patch(
             "trading_journal.crud.create_user",
-            return_value=SimpleNamespace(id=1, username=user_in.username, is_active=True),
+            return_value=SimpleNamespace(
+                id=1, username=user_in.username, is_active=True
+            ),
         ) as mock_create,
-        patch("trading_journal.security.hash_password", return_value=user_in_with_hashed_password["password_hash"]),
+        patch(
+            "trading_journal.security.hash_password",
+            return_value=user_in_with_hashed_password["password_hash"],
+        ),
     ):
         user_out = service.register_user_service(db, user_in)
         assert user_out.id is not None
@@ -330,7 +381,9 @@ def test_register_user_exists_raises() -> None:
         FakeDBFactory().get_session_ctx_manager() as db,
         patch(
             "trading_journal.crud.get_user_by_username",
-            return_value=SimpleNamespace(id=1, username=user_in.username, is_active=True),
+            return_value=SimpleNamespace(
+                id=1, username=user_in.username, is_active=True
+            ),
         ) as mock_get,
     ):
         with pytest.raises(service.UserAlreadyExistsError) as exc_info:
@@ -341,10 +394,13 @@ def test_register_user_exists_raises() -> None:
 
 def test_authenticate_user_success() -> None:
     user_in = dto.UserLogin(username="validuser", password="validpassword")
-    stored_user = SimpleNamespace(id=1, username=user_in.username, is_active=True, password_hash="hashedpassword")
+    stored_user = SimpleNamespace(
+        id=1, username=user_in.username, is_active=True, password_hash="hashedpassword"
+    )
     expected_login_session = dto.SessionsCreate(
         user_id=stored_user.id,
-        expires_at=datetime.now(timezone.utc) + timedelta(seconds=settings.session_expiry_seconds),
+        expires_at=datetime.now(timezone.utc)
+        + timedelta(seconds=settings.session_expiry_seconds),
     )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
@@ -352,12 +408,22 @@ def test_authenticate_user_success() -> None:
             "trading_journal.crud.get_user_by_username",
             return_value=stored_user,
         ) as mock_get,
-        patch("trading_journal.security.verify_password", return_value=True) as mock_verify,
-        patch("trading_journal.security.generate_session_token", return_value="newsessiontoken") as mock_token,
-        patch("trading_journal.security.hash_session_token_sha256", return_value="newsessiontokenhash") as mock_hash_session_token,
+        patch(
+            "trading_journal.security.verify_password", return_value=True
+        ) as mock_verify,
+        patch(
+            "trading_journal.security.generate_session_token",
+            return_value="newsessiontoken",
+        ) as mock_token,
+        patch(
+            "trading_journal.security.hash_session_token_sha256",
+            return_value="newsessiontokenhash",
+        ) as mock_hash_session_token,
         patch(
             "trading_journal.crud.create_login_session",
-            return_value=SimpleNamespace(user_id=stored_user.id, expires_at=expected_login_session.expires_at),
+            return_value=SimpleNamespace(
+                user_id=stored_user.id, expires_at=expected_login_session.expires_at
+            ),
         ) as mock_create_session,
     ):
         user_out = service.authenticate_user_service(db, user_in)
@@ -366,7 +432,14 @@ def test_authenticate_user_success() -> None:
         # assert fields instead of direct equality to avoid pydantic/model issues
         assert getattr(login_session, "user_id", None) == stored_user.id
         assert isinstance(getattr(login_session, "expires_at", None), datetime)
-        assert abs((login_session.expires_at - expected_login_session.expires_at).total_seconds()) < 2
+        assert (
+            abs(
+                (
+                    login_session.expires_at - expected_login_session.expires_at
+                ).total_seconds()
+            )
+            < 2
+        )
         assert token == "newsessiontoken"
         assert login_session.user_id == stored_user.id
         mock_get.assert_called_once_with(db, user_in.username)
@@ -397,14 +470,18 @@ def test_authenticate_user_not_found_returns_none() -> None:
 
 def test_authenticate_user_invalid_password_returns_none() -> None:
     user_in = dto.UserLogin(username="validuser", password="invalidpassword")
-    stored_user = SimpleNamespace(id=1, username=user_in.username, is_active=True, password_hash="hashedpassword")
+    stored_user = SimpleNamespace(
+        id=1, username=user_in.username, is_active=True, password_hash="hashedpassword"
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
         patch(
             "trading_journal.crud.get_user_by_username",
             return_value=stored_user,
         ) as mock_get,
-        patch("trading_journal.security.verify_password", return_value=False) as mock_verify,
+        patch(
+            "trading_journal.security.verify_password", return_value=False
+        ) as mock_verify,
     ):
         user_out = service.authenticate_user_service(db, user_in)
         assert user_out is None
@@ -419,12 +496,22 @@ def test_create_exchange_duplicate_raises() -> None:
         FakeDBFactory().get_session_ctx_manager() as db,
         patch(
             "trading_journal.crud.get_exchange_by_name_and_user_id",
-            return_value=SimpleNamespace(id=1, user_id=1, name=exchange_in.name, notes="Existing exchange"),
+            return_value=SimpleNamespace(
+                id=1, user_id=1, name=exchange_in.name, notes="Existing exchange"
+            ),
         ) as mock_get,
     ):
         with pytest.raises(service.ExchangeAlreadyExistsError) as exc_info:
-            service.create_exchange_service(db, user_id=exchange_in.user_id, name=exchange_in.name, notes=exchange_in.notes)
-        assert str(exc_info.value) == "Exchange with the same name already exists for this user"
+            service.create_exchange_service(
+                db,
+                user_id=exchange_in.user_id,
+                name=exchange_in.name,
+                notes=exchange_in.notes,
+            )
+        assert (
+            str(exc_info.value)
+            == "Exchange with the same name already exists for this user"
+        )
         mock_get.assert_called_once_with(db, exchange_in.name, exchange_in.user_id)
 
 
@@ -438,10 +525,20 @@ def test_create_exchange_success() -> None:
         ) as mock_get,
         patch(
             "trading_journal.crud.create_exchange",
-            return_value=SimpleNamespace(id=2, user_id=exchange_in.user_id, name=exchange_in.name, notes=exchange_in.notes),
+            return_value=SimpleNamespace(
+                id=2,
+                user_id=exchange_in.user_id,
+                name=exchange_in.name,
+                notes=exchange_in.notes,
+            ),
         ) as mock_create,
     ):
-        exchange_out = service.create_exchange_service(db, user_id=exchange_in.user_id, name=exchange_in.name, notes=exchange_in.notes)
+        exchange_out = service.create_exchange_service(
+            db,
+            user_id=exchange_in.user_id,
+            name=exchange_in.name,
+            notes=exchange_in.notes,
+        )
         assert exchange_out.name == exchange_in.name
         assert exchange_out.notes == exchange_in.notes
         mock_get.assert_called_once_with(db, exchange_in.name, exchange_in.user_id)
@@ -455,7 +552,9 @@ def test_get_exchanges_by_user_id() -> None:
             "trading_journal.crud.get_all_exchanges_by_user_id",
             return_value=[
                 SimpleNamespace(id=1, user_id=1, name="NYSE", notes="First exchange"),
-                SimpleNamespace(id=2, user_id=1, name="NASDAQ", notes="Second exchange"),
+                SimpleNamespace(
+                    id=2, user_id=1, name="NASDAQ", notes="Second exchange"
+                ),
             ],
         ) as mock_get,
     ):
@@ -489,14 +588,22 @@ def test_update_exchange_not_found() -> None:
         ) as mock_get,
     ):
         with pytest.raises(service.ExchangeNotFoundError) as exc_info:
-            service.update_exchanges_service(db, exchange_id=1, user_id=1, name=exchange_update.name, notes=exchange_update.notes)
+            service.update_exchanges_service(
+                db,
+                exchange_id=1,
+                user_id=1,
+                name=exchange_update.name,
+                notes=exchange_update.notes,
+            )
         assert str(exc_info.value) == "Exchange not found"
         mock_get.assert_called_once_with(db, 1)
 
 
 def test_update_exchange_owner_mismatch_raises() -> None:
     exchange_update = dto.ExchangesBase(name="UpdatedName", notes="Updated notes")
-    existing_exchange = SimpleNamespace(id=1, user_id=2, name="OldName", notes="Old notes")
+    existing_exchange = SimpleNamespace(
+        id=1, user_id=2, name="OldName", notes="Old notes"
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
         patch(
@@ -505,14 +612,22 @@ def test_update_exchange_owner_mismatch_raises() -> None:
         ) as mock_get,
     ):
         with pytest.raises(service.ExchangeNotFoundError) as exc_info:
-            service.update_exchanges_service(db, exchange_id=1, user_id=1, name=exchange_update.name, notes=exchange_update.notes)
+            service.update_exchanges_service(
+                db,
+                exchange_id=1,
+                user_id=1,
+                name=exchange_update.name,
+                notes=exchange_update.notes,
+            )
         assert str(exc_info.value) == "Exchange not found"
         mock_get.assert_called_once_with(db, 1)
 
 
 def test_update_exchange_duplication() -> None:
     exchange_update = dto.ExchangesBase(name="DuplicateName", notes="Updated notes")
-    existing_exchange = SimpleNamespace(id=1, user_id=1, name="OldName", notes="Old notes")
+    existing_exchange = SimpleNamespace(
+        id=1, user_id=1, name="OldName", notes="Old notes"
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
         patch(
@@ -521,19 +636,32 @@ def test_update_exchange_duplication() -> None:
         ) as mock_get,
         patch(
             "trading_journal.crud.get_exchange_by_name_and_user_id",
-            return_value=SimpleNamespace(id=2, user_id=1, name="DuplicateName", notes="Another exchange"),
+            return_value=SimpleNamespace(
+                id=2, user_id=1, name="DuplicateName", notes="Another exchange"
+            ),
         ) as mock_get_by_name,
     ):
         with pytest.raises(service.ExchangeAlreadyExistsError) as exc_info:
-            service.update_exchanges_service(db, exchange_id=1, user_id=1, name=exchange_update.name, notes=exchange_update.notes)
-        assert str(exc_info.value) == "Another exchange with the same name already exists for this user"
+            service.update_exchanges_service(
+                db,
+                exchange_id=1,
+                user_id=1,
+                name=exchange_update.name,
+                notes=exchange_update.notes,
+            )
+        assert (
+            str(exc_info.value)
+            == "Another exchange with the same name already exists for this user"
+        )
         mock_get.assert_called_once_with(db, 1)
         mock_get_by_name.assert_called_once_with(db, "DuplicateName", 1)
 
 
 def test_update_exchange_success() -> None:
     exchange_update = dto.ExchangesBase(name="UpdatedName", notes="Updated notes")
-    existing_exchange = SimpleNamespace(id=1, user_id=1, name="OldName", notes="Old notes")
+    existing_exchange = SimpleNamespace(
+        id=1, user_id=1, name="OldName", notes="Old notes"
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
         patch(
@@ -546,10 +674,18 @@ def test_update_exchange_success() -> None:
         ) as mock_get_by_name,
         patch(
             "trading_journal.crud.update_exchange",
-            return_value=SimpleNamespace(id=1, user_id=1, name=exchange_update.name, notes=exchange_update.notes),
+            return_value=SimpleNamespace(
+                id=1, user_id=1, name=exchange_update.name, notes=exchange_update.notes
+            ),
         ) as mock_update,
     ):
-        exchange_out = service.update_exchanges_service(db, exchange_id=1, user_id=1, name=exchange_update.name, notes=exchange_update.notes)
+        exchange_out = service.update_exchanges_service(
+            db,
+            exchange_id=1,
+            user_id=1,
+            name=exchange_update.name,
+            notes=exchange_update.notes,
+        )
         assert exchange_out.name == exchange_update.name
         assert exchange_out.notes == exchange_update.notes
         mock_get.assert_called_once_with(db, 1)
@@ -605,7 +741,9 @@ def test_get_cycle_by_id_success() -> None:
         FakeDBFactory().get_session_ctx_manager() as db,
         patch("trading_journal.crud.get_cycle_by_id", return_value=cycle) as mock_get,
     ):
-        cycle_out = service.get_cycle_by_id_service(db, user_id=user_id, cycle_id=cycle_id)
+        cycle_out = service.get_cycle_by_id_service(
+            db, user_id=user_id, cycle_id=cycle_id
+        )
         assert cycle_out.id == cycle_id
         assert cycle_out.user_id == user_id
         assert cycle_out.friendly_name == "Test Cycle"
@@ -622,7 +760,9 @@ def test_get_cycles_by_user_no_cycles() -> None:
     user_id = 1
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_cycles_by_user_id", return_value=[]) as mock_get,
+        patch(
+            "trading_journal.crud.get_cycles_by_user_id", return_value=[]
+        ) as mock_get,
     ):
         cycles = service.get_cycles_by_user_service(db, user_id=user_id)
         assert isinstance(cycles, list)
@@ -660,7 +800,9 @@ def test_get_cycles_by_user_with_cycles() -> None:
     )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_cycles_by_user_id", return_value=[cycle1, cycle2]) as mock_get,
+        patch(
+            "trading_journal.crud.get_cycles_by_user_id", return_value=[cycle1, cycle2]
+        ) as mock_get,
     ):
         cycles = service.get_cycles_by_user_service(db, user_id=user_id)
         assert isinstance(cycles, list)
@@ -683,7 +825,12 @@ def test_update_cycle_closed_status_mismatch_raises() -> None:
 
 
 def test_update_cycle_open_status_mismatch_raises() -> None:
-    cycle_data = dto.CycleUpdate(id=1, friendly_name="Updated Cycle", status="OPEN", end_date=datetime.now(timezone.utc).date())
+    cycle_data = dto.CycleUpdate(
+        id=1,
+        friendly_name="Updated Cycle",
+        status="OPEN",
+        end_date=datetime.now(timezone.utc).date(),
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
     ):
@@ -693,7 +840,9 @@ def test_update_cycle_open_status_mismatch_raises() -> None:
 
 
 def test_update_cycle_invalid_capital_exposure_raises() -> None:
-    cycle_data = dto.CycleUpdate(id=1, friendly_name="Updated Cycle", status="OPEN", capital_exposure_cents=-100)
+    cycle_data = dto.CycleUpdate(
+        id=1, friendly_name="Updated Cycle", status="OPEN", capital_exposure_cents=-100
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
     ):
@@ -703,13 +852,22 @@ def test_update_cycle_invalid_capital_exposure_raises() -> None:
 
 
 def test_update_cycle_no_cash_no_loan_raises() -> None:
-    cycle_data = dto.CycleUpdate(id=1, friendly_name="Updated Cycle", status="OPEN", funding_source="LOAN", loan_amount_cents=None)
+    cycle_data = dto.CycleUpdate(
+        id=1,
+        friendly_name="Updated Cycle",
+        status="OPEN",
+        funding_source="LOAN",
+        loan_amount_cents=None,
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
     ):
         with pytest.raises(service.InvalidCycleDataError) as exc_info:
             service.update_cycle_service(db, user_id=1, cycle_data=cycle_data)
-        assert str(exc_info.value) == "loan_amount_cents and loan_interest_rate_tenth_bps are required when funding_source is not CASH"
+        assert (
+            str(exc_info.value)
+            == "loan_amount_cents and loan_interest_rate_tenth_bps are required when funding_source is not CASH"
+        )
 
 
 def test_update_cycle_loan_missing_interest_raises() -> None:
@@ -725,7 +883,10 @@ def test_update_cycle_loan_missing_interest_raises() -> None:
     ):
         with pytest.raises(service.InvalidCycleDataError) as exc_info:
             service.update_cycle_service(db, user_id=1, cycle_data=cycle_data)
-        assert str(exc_info.value) == "loan_amount_cents and loan_interest_rate_tenth_bps are required when funding_source is not CASH"
+        assert (
+            str(exc_info.value)
+            == "loan_amount_cents and loan_interest_rate_tenth_bps are required when funding_source is not CASH"
+        )
 
 
 def test_update_cycle_loan_negative_loan_raises() -> None:
@@ -759,7 +920,9 @@ def test_update_cycle_loan_negative_interest_raises() -> None:
     ):
         with pytest.raises(service.InvalidCycleDataError) as exc_info:
             service.update_cycle_service(db, user_id=1, cycle_data=cycle_data)
-        assert str(exc_info.value) == "loan_interest_rate_tenth_bps must be non-negative"
+        assert (
+            str(exc_info.value) == "loan_interest_rate_tenth_bps must be non-negative"
+        )
 
 
 def test_update_cycle_not_found_raises() -> None:
@@ -779,7 +942,9 @@ def test_update_cycle_owner_mismatch_raises() -> None:
     existing_cycle = SimpleNamespace(id=1, user_id=2)  # Owned by different user
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_cycle_by_id", return_value=existing_cycle) as mock_get,
+        patch(
+            "trading_journal.crud.get_cycle_by_id", return_value=existing_cycle
+        ) as mock_get,
     ):
         with pytest.raises(service.CycleNotFoundError) as exc_info:
             service.update_cycle_service(db, user_id=1, cycle_data=cycle_data)
@@ -788,7 +953,16 @@ def test_update_cycle_owner_mismatch_raises() -> None:
 
 
 def test_update_cycle_success() -> None:
-    cycle_data = dto.CycleUpdate(id=1, friendly_name="Updated Cycle", status="OPEN", funding_source="CASH", capital_exposure_cents=5000)
+    today = datetime.now(timezone.utc).date()
+    cycle_data = dto.CycleUpdate(
+        id=1,
+        friendly_name="Updated Cycle",
+        status="OPEN",
+        funding_source="MIXED",
+        capital_exposure_cents=5000,
+        loan_amount_cents=2000,
+        loan_interest_rate_tenth_bps=50,
+    )
     existing_cycle = SimpleNamespace(
         id=1,
         user_id=1,
@@ -796,7 +970,7 @@ def test_update_cycle_success() -> None:
         symbol="AAPL",
         exchange_id=1,
         underlying_currency="USD",
-        start_date=datetime.now(timezone.utc).date(),
+        start_date=today,
         status="OPEN",
         funding_source="MIXED",
         capital_exposure_cents=10000,
@@ -814,13 +988,21 @@ def test_update_cycle_success() -> None:
         status=cycle_data.status,
         funding_source=cycle_data.funding_source,
         capital_exposure_cents=cycle_data.capital_exposure_cents,
-        loan_amount_cents=None,
-        loan_interest_rate_tenth_bps=None,
+        loan_amount_cents=cycle_data.loan_amount_cents,
+        loan_interest_rate_tenth_bps=cycle_data.loan_interest_rate_tenth_bps,
     )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_cycle_by_id", return_value=existing_cycle) as mock_get,
-        patch("trading_journal.crud.update_cycle", return_value=updated_cycle) as mock_update,
+        patch(
+            "trading_journal.crud.get_cycle_by_id", return_value=existing_cycle
+        ) as mock_get,
+        patch(
+            "trading_journal.crud.update_cycle", return_value=updated_cycle
+        ) as mock_update,
+        patch(
+            "trading_journal.crud.get_loan_event_by_cycle_id_and_effective_date",
+            return_value=None,
+        ) as mock_get_loan_event,
     ):
         cycle_out = service.update_cycle_service(db, user_id=1, cycle_data=cycle_data)
         assert cycle_out.id == updated_cycle.id
@@ -828,8 +1010,11 @@ def test_update_cycle_success() -> None:
         assert cycle_out.status == updated_cycle.status
         assert cycle_out.funding_source == updated_cycle.funding_source
         assert cycle_out.capital_exposure_cents == updated_cycle.capital_exposure_cents
-        assert cycle_out.loan_amount_cents is None
-        assert cycle_out.loan_interest_rate_tenth_bps is None
+        assert cycle_out.loan_amount_cents == updated_cycle.loan_amount_cents
+        assert (
+            cycle_out.loan_interest_rate_tenth_bps
+            == updated_cycle.loan_interest_rate_tenth_bps
+        )
         mock_get.assert_called_once_with(db, cycle_data.id)
         update_cycle_base = dto.CycleBase(
             friendly_name=cycle_data.friendly_name,
@@ -837,10 +1022,15 @@ def test_update_cycle_success() -> None:
             funding_source=cycle_data.funding_source,
             capital_exposure_cents=cycle_data.capital_exposure_cents,
             loan_amount_cents=getattr(cycle_data, "loan_amount_cents", None),
-            loan_interest_rate_tenth_bps=getattr(cycle_data, "loan_interest_rate_tenth_bps", None),
+            loan_interest_rate_tenth_bps=getattr(
+                cycle_data, "loan_interest_rate_tenth_bps", None
+            ),
             end_date=getattr(cycle_data, "end_date", None),
         )
-        mock_update.assert_called_once_with(db, cycle_data.id, update_data=update_cycle_base)
+        mock_update.assert_called_once_with(
+            db, cycle_data.id, update_data=update_cycle_base
+        )
+        mock_get_loan_event.assert_called_once_with(db, cycle_data.id, today)
 
 
 # --- Trade services ----------------------------------------------------------
@@ -868,7 +1058,10 @@ def test_create_trade_short_option_no_strike() -> None:
     ):
         with pytest.raises(service.InvalidTradeDataError) as exc_info:
             service.create_trade_service(db, 1, trade_data)
-        assert str(exc_info.value) == "Invalid trade data: expiry_date and strike_price_cents are required for SELL_PUT and SELL_CALL trades"
+        assert (
+            str(exc_info.value)
+            == "Invalid trade data: expiry_date and strike_price_cents are required for SELL_PUT and SELL_CALL trades"
+        )
 
 
 def test_create_trade_success() -> None:
@@ -911,7 +1104,9 @@ def test_create_trade_success() -> None:
     )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.create_trade", return_value=created_trade) as mock_create_trade,
+        patch(
+            "trading_journal.crud.create_trade", return_value=created_trade
+        ) as mock_create_trade,
     ):
         trade_out = service.create_trade_service(db, user_id=1, trade_data=trade_data)
         assert trade_out.id == created_trade.id
@@ -920,17 +1115,28 @@ def test_create_trade_success() -> None:
         assert trade_out.trade_type == created_trade.trade_type
         mock_create_trade.assert_called_once()
         _, kwargs = mock_create_trade.call_args
-        passed_trade = kwargs.get("trade_data") or (mock_create_trade.call_args[0][1] if len(mock_create_trade.call_args[0]) > 1 else None)
+        passed_trade = kwargs.get("trade_data") or (
+            mock_create_trade.call_args[0][1]
+            if len(mock_create_trade.call_args[0]) > 1
+            else None
+        )
         assert passed_trade is not None
         # expected for SELL_PUT: gross = quantity * price * quantity_multiplier (positive), net = gross - commission
-        expected_gross = trade_data.quantity * trade_data.price_cents * (trade_data.quantity_multiplier or 1)
+        expected_gross = (
+            trade_data.quantity
+            * trade_data.price_cents
+            * (trade_data.quantity_multiplier or 1)
+        )
         expected_net = expected_gross - trade_data.commission_cents
         assert getattr(passed_trade, "gross_cash_flow_cents", None) == expected_gross
         assert getattr(passed_trade, "net_cash_flow_cents", None) == expected_net
 
 
 def test_get_trade_by_id_not_found_when_missing() -> None:
-    with FakeDBFactory().get_session_ctx_manager() as db, patch("trading_journal.crud.get_trade_by_id", return_value=None) as mock_get:
+    with (
+        FakeDBFactory().get_session_ctx_manager() as db,
+        patch("trading_journal.crud.get_trade_by_id", return_value=None) as mock_get,
+    ):
         with pytest.raises(service.TradeNotFoundError) as exc_info:
             service.get_trade_by_id_service(db, user_id=1, trade_id=1)
         assert str(exc_info.value) == "Trade not found"
@@ -941,7 +1147,9 @@ def test_get_trade_by_id_not_found_owner_mismatch() -> None:
     existing_trade = SimpleNamespace(id=2, user_id=2)
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_trade_by_id", return_value=existing_trade) as mock_get,
+        patch(
+            "trading_journal.crud.get_trade_by_id", return_value=existing_trade
+        ) as mock_get,
     ):
         with pytest.raises(service.TradeNotFoundError) as exc_info:
             service.get_trade_by_id_service(db, user_id=1, trade_id=2)
@@ -976,7 +1184,12 @@ def test_get_trade_by_id_success() -> None:
         notes="ok",
         cycle_id=None,
     )
-    with FakeDBFactory().get_session_ctx_manager() as db, patch("trading_journal.crud.get_trade_by_id", return_value=trade_obj) as mock_get:
+    with (
+        FakeDBFactory().get_session_ctx_manager() as db,
+        patch(
+            "trading_journal.crud.get_trade_by_id", return_value=trade_obj
+        ) as mock_get,
+    ):
         res = service.get_trade_by_id_service(db, user_id=1, trade_id=10)
         assert res.id == trade_obj.id
         assert res.user_id == trade_obj.user_id
@@ -986,9 +1199,14 @@ def test_get_trade_by_id_success() -> None:
 
 
 def test_update_trade_friendly_name_not_found() -> None:
-    with FakeDBFactory().get_session_ctx_manager() as db, patch("trading_journal.crud.get_trade_by_id", return_value=None) as mock_get:
+    with (
+        FakeDBFactory().get_session_ctx_manager() as db,
+        patch("trading_journal.crud.get_trade_by_id", return_value=None) as mock_get,
+    ):
         with pytest.raises(service.TradeNotFoundError) as exc_info:
-            service.update_trade_friendly_name_service(db, user_id=1, trade_id=10, friendly_name="New Name")
+            service.update_trade_friendly_name_service(
+                db, user_id=1, trade_id=10, friendly_name="New Name"
+            )
         assert str(exc_info.value) == "Trade not found"
         mock_get.assert_called_once_with(db, 10)
 
@@ -997,10 +1215,14 @@ def test_update_trade_friendly_name_owner_mismatch_raises() -> None:
     existing_trade = SimpleNamespace(id=10, user_id=2)  # owned by another user
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_trade_by_id", return_value=existing_trade) as mock_get,
+        patch(
+            "trading_journal.crud.get_trade_by_id", return_value=existing_trade
+        ) as mock_get,
     ):
         with pytest.raises(service.TradeNotFoundError) as exc_info:
-            service.update_trade_friendly_name_service(db, user_id=1, trade_id=10, friendly_name="New Name")
+            service.update_trade_friendly_name_service(
+                db, user_id=1, trade_id=10, friendly_name="New Name"
+            )
         assert str(exc_info.value) == "Trade not found"
         mock_get.assert_called_once_with(db, 10)
 
@@ -1031,20 +1253,32 @@ def test_update_trade_friendly_name_success() -> None:
         notes="ok",
         cycle_id=None,
     )
-    updated_trade = SimpleNamespace(**{**existing_trade.__dict__, "friendly_name": "New Friendly"})
+    updated_trade = SimpleNamespace(
+        **{**existing_trade.__dict__, "friendly_name": "New Friendly"}
+    )
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_trade_by_id", return_value=existing_trade) as mock_get,
-        patch("trading_journal.crud.update_trade_friendly_name", return_value=updated_trade) as mock_update,
+        patch(
+            "trading_journal.crud.get_trade_by_id", return_value=existing_trade
+        ) as mock_get,
+        patch(
+            "trading_journal.crud.update_trade_friendly_name",
+            return_value=updated_trade,
+        ) as mock_update,
     ):
-        res = service.update_trade_friendly_name_service(db, user_id=1, trade_id=10, friendly_name="New Friendly")
+        res = service.update_trade_friendly_name_service(
+            db, user_id=1, trade_id=10, friendly_name="New Friendly"
+        )
         assert res.friendly_name == "New Friendly"
         mock_get.assert_called_once_with(db, 10)
         mock_update.assert_called_once_with(db, 10, "New Friendly")
 
 
 def test_update_trade_note_not_found() -> None:
-    with FakeDBFactory().get_session_ctx_manager() as db, patch("trading_journal.crud.get_trade_by_id", return_value=None) as mock_get:
+    with (
+        FakeDBFactory().get_session_ctx_manager() as db,
+        patch("trading_journal.crud.get_trade_by_id", return_value=None) as mock_get,
+    ):
         with pytest.raises(service.TradeNotFoundError) as exc_info:
             service.update_trade_note_service(db, user_id=1, trade_id=20, note="x")
         assert str(exc_info.value) == "Trade not found"
@@ -1055,7 +1289,9 @@ def test_update_trade_note_owner_mismatch_raises() -> None:
     existing_trade = SimpleNamespace(id=20, user_id=2)
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_trade_by_id", return_value=existing_trade) as mock_get,
+        patch(
+            "trading_journal.crud.get_trade_by_id", return_value=existing_trade
+        ) as mock_get,
     ):
         with pytest.raises(service.TradeNotFoundError) as exc_info:
             service.update_trade_note_service(db, user_id=1, trade_id=20, note="x")
@@ -1092,8 +1328,12 @@ def test_update_trade_note_success_and_none_becomes_empty() -> None:
     updated_trade = SimpleNamespace(**{**existing_trade.__dict__, "notes": ""})
     with (
         FakeDBFactory().get_session_ctx_manager() as db,
-        patch("trading_journal.crud.get_trade_by_id", return_value=existing_trade) as mock_get,
-        patch("trading_journal.crud.update_trade_note", return_value=updated_trade) as mock_update,
+        patch(
+            "trading_journal.crud.get_trade_by_id", return_value=existing_trade
+        ) as mock_get,
+        patch(
+            "trading_journal.crud.update_trade_note", return_value=updated_trade
+        ) as mock_update,
     ):
         res = service.update_trade_note_service(db, user_id=1, trade_id=20, note=None)
         assert res.notes == ""