scooped 1.0.0__tar.gz

scooped-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,67 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: CI
+
+on:
+  push:
+    branches: [ "main", "develop" ]
+  pull_request:
+    branches: [ "main", "develop" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+    - uses: actions/checkout@v6
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+        
+    - name: Set up UV
+      uses: astral-sh/setup-uv@v8.1.0
+      
+    - name: Install dependencies
+      run: uv sync
+      
+    - name: Lint
+      run: uv run ruff check .
+      
+    - name: Test with pytest
+      run: |
+        uv run pytest \
+            --junitxml=test-results.xml \
+            --html=report.html \
+            --self-contained-html \
+            --cov=. \
+            --cov-report=term-missing \
+            --cov-report=xml \
+            --cov-report=html
+            
+    - name: Upload test reports
+      uses: actions/upload-artifact@v7
+      if: always()
+      with:
+        name: test-reports
+        path: |
+          report.html
+          test-results.xml
+        if-no-files-found: warn
+        
+    - name: Upload coverage report
+      uses: actions/upload-artifact@v7
+      if: always()
+      with:
+        name: coverage-reports
+        path: |
+          coverage.xml
+          htmlcov/
+        if-no-files-found: warn

scooped-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,38 @@
+name: Release
+
+on:
+    push:
+        tags:
+            - v*
+
+jobs:
+    publish:
+
+        name: Publish to PyPI
+        runs-on: ubuntu-latest
+
+        concurrency:
+            group: release
+            cancel-in-progress: false
+
+        environment:
+            name: pypi
+
+        permissions:
+            id-token: write
+            contents: read
+
+        steps:
+            - uses: actions/checkout@v6
+
+            - name: Setup Python
+              uses: astral-sh/setup-uv@v8.1.0
+            
+            - name: Build
+              run: uv build
+
+            - name: Test
+              run: uv run pytest
+
+            - name: Publish
+              run: uv publish

scooped-1.0.0/.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Pytest
+.coverage
+htmlcov

scooped-1.0.0/.python-version

@@ -0,0 +1 @@
+3.12

scooped-1.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: scooped
+Version: 1.0.0
+Summary: A CLI for project setup from generalised templates
+Author-email: ArchmagePsy <SeaOfCodeSi@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: fire>=0.7.1
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: platformdirs>=4.9.6
+Requires-Dist: pydantic-settings>=2.14.1
+Requires-Dist: rich>=15.0.0
+Description-Content-Type: text/markdown
+
+# Scooped
+
+A generalised project generation command using jinja2 templates
+
+## Why the name 'Scooped'?
+
+To be 'scooped' is a slang term used to explain when you discover that an idea you have had has been previously explored by someone else. This project was originally called 'stencil' the idea being that you could create templates and use them to generate boilerplate projects and save time, the same way you would use a stencil to save you time and effort drawing a shape: precise and consistent results with minimal effort. As it turns out, when I attempted to publish my project to PyPI someone else had already had a similar idea to mine *15 years ago* with unfortunately the exact same name. Because I am proud of the tool I have written and believe it fills a different (albeit **very** similar) niche I have decided to stick with it and rename it to 'scooped' a nod to this hilariously embarrassing situation.

scooped-1.0.0/README.md

@@ -0,0 +1,7 @@
+# Scooped
+
+A generalised project generation command using jinja2 templates
+
+## Why the name 'Scooped'?
+
+To be 'scooped' is a slang term used to explain when you discover that an idea you have had has been previously explored by someone else. This project was originally called 'stencil' the idea being that you could create templates and use them to generate boilerplate projects and save time, the same way you would use a stencil to save you time and effort drawing a shape: precise and consistent results with minimal effort. As it turns out, when I attempted to publish my project to PyPI someone else had already had a similar idea to mine *15 years ago* with unfortunately the exact same name. Because I am proud of the tool I have written and believe it fills a different (albeit **very** similar) niche I have decided to stick with it and rename it to 'scooped' a nod to this hilariously embarrassing situation.

scooped-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "scooped"
+version = "1.0.0"
+description = "A CLI for project setup from generalised templates"
+readme = "README.md"
+authors = [
+    { name = "ArchmagePsy", email = "SeaOfCodeSi@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "fire>=0.7.1",
+    "jinja2>=3.1.6",
+    "platformdirs>=4.9.6",
+    "pydantic-settings>=2.14.1",
+    "rich>=15.0.0",
+]
+
+[project.scripts]
+scooped = "scooped:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+    "pytest-cov>=7.1.0",
+    "pytest-html>=4.2.0",
+    "pytest-mock>=3.15.1",
+    "ruff>=0.15.14",
+]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "B"]
+ignore = ["E501"]
+unfixable = ["B"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["E402"]
+"**/{tests,docs,tools}/*" = ["E402"]
+
+[tool.ruff.format]
+quote-style = "single"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

scooped-1.0.0/src/scooped/__init__.py

@@ -0,0 +1,7 @@
+from scooped.cli.app import App
+
+import fire
+
+
+def main() -> None:
+    fire.Fire(App)

scooped-1.0.0/src/scooped/cli/app.py

@@ -0,0 +1,209 @@
+from pathlib import Path, PurePosixPath
+from typing import Dict, Optional
+from io import BytesIO
+from zipfile import ZipFile
+from platformdirs import PlatformDirs
+from jinja2 import Environment
+from pydantic import ValidationError
+from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, TomlConfigSettingsSource
+from rich.progress import Progress
+from rich import print as rich_print
+
+import urllib.request
+import os
+import tomllib
+import re
+
+from scooped.cli.ui import TemplateRowData, create_template_table, render_temlplate_data_row
+from scooped.cli.util import ProjectNameFormat, Provider, ZipLoader, excluded, find_scooped_config
+from scooped.models.settings import ScoopedSettings
+from scooped.models.metadata import TemplateMetadata
+
+class App:
+
+    def __init__(self, platform_dirs: Optional[PlatformDirs] = None):
+        self.platform_dirs = platform_dirs or PlatformDirs("scooped", "ArchmagePsy", ensure_exists=True)
+        os.makedirs(self.platform_dirs.user_data_path / "templates", exist_ok=True)
+
+        config_path = self.platform_dirs.user_config_path / "config.toml"
+
+        class Settings(BaseSettings):
+            scooped: ScoopedSettings = ScoopedSettings()
+
+            @classmethod    
+            def settings_customise_sources(cls, settings_cls: type[BaseSettings], 
+                                           init_settings: PydanticBaseSettingsSource, 
+                                           env_settings: PydanticBaseSettingsSource, 
+                                           dotenv_settings: PydanticBaseSettingsSource, 
+                                           file_secret_settings: PydanticBaseSettingsSource,) -> tuple[PydanticBaseSettingsSource, ...]:
+                return (
+                    init_settings,
+                    env_settings,
+                    dotenv_settings,
+                    file_secret_settings,
+                    TomlConfigSettingsSource(settings_cls, toml_file=config_path),
+                )
+
+        self.settings = Settings()
+
+    def install(self, repository: Optional[str] = None, url: Optional[str] = None, branch: str = "main", provider: Optional[Provider] = None):
+        """
+        Install a project template from the web
+        """
+        provider = provider or self.settings.scooped.install.default_provider or Provider.NONE
+        provider = Provider(provider)
+
+        if provider is Provider.NONE:
+            if url is None:
+                raise ValueError("You must provide a URL if no provider is set")
+
+        elif provider is Provider.GITHUB:
+            if repository is None or "/" not in repository:
+                raise ValueError("You must provide a repository in the format 'owner/repository' for this provider")
+
+            url = f"https://github.com/{repository}/archive/refs/heads/{branch}.zip"
+
+        with urllib.request.urlopen(url) as response:
+            total = int(response.headers.get("Content-Length", 0))
+
+            archive_bytes = BytesIO()
+
+            with Progress() as progress:
+                task = progress.add_task(f"Downloading from {url}", total=total)
+
+                while not progress.finished:
+                    chunk = response.read(self.settings.scooped.install.chunk_size)
+
+                    if not chunk:
+                        break
+
+                    archive_bytes.write(chunk)
+                    progress.update(task, advance=len(chunk))
+
+            archive = ZipFile(archive_bytes)
+        
+            if len(set(PurePosixPath(path).parts[0] for path in archive.namelist())) > 1 or not (config_file_path := find_scooped_config(archive)) :
+                raise FileNotFoundError("Repository is not a proper scooped template as there is no single directory at the root containing a 'scooped.toml' file")
+            
+            with archive.open(config_file_path.as_posix()) as config_file:
+                template_config = tomllib.load(config_file)
+
+            template_metadata = TemplateMetadata(**template_config["template"])
+
+            if os.path.exists(template_output_path := (self.platform_dirs.user_data_path / f"templates/{template_metadata.name}.zip")):
+                raise FileExistsError(f"A template with this name already exists: {template_metadata.name}")
+            
+            with open(template_output_path, "wb") as template_file:
+                template_file.write(archive_bytes.getbuffer())
+
+
+    def create(self, template_name: str, destination: Optional[str] = None, project_name: Optional[str] = None, project_name_format: Optional[ProjectNameFormat] = None, **parameters: Dict[str, str]):
+        """
+        Create a new project from an installed template
+        """
+        project_name_format = project_name_format or self.settings.scooped.create.default_project_name_format or ProjectNameFormat.NONE
+        project_name_format = ProjectNameFormat(project_name_format)
+
+        if destination is None and project_name is None:
+            raise ValueError("You must provide a project name and/or a destination to infer the project name from")
+
+        elif project_name is None:
+            project_name = os.path.basename(destination)
+
+        elif destination is None:
+            project_name = project_name_format.format(project_name)
+            os.mkdir(project_name)
+            destination = os.path.join(os.getcwd(), project_name)
+
+        else:
+            project_name = project_name_format.format(project_name)
+        
+        with ZipFile(self.platform_dirs.user_data_path / f"templates/{template_name}.zip") as archive:
+            if len(set(PurePosixPath(path).parts[0] for path in archive.namelist())) > 1 or not (root_config_path := find_scooped_config(archive)) :
+                raise FileNotFoundError("Not a valid scooped template as there is no single directory at the root containing a 'scooped.toml' file")
+
+            with archive.open(root_config_path.as_posix()) as root_config_file:
+                root_config = tomllib.load(root_config_file)
+
+            template_metadata = TemplateMetadata(**root_config["template"])
+
+            env = Environment(loader=ZipLoader(archive))
+            env.globals.update({key: value for key, value in root_config.items() if key not in ["template"]})
+            env.globals.update(**parameters)
+            env.globals.update({"project_name": project_name, "project_name_format": project_name_format})
+
+            with Progress() as progress:
+                task = progress.add_task(f"Creating project [blue]{project_name}[/blue] from template [blue]{template_metadata.name}[/blue]", total=None)
+
+                for member in archive.infolist():
+                    if excluded(member.filename, "*/scooped.toml", "**/scooped.toml", *template_metadata.ignore):
+                        continue
+
+                    path = PurePosixPath(member.filename)
+
+                    if member.is_dir():
+                        continue
+
+                    parts = path.parts[1:]
+
+                    if not parts:
+                        continue
+
+                    target_path = PurePosixPath(destination).joinpath(*parts)
+
+                    os.makedirs(target_path.parent.as_posix(), exist_ok=True)
+                    progress.update(task, advance=1, description=f"Creatig parent directories [yellow]{target_path.parent.as_posix()}[/yellow]")
+
+                    if member.filename.endswith((".j2", ".jinja", ".jinja2")):
+                        with open(re.sub(r"(.j2|.jinja|.jinja2)$", "", target_path.as_posix()), "w") as dst:
+                            template = env.get_template(member.filename)
+                            dst.write(template.render())
+                            progress.update(task, advance=1, description=f"Rendering [yellow]{member.filename}[/yellow]")
+                            
+                    else:
+                        with archive.open(member) as src, open(target_path.as_posix(), "wb") as dst:
+                            dst.write(src.read())
+                            progress.update(task, advance=1, description=f"Extracting [yellow]{member.filename}[/yellow]")
+
+                progress.update(task, total=1, completed=1)
+
+    def list(self):
+        """
+        List all installed templates
+        """
+        template_table = create_template_table("Installed Templates", "templates you have installed with scooped under " + str(self.platform_dirs.user_data_path / "templates/"))
+        
+        for path in os.listdir(self.platform_dirs.user_data_path / "templates"):
+            path = str(self.platform_dirs.user_data_path / f"templates/{path}")
+            if path.endswith(".zip"):
+                
+                try:
+                    
+                    with ZipFile(path) as archive:
+                        if (root_config_path := find_scooped_config(archive)) is not None:
+                            with archive.open(root_config_path.as_posix(), "r") as root_config_file:
+                                root_config = tomllib.load(root_config_file)
+                                metadata = TemplateMetadata(**root_config["template"])
+                                template_row_data = TemplateRowData(valid=True, **{key: value for key, value in metadata.model_dump().items() if key in TemplateRowData.columns()})
+                        else:
+                            raise FileNotFoundError("No 'scooped.toml' found at the root directory")
+                        
+                except FileNotFoundError:
+                    template_row_data = TemplateRowData(valid=False, name=f"{Path(path).stem}(?)", description="invalid template, no configuration file found")
+
+                except ValidationError:
+                    template_row_data = TemplateRowData(valid=False, name=f"{Path(path).stem}(?)", description="invalid template, configuration file invalid")
+
+                except (PermissionError, OSError):
+                    template_row_data = TemplateRowData(valid=False, name=f"{Path(path).stem}(?)", description="invalid template, could not read")
+
+                template_table.add_row(*render_temlplate_data_row(template_row_data))
+
+        rich_print(template_table)
+
+    def remove(self, template_name: str):
+        """
+        Remove an installed template
+        """
+        if os.path.exists(template_path := (self.platform_dirs.user_data_path / f"templates/{template_name}.zip")):
+            os.remove(template_path)

scooped-1.0.0/src/scooped/cli/ui.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+from rich.text import Text
+from rich.style import Style
+from rich.table import Table
+from rich import box
+
+@dataclass
+class TemplateRowData:
+    name: str
+    valid: bool
+    author: Optional[str] = None
+    description: Optional[str] = None
+
+    @staticmethod
+    def columns() -> Tuple[str]:
+        return ("name", "author", "description", "valid",)
+
+class TemplateValidBadge:
+
+    VALID_COLOR = "green"
+    INVALID_COLOR = "red"
+    VALID_MARK = ":heavy_check_mark:"
+    INVALID_MARK = ":cross_mark:"
+
+    def __init__(self, valid: bool):
+        self.valid = valid
+
+    def __rich__(self):
+        if self.valid:
+            color = TemplateValidBadge.VALID_COLOR
+            mark = TemplateValidBadge.VALID_MARK
+        
+        else:
+            color = TemplateValidBadge.INVALID_COLOR
+            mark = TemplateValidBadge.INVALID_MARK
+
+        return Text.from_markup(mark, style=Style(color=color, encircle=True, bold=True), justify="center")
+    
+def render_temlplate_data_row(data: TemplateRowData) -> Tuple:
+    return (data.name, data.author, data.description, TemplateValidBadge(data.valid),)
+
+def create_template_table(title: str, caption: str) -> Table:
+    return Table(*TemplateRowData.columns(), 
+                 title=title,
+                 title_style=Style.null(),
+                 title_justify="center",
+                 caption=caption,
+                 caption_style=Style.null(),
+                 caption_justify="left",
+                 box=box.SIMPLE)

scooped-1.0.0/src/scooped/cli/util.py

@@ -0,0 +1,51 @@
+from enum import Enum
+from pathlib import PurePosixPath
+from typing import Callable, Tuple
+from zipfile import ZipFile
+import fnmatch
+import re
+
+from jinja2 import BaseLoader, TemplateNotFound
+
+
+def find_scooped_config(archive: ZipFile) -> PurePosixPath | None:
+    return next((path for path in map(PurePosixPath, archive.namelist()) if len(path.parts) == 2 and path.parts[1] == "scooped.toml"), None)
+
+def excluded(path, *patterns) -> bool:
+    return any(fnmatch.fnmatch(path, pattern) for pattern in patterns)
+
+class ZipLoader(BaseLoader):
+    def __init__(self, archive: ZipFile):
+        self.archive = archive
+
+        self.files = {
+            name: name for name in self.archive.namelist()
+            if not name.endswith("/")
+        }
+
+    def get_source(self, environment, template) -> Tuple[str, str, Callable[[], bool]]:
+        if template not in self.files:
+            raise TemplateNotFound(template)
+
+        source = self.archive.read(template).decode()
+
+        return source, template, lambda: True
+
+class ProjectNameFormat(Enum):
+    KEBAB = "kebab"
+    PASCAL = "pascal"
+    NONE = "none"
+
+    def format(self, project_name: str) -> str:
+        if self is ProjectNameFormat.KEBAB:
+            return re.sub(r"\s+", "-", project_name.lower())
+        
+        elif self is ProjectNameFormat.PASCAL:
+            return "".join([part.capitaize() for part in project_name.split()])
+        
+        else:
+            return project_name
+        
+class Provider(Enum):
+    GITHUB = "github"
+    NONE = "none"

scooped-1.0.0/src/scooped/models/metadata.py

@@ -0,0 +1,9 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+
+class TemplateMetadata(BaseModel):
+    name: str
+    author: Optional[str] = None
+    description: Optional[str] = None
+    ignore: List[str] = []

scooped-1.0.0/src/scooped/models/settings.py

@@ -0,0 +1,16 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from scooped.cli.util import ProjectNameFormat, Provider
+
+
+class InstallSettings(BaseModel):
+    chunk_size: int = 8192
+    default_provider: Optional[Provider] = Field(default=None, alias="provider")
+
+class CreateSettings(BaseModel):
+    default_project_name_format: Optional[ProjectNameFormat] = Field(default=None, alias="project-name-format")
+
+class ScoopedSettings(BaseModel):
+    install: InstallSettings = InstallSettings()
+    create: CreateSettings = CreateSettings()

scooped-1.0.0/tests/conftest.py

@@ -0,0 +1,41 @@
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from platformdirs import PlatformDirs
+import threading
+import pytest
+
+
+@pytest.fixture(scope="session")
+def file_server():
+    test_files_dir = Path(__file__).parent / "resources"
+
+    class Handler(SimpleHTTPRequestHandler):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, directory=str(test_files_dir), **kwargs)
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+
+    host, port = server.server_address
+
+    yield f"http://{host}:{port}"
+
+    server.shutdown()
+    thread.join()
+
+@pytest.fixture
+def temp_dir(tmp_path_factory):
+    base = tmp_path_factory.mktemp("test-app-data")
+
+    class FakeDirs(PlatformDirs):
+        @property
+        def user_data_path(self):
+            return base
+        
+        @property
+        def user_config_path(self):
+            return base
+
+    return FakeDirs("scooped", "ArchmagePsy")

