feat(test-runner): support running tests against external server

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: socksy

tests/integration/features/steps/cli_steps.py

@@ -30,8 +30,11 @@ def step_run_cli_command(context, command):
         test_env = os.environ.copy()
         test_env["FORCE_COLOR"] = "1"  # Force colored output
         test_env["CLICOLOR_FORCE"] = "1"  # Force colored output
-        test_env["TOWER_URL"] = context.tower_url  # Use mock API
-        test_env["TOWER_JWT"] = "mock_jwt_token"
+        test_env["TOWER_URL"] = context.tower_url  # Use configured API URL
+
+        # Only set mock JWT if not already configured externally
+        if "TOWER_JWT" not in os.environ:
+            test_env["TOWER_JWT"] = "mock_jwt_token"
 
         # Override HOME to use test session
         test_home = Path(__file__).parent.parent.parent / "test-home"
@@ -45,9 +48,11 @@ def step_run_cli_command(context, command):
             env=test_env,
         )
         context.cli_output = result.stdout + result.stderr
+        context.cli_stdout = result.stdout
         context.cli_return_code = result.returncode
     except subprocess.TimeoutExpired:
         context.cli_output = "Command timed out"
+        context.cli_stdout = ""
         context.cli_return_code = 124
     except Exception as e:
         print(f"DEBUG: Exception in CLI command: {type(e).__name__}: {e}")
@@ -267,11 +272,17 @@ def step_table_should_show_columns(context, column_list):
         assert column in output, f"Expected column '{column}' in table, got: {output}"
 
 
+def parse_cli_json(context):
+    """Parse JSON from CLI stdout (excludes stderr)."""
+    raw = getattr(context, "cli_stdout", context.cli_output)
+    return json.loads(raw)
+
+
 @step("the output should be valid JSON")
 def step_output_should_be_valid_json(context):
     """Verify output is valid JSON"""
     try:
