djaploy 1.2.5__tar.gz → 1.2.7__tar.gz

{djaploy-1.2.5 → djaploy-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.2.5
+Version: 1.2.7
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License
@@ -289,6 +289,8 @@ python manage.py djaploy rollback --env production
 3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
 4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
 
+> **Note:** Migrations run during Step 1, before traffic switches. Both the old and new slots share the same database, so migrations must be **backward-compatible** (use the expand/contract pattern). Deploy new code that handles both old and new schema, activate, then clean up in a subsequent deploy.
+
 ### Server directory layout comparison
 
 For `app_user="myapp-api"`, `app_name="myapp"`:

{djaploy-1.2.5 → djaploy-1.2.7}/README.md

@@ -227,6 +227,8 @@ python manage.py djaploy rollback --env production
 3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
 4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
 
+> **Note:** Migrations run during Step 1, before traffic switches. Both the old and new slots share the same database, so migrations must be **backward-compatible** (use the expand/contract pattern). Deploy new code that handles both old and new schema, activate, then clean up in a subsequent deploy.
+
 ### Server directory layout comparison
 
 For `app_user="myapp-api"`, `app_name="myapp"`:

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/apps/borg/infra/djaploy_hooks.py

@@ -555,9 +555,9 @@ def restore_borg(host_data, restore_opts):
         )
         bluegreen_services = []
         for svc in services:
-            bluegreen_services.append(f"{app_name}-blue")
-            bluegreen_services.append(f"{app_name}-green")
-        # Also stop streaming coordinator instances
+            bluegreen_services.append(f"{svc}-blue")
+            bluegreen_services.append(f"{svc}-green")
+        # Also stop streaming coordinator instances (app-level, not per-service)
         bluegreen_services.append(f"{app_name}-streaming-blue")
         bluegreen_services.append(f"{app_name}-streaming-green")
         services = bluegreen_services

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/apps/systemd/infra/djaploy_hooks.py

@@ -34,18 +34,37 @@ def start_services(host_data, artifact_path):
         if not target_slot:
             return
 
+        from pyinfra.operations import server
         for service in getattr(host_data, "services", []):
-            app_name = getattr(host_data, 'app_name', service)
-            slot_service = get_slot_service_name(app_name, target_slot)
+            slot_service = get_slot_service_name(service, target_slot)
 
-            systemd.service(
-                name=f"Start and restart {slot_service} (target slot)",
-                service=slot_service,
-                running=True,
-                enabled=True,
-                restarted=True,
+            # Only start if the service unit file exists — custom services
+            # (e.g. streaming) may be rendered by project hooks, not djaploy core.
+            server.shell(
+                name=f"Start {slot_service} if unit exists",
+                commands=[
+                    f"test -f /etc/systemd/system/{slot_service}.service && "
+                    f"systemctl enable {slot_service} && "
+                    f"systemctl restart {slot_service} || "
+                    f"echo 'Unit {slot_service}.service not found, skipping'",
+                ],
                 _sudo=True,
             )
+
+        # Disable legacy single service from zero_downtime/in_place if present.
+        # Runs after the new slot service is started so there's no downtime gap.
+        app_name = getattr(host_data, 'app_name', None)
+        from pyinfra.operations import server
+        server.shell(
+            name="Disable legacy service (migration to bluegreen)",
+            commands=[
+                f"systemctl stop {app_name}.service 2>/dev/null || true",
+                f"systemctl disable {app_name}.service 2>/dev/null || true",
+                f"rm -f /etc/systemd/system/{app_name}.service",
+                f"systemctl daemon-reload 2>/dev/null || true",
+            ],
+            _sudo=True,
+        )
     elif is_zero_downtime(host_data):
         for service in getattr(host_data, "services", []):
             systemd.service(

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/builtin_hooks.py

@@ -114,8 +114,9 @@ def _deploy_calculate_release_info(context):
                 text=True,
             ).strip()
             context["pyinfra_data"]["commit"] = commit
-        except Exception:
-            pass
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).debug("Failed to get commit hash: %s", e)
 
 
 # ── deploy:postcommand ───────────────────────────────────────────────

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/commands/status.py

