aws-perf-load-testing

AWS Performance & Load Testing Skill

Generate benchmarks and load tests by reading handler code and API specs.

Performance Tests (pytest-benchmark + tracemalloc)

Phase 1: Build Realistic Events

Read the handler code to understand:

• What event shape does it expect? (API GW proxy, S3, SQS, direct)
• What are the hot paths? (most common code branches)
• What external calls does it make? (need to mock for benchmarks)

Phase 2: Generate Benchmark Tests

See references/benchmark-patterns.md for full patterns.

"""Performance benchmarks for {handler_name}."""
import json
import pytest
from unittest.mock import patch, MagicMock

pytestmark = pytest.mark.performance


@pytest.fixture
def mock_context():
    ctx = MagicMock()
    ctx.function_name = "test-function"
    ctx.memory_limit_in_mb = 256
    ctx.get_remaining_time_in_millis.return_value = 30000
    return ctx


class TestHandlerLatency:
    """Benchmark handler execution time."""

    def test_get_request_latency(self, mock_context, benchmark):
        # Mock external dependencies so we measure handler logic only
        with patch("handler.main.boto3") as mock_boto:
            mock_boto.client.return_value.get_object.return_value = {
                "Body": MagicMock(read=lambda: b'{"data": "value"}')
            }

            from handler.main import lambda_handler
            event = {
                "httpMethod": "GET",
                "pathParameters": {"id": "bench-123"},
                "headers": {"x-api-key": "test"},
            }

            result = benchmark(lambda_handler, event, mock_context)
            assert result["statusCode"] == 200

    def test_post_request_latency(self, mock_context, benchmark):
        with patch("handler.main.boto3") as mock_boto:
            mock_boto.client.return_value.put_item.return_value = {}

            from handler.main import lambda_handler
            event = {
                "httpMethod": "POST",
                "body": json.dumps({"name": "Benchmark"}),
                "headers": {"x-api-key": "test"},
            }

            result = benchmark(lambda_handler, event, mock_context)
            assert result["statusCode"] in (200, 201)


class TestMemoryUsage:
    """Profile handler memory consumption."""

    def test_memory_within_limit(self, mock_context):
        import tracemalloc
        tracemalloc.start()

        with patch("handler.main.boto3"):
            from handler.main import lambda_handler
            event = {"httpMethod": "GET", "pathParameters": {"id": "mem-test"}}
            lambda_handler(event, mock_context)

        current, peak = tracemalloc.get_traced_memory()
        tracemalloc.stop()

        peak_mb = peak / 1024 / 1024
        limit_mb = mock_context.memory_limit_in_mb
        assert peak_mb < limit_mb * 0.8, (
            f"Peak {peak_mb:.1f}MB is >80% of {limit_mb}MB limit"
        )