ref: рефакторинг usecases
This commit is contained in:
Artem Tsyrulnikov
@@ -1,430 +0,0 @@
|
||||
import datetime
|
||||
import uuid
|
||||
from contextlib import AbstractAsyncContextManager
|
||||
from typing import Any
|
||||
from unittest.mock import AsyncMock
|
||||
|
||||
import pytest
|
||||
|
||||
from src import domain, usecase
|
||||
|
||||
|
||||
class MockDatabase:
|
||||
def __init__(self) -> None:
|
||||
self.users: dict[uuid.UUID, domain.User] = {}
|
||||
self.users_by_telegram_id: dict[int, domain.User] = {}
|
||||
self.login_tokens: dict[str, domain.LoginToken] = {}
|
||||
self.target_channels: dict[uuid.UUID, domain.TargetChannel] = {}
|
||||
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.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.placement_views_histories: dict[uuid.UUID, domain.PlacementViewsHistory] = {}
|
||||
self.m2m_target_external: dict[uuid.UUID, list[uuid.UUID]] = {}
|
||||
|
||||
def transaction(self) -> AbstractAsyncContextManager[None]:
|
||||
return AsyncMock()
|
||||
|
||||
async def get_user(self, *, user_id: uuid.UUID | None = None, telegram_id: int | None = None) -> domain.User | None:
|
||||
if user_id:
|
||||
return self.users.get(user_id)
|
||||
if telegram_id:
|
||||
return self.users_by_telegram_id.get(telegram_id)
|
||||
return None
|
||||
|
||||
async def create_user(self, user: domain.User) -> domain.User:
|
||||
if not user.id:
|
||||
user.id = uuid.uuid4()
|
||||
if not hasattr(user, 'created_at') or user.created_at is None:
|
||||
user.created_at = datetime.datetime.now(datetime.UTC)
|
||||
if not hasattr(user, 'updated_at') or user.updated_at is None:
|
||||
user.updated_at = datetime.datetime.now(datetime.UTC)
|
||||
self.users[user.id] = user
|
||||
self.users_by_telegram_id[user.telegram_id] = user
|
||||
return user
|
||||
|
||||
async def create_login_token(
|
||||
self, user_id: uuid.UUID, token: str, expires_at: datetime.datetime
|
||||
) -> domain.LoginToken:
|
||||
login_token = domain.LoginToken(user_id=user_id, token=token, expires_at=expires_at, used_at=None)
|
||||
if not login_token.id:
|
||||
login_token.id = uuid.uuid4()
|
||||
if not hasattr(login_token, 'created_at') or login_token.created_at is None:
|
||||
login_token.created_at = datetime.datetime.now(datetime.UTC)
|
||||
if not hasattr(login_token, 'updated_at') or login_token.updated_at is None:
|
||||
login_token.updated_at = datetime.datetime.now(datetime.UTC)
|
||||
self.login_tokens[token] = login_token
|
||||
return login_token
|
||||
|
||||
async def get_login_token(self, token: str) -> domain.LoginToken | None:
|
||||
return self.login_tokens.get(token)
|
||||
|
||||
async def mark_token_as_used(self, token: str) -> None:
|
||||
if token in self.login_tokens:
|
||||
self.login_tokens[token].used_at = datetime.datetime.now(datetime.UTC)
|
||||
|
||||
async def get_target_channel(
|
||||
self, user_id: uuid.UUID, channel_id: uuid.UUID | None = None, telegram_id: int | None = None
|
||||
) -> domain.TargetChannel | None:
|
||||
if channel_id:
|
||||
channel = self.target_channels.get(channel_id)
|
||||
if channel and channel.user_id == user_id:
|
||||
return channel
|
||||
if telegram_id:
|
||||
channel = self.target_channels_by_telegram_id.get(telegram_id)
|
||||
if channel and channel.user_id == user_id:
|
||||
return channel
|
||||
return None
|
||||
|
||||
async def upsert_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
|
||||
existing = self.target_channels_by_telegram_id.get(channel.telegram_id)
|
||||
if existing:
|
||||
existing.title = channel.title
|
||||
existing.username = channel.username
|
||||
existing.status = channel.status
|
||||
return existing
|
||||
if not channel.id:
|
||||
channel.id = uuid.uuid4()
|
||||
if not hasattr(channel, 'created_at') or channel.created_at is None:
|
||||
channel.created_at = datetime.datetime.now(datetime.UTC)
|
||||
if not hasattr(channel, 'updated_at') or channel.updated_at is None:
|
||||
channel.updated_at = datetime.datetime.now(datetime.UTC)
|
||||
self.target_channels[channel.id] = channel
|
||||
self.target_channels_by_telegram_id[channel.telegram_id] = channel
|
||||
return channel
|
||||
|
||||
async def get_user_target_channels(self, user_id: uuid.UUID) -> list[domain.TargetChannel]:
|
||||
return [c for c in self.target_channels.values() if c.user_id == user_id]
|
||||
|
||||
async def update_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
|
||||
self.target_channels[channel.id] = channel
|
||||
return channel
|
||||
|
||||
async def create_external_channel(self, channel: domain.ExternalChannel) -> domain.ExternalChannel:
|
||||
if not channel.id:
|
||||
channel.id = uuid.uuid4()
|
||||
if not hasattr(channel, 'created_at') or channel.created_at is None:
|
||||
channel.created_at = datetime.datetime.now(datetime.UTC)
|
||||
if not hasattr(channel, 'updated_at') or channel.updated_at is None:
|
||||
channel.updated_at = datetime.datetime.now(datetime.UTC)
|
||||
self.external_channels[channel.id] = channel
|
||||
return channel
|
||||
|
||||
async def add_external_channel_to_targets(
|
||||
self, external_channel_id: uuid.UUID, target_channel_ids: list[uuid.UUID]
|
||||
) -> None:
|
||||
if external_channel_id not in self.m2m_target_external:
|
||||
self.m2m_target_external[external_channel_id] = []
|
||||
self.m2m_target_external[external_channel_id].extend(target_channel_ids)
|
||||
|
||||
async def get_external_channels_for_target(self, target_channel_id: uuid.UUID) -> list[domain.ExternalChannel]:
|
||||
result = []
|
||||
for ext_id, targets in self.m2m_target_external.items():
|
||||
if target_channel_id in targets:
|
||||
ext_ch = self.external_channels.get(ext_id)
|
||||
if ext_ch:
|
||||
result.append(ext_ch)
|
||||
return result
|
||||
|
||||
async def get_external_channel(
|
||||
self, user_id: uuid.UUID, channel_id: uuid.UUID | None = None, telegram_id: int | None = None
|
||||
) -> domain.ExternalChannel | None:
|
||||
if channel_id:
|
||||
channel = self.external_channels.get(channel_id)
|
||||
if channel and channel.user_id == user_id:
|
||||
return channel
|
||||
if telegram_id:
|
||||
for channel in self.external_channels.values():
|
||||
if channel.telegram_id == telegram_id and channel.user_id == user_id:
|
||||
return channel
|
||||
return None
|
||||
|
||||
async def remove_external_channel_from_target(
|
||||
self, external_channel_id: uuid.UUID, target_channel_id: uuid.UUID
|
||||
) -> None:
|
||||
if external_channel_id in self.m2m_target_external:
|
||||
targets = self.m2m_target_external[external_channel_id]
|
||||
if target_channel_id in targets:
|
||||
targets.remove(target_channel_id)
|
||||
|
||||
async def delete_external_channel(self, channel_id: uuid.UUID) -> None:
|
||||
self.external_channels.pop(channel_id, None)
|
||||
self.m2m_target_external.pop(channel_id, None)
|
||||
|
||||
async def create_creative(self, creative: domain.Creative) -> domain.Creative:
|
||||
if not creative.id:
|
||||
creative.id = uuid.uuid4()
|
||||
if not hasattr(creative, 'created_at') or creative.created_at is None:
|
||||
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, '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
|
||||
if not hasattr(creative, 'status') or creative.status is None:
|
||||
creative.status = domain.CreativeStatus.ACTIVE
|
||||
self.creatives[creative.id] = creative
|
||||
return creative
|
||||
|
||||
async def get_creative(self, user_id: uuid.UUID, creative_id: uuid.UUID) -> domain.Creative | None:
|
||||
creative = self.creatives.get(creative_id)
|
||||
if creative and creative.user_id == user_id:
|
||||
return creative
|
||||
return None
|
||||
|
||||
async def update_creative(self, creative: domain.Creative) -> domain.Creative:
|
||||
self.creatives[creative.id] = creative
|
||||
return creative
|
||||
|
||||
async def get_user_creatives(
|
||||
self,
|
||||
user_id: uuid.UUID,
|
||||
*,
|
||||
target_channel_id: uuid.UUID | None = None,
|
||||
include_archived: bool = False,
|
||||
) -> list[domain.Creative]:
|
||||
result = [c for c in self.creatives.values() if c.user_id == user_id]
|
||||
if target_channel_id:
|
||||
result = [c for c in result if c.target_channel_id == target_channel_id]
|
||||
if not include_archived:
|
||||
result = [c for c in result if c.status == domain.CreativeStatus.ACTIVE]
|
||||
return result
|
||||
|
||||
async def delete_creative(self, creative_id: uuid.UUID) -> None:
|
||||
self.creatives.pop(creative_id, None)
|
||||
|
||||
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(placement.target_channel_id)
|
||||
if target_ch:
|
||||
placement.target_channel = target_ch
|
||||
ext_ch = self.external_channels.get(placement.external_channel_id)
|
||||
if ext_ch:
|
||||
placement.external_channel = ext_ch
|
||||
creative = self.creatives.get(placement.creative_id)
|
||||
if creative:
|
||||
placement.creative = creative
|
||||
self.placements[placement.id] = placement
|
||||
return placement
|
||||
|
||||
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_placement(self, placement: domain.Placement) -> domain.Placement:
|
||||
self.placements[placement.id] = placement
|
||||
return placement
|
||||
|
||||
async def get_user_placements(
|
||||
self,
|
||||
user_id: uuid.UUID,
|
||||
*,
|
||||
target_channel_id: uuid.UUID | None = None,
|
||||
external_channel_id: uuid.UUID | None = None,
|
||||
creative_id: uuid.UUID | None = None,
|
||||
include_archived: bool = False,
|
||||
) -> 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:
|
||||
result = [p for p in result if p.external_channel_id == external_channel_id]
|
||||
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.PlacementStatus.ACTIVE]
|
||||
return sorted(result, key=lambda p: p.placement_date, reverse=True)
|
||||
|
||||
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 placement in self.placements.values():
|
||||
if placement.creative_id == creative_id and placement.status == domain.PlacementStatus.ACTIVE:
|
||||
return True
|
||||
return False
|
||||
|
||||
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()
|
||||
if not hasattr(subscription, 'created_at') or subscription.created_at is None:
|
||||
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)
|
||||
# Загружаем связанные объекты
|
||||
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_subscriber_and_placement(
|
||||
self, subscriber_id: uuid.UUID, placement_id: uuid.UUID
|
||||
) -> domain.Subscription | None:
|
||||
for subscription in self.subscriptions.values():
|
||||
if subscription.subscriber_id == subscriber_id and subscription.placement_id == placement_id:
|
||||
return subscription
|
||||
return None
|
||||
|
||||
async def get_active_subscriptions_by_subscriber_and_channel(
|
||||
self, subscriber_id: uuid.UUID, channel_telegram_id: int
|
||||
) -> list[domain.Subscription]:
|
||||
result = []
|
||||
for subscription in self.subscriptions.values():
|
||||
if subscription.subscriber_id == subscriber_id and subscription.unsubscribed_at is None:
|
||||
placement = self.placements.get(subscription.placement_id)
|
||||
if placement:
|
||||
target_channel = self.target_channels.get(placement.target_channel_id)
|
||||
if target_channel and target_channel.telegram_id == channel_telegram_id:
|
||||
subscription.placement = placement
|
||||
result.append(subscription)
|
||||
return result
|
||||
|
||||
async def get_active_subscription_by_subscriber_and_channel(
|
||||
self, subscriber_id: uuid.UUID, channel_telegram_id: int
|
||||
) -> domain.Subscription | None:
|
||||
subscriptions = await self.get_active_subscriptions_by_subscriber_and_channel(
|
||||
subscriber_id, channel_telegram_id
|
||||
)
|
||||
return subscriptions[0] if subscriptions else None
|
||||
|
||||
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,
|
||||
placement_id: uuid.UUID,
|
||||
*,
|
||||
from_date: datetime.datetime | None = None,
|
||||
to_date: datetime.datetime | None = None,
|
||||
) -> list[domain.PlacementViewsHistory]:
|
||||
result = [h for h in self.placement_views_histories.values() if h.placement_id == placement_id]
|
||||
if from_date:
|
||||
result = [h for h in result if h.fetched_at >= from_date]
|
||||
if to_date:
|
||||
result = [h for h in result if h.fetched_at <= to_date]
|
||||
return sorted(result, key=lambda h: h.fetched_at)
|
||||
|
||||
|
||||
class MockTelegramWriter:
|
||||
def __init__(self) -> None:
|
||||
self.sent_messages: list[dict[str, Any]] = []
|
||||
self.invite_link_counter = 0
|
||||
|
||||
async def send_message(self, text: str, chat_id: int) -> None:
|
||||
self.sent_messages.append({'text': text, 'chat_id': chat_id, 'button': None})
|
||||
|
||||
async def send_message_with_button(self, text: str, chat_id: int, button_text: str, button_url: str) -> None:
|
||||
self.sent_messages.append(
|
||||
{'text': text, 'chat_id': chat_id, 'button': {'text': button_text, 'url': button_url}}
|
||||
)
|
||||
|
||||
async def send_message_with_inline_keyboard(self, text: str, chat_id: int, buttons: list[list[Any]]) -> None:
|
||||
self.sent_messages.append({'text': text, 'chat_id': chat_id, 'inline_keyboard': buttons})
|
||||
|
||||
async def edit_message_reply_markup(self, chat_id: int, message_id: int) -> None:
|
||||
pass
|
||||
|
||||
async def get_chat_member(self, chat_id: int, user_id: int) -> dict[str, Any]:
|
||||
return {}
|
||||
|
||||
async def create_chat_invite_link(self, chat_id: int, requires_approval: bool = False) -> str:
|
||||
self.invite_link_counter += 1
|
||||
link_type = 'approval' if requires_approval else 'public'
|
||||
return f'https://t.me/+{link_type}_link_{self.invite_link_counter}_{chat_id}'
|
||||
|
||||
|
||||
class MockJWTEncoder:
|
||||
def encode_access_token(self, user_id: uuid.UUID, telegram_id: int, username: str | None = None) -> str:
|
||||
return f'jwt_token_{user_id}_{telegram_id}'
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_database() -> MockDatabase:
|
||||
return MockDatabase()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_telegram() -> MockTelegramWriter:
|
||||
return MockTelegramWriter()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_jwt() -> MockJWTEncoder:
|
||||
return MockJWTEncoder()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def usecases(
|
||||
mock_database: MockDatabase,
|
||||
mock_telegram: MockTelegramWriter,
|
||||
mock_jwt: MockJWTEncoder,
|
||||
) -> usecase.Usecase:
|
||||
return usecase.Usecase(
|
||||
database=mock_database, # type: ignore[arg-type]
|
||||
telegram_bot=mock_telegram,
|
||||
jwt_encoder=mock_jwt,
|
||||
)
|
||||
@@ -1,107 +0,0 @@
|
||||
"""Тесты авторизации через Telegram."""
|
||||
|
||||
import datetime
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src import domain, dto, usecase
|
||||
from tests.conftest import MockDatabase, MockTelegramWriter
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_new_user_registration(usecases: usecase.Usecase, mock_telegram: MockTelegramWriter) -> None:
|
||||
"""Новый пользователь регистрируется через Telegram."""
|
||||
input_data = dto.TelegramLoginInput(telegram_id=123456, username='testuser', chat_id=123456)
|
||||
|
||||
await usecases.telegram_login(input_data)
|
||||
|
||||
# Проверяем, что пользователь создан
|
||||
user = await usecases.database.get_user(telegram_id=123456)
|
||||
assert user is not None
|
||||
assert user.telegram_id == 123456
|
||||
assert user.username == 'testuser'
|
||||
|
||||
# Проверяем, что бот отправил сообщение с кнопкой
|
||||
assert len(mock_telegram.sent_messages) == 1
|
||||
msg = mock_telegram.sent_messages[0]
|
||||
assert msg['button'] is not None
|
||||
assert 'token=' in msg['button']['url']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_existing_user_login(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Существующий пользователь получает токен для входа."""
|
||||
# Создаём пользователя
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
input_data = dto.TelegramLoginInput(telegram_id=123456, username='testuser', chat_id=123456)
|
||||
await usecases.telegram_login(input_data)
|
||||
|
||||
# Проверяем, что не создался второй пользователь
|
||||
users_count = len(mock_database.users)
|
||||
assert users_count == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_login_token_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Валидный токен обменивается на JWT."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
token = 'test_token_123'
|
||||
expires_at = datetime.datetime.now(datetime.UTC) + datetime.timedelta(minutes=10)
|
||||
await mock_database.create_login_token(user.id, token, expires_at)
|
||||
|
||||
result = await usecases.validate_login_token(dto.ValidateLoginTokenInput(token=token))
|
||||
|
||||
assert result.access_token.startswith('jwt_token_')
|
||||
assert str(user.id) in result.access_token
|
||||
|
||||
# Проверяем, что токен помечен как использованный
|
||||
login_token = await mock_database.get_login_token(token)
|
||||
assert login_token is not None
|
||||
assert login_token.used_at is not None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_login_token_not_found(usecases: usecase.Usecase) -> None:
|
||||
"""Несуществующий токен вызывает ошибку."""
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.validate_login_token(dto.ValidateLoginTokenInput(token='nonexistent'))
|
||||
assert exc_info.value.status_code == 404
|
||||
assert 'Login token not found' in str(exc_info.value.detail)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_login_token_already_used(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Использованный токен вызывает ошибку."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
token = 'test_token_123'
|
||||
expires_at = datetime.datetime.now(datetime.UTC) + datetime.timedelta(minutes=10)
|
||||
await mock_database.create_login_token(user.id, token, expires_at)
|
||||
await mock_database.mark_token_as_used(token)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.validate_login_token(dto.ValidateLoginTokenInput(token=token))
|
||||
assert exc_info.value.status_code == 400
|
||||
assert 'already been used' in str(exc_info.value.detail)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_login_token_expired(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Истекший токен вызывает ошибку."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
token = 'test_token_123'
|
||||
expires_at = datetime.datetime.now(datetime.UTC) - datetime.timedelta(minutes=1)
|
||||
await mock_database.create_login_token(user.id, token, expires_at)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.validate_login_token(dto.ValidateLoginTokenInput(token=token))
|
||||
assert exc_info.value.status_code == 400
|
||||
assert 'expired' in str(exc_info.value.detail)
|
||||
@@ -1,24 +0,0 @@
|
||||
"""Tests for creative text formatting helpers."""
|
||||
|
||||
from src.usecase.creative.text_formatting import prepare_creative_text_html
|
||||
|
||||
|
||||
def test_placeholder_is_replaced_with_custom_tag() -> None:
|
||||
source = 'Подписывайтесь: {link}!'
|
||||
assert prepare_creative_text_html(source) == 'Подписывайтесь: <a class="tg-link"></a>!'
|
||||
|
||||
|
||||
def test_label_placeholder_is_wrapped() -> None:
|
||||
source = 'Жми [сюда]{link} скорее'
|
||||
assert prepare_creative_text_html(source) == 'Жми <a class="tg-link">сюда</a> скорее'
|
||||
|
||||
|
||||
def test_placeholder_replacement_is_case_insensitive() -> None:
|
||||
source = 'Первый {LINK}, второй {Link}.'
|
||||
expected = 'Первый <a class="tg-link"></a>, второй <a class="tg-link"></a>.'
|
||||
assert prepare_creative_text_html(source) == expected
|
||||
|
||||
|
||||
def test_plain_html_left_untouched() -> None:
|
||||
source = '<b>Жми</b> и <i>делись</i>'
|
||||
assert prepare_creative_text_html(source) == source
|
||||
@@ -1,244 +0,0 @@
|
||||
"""Тесты работы с креативами."""
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src import domain, dto, usecase
|
||||
from tests.conftest import MockDatabase
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_creative_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Создание нового креатива."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
input_data = dto.CreateCreativeInput(
|
||||
name='Test Creative',
|
||||
text='Приглашаю подписаться на канал: {link}',
|
||||
target_channel_id=target_channel.id,
|
||||
)
|
||||
|
||||
result = await usecases.create_creative(input_data, user.id)
|
||||
|
||||
assert result.name == 'Test Creative'
|
||||
assert result.text == 'Приглашаю подписаться на канал: {link}'
|
||||
assert result.target_channel_id == target_channel.id
|
||||
assert result.status == domain.CreativeStatus.ACTIVE
|
||||
assert result.placements_count == 0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_creative_invalid_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Создание креатива для несуществующего целевого канала вызывает ошибку."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
import uuid
|
||||
|
||||
fake_target_id = uuid.uuid4()
|
||||
|
||||
input_data = dto.CreateCreativeInput(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=fake_target_id,
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.create_creative(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_creatives(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Получение списка креативов пользователя."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
creative1 = domain.Creative(
|
||||
name='Creative 1',
|
||||
text='Text 1',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
creative2 = domain.Creative(
|
||||
name='Creative 2',
|
||||
text='Text 2',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative1)
|
||||
await mock_database.create_creative(creative2)
|
||||
|
||||
result = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id))
|
||||
|
||||
assert len(result.creatives) == 2
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_creatives_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)
|
||||
|
||||
target1 = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target 1',
|
||||
username='target1',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
target2 = domain.TargetChannel(
|
||||
telegram_id=-1001234567891,
|
||||
title='Target 2',
|
||||
username='target2',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target1)
|
||||
await mock_database.upsert_target_channel(target2)
|
||||
|
||||
creative1 = domain.Creative(
|
||||
name='Creative 1',
|
||||
text='Text 1',
|
||||
target_channel_id=target1.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
creative2 = domain.Creative(
|
||||
name='Creative 2',
|
||||
text='Text 2',
|
||||
target_channel_id=target2.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative1)
|
||||
await mock_database.create_creative(creative2)
|
||||
|
||||
result = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id, target_channel_id=target1.id))
|
||||
|
||||
assert len(result.creatives) == 1
|
||||
assert result.creatives[0].target_channel_id == target1.id
|
||||
|
||||
|
||||
# TODO: Implement archive_creative method
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_archive_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
# """Архивирование креатива."""
|
||||
# user = domain.User(telegram_id=123456, username='testuser')
|
||||
# await mock_database.create_user(user)
|
||||
#
|
||||
# target_channel = domain.TargetChannel(
|
||||
# telegram_id=-1001234567890,
|
||||
# title='Target Channel',
|
||||
# username='targetchannel',
|
||||
# user_id=user.id,
|
||||
# status=domain.TargetChannelStatus.ACTIVE,
|
||||
# )
|
||||
# await mock_database.upsert_target_channel(target_channel)
|
||||
#
|
||||
# creative = domain.Creative(
|
||||
# name='Test Creative',
|
||||
# text='Test text',
|
||||
# target_channel_id=target_channel.id,
|
||||
# user_id=user.id,
|
||||
# status=domain.CreativeStatus.ACTIVE,
|
||||
# )
|
||||
# await mock_database.create_creative(creative)
|
||||
#
|
||||
# result = await usecases.archive_creative(creative.id, user.id)
|
||||
#
|
||||
# assert result.status == domain.CreativeStatus.ARCHIVED
|
||||
#
|
||||
# # Проверяем, что архивированный креатив не возвращается по умолчанию
|
||||
# creatives_list = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id))
|
||||
# assert len(creatives_list.creatives) == 0
|
||||
#
|
||||
# # Проверяем, что архивированный креатив возвращается с флагом include_archived
|
||||
# creatives_with_archived = await usecases.get_creatives(
|
||||
# dto.GetCreativesInput(user_id=user.id, include_archived=True)
|
||||
# )
|
||||
# assert len(creatives_with_archived.creatives) == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Редактирование креатива."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Old Name',
|
||||
text='Old text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
update_input = dto.UpdateCreativeInput(name='New Name', text='New text')
|
||||
result = await usecases.update_creative(creative.id, update_input, user.id)
|
||||
|
||||
assert result.name == 'New Name'
|
||||
assert result.text == 'New text'
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Удаление креатива."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
await usecases.delete_creative(dto.DeleteCreativeInput(creative_id=creative.id, user_id=user.id))
|
||||
|
||||
# Проверяем, что креатив удалён
|
||||
creatives_list = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id, include_archived=True))
|
||||
assert len(creatives_list.creatives) == 0
|
||||
@@ -1,177 +0,0 @@
|
||||
"""Тесты каталога внешних каналов."""
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src import domain, dto, usecase
|
||||
from tests.conftest import MockDatabase
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_external_channel_with_targets(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Создание внешнего канала с привязкой к целевым каналам."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
input_data = dto.CreateExternalChannelInput(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description='Test external channel',
|
||||
subscribers_count=10000,
|
||||
target_channel_ids=[target_channel.id],
|
||||
)
|
||||
|
||||
result = await usecases.create_external_channel(input_data, user.id)
|
||||
|
||||
assert result.telegram_id == -1009876543210
|
||||
assert result.title == 'External Channel'
|
||||
assert result.subscribers_count == 10000
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_external_channel_invalid_target(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Создание внешнего канала с несуществующим целевым каналом вызывает ошибку."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
import uuid
|
||||
|
||||
fake_target_id = uuid.uuid4()
|
||||
|
||||
input_data = dto.CreateExternalChannelInput(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
target_channel_ids=[fake_target_id],
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.create_external_channel(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_external_channels_for_target(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Получение списка внешних каналов для целевого канала."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
ext_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=10000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(ext_channel)
|
||||
await mock_database.add_external_channel_to_targets(ext_channel.id, [target_channel.id])
|
||||
|
||||
result = await usecases.get_external_channels(
|
||||
dto.GetExternalChannelsInput(target_channel_id=target_channel.id, user_id=user.id)
|
||||
)
|
||||
|
||||
assert len(result.external_channels) == 1
|
||||
assert result.external_channels[0].telegram_id == -1009876543210
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_external_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Удаление внешнего канала."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
ext_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=10000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(ext_channel)
|
||||
await mock_database.add_external_channel_to_targets(ext_channel.id, [target_channel.id])
|
||||
|
||||
await usecases.delete_external_channel(dto.DeleteExternalChannelInput(channel_id=ext_channel.id, user_id=user.id))
|
||||
|
||||
# Проверяем, что канал удалён
|
||||
channels = await mock_database.get_external_channels_for_target(target_channel.id)
|
||||
assert len(channels) == 0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_external_channel_links(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Обновление привязок внешнего канала к целевым каналам."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target1 = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target 1',
|
||||
username='target1',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
target2 = domain.TargetChannel(
|
||||
telegram_id=-1001234567891,
|
||||
title='Target 2',
|
||||
username='target2',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target1)
|
||||
await mock_database.upsert_target_channel(target2)
|
||||
|
||||
ext_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=10000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(ext_channel)
|
||||
await mock_database.add_external_channel_to_targets(ext_channel.id, [target1.id])
|
||||
|
||||
# Добавляем связь с target2
|
||||
await usecases.update_external_channel_links(
|
||||
ext_channel.id,
|
||||
dto.UpdateExternalChannelLinksInput(
|
||||
add_target_channel_ids=[target2.id],
|
||||
remove_target_channel_ids=[],
|
||||
),
|
||||
user.id,
|
||||
)
|
||||
|
||||
# Проверяем, что канал теперь привязан к обоим целевым каналам
|
||||
channels_for_target2 = await mock_database.get_external_channels_for_target(target2.id)
|
||||
assert len(channels_for_target2) == 1
|
||||
@@ -1,632 +0,0 @@
|
||||
"""Тесты работы с закупами."""
|
||||
|
||||
import datetime
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src import domain, dto, usecase
|
||||
from tests.conftest import MockDatabase
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
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)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description='Ad channel',
|
||||
subscribers_count=50000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Summer Sale',
|
||||
text='Подписывайтесь на наш канал по ссылке: {link}',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement_date = datetime.datetime.now(datetime.UTC)
|
||||
input_data = dto.CreatePlacementInput(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
placement_date=placement_date,
|
||||
cost=5000.0,
|
||||
comment='Утреннее размещение',
|
||||
ad_post_url='https://t.me/externalchannel/123',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
)
|
||||
|
||||
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
|
||||
assert result.creative_id == creative.id
|
||||
assert result.cost == 5000.0
|
||||
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.PlacementStatus.PENDING # Ожидает публикации поста
|
||||
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.placements_count == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_placement_with_approval_invite_link(
|
||||
usecases: usecase.Usecase, mock_database: MockDatabase
|
||||
) -> None:
|
||||
"""Создание закупа с пригласительной ссылкой, требующей одобрения."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=30000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Premium Creative',
|
||||
text='Эксклюзивный контент: {link}',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement_date = datetime.datetime.now(datetime.UTC)
|
||||
input_data = dto.CreatePlacementInput(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
placement_date=placement_date,
|
||||
invite_link_type=domain.InviteLinkType.APPROVAL,
|
||||
)
|
||||
|
||||
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_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)
|
||||
|
||||
import uuid
|
||||
|
||||
fake_target_id = uuid.uuid4()
|
||||
fake_external_id = uuid.uuid4()
|
||||
fake_creative_id = uuid.uuid4()
|
||||
|
||||
input_data = dto.CreatePlacementInput(
|
||||
target_channel_id=fake_target_id,
|
||||
external_channel_id=fake_external_id,
|
||||
creative_id=fake_creative_id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
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_placements(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Получение списка закупов пользователя."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=20000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
# Создаём два закупа
|
||||
placement1 = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
cost=3000.0,
|
||||
invite_link='https://t.me/+link1',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
placement2 = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=1),
|
||||
cost=4000.0,
|
||||
invite_link='https://t.me/+link2',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement1)
|
||||
await mock_database.create_placement(placement2)
|
||||
|
||||
result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id))
|
||||
|
||||
assert len(result.placements) == 2
|
||||
# Проверяем сортировку по дате размещения (новые первые)
|
||||
assert result.placements[0].id == placement1.id
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
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)
|
||||
|
||||
target1 = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target 1',
|
||||
username='target1',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
target2 = domain.TargetChannel(
|
||||
telegram_id=-1001234567891,
|
||||
title='Target 2',
|
||||
username='target2',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target1)
|
||||
await mock_database.upsert_target_channel(target2)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=15000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative1 = domain.Creative(
|
||||
name='Creative 1',
|
||||
text='Text 1',
|
||||
target_channel_id=target1.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
creative2 = domain.Creative(
|
||||
name='Creative 2',
|
||||
text='Text 2',
|
||||
target_channel_id=target2.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative1)
|
||||
await mock_database.create_creative(creative2)
|
||||
|
||||
placement1 = domain.Placement(
|
||||
target_channel_id=target1.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative1.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link1',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
placement2 = domain.Placement(
|
||||
target_channel_id=target2.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative2.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link2',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement1)
|
||||
await mock_database.create_placement(placement2)
|
||||
|
||||
result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, 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_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)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=25000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative1 = domain.Creative(
|
||||
name='Creative A',
|
||||
text='Вариант A',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
creative2 = domain.Creative(
|
||||
name='Creative B',
|
||||
text='Вариант B',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative1)
|
||||
await mock_database.create_creative(creative2)
|
||||
|
||||
# Создаём закупы с разными креативами
|
||||
placement1 = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative1.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link1',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
placement2 = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative2.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link2',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement1)
|
||||
await mock_database.create_placement(placement2)
|
||||
|
||||
result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, creative_id=creative1.id))
|
||||
|
||||
assert len(result.placements) == 1
|
||||
assert result.placements[0].creative_id == creative1.id
|
||||
|
||||
|
||||
# TODO: Implement archive_placement method
|
||||
# @pytest.mark.asyncio
|
||||
# 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)
|
||||
#
|
||||
# target_channel = domain.TargetChannel(
|
||||
# telegram_id=-1001234567890,
|
||||
# title='Target Channel',
|
||||
# username='targetchannel',
|
||||
# user_id=user.id,
|
||||
# status=domain.TargetChannelStatus.ACTIVE,
|
||||
# )
|
||||
# await mock_database.upsert_target_channel(target_channel)
|
||||
#
|
||||
# external_channel = domain.ExternalChannel(
|
||||
# telegram_id=-1009876543210,
|
||||
# title='External Channel',
|
||||
# username='externalchannel',
|
||||
# description=None,
|
||||
# subscribers_count=18000,
|
||||
# user_id=user.id,
|
||||
# )
|
||||
# await mock_database.create_external_channel(external_channel)
|
||||
#
|
||||
# creative = domain.Creative(
|
||||
# name='Test Creative',
|
||||
# text='Test text',
|
||||
# target_channel_id=target_channel.id,
|
||||
# user_id=user.id,
|
||||
# status=domain.CreativeStatus.ACTIVE,
|
||||
# )
|
||||
# await mock_database.create_creative(creative)
|
||||
#
|
||||
# placement = domain.Placement(
|
||||
# target_channel_id=target_channel.id,
|
||||
# external_channel_id=external_channel.id,
|
||||
# creative_id=creative.id,
|
||||
# user_id=user.id,
|
||||
# placement_date=datetime.datetime.now(datetime.UTC),
|
||||
# invite_link='https://t.me/+link1',
|
||||
# invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
# status=domain.PlacementStatus.ACTIVE,
|
||||
# )
|
||||
# await mock_database.create_placement(placement)
|
||||
#
|
||||
# result = await usecases.archive_placement(placement.id, user.id)
|
||||
#
|
||||
# assert result.status == domain.PlacementStatus.ARCHIVED
|
||||
#
|
||||
# # Проверяем, что архивированный закуп не возвращается по умолчанию
|
||||
# placements_list = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id))
|
||||
# assert len(placements_list.placements) == 0
|
||||
#
|
||||
# # Проверяем, что архивированный закуп возвращается с флагом include_archived
|
||||
# placements_with_archived = await usecases.get_placements(
|
||||
# dto.GetPlacementsInput(user_id=user.id, include_archived=True)
|
||||
# )
|
||||
# assert len(placements_with_archived.placements) == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
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)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=22000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
old_date = datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=1)
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=old_date,
|
||||
cost=3000.0,
|
||||
comment='Старый комментарий',
|
||||
invite_link='https://t.me/+link1',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
new_date = datetime.datetime.now(datetime.UTC)
|
||||
update_input = dto.UpdatePlacementInput(
|
||||
placement_date=new_date,
|
||||
cost=3500.0,
|
||||
comment='Обновлённый комментарий',
|
||||
ad_post_url='https://t.me/externalchannel/456',
|
||||
)
|
||||
result = await usecases.update_placement(placement.id, update_input, user.id)
|
||||
|
||||
assert result.placement_date == new_date
|
||||
assert result.cost == 3500.0
|
||||
assert result.comment == 'Обновлённый комментарий'
|
||||
assert result.ad_post_url == 'https://t.me/externalchannel/456'
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
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)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=28000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
placements_count=1,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link1',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
await usecases.delete_placement(dto.DeletePlacementInput(placement_id=placement.id, user_id=user.id))
|
||||
|
||||
# Проверяем, что закуп удалён
|
||||
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.placements_count == 0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
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)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external1 = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External 1',
|
||||
username='external1',
|
||||
description=None,
|
||||
subscribers_count=10000,
|
||||
user_id=user.id,
|
||||
)
|
||||
external2 = domain.ExternalChannel(
|
||||
telegram_id=-1009876543211,
|
||||
title='External 2',
|
||||
username='external2',
|
||||
description=None,
|
||||
subscribers_count=20000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external1)
|
||||
await mock_database.create_external_channel(external2)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Universal Creative',
|
||||
text='Универсальный текст',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
# Создаём два закупа с одним креативом в разных внешних каналах
|
||||
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.CreatePlacementInput(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external2.id,
|
||||
creative_id=creative.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
cost=4000.0,
|
||||
)
|
||||
|
||||
result1 = await usecases.create_placement(input1, user.id)
|
||||
result2 = await usecases.create_placement(input2, user.id)
|
||||
|
||||
# Проверяем, что созданы два разных закупа
|
||||
assert result1.id != result2.id
|
||||
assert result1.invite_link != result2.invite_link
|
||||
|
||||
# Проверяем, что счётчик креатива увеличился на 2
|
||||
updated_creative = await mock_database.get_creative(user.id, creative.id)
|
||||
assert updated_creative is not None
|
||||
assert updated_creative.placements_count == 2
|
||||
|
||||
# Проверяем фильтрацию по креативу
|
||||
placements_for_creative = await usecases.get_placements(
|
||||
dto.GetPlacementsInput(user_id=user.id, creative_id=creative.id)
|
||||
)
|
||||
assert len(placements_for_creative.placements) == 2
|
||||
@@ -1,350 +0,0 @@
|
||||
"""Тесты обработки подписок пользователей через invite_link."""
|
||||
|
||||
import datetime
|
||||
|
||||
import pytest
|
||||
|
||||
from src import domain, usecase
|
||||
from tests.conftest import MockDatabase
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_handle_subscription_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Первая подписка пользователя по invite_link успешно создаётся."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=50000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
invite_link = 'https://t.me/+unique_link_123'
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link=invite_link,
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
subscriptions_count=0,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
# Симулируем подписку пользователя
|
||||
subscriber_id = 999888777
|
||||
subscriber_username = 'new_subscriber'
|
||||
await usecases.handle_subscription(
|
||||
user_telegram_id=subscriber_id,
|
||||
username=subscriber_username,
|
||||
invite_link=invite_link,
|
||||
)
|
||||
|
||||
# Проверяем, что подписка создана
|
||||
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.subscriber_id == subscriber.id
|
||||
assert subscription.invite_link == invite_link
|
||||
|
||||
# Проверяем, что счётчик подписок у закупа увеличился
|
||||
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
|
||||
async def test_handle_subscription_duplicate_ignored(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Повторная подписка того же пользователя игнорируется - не создаёт дубликат."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=30000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
invite_link = 'https://t.me/+unique_link_456'
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link=invite_link,
|
||||
invite_link_type=domain.InviteLinkType.APPROVAL,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
subscriptions_count=0,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
subscriber_id = 888777666
|
||||
subscriber_username = 'duplicate_user'
|
||||
|
||||
# Первая подписка
|
||||
await usecases.handle_subscription(
|
||||
user_telegram_id=subscriber_id,
|
||||
username=subscriber_username,
|
||||
invite_link=invite_link,
|
||||
)
|
||||
|
||||
# Проверяем счётчик
|
||||
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(
|
||||
user_telegram_id=subscriber_id,
|
||||
username=subscriber_username,
|
||||
invite_link=invite_link,
|
||||
)
|
||||
|
||||
# Проверяем, что счётчик не увеличился
|
||||
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, не увеличился
|
||||
|
||||
# Проверяем, что в БД только одна подписка этого подписчика
|
||||
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
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_handle_subscription_invalid_invite_link(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Подписка по несуществующему invite_link не создаётся."""
|
||||
fake_invite_link = 'https://t.me/+fake_link_999'
|
||||
|
||||
# Пытаемся обработать подписку по несуществующей ссылке
|
||||
await usecases.handle_subscription(
|
||||
user_telegram_id=777666555,
|
||||
username='unknown_user',
|
||||
invite_link=fake_invite_link,
|
||||
)
|
||||
|
||||
# Проверяем, что подписки не создано
|
||||
assert len(mock_database.subscriptions) == 0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_multiple_users_subscription_same_placement(
|
||||
usecases: usecase.Usecase, mock_database: MockDatabase
|
||||
) -> None:
|
||||
"""Несколько пользователей подписываются через один закуп - каждый учитывается."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=40000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Viral Creative',
|
||||
text='Viral content',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
invite_link = 'https://t.me/+popular_link_789'
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link=invite_link,
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
subscriptions_count=0,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
# Подписываются три разных пользователя
|
||||
users_data = [
|
||||
(111222333, 'user_one'),
|
||||
(444555666, 'user_two'),
|
||||
(777888999, 'user_three'),
|
||||
]
|
||||
|
||||
for telegram_id, username in users_data:
|
||||
await usecases.handle_subscription(
|
||||
user_telegram_id=telegram_id,
|
||||
username=username,
|
||||
invite_link=invite_link,
|
||||
)
|
||||
|
||||
# Проверяем, что создано 3 подписки
|
||||
placement_subscriptions = [s for s in mock_database.subscriptions.values() if s.placement_id == placement.id]
|
||||
assert len(placement_subscriptions) == 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_placements(
|
||||
usecases: usecase.Usecase, mock_database: MockDatabase
|
||||
) -> None:
|
||||
"""Один пользователь может подписаться через разные закупы - каждая подписка учитывается отдельно."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=25000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
# Создаём два разных закупа с разными invite_link
|
||||
placement1 = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link_a',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
subscriptions_count=0,
|
||||
)
|
||||
placement2 = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link_b',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
subscriptions_count=0,
|
||||
)
|
||||
await mock_database.create_placement(placement1)
|
||||
await mock_database.create_placement(placement2)
|
||||
|
||||
subscriber_id = 555444333
|
||||
|
||||
# Пользователь подписывается через первый закуп
|
||||
await usecases.handle_subscription(
|
||||
user_telegram_id=subscriber_id,
|
||||
username='multi_subscriber',
|
||||
invite_link=placement1.invite_link,
|
||||
)
|
||||
|
||||
# Тот же пользователь "подписывается" через второй закуп
|
||||
# (технически невозможно, но тестируем логику)
|
||||
await usecases.handle_subscription(
|
||||
user_telegram_id=subscriber_id,
|
||||
username='multi_subscriber',
|
||||
invite_link=placement2.invite_link,
|
||||
)
|
||||
|
||||
# Проверяем, что у каждого закупа свой счётчик
|
||||
updated_placement1 = await mock_database.get_placement(user.id, placement1.id)
|
||||
updated_placement2 = await mock_database.get_placement(user.id, placement2.id)
|
||||
|
||||
assert updated_placement1 is not None
|
||||
assert updated_placement1.subscriptions_count == 1
|
||||
|
||||
assert updated_placement2 is not None
|
||||
assert updated_placement2.subscriptions_count == 1
|
||||
|
||||
# Проверяем, что создано 2 подписки
|
||||
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
|
||||
@@ -1,169 +0,0 @@
|
||||
"""Тесты подключения целевых каналов."""
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src import domain, dto, usecase
|
||||
from tests.conftest import MockDatabase, MockTelegramWriter
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_new_channel_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Подключение нового канала с правами администратора."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
input_data = dto.ConnectTargetChanInput(
|
||||
telegram_id=-1001234567890,
|
||||
title='Test Channel',
|
||||
username='testchannel',
|
||||
user_telegram_id=123456,
|
||||
bot_permissions=dto.ChannelBotPermissions(
|
||||
is_admin=True,
|
||||
can_invite_users=True,
|
||||
can_restrict_members=True,
|
||||
),
|
||||
)
|
||||
|
||||
result = await usecases.connect_target_chan(input_data)
|
||||
|
||||
assert result.telegram_id == -1001234567890
|
||||
assert result.title == 'Test Channel'
|
||||
assert result.status == domain.TargetChannelStatus.ACTIVE
|
||||
assert result.is_active is True # проверка обратной совместимости
|
||||
|
||||
# Проверяем, что канал сохранён
|
||||
channel = await mock_database.get_target_channel(user.id, telegram_id=-1001234567890)
|
||||
assert channel is not None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_channel_without_admin_rights(
|
||||
usecases: usecase.Usecase, mock_database: MockDatabase, mock_telegram: MockTelegramWriter
|
||||
) -> None:
|
||||
"""Канал без прав администратора не подключается."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
input_data = dto.ConnectTargetChanInput(
|
||||
telegram_id=-1001234567890,
|
||||
title='Test Channel',
|
||||
username='testchannel',
|
||||
user_telegram_id=123456,
|
||||
bot_permissions=dto.ChannelBotPermissions(
|
||||
is_admin=False,
|
||||
can_invite_users=False,
|
||||
can_restrict_members=False,
|
||||
),
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.connect_target_chan(input_data)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
# Проверяем, что бот отправил предупреждение
|
||||
assert len(mock_telegram.sent_messages) == 1
|
||||
assert 'не является админом' in mock_telegram.sent_messages[0]['text']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_channel_without_required_permissions(
|
||||
usecases: usecase.Usecase, mock_database: MockDatabase, mock_telegram: MockTelegramWriter
|
||||
) -> None:
|
||||
"""Канал без необходимых прав не подключается."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
input_data = dto.ConnectTargetChanInput(
|
||||
telegram_id=-1001234567890,
|
||||
title='Test Channel',
|
||||
username='testchannel',
|
||||
user_telegram_id=123456,
|
||||
bot_permissions=dto.ChannelBotPermissions(
|
||||
is_admin=True,
|
||||
can_invite_users=False, # Отсутствует необходимое право
|
||||
can_restrict_members=True,
|
||||
),
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.connect_target_chan(input_data)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
assert len(mock_telegram.sent_messages) == 1
|
||||
assert 'не имеет необходимых прав' in mock_telegram.sent_messages[0]['text']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_channel_user_not_found(usecases: usecase.Usecase, mock_telegram: MockTelegramWriter) -> None:
|
||||
"""Подключение канала неавторизованным пользователем вызывает ошибку."""
|
||||
input_data = dto.ConnectTargetChanInput(
|
||||
telegram_id=-1001234567890,
|
||||
title='Test Channel',
|
||||
username='testchannel',
|
||||
user_telegram_id=999999, # Несуществующий пользователь
|
||||
bot_permissions=dto.ChannelBotPermissions(
|
||||
is_admin=True,
|
||||
can_invite_users=True,
|
||||
can_restrict_members=True,
|
||||
),
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await usecases.connect_target_chan(input_data)
|
||||
|
||||
assert exc_info.value.status_code == 404
|
||||
assert 'not found' in str(exc_info.value.detail).lower()
|
||||
assert len(mock_telegram.sent_messages) == 1
|
||||
assert 'авторизоваться' in mock_telegram.sent_messages[0]['text']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_user_target_channels(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Получение списка каналов пользователя."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
channel1 = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Channel 1',
|
||||
username='channel1',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
channel2 = domain.TargetChannel(
|
||||
telegram_id=-1001234567891,
|
||||
title='Channel 2',
|
||||
username='channel2',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(channel1)
|
||||
await mock_database.upsert_target_channel(channel2)
|
||||
|
||||
result = await usecases.get_user_target_chans(dto.GetUserTargetChansInput(user_id=user.id))
|
||||
|
||||
assert len(result.target_channels) == 2
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Отключение целевого канала."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Test Channel',
|
||||
username='testchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(channel)
|
||||
|
||||
await usecases.disconnect_target_chan(dto.DisconnectTargetChanInput(channel_id=channel.id, user_id=user.id))
|
||||
|
||||
# Проверяем, что канал стал неактивным
|
||||
updated_channel = await mock_database.get_target_channel(user.id, channel_id=channel.id)
|
||||
assert updated_channel is not None
|
||||
assert updated_channel.status == domain.TargetChannelStatus.INACTIVE
|
||||
@@ -1,299 +0,0 @@
|
||||
"""Тесты работы с просмотрами рекламных постов."""
|
||||
|
||||
import datetime
|
||||
|
||||
import pytest
|
||||
|
||||
from src import domain, dto, usecase
|
||||
from tests.conftest import MockDatabase
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_views_manually(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Ручное обновление просмотров создаёт снимок и обновляет закуп."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=40000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link3',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
ad_post_url='https://t.me/externalchannel/456',
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
input_data = dto.UpdateViewsManuallyInput(
|
||||
placement_id=placement.id,
|
||||
user_id=user.id,
|
||||
views_count=15000,
|
||||
)
|
||||
|
||||
result = await usecases.update_views_manually(input=input_data)
|
||||
|
||||
# Проверяем возвращённый результат
|
||||
assert result.views_count == 15000
|
||||
assert result.views_availability == domain.PostViewsAvailability.MANUAL
|
||||
assert result.last_views_fetch_at is not None
|
||||
|
||||
# Проверяем, что создана история просмотров
|
||||
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_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
|
||||
async def test_get_views_history_empty(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Получение истории просмотров для закупа без снимков возвращает пустой список."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=25000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link4',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
input_data = dto.GetViewsHistoryInput(
|
||||
placement_id=placement.id,
|
||||
user_id=user.id,
|
||||
)
|
||||
|
||||
result = await usecases.get_views_history(input=input_data)
|
||||
|
||||
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)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=35000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link5',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
# Создаём несколько записей истории
|
||||
now = datetime.datetime.now(datetime.UTC)
|
||||
history1 = domain.PlacementViewsHistory(
|
||||
placement_id=placement.id,
|
||||
views_count=1000,
|
||||
fetched_at=now - datetime.timedelta(hours=2),
|
||||
)
|
||||
history2 = domain.PlacementViewsHistory(
|
||||
placement_id=placement.id,
|
||||
views_count=1500,
|
||||
fetched_at=now - datetime.timedelta(hours=1),
|
||||
)
|
||||
history3 = domain.PlacementViewsHistory(
|
||||
placement_id=placement.id,
|
||||
views_count=2000,
|
||||
fetched_at=now,
|
||||
)
|
||||
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(
|
||||
placement_id=placement.id,
|
||||
user_id=user.id,
|
||||
)
|
||||
|
||||
result = await usecases.get_views_history(input=input_data)
|
||||
|
||||
assert len(result.histories) == 3
|
||||
# Проверяем сортировку по времени (старые первые)
|
||||
assert result.histories[0].views_count == 1000
|
||||
assert result.histories[1].views_count == 1500
|
||||
assert result.histories[2].views_count == 2000
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_views_history_with_date_filter(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
|
||||
"""Фильтрация истории просмотров по датам работает корректно."""
|
||||
user = domain.User(telegram_id=123456, username='testuser')
|
||||
await mock_database.create_user(user)
|
||||
|
||||
target_channel = domain.TargetChannel(
|
||||
telegram_id=-1001234567890,
|
||||
title='Target Channel',
|
||||
username='targetchannel',
|
||||
user_id=user.id,
|
||||
status=domain.TargetChannelStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.upsert_target_channel(target_channel)
|
||||
|
||||
external_channel = domain.ExternalChannel(
|
||||
telegram_id=-1009876543210,
|
||||
title='External Channel',
|
||||
username='externalchannel',
|
||||
description=None,
|
||||
subscribers_count=28000,
|
||||
user_id=user.id,
|
||||
)
|
||||
await mock_database.create_external_channel(external_channel)
|
||||
|
||||
creative = domain.Creative(
|
||||
name='Test Creative',
|
||||
text='Test text',
|
||||
target_channel_id=target_channel.id,
|
||||
user_id=user.id,
|
||||
status=domain.CreativeStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_creative(creative)
|
||||
|
||||
placement = domain.Placement(
|
||||
target_channel_id=target_channel.id,
|
||||
external_channel_id=external_channel.id,
|
||||
creative_id=creative.id,
|
||||
user_id=user.id,
|
||||
placement_date=datetime.datetime.now(datetime.UTC),
|
||||
invite_link='https://t.me/+link6',
|
||||
invite_link_type=domain.InviteLinkType.PUBLIC,
|
||||
status=domain.PlacementStatus.ACTIVE,
|
||||
)
|
||||
await mock_database.create_placement(placement)
|
||||
|
||||
# Создаём записи с разными датами
|
||||
now = datetime.datetime.now(datetime.UTC)
|
||||
history1 = domain.PlacementViewsHistory(
|
||||
placement_id=placement.id,
|
||||
views_count=1000,
|
||||
fetched_at=now - datetime.timedelta(days=3),
|
||||
)
|
||||
history2 = domain.PlacementViewsHistory(
|
||||
placement_id=placement.id,
|
||||
views_count=1500,
|
||||
fetched_at=now - datetime.timedelta(days=1),
|
||||
)
|
||||
history3 = domain.PlacementViewsHistory(
|
||||
placement_id=placement.id,
|
||||
views_count=2000,
|
||||
fetched_at=now,
|
||||
)
|
||||
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(
|
||||
placement_id=placement.id,
|
||||
user_id=user.id,
|
||||
from_date=now - datetime.timedelta(days=2),
|
||||
)
|
||||
|
||||
result = await usecases.get_views_history(input=input_data)
|
||||
|
||||
# Должны вернуться только history2 и history3
|
||||
assert len(result.histories) == 2
|
||||
assert result.histories[0].views_count == 1500
|
||||
assert result.histories[1].views_count == 2000
|
||||
Reference in New Issue
Block a user