@@ -64,8 +64,10 @@ if is_bluegreen(host.data):
             status_str = "unknown"
             if res[0] and len(res) > 1:
                 try:
-                    status_str = (list(res[1])[0].line if hasattr(list(res[1])[0], 'line') else str(list(res[1])[0])).strip()
-                except (IndexError, AttributeError):
+                    first_item = next(iter(res[1]), None)
+                    if first_item is not None:
+                        status_str = (first_item.line if hasattr(first_item, 'line') else str(first_item)).strip()
+                except (StopIteration, AttributeError):
                     pass
             print(f"Service {svc}: {status_str}")
         print()

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/infra/bluegreen.py

@@ -63,21 +63,28 @@ def update_slot_info_cmd(
     python_interpreter: str,
     venv_path: str,
 ) -> str:
-    """Shell command to update a slot's deployment metadata in state.json."""
+    """Shell command to update a slot's deployment metadata in state.json.
+
+    Note: Production code uses heredocs instead of this function.
+    Kept for testing and as a utility.
+    """
+    # Serialize values safely to avoid injection
+    safe_vals = json.dumps({
+        "release": release,
+        "commit": commit,
+        "python_interpreter": python_interpreter,
+        "venv_path": venv_path,
+    })
     return (
         f"python3 -c \""
-        f"import json, datetime; "
+        f"import json, datetime, os; "
         f"s=json.load(open('{state_file}')); "
-        f"s['slots']['{slot}']={{"
-        f"'release':'{release}',"
-        f"'commit':'{commit}',"
-        f"'deployed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),"
-        f"'python_interpreter':'{python_interpreter}',"
-        f"'venv_path':'{venv_path}'"
-        f"}}; "
+        f"vals={safe_vals}; "
+        f"vals['deployed_at']=datetime.datetime.now(datetime.timezone.utc).isoformat(); "
+        f"s['slots']['{slot}']=vals; "
         f"f=open('{state_file}.tmp','w'); "
         f"json.dump(s,f,indent=2); f.close(); "
-        f"import os; os.rename('{state_file}.tmp','{state_file}')"
+        f"os.rename('{state_file}.tmp','{state_file}')"
         f"\""
     )
 
@@ -120,26 +127,3 @@ def print_slot_info_cmd(state_file: str, slot: str) -> str:
     )
 
 
-def print_status_cmd(state_file: str, app_name: str) -> str:
-    """Shell command that prints full blue-green status."""
-    return (
-        f"python3 -c \""
-        f"import json; "
-        f"s=json.load(open('{state_file}')); "
-        f"active=s.get('active_slot') or 'none'; "
-        f"print(); "
-        f"print('Blue-Green Status for {app_name}'); "
-        f"print('=' * 40); "
-        f"print(f'Active slot: {{active}}'); "
-        f"print(); "
-        f"for slot in ('blue','green'): "
-        f"  info=s['slots'].get(slot); "
-        f"  tag='ACTIVE' if active==slot else 'inactive'; "
-        f"  print(f'{{slot.upper()}} ({{tag}}):'); "
-        f"  ["
-        f"    (print(f'  Release:  {{info[k]}}') for k in ('release','commit','deployed_at','python_interpreter','venv_path'))"
-        f"    if info else print('  (empty)')"
-        f"  ]; "
-        f"  print()"
-        f"\""
-    )

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/infra/djaploy_hooks.py

@@ -8,6 +8,31 @@ Handles server configuration, application deployment, post-deploy tasks
 from djaploy.hooks import deploy_hook
 
 
