test_cli.py

import os
from pathlib import Path

import pytest
from create_awesome_python_app import __version__
from create_awesome_python_app.cli import app
from typer.testing import CliRunner

runner = CliRunner()


def test_version() -> None:
 result = runner.invoke(app, ["--version"])
 assert result.exit_code == 0
 combined = result.stdout + result.stderr
 assert __version__ in combined


def test_help() -> None:
 result = runner.invoke(app, ["--help"])
 assert result.exit_code == 0
 assert "Scaffold" in result.stdout or "create" in result.stdout.lower()


def test_refresh_flag_is_forwarded(tmp_path: Path, monkeypatch) -> None:
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 result = runner.invoke(
 app,
 [
 "--template",
 f"file://{tpl}",
 "--refresh",
 "always",
 "--no-install",
 "--no-interactive",
 "api",
 ],
 )

 assert result.exit_code == 0, result.stdout + result.stderr
 options = captured["options"]
 assert isinstance(options, dict)
 assert options["refresh"] == "always"


def test_invalid_refresh_mode_fails(tmp_path: Path) -> None:
 tpl = tmp_path / "tpl"
 tpl.mkdir()

 result = runner.invoke(
 app,
 [
 "--template",
 f"file://{tpl}",
 "--refresh",
 "bogus",
 "--no-install",
 "--no-interactive",
 "api",
 ],
 )

 assert result.exit_code == 2
 assert "Invalid --refresh mode" in result.stdout + result.stderr


def test_no_cache_sets_explicit_refresh(tmp_path: Path, monkeypatch) -> None:
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 result = runner.invoke(
 app,
 [
 "--template",
 f"file://{tpl}",
 "--no-cache",
 "--no-install",
 "--no-interactive",
 "api",
 ],
 )

 assert result.exit_code == 0, result.stdout + result.stderr
 options = captured["options"]
 assert isinstance(options, dict)
 assert options["refresh"] == "always"


def test_pin_appends_ref_to_template_url(tmp_path: Path, monkeypatch) -> None:
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 result = runner.invoke(
 app,
 [
 "--template",
 f"file://{tpl}",
 "--pin",
 "abc123",
 "--no-install",
 "--no-interactive",
 "api",
 ],
 )

 assert result.exit_code == 0, result.stdout + result.stderr
 options = captured["options"]
 assert isinstance(options, dict)
 assert options["template"] == f"file://{tpl}?ref=abc123"


def test_incompatible_addons_fail_fast(tmp_path: Path, monkeypatch) -> None:
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 catalog = {
 "templates": [
 {"slug": "fastapi-starter", "url": f"file://{tpl}"},
 ],
 "extensions": [
 {
 "slug": "saga",
 "url": "file:///ext/saga",
 "incompatibleWith": ["thunk"],
 },
 {
 "slug": "thunk",
 "url": "file:///ext/thunk",
 "incompatibleWith": ["saga"],
 },
 ],
 }

 async def fake_check_for_latest_version(_package_name):
 return None

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.catalog.get_catalog_data",
 lambda: catalog,
 )

 result = runner.invoke(
 app,
 [
 "--template",
 "fastapi-starter",
 "--addons",
 "saga",
 "--addons",
 "thunk",
 "--no-install",
 "--no-interactive",
 "api",
 ],
 )

 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 2
 assert "Incompatible extension combination" in text
 assert "saga" in text


def test_help_mentions_fixture() -> None:
 result = runner.invoke(app, ["--help"])
 assert result.exit_code == 0
 text = (result.stdout or "") + (result.stderr or "")
 assert "fixture" in text.lower()


def test_options_after_project_directory(tmp_path: Path, monkeypatch) -> None:
 """Regression: README-style `cpa my-api --template …` must work.

 Registering a Typer subcommand group made Click treat ``--template`` as a
 COMMAND after the positional project directory.
 """
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 result = runner.invoke(
 app,
 [
 "my-api",
 "--template",
 f"file://{tpl}",
 "--addons",
 "github-setup",
 "--no-install",
 "--no-interactive",
 ],
 )

 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 0, text
 assert "No such command" not in text
 assert captured["project_directory"] == "my-api"
 options = captured["options"]
 assert isinstance(options, dict)
 assert options["template"] == f"file://{tpl}"


