Scenario Management

MockLoop's scenario management system allows you to create, manage, and switch between different response configurations for comprehensive testing of your applications.

Overview

Scenarios in MockLoop enable you to:

• Define different response behaviors for the same endpoints
• Switch between test scenarios dynamically
• Create realistic testing environments with varying data states
• Test error conditions and edge cases
• Simulate different system states (maintenance, high load, etc.)

Understanding Scenarios

What is a Scenario?

A scenario is a named configuration that defines:

• Response data for specific endpoints
• Response delays and timing behavior
• Error conditions and status codes
• Dynamic behavior rules

Default Scenario

Every mock server starts with a "default" scenario based on your OpenAPI specification:

from mockloop_mcp import manage_mock_data

# List available scenarios
scenarios = manage_mock_data(
    server_url="http://localhost:8000",
    operation="list_scenarios"
)

print("Available scenarios:", scenarios['scenarios'])
# Output: ['default', 'error_testing', 'performance_test']

Creating Scenarios

Basic Scenario Creation

Create a new scenario with custom responses:

# Create a new scenario
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="user_testing",
    scenario_config={
        "description": "Scenario for user management testing",
        "endpoints": {
            "/api/users": {
                "GET": {
                    "response": {
                        "users": [
                            {"id": 1, "name": "Alice", "email": "alice@test.com"},
                            {"id": 2, "name": "Bob", "email": "bob@test.com"}
                        ]
                    },
                    "status_code": 200,
                    "delay_ms": 100
                }
            },
            "/api/users/{user_id}": {
                "GET": {
                    "response": {
                        "id": 1,
                        "name": "Alice",
                        "email": "alice@test.com",
                        "created_at": "2024-01-01T00:00:00Z"
                    },
                    "status_code": 200
                }
            }
        }
    }
)

Error Testing Scenarios

Create scenarios to test error conditions:

# Create error testing scenario
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="error_testing",
    scenario_config={
        "description": "Test various error conditions",
        "endpoints": {
            "/api/users": {
                "GET": {
                    "response": {"error": "Internal server error"},
                    "status_code": 500,
                    "delay_ms": 50
                },
                "POST": {
                    "response": {"error": "Validation failed", "details": "Email already exists"},
                    "status_code": 400
                }
            },
            "/api/users/{user_id}": {
                "GET": {
                    "response": {"error": "User not found"},
                    "status_code": 404
                },
                "DELETE": {
                    "response": {"error": "Forbidden"},
                    "status_code": 403
                }
            }
        }
    }
)

Performance Testing Scenarios

Create scenarios with realistic delays:

# Create performance testing scenario
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="slow_responses",
    scenario_config={
        "description": "Simulate slow network conditions",
        "global_delay_ms": 2000,  # Add 2 second delay to all responses
        "endpoints": {
            "/api/users": {
                "GET": {
                    "delay_ms": 5000,  # Extra slow for this endpoint
                    "response": {"users": []}
                }
            }
        }
    }
)

Switching Scenarios

Active Scenario Management

Switch between scenarios at runtime:

# Switch to error testing scenario
manage_mock_data(
    server_url="http://localhost:8000",
    operation="switch_scenario",
    scenario_name="error_testing"
)

# Verify the switch
current = manage_mock_data(
    server_url="http://localhost:8000",
    operation="get_current_scenario"
)
print(f"Current scenario: {current['scenario_name']}")

Scenario Switching via API

You can also switch scenarios using direct HTTP calls:

# Switch scenario via REST API
curl -X POST http://localhost:8000/admin/scenarios/switch \
  -H "Content-Type: application/json" \
  -d '{"scenario_name": "user_testing"}'

# Get current scenario
curl http://localhost:8000/admin/scenarios/current

Advanced Scenario Features

Dynamic Response Rules

Create scenarios with conditional logic:

# Scenario with dynamic responses based on request data
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="dynamic_responses",
    scenario_config={
        "description": "Dynamic responses based on request",
        "endpoints": {
            "/api/users": {
                "POST": {
                    "rules": [
                        {
                            "condition": "request.json.email == 'admin@test.com'",
                            "response": {"error": "Admin email not allowed"},
                            "status_code": 400
                        },
                        {
                            "condition": "len(request.json.name) < 2",
                            "response": {"error": "Name too short"},
                            "status_code": 400
                        },
                        {
                            "default": True,
                            "response": {
                                "id": "{{random_int(1, 1000)}}",
                                "name": "{{request.json.name}}",
                                "email": "{{request.json.email}}",
                                "created_at": "{{now()}}"
                            },
                            "status_code": 201
                        }
                    ]
                }
            }
        }
    }
)

Template Variables

Use template variables for dynamic content:

# Scenario with template variables
scenario_config = {
    "endpoints": {
        "/api/users/{user_id}": {
            "GET": {
                "response": {
                    "id": "{{path.user_id}}",
                    "name": "User {{path.user_id}}",
                    "email": "user{{path.user_id}}@test.com",
                    "created_at": "{{now()}}",
                    "random_score": "{{random_int(1, 100)}}"
                }
            }
        }
    }
}

