refact: better named module and functions

Author: sfermigier

packages/hop3-server/src/hop3/deployers/addon_provisioning.py

@@ -19,9 +19,10 @@
 
 from hop3.core.credentials import get_credential_encryptor
 from hop3.core.plugins import get_addon
+from hop3.deployers.env_provisioning import set_env_vars
 from hop3.lib import log
 from hop3.lib.logging import server_log
-from hop3.orm import AddonCredential, EnvVar
+from hop3.orm import AddonCredential
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
@@ -155,7 +156,7 @@ def _provision_single_addon(
         db_session.add(credential)
 
     # Add env vars to app (addons can update existing values, e.g., when password changes)
-    _inject_env_vars(app, connection_details, db_session)
+    set_env_vars(app, connection_details, db_session)
 
     log(f"  Attached addon {addon_name} to {app.name}", level=1, fg="green")
     server_log.info(
@@ -165,80 +166,3 @@ def _provision_single_addon(
         app_name=app.name,
         env_vars=list(connection_details.keys()),
     )
-
-
-def inject_config_env_vars(
-    app: App,
-    env_config: dict[str, str],
-    db_session: Session,
-) -> None:
-    """Inject environment variables from hop3.toml [env] section.
-
-    These are treated as defaults: they will only be set if the variable
-    doesn't exist or was previously set from hop3.toml. User-set values
-    (via config:set) and addon values are preserved.
-
-    Args:
-        app: The application model
-        env_config: Dict of env var name -> value from hop3.toml
-        db_session: Database session for persistence
-    """
-    if not env_config:
-        return
-
-    server_log.info(
-        "Injecting env vars from config",
-        app_name=app.name,
-        env_var_count=len(env_config),
-    )
-
-    injected_count = _inject_env_vars(app, env_config, db_session, defaults_only=True)
-
-    log(
-        f"  Injected {injected_count} env var(s) from hop3.toml",
-        level=1,
-        fg="green",
-    )
-
-
-def _inject_env_vars(
-    app: App,
-    env_vars: dict[str, str],
-    db_session: Session,
-    *,
-    defaults_only: bool = False,
-) -> int:
-    """Inject environment variables into an app.
-
-    Args:
-        app: The application model
-        env_vars: Dict of env var name -> value
-        db_session: Database session for persistence
-        defaults_only: If True, only create new vars, never overwrite existing ones
-
-    Returns:
-        Number of env vars actually injected/updated
-    """
-    injected = 0
-
-    for key, value in env_vars.items():
-        # Check if variable already exists
-        existing = None
-        for env_var in app.env_vars:
-            if env_var.name == key:
-                existing = env_var
-                break
-
-        if existing:
-            if defaults_only:
-                # hop3.toml provides defaults only - don't overwrite
-                continue
-            existing.value = str(value)
-            injected += 1
-        else:
-            new_var = EnvVar(app_id=app.id, name=key, value=str(value))
-            db_session.add(new_var)
-            app.env_vars.append(new_var)
-            injected += 1
-
-    return injected

packages/hop3-server/src/hop3/deployers/deployer.py

@@ -8,7 +8,8 @@
 from hop3.core.manifest import RuntimeManifestBuilder
 from hop3.core.plugins import get_builder, get_deployment_strategy
 from hop3.core.protocols import DeploymentContext
-from hop3.deployers.addon_provisioning import inject_config_env_vars, provision_addons
+from hop3.deployers.addon_provisioning import provision_addons
+from hop3.deployers.env_provisioning import set_default_env_vars
 from hop3.lib import Abort, log, shell
 from hop3.lib.logging import server_log
 from hop3.orm.app import AppStateEnum
@@ -416,7 +417,7 @@ def _process_config_dependencies(
             level=1,
             fg="blue",
         )
-        inject_config_env_vars(app, env_config, db_session)
+        set_default_env_vars(app, env_config, db_session)
 
     # Commit changes before continuing with build
     if addon_configs or env_config:

packages/hop3-server/src/hop3/deployers/env_provisioning.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2025, Abilian SAS
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Environment variable provisioning during deployment.
+
+This module handles injection of environment variables from hop3.toml [env] section.
+Values from hop3.toml are treated as defaults - they only create new variables
+and never overwrite existing ones (set via config:set or addon provisioning).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hop3.lib import log
+from hop3.lib.logging import server_log
+from hop3.orm import EnvVar
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+    from hop3.orm.app import App
+
+
+def set_default_env_vars(
+    app: App,
+    env_config: dict[str, str],
+    db_session: Session,
+) -> None:
+    """Set default environment variables from hop3.toml [env] section.
+
+    These are defaults only: they create new variables but never overwrite
+    existing ones. User-set values (via config:set) and addon values are preserved.
+
+    Args:
+        app: The application model
+        env_config: Dict of env var name -> value from hop3.toml
+        db_session: Database session for persistence
+    """
+    if not env_config:
+        return
+
+    server_log.info(
+        "Setting default env vars from config",
+        app_name=app.name,
+        env_var_count=len(env_config),
+    )
+
+    injected_count = set_env_vars(app, env_config, db_session, defaults_only=True)
+
+    log(
+        f"  Set {injected_count} env var(s) from hop3.toml",
+        level=1,
+        fg="green",
+    )
+
+
+def set_env_vars(
+    app: App,
+    env_vars: dict[str, str],
+    db_session: Session,
+    *,
+    defaults_only: bool = False,
+) -> int:
+    """Set environment variables on an app.
+
+    Args:
+        app: The application model
+        env_vars: Dict of env var name -> value
+        db_session: Database session for persistence
+        defaults_only: If True, only create new vars, never overwrite existing ones
+
+    Returns:
+        Number of env vars actually set/updated
+    """
+    count = 0
+
+    for key, value in env_vars.items():
+        existing = None
+        for env_var in app.env_vars:
+            if env_var.name == key:
+                existing = env_var
+                break
+
+        if existing:
+            if defaults_only:
+                continue
+            existing.value = str(value)
+            count += 1
+        else:
+            new_var = EnvVar(app_id=app.id, name=key, value=str(value))
+            db_session.add(new_var)
+            app.env_vars.append(new_var)
+            count += 1
+
+    return count

packages/hop3-server/tests/a_unit/test_addon_provisioning.py

@@ -10,11 +10,8 @@
 
 import pytest
 
-from hop3.deployers.addon_provisioning import (
-    _inject_env_vars,
-    inject_config_env_vars,
-    provision_addons,
-)
+from hop3.deployers.addon_provisioning import provision_addons
+from hop3.deployers.env_provisioning import set_default_env_vars, set_env_vars
 
 
 @pytest.fixture
@@ -35,23 +32,23 @@ def mock_db_session():
     return session
 
 
-class TestInjectEnvVars:
-    """Tests for _inject_env_vars function."""
+class TestSetEnvVars:
+    """Tests for set_env_vars function."""
 
-    def test_inject_new_env_vars(self, mock_app, mock_db_session):
-        """Test injecting new environment variables."""
+    def test_set_new_env_vars(self, mock_app, mock_db_session):
+        """Test setting new environment variables."""
         env_vars = {
             "DATABASE_URL": "postgres://localhost/db",
             "REDIS_URL": "redis://localhost:6379",
         }
 
-        _inject_env_vars(mock_app, env_vars, mock_db_session)
+        set_env_vars(mock_app, env_vars, mock_db_session)
 
         # Should have added 2 new env vars
         assert len(mock_app.env_vars) == 2
         assert mock_db_session.add.call_count == 2
 
-    def test_inject_updates_existing_env_var(self, mock_app, mock_db_session):
+    def test_set_updates_existing_env_var(self, mock_app, mock_db_session):
         """Test updating existing environment variable."""
         # Simulate existing env var
         existing_var = MagicMock()
@@ -61,38 +58,52 @@ def test_inject_updates_existing_env_var(self, mock_app, mock_db_session):
 
         env_vars = {"DATABASE_URL": "new_value"}
 
-        _inject_env_vars(mock_app, env_vars, mock_db_session)
+        set_env_vars(mock_app, env_vars, mock_db_session)
 
         # Should have updated the existing var
         assert existing_var.value == "new_value"
         # Should not have added new env vars
         assert mock_db_session.add.call_count == 0
 
-    def test_inject_empty_env_vars(self, mock_app, mock_db_session):
-        """Test injecting empty env vars dict does nothing."""
-        _inject_env_vars(mock_app, {}, mock_db_session)
+    def test_set_empty_env_vars(self, mock_app, mock_db_session):
+        """Test setting empty env vars dict does nothing."""
+        set_env_vars(mock_app, {}, mock_db_session)
 
         assert mock_db_session.add.call_count == 0
         assert len(mock_app.env_vars) == 0
 
+    def test_defaults_only_skips_existing(self, mock_app, mock_db_session):
+        """Test that defaults_only=True skips existing variables."""
+        existing_var = MagicMock()
+        existing_var.name = "SECRET_KEY"
+        existing_var.value = "user-set-value"
+        mock_app.env_vars = [existing_var]
+
+        env_vars = {"SECRET_KEY": "default-value"}
+
+        set_env_vars(mock_app, env_vars, mock_db_session, defaults_only=True)
+
+        # Should NOT have updated the existing var
+        assert existing_var.value == "user-set-value"
+
 
-class TestInjectConfigEnvVars:
-    """Tests for inject_config_env_vars function."""
+class TestSetDefaultEnvVars:
+    """Tests for set_default_env_vars function."""
 
-    def test_inject_config_env_vars(self, mock_app, mock_db_session):
-        """Test injecting env vars from config."""
+    def test_set_default_env_vars(self, mock_app, mock_db_session):
+        """Test setting default env vars from config."""
         env_config = {
             "DEBUG": "false",
             "SECRET_KEY": "mysecret",
         }
 
-        inject_config_env_vars(mock_app, env_config, mock_db_session)
+        set_default_env_vars(mock_app, env_config, mock_db_session)
 
         assert len(mock_app.env_vars) == 2
 
-    def test_inject_config_env_vars_empty(self, mock_app, mock_db_session):
+    def test_set_default_env_vars_empty(self, mock_app, mock_db_session):
         """Test that empty config does nothing."""
-        inject_config_env_vars(mock_app, {}, mock_db_session)
+        set_default_env_vars(mock_app, {}, mock_db_session)
 
         assert len(mock_app.env_vars) == 0