tests/unit/commands/test_base.py - develop-0.4 - liquid-g/liquid-code

tests/unit/commands/test_base.py
237 строк8 KB
User
0.4.13 - Request/Response DTO с генератором make:dto и полная структура документации по маршрутизации" -m "- Добавлен генератор DTO: lcc make:dto <name> с валидацией через Pydantic
06 июл 2026, 16:08
06 июл 2026, 16:0801392a9
"""Тесты базовых утилит команд."""

import pytest
import tempfile
import os
from liquidcode.commands.base import (
    create_file,
    load_template_file,
    render_template,
    get_template,
    normalize_class_name,
    normalize_route,
    TYPE_MAP,
    normalize_field_type,
)


class TestCreateFile:
    """Тесты функции create_file."""

    def test_create_file_new(self):
        """Создание нового файла."""
        with tempfile.TemporaryDirectory() as tmpdir:
            filepath = os.path.join(tmpdir, "test.txt")
            result = create_file(filepath, "Hello World")

            assert result is True
            assert os.path.exists(filepath)
            with open(filepath, "r", encoding="utf-8") as f:
                assert f.read() == "Hello World"

    def test_create_file_exists_no_overwrite(self):
        """Файл существует, overwrite=False."""
        with tempfile.TemporaryDirectory() as tmpdir:
            filepath = os.path.join(tmpdir, "test.txt")
            with open(filepath, "w", encoding="utf-8") as f:
                f.write("Original")

            result = create_file(filepath, "New Content", overwrite=False)

            assert result is False
            with open(filepath, "r", encoding="utf-8") as f:
                assert f.read() == "Original"

    def test_create_file_exists_overwrite(self):
        """Файл существует, overwrite=True."""
        with tempfile.TemporaryDirectory() as tmpdir:
            filepath = os.path.join(tmpdir, "test.txt")
            with open(filepath, "w", encoding="utf-8") as f:
                f.write("Original")

            result = create_file(filepath, "New Content", overwrite=True)

            assert result is True
            with open(filepath, "r", encoding="utf-8") as f:
                assert f.read() == "New Content"

    def test_create_file_nested_directory(self):
        """Создание файла во вложенной директории."""
        with tempfile.TemporaryDirectory() as tmpdir:
            filepath = os.path.join(tmpdir, "subdir", "nested", "test.txt")
            result = create_file(filepath, "Nested content")

            assert result is True
            assert os.path.exists(filepath)


class TestLoadTemplateFile:
    """Тесты функции load_template_file."""

    def test_load_template_file(self):
        """Загрузка шаблона по имени."""
        template = load_template_file("controller")
        assert "class" in template
        assert "Controller" in template

    def test_load_template_file_not_found(self):
        """Шаблон не найден."""
        from liquidcode.commands.base import TemplateError

        with pytest.raises(TemplateError):
            load_template_file("nonexistent")


class TestRenderTemplate:
    """Тесты функции render_template."""

    def test_render_template(self):
        """Рендеринг шаблона."""
        template_str = "Hello {{ name }}!"
        result = render_template(template_str, name="World")
        assert result == "Hello World!"

    def test_render_template_multiple_vars(self):
        """Рендеринг с несколькими переменными."""
        template_str = "{{ greeting }} {{ target }}!"
        result = render_template(template_str, greeting="Hello", target="World")
        assert result == "Hello World!"

    def test_render_template_with_loop(self):
        """Рендеринг с циклом."""
        template_str = "{% for i in items %}{{ i }} {% endfor %}"
        result = render_template(template_str, items=[1, 2, 3])
        assert result == "1 2 3 "


class TestGetTemplate:
    """Тесты функции get_template."""

    def test_get_template(self):
        """Загрузка и рендеринг шаблона."""
        result = get_template("controller", name="Test")
        assert "class" in result
        assert "Test" in result
        assert "Контроллер Test" in result

    def test_get_template_not_found(self):
        """Шаблон не найден через get_template."""
        from liquidcode.commands.base import TemplateError

        with pytest.raises(TemplateError):
            get_template("nonexistent")


class TestNormalizeClassName:
    """Тесты функции normalize_class_name."""

    def test_simple_name(self):
        """Простое имя."""
        result = normalize_class_name("user")
        assert result == "User"

    def test_camel_case_name(self):
        """CamelCase имя."""
        result = normalize_class_name("userProfile")
        assert result == "UserProfile"

    def test_with_suffix(self):
        """Имя с суффиксом."""
        result = normalize_class_name("UserController", suffix="Controller")
        # Суффикс удаляется, если он уже есть, затем добавляется заново
        # ДляUserController Controller уже есть, поэтому результат - UserController
        assert result == "UserController"

    def test_with_suffix_missing(self):
        """Имя без суффикса."""
        result = normalize_class_name("User", suffix="Controller")
        # Суффикс добавляется, так как его нет
        assert result == "UserController"

    def test_empty_name(self):
        """Пустое имя."""
        with pytest.raises(ValueError):
            normalize_class_name("")

    def test_invalid_start(self):
        """Имя не с буквы."""
        with pytest.raises(ValueError):
            normalize_class_name("1user")

    def test_invalid_chars(self):
        """Имя с недопустимыми символами."""
        with pytest.raises(ValueError):
            normalize_class_name("user-profile")


class TestNormalizeRoute:
    """Тесты функции normalize_route."""

    def test_without_slash(self):
        """Маршрут без начального слэша."""
        result = normalize_route("users")
        assert result == "/users"

    def test_with_slash(self):
        """Маршрут с начальным слэшом."""
        result = normalize_route("/users")
        assert result == "/users"

    def test_with_trailing_slash(self):
        """Маршрут с концевым слэшом (он убирается)."""
        result = normalize_route("/users/")
        assert result == "/users"

    def test_with_parameters(self):
        """Маршрут с параметрами."""
        result = normalize_route("/users/{id}")
        assert result == "/users/{id}"

    def test_empty_route(self):
        """Пустой маршрут."""
        result = normalize_route("")
        assert result == ""

    def test_with_spaces(self):
        """Маршрут с пробелами."""
        with pytest.raises(ValueError):
            normalize_route("/users /profile")

    def test_invalid_chars(self):
        """Маршрут с недопустимыми символами."""
        with pytest.raises(ValueError):
            normalize_route("/users<id>")


class TestNormalizeFieldType:
    """Тесты функции normalize_field_type."""

    def test_string_type(self):
        """Тип string."""
        result = normalize_field_type("string")
        assert result == "str"

    def test_int_type(self):
        """Тип int."""
        result = normalize_field_type("int")
        assert result == "int"

    def test_bool_type(self):
        """Тип bool."""
        result = normalize_field_type("bool")
        assert result == "bool"

    def test_nullable_string(self):
        """Nullable string."""
        result = normalize_field_type("string", nullable=True)
        assert result == "Optional[str]"

    def test_custom_type(self):
        """Кастомный тип."""
        result = normalize_field_type("MyClass")
        assert result == "MyClass"

    def test_list_type(self):
        """Тип list."""
        result = normalize_field_type("list")
        assert result == "list"