+def _update_nginx_upstream(host_data, app_name, target_slot):
+    """Render and deploy the bluegreen nginx upstream config.
+
+    Skipped when nginx_conf.custom is set — custom setups handle
+    their own upstream via activate:post hooks.
+    """
+    from io import StringIO
+    from pyinfra.operations import files
+    from djaploy.infra.templates import NGINX_UPSTREAM_BLUEGREEN, build_template_context
+    from jinja2 import Environment
+
+    ctx = build_template_context(host_data)
+    ctx["active_slot"] = target_slot
+    upstream_content = Environment().from_string(NGINX_UPSTREAM_BLUEGREEN).render(**ctx)
+
+    nginx_cfg = getattr(host_data, 'nginx_conf', None) or {}
+    if not nginx_cfg.get("custom"):
+        files.put(
+            name=f"Update nginx upstream to {target_slot} slot",
+            src=StringIO(upstream_content),
+            dest=f"/etc/nginx/sites-available/{app_name}-upstream.conf",
+            _sudo=True,
+        )
+
+
 def _read_slot_info_from_remote(host, slot, state_file):
     """Read a slot's deployment info from state.json on the remote server.
 
@@ -28,7 +53,7 @@ def _read_slot_info_from_remote(host, slot, state_file):
     if status and output:
         try:
             # pyinfra returns OutputLine objects with a .line attribute
-            lines = [l.line if hasattr(l, 'line') else str(l) for l in output]
+            lines = [line.line if hasattr(line, 'line') else str(line) for line in output]
             raw = "\n".join(lines)
             state_data = json.loads(raw)
             return state_data.get("slots", {}).get(slot) or {}
@@ -160,7 +185,6 @@ def configure_server(host_data):
             _sudo_user=app_user,
         )
 
-
         shared_resources = getattr(host_data, 'shared_resources', None) or []
         if shared_resources:
             mkdir_commands = [
@@ -624,8 +648,13 @@ def activate_release(host_data, artifact_path):
         run_migrations(app_user, build_path, host_data)
         collect_static(app_user, build_path, host_data)
 
-        # Update state.json on the remote server
+        # Update state.json on the remote server.
+        # Serialize release_name and commit with json.dumps to safely
+        # handle quotes and special characters in branch names / messages.
+        import json as _json
         commit = getattr(host_data, 'commit', 'unknown')
+        safe_release = _json.dumps(release_name)
+        safe_commit = _json.dumps(commit)
         socket_path = get_slot_socket_path(app_name, target_slot)
         server.shell(
             name="Update state.json with deployment info",
@@ -636,8 +665,8 @@ def activate_release(host_data, artifact_path):
                 f"python_path = venv_path + '/bin/python' if venv_path != 'unknown' else 'unknown'\n"
                 f"s = json.load(open('{state_file}'))\n"
                 f"s['slots']['{target_slot}'] = {{\n"
-                f"    'release': '{release_name}',\n"
-                f"    'commit': '{commit}',\n"
+                f"    'release': {safe_release},\n"
+                f"    'commit': {safe_commit},\n"
                 f"    'deployed_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),\n"
                 f"    'python_interpreter': python_path,\n"
                 f"    'venv_path': venv_path,\n"
@@ -658,13 +687,13 @@ def activate_release(host_data, artifact_path):
         def _print_deploy_summary(state_f, t_slot, rel, sock):
             info = _read_slot_info_from_remote(host, t_slot, state_f)
 
-            print(f"\n=== Blue-Green Deploy Summary ===")
+            print("\n=== Blue-Green Deploy Summary ===")
             print(f"  Slot:     {t_slot}")
             print(f"  Release:  {rel}")
             print(f"  Socket:   {sock}")
             print(f"  Venv:     {info.get('venv_path', 'unknown')}")
             print(f"  Python:   {info.get('python_interpreter', 'unknown')}")
-            print(f"\n  Status: staged (run 'djaploy activate' to switch traffic)\n")
+            print("\n  Status: staged (run 'djaploy activate' to switch traffic)\n")
 
         python_op.call(
             name="Print deployment summary",
@@ -735,19 +764,7 @@ def rollback_release(host_data, release=None):
         host.data._bluegreen_activated_slot = target_slot
 
         # Update nginx upstream for non-custom setups
-        ctx = build_template_context(host_data)
-        ctx["active_slot"] = target_slot
-        upstream_content = Environment().from_string(NGINX_UPSTREAM_BLUEGREEN).render(**ctx)
-
-        nginx_cfg = getattr(host_data, 'nginx_conf', None) or {}
-        if not nginx_cfg.get("custom"):
-            from pyinfra.operations import files
-            files.put(
-                name=f"Update nginx upstream to {target_slot} slot",
-                src=StringIO(upstream_content),
-                dest=f"/etc/nginx/sites-available/{app_name}-upstream.conf",
-                _sudo=True,
-            )
+        _update_nginx_upstream(host_data, app_name, target_slot)
 
         # Reload nginx
         server.shell(
@@ -769,7 +786,7 @@ def rollback_release(host_data, release=None):
 
         def _print_rollback_summary(state_f, t_slot, p_slot):
             info = _read_slot_info_from_remote(host, t_slot, state_f)
-            print(f"\n=== Blue-Green Rollback ===")
+            print("\n=== Blue-Green Rollback ===")
             print(f"  Switched:  {p_slot} -> {t_slot}")
             print(f"  Release:   {info.get('release', 'unknown')}")
             print(f"  Python:    {info.get('python_interpreter', 'unknown')}")
@@ -823,6 +840,7 @@ def activate_bluegreen(host_data):
     from pyinfra.facts.server import Command
     from djaploy.infra.utils import (
         is_bluegreen, get_app_path, get_slot_socket_path,
+        get_slot_service_name,
     )
     from djaploy.infra.bluegreen import (
         read_active_slot_cmd, set_active_slot_cmd, other_slot,
@@ -875,27 +893,47 @@ def activate_bluegreen(host_data):
     # Store on host.data so activate:post hooks can read it
     host.data._bluegreen_activated_slot = target_slot
 
-    # Update nginx upstream config to point to target slot
-    from io import StringIO
-    from djaploy.infra.templates import NGINX_UPSTREAM_BLUEGREEN, build_template_context
-    from jinja2 import Environment
-
-    ctx = build_template_context(host_data)
-    ctx["active_slot"] = target_slot
-    upstream_content = Environment().from_string(NGINX_UPSTREAM_BLUEGREEN).render(**ctx)
-
-    # Write the upstream config. Custom nginx setups (e.g. bostad) handle
-    # their own upstream file via activate:post hooks.
-    from pyinfra.operations import files
-    nginx_cfg = getattr(host_data, 'nginx_conf', None) or {}
-    if not nginx_cfg.get("custom"):
-        files.put(
-            name=f"Update nginx upstream to {target_slot} slot",
-            src=StringIO(upstream_content),
-            dest=f"/etc/nginx/sites-available/{app_name}-upstream.conf",
+    # Health check: verify all target slot services are running before
+    # switching nginx. Abort activation if any service is down.
+    services = getattr(host_data, "services", []) or []
+    failed_checks = []
+    for svc in services:
+        slot_svc = get_slot_service_name(svc, target_slot)
+        server.shell(
+            name=f"Health check: verify {slot_svc} is active",
+            commands=[
+                f"if systemctl is-active {slot_svc}.service > /dev/null 2>&1; then "
+                f"echo 'Health check passed: {slot_svc} is active'; "
+                f"else "
+                f"echo 'ACTIVATION ABORTED: {slot_svc} is not running.' && "
+                f"echo 'Check: systemctl status {slot_svc}.service' && "
+                f"exit 1; "
+                f"fi",
+            ],
             _sudo=True,
         )
 
+    # Extra gunicorn-specific check: verify the socket is responding
+    socket_path = get_slot_socket_path(app_name, target_slot)
+    server.shell(
+        name=f"Health check: verify {target_slot} gunicorn socket responds",
+        commands=[
+            f"if curl -sf --max-time 5 --unix-socket {socket_path} http://localhost/ > /dev/null 2>&1; then "
+            f"echo 'Health check passed: gunicorn socket is responding'; "
+            f"elif [ -S {socket_path} ]; then "
+            f"echo 'Health check: socket exists, HTTP may be non-200 (proceeding)'; "
+            f"else "
+            f"echo 'ACTIVATION ABORTED: gunicorn socket not responding.' && "
+            f"echo 'Socket: {socket_path}' && "
+            f"exit 1; "
+            f"fi",
+        ],
+        _sudo=True,
+    )
+
+    # Update nginx upstream config to point to target slot
+    _update_nginx_upstream(host_data, app_name, target_slot)
+
     # Reload nginx
     server.shell(
         name="Test and reload nginx",
@@ -905,7 +943,6 @@ def activate_bluegreen(host_data):
 
     # Update state.json on remote
     prev_slot = active_slot or "none"
-    socket_path = get_slot_socket_path(app_name, target_slot)
     server.shell(
         name=f"Set active slot to {target_slot}",
         commands=[set_active_slot_cmd(state_file, target_slot)],
@@ -920,7 +957,7 @@ def activate_bluegreen(host_data):
         new_info = _read_slot_info_from_remote(host, t_slot, state_f)
         old_info = _read_slot_info_from_remote(host, p_slot, state_f) if p_slot != "none" else {}
 
-        print(f"\n=== Blue-Green Activation ===")
+        print("\n=== Blue-Green Activation ===")
         print(f"  Switched:    {p_slot} -> {t_slot}")
         print(f"  Socket:      {sock} (now serving production)")
         print(f"  Deployed at: {new_info.get('deployed_at', 'unknown')}")
@@ -954,11 +991,3 @@ def activate_bluegreen(host_data):
         p_slot=prev_slot,
         sock=socket_path,
     )
-
-
-@deploy_hook("activate")
-def activate_bluegreen_status(host_data):
-    """Print full blue-green status during status command."""
-    # This hook is intentionally a no-op during activate —
-    # the main activate_bluegreen hook handles everything.
-    pass

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/infra/utils.py

@@ -526,8 +526,8 @@ def get_manage_py_path(host_data) -> str:
 def get_python_cmd(app_user: str, app_path: str, host_data) -> str:
     """Get the python command prefix for running management commands.
 