def test_expand_variadic_addons_and_extend() -> None:
 from create_awesome_python_app.cli import (
 _expand_variadic_option,
 _preprocess_cli_argv,
 )

 assert _expand_variadic_option(
 ["cpa", "my-api", "--addons", "fastapi-docker", "github-setup", "--no-install"],
 "--addons",
 ) == [
 "cpa",
 "my-api",
 "--addons",
 "fastapi-docker",
 "--addons",
 "github-setup",
 "--no-install",
 ]
 assert _preprocess_cli_argv(
 [
 "cpa",
 "my-api",
 "--template",
 "fastapi-starter",
 "--addons",
 "fastapi-docker",
 "github-setup",
 "--extend",
 "a",
 "b",
 "--no-interactive",
 ]
 ) == [
 "cpa",
 "my-api",
 "--template",
 "fastapi-starter",
 "--addons",
 "fastapi-docker",
 "--addons",
 "github-setup",
 "--extend",
 "a",
 "--extend",
 "b",
 "--no-interactive",
 ]


def test_expand_preserves_trailing_project_directory() -> None:
 """Repeated ``--addons`` with directory last must not swallow the path."""
 from create_awesome_python_app.cli import _preprocess_cli_argv

 assert _preprocess_cli_argv(
 [
 "cpa",
 "--addons",
 "github-setup",
 "--addons",
 "fastapi-docker",
 "/tmp/app",
 ]
 ) == [
 "cpa",
 "--addons",
 "github-setup",
 "--addons",
 "fastapi-docker",
 "/tmp/app",
 ]
 # CI-shaped argv: flags between last addon and directory.
 assert (
 _preprocess_cli_argv(
 [
 "cpa",
 "--template",
 "fastapi-starter",
 "--addons",
 "fastapi-docker",
 "--addons",
 "github-setup",
 "--no-interactive",
 "--no-install",
 "--force",
 "/tmp/app",
 ]
 )[-1]
 == "/tmp/app"
 )
 # Space-separated addons with directory last (no prior positional).
 assert _preprocess_cli_argv(
 ["cpa", "--addons", "fastapi-docker", "github-setup", "/tmp/app"]
 ) == [
 "cpa",
 "--addons",
 "fastapi-docker",
 "--addons",
 "github-setup",
 "/tmp/app",
 ]


def test_expand_preserves_dir_after_template_file_url() -> None:
 """``--template file://…`` must not block peeling a trailing project dir (#245)."""
 from create_awesome_python_app.cli import _preprocess_cli_argv

 # Single addon URL + directory at EOS (scaffold-check / L3 shape).
 assert _preprocess_cli_argv(
 [
 "cpa",
 "--template",
 "file:///tmp/cpa?subdir=templates/fastapi-starter",
 "--no-interactive",
 "--no-install",
 "--addons",
 "file:///tmp/cpa?subdir=extensions/github-setup",
 "/tmp/my-api",
 ]
 ) == [
 "cpa",
 "--template",
 "file:///tmp/cpa?subdir=templates/fastapi-starter",
 "--no-interactive",
 "--no-install",
 "--addons",
 "file:///tmp/cpa?subdir=extensions/github-setup",
 "/tmp/my-api",
 ]
 # Space-separated addons after a file:// template value.
 assert _preprocess_cli_argv(
 [
 "cpa",
 "--template",
 "file:///tmp/x",
 "--addons",
 "fastapi-docker",
 "github-setup",
 "/tmp/app",
 ]
 ) == [
 "cpa",
 "--template",
 "file:///tmp/x",
 "--addons",
 "fastapi-docker",
 "--addons",
 "github-setup",
 "/tmp/app",
 ]
 # Short -t form.
 assert (
 _preprocess_cli_argv(
 [
 "cpa",
 "-t",
 "file:///tmp/x",
 "--addons",
 "github-setup",
 "scaffold-check",
 ]
 )[-1]
 == "scaffold-check"
 )


def test_space_separated_addons_after_project_directory(
 tmp_path: Path, monkeypatch
) -> None:
 """CNA parity: ``--addons fastapi-docker github-setup`` (one flag, many values)."""
 from create_awesome_python_app.cli import _preprocess_cli_argv

 tpl = tmp_path / "tpl"
 tpl.mkdir()
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 argv = _preprocess_cli_argv(
 [
 "cpa",
 "my-api",
 "--template",
 f"file://{tpl}",
 "--addons",
 "fastapi-docker",
 "github-setup",
 "--no-install",
 "--no-interactive",
 ]
 )
 result = runner.invoke(app, argv[1:])

 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 0, text
 assert "unexpected extra argument" not in text.lower()
 options = captured["options"]
 assert isinstance(options, dict)
 addons = options["addons"]
 assert isinstance(addons, list)
 assert len(addons) == 2
 assert any("fastapi-docker" in a for a in addons)
 assert any("github-setup" in a for a in addons)


