cave-cli 3.6.0b1__tar.gz → 3.6.0b2__tar.gz

{cave_cli-3.6.0b1/cave_cli.egg-info → cave_cli-3.6.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cave_cli
-Version: 3.6.0b1
+Version: 3.6.0b2
 Summary: CLI for creating and managing Docker-based CAVE web applications.
 Author-email: MIT-CAVE <cave-contact@mit.edu>
 License: Apache-2.0

{cave_cli-3.6.0b1 → cave_cli-3.6.0b2}/cave_cli/commands/upgrade.py

@@ -60,45 +60,85 @@ def migrate_3_6_0(app_dir: str) -> None:
     if version_file.exists():
         version_file.unlink()
 
-    # Collect cave_api requirements before moving the directory
-    cave_api_requirements = []
+    # Move cave_core/models.py to legacy/cave_core/models.py if it exists
+    models_file = app_path / "cave_core" / "models.py"
+    if models_file.exists():
+        try:
+            legacy_cave_core = legacy_dir / "cave_core"
+            legacy_cave_core.mkdir(exist_ok=True)
+            shutil.move(models_file, legacy_cave_core / "models.py")
+        except Exception as e:
+            logger.warn(f"Failed to move cave_core/models.py to legacy/cave_core/models.py: {e}")
+
+    # Collect api requirements from cave_api/requirements.txt and cave_api/pyproject.toml
+    # before moving/restructuring the cave_api directory
+    api_requirements = []
+    
+    # 1. Pull from cave_api/requirements.txt
     cave_api_req = app_path / "cave_api" / "requirements.txt"
     if cave_api_req.exists():
         try:
-            cave_api_requirements.extend(cave_api_req.read_text().splitlines())
+            for line in cave_api_req.read_text().splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    api_requirements.append(line)
         except Exception as e:
-            logger.warning(f"Failed to read cave_api requirements: {e}")
+            logger.warn(f"Failed to read cave_api requirements: {e}")
 
-    # Update pyproject.toml with cave_api optional dependencies
-    pyproject_path = app_path / "pyproject.toml"
-    if cave_api_requirements and pyproject_path.exists():
+    # 2. Pull from cave_api/pyproject.toml
+    cave_api_pyproject = app_path / "cave_api" / "pyproject.toml"
+    if cave_api_pyproject.exists():
         try:
-            with open(pyproject_path, "rb") as f:
-                content = f.read()
-                pyproject = tomllib.load(f)
+            with open(cave_api_pyproject, "rb") as f:
+                cave_api_pyproject_data = tomllib.loads(f.read().decode())
+            deps = cave_api_pyproject_data.get("project", {}).get("dependencies", [])
+            for dep in deps:
+                dep = dep.strip()
+                if dep and dep not in api_requirements:
+                    api_requirements.append(dep)
+        except Exception as e:
+            logger.warn(f"Failed to read cave_api pyproject.toml: {e}")
 
-            existing_deps = pyproject.get("project", {}).get("dependencies", [])
-            new_deps = [req for req in cave_api_requirements if req not in existing_deps]
+    # Deduplicate requirements while preserving order
+    seen = set()
+    cleaned_requirements = []
+    for req in api_requirements:
+        if req not in seen:
+            seen.add(req)
+            cleaned_requirements.append(req)
 
-            if new_deps:
-                deps_str = "\n".join(f'  "{dep}",' for dep in new_deps)
-                cave_api_block = f'\n[project.optional-dependencies]\ncave_api = [\n{deps_str}\n]\n'
+    # Update pyproject.toml optional-dependencies.api section
+    pyproject_path = app_path / "pyproject.toml"
+    if cleaned_requirements and pyproject_path.exists():
+        try:
+            with open(pyproject_path, "rb") as f:
+                content_bytes = f.read()
+            content = content_bytes.decode()
 
-                if "[project.optional-dependencies]" in content.decode():
+            deps_str = "\n".join(f'  "{dep}",' for dep in cleaned_requirements)
+            
+            if "[project.optional-dependencies]" in content:
+                if re.search(r"api\s*=\s*\[", content):
                     content = re.sub(
-                        r'(\[project\.optional-dependencies\].*?cave_api\s*=\s*\[)[^\]]*(\])',
-                        f'\\1\n{deps_str}\n\\2',
-                        content.decode(),
+                        r"(api\s*=\s*\[)[^\]]*(\])",
+                        f"\\1\n{deps_str}\n\\2",
+                        content,
                         flags=re.DOTALL
-                    ).encode()
+                    )
                 else:
-                    content = content + cave_api_block.encode()
+                    content = re.sub(
+                        r"(\[project\.optional-dependencies\])",
+                        f"\\1\napi = [\n{deps_str}\n]",
+                        content
+                    )
+            else:
+                content += f'\n[project.optional-dependencies]\napi = [\n{deps_str}\n]\n'
 
-                with open(pyproject_path, "wb") as f:
-                    f.write(content)
+            with open(pyproject_path, "wb") as f:
+                f.write(content.encode())
 
         except Exception as e:
-            logger.warning(f"Failed to update pyproject.toml: {e}")
+            logger.warn(f"Failed to update pyproject.toml: {e}")
 
     # Move cave_api/tests/ to top-level tests/ before restructuring cave_api
     cave_api_tests = app_path / "cave_api" / "tests"
@@ -117,7 +157,7 @@ def migrate_3_6_0(app_dir: str) -> None:
         shutil.move(cave_api, legacy_cave_api)
         shutil.copytree(legacy_cave_api / "cave_api", cave_api)
     else:
-        logger.warning("Expected cave_api/cave_api directory not found, skipping API migration steps.")
+        logger.warn("Expected cave_api/cave_api directory not found, skipping API migration steps.")
 
     # Update code references, skipping legacy/ and tool directories
     for py_file in app_path.rglob("*.py"):
@@ -140,7 +180,7 @@ def migrate_3_6_0(app_dir: str) -> None:
             if new_content != content:
                 py_file.write_text(new_content)
         except Exception as e:
-            logger.warning(f"Failed to migrate code in {py_file}: {e}")
+            logger.warn(f"Failed to migrate code in {py_file}: {e}")
 
     step_done("Applying 3.6.0 Migrations")
 
@@ -157,7 +197,24 @@ def upgrade(args: argparse.Namespace) -> None:
     version = getattr(args, "version", None)
     skip_env_upgrade = getattr(args, "skip_env_upgrade", False)
 
+    # Collect existing api optional dependencies
+    api_deps = []
+    pyproject_path = os.path.join(app_dir, "pyproject.toml")
+    if os.path.exists(pyproject_path):
+        try:
+            import tomllib
+            with open(pyproject_path, "rb") as f:
+                pyproject = tomllib.load(f)
+            api_deps = pyproject.get("project", {}).get("optional-dependencies", {}).get("api", [])
+        except Exception:
+            pass
+
     current_v = get_app_version(app_dir)
+    current_version = version_tuple(current_v)
+    is_pre_3_6 = (
+        (current_version and current_version < (3, 6, 0)) or
+        (not current_version and os.path.exists(os.path.join(app_dir, "requirements.txt")))
+    )
     target_v = version or "main"
 
     temp_dir = None
@@ -193,9 +250,40 @@ def upgrade(args: argparse.Namespace) -> None:
 
     sync_cmd(sync_args, do_reset=False)
 
-    current_version = version_tuple(current_v)
+    if api_deps and os.path.exists(pyproject_path):
+        try:
+            with open(pyproject_path, "r") as f:
+                content = f.read()
+
+            deps_list_str = "\n".join(f'    "{dep}",' for dep in api_deps)
+
+            if "[project.optional-dependencies]" in content:
+                if re.search(r"api\s*=\s*\[", content):
+                    content = re.sub(
+                        r"(api\s*=\s*\[)[^\]]*(\])",
+                        f"\\1\n{deps_list_str}\n  \\2",
+                        content,
+                        flags=re.DOTALL,
+                    )
+                else:
+                    content = re.sub(
+                        r"(\[project\.optional-dependencies\])",
+                        f"\\1\napi = [\n{deps_list_str}\n]",
+                        content,
+                    )
+            else:
+                content += (
+                    f"\n[project.optional-dependencies]\napi = [\n{deps_list_str}\n]\n"
+                )
+
+            with open(pyproject_path, "w") as f:
+                f.write(content)
+            logger.info("Preserved 'api' optional dependencies in pyproject.toml")
+        except Exception as e:
+            logger.warn(f"Failed to preserve 'api' optional dependencies: {e}")
+
     target_version = version_tuple(target_v)
