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

2025-11-13 01:18:04 +03:00
parent a48d5e67cb
commit bba37fbb21
51 changed files with 1144 additions and 1154 deletions
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -18,9 +18,11 @@ class MockDatabase:
        self.target_channels_by_telegram_id: dict[int, domain.TargetChannel] = {}
        self.external_channels: dict[uuid.UUID, domain.ExternalChannel] = {}
        self.creatives: dict[uuid.UUID, domain.Creative] = {}
-        self.purchases: dict[uuid.UUID, domain.Purchase] = {}
+        self.placements: dict[uuid.UUID, domain.Placement] = {}
+        self.subscribers: dict[uuid.UUID, domain.Subscriber] = {}
+        self.subscribers_by_telegram_id: dict[int, domain.Subscriber] = {}
        self.subscriptions: dict[uuid.UUID, domain.Subscription] = {}
-        self.views_snapshots: dict[uuid.UUID, domain.ViewsSnapshot] = {}
+        self.placement_views_histories: dict[uuid.UUID, domain.PlacementViewsHistory] = {}
        self.m2m_target_external: dict[uuid.UUID, list[uuid.UUID]] = {}

    def transaction(self) -> AbstractAsyncContextManager[None]:
@@ -159,8 +161,8 @@ class MockDatabase:
            creative.created_at = datetime.datetime.now(datetime.UTC)
        if not hasattr(creative, 'updated_at') or creative.updated_at is None:
            creative.updated_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(creative, 'purchases_count') or creative.purchases_count is None:
-            creative.purchases_count = 0
+        if not hasattr(creative, 'placements_count') or creative.placements_count is None:
+            creative.placements_count = 0
        target_ch = self.target_channels.get(creative.target_channel_id)
        if target_ch:
            creative.target_channel = target_ch
@@ -196,43 +198,43 @@ class MockDatabase:
    async def delete_creative(self, creative_id: uuid.UUID) -> None:
        self.creatives.pop(creative_id, None)

-    async def create_purchase(self, purchase: domain.Purchase) -> domain.Purchase:
-        if not purchase.id:
-            purchase.id = uuid.uuid4()
-        if not hasattr(purchase, 'created_at') or purchase.created_at is None:
-            purchase.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(purchase, 'updated_at') or purchase.updated_at is None:
-            purchase.updated_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(purchase, 'subscriptions_count') or purchase.subscriptions_count is None:
-            purchase.subscriptions_count = 0
-        if not hasattr(purchase, 'status') or purchase.status is None:
-            purchase.status = domain.PurchaseStatus.ACTIVE
-        if not hasattr(purchase, 'views_availability') or purchase.views_availability is None:
-            purchase.views_availability = domain.PostViewsAvailability.UNKNOWN
+    async def create_placement(self, placement: domain.Placement) -> domain.Placement:
+        if not placement.id:
+            placement.id = uuid.uuid4()
+        if not hasattr(placement, 'created_at') or placement.created_at is None:
+            placement.created_at = datetime.datetime.now(datetime.UTC)
+        if not hasattr(placement, 'updated_at') or placement.updated_at is None:
+            placement.updated_at = datetime.datetime.now(datetime.UTC)
+        if not hasattr(placement, 'subscriptions_count') or placement.subscriptions_count is None:
+            placement.subscriptions_count = 0
+        if not hasattr(placement, 'status') or placement.status is None:
+            placement.status = domain.PlacementStatus.ACTIVE
+        if not hasattr(placement, 'views_availability') or placement.views_availability is None:
+            placement.views_availability = domain.PostViewsAvailability.UNKNOWN
        # Загружаем связанные объекты
-        target_ch = self.target_channels.get(purchase.target_channel_id)
+        target_ch = self.target_channels.get(placement.target_channel_id)
        if target_ch:
-            purchase.target_channel = target_ch
-        ext_ch = self.external_channels.get(purchase.external_channel_id)
+            placement.target_channel = target_ch
+        ext_ch = self.external_channels.get(placement.external_channel_id)
        if ext_ch:
-            purchase.external_channel = ext_ch
-        creative = self.creatives.get(purchase.creative_id)
+            placement.external_channel = ext_ch
+        creative = self.creatives.get(placement.creative_id)
        if creative:
-            purchase.creative = creative
-        self.purchases[purchase.id] = purchase
-        return purchase
+            placement.creative = creative
+        self.placements[placement.id] = placement
+        return placement

