tests/test_storage.py - master - TurGG/AI-Assistant

tests/test_storage.py
348 строк15 KB
molodoybishkek
Первая загрузка кода ИИ-агента.
03 мар 2026, 22:10
03 мар 2026, 22:1015b5eb5
# ===========================================================
# tests/test_storage.py — Тесты слоя доступа к данным (ООП-версия)
# ===========================================================

import pytest
import time
from storage import storage


class TestGetAllUsers:
    """Тесты метода get_all_users."""

    def test_returns_list(self):
        """Должен возвращать список."""
        users = storage.get_all_users()
        assert isinstance(users, list)

    def test_users_have_required_fields(self):
        """У каждого пользователя должны быть обязательные поля."""
        users = storage.get_all_users()
        assert len(users) > 0
        for user in users:
            assert hasattr(user, 'id') or "id" in user
            assert hasattr(user, 'name') or "name" in user
            assert hasattr(user, 'points') or "points" in user

    def test_user_count(self):
        """Проверка количества пользователей (по данным rating.json)."""
        users = storage.get_all_users()
        assert len(users) == 6  # В базе 6 пользователей


class TestGetUserById:
    """Тесты метода get_user_by_id."""

    def test_existing_user(self):
        """Должен находить существующего пользователя."""
        user = storage.get_user_by_id(1)
        assert user is not None
        assert (user.get("name") if isinstance(user, dict) else user.name) == "Eleven"

    def test_non_existing_user(self):
        """Должен возвращать None для несуществующего ID."""
        user = storage.get_user_by_id(999)
        assert user is None

    def test_returns_dict_or_user(self):
        """Должен возвращать словарь или User."""
        user = storage.get_user_by_id(2)
        assert isinstance(user, dict) or hasattr(user, 'id')
        assert (user.get("team") if isinstance(user, dict) else user.team)


class TestGetUsersSortedByPoints:
    """Тесты метода get_users_sorted_by_points."""

    def test_returns_sorted_list(self):
        """Должен возвращать отсортированный список."""
        users = storage.get_users_sorted_by_points()
        assert len(users) > 1
        # Проверяем сортировку по убыванию
        for i in range(len(users) - 1):
            p1 = users[i].get("points") if isinstance(users[i], dict) else users[i].points
            p2 = users[i + 1].get("points") if isinstance(users[i + 1], dict) else users[i + 1].points
            assert p1 >= p2

    def test_limit_parameter(self):
        """Должен ограничивать количество записей."""
        users = storage.get_users_sorted_by_points(limit=3)
        assert len(users) == 3

    def test_first_is_top_scorer(self):
        """Первый пользователь должен иметь максимум баллов."""
        users = storage.get_users_sorted_by_points()
        first = users[0].get("name") if isinstance(users[0], dict) else users[0].name
        assert first == "Eleven"


class TestGetTeamsWithScores:
    """Тесты метода get_teams_with_scores."""

    def test_returns_list_of_tuples(self):
        """Должен возвращать список кортежей."""
        teams = storage.get_teams_with_scores()
        assert isinstance(teams, list)
        if len(teams) > 0:
            assert isinstance(teams[0], tuple)
            assert len(teams[0]) == 2

    def test_teams_sorted_by_points(self):
        """Команды должны быть отсортированы по убыванию баллов."""
        teams = storage.get_teams_with_scores()
        for i in range(len(teams) - 1):
            assert teams[i][1] >= teams[i + 1][1]

    def test_team_count(self):
        """Должно быть 3 команды."""
        teams = storage.get_teams_with_scores()
        assert len(teams) == 3


class TestGetUserRank:
    """Тесты метода get_user_rank."""

    def test_existing_user_rank(self):
        """Должен возвращать позицию для существующего пользователя."""
        rank = storage.get_user_rank(1)
        assert rank == 1  # Eleven — первый

    def test_non_existing_user(self):
        """Должен возвращать None для несуществующего ID."""
        rank = storage.get_user_rank(999)
        assert rank is None