-    if current_version and target_version and current_version < (3, 6, 0) <= target_version:
+    if is_pre_3_6 and target_version and target_version >= (3, 6, 0):
         should_migrate = confirm_action(
             "Upgrading to 3.6.0 requires structural changes to your codebase "
             "(directory layout, import paths, and dependency files). "
@@ -229,7 +317,7 @@ def upgrade(args: argparse.Namespace) -> None:
 
     remove_licence_info(app_dir)
 
-    step_start("Updating LLM docs")
+    step_start("Updating API docs")
     docs_args = argparse.Namespace(
         entrypoint="./utils/generate_docs.sh",
         interactive=False,
@@ -241,6 +329,6 @@ def upgrade(args: argparse.Namespace) -> None:
         loglevel=getattr(args, "loglevel", "INFO"),
     )
     run_cave(app_dir, app_name, docs_args)
-    step_done("Updating LLM docs")
+    step_done("Updating API docs")
 
     logger.success("Upgrade complete.")

{cave_cli-3.6.0b1 → cave_cli-3.6.0b2}/cave_cli/utils/sync.py

@@ -6,6 +6,24 @@ from pathlib import Path
 from cave_cli.utils.logger import logger
 
 
+def can_create_symlinks() -> bool:
+    """
+    Check if the current user/OS environment has permission to create symbolic links.
+    On Windows, this requires Developer Mode or Administrator privileges.
+    """
+    import tempfile
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp_file = os.path.join(tmpdir, "file")
+            tmp_link = os.path.join(tmpdir, "link")
+            with open(tmp_file, "w") as f:
+                f.write("")
+            os.symlink(tmp_file, tmp_link)
+            return True
+    except OSError:
+        return False
+
+
 def sync_files(
     source: str,
     dest: str,
@@ -50,6 +68,8 @@ def sync_files(
     clean_excludes = [strip_quotes(p) for p in (excludes or [])]
     clean_excludes.append(".git")
 
+    symlinks_supported = can_create_symlinks()
+
     def ignore_fn(directory: str, contents: list[str]) -> set[str]:
         rel_dir = os.path.relpath(directory, source)
         ignored: set[str] = set()
@@ -58,14 +78,33 @@ def sync_files(
                 rel_path = name
             else:
                 rel_path = os.path.join(rel_dir, name)
-            if matches_any(rel_path, name, clean_includes):
-                continue
-            if matches_any(rel_path, name, clean_excludes):
-                ignored.add(name)
+            
+            is_ignored = False
+            if not matches_any(rel_path, name, clean_includes):
+                if matches_any(rel_path, name, clean_excludes):
+                    ignored.add(name)
+                    is_ignored = True
+            
+            if not is_ignored:
+                # If we are syncing this file/directory, resolve any conflicts at the destination.
+                dst_path = os.path.join(dest, rel_path)
+                if os.path.lexists(dst_path):
+                    src_path = os.path.join(directory, name)
+                    # If both are concrete directories, let shutil.copytree's dirs_exist_ok merge them.
+                    # Otherwise (file vs file, link vs file, etc.), we must remove the destination path
+                    # first to avoid conflicts and FileExistsError (especially when copying symbolic links).
+                    is_src_dir = os.path.isdir(src_path) and not os.path.islink(src_path)
+                    is_dst_dir = os.path.isdir(dst_path) and not os.path.islink(dst_path)
+                    if not (is_src_dir and is_dst_dir):
+                        if is_dst_dir:
+                            shutil.rmtree(dst_path)
+                        else:
+                            os.unlink(dst_path)
+                            
         return ignored
 
     shutil.copytree(
-        source, dest, ignore=ignore_fn, dirs_exist_ok=True
+        source, dest, ignore=ignore_fn, dirs_exist_ok=True, symlinks=symlinks_supported
     )
 
 

{cave_cli-3.6.0b1 → cave_cli-3.6.0b2}/cave_cli/utils/validate.py

@@ -84,7 +84,16 @@ def validate_app_dir(path: str) -> list[str]:
     p = Path(path)
     errors: list[str] = []
 
-    if not (p / "manage.py").is_file() or not (p / "cave_core").is_dir():
+    # Check if the directory has any characteristic CAVE project elements.
+    # If not, we immediately return "Not a CAVE app directory" to avoid printing
+    # unrelated errors for completely different directories when searching up the tree.
+    is_cave_candidate = (
+        (p / "manage.py").is_file()
+        or (p / "cave_core").is_dir()
+        or (p / "cave_api").is_dir()
+        or (p / "cave_app").is_dir()
+    )
+    if not is_cave_candidate:
         return ["Not a CAVE app directory"]
 
     for folder in ("cave_api", "cave_app", "cave_core"):
@@ -114,7 +123,6 @@ def validate_app_dir(path: str) -> list[str]:
             "One of these must be present in the root project directory."
         )
 
-
     env_path = p / ".env"
     if env_path.is_file():
         from cave_cli.utils.env import parse_env
@@ -133,9 +141,6 @@ def validate_app_dir(path: str) -> list[str]:
                     "should be removed from the '.env' file."
                 )
 
-    if not (p / "Dockerfile").is_file():
-        errors.append("No Dockerfile found in current directory.")
-
     return errors
 
 
@@ -159,13 +164,15 @@ def find_app_dir(start: str | None = None) -> str:
         - What: The absolute path to the CAVE app directory
     """
     path = Path(start or os.getcwd()).resolve()
+    start_path = path
     while True:
         errors = validate_app_dir(str(path))
         if not errors:
             return str(path)
         parent = path.parent
         if parent == path:
-            for err in errors:
+            start_errors = validate_app_dir(str(start_path))
+            for err in start_errors:
                 logger.error(err)
             logger.error("Ensure you are in a valid CAVE app directory")
             sys.exit(1)

{cave_cli-3.6.0b1 → cave_cli-3.6.0b2/cave_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cave_cli
-Version: 3.6.0b1
+Version: 3.6.0b2
 Summary: CLI for creating and managing Docker-based CAVE web applications.
 Author-email: MIT-CAVE <cave-contact@mit.edu>
 License: Apache-2.0

{cave_cli-3.6.0b1 → cave_cli-3.6.0b2}/cave_cli.egg-info/SOURCES.txt

@@ -43,5 +43,6 @@ cave_cli/utils/version.py
 test/test_env.py
 test/test_net.py
 test/test_sync.py
+test/test_upgrade.py
 test/test_validate.py
 utils/prettify.py

{cave_cli-3.6.0b1 → cave_cli-3.6.0b2}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cave_cli"
-version = "3.6.0b1"
+version = "3.6.0b2"
 description = "CLI for creating and managing Docker-based CAVE web applications."
 authors = [
     {name = "MIT-CAVE", email = "cave-contact@mit.edu"}

cave_cli-3.6.0b2/test/test_sync.py

@@ -0,0 +1,116 @@
+import pytest
+from cave_cli.utils.sync import strip_quotes, matches_any, sync_files
+
+
+class TestStripQuotes:
+    def test_single_quotes(self):
+        assert strip_quotes("'hello'") == "hello"
+
+    def test_double_quotes(self):
+        assert strip_quotes('"hello"') == "hello"
+
+    def test_no_quotes(self):
+        assert strip_quotes("hello") == "hello"
+
+    def test_mismatched_quotes(self):
+        assert strip_quotes("'hello\"") == "'hello\""
+
+    def test_strips_whitespace(self):
+        assert strip_quotes("  'hello'  ") == "hello"
+
+    def test_empty_quoted(self):
+        assert strip_quotes("''") == ""
+
+
+class TestMatchesAny:
+    def test_name_wildcard(self):
+        assert matches_any("subdir/file.py", "file.py", ["*.py"])
+
+    def test_rel_path_match(self):
+        assert matches_any("subdir/file.txt", "file.txt", ["subdir/*"])
+
+    def test_no_match(self):
+        assert not matches_any("file.txt", "file.txt", ["*.py"])
+
+    def test_empty_patterns(self):
+        assert not matches_any("file.txt", "file.txt", [])
+
+    def test_git_directory(self):
+        assert matches_any(".git", ".git", [".git"])
+
+    def test_exact_rel_path(self):
+        assert matches_any("docs/readme.md", "readme.md", ["docs/readme.md"])
+
+
+class TestSyncFiles:
+    def test_sync_files_preserves_and_overwrites_symlinks(self, tmp_path):
+        import os
+
+        src = tmp_path / "src"
+        dst = tmp_path / "dst"
+        src.mkdir()
+        dst.mkdir()
+
+        # Create source structure:
+        # target.txt (file)
+        # link.txt (symlink -> target.txt)
+        # file.txt (file)
+        # dir_to_file (file)
+        with open(src / "target.txt", "w") as f:
+            f.write("target content")
+        os.symlink("target.txt", src / "link.txt")
+        with open(src / "file.txt", "w") as f:
+            f.write("new file content")
+        with open(src / "dir_to_file", "w") as f:
+            f.write("new file content replacing directory")
+
+        # Create destination structure:
+        # link.txt (regular file)
+        # file.txt (symlink -> other)
+        # dir_to_file (directory)
+        with open(dst / "link.txt", "w") as f:
+            f.write("old regular file")
+        with open(dst / "other.txt", "w") as f:
+            f.write("other")
+        os.symlink("other.txt", dst / "file.txt")
+        (dst / "dir_to_file").mkdir()
+
+        sync_files(str(src), str(dst))
+
+        assert os.path.islink(dst / "link.txt")
+        assert os.readlink(dst / "link.txt") == "target.txt"
+        assert not os.path.islink(dst / "file.txt")
+        assert (dst / "file.txt").read_text() == "new file content"
+        assert not os.path.islink(dst / "dir_to_file")
+        assert not os.path.isdir(dst / "dir_to_file")
+        assert (dst / "dir_to_file").read_text() == "new file content replacing directory"
+
+    def test_can_create_symlinks(self):
+        from cave_cli.utils.sync import can_create_symlinks
+        res = can_create_symlinks()
+        assert isinstance(res, bool)
+
+    def test_sync_files_fallback_when_symlinks_unsupported(self, tmp_path, monkeypatch):
+        import os
+        import cave_cli.utils.sync
+        from cave_cli.utils.sync import sync_files
+
+        monkeypatch.setattr(cave_cli.utils.sync, "can_create_symlinks", lambda: False)
+
+        src = tmp_path / "src"
+        dst = tmp_path / "dst"
+        src.mkdir()
+        dst.mkdir()
+
+        # Create source structure:
+        # target.txt (file)
+        # link.txt (symlink -> target.txt)
+        with open(src / "target.txt", "w") as f:
+            f.write("target content")
+        os.symlink("target.txt", src / "link.txt")
+
+        sync_files(str(src), str(dst))
+
+        # Because symlinks are unsupported, dst/link.txt should be created as a regular file with the content of target.txt.
+        assert not os.path.islink(dst / "link.txt")
+        assert (dst / "link.txt").read_text() == "target content"

cave_cli-3.6.0b2/test/test_upgrade.py

@@ -0,0 +1,60 @@
+import os
+import shutil
+from pathlib import Path
+from cave_cli.commands.upgrade import migrate_3_6_0
+
+
+def test_migrate_3_6_0_renames_models_file(tmp_path):
+    # Set up directory layout
+    app_dir = tmp_path / "app"
+    app_dir.mkdir()
+
+    # Create cave_core directory and models.py
+    cave_core_dir = app_dir / "cave_core"
+    cave_core_dir.mkdir()
+    models_file = cave_core_dir / "models.py"
+    models_file.write_text("class MyModel:")
+
+    # Create requirements.txt
+    req_file = app_dir / "requirements.txt"
+    req_file.write_text("numpy\npandas")
+
+    # Create VERSION file to verify it gets removed
+    version_file = app_dir / "VERSION"
+    version_file.write_text("3.5.0")
+
+    # Create root pyproject.toml
+    pyproject_file = app_dir / "pyproject.toml"
+    pyproject_file.write_text("[project]\nname = 'myapp'\nversion = '1.0.0'\ndependencies = []\n")
+
+    # Create cave_api directory
+    cave_api_dir = app_dir / "cave_api"
+    cave_api_dir.mkdir()
+
+    # Create cave_api/requirements.txt
+    cave_api_req = cave_api_dir / "requirements.txt"
+    cave_api_req.write_text("requests>=2.0.0\n# comment\npytest\n")
+
+    # Create cave_api/pyproject.toml
+    cave_api_pyproject = cave_api_dir / "pyproject.toml"
+    cave_api_pyproject.write_text("[project]\ndependencies = [\n  'pytest',\n  'django>=4.0'\n]\n")
+
+    # Run migration
+    migrate_3_6_0(str(app_dir))
+
+    # Assertions
+    assert not models_file.exists()
+    legacy_dir = app_dir / "legacy"
+    assert (legacy_dir / "cave_core" / "models.py").exists()
+    assert (legacy_dir / "cave_core" / "models.py").read_text() == "class MyModel:"
+    assert not version_file.exists()
+    assert not req_file.exists()
+    assert (legacy_dir / "requirements.txt").exists()
+    assert (legacy_dir / "requirements.txt").read_text() == "numpy\npandas"
+
+    # Assert that pyproject.toml has merged api dependencies
+    pyproject_content = pyproject_file.read_text()
+    assert "[project.optional-dependencies]" in pyproject_content
+    assert '"requests>=2.0.0"' in pyproject_content
+    assert '"pytest"' in pyproject_content
+    assert '"django>=4.0"' in pyproject_content

cave_cli-3.6.0b2/test/test_validate.py

@@ -0,0 +1,103 @@
+import pytest
+from cave_cli.utils.validate import validate_app_name
+
+
+class TestValidateAppName:
+    def test_valid_simple(self):
+        assert validate_app_name("myapp") is None
+
+    def test_valid_with_hyphen(self):
+        assert validate_app_name("my-app") is None
+
+    def test_valid_with_underscore(self):
+        assert validate_app_name("my_app") is None
+
+    def test_valid_with_numbers(self):
+        assert validate_app_name("app123") is None
+
+    def test_too_short(self):
+        assert validate_app_name("a") is not None
+
+    def test_uppercase_rejected(self):
+        assert validate_app_name("MyApp") is not None
+
+    def test_starts_with_hyphen(self):
+        assert validate_app_name("-myapp") is not None
+
+    def test_starts_with_underscore(self):
+        assert validate_app_name("_myapp") is not None
+
+    def test_ends_with_hyphen(self):
+        assert validate_app_name("myapp-") is not None
+
+    def test_ends_with_underscore(self):
+        assert validate_app_name("myapp_") is not None
+
+    def test_hyphen_followed_by_underscore(self):
+        assert validate_app_name("my-_app") is not None
+
+    def test_underscore_followed_by_hyphen(self):
+        assert validate_app_name("my_-app") is not None
+
+    def test_spaces_rejected(self):
+        assert validate_app_name("my app") is not None
+
+    def test_too_long(self):
+        assert validate_app_name("a" * 256) is not None
+
+    def test_max_valid_length(self):
+        assert validate_app_name("a" * 255) is None
+
+
+class TestValidateAppDir:
+    def test_not_a_candidate(self, tmp_path):
+        from cave_cli.utils.validate import validate_app_dir
+        # Completely empty dir
+        res = validate_app_dir(str(tmp_path))
+        assert res == ["Not a CAVE app directory"]
+
+    def test_candidate_missing_folders_files(self, tmp_path):
+        from cave_cli.utils.validate import validate_app_dir
+        # Contains manage.py, so it is a candidate
+        (tmp_path / "manage.py").write_text("")
+        
+        res = validate_app_dir(str(tmp_path))
+        assert any("The folder 'cave_core' is missing" in err for err in res)
+        assert any("The folder 'cave_api' is missing" in err for err in res)
+        assert any("The file 'Dockerfile' is missing" in err for err in res)
+        assert any("Neither 'requirements.txt' nor 'pyproject.toml' exists." in err for err in res)
+
+    def test_find_app_dir_reports_starting_dir_errors(self, tmp_path, monkeypatch):
+        import sys
+        from cave_cli.utils.validate import find_app_dir
+        
+        # We start in a directory that has manage.py (so it's a candidate) but is missing other things.
+        start_dir = tmp_path / "my_app"
+        start_dir.mkdir()
+        (start_dir / "manage.py").write_text("")
+        
+        # We'll mock sys.exit and logger to verify that when it reaches the root,
+        # it prints the errors of the starting directory start_dir.
+        logged_errors = []
+        class MockLogger:
+            def error(self, msg):
+                logged_errors.append(msg)
+        
+        import cave_cli.utils.validate
+        monkeypatch.setattr(cave_cli.utils.validate, "logger", MockLogger())
+        
+        exit_called = False
+        def mock_exit(code):
+            nonlocal exit_called
+            exit_called = True
+            raise SystemExit(code)
+            
+        monkeypatch.setattr(sys, "exit", mock_exit)
+        
+        with pytest.raises(SystemExit):
+            find_app_dir(str(start_dir))
+            
+        assert exit_called
+        # Check that it printed errors about start_dir (e.g. missing cave_core)
+        any_missing_core = any("The folder 'cave_core' is missing" in err for err in logged_errors)
+        assert any_missing_core

cave_cli-3.6.0b1/test/test_sync.py

@@ -1,42 +0,0 @@
-import pytest
-from cave_cli.utils.sync import strip_quotes, matches_any
-
-
-class TestStripQuotes:
-    def test_single_quotes(self):
-        assert strip_quotes("'hello'") == "hello"
-
-    def test_double_quotes(self):
-        assert strip_quotes('"hello"') == "hello"
-
-    def test_no_quotes(self):
-        assert strip_quotes("hello") == "hello"
-
-    def test_mismatched_quotes(self):
-        assert strip_quotes("'hello\"") == "'hello\""
-
-    def test_strips_whitespace(self):
-        assert strip_quotes("  'hello'  ") == "hello"
-
-    def test_empty_quoted(self):
-        assert strip_quotes("''") == ""
-
-
-class TestMatchesAny:
-    def test_name_wildcard(self):
-        assert matches_any("subdir/file.py", "file.py", ["*.py"])
-
-    def test_rel_path_match(self):
-        assert matches_any("subdir/file.txt", "file.txt", ["subdir/*"])
-
-    def test_no_match(self):
-        assert not matches_any("file.txt", "file.txt", ["*.py"])
-
-    def test_empty_patterns(self):
-        assert not matches_any("file.txt", "file.txt", [])
-
-    def test_git_directory(self):
-        assert matches_any(".git", ".git", [".git"])
-
-    def test_exact_rel_path(self):
-        assert matches_any("docs/readme.md", "readme.md", ["docs/readme.md"])

cave_cli-3.6.0b1/test/test_validate.py

@@ -1,49 +0,0 @@
-import pytest
-from cave_cli.utils.validate import validate_app_name
-
-
-class TestValidateAppName:
-    def test_valid_simple(self):
-        assert validate_app_name("myapp") is None
-
-    def test_valid_with_hyphen(self):
-        assert validate_app_name("my-app") is None
-
-    def test_valid_with_underscore(self):
-        assert validate_app_name("my_app") is None
-
-    def test_valid_with_numbers(self):
-        assert validate_app_name("app123") is None
-
-    def test_too_short(self):
-        assert validate_app_name("a") is not None
-
-    def test_uppercase_rejected(self):
-        assert validate_app_name("MyApp") is not None
-
-    def test_starts_with_hyphen(self):
-        assert validate_app_name("-myapp") is not None
-
-    def test_starts_with_underscore(self):
-        assert validate_app_name("_myapp") is not None
-
-    def test_ends_with_hyphen(self):
-        assert validate_app_name("myapp-") is not None
-
-    def test_ends_with_underscore(self):
-        assert validate_app_name("myapp_") is not None
-
-    def test_hyphen_followed_by_underscore(self):
-        assert validate_app_name("my-_app") is not None
-
-    def test_underscore_followed_by_hyphen(self):
-        assert validate_app_name("my_-app") is not None
-
-    def test_spaces_rejected(self):
-        assert validate_app_name("my app") is not None
-
-    def test_too_long(self):
-        assert validate_app_name("a" * 256) is not None
-
-    def test_max_valid_length(self):
-        assert validate_app_name("a" * 255) is None