fastapi-rtk 2.10.2__tar.gz → 2.11.1__tar.gz

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.10.2
+Version: 2.11.1
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.11.1/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.11.1"

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/fastapi_rtk/backends/generic/filters.py

@@ -64,7 +64,11 @@ class GenericBaseFilter(AbstractBaseFilter[GenericSession]):
             if self.datamodel.is_float(col):
                 return float(value)
             if self.datamodel.is_boolean(col):
-                return value == 1 or value.lower() in ["true", "1"]
+                if isinstance(value, bool):
+                    return value
+                return value == 1 or (
+                    isinstance(value, str) and value.lower() in ["true", "1"]
+                )
             if self.datamodel.is_date(col):
                 return datetime.datetime.fromisoformat(value).date()
             if self.datamodel.is_datetime(col):

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/fastapi_rtk/backends/sqla/filters.py

@@ -42,6 +42,10 @@ __all__ = [
 ]
 
 
+# Oracle needs a length on the CAST target: CAST(x AS VARCHAR2) is ORA-00906.
+_TEXT_CAST_TYPE = sa_types.String().with_variant(sa_types.String(4000), "oracle")
+
+
 class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
     def _get_column(self, col_name: str) -> sqlalchemy.Column:
         """
@@ -121,7 +125,11 @@ class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
             if self.datamodel.is_float(col):
                 return float(value)
             if self.datamodel.is_boolean(col):
-                return value == 1 or value.lower() in ["true", "1"]
+                if isinstance(value, bool):
+                    return value
+                return value == 1 or (
+                    isinstance(value, str) and value.lower() in ["true", "1"]
+                )
             if self.datamodel.is_date(
                 col
             ):  # pragma: no cover - exercised via integration filter tests only
@@ -139,6 +147,28 @@ class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
 
 
 class BaseFilterTextContains(BaseFilter):
+    def _build_concat_expr(self, col_objs: list[sqlalchemy.ColumnElement]):
+        """
+        Concatenate columns as text, separated by a space.
+
+        Chains ``||`` instead of ``concat(*args)``: Oracle's CONCAT takes exactly two
+        arguments and other databases cap function-call args, which wide tables exceed.
+        ``coalesce`` keeps concat's NULL-as-empty.
+
+        Args:
+            col_objs (list[sqlalchemy.ColumnElement]): Columns to concatenate.
+
+        Returns:
+            sqlalchemy.ColumnElement | None: The concatenation, or None when col_objs is empty.
+        """
+        concat_expr = None
+        for col_obj in col_objs:
+            piece = sqlalchemy.func.coalesce(
+                sqlalchemy.cast(col_obj, _TEXT_CAST_TYPE), ""
+            )
+            concat_expr = piece if concat_expr is None else concat_expr + " " + piece
+        return concat_expr
+
     def _handle_relation_contains(self, col: str, value: str):
         sub_col = ""
         if "." in col:
@@ -164,16 +194,14 @@ class BaseFilterTextContains(BaseFilter):
         else:
             # If there is no sub-column, we filter all columns in the relation
             rel_cols = rel_interface.list_columns.keys()
-        concat = []
         rel_obj = rel_interface.obj
         rel_pks = rel_interface.get_pk_attrs()
-        for col_name in rel_cols:
-            col_obj = getattr(rel_obj, col_name)
-            concat.append(sqlalchemy.cast(col_obj, sa_types.String))
-            concat.append(" ")
+        concat_expr = self._build_concat_expr(
+            [getattr(rel_obj, col_name) for col_name in rel_cols]
+        )
         rel_statements = [
             sqlalchemy.select(getattr(rel_obj, pk)).filter(
-                sqlalchemy.func.concat(*concat).ilike("%" + value + "%")
+                concat_expr.ilike("%" + value + "%")
             )
             for pk in rel_pks
         ]
@@ -206,7 +234,7 @@ class BaseFilterTextContains(BaseFilter):
                     if any(value in keywords for keywords in true_keywords)
                     else False
                 )
-        return sqlalchemy.cast(self._cast_column(col), sa_types.String).ilike(
+        return sqlalchemy.cast(self._cast_column(col), _TEXT_CAST_TYPE).ilike(
             "%" + value + "%"
         )
 
@@ -487,9 +515,7 @@ class FilterGlobal(BaseFilterTextContains):
         filters = []
 
         for val in value:
-            # Chain || instead of concat(*args): some databases cap function-call args,
-            # which wide tables exceed. coalesce keeps concat's NULL-as-empty.
-            concat_expr = None
+            concat_cols = []
             rel_filter_arr = []
             for col in cols:
                 if (
@@ -499,13 +525,9 @@ class FilterGlobal(BaseFilterTextContains):
                 ):
                     rel_filter_arr.append(self._handle_text_contains(col, val))
                 elif col in self.datamodel.list_columns:
-                    piece = sqlalchemy.func.coalesce(
-                        sqlalchemy.cast(self._cast_column(col), sa_types.String), ""
-                    )
-                    concat_expr = (
-                        piece if concat_expr is None else concat_expr + " " + piece
-                    )
+                    concat_cols.append(self._cast_column(col))
             params = [*rel_filter_arr]
+            concat_expr = self._build_concat_expr(concat_cols)
             if concat_expr is not None:
                 val = val.strip().lower()
                 params.append(concat_expr.ilike("%" + val + "%"))

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/fastapi_rtk/cli/cli.py

@@ -1,5 +1,6 @@
 import io
 import pathlib
+import re
 import typing
 import zipfile
 
@@ -35,16 +36,26 @@ def callback(
 
 @app.command()
 def create_app(
+    name: typing.Annotated[
+        str,
+        typer.Option(
+            prompt="Project name",
+            help="The name of the new application. Fills the project-name placeholders in the generated files.",
+        ),
+    ],
     directory: typing.Annotated[
         str,
         typer.Option(
-            ...,
             help="The directory where the new FastAPI RTK application will be created.",
         ),
     ] = ".",
 ):
     """
     Create a new FastAPI RTK application with a predefined structure from https://codeberg.org/datatactics/fastapi-rtk-skeleton.
