tests/test_utils.py - master - serkatrinaa/final_project_base

tests/test_utils.py
230 строк8 KB
Katya Mashnina
project done
28 дек 2025, 23:22
28 дек 2025, 23:22cc88ff0
"""
Tests for utils module.
"""

import unittest
import tempfile
import os
import json
import sys

# Добавляем корень проекта в путь
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.utils import (
    load_text_file,
    save_text_file,
    load_reference_texts,
    export_result_to_json,
    load_result_from_json,
    format_score_bar,
    validate_essay_length,
)


class TestFileOperations(unittest.TestCase):
    """Тесты для операций с файлами."""

    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()

    def tearDown(self):
        # Очистка временных файлов
        for file in os.listdir(self.temp_dir):
            os.remove(os.path.join(self.temp_dir, file))
        os.rmdir(self.temp_dir)

    def test_save_and_load_text_file(self):
        """Проверяем сохранение и загрузку текстового файла."""
        filepath = os.path.join(self.temp_dir, "test.txt")
        content = "Тестовый контент\nВторая строка"
        
        save_text_file(filepath, content)
        loaded = load_text_file(filepath)
        
        self.assertEqual(loaded, content)

    def test_load_nonexistent_file(self):
        """Загрузка несуществующего файла должна вызывать ошибку."""
        with self.assertRaises(FileNotFoundError):
            load_text_file("/nonexistent/path/file.txt")

    def test_save_creates_directories(self):
        """Сохранение должно создавать директории."""
        filepath = os.path.join(self.temp_dir, "subdir", "test.txt")
        content = "Тест"
        
        save_text_file(filepath, content)
        
        self.assertTrue(os.path.exists(filepath))
        
        # Очистка
        os.remove(filepath)
        os.rmdir(os.path.join(self.temp_dir, "subdir"))


class TestLoadReferenceTexts(unittest.TestCase):
    """Тесты для загрузки референсных текстов."""

    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()

    def tearDown(self):
        for file in os.listdir(self.temp_dir):
            os.remove(os.path.join(self.temp_dir, file))
        os.rmdir(self.temp_dir)

    def test_load_reference_texts(self):
        """Проверяем загрузку референсных текстов."""
        # Создаём тестовые файлы
        for i in range(3):
            filepath = os.path.join(self.temp_dir, f"ref{i}.txt")
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(f"Референсный текст {i}")
        
        texts = load_reference_texts(self.temp_dir)
        
        self.assertEqual(len(texts), 3)

    def test_load_from_nonexistent_directory(self):
        """Загрузка из несуществующей директории возвращает пустой список."""
        texts = load_reference_texts("/nonexistent/directory")
        
        self.assertEqual(texts, [])

    def test_ignores_non_txt_files(self):
        """Игнорирует файлы не .txt."""
        # Создаём .txt файл
        txt_path = os.path.join(self.temp_dir, "ref.txt")
        with open(txt_path, 'w', encoding='utf-8') as f:
            f.write("Текст")
        
        # Создаём .md файл
        md_path = os.path.join(self.temp_dir, "ref.md")
        with open(md_path, 'w', encoding='utf-8') as f:
            f.write("Маркдаун")
        
        texts = load_reference_texts(self.temp_dir)
        
        self.assertEqual(len(texts), 1)
        
        os.remove(md_path)


class TestJsonOperations(unittest.TestCase):
    """Тесты для JSON операций."""

    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()

    def tearDown(self):
        for file in os.listdir(self.temp_dir):
            os.remove(os.path.join(self.temp_dir, file))
        os.rmdir(self.temp_dir)

    def test_export_and_load_json(self):
        """Проверяем экспорт и загрузку JSON."""
        filepath = os.path.join(self.temp_dir, "result.json")
        result = {
            "total_score": 85.5,
            "grade": "Хорошо",
            "recommendations": ["Рекомендация 1", "Рекомендация 2"]
        }
        
        export_result_to_json(result, filepath)
        loaded = load_result_from_json(filepath)
        
        self.assertEqual(loaded, result)

    def test_json_preserves_cyrillic(self):
        """JSON должен сохранять кириллицу."""
        filepath = os.path.join(self.temp_dir, "cyrillic.json")
        result = {"текст": "Привет мир"}
        
        export_result_to_json(result, filepath)
        loaded = load_result_from_json(filepath)
        
        self.assertEqual(loaded["текст"], "Привет мир")


class TestFormatScoreBar(unittest.TestCase):
    """Тесты для форматирования прогресс-бара."""

    def test_full_score(self):
        """Полный балл должен показывать полный бар."""
        bar = format_score_bar(100, 100, width=10)
        
        self.assertIn("█" * 10, bar)
        self.assertIn("100.0%", bar)

    def test_zero_score(self):
        """Нулевой балл должен показывать пустой бар."""
        bar = format_score_bar(0, 100, width=10)
        
        self.assertIn("░" * 10, bar)
        self.assertIn("0.0%", bar)

    def test_half_score(self):
        """Половина баллов."""
        bar = format_score_bar(50, 100, width=10)
        
        self.assertIn("50.0%", bar)

    def test_zero_max_score(self):
        """Нулевой максимум не должен вызывать деление на ноль."""
        bar = format_score_bar(0, 0, width=10)
        
        self.assertIsInstance(bar, str)


class TestValidateEssayLength(unittest.TestCase):
    """Тесты для валидации длины эссе."""

    def test_valid_length(self):
        """Текст нормальной длины."""
        text = " ".join(["слово"] * 150)
        
        is_valid, count, msg = validate_essay_length(text, min_words=100)
        
        self.assertTrue(is_valid)
        self.assertEqual(count, 150)

    def test_too_short(self):
        """Слишком короткий текст."""
        text = "Короткий текст"
        
        is_valid, count, msg = validate_essay_length(text, min_words=100)
        
        self.assertFalse(is_valid)
        self.assertIn("короткое", msg)

    def test_too_long(self):
        """Слишком длинный текст."""
        text = " ".join(["слово"] * 200)
        
        is_valid, count, msg = validate_essay_length(
            text, min_words=100, max_words=150
        )
        
        self.assertFalse(is_valid)
        self.assertIn("длинное", msg)

    def test_exact_minimum(self):
        """Ровно минимальная длина."""
        text = " ".join(["слово"] * 100)
        
        is_valid, count, msg = validate_essay_length(text, min_words=100)
        
        self.assertTrue(is_valid)

    def test_no_max_limit(self):
        """Без ограничения максимума."""
        text = " ".join(["слово"] * 10000)
        
        is_valid, count, msg = validate_essay_length(text, min_words=100)
        
        self.assertTrue(is_valid)


if __name__ == "__main__":
    unittest.main()