-    For zero-downtime deploys, uses the release's .venv/bin/python directly.
-    For in-place deploys, uses 'poetry run python'.
+    For zero-downtime and blue-green deploys, uses the release/slot's
+    .venv/bin/python directly.  For in-place deploys, uses 'poetry run python'.
     """
     if is_zero_downtime(host_data) or is_bluegreen(host_data):
         return f"{app_path}/.venv/bin/python"

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy/management/commands/djaploy.py

@@ -217,6 +217,8 @@ class Command(BaseCommand):
 
         # Pass --activate flag for bluegreen deploy+activate in one step
         if options.get("activate"):
+            if command_name != "deploy":
+                raise CommandError("--activate is only valid with the 'deploy' command")
             context["activate"] = True
             context["pyinfra_data"]["activate"] = "true"
 

{djaploy-1.2.5 → djaploy-1.2.7}/djaploy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.2.5
+Version: 1.2.7
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License
@@ -289,6 +289,8 @@ python manage.py djaploy rollback --env production
 3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
 4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
 
+> **Note:** Migrations run during Step 1, before traffic switches. Both the old and new slots share the same database, so migrations must be **backward-compatible** (use the expand/contract pattern). Deploy new code that handles both old and new schema, activate, then clean up in a subsequent deploy.
+
 ### Server directory layout comparison
 
 For `app_user="myapp-api"`, `app_name="myapp"`:

{djaploy-1.2.5 → djaploy-1.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "djaploy"
-version = "1.2.5"
+version = "1.2.7"
 description = "Modular Django deployment system based on pyinfra"
 authors = [
     {name = "Johanna Mae Dimayuga", email = "johanna@techco.fi"}

{djaploy-1.2.5 → djaploy-1.2.7}/tests/test_bluegreen.py

@@ -212,21 +212,22 @@ except ImportError:
 class TestBluegreenTemplateRender(unittest.TestCase):
     """Render blue-green templates with Jinja2 and verify output."""
 
-    SYSTEMD_CTX = dict(
-        project_name="myapp",
-        app_user="app",
-        slot="blue",
-        slot_path="/home/app/apps/myapp/slots/blue",
-        manage_subdir="",
-        workers=4,
-        timeout=30,
-        umask="002",
-        wsgi_module="myapp.wsgi:application",
-    )
+    def _base_ctx(self):
+        return dict(
+            project_name="myapp",
+            app_user="app",
+            slot="blue",
+            slot_path="/home/app/apps/myapp/slots/blue",
+            manage_subdir="",
+            workers=4,
+            timeout=30,
+            umask="002",
+            wsgi_module="myapp.wsgi:application",
+        )
 
     def _render(self, template_str, **overrides):
         from jinja2 import Environment
-        ctx = {**self.SYSTEMD_CTX, **overrides}
+        ctx = {**self._base_ctx(), **overrides}
         return Environment().from_string(template_str).render(**ctx)
 
     def test_systemd_renders_slot_in_socket_path(self):
@@ -482,5 +483,122 @@ class TestBluegreenHookDiscovery(unittest.TestCase):
             global_registry._hooks.update(saved_hooks)
 
 
+class TestBluegreenHealthCheck(unittest.TestCase):
+    """Test health check logic in activate hook."""
+
+    def test_health_check_socket_path_uses_target_slot(self):
+        """Health check should curl the target slot's socket."""
+        from djaploy.infra.utils import get_slot_socket_path
+        blue_socket = get_slot_socket_path("myapp", "blue")
+        green_socket = get_slot_socket_path("myapp", "green")
+        self.assertEqual(blue_socket, "/run/myapp-blue/myapp.sock")
+        self.assertEqual(green_socket, "/run/myapp-green/myapp.sock")
+        # Sockets must be different so health check targets the right slot
+        self.assertNotEqual(blue_socket, green_socket)
+
+    def test_health_check_service_name_uses_target_slot(self):
+        """Health check fallback should check the target slot's service."""
+        from djaploy.infra.utils import get_slot_service_name
+        self.assertEqual(get_slot_service_name("myapp", "blue"), "myapp-blue")
+        self.assertEqual(get_slot_service_name("myapp", "green"), "myapp-green")
+
+    def test_health_check_command_structure(self):
+        """Verify the health check shell command contains the expected elements."""
+        # Simulate what activate_bluegreen generates
+        app_name = "testapp"
+        target_slot = "green"
+        from djaploy.infra.utils import get_slot_socket_path
+        socket_path = get_slot_socket_path(app_name, target_slot)
+
+        # Build the command the same way the hook does
+        cmd = (
+            f"if curl -sf --max-time 5 --unix-socket {socket_path} http://localhost/ > /dev/null 2>&1; then "
+            f"echo 'Health check passed: {target_slot} slot is responding'; "
+            f"else "
+            f"if [ -S {socket_path} ] && systemctl is-active {app_name}-{target_slot}.service > /dev/null 2>&1; then "
+            f"echo 'Health check: {target_slot} slot service is active (HTTP response may be non-200, proceeding)'; "
+            f"else "
+            f"echo 'ACTIVATION ABORTED: {target_slot} slot is not responding.' && "
+            f"echo 'Socket: {socket_path}' && "
+            f"echo 'Check: systemctl status {app_name}-{target_slot}.service' && "
+            f"exit 1; "
+            f"fi; "
+            f"fi"
+        )
+
+        # Must curl the correct socket
+        self.assertIn(f"--unix-socket /run/testapp-green/testapp.sock", cmd)
+        # Must check the correct service on fallback
+        self.assertIn("systemctl is-active testapp-green.service", cmd)
+        # Must abort with exit 1 on failure
+        self.assertIn("exit 1", cmd)
+        # Must include the abort message
+        self.assertIn("ACTIVATION ABORTED", cmd)
+
+    def test_health_check_different_slots_produce_different_commands(self):
+        """Blue and green health checks should target different sockets."""
+        from djaploy.infra.utils import get_slot_socket_path
+        blue_cmd = f"curl --unix-socket {get_slot_socket_path('app', 'blue')}"
+        green_cmd = f"curl --unix-socket {get_slot_socket_path('app', 'green')}"
+        self.assertIn("app-blue", blue_cmd)
+        self.assertIn("app-green", green_cmd)
+        self.assertNotEqual(blue_cmd, green_cmd)
+
+
+class TestBluegreenServiceExistenceCheck(unittest.TestCase):
+    """Test that start_services checks unit file existence before starting."""
+
+    def test_service_check_command_structure(self):
+        """The start command should test for the unit file before starting."""
+        from djaploy.infra.utils import get_slot_service_name
+        slot_service = get_slot_service_name("myapp", "blue")
+
+        # Build the command the same way start_services does
+        cmd = (
+            f"test -f /etc/systemd/system/{slot_service}.service && "
+            f"systemctl enable {slot_service} && "
+            f"systemctl restart {slot_service} || "
+            f"echo 'Unit {slot_service}.service not found, skipping'"
+        )
+
+        self.assertIn("test -f /etc/systemd/system/myapp-blue.service", cmd)
+        self.assertIn("systemctl enable myapp-blue", cmd)
+        self.assertIn("systemctl restart myapp-blue", cmd)
+        self.assertIn("not found, skipping", cmd)
+
+    def test_streaming_service_gets_separate_slot_name(self):
+        """bostad-streaming should produce bostad-streaming-blue, not bostad-blue."""
+        from djaploy.infra.utils import get_slot_service_name
+        self.assertEqual(
+            get_slot_service_name("bostad-streaming", "blue"),
+            "bostad-streaming-blue",
+        )
+        self.assertEqual(
+            get_slot_service_name("bostad-streaming", "green"),
+            "bostad-streaming-green",
+        )
+
+
+class TestHeredocInjectionSafety(unittest.TestCase):
+    """Test that state.json update safely handles special characters."""
+
+    def test_release_name_with_quotes_is_safe(self):
+        """json.dumps should escape quotes in release names."""
+        import json
+        release = "feat/o'hare"
+        safe = json.dumps(release)
+        self.assertEqual(safe, '"feat/o\'hare"')
+        # Should be parseable back
+        self.assertEqual(json.loads(safe), release)
+
+    def test_commit_with_special_chars_is_safe(self):
+        """json.dumps should handle commit messages with special chars."""
+        import json
+        commit = 'fix: handle "edge" case'
+        safe = json.dumps(commit)
+        self.assertIn('\\"edge\\"', safe)
+        self.assertEqual(json.loads(safe), commit)
+
+
 if __name__ == "__main__":
     unittest.main()