class TestGetStatistics:
    """Тесты метода get_statistics."""

    def test_returns_dict(self):
        """Должен возвращать словарь."""
        stats = storage.get_statistics()
        assert isinstance(stats, dict)

    def test_has_required_keys(self):
        """Должны быть обязательные ключи."""
        stats = storage.get_statistics()
        assert "total_users" in stats
        assert "total_points" in stats
        assert "average_points" in stats
        assert "teams_count" in stats
        assert "top_scorer" in stats

    def test_total_users(self):
        """Должно быть 6 пользователей."""
        stats = storage.get_statistics()
        assert stats["total_users"] == 6

    def test_top_scorer(self):
        """Лидер должен быть Eleven."""
        stats = storage.get_statistics()
        top = stats["top_scorer"]
        assert top.get("name") == "Eleven" if isinstance(top, dict) else top.name == "Eleven"


class TestGetAllAchievements:
    """Тесты метода get_all_achievements."""

    def test_returns_list(self):
        """Должен возвращать список."""
        achievements = storage.get_all_achievements()
        assert isinstance(achievements, list)

    def test_achievements_have_name_and_count(self):
        """Каждое достижение должно иметь name и count."""
        achievements = storage.get_all_achievements()
        for ach in achievements:
            assert hasattr(ach, 'name') or "name" in ach
            assert hasattr(ach, 'count') or "count" in ach


# ===========================================================
# НОВЫЕ ТЕСТЫ ДЛЯ РАСШИРЕННОЙ ФУНКЦИОНАЛЬНОСТИ
# ===========================================================

class TestMarkAttendance:
    """Тесты метода mark_attendance."""

    def test_mark_attended(self):
        """Должен отмечать посещённое мероприятие."""
        success, message = storage.mark_attendance(1, "Тестовое мероприятие", True)
        assert success is True
        assert "Был" in message

    def test_mark_not_attended(self):
        """Должен отмечать непосещённое мероприятие."""
        success, message = storage.mark_attendance(1, "Тестовое мероприятие 2", False)
        assert success is True
        assert "Не был" in message

    def test_non_existing_user(self):
        """Должен возвращать ошибку для несуществующего пользователя."""
        success, message = storage.mark_attendance(999, "Мероприятие", True)
        assert success is False
        assert "не найден" in message.lower()


class TestUpdateProjectStage:
    """Тесты метода update_project_stage."""

    def test_valid_stage(self):
        """Должен обновлять стадию проекта на валидную."""
        success, message = storage.update_project_stage(1, "Спасение мира", "тестирование")
        assert success is True
        assert "обновлена" in message.lower()

    def test_invalid_stage(self):
        """Должен возвращать ошибку для невалидной стадии."""
        success, message = storage.update_project_stage(1, "Спасение мира", "некорректная_стадия")
        assert success is False
        assert "Некорректная стадия" in message

    def test_non_existing_project(self):
        """Должен возвращать ошибку для несуществующего проекта."""
        success, message = storage.update_project_stage(1, "Несуществующий проект", "тестирование")
        assert success is False
        assert "не найден" in message.lower()

    def test_non_existing_user(self):
        """Должен возвращать ошибку для несуществующего пользователя."""
        success, message = storage.update_project_stage(999, "Проект", "тестирование")
        assert success is False
        assert "не найден" in message.lower()


class TestGetWorstTestTakers:
    """Тесты метода get_worst_test_takers."""

    def test_returns_list(self):
        """Должен возвращать список."""
        result = storage.get_worst_test_takers(3)
        assert isinstance(result, list)
        assert len(result) <= 3

    def test_sorted_by_score(self):
        """Должен быть отсортирован по возрастанию баллов."""
        result = storage.get_worst_test_takers(5)
        for i in range(len(result) - 1):
            assert result[i]["test_score"] <= result[i + 1]["test_score"]

    def test_user_fields(self):
        """Каждый пользователь должен иметь обязательные поля."""
        result = storage.get_worst_test_takers(3)
        for user in result:
            assert "id" in user
            assert "name" in user
            assert "test_score" in user
            assert "team" in user