+
+    Args:
+        name (str): The project name; normalized and substituted into the scaffolded project's placeholder files.
+        directory (str): Target directory for the new application. Defaults to the current directory.
     """
     with httpx.Client() as client:
         url = "https://codeberg.org/datatactics/fastapi-rtk-skeleton/archive/main.zip"
@@ -84,8 +95,41 @@ def create_app(
                     with open(target_file, "wb") as f:
                         f.write(source.read())
 
+            _apply_project_name(pathlib.Path(directory), name)
+
             typer.echo(f"FastAPI RTK application skeleton created in {directory}")
 
 
+def _apply_project_name(directory: pathlib.Path, name: str) -> None:
+    """
+    Substitute the skeleton's project-name placeholders with the given name.
+
+    Each placeholder receives the casing its file expects: a slug for the
+    distribution name, upper snake for the config env var, and the raw name for
+    the page title. Missing files are skipped so partial scaffolds do not error.
+
+    Args:
+        directory (pathlib.Path): Root directory of the freshly created application.
+        name (str): Raw project name entered by the user.
+    """
+    raw = name.strip()
+    slug = re.sub(r"[-_.\s]+", "-", raw.lower()).strip("-")
+    env = slug.upper().replace("-", "_")
+    replacements = {
+        "pyproject.toml": [("project-name", slug)],
+        "requirements.txt": [("project-name", slug)],
+        "app/__init__.py": [("PROJECTNAME", env)],
+        "webapp/index.html": [("YOUR_APP_NAME_HERE", raw)],
+    }
+    for relative_path, subs in replacements.items():
+        target = directory / relative_path
+        if not target.exists():
+            continue
+        content = target.read_text(encoding="utf-8")
+        for placeholder, value in subs:
+            content = content.replace(placeholder, value)
+        target.write_text(content, encoding="utf-8")
+
+
 def main():
     app()

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/fastapi_rtk/security/sqla/models.py

@@ -122,7 +122,9 @@ class Api(Model):
     id: Mapped[int] = mapped_column(
         sqlalchemy.Integer, sqlalchemy.Sequence(API_SEQUENCE), primary_key=True
     )
-    name: Mapped[str] = mapped_column(sqlalchemy.String, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(
+        sqlalchemy.String(256), unique=True, nullable=False
+    )
 
     permissions: Mapped[list[PermissionApi]] = relationship(
         PermissionApi, back_populates="api", cascade="all, delete-orphan"
@@ -143,7 +145,9 @@ class Permission(Model):
     id: Mapped[int] = mapped_column(
         sqlalchemy.Integer, sqlalchemy.Sequence(PERMISSION_SEQUENCE), primary_key=True
     )
-    name: Mapped[str] = mapped_column(sqlalchemy.String, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(
+        sqlalchemy.String(256), unique=True, nullable=False
+    )
 
     apis: Mapped[list[PermissionApi]] = relationship(
         PermissionApi, back_populates="permission", cascade="all, delete-orphan"
@@ -158,7 +162,9 @@ class Role(Model):
     id: Mapped[int] = mapped_column(
         sqlalchemy.Integer, sqlalchemy.Sequence(ROLE_SEQUENCE), primary_key=True
     )
-    name: Mapped[str] = mapped_column(sqlalchemy.String, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(
+        sqlalchemy.String(256), unique=True, nullable=False
+    )
 
     users: Mapped[list["User"]] = relationship(
         "User", secondary=assoc_user_role, back_populates="roles"

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/tests/unit/backends/generic/test_filters.py

@@ -1,7 +1,6 @@
 import datetime
 
 import pytest
-
 from fastapi_rtk.backends.generic.column import GenericColumn
 from fastapi_rtk.backends.generic.filters import (
     GenericBaseFilter,
@@ -109,6 +108,18 @@ class TestCastValue:
         f = GenericFilterEqual(StubInterface({"flag": bool}))
         assert f._cast_value("flag", 1) is True
 
+    def test_boolean_cast_native_true(self, caplog):
+        f = GenericFilterEqual(StubInterface({"flag": bool}))
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("flag", True) is True
+        assert not any("Failed to cast" in r.message for r in caplog.records)
+
+    def test_boolean_cast_native_false(self, caplog):
+        f = GenericFilterEqual(StubInterface({"flag": bool}))
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("flag", False) is False
+        assert not any("Failed to cast" in r.message for r in caplog.records)
+
     def test_date_cast(self):
         f = GenericFilterEqual(StubInterface({"d": datetime.date}))
         assert f._cast_value("d", "2024-01-15") == datetime.date(2024, 1, 15)

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/tests/unit/backends/sqla/test_filters.py

@@ -188,6 +188,18 @@ class TestCastValue:
         f = FilterEqual(iface)
         assert f._cast_value("active", "false") is False
 
+    def test_boolean_native_true(self, iface, caplog):
+        f = FilterEqual(iface)
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("active", True) is True
+        assert not caplog.records
+
+    def test_boolean_native_false(self, iface, caplog):
+        f = FilterEqual(iface)
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("active", False) is False
+        assert not caplog.records
+
 
 class TestSQLAFilterConverter:
     def test_conversion_table_present(self):
@@ -555,3 +567,51 @@ class TestSqlaFiltersCastValueExtras:
         out = f._cast_value("col", [1, 2, 3])
         # Recursive: list of casted values
         assert out == ["1", "2", "3"]
+
+
+class TestOracleDialectCompilation:
+    def test_global_filter_casts_with_varchar2_length(self, session, WideRow_cls):
+        from sqlalchemy.dialects import oracle
+
+        from fastapi_rtk.backends.sqla.filters import FilterGlobal
+
+        iface = SQLAInterface(WideRow_cls)
+        f = FilterGlobal(iface)
+        stmt = f.apply(sqlalchemy.select(iface.obj), list(iface.list_columns), "needle")
+
+        compiled = str(stmt.compile(dialect=oracle.dialect()))
+        assert "AS VARCHAR2(4000 CHAR)" in compiled
+        assert "AS VARCHAR2)" not in compiled
+        assert "concat(" not in compiled.lower()
+
+    def test_text_contains_casts_with_varchar2_length(self, Person_cls):
+        from sqlalchemy.dialects import oracle
+
+        iface = SQLAInterface(Person_cls)
+        f = FilterTextContains(iface)
+        stmt = f.apply(sqlalchemy.select(iface.obj), "name", "alice")
+
+        compiled = str(stmt.compile(dialect=oracle.dialect()))
+        assert "AS VARCHAR2(4000 CHAR)" in compiled
+        assert "AS VARCHAR2)" not in compiled
+
+    def test_relation_contains_avoids_multi_arg_concat(self, Person_cls):
+        from sqlalchemy.dialects import oracle
+
+        iface = SQLAInterface(Person_cls)
+        f = FilterTextContains(iface)
+        stmt = f.apply(sqlalchemy.select(iface.obj), "country", "usa")
+
+        compiled = str(stmt.compile(dialect=oracle.dialect()))
+        assert "concat(" not in compiled.lower()
+        assert "AS VARCHAR2(4000 CHAR)" in compiled
+
+    def test_non_oracle_dialect_keeps_length_less_cast(self, Person_cls):
+        from sqlalchemy.dialects import postgresql
+
+        iface = SQLAInterface(Person_cls)
+        f = FilterTextContains(iface)
+        stmt = f.apply(sqlalchemy.select(iface.obj), "name", "alice")
+
+        compiled = str(stmt.compile(dialect=postgresql.dialect()))
+        assert "AS VARCHAR)" in compiled

fastapi_rtk-2.11.1/tests/unit/cli/test_cli.py

@@ -0,0 +1,172 @@
+"""Tier 14 - tests for fastapi_rtk.cli.cli (top-level Typer app)."""
+
+import io
+import unittest.mock
+import zipfile
+
+import typer.testing
+from fastapi_rtk.cli.cli import app, main
+from fastapi_rtk.version import __version__
+
+runner = typer.testing.CliRunner()
+
+
+def _build_skeleton_zip(
+    *, with_naked_root_entry: bool = False, with_placeholders: bool = True
+) -> bytes:
+    """Synthetic skeleton archive that mimics the layout of the upstream zip."""
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        if with_naked_root_entry:
+            # Triggers the empty-target_path continue branch
+            zf.writestr("skeleton-main", "")
+        zf.writestr("skeleton-main/", "")
+        zf.writestr("skeleton-main/README.md", "# skeleton")
+        if with_placeholders:
+            zf.writestr("skeleton-main/pyproject.toml", 'name = "project-name"\n')
+            zf.writestr(
+                "skeleton-main/requirements.txt",
+                "# via project-name (pyproject.toml)\n",
+            )
+            zf.writestr(
+                "skeleton-main/app/__init__.py", 'ENV_VAR = "PROJECTNAME_CONFIG"\n'
+            )
+            zf.writestr(
+                "skeleton-main/webapp/index.html", "<title>YOUR_APP_NAME_HERE</title>\n"
+            )
+        zf.writestr("skeleton-main/app/", "")
+        zf.writestr("skeleton-main/app/main.py", "print('ok')")
+    return buf.getvalue()
+
+
+def _fake_client(zip_bytes: bytes):
+    """Build a drop-in httpx.Client replacement serving a fixed zip archive."""
+
+    class FakeResponse:
+        content = zip_bytes
+
+        def raise_for_status(self):
+            pass
+
+    class FakeClient:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            pass
+
+        def get(self, url):
+            return FakeResponse()
+
+    return FakeClient
+
+
+class TestHelp:
+    def test_help_returns_zero(self):
+        result = runner.invoke(app, ["--help"])
+        assert result.exit_code == 0
+
+    def test_help_shows_create_app(self):
+        result = runner.invoke(app, ["--help"])
+        assert "create-app" in result.output
+
+
+class TestVersion:
+    def test_version_returns_zero(self):
+        result = runner.invoke(app, ["--version"])
+        assert result.exit_code == 0
+
+    def test_version_shows_version_string(self):
+        result = runner.invoke(app, ["--version"])
+        assert __version__ in result.output
+
+
+class TestCreateAppHelp:
+    def test_create_app_help(self):
+        result = runner.invoke(app, ["create-app", "--help"])
+        assert result.exit_code == 0
+        assert "directory" in result.output.lower()
+
+    def test_create_app_help_shows_name(self):
+        result = runner.invoke(app, ["create-app", "--help"])
+        assert "name" in result.output.lower()
+
+
+class TestCreateAppExtraction:
+    def test_create_app_extracts_skeleton(self, tmp_path):
+        zip_bytes = _build_skeleton_zip()
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app, ["create-app", "--name", "demo", "--directory", str(tmp_path)]
+            )
+        assert result.exit_code == 0, result.output
+        assert (tmp_path / "README.md").exists()
+        assert (tmp_path / "app" / "main.py").exists()
+        assert "skeleton created" in result.output
+
+    def test_create_app_handles_naked_root_entry(self, tmp_path):
+        zip_bytes = _build_skeleton_zip(with_naked_root_entry=True)
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app, ["create-app", "--name", "demo", "--directory", str(tmp_path)]
+            )
+        assert result.exit_code == 0, result.output
+        assert (tmp_path / "README.md").exists()
+
+
+class TestCreateAppProjectName:
+    def test_create_app_substitutes_all_placeholders(self, tmp_path):
+        zip_bytes = _build_skeleton_zip()
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app,
+                ["create-app", "--name", "My Cool App", "--directory", str(tmp_path)],
+            )
+        assert result.exit_code == 0, result.output
+        assert 'name = "my-cool-app"' in (tmp_path / "pyproject.toml").read_text()
+        assert "my-cool-app" in (tmp_path / "requirements.txt").read_text()
+        assert (
+            'ENV_VAR = "MY_COOL_APP_CONFIG"'
+            in (tmp_path / "app" / "__init__.py").read_text()
+        )
+        assert (
+            "<title>My Cool App</title>"
+            in (tmp_path / "webapp" / "index.html").read_text()
+        )
+
+    def test_create_app_prompts_for_name(self, tmp_path):
+        zip_bytes = _build_skeleton_zip()
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app,
+                ["create-app", "--directory", str(tmp_path)],
+                input="prompted-app\n",
+            )
+        assert result.exit_code == 0, result.output
+        assert 'name = "prompted-app"' in (tmp_path / "pyproject.toml").read_text()
+
+    def test_create_app_without_placeholders_is_noop(self, tmp_path):
+        zip_bytes = _build_skeleton_zip(with_placeholders=False)
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app, ["create-app", "--name", "demo", "--directory", str(tmp_path)]
+            )
+        assert result.exit_code == 0, result.output
+        assert not (tmp_path / "pyproject.toml").exists()
+
+
+class TestMain:
+    def test_main_invokes_app(self):
+        with unittest.mock.patch("fastapi_rtk.cli.cli.app") as mock_app:
+            main()
+            mock_app.assert_called_once()

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.1}/tests/unit/security/sqla/test_models.py

@@ -250,3 +250,10 @@ class TestPermissionApiPersist:
         assert pa.id is not None
         assert pa.permission.name == "can_edit"
         assert pa.api.name == "WidgetApi"
+
+
+class TestColumnLengths:
+    def test_name_columns_have_explicit_length(self):
+        # Oracle rejects a length-less VARCHAR2 in DDL (ORA-00906).
+        for model in (Api, Permission, Role):
+            assert model.__table__.c.name.type.length == 256

fastapi_rtk-2.10.2/fastapi_rtk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.10.2"

fastapi_rtk-2.10.2/tests/unit/cli/test_cli.py

@@ -1,117 +0,0 @@
-"""Tier 14 - tests for fastapi_rtk.cli.cli (top-level Typer app)."""
-
-import io
-import unittest.mock
-import zipfile
-
-import typer.testing
-
-from fastapi_rtk.cli.cli import app, main
-from fastapi_rtk.version import __version__
-
-runner = typer.testing.CliRunner()
-
-
-def _build_skeleton_zip(*, with_naked_root_entry: bool = False) -> bytes:
-    """Synthetic skeleton archive that mimics the layout of the upstream zip."""
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, "w") as zf:
-        if with_naked_root_entry:
-            # Triggers the empty-target_path continue branch
-            zf.writestr("skeleton-main", "")
-        zf.writestr("skeleton-main/", "")
-        zf.writestr("skeleton-main/README.md", "# skeleton")
-        zf.writestr("skeleton-main/app/", "")
-        zf.writestr("skeleton-main/app/main.py", "print('ok')")
-    return buf.getvalue()
-
-
-class TestHelp:
-    def test_help_returns_zero(self):
-        result = runner.invoke(app, ["--help"])
-        assert result.exit_code == 0
-
-    def test_help_shows_create_app(self):
-        result = runner.invoke(app, ["--help"])
-        assert "create-app" in result.output
-
-
-class TestVersion:
-    def test_version_returns_zero(self):
-        result = runner.invoke(app, ["--version"])
-        assert result.exit_code == 0
-
-    def test_version_shows_version_string(self):
-        result = runner.invoke(app, ["--version"])
-        assert __version__ in result.output
-
-
-class TestCreateAppHelp:
-    def test_create_app_help(self):
-        result = runner.invoke(app, ["create-app", "--help"])
-        assert result.exit_code == 0
-        assert "directory" in result.output.lower()
-
-
-class TestCreateAppExtraction:
-    def test_create_app_extracts_skeleton(self, tmp_path):
-        # Mock httpx.Client to return a fake zip archive so the command
-        # exercises its extraction logic without hitting the network.
-        zip_bytes = _build_skeleton_zip()
-
-        class FakeResponse:
-            content = zip_bytes
-
-            def raise_for_status(self):
-                pass
-
-        class FakeClient:
-            def __enter__(self):
-                return self
-
-            def __exit__(self, *a):
-                pass
-
-            def get(self, url):
-                return FakeResponse()
-
-        with unittest.mock.patch("fastapi_rtk.cli.cli.httpx.Client", FakeClient):
-            result = runner.invoke(app, ["create-app", "--directory", str(tmp_path)])
-        assert result.exit_code == 0, result.output
-        assert (tmp_path / "README.md").exists()
-        assert (tmp_path / "app" / "main.py").exists()
-        assert "skeleton created" in result.output
-
-    def test_create_app_handles_naked_root_entry(self, tmp_path):
-        # Some zip producers list the top-level dir without a trailing slash;
-        # exercise the empty-target_path skip branch.
-        zip_bytes = _build_skeleton_zip(with_naked_root_entry=True)
-
-        class FakeResponse:
-            content = zip_bytes
-
-            def raise_for_status(self):
-                pass
-
-        class FakeClient:
-            def __enter__(self):
-                return self
-
-            def __exit__(self, *a):
-                pass
-
-            def get(self, url):
-                return FakeResponse()
-
-        with unittest.mock.patch("fastapi_rtk.cli.cli.httpx.Client", FakeClient):
-            result = runner.invoke(app, ["create-app", "--directory", str(tmp_path)])
-        assert result.exit_code == 0, result.output
-        assert (tmp_path / "README.md").exists()
-
-
-class TestMain:
-    def test_main_invokes_app(self):
-        # main() calls app() under typer; verify it's a callable that runs.
-        with unittest.mock.patch("fastapi_rtk.cli.cli.app") as mock_app:
-            main()
-            mock_app.assert_called_once()