{djaploy-1.2.5 → djaploy-1.2.7}/tests/test_borg.py

@@ -245,6 +245,36 @@ class TestBorgBackupScriptGeneration(unittest.TestCase):
         self.assertIn('MEDIA_DIR="/home/app/apps/myapp/media"', script)
         self.assertNotIn("/shared/media", script)
 
+    def test_script_default_media_path_bluegreen(self):
+        """Bluegreen deploys use shared/media by default (same as zero_downtime)."""
+        config = {"passphrase": "s", "repo_host": ""}
+        host_data = MagicMock()
+        host_data.app_name = "myapp"
+        host_data.db_dir = None
+        host_data.deployment_strategy = "bluegreen"
+        script = self._generate(config, app_user="app", host_data=host_data)
+        self.assertIn('MEDIA_DIR="/home/app/apps/myapp/shared/media"', script)
+
+    def test_script_default_db_path_bluegreen(self):
+        """Bluegreen db_path defaults to host db_dir or /home/{user}/dbs."""
+        config = {"passphrase": "s", "repo_host": ""}
+        host_data = MagicMock()
+        host_data.app_name = "myapp"
+        host_data.db_dir = "/home/app/dbs/myapp"
+        host_data.deployment_strategy = "bluegreen"
+        script = self._generate(config, app_user="app", host_data=host_data)
+        self.assertIn('DB_DIR="/home/app/dbs/myapp"', script)
+
+    def test_script_default_media_path_bluegreen_in_place(self):
+        """Bluegreen should NOT use the in_place media path."""
+        config = {"passphrase": "s", "repo_host": ""}
+        host_data = MagicMock()
+        host_data.app_name = "myapp"
+        host_data.db_dir = None
+        host_data.deployment_strategy = "bluegreen"
+        script = self._generate(config, app_user="app", host_data=host_data)
+        self.assertNotIn('MEDIA_DIR="/home/app/apps/myapp/media"', script)
+
     def test_script_explicit_media_path_overrides_strategy(self):
         """Explicit media_path overrides the strategy-derived default."""
         config = {"passphrase": "s", "repo_host": "", "media_path": "/custom/media"}