velocity-python 0.1.22__tar.gz → 0.1.24__tar.gz

{velocity_python-0.1.22/src/velocity_python.egg-info → velocity_python-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.22
+Version: 0.1.24
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.22 → velocity_python-0.1.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.22"
+version = "0.1.24"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.22 → velocity_python-0.1.24}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.22"
+__version__ = version = "0.1.24"
 
 import importlib as _importlib
 

{velocity_python-0.1.22 → velocity_python-0.1.24}/src/velocity/aws/amplify_build.py

@@ -235,6 +235,36 @@ def retryable_call(
             raise
 
 
+def resolve_latest_layer_arns(
+    lambda_client,
+    current_layers: Sequence[Mapping[str, Any]],
+) -> Sequence[str]:
+    updated_layer_arns = []
+
+    for layer in current_layers or ():
+        layer_arn = layer["Arn"]
+        layer_name = layer_arn.split(":")[-2]
+        current_version = layer_arn.split(":")[-1]
+
+        latest_response = retryable_call(
+            lambda_client.list_layer_versions,
+            LayerName=layer_name,
+            MaxItems=1,
+        )
+
+        if latest_response and latest_response.get("LayerVersions"):
+            latest_version_info = latest_response["LayerVersions"][0]
+            latest_version = latest_version_info["Version"]
+            latest_arn = latest_version_info["LayerVersionArn"]
+            updated_layer_arns.append(
+                latest_arn if str(latest_version) != str(current_version) else layer_arn
+            )
+        else:
+            updated_layer_arns.append(layer_arn)
+
+    return updated_layer_arns
+
+
 def _serialize_policy_document(policy_document: Any) -> str:
     if isinstance(policy_document, str):
         return policy_document
@@ -443,6 +473,16 @@ def run_backend_deployment(
 
         timeout_value = config.resolve_timeout(function_name)
         memory_value = config.resolve_memory_size(function_name)
+        layers_value = None
+        current_layers = function.get("Layers") or []
+        if current_layers:
+            try:
+                layers_value = list(resolve_latest_layer_arns(lambda_client, current_layers))
+            except Exception as exc:
+                print(
+                    f"[WARN] Unable to resolve latest layers for {function_name}: {exc}. "
+                    "Keeping current layer attachments."
+                )
         print(
             f"[INFO] Updating Lambda function {function_name} with timeout={timeout_value}"
             + (
@@ -456,6 +496,7 @@ def run_backend_deployment(
             memory_size=memory_value,
             subnet_ids=subnet_ids,
             security_group_ids=security_group_ids,
+            layers=layers_value,
         )
 
         if not set_cloudwatch_logging(
@@ -563,44 +604,34 @@ def update_lambda_layers_to_latest(
                 layer_arn = layer["Arn"]
                 layer_name = layer_arn.split(":")[-2]
                 current_version = layer_arn.split(":")[-1]
-
                 print(
                     f"[INFO] Processing layer: {layer_name} (current version: {current_version})"
                 )
 
-                try:
-                    latest_response = retryable_call(
-                        lambda_client.list_layer_versions,
-                        LayerName=layer_name,
-                        MaxItems=1,
+            try:
+                updated_layer_arns = list(
+                    resolve_latest_layer_arns(lambda_client, current_layers)
+                )
+            except Exception as exc:
+                print(f"[ERROR] Failed to resolve latest layers: {exc}")
+                print("[INFO] Keeping current layer versions")
+                updated_layer_arns = [layer["Arn"] for layer in current_layers]
+
+            for original_arn, updated_arn in zip(
+                [layer["Arn"] for layer in current_layers],
+                updated_layer_arns,
+            ):
+                layer_name = original_arn.split(":")[-2]
+                current_version = original_arn.split(":")[-1]
+                latest_version = updated_arn.split(":")[-1]
+                if updated_arn != original_arn:
+                    print(
+                        f"[INFO] Updating {layer_name}: v{current_version} -> v{latest_version}"
                     )
-
-                    if latest_response and latest_response.get("LayerVersions"):
-                        latest_version_info = latest_response["LayerVersions"][0]
-                        latest_version = latest_version_info["Version"]
-                        latest_arn = latest_version_info["LayerVersionArn"]
-
-                        if str(latest_version) != str(current_version):
-                            print(
-                                f"[INFO] Updating {layer_name}: v{current_version} -> v{latest_version}"
-                            )
-                            updated_layer_arns.append(latest_arn)
-                        else:
-                            print(
-                                f"[INFO] {layer_name} is already at latest version (v{latest_version})"
-                            )
-                            updated_layer_arns.append(layer_arn)
-                    else:
-                        print(
-                            f"[WARN] No versions found for layer {layer_name}, keeping current version"
-                        )
-                        updated_layer_arns.append(layer_arn)
-                except Exception as exc:
+                else:
                     print(
-                        f"[ERROR] Failed to get latest version for layer {layer_name}: {exc}"
+                        f"[INFO] {layer_name} is already at latest version (v{latest_version})"
                     )
-                    print(f"[INFO] Keeping current version for {layer_name}")
-                    updated_layer_arns.append(layer_arn)
 
             current_layer_arns = [layer["Arn"] for layer in current_layers]
             if updated_layer_arns != current_layer_arns:

velocity_python-0.1.24/src/velocity/aws/ssm_config.py

@@ -0,0 +1,94 @@
+"""
+SSM-backed configuration with environment-variable fallback.
+
+Opt-in: set ``VELOCITY_SSM_ENABLED=true`` in your Amplify environment variables
+(pushed via ``bootstrap.py secrets``).
+
+When enabled, ``getenv(key)`` reads from SSM at::
+
+    /{ProjectName}/{ENV}/{key}
+
+and falls back to ``os.environ`` on a miss or any error.  Results are cached
+for the process lifetime so SSM is called at most once per key per Lambda
+cold start.
+
+When **not** enabled (the default), ``getenv`` is a thin wrapper around
+``os.environ.get`` with zero extra overhead — preserving full backward
+compatibility for projects that don't use SSM (e.g. caringcent).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Per-process cache: key → value (str) or sentinel _MISS.
+_MISS = object()
+_cache: dict[str, object] = {}
+
+# Lazily evaluated once per process.
+_SSM_ENABLED: bool | None = None
+
+
+def _is_enabled() -> bool:
+    global _SSM_ENABLED
+    if _SSM_ENABLED is None:
+        _SSM_ENABLED = os.environ.get('VELOCITY_SSM_ENABLED', '').lower() in ('1', 'true', 'yes')
+    return _SSM_ENABLED
+
+
+def _ssm_prefix() -> str | None:
+    """Return '/{ProjectName}/{ENV}' or None if either var is missing."""
+    project = os.environ.get('ProjectName')
+    env = os.environ.get('ENV')
+    if project and env:
+        return f'/{project}/{env}'
+    return None
+
+
+def _fetch(key: str) -> str | None:
+    """Single SSM GetParameter call; returns value or None on any failure."""
+    prefix = _ssm_prefix()
+    if prefix is None:
+        return None
+    param_name = f'{prefix}/{key}'
+    try:
+        import boto3
+        ssm = boto3.client('ssm', region_name=os.environ.get('REGION', 'us-east-1'))
+        resp = ssm.get_parameter(Name=param_name, WithDecryption=True)
+        return resp['Parameter']['Value']
+    except Exception as exc:
+        logger.debug('SSM miss for %s: %s', param_name, exc)
+        return None
+
+
+def getenv(key: str, default: Optional[str] = None) -> Optional[str]:
+    """
+    Read a config value, checking SSM before ``os.environ``.
+
+    SSM is only consulted when ``VELOCITY_SSM_ENABLED=true`` is set in the
+    Lambda environment *and* both ``ProjectName`` and ``ENV`` are present.
+    All other cases fall straight through to ``os.environ``.
+
+    Results are cached per process so SSM is queried at most once per key
+    per Lambda cold start.
+    """
+    if _is_enabled():
+        if key not in _cache:
+            value = _fetch(key)
+            _cache[key] = value if value is not None else _MISS
+        cached = _cache[key]
+        if cached is not _MISS:
+            return cached  # type: ignore[return-value]
+
+    return os.environ.get(key, default)
+
+
+def clear_cache() -> None:
+    """Clear the SSM cache (useful in tests)."""
+    _cache.clear()
+    global _SSM_ENABLED
+    _SSM_ENABLED = None

{velocity_python-0.1.22 → velocity_python-0.1.24}/src/velocity/db/core/async_support.py

@@ -493,10 +493,18 @@ class AsyncTransaction:
 
         # R12 — Slow query logging
         if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
+            from velocity.db.core.transaction import _summarize_sql
+
+            sql_preview = _summarize_sql(sql)
             _logger.warning(
                 "Slow async query: %.1f ms sql=%s",
-                elapsed_ms, sql[:200],
-                extra={"query_duration_ms": round(elapsed_ms, 1)},
+                elapsed_ms,
+                sql_preview,
+                extra={
+                    "query_duration_ms": round(elapsed_ms, 1),
+                    "sql_preview": sql_preview,
+                },
+                stack_info=True,
             )
 
         # R14 — N+1 detection

{velocity_python-0.1.22 → velocity_python-0.1.24}/src/velocity/db/core/transaction.py

@@ -23,6 +23,7 @@ _DEFAULT_QUERY_CACHE_SIZE = int(os.environ.get("VELOCITY_QUERY_CACHE_SIZE", "100
 
 # Slow-query threshold in milliseconds (0 = disabled).
 _SLOW_QUERY_MS = int(os.environ.get("VELOCITY_SLOW_QUERY_MS", "500"))
+_SLOW_QUERY_SQL_CHARS = int(os.environ.get("VELOCITY_SLOW_QUERY_SQL_CHARS", "4000"))
 
 # N+1 detection: warn when the same table is SELECTed more than this many
 # times within a single transaction.  0 = disabled.  Only active when the
@@ -76,6 +77,16 @@ def _extract_table_name(sql):
     return None
 
 
+def _summarize_sql(sql, limit=None):
+    if not sql:
+        return None
+    compact = " ".join(str(sql).split())
+    max_chars = _SLOW_QUERY_SQL_CHARS if limit is None else limit
+    if max_chars and len(compact) > max_chars:
+        return compact[:max_chars] + "... [truncated]"
+    return compact
+
+
 class Transaction:
     """
     Encapsulates a single transaction in the database (connection + commit/rollback).
@@ -210,14 +221,17 @@ class Transaction:
         if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
             op = _classify_sql(sql)
             tbl = _extract_table_name(sql)
+            sql_preview = _summarize_sql(sql)
             _logger.warning(
-                "Slow query (%s): %.1f ms table=%s",
-                op, elapsed_ms, tbl,
+                "Slow query (%s): %.1f ms table=%s sql=%s",
+                op, elapsed_ms, tbl, sql_preview,
                 extra={
                     "query_duration_ms": round(elapsed_ms, 1),
                     "table_name": tbl,
                     "operation": op,
+                    "sql_preview": sql_preview,
                 },
+                stack_info=True,
             )
 
         # R14 — N+1 detection (only when debug=True).

{velocity_python-0.1.22 → velocity_python-0.1.24}/src/velocity/db/servers/postgres/__init__.py

@@ -1,6 +1,7 @@
 import os
 from ..base.initializer import BaseInitializer
 from velocity.db.core import engine
+from velocity.aws.ssm_config import getenv as _getenv
 
 
 # Default TCP keepalive settings for PostgreSQL connections.
@@ -41,14 +42,14 @@ class PostgreSQLInitializer(BaseInitializer):
 
         from .sql import SQL
 
-        # Base configuration from environment
+        # Base configuration from environment / SSM
         # psycopg v3 uses libpq param names; 'dbname' not 'database'.
         base_config = {
-            "dbname": os.environ.get("DBDatabase"),
-            "host": os.environ.get("DBHost"),
-            "port": os.environ.get("DBPort"),
-            "user": os.environ.get("DBUser"),
-            "password": os.environ.get("DBPassword"),
+            "dbname": _getenv("DBDatabase"),
+            "host": _getenv("DBHost"),
+            "port": _getenv("DBPort"),
+            "user": _getenv("DBUser"),
+            "password": _getenv("DBPassword"),
         }
 
         # Remove None values
@@ -65,7 +66,7 @@ class PostgreSQLInitializer(BaseInitializer):
 
         # SSL mode — default to "prefer" so connections upgrade when the
         # server supports TLS but don't fail when it doesn't.
-        ssl_mode = os.environ.get("VELOCITY_SSL_MODE")
+        ssl_mode = _getenv("VELOCITY_SSL_MODE")
         if ssl_mode:
             final_config.setdefault("sslmode", ssl_mode)
 
@@ -108,11 +109,11 @@ def initialize(config=None, schema_locked=False, **kwargs):
     from .sql import SQL
 
     konfig = {
-        "dbname": os.environ["DBDatabase"],
-        "host": os.environ["DBHost"],
-        "port": os.environ["DBPort"],
-        "user": os.environ["DBUser"],
-        "password": os.environ["DBPassword"],
+        "dbname": _getenv("DBDatabase") or os.environ["DBDatabase"],
+        "host": _getenv("DBHost") or os.environ["DBHost"],
+        "port": _getenv("DBPort") or os.environ["DBPort"],
+        "user": _getenv("DBUser") or os.environ["DBUser"],
+        "password": _getenv("DBPassword") or os.environ["DBPassword"],
     }
     konfig.update(config or {})
     konfig.update(kwargs)
@@ -122,7 +123,7 @@ def initialize(config=None, schema_locked=False, **kwargs):
         konfig.setdefault(key, default_val)
 
     # SSL mode.
-    ssl_mode = os.environ.get("VELOCITY_SSL_MODE")
+    ssl_mode = _getenv("VELOCITY_SSL_MODE")
     if ssl_mode:
         konfig.setdefault("sslmode", ssl_mode)
 

{velocity_python-0.1.22 → velocity_python-0.1.24/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.22
+Version: 0.1.24
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.22 → velocity_python-0.1.24}/src/velocity_python.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/velocity/aws/__init__.py
 src/velocity/aws/amplify.py
 src/velocity/aws/amplify_build.py
 src/velocity/aws/s3.py
+src/velocity/aws/ssm_config.py
 src/velocity/aws/handlers/__init__.py
 src/velocity/aws/handlers/base_handler.py
 src/velocity/aws/handlers/context.py

velocity_python-0.1.24/tests/test_amplify_build.py

@@ -0,0 +1,150 @@
+from velocity.aws.amplify_build import (
+    BackendDeploymentConfig,
+    build_environment_variables,
+    get_amplify_app_id_and_branch,
+    run_backend_deployment,
+)
+
+
+class FakeAmplifyProject:
+    def get_merged_env_vars(self, branch):
+        return {"EXISTING": branch}
+
+    def get_region(self):
+        return "us-east-1"
+
+
+class FakeDeployProject(FakeAmplifyProject):
+    def __init__(self):
+        self.updated_functions = []
+
+    def list_lambda_functions_filtered(self, branch):
+        return [
+            {
+                "FunctionName": f"ClientEvents-{branch}",
+                "Layers": [
+                    {
+                        "Arn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:225"
+                    },
+                    {
+                        "Arn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34"
+                    },
+                ],
+            }
+        ]
+
+    def update_lambda_function(self, **kwargs):
+        self.updated_functions.append(kwargs)
+
+
+class FakeLambdaClient:
+    def list_layer_versions(self, LayerName, MaxItems):
+        versions = {
+            "py-lib-support": [
+                {
+                    "Version": 240,
+                    "LayerVersionArn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:240",
+                }
+            ],
+            "py-lib-accounting": [
+                {
+                    "Version": 34,
+                    "LayerVersionArn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34",
+                }
+            ],
+        }
+        return {"LayerVersions": versions[LayerName][:MaxItems]}
+
+
+def test_backend_deployment_config_resolves_queue_timeout_and_memory_size():
+    config = BackendDeploymentConfig(
+        queue_name_template="clients-queue-{branch}",
+        short_timeout_tokens=("Events", "Data"),
+        memory_size_by_token={"QueueHandler": 1024, "Events": 512},
+    )
+
+    assert config.resolve_queue_name("Demo") == "clients-queue-demo"
+    assert config.resolve_timeout("ClientEvents-demo") == 60
+    assert config.resolve_timeout("ClientUtility-demo") == 900
+    assert config.resolve_memory_size("ClientQueueHandler-demo") == 1024
+    assert config.resolve_memory_size("ClientEvents-demo") == 512
+    assert config.resolve_memory_size("ClientUtility-demo") is None
+
+
+def test_build_environment_variables_reads_project_metadata(tmp_path, monkeypatch):
+    amplify_dir = tmp_path / "amplify" / "backend"
+    amplify_dir.mkdir(parents=True)
+    (amplify_dir / "amplify-meta.json").write_text('{"UserPoolId": "us-east-1_demoPool",}')
+
+    monkeypatch.setenv("AWS_JOB_ID", "job-123")
+    app = FakeAmplifyProject()
+
+    env_vars = build_environment_variables(
+        app,
+        "demo",
+        "clients-queue-demo",
+        project_root=tmp_path,
+    )
+
+    assert env_vars["EXISTING"] == "demo"
+    assert env_vars["SqsWorkQueue"] == "clients-queue-demo"
+    assert env_vars["AWS_JOB_ID"] == "job-123"
+    assert env_vars["AWS_USER_POOL_ID"] == "us-east-1_demoPool"
+    assert env_vars["USER_BRANCH"] == "demo"
+    assert env_vars["REACT_APP_USER_BRANCH"] == "demo"
+    assert env_vars["USER_REGION"] == "us-east-1"
+    assert env_vars["LOGLEVEL"] == "INFO"
+    assert "BUILD_DATETIME" in env_vars
+
+
+def test_get_amplify_app_id_and_branch_uses_team_provider_info(tmp_path, monkeypatch):
+    team_provider_path = tmp_path / "amplify"
+    team_provider_path.mkdir(parents=True)
+    (team_provider_path / "team-provider-info.json").write_text(
+        '{"demo": {"awscloudformation": {"AmplifyAppId": "app-123"}}}'
+    )
+
+    monkeypatch.setenv("AWS_BRANCH", "demo")
+    monkeypatch.delenv("AWS_APP_ID", raising=False)
+
+    app_id, branch = get_amplify_app_id_and_branch(tmp_path)
+
+    assert app_id == "app-123"
+    assert branch == "demo"
+
+
+def test_run_backend_deployment_refreshes_lambda_layers(monkeypatch, tmp_path):
+    monkeypatch.setattr(
+        "velocity.aws.amplify_build.ensure_lambda_policies_and_attach",
+        lambda *args, **kwargs: None,
+    )
+    monkeypatch.setattr(
+        "velocity.aws.amplify_build.set_cloudwatch_logging",
+        lambda *args, **kwargs: True,
+    )
+
+    app = FakeDeployProject()
+    config = BackendDeploymentConfig(
+        queue_name_template="clients-queue-{branch}",
+        short_timeout_tokens=("Events",),
+        memory_size_by_token={"Events": 512},
+    )
+
+    run_backend_deployment(
+        "app-123",
+        "demo",
+        config,
+        project_root=tmp_path,
+        app=app,
+        lambda_client=FakeLambdaClient(),
+        logs_client=object(),
+    )
+
+    assert len(app.updated_functions) == 1
+    assert app.updated_functions[0]["function_name"] == "ClientEvents-demo"
+    assert app.updated_functions[0]["timeout"] == 60
+    assert app.updated_functions[0]["memory_size"] == 512
+    assert app.updated_functions[0]["layers"] == [
+        "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:240",
+        "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34",
+    ]

{velocity_python-0.1.22 → velocity_python-0.1.24}/tests/test_async_support.py

@@ -687,3 +687,8 @@ class TestAsyncSlowQueryLogging:
                     if "Slow" in str(c)
                 ]
                 assert len(slow_calls) >= 1
+                args = slow_calls[0].args
+                kwargs = slow_calls[0].kwargs
+                assert args[2] == "SELECT * FROM large_table"
+                assert kwargs["extra"]["sql_preview"] == "SELECT * FROM large_table"
+                assert kwargs["stack_info"] is True

{velocity_python-0.1.22 → velocity_python-0.1.24}/tests/test_observability.py

@@ -177,6 +177,7 @@ class TestSlowQueryLogging:
 
         assert any("Slow query" in r.message for r in caplog.records)
         assert any("big_table" in r.message for r in caplog.records)
+        assert any("sql=SELECT * FROM big_table" in r.message for r in caplog.records)
 
     def test_fast_query_no_warning(self, caplog):
         tx = _make_tx()
@@ -230,6 +231,8 @@ class TestSlowQueryLogging:
         assert rec.query_duration_ms > 0
         assert rec.table_name == "orders"
         assert rec.operation == "SELECT"
+        assert rec.sql_preview == "SELECT * FROM orders WHERE id = 1"
+        assert rec.stack_info
 
 
 # ──────────────────────────────────────────────────────────────────────

velocity_python-0.1.22/tests/test_amplify_build.py

@@ -1,70 +0,0 @@
-from velocity.aws.amplify_build import (
-    BackendDeploymentConfig,
-    build_environment_variables,
-    get_amplify_app_id_and_branch,
-)
-
-
-class FakeAmplifyProject:
-    def get_merged_env_vars(self, branch):
-        return {"EXISTING": branch}
-
-    def get_region(self):
-        return "us-east-1"
-
-
-def test_backend_deployment_config_resolves_queue_timeout_and_memory_size():
-    config = BackendDeploymentConfig(
-        queue_name_template="clients-queue-{branch}",
-        short_timeout_tokens=("Events", "Data"),
-        memory_size_by_token={"QueueHandler": 1024, "Events": 512},
-    )
-
-    assert config.resolve_queue_name("Demo") == "clients-queue-demo"
-    assert config.resolve_timeout("ClientEvents-demo") == 60
-    assert config.resolve_timeout("ClientUtility-demo") == 900
-    assert config.resolve_memory_size("ClientQueueHandler-demo") == 1024
-    assert config.resolve_memory_size("ClientEvents-demo") == 512
-    assert config.resolve_memory_size("ClientUtility-demo") is None
-
-
-def test_build_environment_variables_reads_project_metadata(tmp_path, monkeypatch):
-    amplify_dir = tmp_path / "amplify" / "backend"
-    amplify_dir.mkdir(parents=True)
-    (amplify_dir / "amplify-meta.json").write_text('{"UserPoolId": "us-east-1_demoPool",}')
-
-    monkeypatch.setenv("AWS_JOB_ID", "job-123")
-    app = FakeAmplifyProject()
-
-    env_vars = build_environment_variables(
-        app,
-        "demo",
-        "clients-queue-demo",
-        project_root=tmp_path,
-    )
-
-    assert env_vars["EXISTING"] == "demo"
-    assert env_vars["SqsWorkQueue"] == "clients-queue-demo"
-    assert env_vars["AWS_JOB_ID"] == "job-123"
-    assert env_vars["AWS_USER_POOL_ID"] == "us-east-1_demoPool"
-    assert env_vars["USER_BRANCH"] == "demo"
-    assert env_vars["REACT_APP_USER_BRANCH"] == "demo"
-    assert env_vars["USER_REGION"] == "us-east-1"
-    assert env_vars["LOGLEVEL"] == "INFO"
-    assert "BUILD_DATETIME" in env_vars
-
-
-def test_get_amplify_app_id_and_branch_uses_team_provider_info(tmp_path, monkeypatch):
-    team_provider_path = tmp_path / "amplify"
-    team_provider_path.mkdir(parents=True)
-    (team_provider_path / "team-provider-info.json").write_text(
-        '{"demo": {"awscloudformation": {"AmplifyAppId": "app-123"}}}'
-    )
-
-    monkeypatch.setenv("AWS_BRANCH", "demo")
-    monkeypatch.delenv("AWS_APP_ID", raising=False)
-
-    app_id, branch = get_amplify_app_id_and_branch(tmp_path)
-
-    assert app_id == "app-123"
-    assert branch == "demo"