Stateful Scenarios

Create scenarios that maintain state across requests:

# Stateful scenario with in-memory storage
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="stateful_testing",
    scenario_config={
        "description": "Maintain state across requests",
        "state_enabled": True,
        "endpoints": {
            "/api/users": {
                "GET": {
                    "response": "{{state.users or []}}"
                },
                "POST": {
                    "actions": [
                        "state.users = state.users or []",
                        "new_user = {**request.json, 'id': len(state.users) + 1}",
                        "state.users.append(new_user)"
                    ],
                    "response": "{{new_user}}",
                    "status_code": 201
                }
            }
        }
    }
)

Scenario Inheritance

Base Scenarios

Create base scenarios that can be extended:

# Create base scenario
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="base_api",
    scenario_config={
        "description": "Base API responses",
        "endpoints": {
            "/api/health": {
                "GET": {
                    "response": {"status": "healthy"},
                    "status_code": 200
                }
            }
        }
    }
)

# Create scenario that inherits from base
manage_mock_data(
    server_url="http://localhost:8000",
    operation="create_scenario",
    scenario_name="extended_api",
    scenario_config={
        "description": "Extended API with additional endpoints",
        "inherits_from": "base_api",
        "endpoints": {
            "/api/users": {
                "GET": {
                    "response": {"users": []},
                    "status_code": 200
                }
            }
        }
    }
)

Scenario Testing Workflows

Automated Scenario Testing

Create test suites that use different scenarios:

import requests
from mockloop_mcp import manage_mock_data

def test_user_scenarios():
    base_url = "http://localhost:8000"

    # Test normal scenario
    manage_mock_data(base_url, "switch_scenario", scenario_name="user_testing")
    response = requests.get(f"{base_url}/api/users")
    assert response.status_code == 200
    assert len(response.json()["users"]) == 2

    # Test error scenario
    manage_mock_data(base_url, "switch_scenario", scenario_name="error_testing")
    response = requests.get(f"{base_url}/api/users")
    assert response.status_code == 500

    # Test performance scenario
    manage_mock_data(base_url, "switch_scenario", scenario_name="slow_responses")
    import time
    start = time.time()
    response = requests.get(f"{base_url}/api/users")
    duration = time.time() - start
    assert duration > 2.0  # Should be slow

CI/CD Integration

Use scenarios in continuous integration:

# .github/workflows/api-tests.yml
name: API Tests
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Start MockLoop server
        run: |
          mockloop generate-mock-api openapi.yaml
          cd generated_mock_server && python main.py &

      - name: Test normal scenarios
        run: |
          python -c "
          from mockloop_mcp import manage_mock_data
          manage_mock_data('http://localhost:8000', 'switch_scenario', scenario_name='default')
          "
          pytest tests/test_normal_flow.py

      - name: Test error scenarios
        run: |
          python -c "
          from mockloop_mcp import manage_mock_data
          manage_mock_data('http://localhost:8000', 'switch_scenario', scenario_name='error_testing')
          "
          pytest tests/test_error_handling.py

Scenario Management Best Practices

Naming Conventions

Use clear, descriptive scenario names:

• default - Standard API responses
• error_testing - Various error conditions
• performance_slow - Slow response testing
• user_empty_state - No users in system
• user_full_state - System with many users
• maintenance_mode - System under maintenance

Scenario Documentation

Document your scenarios:

scenario_config = {
    "description": "User management testing scenario",
    "purpose": "Test user CRUD operations with realistic data",
    "test_cases": [
        "User creation with valid data",
        "User retrieval by ID",
        "User list pagination"
    ],
    "notes": "Uses 2 test users: Alice and Bob",
    "endpoints": {
        # ... endpoint configurations
    }
}

Version Control

Store scenario configurations in version control:

# Export scenarios to files
mkdir scenarios
python -c "
from mockloop_mcp import manage_mock_data
import json

scenarios = manage_mock_data('http://localhost:8000', 'list_scenarios')
for scenario in scenarios['scenarios']:
    config = manage_mock_data('http://localhost:8000', 'get_scenario', scenario_name=scenario)
    with open(f'scenarios/{scenario}.json', 'w') as f:
        json.dump(config, f, indent=2)
"

Troubleshooting Scenarios

Common Issues

1. Scenario not switching: Check scenario name spelling
2. Template errors: Validate template syntax
3. State not persisting: Ensure state_enabled is true
4. Performance issues: Review complex rules and templates

Debugging Scenarios

Enable debug logging for scenario operations:

# Enable debug mode
manage_mock_data(
    server_url="http://localhost:8000",
    operation="configure_debug",
    config={"scenario_debug": True}
)

# Check scenario logs
logs = query_mock_logs(
    server_url="http://localhost:8000",
    include_admin=True,
    path_pattern="/admin/scenarios/*"
)

Next Steps

• Performance Monitoring - Monitor scenario performance
• Docker Integration - Deploy scenarios in containers
• Advanced Features - Explore advanced scenario capabilities