def test_repeated_addons_with_directory_last(tmp_path: Path, monkeypatch) -> None:
 """``--addons a --addons b <dir>`` must keep ``<dir>`` as project_directory."""
 from create_awesome_python_app.cli import _preprocess_cli_argv

 tpl = tmp_path / "tpl"
 tpl.mkdir()
 target = tmp_path / "app"
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 argv = _preprocess_cli_argv(
 [
 "cpa",
 "--template",
 f"file://{tpl}",
 "--addons",
 "fastapi-docker",
 "--addons",
 "github-setup",
 "--no-install",
 "--no-interactive",
 str(target),
 ]
 )
 result = runner.invoke(app, argv[1:])
 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 0, text
 assert captured["project_directory"] == str(target)
 options = captured["options"]
 assert isinstance(options, dict)
 addons = options["addons"]
 assert isinstance(addons, list)
 assert len(addons) == 2
 assert not any(str(target) in a for a in addons)


def test_preprocess_fixture_argv_bare_and_with_dir() -> None:
 from create_awesome_python_app.cli import _FIXTURE_AUTO, _preprocess_fixture_argv

 assert _preprocess_fixture_argv(["cpa", "--fixture", "--list-templates"]) == [
 "cpa",
 f"--fixture={_FIXTURE_AUTO}",
 "--list-templates",
 ]
 assert _preprocess_fixture_argv(
 ["cpa", "--fixture", "./my-fixtures", "--list-templates"]
 ) == ["cpa", "--fixture", "./my-fixtures", "--list-templates"]


def test_fixture_flag_enables_catalog_fixture(
 tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
 from create_awesome_python_app.cli import _FIXTURE_AUTO, apply_fixture_mode

 apply_fixture_mode(_FIXTURE_AUTO)
 assert os.environ.get("CPA_CATALOG_FIXTURE") == "1"
 assert "CPA_FIXTURE_DIR" not in os.environ

 monkeypatch.delenv("CPA_CATALOG_FIXTURE", raising=False)
 monkeypatch.delenv("CPA_FIXTURE_DIR", raising=False)
 apply_fixture_mode(str(tmp_path))
 assert os.environ.get("CPA_CATALOG_FIXTURE") == "1"
 assert os.environ.get("CPA_FIXTURE_DIR") == str(tmp_path)


def test_list_templates_with_fixture_dir(
 tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
 import json
 import os

 catalog_dir = tmp_path / "fixtures" / "catalog"
 catalog_dir.mkdir(parents=True)
 (catalog_dir / "templates.json").write_text(
 json.dumps(
 {
 "templates": [
 {
 "slug": "fixture-only",
 "category": "tooling",
 "type": "cli",
 }
 ],
 "extensions": [],
 "categories": [],
 }
 ),
 encoding="utf-8",
 )
 monkeypatch.delenv("CPA_CATALOG_FIXTURE", raising=False)
 monkeypatch.delenv("CPA_FIXTURE_DIR", raising=False)

 result = runner.invoke(
 app,
 ["--fixture", str(tmp_path), "--list-templates"],
 )
 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 0, text
 assert "fixture-only" in text
 assert os.environ.get("CPA_CATALOG_FIXTURE") == "1"


def test_non_empty_target_fails_before_scaffold(
 tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
 """Leftover target dir must fail immediately — not after interactive work."""
 target = tmp_path / "existing"
 target.mkdir()
 (target / "leftover.txt").write_text("already here", encoding="utf-8")
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 called: dict[str, bool] = {"create": False}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(*_args, **_kwargs):
 called["create"] = True

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 result = runner.invoke(
 app,
 [
 "--template",
 f"file://{tpl}",
 "--no-install",
 "--no-interactive",
 str(target),
 ],
 )
 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 1, text
 assert "not empty" in text.lower()
 assert "--force" in text
 assert called["create"] is False


def test_non_empty_target_allows_force(
 tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
 target = tmp_path / "existing"
 target.mkdir()
 (target / "leftover.txt").write_text("already here", encoding="utf-8")
 tpl = tmp_path / "tpl"
 tpl.mkdir()
 captured: dict[str, object] = {}

 async def fake_check_for_latest_version(_package_name):
 return None

 async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
 captured["project_directory"] = project_directory
 captured["options"] = options

 monkeypatch.setattr(
 "create_awesome_python_app.cli.check_for_latest_version",
 fake_check_for_latest_version,
 )
 monkeypatch.setattr(
 "create_awesome_python_app.cli.create_python_app",
 fake_create_python_app,
 )

 result = runner.invoke(
 app,
 [
 "--template",
 f"file://{tpl}",
 "--force",
 "--no-install",
 "--no-interactive",
 str(target),
 ],
 )
 text = (result.stdout or "") + (result.stderr or "")
 assert result.exit_code == 0, text
 assert captured["project_directory"] == str(target)
 options = captured["options"]
 assert isinstance(options, dict)
 assert options["force"] is True