faas-gitops 0.2.1__tar.gz → 0.3.0__tar.gz

{faas_gitops-0.2.1/src/faas_gitops.egg-info → faas_gitops-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: faas-gitops
-Version: 0.2.1
+Version: 0.3.0
 Summary: Declarative GitOps for FaaS
 Requires-Python: >=3.12
 Requires-Dist: aiofiles>=23.0

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "faas-gitops"
-version = "0.2.1"
+version = "0.3.0"
 description = "Declarative GitOps for FaaS"
 requires-python = ">=3.12"
 dependencies = [

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/adapters/bizy_function_provider.py

@@ -29,3 +29,10 @@ class BizyFunctionProvider:
             name=meta.get("functionName"),
             tags=meta.get("tags"),
         )
+
+    async def list_deployments(self, func_id: str) -> list[dict]:
+        result = await self._p.list_deployments(function_id=func_id)
+        return [dict(d) for d in (result.data.data or []) if d is not None]
+
+    async def deploy_version(self, func_id: str, deployment_id: str, version: str) -> None:
+        await self._p.deploy(version=version, function_id=func_id, deployment_id=deployment_id)

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/cli/app.py

@@ -12,11 +12,12 @@ from faas_gitops.adapters.bizy_function_provider import BizyFunctionProvider
 from faas_gitops.adapters.bizy_template_provider import BizyTemplateProvider
 from faas_gitops.adapters.git_cli_gateway import GitCliGateway
 from faas_gitops.cli.parser import build_parser
-from faas_gitops.cli.presenters import print_apply_report, print_drift_report
+from faas_gitops.cli.presenters import print_apply_report, print_deploy_report, print_drift_report
 from faas_gitops.config import load_settings
 from faas_gitops.models import ApplyResult
 from faas_gitops.usecases.apply_function_changes import ApplyFunctionChanges
 from faas_gitops.usecases.apply_template_changes import ApplyTemplateChanges
+from faas_gitops.usecases.deploy_functions import DeployFunctions
 from faas_gitops.usecases.detect_function_drift import DetectFunctionDrift
 from faas_gitops.usecases.detect_template_drift import DetectTemplateDrift
 from faas_gitops.usecases.render_definitions import render_definitions
@@ -95,10 +96,16 @@ async def async_main() -> int:
             faas = await _make_faas(stack)
             git = _make_git()
             repo_path = await git.clone_repo(repo_slug)
+            dry_run = getattr(args, "dry_run", False)
             result = await ApplyFunctionChanges(BizyFunctionProvider(faas), settings).run(
-                repo_path, dry_run=getattr(args, "dry_run", False), repo_slug=repo_slug,
+                repo_path, dry_run=dry_run, repo_slug=repo_slug,
             )
-            return print_apply_report(result, getattr(args, "dry_run", False))
+            if not dry_run and result.applied_versions:
+                deploy_result = await DeployFunctions(BizyFunctionProvider(faas), settings).run(
+                    result.applied_versions, repo_path
+                )
+                print_deploy_report(deploy_result)
+            return print_apply_report(result, dry_run)
 
     logger.warning(f"unknown command: {args.command}")
     return 1

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/cli/presenters.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from loguru import logger
 
-from faas_gitops.models import ApplyResult, DriftResult
+from faas_gitops.models import ApplyResult, DeployResult, DriftResult
 
 
 def print_drift_report(result: DriftResult) -> int:
@@ -28,3 +28,14 @@ def print_apply_report(result: ApplyResult, dry_run: bool = False) -> int:
     for name, err in result.failed:
         logger.warning(f"  ! {name}: {err}")
     return 1 if result.failed else 0
+
+
+def print_deploy_report(result: DeployResult) -> int:
+    logger.info(f"deployed={len(result.deployed)} skipped={len(result.skipped)} failed={len(result.failed)}")
+    for n in result.deployed:
+        logger.info(f"  → {n}")
+    for n in result.skipped:
+        logger.info(f"  = {n}")
+    for name, err in result.failed:
+        logger.warning(f"  ! {name}: {err}")
+    return 1 if result.failed else 0

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/layout.py

@@ -10,3 +10,4 @@ FUNCTION_BASE = "base.yaml"
 FUNCTION_DEFINITION = "definition.yaml"
 FUNCTION_FILES = (FUNCTION_META, FUNCTION_BASE, FUNCTION_DEFINITION)
 FUNCTION_RENDERED = "rendered.yaml"
+AUTO_DEPLOY_TAGS = ("bizytrd_auto_deploy",)

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/models.py

@@ -82,6 +82,16 @@ class ApplyResult:
     """Container for apply operation results."""
 
     applied: list[str] = field(default_factory=list)
+    applied_versions: dict[str, str] = field(default_factory=dict)
     unchanged: list[str] = field(default_factory=list)
     skipped: list[str] = field(default_factory=list)
     failed: list[tuple[str, str]] = field(default_factory=list)
+
+
+@dataclass
+class DeployResult:
+    """Container for deploy operation results."""
+
+    deployed: list[str] = field(default_factory=list)
+    skipped: list[str] = field(default_factory=list)
+    failed: list[tuple[str, str]] = field(default_factory=list)

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/protocols/faas_function.py

@@ -51,3 +51,16 @@ class FaaSFunctionProvider(Protocol):
             meta: Dict with 'functionName' and/or 'tags' keys.
         """
         ...
+
+    async def list_deployments(self, func_id: str) -> list[dict]:
+        """List all deployments for a function.
+
+        Returns:
+            List of deployment dicts with 'id', 'status', 'definition_version'.
+        """
+        ...
+
+    async def deploy_version(self, func_id: str, deployment_id: str, version: str) -> None:
+        """Deploy a specific definition version to a deployment (fire-and-forget).
+        """
+        ...

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/usecases/apply_function_changes.py

@@ -51,7 +51,9 @@ class ApplyFunctionChanges:
             if parts.definition is not None:
                 def_payload = parts.to_faas_definition(comment=comment)
                 if def_payload is not None:
-                    await self._provider.push_definition(fid, def_payload)
+                    version = await self._provider.push_definition(fid, def_payload)
+                    if version is not None:
+                        result.applied_versions[fid] = str(version)
             await self._provider.update_function_meta(fid, parts.to_faas_meta())
             result.applied.append(fid)
         return result

faas_gitops-0.3.0/src/faas_gitops/usecases/deploy_functions.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from loguru import logger
+
+from faas_gitops.config import Settings
+from faas_gitops.layout import AUTO_DEPLOY_TAGS, FUNCTION_DIR, FUNCTION_META
+from faas_gitops.models import DeployResult
+from faas_gitops.protocols.faas_function import FaaSFunctionProvider
+from faas_gitops.usecases.sync_functions import read_function_from_dir
+
+
+class DeployFunctions:
+    """Auto-deploy drifted functions tagged with AUTO_DEPLOY_TAG.
+
+    For each applied function whose meta.yaml tags include AUTO_DEPLOY_TAG,
+    deploys the pushed version to every non-terminated deployment.
+    Skips deployments already at the target version (idempotency guard).
+    Fire-and-forget: triggers deploy without waiting for readiness.
+    """
+
+    def __init__(self, provider: FaaSFunctionProvider, settings: Settings) -> None:
+        self._provider = provider
+        self._settings = settings
+
+    async def run(self, applied_versions: dict[str, str], repo_path: Path) -> DeployResult:
+        result = DeployResult()
+        for fid, version in applied_versions.items():
+            try:
+                parts = await read_function_from_dir(repo_path / FUNCTION_DIR / fid)
+                tags = parts.meta.get("tags") or []
+                if not set(AUTO_DEPLOY_TAGS) & set(tags):
+                    continue
+                deployments = await self._provider.list_deployments(fid)
+                active = [d for d in deployments if d.get("status") != "terminated"]
+                if not active:
+                    logger.warning(f"  ! {fid}: no active deployments")
+                    result.skipped.append(fid)
+                    continue
+                for dep in active:
+                    deploy_id = dep["id"]
+                    current = str(dep.get("definition_version", ""))
+                    if current == str(version):
+                        logger.info(f"  = {fid}/{deploy_id}: already at version {version}")
+                        result.skipped.append(f"{fid}/{deploy_id}")
+                        continue
+                    try:
+                        await self._provider.deploy_version(fid, deploy_id, version)
+                        logger.info(f"  → {fid}/{deploy_id}: {current} → {version}")
+                        result.deployed.append(f"{fid}/{deploy_id}")
+                    except Exception as e:
+                        logger.error(f"  ✗ {fid}/{deploy_id}: {e}")
+                        result.failed.append((f"{fid}/{deploy_id}", str(e)))
+            except Exception as e:
+                logger.error(f"  ✗ {fid}: {e}")
+                result.failed.append((fid, str(e)))
+        return result

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/usecases/detect_drift.py

@@ -27,35 +27,57 @@ async def run_git_diff(repo_path: Path, base: str, head: str, prefix: str) -> st
     return stdout.decode()
 
 
-def parse_git_diff(text: str, prefix: str, depth: int, *, exclude_suffixes: tuple[str, ...] = ()) -> DriftResult:
-    result = DriftResult(diff_text=text)
+def parse_git_diff(
+    text: str,
+    prefix: str,
+    depth: int,
+    *,
+    exclude_suffixes: tuple[str, ...] = (),
+    include_suffixes: tuple[str, ...] = (),
+) -> DriftResult:
     if not text:
-        return result
+        return DriftResult()
 
     seen: dict[str, str] = {}
+    sections: list[tuple[str, str]] = []
     current_path: str | None = None
     current_status: str | None = None
+    current_lines: list[str] = []
+
     for line in text.splitlines():
         m = _DIFF_HEADER.match(line)
         if m:
-            if current_path and current_status:
-                seen[current_path] = current_status
+            if current_path:
+                if current_status:
+                    seen[current_path] = current_status
+                sections.append((current_path, "\n".join(current_lines)))
             current_path = m.group(1)
             current_status = "modified"
+            current_lines = [line]
             continue
         if current_path:
+            current_lines.append(line)
             if _NEW_FILE.match(line):
                 current_status = "missing_in_faas"
             elif _DELETED_FILE.match(line):
                 current_status = "missing_in_git"
-    if current_path and current_status:
-        seen[current_path] = current_status
+    if current_path:
+        if current_status:
+            seen[current_path] = current_status
+        sections.append((current_path, "\n".join(current_lines)))
 
-    items: dict[str, str] = {}
-    for path, status in seen.items():
+    def _path_kept(path: str) -> bool:
         if not path.startswith(prefix + "/"):
-            continue
+            return False
+        if include_suffixes and not any(path.endswith(s) for s in include_suffixes):
+            return False
         if exclude_suffixes and any(path.endswith(s) for s in exclude_suffixes):
+            return False
+        return True
+
+    items: dict[str, str] = {}
+    for path, status in seen.items():
+        if not _path_kept(path):
             continue
         rel = path[len(prefix) + 1:]
         parts = rel.split("/")
@@ -66,6 +88,9 @@ def parse_git_diff(text: str, prefix: str, depth: int, *, exclude_suffixes: tupl
             continue
         items[item_id] = status
 
+    filtered_text = "\n".join(section for path, section in sections if _path_kept(path))
+
+    result = DriftResult(diff_text=filtered_text)
     for item_id, status in items.items():
         if status == "missing_in_faas":
             result.missing_in_faas.append(item_id)

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops/usecases/detect_function_drift.py

@@ -8,7 +8,7 @@ import yaml
 
 from faas_gitops.config import Settings
 from faas_gitops.filtering import match_scope
-from faas_gitops.layout import FUNCTION_DIR, FUNCTION_META
+from faas_gitops.layout import FUNCTION_DIR, FUNCTION_META, FUNCTION_RENDERED
 from faas_gitops.models import DriftResult
 from faas_gitops.usecases.detect_drift import parse_git_diff, run_git_diff
 
@@ -20,7 +20,7 @@ class DetectFunctionDrift:
 
     async def run(self, repo_path: Path, base: str = "main", sync_branch: str = "sync/faas-functions") -> DriftResult:
         text = await run_git_diff(repo_path, base, sync_branch, FUNCTION_DIR)
-        result = parse_git_diff(text, FUNCTION_DIR, depth=1, exclude_suffixes=())
+        result = parse_git_diff(text, FUNCTION_DIR, depth=1, include_suffixes=(FUNCTION_RENDERED,))
         if not any((result.drifted, result.missing_in_git, result.missing_in_faas)):
             return result
         await self._apply_scope(result, repo_path)

{faas_gitops-0.2.1 → faas_gitops-0.3.0/src/faas_gitops.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: faas-gitops
-Version: 0.2.1
+Version: 0.3.0
 Summary: Declarative GitOps for FaaS
 Requires-Python: >=3.12
 Requires-Dist: aiofiles>=23.0

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/src/faas_gitops.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/faas_gitops/protocols/git_gateway.py
 src/faas_gitops/usecases/__init__.py
 src/faas_gitops/usecases/apply_function_changes.py
 src/faas_gitops/usecases/apply_template_changes.py
+src/faas_gitops/usecases/deploy_functions.py
 src/faas_gitops/usecases/detect_drift.py
 src/faas_gitops/usecases/detect_function_drift.py
 src/faas_gitops/usecases/detect_template_drift.py
@@ -36,6 +37,7 @@ src/faas_gitops/usecases/sync_functions.py
 src/faas_gitops/usecases/sync_templates.py
 tests/test_apply_function_changes.py
 tests/test_apply_template_changes.py
+tests/test_deploy_functions.py
 tests/test_detect_drift.py
 tests/test_detect_function_drift.py
 tests/test_git_cli_gateway.py

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/tests/test_apply_function_changes.py

@@ -9,6 +9,7 @@ import pytest
 import yaml
 
 from faas_gitops.config import Settings
+from faas_gitops.layout import FUNCTION_RENDERED
 from faas_gitops.models import FunctionParts
 from faas_gitops.usecases.apply_function_changes import ApplyFunctionChanges
 from faas_gitops.usecases.sync_functions import read_function_from_dir
@@ -29,14 +30,15 @@ def _make_repo(tmp_path: Path) -> Path:
     (func_dir / "meta.yaml").write_text("functionName: my-func\ntags:\n- gitops\n")
     (func_dir / "base.yaml").write_text("templateName: some-template\n")
     (func_dir / "definition.yaml").write_text("repo: siliconflow/test\n")
+    (func_dir / FUNCTION_RENDERED).write_text("old: rendered\n")
     (r / "README").write_text("hi")
     _git("add", ".", cwd=r)
     _git("commit", "-m", "init", cwd=r)
     _git("checkout", "-b", "sync/faas-functions", cwd=r)
     _git("checkout", "main", cwd=r)
-    (func_dir / "meta.yaml").write_text("functionName: my-func-updated\ntags:\n- gitops\n")
+    (func_dir / FUNCTION_RENDERED).write_text("new: rendered\n")
     _git("add", ".", cwd=r)
-    _git("commit", "-m", "update fn1 on main", cwd=r)
+    _git("commit", "-m", "update fn1 rendered.yaml on main", cwd=r)
     _git("remote", "add", "origin", str(r), cwd=r)
     _git("fetch", "origin", cwd=r)
     return r
@@ -93,10 +95,11 @@ class TestApplyFunctionChanges:
         repo = _make_repo(tmp_path)
         provider = MagicMock()
         provider.get_latest_definition = AsyncMock(return_value={"metadata": {"templateName": "tpl"}, "spec": {"data": {"repo": "old"}}})
-        provider.push_definition = AsyncMock()
+        provider.push_definition = AsyncMock(return_value="5")
         provider.update_function_meta = AsyncMock()
         result = await ApplyFunctionChanges(provider, Settings()).run(repo, repo_slug="org/repo")
         assert result.applied == ["fn1"]
+        assert result.applied_versions == {"fn1": "5"}
         assert not result.failed
         provider.push_definition.assert_called_once()
         provider.update_function_meta.assert_called_once()
@@ -110,6 +113,7 @@ class TestApplyFunctionChanges:
         result = await ApplyFunctionChanges(provider, Settings()).run(repo, dry_run=True, repo_slug="org/repo")
         assert result.skipped == ["fn1"]
         assert not result.applied
+        assert result.applied_versions == {}
         provider.push_definition.assert_not_called()
         provider.update_function_meta.assert_not_called()
 
@@ -146,7 +150,7 @@ class TestApplyFunctionChanges:
         _git("checkout", "-b", "sync/faas-functions", cwd=r)
         func_dir = r / "functions" / "fn1"
         func_dir.mkdir(parents=True)
-        (func_dir / "meta.yaml").write_text("functionName: my-func\ntags:\n- gitops\n")
+        (func_dir / FUNCTION_RENDERED).write_text("old: rendered\n")
         _git("add", ".", cwd=r)
         _git("commit", "-m", "add fn1 on sync", cwd=r)
         _git("checkout", "main", cwd=r)

faas_gitops-0.3.0/tests/test_deploy_functions.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from faas_gitops.config import Settings
+from faas_gitops.layout import FUNCTION_DIR, FUNCTION_META
+from faas_gitops.usecases.deploy_functions import DeployFunctions
+
+
+def _make_repo(*funcs: tuple[str, str]) -> Path:
+    repo = Path(tempfile.mkdtemp(prefix="faas-test-"))
+    for fid, meta_content in funcs:
+        d = repo / FUNCTION_DIR / fid
+        d.mkdir(parents=True)
+        (d / FUNCTION_META).write_text(meta_content)
+    return repo
+
+
+_META_WITH_TAG = "functionName: f1\ntags:\n- bizytrd_auto_deploy\n"
+_META_WITHOUT_TAG = "functionName: f2\ntags:\n- other\n"
+
+
+class TestDeployFunctions:
+    @pytest.mark.asyncio
+    async def test_no_tag_skipped(self) -> None:
+        repo = _make_repo(("fn1", _META_WITHOUT_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock()
+        provider.deploy_version = AsyncMock()
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5"}, repo)
+        assert result.deployed == []
+        assert result.skipped == []
+        provider.list_deployments.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_tag_with_active_dep_gets_deployed(self) -> None:
+        repo = _make_repo(("fn1", _META_WITH_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock(return_value=[
+            {"id": "dep1", "status": "ready", "definition_version": 3},
+        ])
+        provider.deploy_version = AsyncMock()
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5"}, repo)
+        assert "fn1/dep1" in result.deployed
+        provider.deploy_version.assert_called_once_with("fn1", "dep1", "5")
+
+    @pytest.mark.asyncio
+    async def test_idempotent_skip_when_same_version(self) -> None:
+        repo = _make_repo(("fn1", _META_WITH_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock(return_value=[
+            {"id": "dep1", "status": "ready", "definition_version": 5},
+        ])
+        provider.deploy_version = AsyncMock()
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5"}, repo)
+        assert result.deployed == []
+        assert "fn1/dep1" in result.skipped
+        provider.deploy_version.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_terminated_deployments_excluded(self) -> None:
+        repo = _make_repo(("fn1", _META_WITH_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock(return_value=[
+            {"id": "dep1", "status": "terminated", "definition_version": 1},
+            {"id": "dep2", "status": "ready", "definition_version": 1},
+        ])
+        provider.deploy_version = AsyncMock()
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5"}, repo)
+        assert "fn1/dep2" in result.deployed
+        assert all("dep1" not in d for d in result.deployed)
+
+    @pytest.mark.asyncio
+    async def test_no_active_deployments_warns(self) -> None:
+        repo = _make_repo(("fn1", _META_WITH_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock(return_value=[
+            {"id": "dep1", "status": "terminated", "definition_version": 1},
+        ])
+        provider.deploy_version = AsyncMock()
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5"}, repo)
+        assert result.deployed == []
+        assert "fn1" in result.skipped
+
+    @pytest.mark.asyncio
+    async def test_deploy_error_continues_to_next_function(self) -> None:
+        repo = _make_repo(("fn1", _META_WITH_TAG), ("fn2", _META_WITH_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock(return_value=[
+            {"id": "dep1", "status": "ready", "definition_version": 1},
+        ])
+        provider.deploy_version = AsyncMock(side_effect=[RuntimeError("boom"), None])
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5", "fn2": "6"}, repo)
+        assert "fn2/dep1" in result.deployed
+        assert len(result.failed) == 1
+        assert result.failed[0][0] == "fn1/dep1"
+
+    @pytest.mark.asyncio
+    async def test_multiple_active_deployments_all_deployed(self) -> None:
+        repo = _make_repo(("fn1", _META_WITH_TAG))
+        provider = MagicMock()
+        provider.list_deployments = AsyncMock(return_value=[
+            {"id": "dep1", "status": "ready", "definition_version": 1},
+            {"id": "dep2", "status": "pending", "definition_version": 2},
+        ])
+        provider.deploy_version = AsyncMock()
+        result = await DeployFunctions(provider, Settings()).run({"fn1": "5"}, repo)
+        assert "fn1/dep1" in result.deployed
+        assert "fn1/dep2" in result.deployed
+        assert provider.deploy_version.call_count == 2

{faas_gitops-0.2.1 → faas_gitops-0.3.0}/tests/test_detect_function_drift.py

@@ -8,6 +8,7 @@ import pytest
 
 from faas_gitops.config import Settings
 from faas_gitops.layout import FUNCTION_DIR, FUNCTION_META
+from faas_gitops.usecases import detect_function_drift as _module
 from faas_gitops.usecases.detect_function_drift import DetectFunctionDrift
 
 
@@ -51,3 +52,61 @@ class TestDetectFunctionDriftScope:
     async def test_none_tags_treated_as_empty(self) -> None:
         repo = _make_repo_with_functions(("fn3", _META_NO_TAGS))
         assert await DetectFunctionDrift(Settings(scoped_function_tags={"gitops"}))._in_scope("fn3", repo) is False
+
+
+_DIFF_RENDERED_ONLY = """\
+diff --git a/functions/fn1/rendered.yaml b/functions/fn1/rendered.yaml
+index abc..def 100644
+--- a/functions/fn1/rendered.yaml
++++ b/functions/fn1/rendered.yaml
+@@ -1 +1 @@
+-old: rendered
++new: rendered
+"""
+
+_DIFF_META_ONLY = """\
+diff --git a/functions/fn1/meta.yaml b/functions/fn1/meta.yaml
+index abc..def 100644
+--- a/functions/fn1/meta.yaml
++++ b/functions/fn1/meta.yaml
+@@ -1,2 +1,2 @@
+-functionName: old
++functionName: new
+  tags:
+"""
+
+_DIFF_DEFINITION_ONLY = """\
+diff --git a/functions/fn1/definition.yaml b/functions/fn1/definition.yaml
+index abc..def 100644
+--- a/functions/fn1/definition.yaml
++++ b/functions/fn1/definition.yaml
+@@ -1 +1 @@
+-repo: old
++repo: new
+"""
+
+
+def _patch_run_git_diff(monkeypatch, diff_text: str) -> None:
+    async def _fake_run_git_diff(repo_path, base, head, prefix):
+        return diff_text
+    monkeypatch.setattr(_module, "run_git_diff", _fake_run_git_diff)
+
+
+class TestDetectFunctionDriftRunRenderedOnly:
+    @pytest.mark.asyncio
+    async def test_rendered_yaml_change_triggers_drift(self, monkeypatch) -> None:
+        _patch_run_git_diff(monkeypatch, _DIFF_RENDERED_ONLY)
+        result = await DetectFunctionDrift(Settings()).run(Path("/tmp/unused"))
+        assert result.drifted == ["fn1"]
+
+    @pytest.mark.asyncio
+    async def test_meta_only_change_does_not_trigger_drift(self, monkeypatch) -> None:
+        _patch_run_git_diff(monkeypatch, _DIFF_META_ONLY)
+        result = await DetectFunctionDrift(Settings()).run(Path("/tmp/unused"))
+        assert result.drifted == []
+
+    @pytest.mark.asyncio
+    async def test_definition_only_change_does_not_trigger_drift(self, monkeypatch) -> None:
+        _patch_run_git_diff(monkeypatch, _DIFF_DEFINITION_ONLY)
+        result = await DetectFunctionDrift(Settings()).run(Path("/tmp/unused"))
+        assert result.drifted == []