class TestGetNonAttendees:
    """Тесты метода get_non_attendees."""

    def test_returns_list(self):
        """Должен возвращать список."""
        result = storage.get_non_attendees()
        assert isinstance(result, list)

    def test_user_fields(self):
        """Каждый пользователь должен иметь обязательные поля."""
        result = storage.get_non_attendees()
        for user in result:
            assert "id" in user
            assert "name" in user
            assert "team" in user


class TestPendingAchievements:
    """Тесты методов для работы с заявками на достижения."""

    def test_add_pending(self):
        """Должен добавлять заявку на достижение."""
        unique_name = f"Тестовое достижение {int(time.time())}"
        success, message = storage.add_pending_achievement(1, unique_name, "Описание")
        assert success is True
        assert "отправлена" in message.lower()

    def test_add_duplicate_pending(self):
        """Должен возвращать ошибку при дубликате заявки."""
        unique_name = f"Тестовое достижение 2 {int(time.time())}"
        storage.add_pending_achievement(1, unique_name, "Описание")
        success, message = storage.add_pending_achievement(1, unique_name, "Описание")
        assert success is False
        assert "уже находится" in message.lower()

    def test_non_existing_user(self):
        """Должен возвращать ошибку для несуществующего пользователя."""
        success, message = storage.add_pending_achievement(999, "Достижение", "Описание")
        assert success is False
        assert "не найден" in message.lower()

    def test_get_pending_list(self):
        """Должен возвращать список заявок."""
        result = storage.get_pending_achievements()
        assert isinstance(result, list)


class TestApproveRejectAchievement:
    """Тесты методов approve_pending_achievement и reject_pending_achievement."""

    def test_approve_non_existing(self):
        """Должен возвращать ошибку для несуществующей заявки."""
        success, message = storage.approve_pending_achievement(1, "Несуществующее достижение")
        assert success is False
        assert "не найдена" in message.lower()

    def test_reject_non_existing(self):
        """Должен возвращать ошибку для несуществующей заявки."""
        success, message = storage.reject_pending_achievement(1, "Несуществующее достижение")
        assert success is False
        assert "не найдена" in message.lower()


class TestGetTeamLeads:
    """Тесты метода get_team_leads."""

    def test_returns_list(self):
        """Должен возвращать список тимлидов."""
        result = storage.get_team_leads()
        assert isinstance(result, list)
        assert len(result) > 0

    def test_team_lead_fields(self):
        """Каждый тимлид должен иметь обязательные поля."""
        result = storage.get_team_leads()
        for lead in result:
            assert "id" in lead
            assert "name" in lead
            assert "team" in lead

    def test_filter_by_team(self):
        """Должен фильтровать тимлидов по команде."""
        result = storage.get_team_leads("The Party")
        for lead in result:
            assert lead["team"] == "The Party"


class TestGetUsersByStage:
    """Тесты метода get_users_by_stage."""

    def test_returns_list(self):
        """Должен возвращать список пользователей."""
        result = storage.get_users_by_stage("тестирование")
        assert isinstance(result, list)

    def test_invalid_stage(self):
        """Должен возвращать пустой список для невалидной стадии."""
        result = storage.get_users_by_stage("некорректная_стадия")
        assert isinstance(result, list)
        assert len(result) == 0

    def test_user_fields(self):
        """Каждый пользователь должен иметь обязательные поля."""
        result = storage.get_users_by_stage("анализ и синтез")
        for user in result:
            assert "id" in user
            assert "name" in user
            assert "project_name" in user
            assert "current_stage" in user