-        json.loads(context.cli_output)
+        parse_cli_json(context)
     except json.JSONDecodeError as e:
         raise AssertionError(
             f"Output is not valid JSON: {e}\nOutput: {context.cli_output}"
@@ -281,7 +292,7 @@ def step_output_should_be_valid_json(context):
 @step("the JSON should contain app information")
 def step_json_should_contain_app_info(context):
     """Verify JSON contains app-related information"""
-    data = json.loads(context.cli_output)
+    data = parse_cli_json(context)
     assert (
         "app" in data or "name" in data
     ), f"Expected app information in JSON, got: {data}"
@@ -290,7 +301,7 @@ def step_json_should_contain_app_info(context):
 @step("the JSON should contain runs array")
 def step_json_should_contain_runs_array(context):
     """Verify JSON contains runs array"""
-    data = json.loads(context.cli_output)
+    data = parse_cli_json(context)
     assert "runs" in data and isinstance(
         data["runs"], list
     ), f"Expected runs array in JSON, got: {data}"
@@ -299,7 +310,7 @@ def step_json_should_contain_runs_array(context):
 @step("the JSON should contain the created app information")
 def step_json_should_contain_created_app_info(context):
     """Verify JSON contains created app information"""
-    data = json.loads(context.cli_output)
+    data = parse_cli_json(context)
 
     expected = IsPartialDict(
         result="success",
@@ -319,7 +330,7 @@ def step_json_should_contain_created_app_info(context):
 @step('the app name should be "{expected_name}"')
 def step_app_name_should_be(context, expected_name):
     """Verify app name matches expected value"""
-    data = json.loads(context.cli_output)
+    data = parse_cli_json(context)
     # Extract app name from response structure
     if "app" in data and "name" in data["app"]:
         actual_name = data["app"]["name"]
@@ -338,7 +349,7 @@ def step_app_name_should_be(context, expected_name):
 @step('the app description should be "{expected_description}"')
 def step_app_description_should_be(context, expected_description):
     """Verify app description matches expected value"""
-    data = json.loads(context.cli_output)
+    data = parse_cli_json(context)
     candidates = []
 
     if "app" in data:

tests/integration/run_tests.py

@@ -2,6 +2,12 @@
 """
 Simple test runner for Tower MCP integration tests.
 Assumes dependencies are already installed via nix devShell.
+
+Supports two modes:
+1. Mock mode (default): Starts local mock server at http://127.0.0.1:8000
+2. Real server mode: Set TOWER_URL env var to use external server
+   - Skips mock server startup
+   - Preserves externally configured session.json
 """
 
 import os
@@ -18,12 +24,41 @@ def log(msg):
     print(f"\033[36m[test-runner]\033[0m {msg}")
 
 
+def is_session_externally_configured(test_home):
+    """Check if session.json has been externally configured.
+
+    Returns True if session.json is newer than the git HEAD version,
+    indicating it was set up by external orchestration (e.g., from monorepo).
+    """
+    session_file = test_home / ".config" / "tower" / "session.json"
+    if not session_file.exists():
+        return False
+
+    try:
+        result = subprocess.run(
+            ["git", "log", "-1", "--format=%ct", str(session_file)],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        git_mtime = int(result.stdout.strip())
+        file_mtime = int(session_file.stat().st_mtime)
+        return file_mtime > git_mtime
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
+        return False
+
+
 def reset_session_fixture(test_home):
     """Reset the session.json fixture to its committed state before tests.
 
     The CLI may modify session.json during MCP operations (like team switching),
     so we restore it to the canonical committed version before each test run.
+    Skips reset if session appears to be externally configured.
     """
+    if is_session_externally_configured(test_home):
+        log("Skipping session.json reset (externally configured)")
+        return
+
     session_file = test_home / ".config" / "tower" / "session.json"
     subprocess.run(
         ["git", "checkout", str(session_file)],
@@ -87,32 +122,40 @@ def main():
 
     # Set up environment
     env = os.environ.copy()
-    if "TOWER_URL" not in env:
-        env["TOWER_URL"] = "http://127.0.0.1:8000"
 
     # Set HOME to test-home directory to isolate session from user's real config
     test_home = Path(__file__).parent / "test-home"
     env["HOME"] = str(test_home.absolute())
 
-    log(f"Using API URL: \033[1m{env['TOWER_URL']}\033[0m")
-    log(f"Using test HOME: \033[1m{env['HOME']}\033[0m")
-
-    # Ensure mock server is running
-    mock_process = None
-    if not check_mock_server_health(env["TOWER_URL"]):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        port_in_use = sock.connect_ex(("127.0.0.1", 8000)) == 0
-        sock.close()
-
-        if port_in_use:
-            log(
-                "ERROR: Port 8000 is in use but not responding to health check (some unrelated server?)."
-            )
-            return 1
-
-        mock_process = start_mock_server()
+    # Determine if we're using external configuration or mock server
+    tower_url_preset = "TOWER_URL" in os.environ
+    if tower_url_preset:
+        server_url = env["TOWER_URL"]
+        mock_process = None
+        log(f"Using externally configured API URL: \033[1m{server_url}\033[0m")
     else:
-        log("Mock server already running and healthy")
+        server_url = "http://127.0.0.1:8000"
+        env["TOWER_URL"] = server_url
+        log(f"Using mock server API URL: \033[1m{server_url}\033[0m")
+
+        # Ensure mock server is running
+        mock_process = None
+        if not check_mock_server_health(server_url):
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            port_in_use = sock.connect_ex(("127.0.0.1", 8000)) == 0
+            sock.close()
+
+            if port_in_use:
+                log(
+                    "ERROR: Port 8000 is in use but not responding to health check (some unrelated server?)."
+                )
+                return 1
+
+            mock_process = start_mock_server()
+        else:
+            log("Mock server already running and healthy")
+
+    log(f"Using test HOME: \033[1m{env['HOME']}\033[0m")
 
     # Actually run tests
     try: