agent-starter-pack 0.3.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

src/deployment_targets/cloud_run/tests/integration/test_server_e2e.py

@@ -1,249 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-import logging
-import os
-import subprocess
-import sys
-import threading
-import time
-import uuid
-from collections.abc import Iterator
-from typing import Any
-
-import pytest
-import requests
-from requests.exceptions import RequestException
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-BASE_URL = "http://127.0.0.1:8000/"
-{%- if "adk" in cookiecutter.tags %}
-STREAM_URL = BASE_URL + "run_sse"
-{%- else %}
-STREAM_URL = BASE_URL + "stream_messages"
-{%- endif %}
-FEEDBACK_URL = BASE_URL + "feedback"
-
-HEADERS = {"Content-Type": "application/json"}
-
-
-def log_output(pipe: Any, log_func: Any) -> None:
-    """Log the output from the given pipe."""
-    for line in iter(pipe.readline, ""):
-        log_func(line.strip())
-
-
-def start_server() -> subprocess.Popen[str]:
-    """Start the FastAPI server using subprocess and log its output."""
-    command = [
-        sys.executable,
-        "-m",
-        "uvicorn",
-        "app.server:app",
-        "--host",
-        "0.0.0.0",
-        "--port",
-        "8000",
-    ]
-    env = os.environ.copy()
-    env["INTEGRATION_TEST"] = "TRUE"
-    process = subprocess.Popen(
-        command,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        bufsize=1,
-        env=env,
-    )
-
-    # Start threads to log stdout and stderr in real-time
-    threading.Thread(
-        target=log_output, args=(process.stdout, logger.info), daemon=True
-    ).start()
-    threading.Thread(
-        target=log_output, args=(process.stderr, logger.error), daemon=True
-    ).start()
-
-    return process
-
-
-def wait_for_server(timeout: int = 60, interval: int = 1) -> bool:
-    """Wait for the server to be ready."""
-    start_time = time.time()
-    while time.time() - start_time < timeout:
-        try:
-            response = requests.get("http://127.0.0.1:8000/docs", timeout=10)
-            if response.status_code == 200:
-                logger.info("Server is ready")
-                return True
-        except RequestException:
-            pass
-        time.sleep(interval)
-    logger.error(f"Server did not become ready within {timeout} seconds")
-    return False
-
-
-@pytest.fixture(scope="session")
-def server_fixture(request: Any) -> Iterator[subprocess.Popen[str]]:
-    """Pytest fixture to start and stop the server for testing."""
-    logger.info("Starting server process")
-    server_process = start_server()
-    if not wait_for_server():
-        pytest.fail("Server failed to start")
-    logger.info("Server process started")
-
-    def stop_server() -> None:
-        logger.info("Stopping server process")
-        server_process.terminate()
-        server_process.wait()
-        logger.info("Server process stopped")
-
-    request.addfinalizer(stop_server)
-    yield server_process
-
-
-def test_chat_stream(server_fixture: subprocess.Popen[str]) -> None:
-    """Test the chat stream functionality."""
-    logger.info("Starting chat stream test")
-{% if "adk" in cookiecutter.tags %}
-    # Create session first
-    user_id = "user_123"
-    session_id = "session_abc"
-    session_data = {"state": {"preferred_language": "English", "visit_count": 5}}
-    session_response = requests.post(
-        f"{BASE_URL}/apps/app/users/{user_id}/sessions/{session_id}",
-        headers=HEADERS,
-        json=session_data,
-        timeout=10,
-    )
-    assert session_response.status_code == 200
-
-    # Then send chat message
-    data = {
-        "app_name": "app",
-        "user_id": user_id,
-        "session_id": session_id,
-        "new_message": {
-            "role": "user",
-            "parts": [{"text": "What's the weather in San Francisco?"}],
-        },
-        "streaming": True,
-    }
-{% else %}
-    data = {
-        "input": {
-            "messages": [
-                {"type": "human", "content": "Hello, AI!"},
-                {"type": "ai", "content": "Hello!"},
-                {"type": "human", "content": "Who are you?"},
-            ]
-        },
-        "config": {"metadata": {"user_id": "test-user", "session_id": "test-session"}},
-    }
-{% endif %}
-    response = requests.post(
-        STREAM_URL, headers=HEADERS, json=data, stream=True, timeout=10
-    )
-    assert response.status_code == 200
-
-{%- if "adk" in cookiecutter.tags %}
-    # Parse SSE events from response
-    events = []
-    for line in response.iter_lines():
-        if line:
-            # SSE format is "data: {json}"
-            line_str = line.decode("utf-8")
-            if line_str.startswith("data: "):
-                event_json = line_str[6:]  # Remove "data: " prefix
-                event = json.loads(event_json)
-                events.append(event)
-
-    assert events, "No events received from stream"
-    # Check for valid content in the response
-    has_text_content = False
-    for event in events:
-        content = event.get("content")
-        if (
-            content is not None
-            and content.get("parts")
-            and any(part.get("text") for part in content["parts"])
-        ):
-            has_text_content = True
-            break
-{%- else %}
-    events = [json.loads(line) for line in response.iter_lines() if line]
-    assert events, "No events received from stream"
-
-    # Verify each event is a tuple of message and metadata
-    for event in events:
-        assert isinstance(event, list), "Event should be a list"
-        assert len(event) == 2, "Event should contain message and metadata"
-        message, _ = event
-
-        # Verify message structure
-        assert isinstance(message, dict), "Message should be a dictionary"
-        assert message["type"] == "constructor"
-        assert "kwargs" in message, "Constructor message should have kwargs"
-
-    # Verify at least one message has content
-    has_content = False
-    for event in events:
-        message = event[0]
-        if message.get("type") == "constructor" and "content" in message["kwargs"]:
-            has_content = True
-            break
-    assert has_content, "At least one message should have content"
-{%- endif %}
-
-
-def test_chat_stream_error_handling(server_fixture: subprocess.Popen[str]) -> None:
-    """Test the chat stream error handling."""
-    logger.info("Starting chat stream error handling test")
-    data = {
-        "input": {"messages": [{"type": "invalid_type", "content": "Cause an error"}]}
-    }
-    response = requests.post(
-        STREAM_URL, headers=HEADERS, json=data, stream=True, timeout=10
-    )
-
-    assert response.status_code == 422, (
-        f"Expected status code 422, got {response.status_code}"
-    )
-    logger.info("Error handling test completed successfully")
-
-
-def test_collect_feedback(server_fixture: subprocess.Popen[str]) -> None:
-    """
-    Test the feedback collection endpoint (/feedback) to ensure it properly
-    logs the received feedback.
-    """
-    # Create sample feedback data
-    feedback_data = {
-        "score": 4,
-{%- if "adk" in cookiecutter.tags %}
-        "invocation_id": str(uuid.uuid4()),
-{%- else %}
-        "run_id": str(uuid.uuid4()),
-{%- endif %}
-        "text": "Great response!",
-    }
-
-    response = requests.post(
-        FEEDBACK_URL, json=feedback_data, headers=HEADERS, timeout=10
-    )
-    assert response.status_code == 200