-    async def get_purchase(self, user_id: uuid.UUID, purchase_id: uuid.UUID) -> domain.Purchase | None:
-        purchase = self.purchases.get(purchase_id)
-        if purchase and purchase.user_id == user_id:
-            return purchase
+    async def get_placement(self, user_id: uuid.UUID, placement_id: uuid.UUID) -> domain.Placement | None:
+        placement = self.placements.get(placement_id)
+        if placement and placement.user_id == user_id:
+            return placement
        return None

-    async def update_purchase(self, purchase: domain.Purchase) -> domain.Purchase:
-        self.purchases[purchase.id] = purchase
-        return purchase
+    async def update_placement(self, placement: domain.Placement) -> domain.Placement:
+        self.placements[placement.id] = placement
+        return placement

-    async def get_user_purchases(
+    async def get_user_placements(
        self,
        user_id: uuid.UUID,
        *,
@@ -240,8 +242,8 @@ class MockDatabase:
        external_channel_id: uuid.UUID | None = None,
        creative_id: uuid.UUID | None = None,
        include_archived: bool = False,
-    ) -> list[domain.Purchase]:
-        result = [p for p in self.purchases.values() if p.user_id == user_id]
+    ) -> list[domain.Placement]:
+        result = [p for p in self.placements.values() if p.user_id == user_id]
        if target_channel_id:
            result = [p for p in result if p.target_channel_id == target_channel_id]
        if external_channel_id:
@@ -249,24 +251,47 @@ class MockDatabase:
        if creative_id:
            result = [p for p in result if p.creative_id == creative_id]
        if not include_archived:
-            result = [p for p in result if p.status == domain.PurchaseStatus.ACTIVE]
+            result = [p for p in result if p.status == domain.PlacementStatus.ACTIVE]
        return sorted(result, key=lambda p: p.placement_date, reverse=True)

-    async def delete_purchase(self, purchase_id: uuid.UUID) -> None:
-        self.purchases.pop(purchase_id, None)
+    async def delete_placement(self, placement_id: uuid.UUID) -> None:
+        self.placements.pop(placement_id, None)

    async def check_creative_in_use(self, creative_id: uuid.UUID) -> bool:
-        for purchase in self.purchases.values():
-            if purchase.creative_id == creative_id and purchase.status == domain.PurchaseStatus.ACTIVE:
+        for placement in self.placements.values():
+            if placement.creative_id == creative_id and placement.status == domain.PlacementStatus.ACTIVE:
                return True
        return False

-    async def get_purchase_by_invite_link(self, invite_link: str) -> domain.Purchase | None:
-        for purchase in self.purchases.values():
-            if purchase.invite_link == invite_link:
-                return purchase
+    async def get_placement_by_invite_link(self, invite_link: str) -> domain.Placement | None:
+        for placement in self.placements.values():
+            if placement.invite_link == invite_link:
+                return placement
        return None

+    async def get_subscriber(self, telegram_id: int) -> domain.Subscriber | None:
+        return self.subscribers_by_telegram_id.get(telegram_id)
+
+    async def create_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
+        if not subscriber.id:
+            subscriber.id = uuid.uuid4()
+        if not hasattr(subscriber, 'created_at') or subscriber.created_at is None:
+            subscriber.created_at = datetime.datetime.now(datetime.UTC)
+        if not hasattr(subscriber, 'updated_at') or subscriber.updated_at is None:
+            subscriber.updated_at = datetime.datetime.now(datetime.UTC)
+        self.subscribers[subscriber.id] = subscriber
+        self.subscribers_by_telegram_id[subscriber.telegram_id] = subscriber
+        return subscriber
+
+    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
+        existing = await self.get_subscriber(subscriber.telegram_id)
+        if existing:
+            existing.username = subscriber.username
+            existing.first_name = subscriber.first_name
+            existing.last_name = subscriber.last_name
+            return existing
+        return await self.create_subscriber(subscriber)
+
    async def create_subscription(self, subscription: domain.Subscription) -> domain.Subscription:
        if not subscription.id:
            subscription.id = uuid.uuid4()
@@ -274,47 +299,52 @@ class MockDatabase:
            subscription.created_at = datetime.datetime.now(datetime.UTC)
        if not hasattr(subscription, 'updated_at') or subscription.updated_at is None:
            subscription.updated_at = datetime.datetime.now(datetime.UTC)
-        # Загружаем связанный объект
-        purchase = self.purchases.get(subscription.purchase_id)
-        if purchase:
-            subscription.purchase = purchase
+        # Загружаем связанные объекты
+        placement = self.placements.get(subscription.placement_id)
+        if placement:
+            subscription.placement = placement
+        subscriber = self.subscribers.get(subscription.subscriber_id)
+        if subscriber:
+            subscription.subscriber = subscriber
        self.subscriptions[subscription.id] = subscription
        return subscription

