initial release

tests/test_cli.py

@@ -0,0 +1,651 @@
+# SPDX-FileCopyrightText: 2025 Alexander Kalinovsky <a@k8y.ru>
+#
+# SPDX-License-Identifier: MIT
+
+"""Tests for the CLI functionality."""
+
+import inspect
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+import typer
+import yaml
+from typer.testing import CliRunner
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from quickbot_cli.cli import (
+    _init_project,
+    app,
+    apply_optionals,
+    ask_variables,
+    init,
+    load_template_spec,
+    main,
+    render_tree,
+    run_post_tasks,
+)
+
+
+class TestLoadTemplateSpec:
+    """Test template specification loading."""
+
+    def test_load_template_spec_with_valid_file(self, temp_dir: Path) -> None:
+        """Test loading template spec from a valid YAML file."""
+        spec_file = temp_dir / "__template__.yaml"
+        spec_content = {
+            "variables": {"project_name": {"prompt": "Project name", "default": "test"}},
+            "post_tasks": [{"run": ["echo", "test"]}],
+        }
+        spec_file.write_text(yaml.dump(spec_content))
+
+        result = load_template_spec(temp_dir)
+        assert result == spec_content
+
+    def test_load_template_spec_without_file(self, temp_dir: Path) -> None:
+        """Test loading template spec when file doesn't exist."""
+        result = load_template_spec(temp_dir)
+        assert result == {"variables": {}, "post_tasks": []}
+
+    def test_load_template_spec_with_invalid_yaml(self, temp_dir: Path) -> None:
+        """Test loading template spec with invalid YAML."""
+        spec_file = temp_dir / "__template__.yaml"
+        spec_file.write_text("invalid: yaml: content: [")
+
+        with pytest.raises((typer.Exit, Exception)):
+            load_template_spec(temp_dir)
+
+
+class TestAskVariables:
+    """Test variable prompting and validation."""
+
+    def test_ask_variables_with_non_interactive(self) -> None:
+        """Test asking variables with non-interactive mode."""
+        spec = {
+            "variables": {
+                "project_name": {"type": "string", "default": "my_project"},
+                "description": {"type": "string", "default": "A test project"},
+            }
+        }
+        non_interactive = {"project_name": "my_project", "description": "A test project"}
+        result = ask_variables(spec, non_interactive)
+        assert result["project_name"] == "my_project"
+        assert result["description"] == "A test project"
+
+    def test_ask_variables_with_choices_validation(self, mock_typer_prompt: MagicMock) -> None:
+        """Test asking variables with choices validation."""
+        spec = {
+            "variables": {"include_alembic": {"prompt": "Include Alembic?", "choices": ["yes", "no"], "default": "yes"}}
+        }
+        non_interactive: dict[str, str] = {}
+
+        # Test valid choice
+        mock_typer_prompt.return_value = "yes"
+        result = ask_variables(spec, non_interactive)
+        assert result["include_alembic"] == "yes"
+
+    def test_ask_variables_with_invalid_choice(self, mock_typer_prompt: MagicMock) -> None:
+        """Test asking variables with invalid choice."""
+        spec = {
+            "variables": {"include_alembic": {"prompt": "Include Alembic?", "choices": ["yes", "no"], "default": "yes"}}
+        }
+        non_interactive: dict[str, str] = {}
+
+        # Test invalid choice
+        mock_typer_prompt.return_value = "maybe"
+
+        with pytest.raises((SystemExit, Exception)):
+            ask_variables(spec, non_interactive)
+
+    def test_ask_variables_with_boolean_choices_true(self, mock_typer_prompt: MagicMock) -> None:
+        """Boolean choices should coerce various truthy inputs to True."""
+        spec = {
+            "variables": {
+                "feature_flag": {
+                    "prompt": "Enable feature?",
+                    "choices": [True, False],
+                    "default": True,
+                }
+            }
+        }
+        non_interactive: dict[str, str] = {}
+
+        # Try several truthy inputs
+        for truthy in [True, "true", "Yes", "Y", "1"]:
+            mock_typer_prompt.return_value = truthy
+            result = ask_variables(spec, non_interactive)
+            assert result["feature_flag"] is True
+
+    def test_ask_variables_with_boolean_choices_false(self, mock_typer_prompt: MagicMock) -> None:
+        """Boolean choices should coerce various falsy inputs to False."""
+        spec = {
+            "variables": {
+                "feature_flag": {
+                    "prompt": "Enable feature?",
+                    "choices": [True, False],
+                    "default": False,
+                }
+            }
+        }
+        non_interactive: dict[str, str] = {}
+
+        for falsy in [False, "false", "No", "n", "0"]:
+            mock_typer_prompt.return_value = falsy
+            result = ask_variables(spec, non_interactive)
+            assert result["feature_flag"] is False
+
+    def test_ask_variables_with_boolean_choices_invalid(self, mock_typer_prompt: MagicMock) -> None:
+        """Invalid input for boolean choices should raise SystemExit."""
+        spec = {
+            "variables": {
+                "feature_flag": {
+                    "prompt": "Enable feature?",
+                    "choices": [True, False],
+                    "default": True,
+                }
+            }
+        }
+        non_interactive: dict[str, str] = {}
+
+        mock_typer_prompt.return_value = "maybe"
+        with pytest.raises((SystemExit, Exception)):
+            ask_variables(spec, non_interactive)
+
+    def test_ask_variables_with_regex_validation(self, mock_typer_prompt: MagicMock) -> None:
+        """Test asking variables with regex validation."""
+        spec = {
+            "variables": {
+                "project_name": {"prompt": "Project name", "default": "test", "validate": r"^[a-z_][a-z0-9_]*$"}
+            }
+        }
+        non_interactive: dict[str, str] = {}
+
+        # Test valid name
+        mock_typer_prompt.return_value = "valid_name"
+        result = ask_variables(spec, non_interactive)
+        assert result["project_name"] == "valid_name"
+
+        # Test invalid name
+        mock_typer_prompt.return_value = "Invalid-Name"
+
+        with pytest.raises((SystemExit, Exception)):
+            ask_variables(spec, non_interactive)
+
+
+class TestRenderTree:
+    """Test template file rendering."""
+
+    def test_render_tree_creates_directories(self, temp_dir: Path) -> None:
+        """Test that render_tree creates directories correctly."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+        (template_root / "app").mkdir()
+        (template_root / "app" / "models").mkdir()
+
+        output_dir = temp_dir / "output"
+        context = {"project_name": "test_project"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        render_tree(env, template_root, output_dir, context, overwrite=False)
+
+        assert (output_dir / "app" / "models").exists()
+        assert (output_dir / "app" / "models").is_dir()
+
+    def test_render_tree_renders_jinja2_files(self, temp_dir: Path) -> None:
+        """Test that render_tree renders Jinja2 template files."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+
+        template_file = template_root / "main.py.j2"
+        template_file.write_text("app = FastAPI(title='{{ project_name }}')")
+
+        output_dir = temp_dir / "output"
+        context = {"project_name": "test_project"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        render_tree(env, template_root, output_dir, context, overwrite=False)
+
+        output_file = output_dir / "main.py"
+        assert output_file.exists()
+        assert "app = FastAPI(title='test_project')" in output_file.read_text()
+
+    def test_render_tree_renders_regular_files(self, temp_dir: Path) -> None:
+        """Test that render_tree renders regular text files."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+
+        template_file = template_root / "README.md.j2"
+        template_file.write_text("# {{ project_name }}\n\n{{ description }}")
+
+        output_dir = temp_dir / "output"
+        context = {"project_name": "test_project", "description": "Test description"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        render_tree(env, template_root, output_dir, context, overwrite=False)
+
+        output_file = output_dir / "README.md"
+        assert output_file.exists()
+        assert "# test_project" in output_file.read_text()
+        assert "Test description" in output_file.read_text()
+
+    def test_render_tree_copies_binary_files(self, temp_dir: Path) -> None:
+        """Test that render_tree copies binary files without modification."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+
+        # Create a mock binary file
+        binary_file = template_root / "image.png"
+        binary_content = b"fake_png_data"
+        binary_file.write_bytes(binary_content)
+
+        output_dir = temp_dir / "output"
+        context = {"project_name": "test_project"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        render_tree(env, template_root, output_dir, context, overwrite=False)
+
+        output_file = output_dir / "image.png"
+        assert output_file.exists()
+        assert output_file.read_bytes() == binary_content
+
+    def test_render_tree_binary_file_exists_error(self, temp_dir: Path) -> None:
+        """Test that render_tree raises error when binary file exists and overwrite is disabled."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+
+        # Create a mock binary file
+        binary_file = template_root / "image.png"
+        binary_content = b"fake_png_data"
+        binary_file.write_bytes(binary_content)
+
+        output_dir = temp_dir / "output"
+        output_dir.mkdir()
+
+        # Create existing binary file
+        existing_file = output_dir / "image.png"
+        existing_file.write_bytes(b"existing_binary_data")
+
+        context = {"project_name": "test_project"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        with pytest.raises(FileExistsError, match="File exists:"):
+            render_tree(env, template_root, output_dir, context, overwrite=False)
+
+    def test_render_tree_with_overwrite_disabled(self, temp_dir: Path) -> None:
+        """Test that render_tree raises error when overwrite is disabled and file exists."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+
+        template_file = template_root / "main.py.j2"
+        template_file.write_text("app = FastAPI(title='{{ project_name }}')")
+
+        output_dir = temp_dir / "output"
+        output_dir.mkdir()
+
+        # Create existing file
+        existing_file = output_dir / "main.py"
+        existing_file.write_text("existing content")
+
+        context = {"project_name": "test_project"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        with pytest.raises(FileExistsError):
+            render_tree(env, template_root, output_dir, context, overwrite=False)
+
+    def test_render_tree_with_overwrite_enabled(self, temp_dir: Path) -> None:
+        """Test that render_tree overwrites existing files when enabled."""
+        template_root = temp_dir / "template"
+        template_root.mkdir()
+
+        template_file = template_root / "main.py.j2"
+        template_file.write_text("app = FastAPI(title='{{ project_name }}')")
+
+        output_dir = temp_dir / "output"
+        output_dir.mkdir()
+
+        # Create existing file
+        existing_file = output_dir / "main.py"
+        existing_file.write_text("existing content")
+
+        context = {"project_name": "test_project"}
+        env = Environment(loader=FileSystemLoader(str(template_root)), undefined=StrictUndefined, autoescape=True)
+
+        render_tree(env, template_root, output_dir, context, overwrite=True)
+
+        output_file = output_dir / "main.py"
+        assert output_file.exists()
+        assert "app = FastAPI(title='test_project')" in output_file.read_text()
+
+
+class TestRunPostTasks:
+    """Test post-task execution."""
+
+    def test_run_post_tasks_with_conditions(self, temp_dir: Path) -> None:
+        """Test running post tasks with conditional execution."""
+        spec = {
+            "post_tasks": [
+                {"when": "{{ include_alembic }}", "run": ["echo", "alembic_init"]},
+                {"when": "{{ include_i18n }}", "run": ["echo", "babel_init"]},
+            ]
+        }
+        context = {"include_alembic": True, "include_i18n": False}
+        cwd = temp_dir / "test_cwd"
+        cwd.mkdir(parents=True, exist_ok=True)
+
+        run_post_tasks(spec, context, cwd)
+
+    def test_run_post_tasks_without_conditions(self, temp_dir: Path) -> None:
+        """Test running post tasks without conditions."""
+        spec = {
+            "post_tasks": [{"run": ["echo", "hello"]}, {"run": ["command", "hello"]}, {"run": ["command", "world"]}]
+        }
+        context: dict[str, str] = {}
+        cwd = temp_dir / "test_cwd"
+        cwd.mkdir(parents=True, exist_ok=True)
+
+        run_post_tasks(spec, context, cwd)
+
+    def test_run_post_tasks_with_subprocess_error_continues(self, temp_dir: Path) -> None:
+        """Test that post task errors don't stop execution."""
+        # This test verifies that subprocess errors don't stop execution
+        # The actual error handling is tested in the main run_post_tasks function
+
+
+class TestApplyOptionals:
+    """Test optional module inclusion/exclusion."""
+
+    def test_apply_optionals_disables_alembic(self, temp_dir: Path) -> None:
+        """Test that apply_optionals removes alembic files when disabled."""
+        # Create alembic files
+        alembic_dir = temp_dir / "alembic"
+        alembic_dir.mkdir()
+        (alembic_dir / "alembic.ini").write_text("config")
+
+        scripts_dir = temp_dir / "scripts"
+        scripts_dir.mkdir()
+        (scripts_dir / "migrations_generate.sh").write_text("script")
+        (scripts_dir / "migrations_apply.sh").write_text("script")
+
+        apply_optionals(temp_dir, include_alembic=False, include_i18n=True)
+
+        assert not alembic_dir.exists()
+        assert not (scripts_dir / "migrations_generate.sh").exists()
+        assert not (scripts_dir / "migrations_apply.sh").exists()
+
+    def test_apply_optionals_disables_babel(self, temp_dir: Path) -> None:
+        """Test that apply_optionals removes babel files when disabled."""
+        # Create babel files
+        locales_dir = temp_dir / "locales"
+        locales_dir.mkdir()
+        (locales_dir / "en").mkdir()
+
+        scripts_dir = temp_dir / "scripts"
+        scripts_dir.mkdir()
+        (scripts_dir / "babel_init.sh").write_text("script")
+        (scripts_dir / "babel_extract.sh").write_text("script")
+        (scripts_dir / "babel_update.sh").write_text("script")
+        (scripts_dir / "babel_compile.sh").write_text("script")
+
+        apply_optionals(temp_dir, include_alembic=True, include_i18n=False)
+
+        assert not locales_dir.exists()
+        assert not (scripts_dir / "babel_init.sh").exists()
+        assert not (scripts_dir / "babel_extract.sh").exists()
+        assert not (scripts_dir / "babel_update.sh").exists()
+        assert not (scripts_dir / "babel_compile.sh").exists()
+
+    def test_apply_optionals_keeps_enabled_modules(self, temp_dir: Path) -> None:
+        """Test that apply_optionals keeps files for enabled modules."""
+        # Create both module files
+        alembic_dir = temp_dir / "alembic"
+        alembic_dir.mkdir()
+        (alembic_dir / "alembic.ini").write_text("config")
+
+        locales_dir = temp_dir / "locales"
+        locales_dir.mkdir()
+        (locales_dir / "en").mkdir()
+
+        apply_optionals(temp_dir, include_alembic=True, include_i18n=True)
+
+        assert alembic_dir.exists()
+        assert locales_dir.exists()
+
+
+class TestInitCommand:
+    """Test the main init command."""
+
+    def test_init_command_success(
+        self,
+        temp_dir: Path,
+    ) -> None:
+        """Test successful project initialization."""
+        with patch("quickbot_cli.cli.TEMPLATES_DIR", temp_dir / "templates"):
+            # Create template structure
+            template_dir = temp_dir / "templates" / "basic"
+            template_dir.mkdir(parents=True)
+
+            # Create template spec
+            spec_file = template_dir / "__template__.yaml"
+            spec_file.write_text("variables:\n  project_name:\n    prompt: Project name\n    default: test_project")
+
+            # Create template files
+            (template_dir / "app").mkdir()
+            (template_dir / "app" / "main.py.j2").write_text("app = FastAPI(title='{{ project_name }}')")
+
+            # Test the init function directly instead of through CLI
+            output_path = temp_dir / "output"
+            _init_project(output_path, "basic")
+
+    def test_init_command_with_template_not_found(self, temp_dir: Path) -> None:
+        """Test init command when template is not found."""
+        with patch("quickbot_cli.cli.TEMPLATES_DIR", temp_dir / "templates"):
+            output_path = temp_dir / "output"
+            with pytest.raises(FileNotFoundError, match="Template 'nonexistent' not found"):
+                _init_project(output_path, "nonexistent")
+
+    def test_init_command_with_template_not_found_error_message(self, temp_dir: Path) -> None:
+        """Test that template not found shows the correct error message."""
+        with patch("quickbot_cli.cli.TEMPLATES_DIR", temp_dir / "templates"):
+            output_path = temp_dir / "output"
+            with pytest.raises(FileNotFoundError, match="Template 'nonexistent' not found"):
+                _init_project(output_path, "nonexistent")
+
+            # The function now raises FileNotFoundError directly, so no typer.secho call
+            # This test verifies the exception is raised with the correct message
+
+    def test_init_command_with_non_interactive_options(
+        self,
+        temp_dir: Path,
+    ) -> None:
+        """Test init command with non-interactive options."""
+        with patch("quickbot_cli.cli.TEMPLATES_DIR", temp_dir / "templates"):
+            # Create template structure
+            template_dir = temp_dir / "templates" / "basic"
+            template_dir.mkdir(parents=True)
+
+            # Create template spec
+            spec_file = template_dir / "__template__.yaml"
+            spec_file.write_text("variables:\n  project_name:\n    prompt: Project name\n    default: test_project")
+
+            # Create template files
+            (template_dir / "app").mkdir()
+            (template_dir / "app" / "main.py.j2").write_text("app = FastAPI(title='{{ project_name }}')")
+
+            # Test the init function directly instead of through CLI
+            output_path = temp_dir / "output"
+            _init_project(
+                output_path,
+                "basic",
+                project_name="my_project",
+                description="A test project",
+                author="Test Author",
+                license_name="MIT",
+                include_alembic=True,
+                include_i18n=False,
+                overwrite=False,
+            )
+
+    def test_init_command_with_overwrite(
+        self,
+        temp_dir: Path,
+    ) -> None:
+        """Test init command with overwrite flag."""
+        with patch("quickbot_cli.cli.TEMPLATES_DIR", temp_dir / "templates"):
+            # Create template structure
+            template_dir = temp_dir / "templates" / "basic"
+            template_dir.mkdir(parents=True)
+
+            # Create template spec
+            spec_file = template_dir / "__template__.yaml"
+            spec_file.write_text("variables:\n  project_name:\n    prompt: Project name\n    default: test_project")
+
+            # Create template files
+            (template_dir / "app").mkdir()
+            (template_dir / "app" / "main.py.j2").write_text("app = FastAPI(title='{{ project_name }}')")
+
+            # Test the init function directly instead of through CLI
+            # Call init function directly with overwrite
+            output_path = temp_dir / "output"
+            _init_project(output_path, "basic", overwrite=True)
+
+    def test_cli_boolean_flags_defaults_and_negation(self, temp_dir: Path) -> None:
+        """init() should honor boolean defaults and negation when called directly."""
+        with patch("quickbot_cli.cli.TEMPLATES_DIR", temp_dir / "templates"):
+            template_dir = temp_dir / "templates" / "basic"
+            template_dir.mkdir(parents=True)
+
+            # Minimal spec and files
+            (template_dir / "__template__.yaml").write_text(
+                "variables:\n  project_name:\n    prompt: P\n    default: test_project\n"
+            )
+            (template_dir / "app").mkdir()
+            (template_dir / "app" / "main.py.j2").write_text("ok")
+            (template_dir / "alembic").mkdir()
+            (template_dir / "alembic" / "alembic.ini.j2").write_text("a")
+            (template_dir / "locales").mkdir()
+            (template_dir / "locales" / "en").mkdir(parents=True, exist_ok=True)
+            (template_dir / "scripts").mkdir()
+            (template_dir / "scripts" / "babel_init.sh.j2").write_text("b")
+
+            # Default (both enabled)
+            out1 = temp_dir / "out1"
+            init(output=out1, template="basic")
+            assert (out1 / "alembic").exists()
+            assert (out1 / "locales").exists()
+
+            # Disable alembic
+            out2 = temp_dir / "out2"
+            init(output=out2, template="basic", include_alembic=False)
+            assert not (out2 / "alembic").exists()
+            assert (out2 / "locales").exists()
+
+            # Disable i18n
+            out3 = temp_dir / "out3"
+            init(output=out3, template="basic", include_i18n=False)
+            assert (out3 / "alembic").exists()
+            assert not (out3 / "locales").exists()
+
+
+class TestCLIHelp:
+    """Test CLI help and argument parsing."""
+
+    def test_cli_help(self, cli_runner: CliRunner) -> None:
+        """Test that CLI shows help information."""
+        # Test the actual CLI interface
+        result = cli_runner.invoke(app, ["--help"])
+        assert result.exit_code == 0
+        # Check for the actual help text that appears
+        assert "init [OPTIONS] OUTPUT" in result.output
+
+    def test_init_command_help(self, cli_runner: CliRunner) -> None:
+        """Test that init command shows help information."""
+        # Test the actual CLI interface
+        result = cli_runner.invoke(app, ["init", "--help"])
+        assert result.exit_code == 0
+        # Check for the actual help text that appears
+        assert "OUTPUT" in result.output
+        assert "PATH" in result.output
+
+    def test_init_command_arguments(self, cli_runner: CliRunner) -> None:
+        """Test that init command accepts required arguments."""
+        # Test the actual CLI interface
+        result = cli_runner.invoke(app, ["init", "--help"])
+        assert result.exit_code == 0
+        assert "OUTPUT" in result.output
+
+    def test_cli_wrapper_function(self) -> None:
+        """Test that the CLI wrapper function exists and is callable."""
+        # Verify the function exists and is callable
+        assert callable(init)
+
+        # Check that it has the expected signature
+        sig = inspect.signature(init)
+        assert "output" in sig.parameters
+        assert "template" in sig.parameters
+
+    def test_main_function(self) -> None:
+        """Test that the main function exists and is callable."""
+        assert callable(main)
+
+    def test_cli_command_execution(self) -> None:
+        """Test that the CLI wrapper function has the correct signature and behavior."""
+        # Test that the function exists and has the right signature
+        assert callable(init)
+
+        # Check the function signature
+        sig = inspect.signature(init)
+
+        # Verify all expected parameters are present
+        expected_params = [
+            "output",
+            "template",
+            "project_name",
+            "description",
+            "author",
+            "license_name",
+            "include_alembic",
+            "include_i18n",
+            "overwrite",
+        ]
+        for param in expected_params:
+            assert param in sig.parameters
+
+        # Test that the function is properly decorated as a Typer command
+        # We can't easily test the full execution due to Typer decorators,
+        # but we can verify the function structure
+        assert hasattr(init, "__name__")
+        assert init.__name__ == "init"
+
+
+class TestCLIOverwriteParsing:
+    """Test overwrite string parsing through the init function (covers conversion)."""
+
+    def test_overwrite_true_converted_to_bool(self, tmp_path: Path) -> None:
+        """Test that overwrite True is passed to _init_project."""
+        output_dir = tmp_path / "output"
+        with patch("quickbot_cli.cli._init_project") as mock_init:
+            # Call the function directly to exercise conversion logic
+            init(
+                output=output_dir,
+                template="basic",
+                overwrite=True,
+            )
+            mock_init.assert_called_once()
+            kwargs = mock_init.call_args.kwargs
+            assert kwargs["overwrite"] is True
+
+    def test_overwrite_false_converted_to_bool(self, tmp_path: Path) -> None:
+        """Test that overwrite False is passed to _init_project."""
+        output_dir = tmp_path / "output"
+        with patch("quickbot_cli.cli._init_project") as mock_init:
+            init(
+                output=output_dir,
+                template="basic",
+                overwrite=False,
+            )
+            kwargs = mock_init.call_args.kwargs
+            assert kwargs["overwrite"] is False