src/deployment_targets/cloud_run/tests/load_test/README.md

@@ -1,83 +0,0 @@
-# Robust Load Testing for Generative AI Applications
-
-This directory provides a comprehensive load testing framework for your Generative AI application, leveraging the power of [Locust](http://locust.io), a leading open-source load testing tool.
-
-## Local Load Testing
-
-Follow these steps to execute load tests on your local machine:
-
-**1. Start the FastAPI Server:**
-
-Launch the FastAPI server in a separate terminal:
-
-```bash
-uv run uvicorn app.server:app --host 0.0.0.0 --port 8000 --reload
-```
-
-**2. (In another tab) Create virtual environment with Locust**
-Using another terminal tab, This is suggested to avoid conflicts with the existing application python environment.
-
-```bash
-python3 -m venv locust_env && source locust_env/bin/activate && pip install locust==2.31.1
-```
-
-**3. Execute the Load Test:**
-Trigger the Locust load test with the following command:
-
-```bash
-locust -f tests/load_test/load_test.py \
--H http://127.0.0.1:8000 \
---headless \
--t 30s -u 10 -r 2 \
---csv=tests/load_test/.results/results \
---html=tests/load_test/.results/report.html
-```
-
-This command initiates a 30-second load test, simulating 2 users spawning per second, reaching a maximum of 60 concurrent users.
-
-**Results:**
-
-Comprehensive CSV and HTML reports detailing the load test performance will be generated and saved in the `tests/load_test/.results` directory.
-
-## Remote Load Testing (Targeting Cloud Run)
-
-This framework also supports load testing against remote targets, such as a staging Cloud Run instance. This process is seamlessly integrated into the Continuous Delivery pipeline via Cloud Build, as defined in the [pipeline file](cicd/cd/staging.yaml).
-
-**Prerequisites:**
-
-- **Dependencies:** Ensure your environment has the same dependencies required for local testing.
-- **Cloud Run Invoker Role:** You'll need the `roles/run.invoker` role to invoke the Cloud Run service.
-
-**Steps:**
-
-**1. Obtain Cloud Run Service URL:**
-
-Navigate to the Cloud Run console, select your service, and copy the URL displayed at the top. Set this URL as an environment variable:
-
-```bash
-export RUN_SERVICE_URL=https://your-cloud-run-service-url.run.app
-```
-
-**2. Obtain ID Token:**
-
-Retrieve the ID token required for authentication:
-
-```bash
-export _ID_TOKEN=$(gcloud auth print-identity-token -q)
-```
-
-**3. Execute the Load Test:**
-Create virtual environment with Locust:
-```bash
-python3 -m venv locust_env && source locust_env/bin/activate && pip install locust==2.31.1
-```
-
-Execute load tests. The following command executes the same load test parameters as the local test but targets your remote Cloud Run instance.
-```bash
-locust -f tests/load_test/load_test.py \
--H $RUN_SERVICE_URL \
---headless \
--t 30s -u 60 -r 2 \
---csv=tests/load_test/.results/results \
---html=tests/load_test/.results/report.html
-```

src/deployment_targets/cloud_run/tests/load_test/load_test.py

@@ -1,118 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-import os
-import time
-{%- if "adk" in cookiecutter.tags %}
-import uuid
-
-import requests
-from locust import HttpUser, between, task
-{%- else %}
-
-from locust import HttpUser, between, task
-{%- endif %}
-{% if "adk" in cookiecutter.tags %}
-ENDPOINT = "/run_sse"
-{% else %}
-ENDPOINT = "/stream_messages"
-{% endif %}
-
-class ChatStreamUser(HttpUser):
-    """Simulates a user interacting with the chat stream API."""
-
-    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
-
-    @task
-    def chat_stream(self) -> None:
-        """Simulates a chat stream interaction."""
-        headers = {"Content-Type": "application/json"}
-        if os.environ.get("_ID_TOKEN"):
-            headers["Authorization"] = f"Bearer {os.environ['_ID_TOKEN']}"
-{%- if "adk" in cookiecutter.tags %}
-        # Create session first
-        user_id = f"user_{uuid.uuid4()}"
-        session_id = f"session_{uuid.uuid4()}"
-        session_data = {"state": {"preferred_language": "English", "visit_count": 5}}
-        requests.post(
-            f"{self.client.base_url}/apps/app/users/{user_id}/sessions/{session_id}",
-            headers=headers,
-            json=session_data,
-            timeout=10,
-        )
-
-        # Send chat message
-        data = {
-            "app_name": "app",
-            "user_id": user_id,
-            "session_id": session_id,
-            "new_message": {
-                "role": "user",
-                "parts": [{"text": "What's the weather in San Francisco?"}],
-            },
-            "streaming": True,
-        }
-{%- else %}
-        data = {
-            "input": {
-                "messages": [
-                    {"type": "human", "content": "Hello, AI!"},
-                    {"type": "ai", "content": "Hello!"},
-                    {"type": "human", "content": "Who are you?"},
-                ]
-            },
-            "config": {
-                "metadata": {"user_id": "test-user", "session_id": "test-session"}
-            },
-        }
-{%- endif %}
-        start_time = time.time()
-
-        with self.client.post(
-            ENDPOINT,
-            name=f"{ENDPOINT} message",
-            headers=headers,
-            json=data,
-            catch_response=True,
-            stream=True,
-            params={"alt": "sse"},
-        ) as response:
-            if response.status_code == 200:
-                events = []
-                for line in response.iter_lines():
-                    if line:
-{%- if "adk" in cookiecutter.tags %}
-                        # SSE format is "data: {json}"
-                        line_str = line.decode("utf-8")
-                        if line_str.startswith("data: "):
-                            event_json = line_str[6:]  # Remove "data: " prefix
-                            event = json.loads(event_json)
-                            events.append(event)
-{%- else %}
-                        event = json.loads(line)
-                        events.append(event)
-{%- endif %}
-                end_time = time.time()
-                total_time = end_time - start_time
-                self.environment.events.request.fire(
-                    request_type="POST",
-                    name=f"{ENDPOINT} end",
-                    response_time=total_time * 1000,  # Convert to milliseconds
-                    response_length=len(json.dumps(events)),
-                    response=response,
-                    context={},
-                )
-            else:
-                response.failure(f"Unexpected status code: {response.status_code}")