feat: доменный нейминг изменен

tests/test_subscriptions.py

@@ -43,7 +43,7 @@ async def test_handle_subscription_success(usecases: usecase.Usecase, mock_datab
     await mock_database.create_creative(creative)
 
     invite_link = 'https://t.me/+unique_link_123'
-    purchase = domain.Purchase(
+    placement = domain.Placement(
         target_channel_id=target_channel.id,
         external_channel_id=external_channel.id,
         creative_id=creative.id,
@@ -51,10 +51,10 @@ async def test_handle_subscription_success(usecases: usecase.Usecase, mock_datab
         placement_date=datetime.datetime.now(datetime.UTC),
         invite_link=invite_link,
         invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
         subscriptions_count=0,
     )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)
 
     # Симулируем подписку пользователя
     subscriber_id = 999888777
@@ -66,16 +66,20 @@ async def test_handle_subscription_success(usecases: usecase.Usecase, mock_datab
     )
 
     # Проверяем, что подписка создана
-    subscription = await mock_database.get_subscription_by_user_and_purchase(subscriber_id, purchase.id)
+    subscriber = await mock_database.get_subscriber(subscriber_id)
+    assert subscriber is not None
+    assert subscriber.telegram_id == subscriber_id
+    assert subscriber.username == subscriber_username
+
+    subscription = await mock_database.get_subscription_by_subscriber_and_placement(subscriber.id, placement.id)
     assert subscription is not None
-    assert subscription.user_telegram_id == subscriber_id
-    assert subscription.username == subscriber_username
+    assert subscription.subscriber_id == subscriber.id
     assert subscription.invite_link == invite_link
 
     # Проверяем, что счётчик подписок у закупа увеличился
-    updated_purchase = await mock_database.get_purchase(user.id, purchase.id)
-    assert updated_purchase is not None
-    assert updated_purchase.subscriptions_count == 1
+    updated_placement = await mock_database.get_placement(user.id, placement.id)
+    assert updated_placement is not None
+    assert updated_placement.subscriptions_count == 1
 
 
 @pytest.mark.asyncio
@@ -113,7 +117,7 @@ async def test_handle_subscription_duplicate_ignored(usecases: usecase.Usecase,
     await mock_database.create_creative(creative)
 
     invite_link = 'https://t.me/+unique_link_456'
-    purchase = domain.Purchase(
+    placement = domain.Placement(
         target_channel_id=target_channel.id,
         external_channel_id=external_channel.id,
         creative_id=creative.id,
@@ -121,10 +125,10 @@ async def test_handle_subscription_duplicate_ignored(usecases: usecase.Usecase,
         placement_date=datetime.datetime.now(datetime.UTC),
         invite_link=invite_link,
         invite_link_type=domain.InviteLinkType.APPROVAL,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
         subscriptions_count=0,
     )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)
 
     subscriber_id = 888777666
     subscriber_username = 'duplicate_user'
@@ -137,9 +141,9 @@ async def test_handle_subscription_duplicate_ignored(usecases: usecase.Usecase,
     )
 
     # Проверяем счётчик
-    updated_purchase = await mock_database.get_purchase(user.id, purchase.id)
-    assert updated_purchase is not None
-    assert updated_purchase.subscriptions_count == 1
+    updated_placement = await mock_database.get_placement(user.id, placement.id)
+    assert updated_placement is not None
+    assert updated_placement.subscriptions_count == 1
 
     # Повторная попытка подписки того же пользователя
     await usecases.handle_subscription(
@@ -149,12 +153,14 @@ async def test_handle_subscription_duplicate_ignored(usecases: usecase.Usecase,
     )
 
     # Проверяем, что счётчик не увеличился
-    updated_purchase_again = await mock_database.get_purchase(user.id, purchase.id)
-    assert updated_purchase_again is not None
-    assert updated_purchase_again.subscriptions_count == 1  # Остался 1, не увеличился
+    updated_placement_again = await mock_database.get_placement(user.id, placement.id)
+    assert updated_placement_again is not None
+    assert updated_placement_again.subscriptions_count == 1  # Остался 1, не увеличился
 
-    # Проверяем, что в БД только одна подписка этого пользователя
-    all_subscriptions = [s for s in mock_database.subscriptions.values() if s.user_telegram_id == subscriber_id]
+    # Проверяем, что в БД только одна подписка этого подписчика
+    subscriber = await mock_database.get_subscriber(subscriber_id)
+    assert subscriber is not None
+    all_subscriptions = [s for s in mock_database.subscriptions.values() if s.subscriber_id == subscriber.id]
     assert len(all_subscriptions) == 1
 
 
@@ -175,7 +181,7 @@ async def test_handle_subscription_invalid_invite_link(usecases: usecase.Usecase
 
 
 @pytest.mark.asyncio
-async def test_multiple_users_subscription_same_purchase(
+async def test_multiple_users_subscription_same_placement(
     usecases: usecase.Usecase, mock_database: MockDatabase
 ) -> None:
     """Несколько пользователей подписываются через один закуп - каждый учитывается."""
@@ -211,7 +217,7 @@ async def test_multiple_users_subscription_same_purchase(
     await mock_database.create_creative(creative)
 
     invite_link = 'https://t.me/+popular_link_789'
-    purchase = domain.Purchase(
+    placement = domain.Placement(
         target_channel_id=target_channel.id,
         external_channel_id=external_channel.id,
         creative_id=creative.id,
@@ -219,10 +225,10 @@ async def test_multiple_users_subscription_same_purchase(
         placement_date=datetime.datetime.now(datetime.UTC),
         invite_link=invite_link,
         invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
         subscriptions_count=0,
     )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)
 
     # Подписываются три разных пользователя
     users_data = [
@@ -239,17 +245,17 @@ async def test_multiple_users_subscription_same_purchase(
         )
 
     # Проверяем, что создано 3 подписки
-    purchase_subscriptions = [s for s in mock_database.subscriptions.values() if s.purchase_id == purchase.id]
-    assert len(purchase_subscriptions) == 3
+    placement_subscriptions = [s for s in mock_database.subscriptions.values() if s.placement_id == placement.id]
+    assert len(placement_subscriptions) == 3
 
     # Проверяем, что счётчик правильный
-    updated_purchase = await mock_database.get_purchase(user.id, purchase.id)
-    assert updated_purchase is not None
-    assert updated_purchase.subscriptions_count == 3
+    updated_placement = await mock_database.get_placement(user.id, placement.id)
+    assert updated_placement is not None
+    assert updated_placement.subscriptions_count == 3
 
 
 @pytest.mark.asyncio
-async def test_subscription_tracking_across_different_purchases(
+async def test_subscription_tracking_across_different_placements(
     usecases: usecase.Usecase, mock_database: MockDatabase
 ) -> None:
     """Один пользователь может подписаться через разные закупы - каждая подписка учитывается отдельно."""
@@ -285,7 +291,7 @@ async def test_subscription_tracking_across_different_purchases(
     await mock_database.create_creative(creative)
 
     # Создаём два разных закупа с разными invite_link
-    purchase1 = domain.Purchase(
+    placement1 = domain.Placement(
         target_channel_id=target_channel.id,
         external_channel_id=external_channel.id,
         creative_id=creative.id,
@@ -293,10 +299,10 @@ async def test_subscription_tracking_across_different_purchases(
         placement_date=datetime.datetime.now(datetime.UTC),
         invite_link='https://t.me/+link_a',
         invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
         subscriptions_count=0,
     )
-    purchase2 = domain.Purchase(
+    placement2 = domain.Placement(
         target_channel_id=target_channel.id,
         external_channel_id=external_channel.id,
         creative_id=creative.id,
@@ -304,11 +310,11 @@ async def test_subscription_tracking_across_different_purchases(
         placement_date=datetime.datetime.now(datetime.UTC),
         invite_link='https://t.me/+link_b',
         invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
         subscriptions_count=0,
     )
-    await mock_database.create_purchase(purchase1)
-    await mock_database.create_purchase(purchase2)
+    await mock_database.create_placement(placement1)
+    await mock_database.create_placement(placement2)
 
     subscriber_id = 555444333
 
@@ -316,7 +322,7 @@ async def test_subscription_tracking_across_different_purchases(
     await usecases.handle_subscription(
         user_telegram_id=subscriber_id,
         username='multi_subscriber',
-        invite_link=purchase1.invite_link,
+        invite_link=placement1.invite_link,
     )
 
     # Тот же пользователь "подписывается" через второй закуп
@@ -324,19 +330,21 @@ async def test_subscription_tracking_across_different_purchases(
     await usecases.handle_subscription(
         user_telegram_id=subscriber_id,
         username='multi_subscriber',
-        invite_link=purchase2.invite_link,
+        invite_link=placement2.invite_link,
     )
 
     # Проверяем, что у каждого закупа свой счётчик
-    updated_purchase1 = await mock_database.get_purchase(user.id, purchase1.id)
-    updated_purchase2 = await mock_database.get_purchase(user.id, purchase2.id)
+    updated_placement1 = await mock_database.get_placement(user.id, placement1.id)
+    updated_placement2 = await mock_database.get_placement(user.id, placement2.id)
 
-    assert updated_purchase1 is not None
-    assert updated_purchase1.subscriptions_count == 1
+    assert updated_placement1 is not None
+    assert updated_placement1.subscriptions_count == 1
 
-    assert updated_purchase2 is not None
-    assert updated_purchase2.subscriptions_count == 1
+    assert updated_placement2 is not None
+    assert updated_placement2.subscriptions_count == 1
 
     # Проверяем, что создано 2 подписки
-    user_subscriptions = [s for s in mock_database.subscriptions.values() if s.user_telegram_id == subscriber_id]
+    subscriber = await mock_database.get_subscriber(subscriber_id)
+    assert subscriber is not None
+    user_subscriptions = [s for s in mock_database.subscriptions.values() if s.subscriber_id == subscriber.id]
     assert len(user_subscriptions) == 2