fix cache clearing (#359)

wasn't updated to handle the dedicated build namespace

Author: ewdurbin

cabotage/celery/tasks/build.py

@@ -268,7 +268,9 @@ def _dispatch_release_failure(release, error_detail):
 
 def _build_namespace(app_env):
     """Return the namespace where build jobs run."""
-    return "cabotage-tenant-builds"
+    return current_app.config.get(
+        "KUBERNETES_BUILD_NAMESPACE", "cabotage-tenant-builds"
+    )
 
 
 Activity = activity_plugin.activity_cls

cabotage/server/config.py

@@ -131,6 +131,7 @@ class Config(metaclass=MetaFlaskEnv):
     CELERY_RESULT_BACKEND = "redis://redis:6379"
     KUBERNETES_ENABLED = False
     KUBERNETES_CONTEXT = "cabotage"
+    KUBERNETES_BUILD_NAMESPACE = "cabotage-tenant-builds"
     NETWORK_POLICIES_ENABLED = False
     BACKING_SERVICE_POSTGRES_ENABLED = False
     BACKING_SERVICE_REDIS_ENABLED = False

cabotage/server/user/views.py

@@ -5403,9 +5403,13 @@ def application_clear_cache(org_slug, project_slug, app_slug):
     image = application.images.first()
     if image is not None and current_app.config["KUBERNETES_ENABLED"]:
         from cabotage.celery.tasks.deploy import run_job
-        from cabotage.celery.tasks.build import fetch_image_build_cache_volume_claim
+        from cabotage.celery.tasks.build import (
+            _build_namespace,
+            fetch_image_build_cache_volume_claim,
+        )
 
         buildkit_image = current_app.config["BUILDKIT_IMAGE"]
+        build_namespace = _build_namespace(app_env)
 
         from cabotage.celery.tasks.deploy import _safe_labels_from_application
 
@@ -5490,7 +5494,7 @@ def application_clear_cache(org_slug, project_slug, app_slug):
         )
 
         job_complete, job_logs = run_job(
-            core_api_instance, batch_api_instance, "default", job_object
+            core_api_instance, batch_api_instance, build_namespace, job_object
         )
 
     def auth(dxf, response):

tests/test_build_jobs.py

@@ -160,14 +160,22 @@ def _run_image_build(image, mock_core, mock_run_job):
 
 
 class TestBuildNamespace:
-    def test_always_returns_tenant_builds_namespace(self):
+    def test_always_returns_tenant_builds_namespace(self, mock_app):
         app_env = _make_app_env(org_k8s="myorg", env_k8s="staging", env_enabled=True)
         assert _build_namespace(app_env) == "cabotage-tenant-builds"
 
-    def test_env_disabled_still_returns_tenant_builds(self):
+    def test_env_disabled_still_returns_tenant_builds(self, mock_app):
         app_env = _make_app_env(org_k8s="myorg", env_enabled=False)
         assert _build_namespace(app_env) == "cabotage-tenant-builds"
 
+    def test_uses_configured_build_namespace(self):
+        app_env = _make_app_env(org_k8s="myorg", env_k8s="staging", env_enabled=True)
+        mock_app = MagicMock()
+        mock_app.config = {"KUBERNETES_BUILD_NAMESPACE": "tenant-builds-custom"}
+
+        with patch.object(build_module, "current_app", mock_app):
+            assert _build_namespace(app_env) == "tenant-builds-custom"
+
 
 class TestBuildCachePVCName:
     def test_includes_environment_when_env_mode_enabled_even_if_app_env_is_legacy(self):
@@ -383,7 +391,7 @@ def test_reaper_label_selector_excludes_build_jobs(self):
 
 
 class TestBuildCachePVC:
-    def test_pvc_created_in_tenant_namespace(self):
+    def test_pvc_created_in_tenant_namespace(self, mock_app):
         from kubernetes.client.rest import ApiException
 
         image = _make_image(org_k8s="myorg", env_k8s="prod")
@@ -398,7 +406,7 @@ def test_pvc_created_in_tenant_namespace(self):
         create_call = mock_core.create_namespaced_persistent_volume_claim.call_args
         assert create_call[0][0] == "cabotage-tenant-builds"
 
-    def test_pvc_created_with_safe_labels(self):
+    def test_pvc_created_with_safe_labels(self, mock_app):
         from kubernetes.client.rest import ApiException
 
         image = _make_image(org_k8s="myorg", env_k8s="prod")
@@ -420,7 +428,7 @@ def test_pvc_created_with_safe_labels(self):
             "cabotage.io/build-cache": "true",
         }
 
-    def test_pvc_read_in_tenant_namespace(self):
+    def test_pvc_read_in_tenant_namespace(self, mock_app):
         image = _make_image(org_k8s="myorg", env_k8s="prod")
         mock_core = MagicMock()
 

tests/test_clear_cache.py