scooped-1.0.0/tests/resources/missing_name_template/scooped.toml

@@ -0,0 +1,2 @@
+[template]
+description = "A template that is missing a name"

scooped-1.0.0/tests/resources/test_template/scooped.toml

@@ -0,0 +1,13 @@
+[template]
+name = "TestTemplate"
+author = "ArchmagePsy"
+description = "A simple template used in the scooped tests"
+ignore = [
+    ".venv/*", 
+    ".idea/*", 
+    ".vscode/*",
+    "*.ignore*"
+]
+
+[user]
+name = "World"

scooped-1.0.0/tests/resources/test_template/test.txt.ignore

@@ -0,0 +1 @@
+This should never appear in the generated project!

scooped-1.0.0/tests/resources/test_template/test.txt.j2

@@ -0,0 +1 @@
+Hello {{ user.name }}!

scooped-1.0.0/tests/test_cli.py

@@ -0,0 +1,129 @@
+from pathlib import Path
+import shutil
+import os
+from unittest.mock import ANY, Mock
+import pytest
+
+from scooped.cli.app import App
+from scooped.cli.ui import TemplateValidBadge
+from scooped.cli.util import Provider
+
+
+@pytest.fixture
+def app(temp_dir) -> App:
+    return App(platform_dirs=temp_dir)
+
+@pytest.fixture
+def install_template(temp_dir):
+    shutil.copy(Path(__file__).parent / "resources/test_template.zip", temp_dir.user_data_path / "templates/TestTemplate.zip")
+
+@pytest.fixture
+def install_missing_config_template(temp_dir):
+    shutil.copy(Path(__file__).parent / "resources/bad_test_template.zip", temp_dir.user_data_path / "templates/BadTemplate.zip")
+
+@pytest.fixture
+def install_missing_name_template(temp_dir):
+    shutil.copy(Path(__file__).parent / "resources/missing_name_template.zip", temp_dir.user_data_path / "templates/MissingNameTemplate.zip")
+
+@pytest.fixture
+def project_dir(tmp_path_factory) -> Path:
+    return tmp_path_factory.mktemp("test-projects")
+
+@pytest.fixture
+def table_add_row_mock(mocker) -> Mock:
+    return mocker.patch("scooped.cli.ui.Table.add_row")
+
+@pytest.fixture
+def zip_permissions_mock(mocker) -> Mock:
+    return mocker.patch("scooped.cli.app.ZipFile", side_effect=PermissionError())
+
+def test_install_template_success(app, file_server):
+    app.install(url=f"{file_server}/test_template.zip", provider=None)
+    
+    assert os.path.exists(app.platform_dirs.user_data_path / "templates/TestTemplate.zip")
+
+def test_install_template_already_installed(app, file_server):
+    app.install(url=f"{file_server}/test_template.zip", provider=None)
+
+    with pytest.raises(FileExistsError):
+        app.install(url=f"{file_server}/test_template.zip", provider=None)
+
+def test_install_template_without_config(app, file_server):
+    with pytest.raises(FileNotFoundError):
+        app.install(url=f"{file_server}/bad_test_template.zip", provider=None)
+
+def test_install_template_from_bad_repository_name(app, file_server):
+    with pytest.raises(ValueError, match="repository in the format 'owner/repository' for this provider"):
+        app.install(repository="bad-repository-name", provider=Provider.GITHUB)
+
+def test_install_template_without_url(app, file_server):
+    with pytest.raises(ValueError, match="URL if no provider is set"):
+        app.install(provider=None)
+
+def test_create_from_template(app, install_template, project_dir):
+    os.chdir(project_dir)
+    app.create(template_name="TestTemplate", project_name="my test project")
+
+    assert (test_txt_path := Path(project_dir) / "my test project/test.txt").exists()
+    assert not (Path(project_dir) / "my test project/test.txt.ignore").exists()
+    assert not (Path(project_dir) / "my test project/scooped.toml").exists()
+    assert test_txt_path.read_text() == "Hello World!"
+
+def test_create_from_template_and_existing_directory(app, install_template, project_dir):
+    project_path = project_dir / "my-test-project2"
+    project_path.mkdir()
+    os.chdir(project_path)
+
+    app.create(template_name="TestTemplate", destination=".")
+
+    assert (test_txt_path := Path(project_dir) / "my-test-project2/test.txt").exists()
+    assert not (Path(project_dir) / "my-test-project2/test.txt.ignore").exists()
+    assert test_txt_path.read_text() == "Hello World!"
+
+def test_create_from_bad_template(app, install_missing_config_template, project_dir):
+    os.chdir(project_dir)
+
+    with pytest.raises(FileNotFoundError):
+        app.create(template_name="BadTemplate", project_name="my-bad-project")
+
+def test_create_no_project_name_or_destination(app, install_template, project_dir):
+    os.chdir(project_dir)
+
+    with pytest.raises(ValueError):
+        app.create(template_name="TestTemplate")
+
+def test_list(app, install_template, table_add_row_mock):
+    app.list()
+
+    table_add_row_mock.assert_called_once()
+    table_add_row_mock.assert_called_with("TestTemplate", "ArchmagePsy", "A simple template used in the scooped tests", ANY)
+    badge = table_add_row_mock.call_args.args[3]
+    assert isinstance(badge, TemplateValidBadge)
+    assert badge.valid
+
+def test_list_template_missing_config(app, install_missing_config_template, table_add_row_mock):    
+    app.list()
+
+    table_add_row_mock.assert_called_once()
+    table_add_row_mock.assert_called_with("BadTemplate(?)", None, "invalid template, no configuration file found", ANY)
+    badge = table_add_row_mock.call_args.args[3]
+    assert isinstance(badge, TemplateValidBadge)
+    assert not badge.valid
+
+def test_list_template_missing_metadata(app, install_missing_name_template, table_add_row_mock):    
+    app.list()
+
+    table_add_row_mock.assert_called_once()
+    table_add_row_mock.assert_called_with("MissingNameTemplate(?)", None, "invalid template, configuration file invalid", ANY)
+    badge = table_add_row_mock.call_args.args[3]
+    assert isinstance(badge, TemplateValidBadge)
+    assert not badge.valid
+
+def test_list_template_invalid_permissions(app, install_template, table_add_row_mock, zip_permissions_mock):    
+    app.list()
+
+    table_add_row_mock.assert_called_once()
+    table_add_row_mock.assert_called_with("TestTemplate(?)", None, "invalid template, could not read", ANY)
+    badge = table_add_row_mock.call_args.args[3]
+    assert isinstance(badge, TemplateValidBadge)
+    assert not badge.valid