-    async def get_subscription_by_user_and_purchase(
-        self, user_telegram_id: int, purchase_id: uuid.UUID
+    async def get_subscription_by_subscriber_and_placement(
+        self, subscriber_id: uuid.UUID, placement_id: uuid.UUID
    ) -> domain.Subscription | None:
        for subscription in self.subscriptions.values():
-            if subscription.user_telegram_id == user_telegram_id and subscription.purchase_id == purchase_id:
+            if subscription.subscriber_id == subscriber_id and subscription.placement_id == placement_id:
                return subscription
        return None

-    async def create_views_snapshot(self, snapshot: domain.ViewsSnapshot) -> domain.ViewsSnapshot:
-        if not snapshot.id:
-            snapshot.id = uuid.uuid4()
-        if not hasattr(snapshot, 'created_at') or snapshot.created_at is None:
-            snapshot.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(snapshot, 'updated_at') or snapshot.updated_at is None:
-            snapshot.updated_at = datetime.datetime.now(datetime.UTC)
-        purchase = self.purchases.get(snapshot.purchase_id)
-        if purchase:
-            snapshot.purchase = purchase
-        self.views_snapshots[snapshot.id] = snapshot
-        return snapshot
+    async def create_placement_views_history(
+        self, history: domain.PlacementViewsHistory
+    ) -> domain.PlacementViewsHistory:
+        if not history.id:
+            history.id = uuid.uuid4()
+        if not hasattr(history, 'created_at') or history.created_at is None:
+            history.created_at = datetime.datetime.now(datetime.UTC)
+        if not hasattr(history, 'updated_at') or history.updated_at is None:
+            history.updated_at = datetime.datetime.now(datetime.UTC)
+        placement = self.placements.get(history.placement_id)
+        if placement:
+            history.placement = placement
+        self.placement_views_histories[history.id] = history
+        return history

    async def get_views_history(
        self,
-        purchase_id: uuid.UUID,
+        placement_id: uuid.UUID,
        *,
        from_date: datetime.datetime | None = None,
        to_date: datetime.datetime | None = None,
-    ) -> list[domain.ViewsSnapshot]:
-        result = [s for s in self.views_snapshots.values() if s.purchase_id == purchase_id]
+    ) -> list[domain.PlacementViewsHistory]:
+        result = [h for h in self.placement_views_histories.values() if h.placement_id == placement_id]
        if from_date:
-            result = [s for s in result if s.fetched_at >= from_date]
+            result = [h for h in result if h.fetched_at >= from_date]
        if to_date:
-            result = [s for s in result if s.fetched_at <= to_date]
-        return sorted(result, key=lambda s: s.fetched_at)
+            result = [h for h in result if h.fetched_at <= to_date]
+        return sorted(result, key=lambda h: h.fetched_at)


 class MockTelegramWriter:
--- a/tests/test_creatives.py
+++ b/tests/test_creatives.py
@@ -34,7 +34,7 @@ async def test_create_creative_success(usecases: usecase.Usecase, mock_database:
    assert result.text == 'Приглашаю подписаться на канал: {link}'
    assert result.target_channel_id == target_channel.id
    assert result.status == domain.CreativeStatus.ACTIVE
-    assert result.purchases_count == 0
+    assert result.placements_count == 0


@pytest.mark.asyncio
--- a/tests/test_placements.py
+++ b/tests/test_placements.py
@@ -10,7 +10,7 @@ from tests.conftest import MockDatabase


@pytest.mark.asyncio
-async def test_create_purchase_with_public_invite_link(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_create_placement_with_public_invite_link(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Создание закупа с публичной пригласительной ссылкой."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -44,7 +44,7 @@ async def test_create_purchase_with_public_invite_link(usecases: usecase.Usecase
    await mock_database.create_creative(creative)

    placement_date = datetime.datetime.now(datetime.UTC)
-    input_data = dto.CreatePurchaseInput(
+    input_data = dto.CreatePlacementInput(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -55,7 +55,7 @@ async def test_create_purchase_with_public_invite_link(usecases: usecase.Usecase
        invite_link_type=domain.InviteLinkType.PUBLIC,
    )

-    result = await usecases.create_purchase(input_data, user.id)
+    result = await usecases.create_placement(input_data, user.id)

    assert result.target_channel_id == target_channel.id
    assert result.external_channel_id == external_channel.id
@@ -64,17 +64,17 @@ async def test_create_purchase_with_public_invite_link(usecases: usecase.Usecase
    assert result.comment == 'Утреннее размещение'
    assert result.invite_link_type == domain.InviteLinkType.PUBLIC
    assert result.invite_link.startswith('https://t.me/+public_link_')
-    assert result.status == domain.PurchaseStatus.ACTIVE
+    assert result.status == domain.PlacementStatus.ACTIVE
    assert result.subscriptions_count == 0

    # Проверяем, что счётчик закупов у креатива увеличился
    updated_creative = await mock_database.get_creative(user.id, creative.id)
    assert updated_creative is not None
-    assert updated_creative.purchases_count == 1
+    assert updated_creative.placements_count == 1


@pytest.mark.asyncio
-async def test_create_purchase_with_approval_invite_link(
+async def test_create_placement_with_approval_invite_link(
    usecases: usecase.Usecase, mock_database: MockDatabase
 ) -> None:
    """Создание закупа с пригласительной ссылкой, требующей одобрения."""
@@ -110,7 +110,7 @@ async def test_create_purchase_with_approval_invite_link(
    await mock_database.create_creative(creative)

    placement_date = datetime.datetime.now(datetime.UTC)
-    input_data = dto.CreatePurchaseInput(
+    input_data = dto.CreatePlacementInput(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -118,14 +118,14 @@ async def test_create_purchase_with_approval_invite_link(
        invite_link_type=domain.InviteLinkType.APPROVAL,
    )

-    result = await usecases.create_purchase(input_data, user.id)
+    result = await usecases.create_placement(input_data, user.id)

    assert result.invite_link_type == domain.InviteLinkType.APPROVAL
    assert 'approval_link_' in result.invite_link


@pytest.mark.asyncio
-async def test_create_purchase_invalid_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_create_placement_invalid_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Создание закупа для несуществующего целевого канала вызывает ошибку."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -136,7 +136,7 @@ async def test_create_purchase_invalid_target_channel(usecases: usecase.Usecase,
    fake_external_id = uuid.uuid4()
    fake_creative_id = uuid.uuid4()

-    input_data = dto.CreatePurchaseInput(
+    input_data = dto.CreatePlacementInput(
        target_channel_id=fake_target_id,
        external_channel_id=fake_external_id,
        creative_id=fake_creative_id,
@@ -144,13 +144,13 @@ async def test_create_purchase_invalid_target_channel(usecases: usecase.Usecase,
    )

    with pytest.raises(HTTPException) as exc_info:
-        await usecases.create_purchase(input_data, user.id)
+        await usecases.create_placement(input_data, user.id)
    assert exc_info.value.status_code == 404
    assert 'Target channel' in str(exc_info.value.detail)


@pytest.mark.asyncio
-async def test_get_user_purchases(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_get_user_placements(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Получение списка закупов пользователя."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -184,7 +184,7 @@ async def test_get_user_purchases(usecases: usecase.Usecase, mock_database: Mock
    await mock_database.create_creative(creative)

    # Создаём два закупа
-    purchase1 = domain.Purchase(
+    placement1 = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -193,9 +193,9 @@ async def test_get_user_purchases(usecases: usecase.Usecase, mock_database: Mock
        cost=3000.0,
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    purchase2 = domain.Purchase(
+    placement2 = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -204,20 +204,22 @@ async def test_get_user_purchases(usecases: usecase.Usecase, mock_database: Mock
        cost=4000.0,
        invite_link='https://t.me/+link2',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase1)
-    await mock_database.create_purchase(purchase2)
+    await mock_database.create_placement(placement1)
+    await mock_database.create_placement(placement2)

-    result = await usecases.get_purchases(dto.GetPurchasesInput(user_id=user.id))
+    result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id))

-    assert len(result.purchases) == 2
+    assert len(result.placements) == 2
    # Проверяем сортировку по дате размещения (новые первые)
-    assert result.purchases[0].id == purchase1.id
+    assert result.placements[0].id == placement1.id


@pytest.mark.asyncio
-async def test_get_purchases_filtered_by_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_get_placements_filtered_by_target_channel(
+    usecases: usecase.Usecase, mock_database: MockDatabase
+) -> None:
    """Получение закупов, отфильтрованных по целевому каналу."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -266,7 +268,7 @@ async def test_get_purchases_filtered_by_target_channel(usecases: usecase.Usecas
    await mock_database.create_creative(creative1)
    await mock_database.create_creative(creative2)

-    purchase1 = domain.Purchase(
+    placement1 = domain.Placement(
        target_channel_id=target1.id,
        external_channel_id=external_channel.id,
        creative_id=creative1.id,
@@ -274,9 +276,9 @@ async def test_get_purchases_filtered_by_target_channel(usecases: usecase.Usecas
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    purchase2 = domain.Purchase(
+    placement2 = domain.Placement(
        target_channel_id=target2.id,
        external_channel_id=external_channel.id,
        creative_id=creative2.id,
@@ -284,19 +286,19 @@ async def test_get_purchases_filtered_by_target_channel(usecases: usecase.Usecas
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link2',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase1)
-    await mock_database.create_purchase(purchase2)
+    await mock_database.create_placement(placement1)
+    await mock_database.create_placement(placement2)

-    result = await usecases.get_purchases(dto.GetPurchasesInput(user_id=user.id, target_channel_id=target1.id))
+    result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, target_channel_id=target1.id))

-    assert len(result.purchases) == 1
-    assert result.purchases[0].target_channel_id == target1.id
+    assert len(result.placements) == 1
+    assert result.placements[0].target_channel_id == target1.id


@pytest.mark.asyncio
-async def test_get_purchases_filtered_by_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_get_placements_filtered_by_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Получение закупов, отфильтрованных по креативу - для оценки эффективности креатива."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -338,7 +340,7 @@ async def test_get_purchases_filtered_by_creative(usecases: usecase.Usecase, moc
    await mock_database.create_creative(creative2)

    # Создаём закупы с разными креативами
-    purchase1 = domain.Purchase(
+    placement1 = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative1.id,
@@ -346,9 +348,9 @@ async def test_get_purchases_filtered_by_creative(usecases: usecase.Usecase, moc
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    purchase2 = domain.Purchase(
+    placement2 = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative2.id,
@@ -356,19 +358,19 @@ async def test_get_purchases_filtered_by_creative(usecases: usecase.Usecase, moc
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link2',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase1)
-    await mock_database.create_purchase(purchase2)
+    await mock_database.create_placement(placement1)
+    await mock_database.create_placement(placement2)

-    result = await usecases.get_purchases(dto.GetPurchasesInput(user_id=user.id, creative_id=creative1.id))
+    result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, creative_id=creative1.id))

-    assert len(result.purchases) == 1
-    assert result.purchases[0].creative_id == creative1.id
+    assert len(result.placements) == 1
+    assert result.placements[0].creative_id == creative1.id


@pytest.mark.asyncio
-async def test_archive_purchase(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_archive_placement(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Архивирование закупа - убирает его из активной статистики."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -401,7 +403,7 @@ async def test_archive_purchase(usecases: usecase.Usecase, mock_database: MockDa
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -409,27 +411,27 @@ async def test_archive_purchase(usecases: usecase.Usecase, mock_database: MockDa
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

-    result = await usecases.archive_purchase(purchase.id, user.id)
+    result = await usecases.archive_placement(placement.id, user.id)

-    assert result.status == domain.PurchaseStatus.ARCHIVED
+    assert result.status == domain.PlacementStatus.ARCHIVED

    # Проверяем, что архивированный закуп не возвращается по умолчанию
-    purchases_list = await usecases.get_purchases(dto.GetPurchasesInput(user_id=user.id))
-    assert len(purchases_list.purchases) == 0
+    placements_list = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id))
+    assert len(placements_list.placements) == 0

    # Проверяем, что архивированный закуп возвращается с флагом include_archived
-    purchases_with_archived = await usecases.get_purchases(
-        dto.GetPurchasesInput(user_id=user.id, include_archived=True)
+    placements_with_archived = await usecases.get_placements(
+        dto.GetPlacementsInput(user_id=user.id, include_archived=True)
    )
-    assert len(purchases_with_archived.purchases) == 1
+    assert len(placements_with_archived.placements) == 1


@pytest.mark.asyncio
-async def test_update_purchase(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_update_placement(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Редактирование закупа - обновление стоимости, комментария, даты."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -463,7 +465,7 @@ async def test_update_purchase(usecases: usecase.Usecase, mock_database: MockDat
    await mock_database.create_creative(creative)

    old_date = datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=1)
-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -473,18 +475,18 @@ async def test_update_purchase(usecases: usecase.Usecase, mock_database: MockDat
        comment='Старый комментарий',
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

    new_date = datetime.datetime.now(datetime.UTC)
-    update_input = dto.UpdatePurchaseInput(
+    update_input = dto.UpdatePlacementInput(
        placement_date=new_date,
        cost=3500.0,
        comment='Обновлённый комментарий',
        ad_post_url='https://t.me/externalchannel/456',
    )
-    result = await usecases.update_purchase(purchase.id, update_input, user.id)
+    result = await usecases.update_placement(placement.id, update_input, user.id)

    assert result.placement_date == new_date
    assert result.cost == 3500.0
@@ -493,7 +495,7 @@ async def test_update_purchase(usecases: usecase.Usecase, mock_database: MockDat


@pytest.mark.asyncio
-async def test_delete_purchase(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_delete_placement(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Удаление закупа - уменьшает счётчик закупов у креатива."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -523,11 +525,11 @@ async def test_delete_purchase(usecases: usecase.Usecase, mock_database: MockDat
        target_channel_id=target_channel.id,
        user_id=user.id,
        status=domain.CreativeStatus.ACTIVE,
-        purchases_count=1,
+        placements_count=1,
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -535,24 +537,24 @@ async def test_delete_purchase(usecases: usecase.Usecase, mock_database: MockDat
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

-    await usecases.delete_purchase(dto.DeletePurchaseInput(purchase_id=purchase.id, user_id=user.id))
+    await usecases.delete_placement(dto.DeletePlacementInput(placement_id=placement.id, user_id=user.id))

    # Проверяем, что закуп удалён
-    purchases_list = await usecases.get_purchases(dto.GetPurchasesInput(user_id=user.id, include_archived=True))
-    assert len(purchases_list.purchases) == 0
+    placements_list = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, include_archived=True))
+    assert len(placements_list.placements) == 0

    # Проверяем, что счётчик закупов у креатива уменьшился
    updated_creative = await mock_database.get_creative(user.id, creative.id)
    assert updated_creative is not None
-    assert updated_creative.purchases_count == 0
+    assert updated_creative.placements_count == 0


@pytest.mark.asyncio
-async def test_multiple_purchases_same_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
+async def test_multiple_placements_same_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
    """Создание нескольких закупов с одним креативом - для A/B тестирования в разных каналах."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)
@@ -595,14 +597,14 @@ async def test_multiple_purchases_same_creative(usecases: usecase.Usecase, mock_
    await mock_database.create_creative(creative)

    # Создаём два закупа с одним креативом в разных внешних каналах
-    input1 = dto.CreatePurchaseInput(
+    input1 = dto.CreatePlacementInput(
        target_channel_id=target_channel.id,
        external_channel_id=external1.id,
        creative_id=creative.id,
        placement_date=datetime.datetime.now(datetime.UTC),
        cost=2000.0,
    )
-    input2 = dto.CreatePurchaseInput(
+    input2 = dto.CreatePlacementInput(
        target_channel_id=target_channel.id,
        external_channel_id=external2.id,
        creative_id=creative.id,
@@ -610,8 +612,8 @@ async def test_multiple_purchases_same_creative(usecases: usecase.Usecase, mock_
        cost=4000.0,
    )

-    result1 = await usecases.create_purchase(input1, user.id)
-    result2 = await usecases.create_purchase(input2, user.id)
+    result1 = await usecases.create_placement(input1, user.id)
+    result2 = await usecases.create_placement(input2, user.id)

    # Проверяем, что созданы два разных закупа
    assert result1.id != result2.id
@@ -620,10 +622,10 @@ async def test_multiple_purchases_same_creative(usecases: usecase.Usecase, mock_
    # Проверяем, что счётчик креатива увеличился на 2
    updated_creative = await mock_database.get_creative(user.id, creative.id)
    assert updated_creative is not None
-    assert updated_creative.purchases_count == 2
+    assert updated_creative.placements_count == 2

    # Проверяем фильтрацию по креативу
-    purchases_for_creative = await usecases.get_purchases(
-        dto.GetPurchasesInput(user_id=user.id, creative_id=creative.id)
+    placements_for_creative = await usecases.get_placements(
+        dto.GetPlacementsInput(user_id=user.id, creative_id=creative.id)
    )
-    assert len(purchases_for_creative.purchases) == 2
+    assert len(placements_for_creative.placements) == 2
--- a/tests/test_subscriptions.py
+++ b/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
--- a/tests/test_views.py
+++ b/tests/test_views.py
@@ -42,7 +42,7 @@ async def test_fetch_views_no_ad_post_url(usecases: usecase.Usecase, mock_databa
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -50,13 +50,13 @@ async def test_fetch_views_no_ad_post_url(usecases: usecase.Usecase, mock_databa
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link1',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
        ad_post_url=None,  # Нет ссылки на пост
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

    input_data = dto.FetchViewsInputManually(
-        purchase_id=purchase.id,
+        placement_id=placement.id,
        user_id=user.id,
    )

@@ -101,7 +101,7 @@ async def test_fetch_views_api_unavailable(usecases: usecase.Usecase, mock_datab
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -109,13 +109,13 @@ async def test_fetch_views_api_unavailable(usecases: usecase.Usecase, mock_datab
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link2',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
        ad_post_url='https://t.me/externalchannel/123',
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

    input_data = dto.FetchViewsInputManually(
-        purchase_id=purchase.id,
+        placement_id=placement.id,
        user_id=user.id,
    )

@@ -126,11 +126,11 @@ async def test_fetch_views_api_unavailable(usecases: usecase.Usecase, mock_datab
    assert result.views_availability == domain.PostViewsAvailability.UNAVAILABLE
    assert 'Failed to fetch views' in result.error_message

-    # Проверяем, что purchase обновлён
-    updated_purchase = await mock_database.get_purchase(user.id, purchase.id)
-    assert updated_purchase is not None
-    assert updated_purchase.views_availability == domain.PostViewsAvailability.UNAVAILABLE
-    assert updated_purchase.last_views_fetch_at is not None
+    # Проверяем, что placement обновлён
+    updated_placement = await mock_database.get_placement(user.id, placement.id)
+    assert updated_placement is not None
+    assert updated_placement.views_availability == domain.PostViewsAvailability.UNAVAILABLE
+    assert updated_placement.last_views_fetch_at is not None


@pytest.mark.asyncio
@@ -167,7 +167,7 @@ async def test_update_views_manually(usecases: usecase.Usecase, mock_database: M
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -175,13 +175,13 @@ async def test_update_views_manually(usecases: usecase.Usecase, mock_database: M
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link3',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
        ad_post_url='https://t.me/externalchannel/456',
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

    input_data = dto.UpdateViewsManuallyInput(
-        purchase_id=purchase.id,
+        placement_id=placement.id,
        user_id=user.id,
        views_count=15000,
    )
@@ -193,16 +193,16 @@ async def test_update_views_manually(usecases: usecase.Usecase, mock_database: M
    assert result.views_availability == domain.PostViewsAvailability.MANUAL
    assert result.last_views_fetch_at is not None

-    # Проверяем, что создан снимок
-    snapshots = [s for s in mock_database.views_snapshots.values() if s.purchase_id == purchase.id]
-    assert len(snapshots) == 1
-    assert snapshots[0].views_count == 15000
+    # Проверяем, что создана история просмотров
+    histories = [h for h in mock_database.placement_views_histories.values() if h.placement_id == placement.id]
+    assert len(histories) == 1
+    assert histories[0].views_count == 15000

    # Проверяем, что закуп обновлён
-    updated_purchase = await mock_database.get_purchase(user.id, purchase.id)
-    assert updated_purchase is not None
-    assert updated_purchase.views_count == 15000
-    assert updated_purchase.views_availability == domain.PostViewsAvailability.MANUAL
+    updated_placement = await mock_database.get_placement(user.id, placement.id)
+    assert updated_placement is not None
+    assert updated_placement.views_count == 15000
+    assert updated_placement.views_availability == domain.PostViewsAvailability.MANUAL


@pytest.mark.asyncio
@@ -239,7 +239,7 @@ async def test_get_views_history_empty(usecases: usecase.Usecase, mock_database:
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -247,23 +247,23 @@ async def test_get_views_history_empty(usecases: usecase.Usecase, mock_database:
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link4',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

    input_data = dto.GetViewsHistoryInput(
-        purchase_id=purchase.id,
+        placement_id=placement.id,
        user_id=user.id,
    )

    result = await usecases.get_views_history(input=input_data)

-    assert len(result.snapshots) == 0
+    assert len(result.histories) == 0


@pytest.mark.asyncio
 async def test_get_views_history_with_snapshots(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение истории просмотров возвращает снимки в хронологическом порядке."""
+    """Получение истории просмотров возвращает записи в хронологическом порядке."""
    user = domain.User(telegram_id=123456, username='testuser')
    await mock_database.create_user(user)

@@ -295,7 +295,7 @@ async def test_get_views_history_with_snapshots(usecases: usecase.Usecase, mock_
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -303,43 +303,43 @@ async def test_get_views_history_with_snapshots(usecases: usecase.Usecase, mock_
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link5',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

-    # Создаём несколько снимков
+    # Создаём несколько записей истории
    now = datetime.datetime.now(datetime.UTC)
-    snapshot1 = domain.ViewsSnapshot(
-        purchase_id=purchase.id,
+    history1 = domain.PlacementViewsHistory(
+        placement_id=placement.id,
        views_count=1000,
        fetched_at=now - datetime.timedelta(hours=2),
    )
-    snapshot2 = domain.ViewsSnapshot(
-        purchase_id=purchase.id,
+    history2 = domain.PlacementViewsHistory(
+        placement_id=placement.id,
        views_count=1500,
        fetched_at=now - datetime.timedelta(hours=1),
    )
-    snapshot3 = domain.ViewsSnapshot(
-        purchase_id=purchase.id,
+    history3 = domain.PlacementViewsHistory(
+        placement_id=placement.id,
        views_count=2000,
        fetched_at=now,
    )
-    await mock_database.create_views_snapshot(snapshot1)
-    await mock_database.create_views_snapshot(snapshot2)
-    await mock_database.create_views_snapshot(snapshot3)
+    await mock_database.create_placement_views_history(history1)
+    await mock_database.create_placement_views_history(history2)
+    await mock_database.create_placement_views_history(history3)

    input_data = dto.GetViewsHistoryInput(
-        purchase_id=purchase.id,
+        placement_id=placement.id,
        user_id=user.id,
    )

    result = await usecases.get_views_history(input=input_data)

-    assert len(result.snapshots) == 3
+    assert len(result.histories) == 3
    # Проверяем сортировку по времени (старые первые)
-    assert result.snapshots[0].views_count == 1000
-    assert result.snapshots[1].views_count == 1500
-    assert result.snapshots[2].views_count == 2000
+    assert result.histories[0].views_count == 1000
+    assert result.histories[1].views_count == 1500
+    assert result.histories[2].views_count == 2000


@pytest.mark.asyncio
@@ -376,7 +376,7 @@ async def test_get_views_history_with_date_filter(usecases: usecase.Usecase, moc
    )
    await mock_database.create_creative(creative)

-    purchase = domain.Purchase(
+    placement = domain.Placement(
        target_channel_id=target_channel.id,
        external_channel_id=external_channel.id,
        creative_id=creative.id,
@@ -384,41 +384,41 @@ async def test_get_views_history_with_date_filter(usecases: usecase.Usecase, moc
        placement_date=datetime.datetime.now(datetime.UTC),
        invite_link='https://t.me/+link6',
        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PurchaseStatus.ACTIVE,
+        status=domain.PlacementStatus.ACTIVE,
    )
-    await mock_database.create_purchase(purchase)
+    await mock_database.create_placement(placement)

-    # Создаём снимки с разными датами
+    # Создаём записи с разными датами
    now = datetime.datetime.now(datetime.UTC)
-    snapshot1 = domain.ViewsSnapshot(
-        purchase_id=purchase.id,
+    history1 = domain.PlacementViewsHistory(
+        placement_id=placement.id,
        views_count=1000,
        fetched_at=now - datetime.timedelta(days=3),
    )
-    snapshot2 = domain.ViewsSnapshot(
-        purchase_id=purchase.id,
+    history2 = domain.PlacementViewsHistory(
+        placement_id=placement.id,
        views_count=1500,
        fetched_at=now - datetime.timedelta(days=1),
    )
-    snapshot3 = domain.ViewsSnapshot(
-        purchase_id=purchase.id,
+    history3 = domain.PlacementViewsHistory(
+        placement_id=placement.id,
        views_count=2000,
        fetched_at=now,
    )
-    await mock_database.create_views_snapshot(snapshot1)
-    await mock_database.create_views_snapshot(snapshot2)
-    await mock_database.create_views_snapshot(snapshot3)
+    await mock_database.create_placement_views_history(history1)
+    await mock_database.create_placement_views_history(history2)
+    await mock_database.create_placement_views_history(history3)

    # Запрашиваем историю за последние 2 дня
    input_data = dto.GetViewsHistoryInput(
-        purchase_id=purchase.id,
+        placement_id=placement.id,
        user_id=user.id,
        from_date=now - datetime.timedelta(days=2),
    )

    result = await usecases.get_views_history(input=input_data)

-    # Должны вернуться только snapshot2 и snapshot3
-    assert len(result.snapshots) == 2
-    assert result.snapshots[0].views_count == 1500
-    assert result.snapshots[1].views_count == 2000
+    # Должны вернуться только history2 и history3
+    assert len(result.histories) == 2
+    assert result.histories[0].views_count == 1500
+    assert result.histories[1].views_count == 2000