@@ -0,0 +1,185 @@
+"""Tests for application cache-clearing behavior."""
+
+import time
+import uuid
+from unittest.mock import MagicMock, patch
+
+import pytest
+from flask_security import hash_password
+
+from cabotage.server import db
+from cabotage.server.models.auth import Organization, User
+from cabotage.server.models.auth_associations import OrganizationMember
+from cabotage.server.models.projects import (
+    Application,
+    ApplicationEnvironment,
+    Environment,
+    Image,
+    Project,
+)
+from cabotage.server.wsgi import app as _app
+
+
+@pytest.fixture
+def app():
+    _app.config["TESTING"] = True
+    _app.config["WTF_CSRF_ENABLED"] = False
+    _app.config["REQUIRE_MFA"] = False
+    _app.config["KUBERNETES_ENABLED"] = True
+    _app.config["KUBERNETES_BUILD_NAMESPACE"] = "tenant-builds-custom"
+    _app.config["BUILDKIT_IMAGE"] = "moby/buildkit:latest"
+    _app.config["REGISTRY_BUILD"] = "registry.example.com"
+    _app.config["REGISTRY_SECURE"] = False
+    _app.config["REGISTRY_VERIFY"] = False
+    with _app.app_context():
+        yield _app
+    _app.config["REQUIRE_MFA"] = True
+    _app.config["KUBERNETES_ENABLED"] = False
+    _app.config["KUBERNETES_BUILD_NAMESPACE"] = "cabotage-tenant-builds"
+
+
+@pytest.fixture
+def client(app):
+    return app.test_client()
+
+
+@pytest.fixture
+def db_session(app):
+    yield db.session
+    db.session.rollback()
+
+
+@pytest.fixture
+def admin_user(db_session):
+    user = User(
+        username=f"admin-{uuid.uuid4().hex[:8]}",
+        email=f"admin-{uuid.uuid4().hex[:8]}@example.com",
+        password=hash_password("password123"),
+        active=True,
+        fs_uniquifier=uuid.uuid4().hex,
+    )
+    db_session.add(user)
+    db_session.flush()
+    return user
+
+
+@pytest.fixture
+def org(db_session, admin_user):
+    org = Organization(name="Test Org", slug=f"testorg-{uuid.uuid4().hex[:8]}")
+    db_session.add(org)
+    db_session.flush()
+    db_session.add(
+        OrganizationMember(organization_id=org.id, user_id=admin_user.id, admin=True)
+    )
+    db_session.flush()
+    return org
+
+
+@pytest.fixture
+def project(db_session, org):
+    project = Project(name="Test Project", organization_id=org.id)
+    db_session.add(project)
+    db_session.flush()
+    return project
+
+
+@pytest.fixture
+def environment(db_session, project):
+    environment = Environment(name="default", project_id=project.id, ephemeral=False)
+    db_session.add(environment)
+    db_session.flush()
+    return environment
+
+
+@pytest.fixture
+def application(db_session, project):
+    application = Application(
+        name="webapp",
+        slug="webapp",
+        project_id=project.id,
+        github_repository="myorg/myrepo",
+    )
+    db_session.add(application)
+    db_session.flush()
+    return application
+
+
+@pytest.fixture
+def app_env(db_session, application, environment):
+    app_env = ApplicationEnvironment(
+        application_id=application.id,
+        environment_id=environment.id,
+    )
+    db_session.add(app_env)
+    db_session.flush()
+    return app_env
+
+
+@pytest.fixture
+def image(db_session, application, app_env):
+    image = Image(
+        application_id=application.id,
+        application_environment_id=app_env.id,
+        _repository_name=application.registry_repository_name(app_env),
+        build_ref="main",
+    )
+    db_session.add(image)
+    db_session.flush()
+    return image
+
+
+def _login(client, user):
+    with client.session_transaction() as sess:
+        sess["_user_id"] = user.fs_uniquifier
+        sess["_fresh"] = True
+        sess["fs_cc"] = "set"
+        sess["fs_paa"] = time.time()
+        sess["identity.id"] = user.id
+        sess["identity.auth_type"] = "session"
+
+
+class TestApplicationClearCache:
+    def test_clear_cache_runs_job_in_configured_build_namespace(
+        self, client, admin_user, org, project, application, app_env, image
+    ):
+        _login(client, admin_user)
+
+        volume_claim = MagicMock()
+        volume_claim.metadata.name = "build-cache-pvc"
+        dxf_client = MagicMock()
+
+        with (
+            patch("cabotage.server.user.views.kubernetes_ext") as mock_kext,
+            patch(
+                "cabotage.server.user.views.kubernetes.client.CoreV1Api",
+                return_value=MagicMock(),
+            ),
+            patch(
+                "cabotage.server.user.views.kubernetes.client.BatchV1Api",
+                return_value=MagicMock(),
+            ),
+            patch(
+                "cabotage.celery.tasks.build.fetch_image_build_cache_volume_claim",
+                return_value=volume_claim,
+            ),
+            patch(
+                "cabotage.celery.tasks.deploy.run_job",
+                return_value=(True, "cleared"),
+            ) as mock_run_job,
+            patch("cabotage.server.user.views.DXF", return_value=dxf_client),
+        ):
+            mock_kext.kubernetes_client = MagicMock()
+            dxf_client.get_alias.side_effect = [
+                MagicMock(),
+                MagicMock(),
+            ]
+
+            response = client.post(
+                (
+                    f"/projects/{org.slug}/{project.slug}/applications/"
+                    f"{application.slug}/clearcache"
+                )
+            )
+
+        assert response.status_code == 302
+        assert mock_run_job.call_args[0][2] == "tenant-builds-custom"