Load Injection (Load Scenarios)

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.model.SocketAddress;

import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("checkout-load")
    .withProfile(LoadProfile.of(
        LoadStage.rampVus(1, 10, 30000, RampCurve.LINEAR),
        LoadStage.constantVus(10, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/orders/$iteration.index")
            .withHeader("Host", "orders.svc:8080")
            .withSocketAddress("orders.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.loadScenario(scenario);                  // 1. register (does NOT start it yet)
client.startLoadScenarios("checkout-load");     // 2. start (requires loadGenerationEnabled=true)
String listing = client.loadScenarios();        // 3. list all registered scenarios
String status = client.getLoadScenario("checkout-load"); // live throughput / latency status
client.stopLoadScenarios("checkout-load");      // 4. stop (no args stops ALL running scenarios)

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

// The per-step field is `request` (a full HttpRequest), not `httpRequest`.
var scenario = {
    name: 'checkout-load',
    profile: { stages: [
        { type: 'VU', startVus: 1, endVus: 10, durationMillis: 30000, curve: 'LINEAR' },
        { type: 'VU', vus: 10, durationMillis: 60000 }
    ] },
    steps: [
        { request: { method: 'GET', path: '/api/orders/$iteration.index',
                     headers: { Host: ['orders.svc:8080'] },
                     socketAddress: { host: 'orders.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.loadScenario(scenario);                 // 1. register (does NOT start it yet)
    await client.startLoadScenarios('checkout-load');    // 2. start (requires loadGenerationEnabled=true)
    var listing = await client.loadScenarios();          // 3. list all registered scenarios
    var status = await client.getLoadScenario('checkout-load'); // live status
    await client.stopLoadScenarios('checkout-load');     // 4. stop (no arg stops ALL running scenarios)
})();

from mockserver import (HttpRequest, KeyToMultiValue, LoadProfile, LoadScenario,
                        LoadStage, LoadStep, MockServerClient, SocketAddress)

scenario = LoadScenario(
    name="checkout-load",
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(30000, start_vus=1, end_vus=10, curve="LINEAR"),
        LoadStage.vu_stage(60000, vus=10),
    ]),
    steps=[
        LoadStep(request=HttpRequest(
            method="GET", path="/api/orders/$iteration.index",
            headers=[KeyToMultiValue(name="Host", values=["orders.svc:8080"])],
            socket_address=SocketAddress(host="orders.svc", port=8080, scheme="HTTP"))),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)                # 1. register (does NOT start it yet)
    client.start_load_scenarios("checkout-load")  # 2. start (requires loadGenerationEnabled=true)
    listing = client.load_scenarios()             # 3. list all registered scenarios
    status = client.get_load_scenario("checkout-load")  # live status
    client.stop_load_scenarios("checkout-load")   # 4. stop (None stops ALL running scenarios)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

scenario = LoadScenario.new(
  name: 'checkout-load',
  profile: LoadProfile.new(stages: [
    LoadStage.vu(30_000, start_vus: 1, end_vus: 10, curve: 'LINEAR'),
    LoadStage.vu(60_000, vus: 10)
  ]),
  steps: [
    LoadStep.new(request: HttpRequest.new(method: 'GET', path: '/api/orders/$iteration.index',
                                          socket_address: SocketAddress.new(host: 'orders.svc', port: 8080, scheme: 'HTTP'))
                            .with_header('Host', 'orders.svc:8080'))
  ]
)

client.load_scenario(scenario)               # 1. register (does NOT start it yet)
client.start_load_scenarios('checkout-load') # 2. start (requires loadGenerationEnabled=true)
client.load_scenarios                        # 3. list all registered scenarios
client.get_load_scenario('checkout-load')    # live status
client.stop_load_scenarios('checkout-load')  # 4. stop (nil stops ALL running scenarios)
client.close

package main

import (
    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    order := mockserver.Request().Method("GET").Path("/api/orders/$iteration.index").
        Header("Host", "orders.svc:8080").Build()
    order.SocketAddress = &mockserver.SocketAddress{Host: "orders.svc", Port: 8080, Scheme: "HTTP"}

    scenario := mockserver.LoadScenario{
        Name: "checkout-load",
        Profile: &mockserver.LoadProfile{
            Stages: []mockserver.LoadStage{
                mockserver.RampVusStage(1, 10, 30000, mockserver.RampLinear),
                mockserver.ConstantVusStage(10, 60000),
            },
        },
        Steps: []mockserver.LoadStep{
            {Request: &order},
        },
    }

    client.LoadScenario(scenario)              // 1. register (does NOT start it yet)
    client.StartLoadScenarios("checkout-load") // 2. start (requires loadGenerationEnabled=true)
    client.LoadScenarios()                     // 3. list all registered scenarios
    client.GetLoadScenario("checkout-load")    // live status
    client.StopLoadScenarios("checkout-load")  // 4. stop (no args stops ALL running scenarios)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

var ordersRequest = HttpRequest.Request()
    .WithMethod("GET").WithPath("/api/orders/$iteration.index")
    .WithHeader("Host", "orders.svc:8080")
    .Build();
ordersRequest.SocketAddress = new SocketAddress { Host = "orders.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "checkout-load",
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage>
        {
            LoadStage.RampVus(1, 10, 30000, RampCurve.LINEAR),
            LoadStage.ConstantVus(10, 60000)
        }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = ordersRequest }
    }
};

await client.LoadScenarioAsync(scenario);              // 1. register (does NOT start it yet)
await client.StartLoadScenariosAsync("checkout-load"); // 2. start (requires loadGenerationEnabled=true)
var listing = await client.LoadScenariosAsync();       // 3. list all registered scenarios
var status = await client.GetLoadScenarioAsync("checkout-load"); // live status
await client.StopLoadScenariosAsync("checkout-load");  // 4. stop (no args stops ALL running scenarios)

use mockserver_client::{
    ClientBuilder, HttpRequest, LoadProfile, LoadScenario, LoadStage, LoadStep, RampCurve, SocketAddress,
};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let profile = LoadProfile::of(vec![
    LoadStage::vu_ramp(1, 10, 30_000, RampCurve::Linear),
    LoadStage::vu_hold(10, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/api/orders/$iteration.index")
        .header("Host", "orders.svc:8080")
        .socket_address(SocketAddress::new("orders.svc", 8080).scheme("HTTP"))),
];
let scenario = LoadScenario::new("checkout-load", profile, steps);

client.load_scenario(&scenario).unwrap();                 // 1. register (does NOT start it yet)
client.start_load_scenarios(&["checkout-load"]).unwrap(); // 2. start (requires loadGenerationEnabled=true)
client.load_scenarios().unwrap();                         // 3. list all registered scenarios
client.get_load_scenario("checkout-load").unwrap();       // live status
client.stop_load_scenarios(&["checkout-load"]).unwrap();  // 4. stop (&[] stops ALL running scenarios)

require_once 'vendor/autoload.php';

use MockServer\HttpRequest;
use MockServer\LoadProfile;
use MockServer\LoadScenario;
use MockServer\LoadStage;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$scenario = LoadScenario::scenario('checkout-load')
    ->profile(LoadProfile::of(
        LoadStage::vuRamp(1, 10, 30000, 'LINEAR'),
        LoadStage::vuHold(10, 60000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/api/orders/$iteration.index')
            ->header('Host', 'orders.svc:8080')
            ->socketAddress('orders.svc', 8080, 'HTTP'),
    );

$client->loadScenario($scenario);              // 1. register (does NOT start it yet)
$client->startLoadScenarios('checkout-load');  // 2. start (requires loadGenerationEnabled=true)
$client->loadScenarios();                       // 3. list all registered scenarios
$client->getLoadScenario('checkout-load');      // live status
$client->stopLoadScenarios('checkout-load');    // 4. stop (null stops ALL running scenarios)

# 1. Enable load generation (set once at startup or via the config endpoint)
docker run -e MOCKSERVER_LOAD_GENERATION_ENABLED=true mockserver/mockserver

# 2. LOAD (register) a scenario — this does NOT run it
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "checkout-load",
    "startDelayMillis": 0,
    "profile": {
      "stages": [
        { "type": "VU", "startVus": 1, "endVus": 10, "durationMillis": 30000, "curve": "LINEAR" },
        { "type": "VU", "vus": 10, "durationMillis": 60000 }
      ]
    },
    "steps": [
      {
        "request": {
          "method": "GET",
          "path": "/api/orders/$iteration.index",
          "headers": { "Host": ["orders.svc:8080"] },
          "socketAddress": { "host": "orders.svc", "port": 8080, "scheme": "HTTP" }
        }
      }
    ]
  }'

# 3. TRIGGER it to run (one or many names at once)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -H "Content-Type: application/json" \
  -d '{ "name": "checkout-load" }'

# 4. Poll progress (one scenario, or list all)
curl -s http://localhost:1080/mockserver/loadScenario/checkout-load
curl -s http://localhost:1080/mockserver/loadScenario

# 5. Stop it (stays registered, STOPPED — can be re-triggered)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/stop \
  -d '{ "name": "checkout-load" }'

client.startLoadScenarios("checkout-load", "background-poller");

await client.startLoadScenarios(['checkout-load', 'background-poller']);

client.start_load_scenarios(["checkout-load", "background-poller"])

client.start_load_scenarios(['checkout-load', 'background-poller'])

client.StartLoadScenarios("checkout-load", "background-poller")

await client.StartLoadScenariosAsync("checkout-load", "background-poller");

client.start_load_scenarios(&["checkout-load", "background-poller"]).unwrap();

$client->startLoadScenarios(['checkout-load', 'background-poller']);

curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -d '{ "names": ["checkout-load", "background-poller"] }'

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.model.SocketAddress;

import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("spike-test")
    .withProfile(LoadProfile.shaped(
        LoadShape.spike(LoadShape.Metric.RATE, 10, 200, 15000, 30000, 15000)
            .withRecoveryHoldMillis(30000L)))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/health")
            .withSocketAddress("target.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.loadScenario(scenario);            // register the SPIKE-shaped scenario
client.startLoadScenarios("spike-test");  // start (requires loadGenerationEnabled=true)

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

// A named SPIKE shape expands into ramp-up / hold / ramp-down / recovery stages.
var scenario = {
    name: 'spike-test',
    profile: {
        shape: {
            type: 'SPIKE', metric: 'RATE',
            baseline: 10, peak: 200,
            rampUpMillis: 15000, holdMillis: 30000,
            rampDownMillis: 15000, recoveryHoldMillis: 30000
        }
    },
    steps: [
        { request: { method: 'GET', path: '/api/health',
                     socketAddress: { host: 'target.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.loadScenario(scenario);            // register the SPIKE-shaped scenario
    await client.startLoadScenarios('spike-test');  // start (requires loadGenerationEnabled=true)
})();

from mockserver import (HttpRequest, LoadProfile, LoadScenario, LoadShape,
                        LoadStep, MockServerClient, SocketAddress)

scenario = LoadScenario(
    name="spike-test",
    profile=LoadProfile(shape=LoadShape(
        type="SPIKE", metric="RATE",
        baseline=10, peak=200,
        ramp_up_millis=15000, hold_millis=30000,
        ramp_down_millis=15000, recovery_hold_millis=30000,
    )),
    steps=[
        LoadStep(request=HttpRequest(method="GET", path="/api/health",
                 socket_address=SocketAddress(host="target.svc", port=8080, scheme="HTTP"))),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)             # register the SPIKE-shaped scenario
    client.start_load_scenarios("spike-test")  # start (requires loadGenerationEnabled=true)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

scenario = LoadScenario.new(
  name: 'spike-test',
  profile: LoadProfile.new(shape: LoadShape.new(
    type: 'SPIKE', metric: 'RATE',
    baseline: 10, peak: 200,
    ramp_up_millis: 15_000, hold_millis: 30_000,
    ramp_down_millis: 15_000, recovery_hold_millis: 30_000
  )),
  steps: [
    LoadStep.new(request: HttpRequest.new(method: 'GET', path: '/api/health',
                 socket_address: SocketAddress.new(host: 'target.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)            # register the SPIKE-shaped scenario
client.start_load_scenarios('spike-test') # start (requires loadGenerationEnabled=true)
client.close

package main

import (
    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    health := mockserver.Request().Method("GET").Path("/api/health").Build()
    health.SocketAddress = &mockserver.SocketAddress{Host: "target.svc", Port: 8080, Scheme: "HTTP"}

    // A named SPIKE shape expands into ramp-up / hold / ramp-down / recovery stages.
    baseline := 10.0
    peak := 200.0
    scenario := mockserver.LoadScenario{
        Name: "spike-test",
        Profile: &mockserver.LoadProfile{
            Shape: &mockserver.LoadShape{
                Type: mockserver.LoadShapeSpike, Metric: mockserver.LoadShapeMetricRate,
                Baseline: &baseline, Peak: &peak,
                RampUpMillis: 15000, HoldMillis: 30000,
                RampDownMillis: 15000, RecoveryHoldMillis: 30000,
            },
        },
        Steps: []mockserver.LoadStep{ {Request: &health} },
    }

    client.LoadScenario(scenario)           // register the SPIKE-shaped scenario
    client.StartLoadScenarios("spike-test") // start (requires loadGenerationEnabled=true)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

var health = HttpRequest.Request().WithMethod("GET").WithPath("/api/health").Build();
health.SocketAddress = new SocketAddress { Host = "target.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "spike-test",
    Profile = new LoadProfile
    {
        Shape = new LoadShape
        {
            Type = LoadShapeType.SPIKE, Metric = LoadShapeMetric.RATE,
            Baseline = 10, Peak = 200,
            RampUpMillis = 15000, HoldMillis = 30000,
            RampDownMillis = 15000, RecoveryHoldMillis = 30000
        }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = health }
    }
};

await client.LoadScenarioAsync(scenario);           // register the SPIKE-shaped scenario
await client.StartLoadScenariosAsync("spike-test"); // start (requires loadGenerationEnabled=true)

use mockserver_client::{
    ClientBuilder, HttpRequest, LoadProfile, LoadScenario, LoadShape, LoadShapeMetric, LoadStep,
    SocketAddress,
};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let profile = LoadProfile::shaped(
    LoadShape::spike(10.0, 200.0, 15_000, 30_000, 15_000)
        .recovery_hold_millis(30_000)
        .metric(LoadShapeMetric::Rate),
);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/api/health")
        .socket_address(SocketAddress::new("target.svc", 8080))),
];
let scenario = LoadScenario::new("spike-test", profile, steps);

client.load_scenario(&scenario).unwrap();              // register the SPIKE-shaped scenario
client.start_load_scenarios(&["spike-test"]).unwrap(); // start (requires loadGenerationEnabled=true)

require_once 'vendor/autoload.php';

use MockServer\HttpRequest;
use MockServer\LoadProfile;
use MockServer\LoadScenario;
use MockServer\LoadShape;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$scenario = LoadScenario::scenario('spike-test')
    ->profile(LoadProfile::fromShape(
        LoadShape::spike('RATE', 10, 200, 15000, 30000, 15000)->recoveryHoldMillis(30000)
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/api/health')
            ->socketAddress('target.svc', 8080, 'HTTP'),
    );

$client->loadScenario($scenario);          // register the SPIKE-shaped scenario
$client->startLoadScenarios('spike-test'); // start (requires loadGenerationEnabled=true)

# A SPIKE shape — no need to write five explicit stages
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "spike-test",
    "profile": {
      "shape": {
        "type": "SPIKE",
        "metric": "RATE",
        "baseline": 10,
        "peak": 200,
        "rampUpMillis": 15000,
        "holdMillis": 30000,
        "rampDownMillis": 15000,
        "recoveryHoldMillis": 30000
      }
    },
    "steps": [
      {
        "request": { "method": "GET", "path": "/api/health",
                     "socketAddress": { "host": "target.svc", "port": 8080, "scheme": "HTTP" } }
      }
    ]
  }'

# ...then start it (requires loadGenerationEnabled=true)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start -d '{ "name": "spike-test" }'

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.model.SocketAddress;

import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("paced-load")
    .withPacing(LoadPacing.constantPacing(500))
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(10, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/products")
            .withSocketAddress("target.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.loadScenario(scenario);            // register the paced scenario
client.startLoadScenarios("paced-load");  // start (requires loadGenerationEnabled=true)

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

// CONSTANT_PACING caps each VU at one iteration per 500 ms (2 iterations/second/VU).
var scenario = {
    name: 'paced-load',
    pacing: { mode: 'CONSTANT_PACING', value: 500 },
    profile: { stages: [ { type: 'VU', vus: 10, durationMillis: 60000 } ] },
    steps: [
        { request: { method: 'GET', path: '/api/products',
                     socketAddress: { host: 'target.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.loadScenario(scenario);            // register the paced scenario
    await client.startLoadScenarios('paced-load');  // start (requires loadGenerationEnabled=true)
})();

from mockserver import (HttpRequest, LoadPacing, LoadProfile, LoadScenario,
                        LoadStage, LoadStep, MockServerClient, SocketAddress)

scenario = LoadScenario(
    name="paced-load",
    pacing=LoadPacing(mode="CONSTANT_PACING", value=500),
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(60000, vus=10),
    ]),
    steps=[
        LoadStep(request=HttpRequest(method="GET", path="/api/products",
                 socket_address=SocketAddress(host="target.svc", port=8080, scheme="HTTP"))),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)            # register the paced scenario
    client.start_load_scenarios("paced-load") # start (requires loadGenerationEnabled=true)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

scenario = LoadScenario.new(
  name: 'paced-load',
  pacing: LoadPacing.new(mode: 'CONSTANT_PACING', value: 500),
  profile: LoadProfile.new(stages: [
    LoadStage.vu(60_000, vus: 10)
  ]),
  steps: [
    LoadStep.new(request: HttpRequest.new(method: 'GET', path: '/api/products',
                 socket_address: SocketAddress.new(host: 'target.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)            # register the paced scenario
client.start_load_scenarios('paced-load') # start (requires loadGenerationEnabled=true)
client.close

package main

import (
    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    products := mockserver.Request().Method("GET").Path("/api/products").Build()
    products.SocketAddress = &mockserver.SocketAddress{Host: "target.svc", Port: 8080, Scheme: "HTTP"}

    scenario := mockserver.LoadScenario{
        Name:   "paced-load",
        Pacing: &mockserver.LoadPacing{Mode: mockserver.LoadPacingConstantPacing, Value: 500},
        Profile: &mockserver.LoadProfile{
            Stages: []mockserver.LoadStage{
                mockserver.ConstantVusStage(10, 60000),
            },
        },
        Steps: []mockserver.LoadStep{ {Request: &products} },
    }

    client.LoadScenario(scenario)           // register the paced scenario
    client.StartLoadScenarios("paced-load") // start (requires loadGenerationEnabled=true)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

var products = HttpRequest.Request().WithMethod("GET").WithPath("/api/products").Build();
products.SocketAddress = new SocketAddress { Host = "target.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "paced-load",
    Pacing = new LoadPacing { Mode = LoadPacingMode.CONSTANT_PACING, Value = 500 },
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage>
        {
            LoadStage.ConstantVus(10, 60000)
        }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = products }
    }
};

await client.LoadScenarioAsync(scenario);           // register the paced scenario
await client.StartLoadScenariosAsync("paced-load"); // start (requires loadGenerationEnabled=true)

use mockserver_client::{
    ClientBuilder, HttpRequest, LoadPacing, LoadProfile, LoadScenario, LoadStage, LoadStep,
    SocketAddress,
};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(10, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/api/products")
        .socket_address(SocketAddress::new("target.svc", 8080))),
];
let scenario = LoadScenario::new("paced-load", profile, steps)
    .pacing(LoadPacing::constant_pacing(500.0));

client.load_scenario(&scenario).unwrap();              // register the paced scenario
client.start_load_scenarios(&["paced-load"]).unwrap(); // start (requires loadGenerationEnabled=true)

require_once 'vendor/autoload.php';

use MockServer\HttpRequest;
use MockServer\LoadPacing;
use MockServer\LoadProfile;
use MockServer\LoadScenario;
use MockServer\LoadStage;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$scenario = LoadScenario::scenario('paced-load')
    ->pacing(LoadPacing::constantPacing(500))
    ->profile(LoadProfile::of(
        LoadStage::vuHold(10, 60000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/api/products')
            ->socketAddress('target.svc', 8080, 'HTTP'),
    );

$client->loadScenario($scenario);          // register the paced scenario
$client->startLoadScenarios('paced-load'); // start (requires loadGenerationEnabled=true)

# Each VU loops at most once per 500 ms (2 iterations/second/VU max)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "paced-load",
    "pacing": { "mode": "CONSTANT_PACING", "value": 500 },
    "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 60000 } ] },
    "steps": [
      {
        "request": { "method": "GET", "path": "/api/products",
                     "socketAddress": { "host": "target.svc", "port": 8080, "scheme": "HTTP" } }
      }
    ]
  }'

# ...then start it (requires loadGenerationEnabled=true)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start -d '{ "name": "paced-load" }'

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.model.HttpTemplate;
import org.mockserver.model.SocketAddress;
import java.util.List;
import java.util.Map;

import static org.mockserver.load.LoadFeeder.loadFeeder;
import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("user-browse")
    .withTemplateType(HttpTemplate.TemplateType.MUSTACHE)
    .withFeeder(loadFeeder()
        .withRows(List.of(
            Map.of("userId", "alice", "accountId", "A1"),
            Map.of("userId", "bob", "accountId", "A2"),
            Map.of("userId", "carol", "accountId", "A3")))
        .withStrategy(LoadFeeder.Strategy.CIRCULAR))
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(5, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET")
                .withPath("/accounts/{{iteration.data.accountId}}")
                .withHeader("X-User", "{{iteration.data.userId}}")
                .withHeader("Host", "api.svc:8080")
                .withSocketAddress("api.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.loadScenario(scenario);   // register (does NOT start it yet)

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

var scenario = {
    name: 'user-browse',
    templateType: 'MUSTACHE',
    feeder: {
        strategy: 'CIRCULAR',
        rows: [
            { userId: 'alice', accountId: 'A1' },
            { userId: 'bob', accountId: 'A2' },
            { userId: 'carol', accountId: 'A3' }
        ]
    },
    profile: { stages: [ { type: 'VU', vus: 5, durationMillis: 60000 } ] },
    steps: [
        { request: { method: 'GET', path: '/accounts/{{iteration.data.accountId}}',
                     headers: { 'X-User': ['{{iteration.data.userId}}'], 'Host': ['api.svc:8080'] },
                     socketAddress: { host: 'api.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.loadScenario(scenario);   // register (does NOT start it yet)
})();

from mockserver import (HttpRequest, KeyToMultiValue, LoadFeeder, LoadProfile,
                        LoadScenario, LoadStage, LoadStep, MockServerClient, SocketAddress)

scenario = LoadScenario(
    name="user-browse",
    template_type="MUSTACHE",
    feeder=LoadFeeder(
        rows=[
            {"userId": "alice", "accountId": "A1"},
            {"userId": "bob", "accountId": "A2"},
            {"userId": "carol", "accountId": "A3"},
        ],
        strategy="CIRCULAR",
    ),
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(60000, vus=5),
    ]),
    steps=[
        LoadStep(request=HttpRequest(
            method="GET",
            path="/accounts/{{iteration.data.accountId}}",
            headers=[
                KeyToMultiValue(name="X-User", values=["{{iteration.data.userId}}"]),
                KeyToMultiValue(name="Host", values=["api.svc:8080"]),
            ],
            socket_address=SocketAddress(host="api.svc", port=8080, scheme="HTTP"))),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)   # register (does NOT start it yet)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

scenario = LoadScenario.new(
  name: 'user-browse',
  template_type: 'MUSTACHE',
  feeder: LoadFeeder.new(
    strategy: 'CIRCULAR',
    rows: [
      { 'userId' => 'alice', 'accountId' => 'A1' },
      { 'userId' => 'bob',   'accountId' => 'A2' },
      { 'userId' => 'carol', 'accountId' => 'A3' }
    ]
  ),
  profile: LoadProfile.new(stages: [
    LoadStage.vu(60_000, vus: 5)
  ]),
  steps: [
    LoadStep.new(request: HttpRequest.new(
      method: 'GET',
      path: '/accounts/{{iteration.data.accountId}}',
      headers: [
        KeyToMultiValue.new(name: 'X-User', values: ['{{iteration.data.userId}}']),
        KeyToMultiValue.new(name: 'Host', values: ['api.svc:8080'])
      ],
      socket_address: SocketAddress.new(host: 'api.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)   # register (does NOT start it yet)
client.close

package main

import (
    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    browse := mockserver.Request().Method("GET").Path("/accounts/{{iteration.data.accountId}}").
        Header("X-User", "{{iteration.data.userId}}").
        Header("Host", "api.svc:8080").Build()
    browse.SocketAddress = &mockserver.SocketAddress{Host: "api.svc", Port: 8080, Scheme: "HTTP"}

    scenario := mockserver.LoadScenario{
        Name:         "user-browse",
        TemplateType: "MUSTACHE",
        Feeder: &mockserver.LoadFeeder{
            Strategy: mockserver.LoadFeederCircular,
            Rows: []map[string]string{
                {"userId": "alice", "accountId": "A1"},
                {"userId": "bob", "accountId": "A2"},
                {"userId": "carol", "accountId": "A3"},
            },
        },
        Profile: &mockserver.LoadProfile{
            Stages: []mockserver.LoadStage{
                mockserver.ConstantVusStage(5, 60000),
            },
        },
        Steps: []mockserver.LoadStep{
            {Request: &browse},
        },
    }

    client.LoadScenario(scenario)   // register (does NOT start it yet)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

var browse = HttpRequest.Request().WithMethod("GET").WithPath("/accounts/{{iteration.data.accountId}}")
    .WithHeader("X-User", "{{iteration.data.userId}}")
    .WithHeader("Host", "api.svc:8080")
    .Build();
browse.SocketAddress = new SocketAddress { Host = "api.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "user-browse",
    TemplateType = LoadTemplateType.MUSTACHE,
    Feeder = new LoadFeeder
    {
        Strategy = LoadFeederStrategy.CIRCULAR,
        Rows = new List<Dictionary<string, string>>
        {
            new() { ["userId"] = "alice", ["accountId"] = "A1" },
            new() { ["userId"] = "bob", ["accountId"] = "A2" },
            new() { ["userId"] = "carol", ["accountId"] = "A3" }
        }
    },
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(5, 60000) }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = browse }
    }
};

await client.LoadScenarioAsync(scenario);   // register (does NOT start it yet)

use mockserver_client::{
    ClientBuilder, HttpRequest, LoadFeeder, LoadFeederStrategy, LoadProfile, LoadScenario,
    LoadStage, LoadStep, SocketAddress,
};
use std::collections::HashMap;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let feeder = LoadFeeder::rows(vec![
    HashMap::from([("userId".to_string(), "alice".to_string()), ("accountId".to_string(), "A1".to_string())]),
    HashMap::from([("userId".to_string(), "bob".to_string()), ("accountId".to_string(), "A2".to_string())]),
    HashMap::from([("userId".to_string(), "carol".to_string()), ("accountId".to_string(), "A3".to_string())]),
])
.strategy(LoadFeederStrategy::Circular);

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(5, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/accounts/{{iteration.data.accountId}}")
        .header("X-User", "{{iteration.data.userId}}")
        .header("Host", "api.svc:8080")
        .socket_address(SocketAddress::new("api.svc", 8080))),
];
let scenario = LoadScenario::new("user-browse", profile, steps)
    .template_type("MUSTACHE")
    .feeder(feeder);

client.load_scenario(&scenario).unwrap();   // register (does NOT start it yet)

require_once 'vendor/autoload.php';

use MockServer\HttpRequest;
use MockServer\LoadFeeder;
use MockServer\LoadProfile;
use MockServer\LoadScenario;
use MockServer\LoadStage;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$scenario = LoadScenario::scenario('user-browse')
    ->templateType('MUSTACHE')
    ->feeder(LoadFeeder::rows([
        ['userId' => 'alice', 'accountId' => 'A1'],
        ['userId' => 'bob', 'accountId' => 'A2'],
        ['userId' => 'carol', 'accountId' => 'A3'],
    ])->strategy('CIRCULAR'))
    ->profile(LoadProfile::of(
        LoadStage::vuHold(5, 60000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/accounts/{{iteration.data.accountId}}')
            ->header('X-User', '{{iteration.data.userId}}')
            ->header('Host', 'api.svc:8080')
            ->socketAddress('api.svc', 8080, 'HTTP'),
    );

$client->loadScenario($scenario);   // register (does NOT start it yet)

# Inline rows — CIRCULAR: each iteration picks the next user in round-robin
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "user-browse",
    "templateType": "MUSTACHE",
    "feeder": {
      "strategy": "CIRCULAR",
      "rows": [
        { "userId": "alice", "accountId": "A1" },
        { "userId": "bob",   "accountId": "A2" },
        { "userId": "carol", "accountId": "A3" }
      ]
    },
    "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
    "steps": [
      {
        "request": {
          "method": "GET",
          "path": "/accounts/{{iteration.data.accountId}}",
          "headers": { "X-User": ["{{iteration.data.userId}}"],
                       "Host": ["api.svc:8080"] },
          "socketAddress": { "host": "api.svc", "port": 8080, "scheme": "HTTP" }
        }
      }
    ]
  }'

LoadScenario scenario = LoadScenario.loadScenario("user-browse-csv")
    .withTemplateType(HttpTemplate.TemplateType.MUSTACHE)
    .withFeeder(loadFeeder()
        .withData("userId,accountId\nalice,A1\nbob,A2\ncarol,A3")
        .withFormat(LoadFeeder.Format.CSV)
        .withStrategy(LoadFeeder.Strategy.CIRCULAR))
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(5, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET")
                .withPath("/accounts/{{iteration.data.accountId}}")
                .withHeader("Host", "api.svc:8080")
                .withSocketAddress("api.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.loadScenario(scenario);   // register (does NOT start it yet)

var scenario = {
    name: 'user-browse-csv',
    templateType: 'MUSTACHE',
    feeder: {
        format: 'CSV',
        strategy: 'CIRCULAR',
        data: 'userId,accountId\nalice,A1\nbob,A2\ncarol,A3'
    },
    profile: { stages: [ { type: 'VU', vus: 5, durationMillis: 60000 } ] },
    steps: [
        { request: { method: 'GET', path: '/accounts/{{iteration.data.accountId}}',
                     headers: { 'Host': ['api.svc:8080'] },
                     socketAddress: { host: 'api.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.loadScenario(scenario);   // register (does NOT start it yet)
})();

scenario = LoadScenario(
    name="user-browse-csv",
    template_type="MUSTACHE",
    feeder=LoadFeeder(
        data="userId,accountId\nalice,A1\nbob,A2\ncarol,A3",
        format="CSV",
        strategy="CIRCULAR",
    ),
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(60000, vus=5),
    ]),
    steps=[
        LoadStep(request=HttpRequest(
            method="GET",
            path="/accounts/{{iteration.data.accountId}}",
            headers=[KeyToMultiValue(name="Host", values=["api.svc:8080"])],
            socket_address=SocketAddress(host="api.svc", port=8080, scheme="HTTP"))),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)   # register (does NOT start it yet)

scenario = LoadScenario.new(
  name: 'user-browse-csv',
  template_type: 'MUSTACHE',
  feeder: LoadFeeder.new(
    format: 'CSV',
    strategy: 'CIRCULAR',
    data: "userId,accountId\nalice,A1\nbob,A2\ncarol,A3"
  ),
  profile: LoadProfile.new(stages: [
    LoadStage.vu(60_000, vus: 5)
  ]),
  steps: [
    LoadStep.new(request: HttpRequest.new(
      method: 'GET',
      path: '/accounts/{{iteration.data.accountId}}',
      headers: [KeyToMultiValue.new(name: 'Host', values: ['api.svc:8080'])],
      socket_address: SocketAddress.new(host: 'api.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)   # register (does NOT start it yet)
client.close

browse := mockserver.Request().Method("GET").Path("/accounts/{{iteration.data.accountId}}").
    Header("Host", "api.svc:8080").Build()
browse.SocketAddress = &mockserver.SocketAddress{Host: "api.svc", Port: 8080, Scheme: "HTTP"}

scenario := mockserver.LoadScenario{
    Name:         "user-browse-csv",
    TemplateType: "MUSTACHE",
    Feeder: &mockserver.LoadFeeder{
        Data:     "userId,accountId\nalice,A1\nbob,A2\ncarol,A3",
        Format:   "CSV",
        Strategy: mockserver.LoadFeederCircular,
    },
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.ConstantVusStage(5, 60000),
        },
    },
    Steps: []mockserver.LoadStep{
        {Request: &browse},
    },
}

client.LoadScenario(scenario)   // register (does NOT start it yet)

var browse = HttpRequest.Request().WithMethod("GET").WithPath("/accounts/{{iteration.data.accountId}}")
    .WithHeader("Host", "api.svc:8080")
    .Build();
browse.SocketAddress = new SocketAddress { Host = "api.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "user-browse-csv",
    TemplateType = LoadTemplateType.MUSTACHE,
    Feeder = new LoadFeeder
    {
        Data = "userId,accountId\nalice,A1\nbob,A2\ncarol,A3",
        Format = LoadFeederFormat.CSV,
        Strategy = LoadFeederStrategy.CIRCULAR
    },
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(5, 60000) }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = browse }
    }
};

await client.LoadScenarioAsync(scenario);   // register (does NOT start it yet)

use mockserver_client::{LoadFeeder, LoadFeederFormat, LoadFeederStrategy};

let feeder = LoadFeeder::data("userId,accountId\nalice,A1\nbob,A2\ncarol,A3", LoadFeederFormat::Csv)
    .strategy(LoadFeederStrategy::Circular);

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(5, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/accounts/{{iteration.data.accountId}}")
        .header("Host", "api.svc:8080")
        .socket_address(SocketAddress::new("api.svc", 8080))),
];
let scenario = LoadScenario::new("user-browse-csv", profile, steps)
    .template_type("MUSTACHE")
    .feeder(feeder);

client.load_scenario(&scenario).unwrap();   // register (does NOT start it yet)

$scenario = LoadScenario::scenario('user-browse-csv')
    ->templateType('MUSTACHE')
    ->feeder(LoadFeeder::raw("userId,accountId\nalice,A1\nbob,A2\ncarol,A3", 'CSV')->strategy('CIRCULAR'))
    ->profile(LoadProfile::of(
        LoadStage::vuHold(5, 60000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/accounts/{{iteration.data.accountId}}')
            ->header('Host', 'api.svc:8080')
            ->socketAddress('api.svc', 8080, 'HTTP'),
    );

$client->loadScenario($scenario);   // register (does NOT start it yet)

# Equivalent with raw CSV — parse happens once at scenario load time
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "user-browse-csv",
    "templateType": "MUSTACHE",
    "feeder": {
      "format": "CSV",
      "strategy": "CIRCULAR",
      "data": "userId,accountId\nalice,A1\nbob,A2\ncarol,A3"
    },
    "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
    "steps": [
      {
        "request": {
          "method": "GET",
          "path": "/accounts/{{iteration.data.accountId}}",
          "headers": { "Host": ["api.svc:8080"] },
          "socketAddress": { "host": "api.svc", "port": 8080, "scheme": "HTTP" }
        }
      }
    ]
  }'

LoadScenario scenario = LoadScenario.loadScenario("login-then-browse")
    .withTemplateType(HttpTemplate.TemplateType.MUSTACHE)
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(5, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("POST").withPath("/auth/login")
                .withHeader("Host", "api.svc:8080")
                .withHeader("Content-Type", "application/json")
                .withBody("{\"username\":\"user{{iteration.vuId}}\",\"password\":\"secret\"}")
                .withSocketAddress("api.svc", 8080, SocketAddress.Scheme.HTTP))
            .withName("login")
            .withCapture(LoadCapture.loadCapture("token", LoadCapture.Source.BODY_JSONPATH, "$.accessToken")),
        LoadStep.loadStep(request().withMethod("GET").withPath("/account")
                .withHeader("Host", "api.svc:8080")
                .withHeader("Authorization", "Bearer {{iteration.captured.token}}")
                .withSocketAddress("api.svc", 8080, SocketAddress.Scheme.HTTP))
            .withName("fetch-account")
    );

client.loadScenario(scenario);   // register (does NOT start it yet)

var scenario = {
    name: 'login-then-browse',
    templateType: 'MUSTACHE',
    profile: { stages: [
        { type: 'VU', vus: 5, durationMillis: 60000 }
    ] },
    steps: [
        { name: 'login',
          request: { method: 'POST', path: '/auth/login',
                     headers: { 'Host': ['api.svc:8080'], 'Content-Type': ['application/json'] },
                     body: '{"username":"user{{iteration.vuId}}","password":"secret"}',
                     socketAddress: { host: 'api.svc', port: 8080, scheme: 'HTTP' } },
          captures: [ { name: 'token', source: 'BODY_JSONPATH', expression: '$.accessToken' } ] },
        { name: 'fetch-account',
          request: { method: 'GET', path: '/account',
                     headers: { 'Host': ['api.svc:8080'], 'Authorization': ['Bearer {{iteration.captured.token}}'] },
                     socketAddress: { host: 'api.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

await client.loadScenario(scenario);   // register (does NOT start it yet)

scenario = LoadScenario(
    name="login-then-browse",
    template_type="MUSTACHE",
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(60000, vus=5),
    ]),
    steps=[
        LoadStep(name="login",
                 request=HttpRequest(method="POST", path="/auth/login",
                                     headers=[KeyToMultiValue(name="Host", values=["api.svc:8080"]),
                                              KeyToMultiValue(name="Content-Type", values=["application/json"])],
                                     body='{"username":"user{{iteration.vuId}}","password":"secret"}',
                                     socket_address=SocketAddress(host="api.svc", port=8080, scheme="HTTP")),
                 captures=[LoadCapture(name="token", source="BODY_JSONPATH", expression="$.accessToken")]),
        LoadStep(name="fetch-account",
                 request=HttpRequest(method="GET", path="/account",
                                     headers=[KeyToMultiValue(name="Host", values=["api.svc:8080"]),
                                              KeyToMultiValue(name="Authorization", values=["Bearer {{iteration.captured.token}}"])],
                                     socket_address=SocketAddress(host="api.svc", port=8080, scheme="HTTP"))),
    ],
)

client.load_scenario(scenario)   # register (does NOT start it yet)

scenario = LoadScenario.new(
  name: 'login-then-browse',
  template_type: 'MUSTACHE',
  profile: LoadProfile.new(stages: [
    LoadStage.vu(60_000, vus: 5)
  ]),
  steps: [
    LoadStep.new(name: 'login',
                 request: HttpRequest.new(method: 'POST', path: '/auth/login',
                                          headers: { 'Host' => ['api.svc:8080'], 'Content-Type' => ['application/json'] },
                                          body: '{"username":"user{{iteration.vuId}}","password":"secret"}',
                                          socket_address: SocketAddress.new(host: 'api.svc', port: 8080, scheme: 'HTTP')),
                 captures: [LoadCapture.new(name: 'token', source: 'BODY_JSONPATH', expression: '$.accessToken')]),
    LoadStep.new(name: 'fetch-account',
                 request: HttpRequest.new(method: 'GET', path: '/account',
                                          headers: { 'Host' => ['api.svc:8080'], 'Authorization' => ['Bearer {{iteration.captured.token}}'] },
                                          socket_address: SocketAddress.new(host: 'api.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)   # register (does NOT start it yet)

login := mockserver.Request().Method("POST").Path("/auth/login").
    Header("Host", "api.svc:8080").
    Header("Content-Type", "application/json").
    Body(`{"username":"user{{iteration.vuId}}","password":"secret"}`).Build()
login.SocketAddress = &mockserver.SocketAddress{Host: "api.svc", Port: 8080, Scheme: "HTTP"}

account := mockserver.Request().Method("GET").Path("/account").
    Header("Host", "api.svc:8080").
    Header("Authorization", "Bearer {{iteration.captured.token}}").Build()
account.SocketAddress = &mockserver.SocketAddress{Host: "api.svc", Port: 8080, Scheme: "HTTP"}

scenario := mockserver.LoadScenario{
    Name:         "login-then-browse",
    TemplateType: "MUSTACHE",
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.ConstantVusStage(5, 60000),
        },
    },
    Steps: []mockserver.LoadStep{
        {Name: "login", Request: &login,
         Captures: []mockserver.LoadCapture{
             {Name: "token", Source: mockserver.LoadCaptureBodyJSONPath, Expression: "$.accessToken"},
         }},
        {Name: "fetch-account", Request: &account},
    },
}

client.LoadScenario(scenario)   // register (does NOT start it yet)

var login = HttpRequest.Request().WithMethod("POST").WithPath("/auth/login")
    .WithHeader("Host", "api.svc:8080")
    .WithHeader("Content-Type", "application/json")
    .WithBody("{\"username\":\"user{{iteration.vuId}}\",\"password\":\"secret\"}").Build();
login.SocketAddress = new SocketAddress { Host = "api.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var account = HttpRequest.Request().WithMethod("GET").WithPath("/account")
    .WithHeader("Host", "api.svc:8080")
    .WithHeader("Authorization", "Bearer {{iteration.captured.token}}").Build();
account.SocketAddress = new SocketAddress { Host = "api.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "login-then-browse",
    TemplateType = LoadTemplateType.MUSTACHE,
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(5, 60000) }
    },
    Steps = new List<LoadStep>
    {
        new() { Name = "login", Request = login,
                Captures = new() { new LoadCapture { Name = "token", Source = LoadCaptureSource.BODY_JSONPATH, Expression = "$.accessToken" } } },
        new() { Name = "fetch-account", Request = account }
    }
};

await client.LoadScenarioAsync(scenario);   // register (does NOT start it yet)

let login = HttpRequest::new().method("POST").path("/auth/login")
    .header("Host", "api.svc:8080")
    .header("Content-Type", "application/json")
    .body(r#"{"username":"user{{iteration.vuId}}","password":"secret"}"#)
    .socket_address(SocketAddress::new("api.svc", 8080));
let account = HttpRequest::new().method("GET").path("/account")
    .header("Host", "api.svc:8080")
    .header("Authorization", "Bearer {{iteration.captured.token}}")
    .socket_address(SocketAddress::new("api.svc", 8080));

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(5, 60_000),
]);
let steps = vec![
    LoadStep::new(login)
        .capture(LoadCapture::new("token", LoadCaptureSource::BodyJsonpath, "$.accessToken")),
    LoadStep::new(account),
];
let scenario = LoadScenario::new("login-then-browse", profile, steps)
    .template_type("MUSTACHE");

client.load_scenario(&scenario).unwrap();   // register (does NOT start it yet)

$login = HttpRequest::request()->method('POST')->path('/auth/login')
    ->header('Host', 'api.svc:8080')
    ->header('Content-Type', 'application/json')
    ->body('{"username":"user{{iteration.vuId}}","password":"secret"}')
    ->socketAddress('api.svc', 8080, 'HTTP');

$account = HttpRequest::request()->method('GET')->path('/account')
    ->header('Host', 'api.svc:8080')
    ->header('Authorization', 'Bearer {{iteration.captured.token}}')
    ->socketAddress('api.svc', 8080, 'HTTP');

$scenario = LoadScenario::scenario('login-then-browse')
    ->templateType('MUSTACHE')
    ->profile(LoadProfile::of(
        LoadStage::vuHold(5, 60000),
    ))
    ->addStep($login, name: 'login',
        captures: [LoadCapture::of('token', 'BODY_JSONPATH', '$.accessToken')])
    ->addStep($account, name: 'fetch-account');

$client->loadScenario($scenario);   // register (does NOT start it yet)

# Login → capture token → use in subsequent step
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "login-then-browse",
    "templateType": "MUSTACHE",
    "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
    "steps": [
      {
        "name": "login",
        "request": {
          "method": "POST",
          "path": "/auth/login",
          "headers": {
            "Host": ["api.svc:8080"],
            "Content-Type": ["application/json"]
          },
          "body": { "username": "user{{iteration.vuId}}", "password": "secret" },
          "socketAddress": { "host": "api.svc", "port": 8080, "scheme": "HTTP" }
        },
        "captures": [
          { "name": "token", "source": "BODY_JSONPATH", "expression": "$.accessToken" }
        ]
      },
      {
        "name": "fetch-account",
        "request": {
          "method": "GET",
          "path": "/account",
          "headers": {
            "Host": ["api.svc:8080"],
            "Authorization": ["Bearer {{iteration.captured.token}}"]
          },
          "socketAddress": { "host": "api.svc", "port": 8080, "scheme": "HTTP" }
        }
      }
    ]
  }'

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.slo.SloObjective;

import java.util.List;

import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("checked-scenario")
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(5, 60000)
    ))
    .withThresholds(
        LoadThreshold.loadThreshold()
            .withMetric(LoadThreshold.Metric.CHECK_FAILURE_RATE)
            .withComparator(SloObjective.Comparator.LESS_THAN)
            .withThreshold(0.01)
    )
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/orders/123")
                .withSocketAddress("target", 8080))
            .withChecks(List.of(
                LoadCheck.loadCheck()
                    .withSource(LoadCheck.Source.STATUS)
                    .withComparator(LoadCheck.Comparator.EQUALS)
                    .withValue("200"),
                LoadCheck.loadCheck()
                    .withSource(LoadCheck.Source.HEADER)
                    .withHeaderName("Content-Type")
                    .withComparator(LoadCheck.Comparator.CONTAINS)
                    .withValue("application/json"),
                LoadCheck.loadCheck()
                    .withSource(LoadCheck.Source.BODY_JSONPATH)
                    .withJsonPath("$.status")
                    .withComparator(LoadCheck.Comparator.EQUALS)
                    .withValue("CONFIRMED")
            ))
    );

client.runLoadScenario(scenario);              // register + start (needs loadGenerationEnabled=true)
client.stopLoadScenarios("checked-scenario");  // stop when done

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

// The client submits raw JSON, so `checks` is expressed inline.
var scenario = {
    name: 'checked-scenario',
    profile: { stages: [ { type: 'VU', vus: 5, durationMillis: 60000 } ] },
    thresholds: [
        { metric: 'CHECK_FAILURE_RATE', comparator: 'LESS_THAN', threshold: 0.01 }
    ],
    steps: [
        {
            request: { method: 'GET', path: '/api/orders/123',
                       socketAddress: { host: 'target', port: 8080 } },
            checks: [
                { source: 'STATUS', comparator: 'EQUALS', value: '200' },
                { source: 'HEADER', headerName: 'Content-Type', comparator: 'CONTAINS', value: 'application/json' },
                { source: 'BODY_JSONPATH', jsonPath: '$.status', comparator: 'EQUALS', value: 'CONFIRMED' }
            ]
        }
    ]
};

(async function () {
    await client.runLoadScenario(scenario);            // register + start (needs loadGenerationEnabled=true)
    await client.stopLoadScenarios('checked-scenario');
})();

from mockserver import MockServerClient

# The typed LoadStep has no `checks` field yet, so submit the scenario as a raw dict.
scenario = {
    "name": "checked-scenario",
    "profile": {"stages": [{"type": "VU", "vus": 5, "durationMillis": 60000}]},
    "thresholds": [
        {"metric": "CHECK_FAILURE_RATE", "comparator": "LESS_THAN", "threshold": 0.01}
    ],
    "steps": [
        {
            "request": {"method": "GET", "path": "/api/orders/123",
                        "socketAddress": {"host": "target", "port": 8080}},
            "checks": [
                {"source": "STATUS", "comparator": "EQUALS", "value": "200"},
                {"source": "HEADER", "headerName": "Content-Type", "comparator": "CONTAINS", "value": "application/json"},
                {"source": "BODY_JSONPATH", "jsonPath": "$.status", "comparator": "EQUALS", "value": "CONFIRMED"},
            ],
        }
    ],
}

with MockServerClient("localhost", 1080) as client:
    client.run_load_scenario(scenario)             # register + start (needs loadGenerationEnabled=true)
    client.stop_load_scenarios("checked-scenario")

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

# The typed LoadStep has no `checks` field yet, so submit the scenario as a raw Hash.
scenario = {
  'name' => 'checked-scenario',
  'profile' => { 'stages' => [ { 'type' => 'VU', 'vus' => 5, 'durationMillis' => 60_000 } ] },
  'thresholds' => [
    { 'metric' => 'CHECK_FAILURE_RATE', 'comparator' => 'LESS_THAN', 'threshold' => 0.01 }
  ],
  'steps' => [
    {
      'request' => { 'method' => 'GET', 'path' => '/api/orders/123',
                     'socketAddress' => { 'host' => 'target', 'port' => 8080 } },
      'checks' => [
        { 'source' => 'STATUS', 'comparator' => 'EQUALS', 'value' => '200' },
        { 'source' => 'HEADER', 'headerName' => 'Content-Type', 'comparator' => 'CONTAINS', 'value' => 'application/json' },
        { 'source' => 'BODY_JSONPATH', 'jsonPath' => '$.status', 'comparator' => 'EQUALS', 'value' => 'CONFIRMED' }
      ]
    }
  ]
}

client.run_load_scenario(scenario)             # register + start (needs loadGenerationEnabled=true)
client.stop_load_scenarios('checked-scenario')
client.close

package main

import (
    "net/http"
    "strings"
)

func main() {
    // The typed LoadStep has no Checks field yet, so PUT the raw JSON directly.
    scenario := `{
      "name": "checked-scenario",
      "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
      "thresholds": [
        { "metric": "CHECK_FAILURE_RATE", "comparator": "LESS_THAN", "threshold": 0.01 }
      ],
      "steps": [
        {
          "request": { "method": "GET", "path": "/api/orders/123",
                       "socketAddress": { "host": "target", "port": 8080 } },
          "checks": [
            { "source": "STATUS", "comparator": "EQUALS", "value": "200" },
            { "source": "HEADER", "headerName": "Content-Type", "comparator": "CONTAINS", "value": "application/json" },
            { "source": "BODY_JSONPATH", "jsonPath": "$.status", "comparator": "EQUALS", "value": "CONFIRMED" }
          ]
        }
      ]
    }`

    base := "http://localhost:1080/mockserver"
    reg, _ := http.NewRequest("PUT", base+"/loadScenario", strings.NewReader(scenario))
    reg.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(reg) // 1. register (does NOT start it yet)

    start, _ := http.NewRequest("PUT", base+"/loadScenario/start",
        strings.NewReader(`{ "name": "checked-scenario" }`))
    http.DefaultClient.Do(start) // 2. start (needs loadGenerationEnabled=true)
}

using System.Net.Http;
using System.Text;

// The typed LoadStep has no Checks property yet, so PUT the raw JSON directly.
var scenario = """
{
  "name": "checked-scenario",
  "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
  "thresholds": [
    { "metric": "CHECK_FAILURE_RATE", "comparator": "LESS_THAN", "threshold": 0.01 }
  ],
  "steps": [
    {
      "request": { "method": "GET", "path": "/api/orders/123",
                   "socketAddress": { "host": "target", "port": 8080 } },
      "checks": [
        { "source": "STATUS", "comparator": "EQUALS", "value": "200" },
        { "source": "HEADER", "headerName": "Content-Type", "comparator": "CONTAINS", "value": "application/json" },
        { "source": "BODY_JSONPATH", "jsonPath": "$.status", "comparator": "EQUALS", "value": "CONFIRMED" }
      ]
    }
  ]
}
""";

using var http = new HttpClient();
var body = new StringContent(scenario, Encoding.UTF8, "application/json");
await http.PutAsync("http://localhost:1080/mockserver/loadScenario", body);           // register
await http.PutAsync("http://localhost:1080/mockserver/loadScenario/start",            // start
    new StringContent("{ \"name\": \"checked-scenario\" }", Encoding.UTF8, "application/json"));

use reqwest::blocking::Client;

// The typed LoadStep has no `checks` field yet, so PUT the raw JSON directly.
let scenario = r#"{
  "name": "checked-scenario",
  "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
  "thresholds": [
    { "metric": "CHECK_FAILURE_RATE", "comparator": "LESS_THAN", "threshold": 0.01 }
  ],
  "steps": [
    {
      "request": { "method": "GET", "path": "/api/orders/123",
                   "socketAddress": { "host": "target", "port": 8080 } },
      "checks": [
        { "source": "STATUS", "comparator": "EQUALS", "value": "200" },
        { "source": "HEADER", "headerName": "Content-Type", "comparator": "CONTAINS", "value": "application/json" },
        { "source": "BODY_JSONPATH", "jsonPath": "$.status", "comparator": "EQUALS", "value": "CONFIRMED" }
      ]
    }
  ]
}"#;

let http = Client::new();
http.put("http://localhost:1080/mockserver/loadScenario")            // register
    .header("Content-Type", "application/json").body(scenario).send().unwrap();
http.put("http://localhost:1080/mockserver/loadScenario/start")      // start (needs loadGenerationEnabled=true)
    .body(r#"{ "name": "checked-scenario" }"#).send().unwrap();

require_once 'vendor/autoload.php';

use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

// The typed LoadStep has no checks setter yet, so submit the scenario as a raw array.
$scenario = [
    'name' => 'checked-scenario',
    'profile' => ['stages' => [['type' => 'VU', 'vus' => 5, 'durationMillis' => 60000]]],
    'thresholds' => [
        ['metric' => 'CHECK_FAILURE_RATE', 'comparator' => 'LESS_THAN', 'threshold' => 0.01],
    ],
    'steps' => [
        [
            'request' => ['method' => 'GET', 'path' => '/api/orders/123',
                          'socketAddress' => ['host' => 'target', 'port' => 8080]],
            'checks' => [
                ['source' => 'STATUS', 'comparator' => 'EQUALS', 'value' => '200'],
                ['source' => 'HEADER', 'headerName' => 'Content-Type', 'comparator' => 'CONTAINS', 'value' => 'application/json'],
                ['source' => 'BODY_JSONPATH', 'jsonPath' => '$.status', 'comparator' => 'EQUALS', 'value' => 'CONFIRMED'],
            ],
        ],
    ],
];

$client->runLoadScenario($scenario);             // register + start (needs loadGenerationEnabled=true)
$client->stopLoadScenarios('checked-scenario');

# Start the server with load generation enabled:
#   docker run -e MOCKSERVER_LOAD_GENERATION_ENABLED=true mockserver/mockserver

# 1. REGISTER the scenario (does NOT run it) — PUT /mockserver/loadScenario
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "checked-scenario",
    "profile": { "stages": [ { "type": "VU", "vus": 5, "durationMillis": 60000 } ] },
    "thresholds": [
      { "metric": "CHECK_FAILURE_RATE", "comparator": "LESS_THAN", "threshold": 0.01 }
    ],
    "steps": [
      {
        "request": { "method": "GET", "path": "/api/orders/123",
                     "socketAddress": { "host": "target", "port": 8080 } },
        "checks": [
          { "source": "STATUS", "comparator": "EQUALS", "value": "200" },
          { "source": "HEADER", "headerName": "Content-Type", "comparator": "CONTAINS", "value": "application/json" },
          { "source": "BODY_JSONPATH", "jsonPath": "$.status", "comparator": "EQUALS", "value": "CONFIRMED" }
        ]
      }
    ]
  }'

# 2. START it (requires loadGenerationEnabled=true; else 403)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start -d '{ "name": "checked-scenario" }'

LoadScenario scenario = LoadScenario.loadScenario("mixed-shop-workload")
    .withStepSelection(LoadScenario.StepSelection.WEIGHTED)
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(20, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/products")
                .withSocketAddress("shop.svc", 8080, SocketAddress.Scheme.HTTP))
            .withName("browse")
            .withWeight(7.0),
        LoadStep.loadStep(request().withMethod("GET").withPath("/search?q=shoes")
                .withSocketAddress("shop.svc", 8080, SocketAddress.Scheme.HTTP))
            .withName("search")
            .withWeight(2.0),
        LoadStep.loadStep(request().withMethod("POST").withPath("/checkout")
                .withSocketAddress("shop.svc", 8080, SocketAddress.Scheme.HTTP))
            .withName("checkout")
            .withWeight(1.0)
    );

client.loadScenario(scenario);   // register (does NOT start it yet)

var scenario = {
    name: 'mixed-shop-workload',
    stepSelection: 'WEIGHTED',
    profile: { stages: [
        { type: 'VU', vus: 20, durationMillis: 60000 }
    ] },
    steps: [
        { name: 'browse', weight: 7,
          request: { method: 'GET', path: '/products',
                     socketAddress: { host: 'shop.svc', port: 8080, scheme: 'HTTP' } } },
        { name: 'search', weight: 2,
          request: { method: 'GET', path: '/search?q=shoes',
                     socketAddress: { host: 'shop.svc', port: 8080, scheme: 'HTTP' } } },
        { name: 'checkout', weight: 1,
          request: { method: 'POST', path: '/checkout',
                     socketAddress: { host: 'shop.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

await client.loadScenario(scenario);   // register (does NOT start it yet)

scenario = LoadScenario(
    name="mixed-shop-workload",
    step_selection="WEIGHTED",
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(60000, vus=20),
    ]),
    steps=[
        LoadStep(name="browse", weight=7.0,
                 request=HttpRequest(method="GET", path="/products",
                                     socket_address=SocketAddress(host="shop.svc", port=8080, scheme="HTTP"))),
        LoadStep(name="search", weight=2.0,
                 request=HttpRequest(method="GET", path="/search?q=shoes",
                                     socket_address=SocketAddress(host="shop.svc", port=8080, scheme="HTTP"))),
        LoadStep(name="checkout", weight=1.0,
                 request=HttpRequest(method="POST", path="/checkout",
                                     socket_address=SocketAddress(host="shop.svc", port=8080, scheme="HTTP"))),
    ],
)

client.load_scenario(scenario)   # register (does NOT start it yet)

scenario = LoadScenario.new(
  name: 'mixed-shop-workload',
  step_selection: 'WEIGHTED',
  profile: LoadProfile.new(stages: [
    LoadStage.vu(60_000, vus: 20)
  ]),
  steps: [
    LoadStep.new(name: 'browse', weight: 7.0,
                 request: HttpRequest.new(method: 'GET', path: '/products',
                                          socket_address: SocketAddress.new(host: 'shop.svc', port: 8080, scheme: 'HTTP'))),
    LoadStep.new(name: 'search', weight: 2.0,
                 request: HttpRequest.new(method: 'GET', path: '/search?q=shoes',
                                          socket_address: SocketAddress.new(host: 'shop.svc', port: 8080, scheme: 'HTTP'))),
    LoadStep.new(name: 'checkout', weight: 1.0,
                 request: HttpRequest.new(method: 'POST', path: '/checkout',
                                          socket_address: SocketAddress.new(host: 'shop.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)   # register (does NOT start it yet)

browseReq := mockserver.Request().Method("GET").Path("/products").Build()
browseReq.SocketAddress = &mockserver.SocketAddress{Host: "shop.svc", Port: 8080, Scheme: "HTTP"}
searchReq := mockserver.Request().Method("GET").Path("/search?q=shoes").Build()
searchReq.SocketAddress = &mockserver.SocketAddress{Host: "shop.svc", Port: 8080, Scheme: "HTTP"}
checkoutReq := mockserver.Request().Method("POST").Path("/checkout").Build()
checkoutReq.SocketAddress = &mockserver.SocketAddress{Host: "shop.svc", Port: 8080, Scheme: "HTTP"}

browseWeight, searchWeight, checkoutWeight := 7.0, 2.0, 1.0

scenario := mockserver.LoadScenario{
    Name:          "mixed-shop-workload",
    StepSelection: mockserver.StepSelectionWeighted,
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.ConstantVusStage(20, 60000),
        },
    },
    Steps: []mockserver.LoadStep{
        {Name: "browse", Request: &browseReq, Weight: &browseWeight},
        {Name: "search", Request: &searchReq, Weight: &searchWeight},
        {Name: "checkout", Request: &checkoutReq, Weight: &checkoutWeight},
    },
}

client.LoadScenario(scenario)   // register (does NOT start it yet)

var browse = HttpRequest.Request().WithMethod("GET").WithPath("/products").Build();
browse.SocketAddress = new SocketAddress { Host = "shop.svc", Port = 8080, Scheme = SocketScheme.HTTP };
var search = HttpRequest.Request().WithMethod("GET").WithPath("/search?q=shoes").Build();
search.SocketAddress = new SocketAddress { Host = "shop.svc", Port = 8080, Scheme = SocketScheme.HTTP };
var checkout = HttpRequest.Request().WithMethod("POST").WithPath("/checkout").Build();
checkout.SocketAddress = new SocketAddress { Host = "shop.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "mixed-shop-workload",
    StepSelection = LoadStepSelection.WEIGHTED,
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(20, 60000) }
    },
    Steps = new List<LoadStep>
    {
        new() { Name = "browse", Request = browse, Weight = 7.0 },
        new() { Name = "search", Request = search, Weight = 2.0 },
        new() { Name = "checkout", Request = checkout, Weight = 1.0 }
    }
};

await client.LoadScenarioAsync(scenario);   // register (does NOT start it yet)

let browse = HttpRequest::new().method("GET").path("/products")
    .socket_address(SocketAddress::new("shop.svc", 8080));
let search = HttpRequest::new().method("GET").path("/search?q=shoes")
    .socket_address(SocketAddress::new("shop.svc", 8080));
let checkout = HttpRequest::new().method("POST").path("/checkout")
    .socket_address(SocketAddress::new("shop.svc", 8080));

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(20, 60_000),
]);
let steps = vec![
    LoadStep::new(browse).weight(7.0),
    LoadStep::new(search).weight(2.0),
    LoadStep::new(checkout).weight(1.0),
];
let scenario = LoadScenario::new("mixed-shop-workload", profile, steps)
    .step_selection(LoadStepSelection::Weighted);

client.load_scenario(&scenario).unwrap();   // register (does NOT start it yet)

$browse = HttpRequest::request()->method('GET')->path('/products')
    ->socketAddress('shop.svc', 8080, 'HTTP');
$search = HttpRequest::request()->method('GET')->path('/search?q=shoes')
    ->socketAddress('shop.svc', 8080, 'HTTP');
$checkout = HttpRequest::request()->method('POST')->path('/checkout')
    ->socketAddress('shop.svc', 8080, 'HTTP');

$scenario = LoadScenario::scenario('mixed-shop-workload')
    ->stepSelection('WEIGHTED')
    ->profile(LoadProfile::of(
        LoadStage::vuHold(20, 60000),
    ))
    ->addStep($browse, name: 'browse', weight: 7.0)
    ->addStep($search, name: 'search', weight: 2.0)
    ->addStep($checkout, name: 'checkout', weight: 1.0);

$client->loadScenario($scenario);   // register (does NOT start it yet)

# Mixed workload: 70% browse, 20% search, 10% checkout
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "mixed-shop-workload",
    "stepSelection": "WEIGHTED",
    "profile": { "stages": [ { "type": "VU", "vus": 20, "durationMillis": 60000 } ] },
    "steps": [
      {
        "name": "browse",
        "weight": 7,
        "request": { "method": "GET", "path": "/products",
                     "socketAddress": { "host": "shop.svc", "port": 8080, "scheme": "HTTP" } }
      },
      {
        "name": "search",
        "weight": 2,
        "request": { "method": "GET", "path": "/search?q=shoes",
                     "socketAddress": { "host": "shop.svc", "port": 8080, "scheme": "HTTP" } }
      },
      {
        "name": "checkout",
        "weight": 1,
        "request": { "method": "POST", "path": "/checkout",
                     "socketAddress": { "host": "shop.svc", "port": 8080, "scheme": "HTTP" } }
      }
    ]
  }'

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.model.Delay;
import org.mockserver.model.HttpTemplate;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("checkout-load")
    .withTemplateType(HttpTemplate.TemplateType.VELOCITY)
    .withMaxRequests(100000)
    .withStartDelayMillis(500)
    .withLabels(Map.of("team", "payments", "env", "staging"))
    .withProfile(LoadProfile.of(
        LoadStage.rampRate(5, 50, 30000, RampCurve.LINEAR).withMaxVus(50),
        LoadStage.constantVus(25, 60000),
        LoadStage.pause(10000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/products/$!iteration.index"))
            .withName("browse")
            .withThinkTime(new Delay(TimeUnit.MILLISECONDS, 500)),
        LoadStep.loadStep(request().withMethod("POST").withPath("/cart/checkout")
                .withBody("{\"item\":\"$!iteration.index\",\"qty\":1}"))
            .withName("checkout")
            .withLabels(Map.of("critical", "true"))
    );

client.loadScenario(scenario);                  // 1. register (does NOT start it yet)
client.startLoadScenarios("checkout-load");     // 2. start (requires loadGenerationEnabled=true)
String listing = client.loadScenarios();        // 3. list all registered scenarios
String status = client.getLoadScenario("checkout-load"); // live throughput / latency status
client.stopLoadScenarios("checkout-load");      // 4. stop (no args stops ALL running scenarios)
client.clearLoadScenarios();                     //    tidy up the registry

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

// The per-step field is `request` (a full HttpRequest), not `httpRequest`.
var scenario = {
    name: 'checkout-load',
    templateType: 'VELOCITY',
    maxRequests: 100000,
    startDelayMillis: 500,
    labels: { team: 'payments', env: 'staging' },
    profile: {
        stages: [
            { type: 'RATE', startRate: 5, endRate: 50, durationMillis: 30000, curve: 'LINEAR', maxVus: 50 },
            { type: 'VU', vus: 25, durationMillis: 60000 },
            { type: 'PAUSE', durationMillis: 10000 }
        ]
    },
    steps: [
        { name: 'browse', request: { method: 'GET', path: '/products/$!iteration.index' },
          thinkTime: { timeUnit: 'MILLISECONDS', value: 500 } },
        { name: 'checkout', labels: { critical: 'true' },
          request: { method: 'POST', path: '/cart/checkout',
                     headers: { 'Content-Type': ['application/json'] },
                     body: '{"item":"$!iteration.index","qty":1}' } }
    ]
};

(async function () {
    await client.loadScenario(scenario);                 // 1. register (does NOT start it yet)
    await client.startLoadScenarios('checkout-load');    // 2. start (requires loadGenerationEnabled=true)
    var listing = await client.loadScenarios();          // 3. list all registered scenarios
    var status = await client.getLoadScenario('checkout-load'); // live status
    await client.stopLoadScenarios('checkout-load');     // 4. stop (no arg stops ALL running scenarios)
    await client.clearLoadScenarios();                    //    tidy up the registry
})();

from mockserver import (Delay, HttpRequest, LoadProfile, LoadScenario,
                        LoadStage, LoadStep, MockServerClient)

scenario = LoadScenario(
    name="checkout-load",
    template_type="VELOCITY",
    max_requests=100000,
    start_delay_millis=500,
    labels={"team": "payments", "env": "staging"},
    profile=LoadProfile(stages=[
        LoadStage.rate_stage(30000, start_rate=5, end_rate=50, max_vus=50, curve="LINEAR"),
        LoadStage.vu_stage(60000, vus=25),
        LoadStage.pause_stage(10000),
    ]),
    steps=[
        LoadStep(name="browse",
                 request=HttpRequest(method="GET", path="/products/$!iteration.index"),
                 think_time=Delay(time_unit="MILLISECONDS", value=500)),
        LoadStep(name="checkout", labels={"critical": "true"},
                 request=HttpRequest(method="POST", path="/cart/checkout",
                                     body='{"item":"$!iteration.index","qty":1}')),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)                # 1. register (does NOT start it yet)
    client.start_load_scenarios("checkout-load")  # 2. start (requires loadGenerationEnabled=true)
    listing = client.load_scenarios()             # 3. list all registered scenarios
    status = client.get_load_scenario("checkout-load")  # live status
    client.stop_load_scenarios("checkout-load")   # 4. stop (None stops ALL running scenarios)
    client.clear_load_scenarios()                  #    tidy up the registry

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

scenario = LoadScenario.new(
  name: 'checkout-load',
  template_type: 'VELOCITY',
  max_requests: 100_000,
  start_delay_millis: 500,
  labels: { 'team' => 'payments', 'env' => 'staging' },
  profile: LoadProfile.new(stages: [
    LoadStage.rate(30_000, start_rate: 5, end_rate: 50, max_vus: 50, curve: 'LINEAR'),
    LoadStage.vu(60_000, vus: 25),
    LoadStage.pause(10_000)
  ]),
  steps: [
    LoadStep.new(name: 'browse',
                 request: HttpRequest.new(method: 'GET', path: '/products/$!iteration.index'),
                 think_time: Delay.new(time_unit: 'MILLISECONDS', value: 500)),
    LoadStep.new(name: 'checkout', labels: { 'critical' => 'true' },
                 request: HttpRequest.new(method: 'POST', path: '/cart/checkout',
                                          body: '{"item":"$!iteration.index","qty":1}'))
  ]
)

client.load_scenario(scenario)               # 1. register (does NOT start it yet)
client.start_load_scenarios('checkout-load') # 2. start (requires loadGenerationEnabled=true)
client.load_scenarios                        # 3. list all registered scenarios
client.get_load_scenario('checkout-load')    # live status
client.stop_load_scenarios('checkout-load')  # 4. stop (nil stops ALL running scenarios)
client.clear_load_scenarios                  #    tidy up the registry
client.close

package main

import (
    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    browse := mockserver.Request().Method("GET").Path("/products/$!iteration.index").Build()
    checkout := mockserver.Request().Method("POST").Path("/cart/checkout").
        Body(`{"item":"$!iteration.index","qty":1}`).Build()

    // MaxVus is an optional *int field on a RATE stage.
    rampStage := mockserver.RampRateStage(5, 50, 30000, mockserver.RampLinear)
    maxVus := 50
    rampStage.MaxVus = &maxVus

    scenario := mockserver.LoadScenario{
        Name:             "checkout-load",
        TemplateType:     "VELOCITY",
        MaxRequests:      100000,
        StartDelayMillis: 500,
        Labels:           map[string]string{"team": "payments", "env": "staging"},
        Profile: &mockserver.LoadProfile{
            Stages: []mockserver.LoadStage{
                rampStage,
                mockserver.ConstantVusStage(25, 60000),
                mockserver.PauseStage(10000),
            },
        },
        Steps: []mockserver.LoadStep{
            {Name: "browse", Request: &browse, ThinkTime: &mockserver.Delay{TimeUnit: "MILLISECONDS", Value: 500}},
            {Name: "checkout", Request: &checkout, Labels: map[string]string{"critical": "true"}},
        },
    }

    client.LoadScenario(scenario)              // 1. register (does NOT start it yet)
    client.StartLoadScenarios("checkout-load") // 2. start (requires loadGenerationEnabled=true)
    client.LoadScenarios()                     // 3. list all registered scenarios
    client.GetLoadScenario("checkout-load")    // live status
    client.StopLoadScenarios("checkout-load")  // 4. stop (no args stops ALL running scenarios)
    client.ClearLoadScenarios()                //    tidy up the registry
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

var scenario = new LoadScenario
{
    Name = "checkout-load",
    TemplateType = LoadTemplateType.VELOCITY,
    MaxRequests = 100000,
    StartDelayMillis = 500,
    Labels = new Dictionary<string, string> { ["team"] = "payments", ["env"] = "staging" },
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage>
        {
            new LoadStage { Type = LoadStageType.RATE, StartRate = 5, EndRate = 50,
                            DurationMillis = 30000, Curve = RampCurve.LINEAR, MaxVus = 50 },
            LoadStage.ConstantVus(25, 60000),
            LoadStage.Pause(10000)
        }
    },
    Steps = new List<LoadStep>
    {
        new() { Name = "browse",
                Request = HttpRequest.Request().WithMethod("GET").WithPath("/products/$!iteration.index"),
                ThinkTime = new Delay { TimeUnit = TimeUnit.MILLISECONDS, Value = 500 } },
        new() { Name = "checkout",
                Request = HttpRequest.Request().WithMethod("POST").WithPath("/cart/checkout")
                    .WithBody("{\"item\":\"$!iteration.index\",\"qty\":1}"),
                Labels = new Dictionary<string, string> { ["critical"] = "true" } }
    }
};

await client.LoadScenarioAsync(scenario);              // 1. register (does NOT start it yet)
await client.StartLoadScenariosAsync("checkout-load"); // 2. start (requires loadGenerationEnabled=true)
var listing = await client.LoadScenariosAsync();       // 3. list all registered scenarios
var status = await client.GetLoadScenarioAsync("checkout-load"); // live status
await client.StopLoadScenariosAsync("checkout-load");  // 4. stop (no args stops ALL running scenarios)
await client.ClearLoadScenariosAsync();                //    tidy up the registry

use mockserver_client::{
    ClientBuilder, Delay, HttpRequest, LoadProfile, LoadScenario, LoadStage, LoadStep, RampCurve,
};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let profile = LoadProfile::of(vec![
    LoadStage::rate_ramp(5.0, 50.0, 30_000, RampCurve::Linear).max_vus(50),
    LoadStage::vu_hold(25, 60_000),
    LoadStage::pause(10_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/products/$!iteration.index"))
        .think_time(Delay::milliseconds(500)),
    LoadStep::new(HttpRequest::new().method("POST").path("/cart/checkout")
        .body(r#"{"item":"$!iteration.index","qty":1}"#)),
];
let scenario = LoadScenario::new("checkout-load", profile, steps)
    .template_type("VELOCITY")
    .max_requests(100_000)
    .start_delay_millis(500);

client.load_scenario(&scenario).unwrap();                // 1. register (does NOT start it yet)
client.start_load_scenarios(&["checkout-load"]).unwrap(); // 2. start (requires loadGenerationEnabled=true)
client.load_scenarios().unwrap();                         // 3. list all registered scenarios
client.get_load_scenario("checkout-load").unwrap();       // live status
client.stop_load_scenarios(&["checkout-load"]).unwrap();  // 4. stop (&[] stops ALL running scenarios)
client.clear_load_scenarios().unwrap();                   //    tidy up the registry

require_once 'vendor/autoload.php';

use MockServer\Delay;
use MockServer\HttpRequest;
use MockServer\LoadProfile;
use MockServer\LoadScenario;
use MockServer\LoadStage;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$scenario = LoadScenario::scenario('checkout-load')
    ->templateType('VELOCITY')
    ->maxRequests(100000)
    ->startDelayMillis(500)
    ->labels(['team' => 'payments', 'env' => 'staging'])
    ->profile(LoadProfile::of(
        LoadStage::rateRamp(5, 50, 30000, 'LINEAR')->maxVus(50),
        LoadStage::vuHold(25, 60000),
        LoadStage::pause(10000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/products/$!iteration.index'),
        Delay::milliseconds(500),
        'browse',
    )
    ->addStep(
        HttpRequest::request()->method('POST')->path('/cart/checkout')
            ->body('{"item":"$!iteration.index","qty":1}'),
        null,
        'checkout',
        ['critical' => 'true'],
    );

$client->loadScenario($scenario);              // 1. register (does NOT start it yet)
$client->startLoadScenarios('checkout-load');  // 2. start (requires loadGenerationEnabled=true)
$client->loadScenarios();                       // 3. list all registered scenarios
$client->getLoadScenario('checkout-load');      // live status
$client->stopLoadScenarios('checkout-load');    // 4. stop (null stops ALL running scenarios)
$client->clearLoadScenarios();                  //    tidy up the registry

# Start the server with load generation enabled:
#   docker run -e MOCKSERVER_LOAD_GENERATION_ENABLED=true mockserver/mockserver

# 1. REGISTER (does NOT run it) — PUT /mockserver/loadScenario
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "checkout-load",
    "templateType": "VELOCITY",
    "maxRequests": 100000,
    "startDelayMillis": 500,
    "labels": { "team": "payments", "env": "staging" },
    "profile": { "stages": [
      { "type": "RATE", "startRate": 5, "endRate": 50, "durationMillis": 30000, "curve": "LINEAR", "maxVus": 50 },
      { "type": "VU", "vus": 25, "durationMillis": 60000 },
      { "type": "PAUSE", "durationMillis": 10000 }
    ] },
    "steps": [
      { "name": "browse", "request": { "method": "GET", "path": "/products/$!iteration.index" },
        "thinkTime": { "timeUnit": "MILLISECONDS", "value": 500 } },
      { "name": "checkout", "labels": { "critical": "true" },
        "request": { "method": "POST", "path": "/cart/checkout",
                     "body": "{\"item\":\"$!iteration.index\",\"qty\":1}" } }
    ]
  }'

# 2. START it (requires loadGenerationEnabled=true; else 403)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -d '{ "name": "checkout-load" }'

# 3. LIST all registered scenarios, and read one scenario's live status
curl -s http://localhost:1080/mockserver/loadScenario
curl -s http://localhost:1080/mockserver/loadScenario/checkout-load

# 4. STOP it (stays registered, STOPPED — can be re-triggered)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/stop \
  -d '{ "name": "checkout-load" }'

LoadScenario scenario = LoadScenario.loadScenario("orders-ramp")
    .withProfile(LoadProfile.of(
        LoadStage.rampVus(1, 10, 30000, RampCurve.LINEAR),
        LoadStage.constantVus(10, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/orders/$!iteration.index"))
            .withThinkTime(new Delay(TimeUnit.MILLISECONDS, 20))
    );

client.runLoadScenario(scenario);          // register + start in one call
client.stopLoadScenarios("orders-ramp");   // stop when done

var scenario = {
    name: 'orders-ramp',
    profile: { stages: [
        { type: 'VU', startVus: 1, endVus: 10, durationMillis: 30000, curve: 'LINEAR' },
        { type: 'VU', vus: 10, durationMillis: 60000 }
    ] },
    steps: [
        { request: { method: 'GET', path: '/api/orders/$!iteration.index' },
          thinkTime: { timeUnit: 'MILLISECONDS', value: 20 } }
    ]
};

await client.runLoadScenario(scenario);     // register + start in one call
await client.stopLoadScenarios('orders-ramp');

scenario = LoadScenario(
    name="orders-ramp",
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(30000, start_vus=1, end_vus=10, curve="LINEAR"),
        LoadStage.vu_stage(60000, vus=10),
    ]),
    steps=[
        LoadStep(request=HttpRequest(method="GET", path="/api/orders/$!iteration.index"),
                 think_time=Delay(time_unit="MILLISECONDS", value=20)),
    ],
)

client.run_load_scenario(scenario)          # register + start in one call
client.stop_load_scenarios("orders-ramp")

scenario = LoadScenario.new(
  name: 'orders-ramp',
  profile: LoadProfile.new(stages: [
    LoadStage.vu(30_000, start_vus: 1, end_vus: 10, curve: 'LINEAR'),
    LoadStage.vu(60_000, vus: 10)
  ]),
  steps: [
    LoadStep.new(request: HttpRequest.new(method: 'GET', path: '/api/orders/$!iteration.index'),
                 think_time: Delay.new(time_unit: 'MILLISECONDS', value: 20))
  ]
)

client.run_load_scenario(scenario)          # register + start in one call
client.stop_load_scenarios('orders-ramp')

order := mockserver.Request().Method("GET").Path("/api/orders/$!iteration.index").Build()

scenario := mockserver.LoadScenario{
    Name: "orders-ramp",
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.RampVusStage(1, 10, 30000, mockserver.RampLinear),
            mockserver.ConstantVusStage(10, 60000),
        },
    },
    Steps: []mockserver.LoadStep{
        {Request: &order, ThinkTime: &mockserver.Delay{TimeUnit: "MILLISECONDS", Value: 20}},
    },
}

client.RunLoadScenario(scenario)            // register + start in one call
client.StopLoadScenarios("orders-ramp")

var scenario = new LoadScenario
{
    Name = "orders-ramp",
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage>
        {
            LoadStage.RampVus(1, 10, 30000, RampCurve.LINEAR),
            LoadStage.ConstantVus(10, 60000)
        }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = HttpRequest.Request().WithMethod("GET").WithPath("/api/orders/$!iteration.index"),
                ThinkTime = new Delay { TimeUnit = TimeUnit.MILLISECONDS, Value = 20 } }
    }
};

await client.RunLoadScenarioAsync(scenario);     // register + start in one call
await client.StopLoadScenariosAsync("orders-ramp");

let profile = LoadProfile::of(vec![
    LoadStage::vu_ramp(1, 10, 30_000, RampCurve::Linear),
    LoadStage::vu_hold(10, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/api/orders/$!iteration.index"))
        .think_time(Delay::milliseconds(20)),
];
let scenario = LoadScenario::new("orders-ramp", profile, steps);

client.run_load_scenario(&scenario).unwrap();      // register + start in one call
client.stop_load_scenarios(&["orders-ramp"]).unwrap();

$scenario = LoadScenario::scenario('orders-ramp')
    ->profile(LoadProfile::of(
        LoadStage::vuRamp(1, 10, 30000, 'LINEAR'),
        LoadStage::vuHold(10, 60000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/api/orders/$!iteration.index'),
        Delay::milliseconds(20),
    );

$client->runLoadScenario($scenario);             // register + start in one call
$client->stopLoadScenarios('orders-ramp');

# Register the scenario...
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "orders-ramp",
    "profile": { "stages": [
      { "type": "VU", "startVus": 1, "endVus": 10, "durationMillis": 30000, "curve": "LINEAR" },
      { "type": "VU", "vus": 10, "durationMillis": 60000 }
    ] },
    "steps": [
      { "request": { "method": "GET", "path": "/api/orders/$!iteration.index" },
        "thinkTime": { "timeUnit": "MILLISECONDS", "value": 20 } }
    ]
  }'

# ...then start it (requires loadGenerationEnabled=true)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start -d '{ "name": "orders-ramp" }'

LoadScenario scenario = LoadScenario.loadScenario("rate-soak")
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(2, 10000),
        LoadStage.pause(5000),
        LoadStage.rampRate(10, 200, 30000, RampCurve.EXPONENTIAL).withMaxVus(40),
        LoadStage.constantRate(200, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/health"))
    );

client.runLoadScenario(scenario);          // register + start in one call
client.stopLoadScenarios("rate-soak");

var scenario = {
    name: 'rate-soak',
    profile: { stages: [
        { type: 'VU', vus: 2, durationMillis: 10000 },
        { type: 'PAUSE', durationMillis: 5000 },
        { type: 'RATE', startRate: 10, endRate: 200, durationMillis: 30000, curve: 'EXPONENTIAL', maxVus: 40 },
        { type: 'RATE', rate: 200, durationMillis: 60000 }
    ] },
    steps: [ { request: { method: 'GET', path: '/health' } } ]
};

await client.runLoadScenario(scenario);     // register + start in one call
await client.stopLoadScenarios('rate-soak');

scenario = LoadScenario(
    name="rate-soak",
    profile=LoadProfile(stages=[
        LoadStage.vu_stage(10000, vus=2),
        LoadStage.pause_stage(5000),
        LoadStage.rate_stage(30000, start_rate=10, end_rate=200, max_vus=40, curve="EXPONENTIAL"),
        LoadStage.rate_stage(60000, rate=200),
    ]),
    steps=[LoadStep(request=HttpRequest(method="GET", path="/health"))],
)

client.run_load_scenario(scenario)          # register + start in one call
client.stop_load_scenarios("rate-soak")

scenario = LoadScenario.new(
  name: 'rate-soak',
  profile: LoadProfile.new(stages: [
    LoadStage.vu(10_000, vus: 2),
    LoadStage.pause(5_000),
    LoadStage.rate(30_000, start_rate: 10, end_rate: 200, max_vus: 40, curve: 'EXPONENTIAL'),
    LoadStage.rate(60_000, rate: 200)
  ]),
  steps: [LoadStep.new(request: HttpRequest.new(method: 'GET', path: '/health'))]
)

client.run_load_scenario(scenario)          # register + start in one call
client.stop_load_scenarios('rate-soak')

health := mockserver.Request().Method("GET").Path("/health").Build()

ramp := mockserver.RampRateStage(10, 200, 30000, mockserver.RampExponential)
maxVus := 40
ramp.MaxVus = &maxVus

scenario := mockserver.LoadScenario{
    Name: "rate-soak",
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.ConstantVusStage(2, 10000),
            mockserver.PauseStage(5000),
            ramp,
            mockserver.ConstantRateStage(200, 60000),
        },
    },
    Steps: []mockserver.LoadStep{ {Request: &health} },
}

client.RunLoadScenario(scenario)            // register + start in one call
client.StopLoadScenarios("rate-soak")

var scenario = new LoadScenario
{
    Name = "rate-soak",
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage>
        {
            LoadStage.ConstantVus(2, 10000),
            LoadStage.Pause(5000),
            new LoadStage { Type = LoadStageType.RATE, StartRate = 10, EndRate = 200,
                            DurationMillis = 30000, Curve = RampCurve.EXPONENTIAL, MaxVus = 40 },
            LoadStage.ConstantRate(200, 60000)
        }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = HttpRequest.Request().WithMethod("GET").WithPath("/health") }
    }
};

await client.RunLoadScenarioAsync(scenario);     // register + start in one call
await client.StopLoadScenariosAsync("rate-soak");

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(2, 10_000),
    LoadStage::pause(5_000),
    LoadStage::rate_ramp(10.0, 200.0, 30_000, RampCurve::Exponential).max_vus(40),
    LoadStage::rate_hold(200.0, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/health")),
];
let scenario = LoadScenario::new("rate-soak", profile, steps);

client.run_load_scenario(&scenario).unwrap();      // register + start in one call
client.stop_load_scenarios(&["rate-soak"]).unwrap();

$scenario = LoadScenario::scenario('rate-soak')
    ->profile(LoadProfile::of(
        LoadStage::vuHold(2, 10000),
        LoadStage::pause(5000),
        LoadStage::rateRamp(10, 200, 30000, 'EXPONENTIAL')->maxVus(40),
        LoadStage::rateHold(200, 60000),
    ))
    ->addStep(HttpRequest::request()->method('GET')->path('/health'));

$client->runLoadScenario($scenario);             // register + start in one call
$client->stopLoadScenarios('rate-soak');

# Register the open-model soak...
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "rate-soak",
    "profile": { "stages": [
      { "type": "VU", "vus": 2, "durationMillis": 10000 },
      { "type": "PAUSE", "durationMillis": 5000 },
      { "type": "RATE", "startRate": 10, "endRate": 200, "durationMillis": 30000, "curve": "EXPONENTIAL", "maxVus": 40 },
      { "type": "RATE", "rate": 200, "durationMillis": 60000 }
    ] },
    "steps": [
      { "request": { "method": "GET", "path": "/health" } }
    ]
  }'

# ...then start it (requires loadGenerationEnabled=true)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start -d '{ "name": "rate-soak" }'

import org.mockserver.client.MockServerClient;
import org.mockserver.load.*;
import org.mockserver.model.SocketAddress;
import org.mockserver.slo.SloObjective;

import static org.mockserver.model.HttpRequest.request;

MockServerClient client = new MockServerClient("localhost", 1080);

LoadScenario scenario = LoadScenario.loadScenario("checkout-gated")
    .withThresholds(
        LoadThreshold.loadThreshold()
            .withMetric(LoadThreshold.Metric.LATENCY_P99)
            .withComparator(SloObjective.Comparator.LESS_THAN)
            .withThreshold(200),
        LoadThreshold.loadThreshold()
            .withMetric(LoadThreshold.Metric.ERROR_RATE)
            .withComparator(SloObjective.Comparator.LESS_THAN_OR_EQUAL)
            .withThreshold(0.01))
    .withAbortOnFail(true)
    .withAbortGraceMillis(5000)
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(10, 60000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("POST").withPath("/checkout")
            .withSocketAddress("shop.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.loadScenario(scenario);                // register
client.startLoadScenarios("checkout-gated");  // start (requires loadGenerationEnabled=true)
String status = client.getLoadScenario("checkout-gated");
// the status JSON carries a "verdict" field — "PASS" while all thresholds hold, "FAIL" on a breach

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

var scenario = {
    name: 'checkout-gated',
    thresholds: [
        { metric: 'LATENCY_P99', comparator: 'LESS_THAN', threshold: 200 },
        { metric: 'ERROR_RATE', comparator: 'LESS_THAN_OR_EQUAL', threshold: 0.01 }
    ],
    abortOnFail: true,
    abortGraceMillis: 5000,
    profile: { stages: [ { type: 'VU', vus: 10, durationMillis: 60000 } ] },
    steps: [
        { request: { method: 'POST', path: '/checkout',
                     socketAddress: { host: 'shop.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.loadScenario(scenario);               // register
    await client.startLoadScenarios('checkout-gated'); // start (requires loadGenerationEnabled=true)
    var status = await client.getLoadScenario('checkout-gated');
    // status.verdict is 'PASS' while all thresholds hold, 'FAIL' on a breach
    console.log('verdict:', status.verdict);
})();

from mockserver import (HttpRequest, LoadProfile, LoadScenario, LoadStage,
                        LoadStep, LoadThreshold, MockServerClient, SocketAddress)

scenario = LoadScenario(
    name="checkout-gated",
    thresholds=[
        LoadThreshold(metric="LATENCY_P99", comparator="LESS_THAN", threshold=200),
        LoadThreshold(metric="ERROR_RATE", comparator="LESS_THAN_OR_EQUAL", threshold=0.01),
    ],
    abort_on_fail=True,
    abort_grace_millis=5000,
    profile=LoadProfile(stages=[LoadStage.vu_stage(60000, vus=10)]),
    steps=[
        LoadStep(request=HttpRequest(method="POST", path="/checkout",
                                     socket_address=SocketAddress(host="shop.svc", port=8080, scheme="HTTP"))),
    ],
)

with MockServerClient("localhost", 1080) as client:
    client.load_scenario(scenario)                 # register
    client.start_load_scenarios("checkout-gated")  # start (requires loadGenerationEnabled=true)
    status = client.get_load_scenario("checkout-gated")
    # status["verdict"] is "PASS" while all thresholds hold, "FAIL" on a breach
    print("verdict:", status.get("verdict"))

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

scenario = LoadScenario.new(
  name: 'checkout-gated',
  thresholds: [
    LoadThreshold.new(metric: 'LATENCY_P99', comparator: 'LESS_THAN', threshold: 200),
    LoadThreshold.new(metric: 'ERROR_RATE', comparator: 'LESS_THAN_OR_EQUAL', threshold: 0.01)
  ],
  abort_on_fail: true,
  abort_grace_millis: 5000,
  profile: LoadProfile.new(stages: [LoadStage.vu(60_000, vus: 10)]),
  steps: [
    LoadStep.new(request: HttpRequest.new(method: 'POST', path: '/checkout',
                                          socket_address: SocketAddress.new(host: 'shop.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)                # register
client.start_load_scenarios('checkout-gated') # start (requires loadGenerationEnabled=true)
status = client.get_load_scenario('checkout-gated')
# status['verdict'] is 'PASS' while all thresholds hold, 'FAIL' on a breach
client.close

package main

import (
    "fmt"

    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    checkout := mockserver.Request().Method("POST").Path("/checkout").Build()
    checkout.SocketAddress = &mockserver.SocketAddress{Host: "shop.svc", Port: 8080, Scheme: "HTTP"}

    scenario := mockserver.LoadScenario{
        Name: "checkout-gated",
        Thresholds: []mockserver.LoadThreshold{
            {Metric: mockserver.LoadThresholdLatencyP99, Comparator: "LESS_THAN", Threshold: 200},
            {Metric: mockserver.LoadThresholdErrorRate, Comparator: "LESS_THAN_OR_EQUAL", Threshold: 0.01},
        },
        AbortOnFail:      true,
        AbortGraceMillis: 5000,
        Profile: &mockserver.LoadProfile{
            Stages: []mockserver.LoadStage{
                mockserver.ConstantVusStage(10, 60000),
            },
        },
        Steps: []mockserver.LoadStep{ {Request: &checkout} },
    }

    client.LoadScenario(scenario)               // register
    client.StartLoadScenarios("checkout-gated") // start (requires loadGenerationEnabled=true)
    status, _ := client.GetLoadScenario("checkout-gated")
    // status.Verdict is "PASS" while all thresholds hold, "FAIL" on a breach
    fmt.Println("verdict:", status.Verdict)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

var checkout = HttpRequest.Request().WithMethod("POST").WithPath("/checkout").Build();
checkout.SocketAddress = new SocketAddress { Host = "shop.svc", Port = 8080, Scheme = SocketScheme.HTTP };

var scenario = new LoadScenario
{
    Name = "checkout-gated",
    Thresholds = new()
    {
        new LoadThreshold { Metric = LoadThresholdMetric.LATENCY_P99,
                            Comparator = LoadThresholdComparator.LESS_THAN, Threshold = 200 },
        new LoadThreshold { Metric = LoadThresholdMetric.ERROR_RATE,
                            Comparator = LoadThresholdComparator.LESS_THAN_OR_EQUAL, Threshold = 0.01 }
    },
    AbortOnFail = true,
    AbortGraceMillis = 5000,
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(10, 60000) }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = checkout }
    }
};

await client.LoadScenarioAsync(scenario);               // register
await client.StartLoadScenariosAsync("checkout-gated"); // start (requires loadGenerationEnabled=true)
var status = await client.GetLoadScenarioAsync("checkout-gated");
// the status JSON carries a "verdict" field — "PASS" while all thresholds hold, "FAIL" on a breach

use mockserver_client::{
    ClientBuilder, HttpRequest, LoadComparator, LoadProfile, LoadScenario, LoadStage, LoadStep,
    LoadThreshold, LoadThresholdMetric, SocketAddress,
};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let profile = LoadProfile::of(vec![
    LoadStage::vu_hold(10, 60_000),
]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("POST").path("/checkout")
        .socket_address(SocketAddress::new("shop.svc", 8080))),
];
let scenario = LoadScenario::new("checkout-gated", profile, steps)
    .threshold(LoadThreshold::new(LoadThresholdMetric::LatencyP99, LoadComparator::LessThan, 200.0))
    .threshold(LoadThreshold::new(LoadThresholdMetric::ErrorRate, LoadComparator::LessThanOrEqual, 0.01))
    .abort_on_fail(true)
    .abort_grace_millis(5000);

client.load_scenario(&scenario).unwrap();                 // register
client.start_load_scenarios(&["checkout-gated"]).unwrap(); // start (requires loadGenerationEnabled=true)
let status = client.get_load_scenario("checkout-gated").unwrap();
// the status JSON carries a "verdict" field — "PASS" while all thresholds hold, "FAIL" on a breach

require_once 'vendor/autoload.php';

use MockServer\HttpRequest;
use MockServer\LoadProfile;
use MockServer\LoadScenario;
use MockServer\LoadStage;
use MockServer\LoadThreshold;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$scenario = LoadScenario::scenario('checkout-gated')
    ->addThreshold(LoadThreshold::of('LATENCY_P99', 'LESS_THAN', 200))
    ->addThreshold(LoadThreshold::of('ERROR_RATE', 'LESS_THAN_OR_EQUAL', 0.01))
    ->abortOnFail()
    ->abortGraceMillis(5000)
    ->profile(LoadProfile::of(
        LoadStage::vuHold(10, 60000),
    ))
    ->addStep(
        HttpRequest::request()->method('POST')->path('/checkout')
            ->socketAddress('shop.svc', 8080, 'HTTP'),
    );

$client->loadScenario($scenario);               // register
$client->startLoadScenarios('checkout-gated');  // start (requires loadGenerationEnabled=true)
$status = $client->getLoadScenario('checkout-gated');
// $status['verdict'] is 'PASS' while all thresholds hold, 'FAIL' on a breach

# Scenario with thresholds — will FAIL the run if p99 exceeds 200ms or error rate exceeds 1%
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "checkout-gated",
    "thresholds": [
      { "metric": "LATENCY_P99", "comparator": "LESS_THAN", "threshold": 200 },
      { "metric": "ERROR_RATE",  "comparator": "LESS_THAN_OR_EQUAL", "threshold": 0.01 }
    ],
    "abortOnFail": true,
    "abortGraceMillis": 5000,
    "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 60000 } ] },
    "steps": [
      {
        "request": { "method": "POST", "path": "/checkout",
                     "socketAddress": { "host": "shop.svc", "port": 8080, "scheme": "HTTP" } }
      }
    ]
  }'

curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -d '{ "name": "checkout-gated" }'

# Poll until terminal, then check the verdict
until [ "$(curl -s http://localhost:1080/mockserver/loadScenario/checkout-gated \
             | python3 -c "import sys,json; s=json.load(sys.stdin); print(s.get('state',''))")" \
        != "RUNNING" ]; do sleep 2; done

VERDICT=$(curl -s http://localhost:1080/mockserver/loadScenario/checkout-gated \
  | python3 -c "import sys,json; s=json.load(sys.stdin); print(s.get('verdict','PASS'))")
echo "Verdict: $VERDICT"
[ "$VERDICT" = "FAIL" ] && exit 1 || exit 0

import org.mockserver.client.MockServerClient;
import java.nio.file.Files;
import java.nio.file.Path;

MockServerClient client = new MockServerClient("localhost", 1080);

String jsonReport = client.getLoadScenarioReport("checkout-load");           // JSON summary
String junitReport = client.getLoadScenarioReport("checkout-load", "junit"); // JUnit XML
Files.writeString(Path.of("load-report.xml"), junitReport);                  // attach to CI as a test artifact

var mockServerClient = require('mockserver-client').mockServerClient;
var fs = require('fs');
var client = mockServerClient("localhost", 1080);

(async function () {
    var jsonReport = await client.getLoadScenarioReport('checkout-load');           // parsed JSON
    var junitReport = await client.getLoadScenarioReport('checkout-load', 'junit'); // JUnit XML string
    fs.writeFileSync('load-report.xml', junitReport);                               // attach to CI
})();

from mockserver import MockServerClient

with MockServerClient("localhost", 1080) as client:
    json_report = client.get_load_scenario_report("checkout-load")                  # dict
    junit_report = client.get_load_scenario_report("checkout-load", format="junit") # JUnit XML string
    with open("load-report.xml", "w") as f:                                          # attach to CI
        f.write(junit_report)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

json_report = client.get_load_scenario_report('checkout-load')            # Hash
junit_report = client.get_load_scenario_report('checkout-load', 'junit')  # JUnit XML string
File.write('load-report.xml', junit_report)                               # attach to CI
client.close

package main

import (
    "os"

    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    jsonReport, _ := client.GetLoadScenarioReport("checkout-load", "")       // JSON summary
    junitReport, _ := client.GetLoadScenarioReport("checkout-load", "junit") // JUnit XML
    _ = jsonReport
    os.WriteFile("load-report.xml", []byte(junitReport), 0o644)              // attach to CI
}

using MockServer.Client;

using var client = new MockServerClient("localhost", 1080);

var jsonReport = client.GetLoadScenarioReport("checkout-load");           // JSON summary
var junitReport = client.GetLoadScenarioReport("checkout-load", "junit"); // JUnit XML
File.WriteAllText("load-report.xml", junitReport);                        // attach to CI

use mockserver_client::ClientBuilder;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

let json_report = client.get_load_scenario_report("checkout-load", None).unwrap();           // JSON summary
let junit_report = client.get_load_scenario_report("checkout-load", Some("junit")).unwrap(); // JUnit XML
std::fs::write("load-report.xml", junit_report).unwrap();                                     // attach to CI

require_once 'vendor/autoload.php';

use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$jsonReport = $client->getLoadScenarioReport('checkout-load');            // array
$junitReport = $client->getLoadScenarioReport('checkout-load', 'junit');  // JUnit XML string
file_put_contents('load-report.xml', $junitReport);                       // attach to CI

# JSON report
curl http://localhost:1080/mockserver/loadScenario/checkout-load/report

# JUnit XML — attach to CI as a test artifact
curl 'http://localhost:1080/mockserver/loadScenario/checkout-load/report?format=junit' \
  -o load-report.xml

import org.mockserver.client.MockServerClient;

MockServerClient client = new MockServerClient("localhost", 1080);

// generateLoadScenarioFromOpenAPI takes a raw JSON request document.
String request = """
    {
      "name": "petstore-load",
      "specUrlOrPayload": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml",
      "target": { "host": "petstore.svc", "port": 8080, "scheme": "http" },
      "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 60000 } ] }
    }""";

client.generateLoadScenarioFromOpenAPI(request);   // generate + register (LOADED), no traffic
client.startLoadScenarios("petstore-load");        // start (requires loadGenerationEnabled=true)

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

(async function () {
    await client.generateLoadScenarioFromOpenAPI({
        name: 'petstore-load',
        specUrlOrPayload: 'https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml',
        target: { host: 'petstore.svc', port: 8080, scheme: 'http' },
        profile: { stages: [ { type: 'VU', vus: 10, durationMillis: 60000 } ] }
    });                                               // generate + register (LOADED), no traffic
    await client.startLoadScenarios('petstore-load'); // start (requires loadGenerationEnabled=true)
})();

from mockserver import LoadProfile, LoadStage, MockServerClient

with MockServerClient("localhost", 1080) as client:
    client.generate_load_scenario_from_openapi(
        "petstore-load",
        "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml",
        target={"host": "petstore.svc", "port": 8080, "scheme": "http"},
        profile=LoadProfile(stages=[LoadStage.vu_stage(60000, vus=10)]),
    )                                             # generate + register (LOADED), no traffic
    client.start_load_scenarios("petstore-load")  # start (requires loadGenerationEnabled=true)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

client.generate_load_scenario_from_openapi(
  'petstore-load',
  'https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml',
  target: { 'host' => 'petstore.svc', 'port' => 8080, 'scheme' => 'http' },
  profile: LoadProfile.new(stages: [LoadStage.vu(60_000, vus: 10)])
)                                            # generate + register (LOADED), no traffic
client.start_load_scenarios('petstore-load') # start (requires loadGenerationEnabled=true)
client.close

package main

import (
    mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"
)

func main() {
    client := mockserver.New("localhost", 1080)

    // GenerateLoadScenarioFromOpenAPI takes a raw request document.
    client.GenerateLoadScenarioFromOpenAPI(map[string]any{
        "name":             "petstore-load",
        "specUrlOrPayload": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml",
        "target":           map[string]any{"host": "petstore.svc", "port": 8080, "scheme": "http"},
        "profile": map[string]any{
            "stages": []map[string]any{
                {"type": "VU", "vus": 10, "durationMillis": 60000},
            },
        },
    }) // generate + register (LOADED), no traffic
    client.StartLoadScenarios("petstore-load") // start (requires loadGenerationEnabled=true)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

await client.GenerateLoadScenarioFromOpenAPIAsync(
    "petstore-load",
    "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml",
    new LoadGenerateTarget { Host = "petstore.svc", Port = 8080, Scheme = LoadTargetScheme.http },
    new LoadProfile { Stages = new List<LoadStage> { LoadStage.ConstantVus(10, 60000) } }); // generate + register (LOADED)
await client.StartLoadScenariosAsync("petstore-load");                  // start (requires loadGenerationEnabled=true)

use mockserver_client::ClientBuilder;
use serde_json::json;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

// generate_load_scenario_from_openapi takes a raw request document.
client.generate_load_scenario_from_openapi(&json!({
    "name": "petstore-load",
    "specUrlOrPayload": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml",
    "target": { "host": "petstore.svc", "port": 8080, "scheme": "http" },
    "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 60000 } ] }
})).unwrap();                                              // generate + register (LOADED), no traffic
client.start_load_scenarios(&["petstore-load"]).unwrap(); // start (requires loadGenerationEnabled=true)

require_once 'vendor/autoload.php';

use MockServer\LoadProfile;
use MockServer\LoadStage;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$client->generateLoadScenarioFromOpenAPI(
    'petstore-load',
    'https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml',
    ['host' => 'petstore.svc', 'port' => 8080, 'scheme' => 'http'],
    LoadProfile::of(LoadStage::vuHold(10, 60000)),
);                                            // generate + register (LOADED), no traffic
$client->startLoadScenarios('petstore-load'); // start (requires loadGenerationEnabled=true)

# Generate a load scenario from a public OpenAPI spec
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/generateFromOpenAPI \
  -H "Content-Type: application/json" \
  -d '{
    "name": "petstore-load",
    "specUrlOrPayload": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml",
    "target": { "host": "petstore.svc", "port": 8080, "scheme": "http" },
    "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 60000 } ] }
  }'

# Then trigger it (requires loadGenerationEnabled=true)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -d '{ "name": "petstore-load" }'

import org.mockserver.client.MockServerClient;

MockServerClient client = new MockServerClient("localhost", 1080);

// generateLoadScenarioFromRecording takes a raw JSON request document.
String request = """
    {
      "name": "replay-prod-traffic",
      "mode": "TEMPLATIZED",
      "requestFilter": { "path": "/api/.*" },
      "maxSteps": 50,
      "target": { "host": "staging.svc", "port": 8080, "scheme": "http" }
    }""";

client.generateLoadScenarioFromRecording(request);  // generate + register (LOADED), no traffic
client.startLoadScenarios("replay-prod-traffic");   // start (requires loadGenerationEnabled=true)

var mockServerClient = require('mockserver-client').mockServerClient;
var client = mockServerClient("localhost", 1080);

(async function () {
    await client.generateLoadScenarioFromRecording({
        name: 'replay-prod-traffic',
        mode: 'TEMPLATIZED',
        requestFilter: { path: '/api/.*' },
        maxSteps: 50,
        target: { host: 'staging.svc', port: 8080, scheme: 'http' }
    });                                                    // generate + register (LOADED), no traffic
    await client.startLoadScenarios('replay-prod-traffic'); // start (requires loadGenerationEnabled=true)
})();

from mockserver import HttpRequest, MockServerClient

with MockServerClient("localhost", 1080) as client:
    client.generate_load_scenario_from_recording(
        "replay-prod-traffic",
        mode="TEMPLATIZED",
        request_filter=HttpRequest(path="/api/.*"),
        max_steps=50,
        target={"host": "staging.svc", "port": 8080, "scheme": "http"},
    )                                                  # generate + register (LOADED), no traffic
    client.start_load_scenarios("replay-prod-traffic")  # start (requires loadGenerationEnabled=true)

require 'mockserver-client'
include MockServer

client = Client.new('localhost', 1080)

client.generate_load_scenario_from_recording(
  'replay-prod-traffic',
  mode: 'TEMPLATIZED',
  request_filter: HttpRequest.new(path: '/api/.*'),
  max_steps: 50,
  target: { 'host' => 'staging.svc', 'port' => 8080, 'scheme' => 'http' }
)                                                  # generate + register (LOADED), no traffic
client.start_load_scenarios('replay-prod-traffic') # start (requires loadGenerationEnabled=true)
client.close

client := mockserver.New("localhost", 1080)

// GenerateLoadScenarioFromRecording takes a raw request document.
client.GenerateLoadScenarioFromRecording(map[string]any{
    "name":          "replay-prod-traffic",
    "mode":          "TEMPLATIZED",
    "requestFilter": map[string]any{"path": "/api/.*"},
    "maxSteps":      50,
    "target":        map[string]any{"host": "staging.svc", "port": 8080, "scheme": "http"},
}) // generate + register (LOADED), no traffic
client.StartLoadScenarios("replay-prod-traffic") // start (requires loadGenerationEnabled=true)

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);

// Parameter order is (name, mode, requestFilter, target, maxSteps).
await client.GenerateLoadScenarioFromRecordingAsync(
    "replay-prod-traffic",
    LoadRecordingMode.TEMPLATIZED,
    HttpRequest.Request().WithPath("/api/.*"),
    new LoadGenerateTarget { Host = "staging.svc", Port = 8080, Scheme = LoadTargetScheme.http },
    maxSteps: 50);                                           // generate + register (LOADED), no traffic
await client.StartLoadScenariosAsync("replay-prod-traffic"); // start (requires loadGenerationEnabled=true)

use mockserver_client::ClientBuilder;
use serde_json::json;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();

// generate_load_scenario_from_recording takes a raw request document.
client.generate_load_scenario_from_recording(&json!({
    "name": "replay-prod-traffic",
    "mode": "TEMPLATIZED",
    "requestFilter": { "path": "/api/.*" },
    "maxSteps": 50,
    "target": { "host": "staging.svc", "port": 8080, "scheme": "http" }
})).unwrap();                                                   // generate + register (LOADED), no traffic
client.start_load_scenarios(&["replay-prod-traffic"]).unwrap(); // start (requires loadGenerationEnabled=true)

use MockServer\HttpRequest;
use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);

$client->generateLoadScenarioFromRecording(
    'replay-prod-traffic',
    mode: 'TEMPLATIZED',
    requestFilter: HttpRequest::request()->path('/api/.*'),
    target: ['host' => 'staging.svc', 'port' => 8080, 'scheme' => 'http'],
    maxSteps: 50,
);                                                  // generate + register (LOADED), no traffic
$client->startLoadScenarios('replay-prod-traffic'); // start (requires loadGenerationEnabled=true)

# First, record real traffic through the MockServer proxy...
# (see Proxy Configuration for setup)

# Then generate a load scenario from the recorded traffic
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/generateFromRecording \
  -H "Content-Type: application/json" \
  -d '{
    "name": "replay-prod-traffic",
    "mode": "TEMPLATIZED",
    "requestFilter": { "path": "/api/.*" },
    "maxSteps": 50,
    "target": { "host": "staging.svc", "port": 8080, "scheme": "http" }
  }'

# Then trigger it
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -d '{ "name": "replay-prod-traffic" }'

import org.mockserver.model.SocketAddress;
import org.mockserver.slo.SloCriteria;
import org.mockserver.slo.SloObjective;
import org.mockserver.slo.SloWindow;
import java.util.Set;

LoadScenario scenario = LoadScenario.loadScenario("slo-validation-run")
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(10, 30000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/health")
            .withSocketAddress("target.svc", 8080, SocketAddress.Scheme.HTTP))
    );

client.runLoadScenario(scenario);   // register + start (requires loadGenerationEnabled=true)

// ... let the run COMPLETE before asserting (poll getLoadScenario until state COMPLETED) ...

// assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
client.verifySLO(SloCriteria.sloCriteria()
    .withName("checkout-slo")
    .withWindow(SloWindow.lookback(60000))
    .withMinimumSampleCount(50)
    .withUpstreamHosts(Set.of("target.svc"))
    .withObjectives(
        SloObjective.sloObjective()
            .withSli(SloObjective.Sli.LATENCY_P95)
            .withComparator(SloObjective.Comparator.LESS_THAN)
            .withThreshold(200.0),
        SloObjective.sloObjective()
            .withSli(SloObjective.Sli.ERROR_RATE)
            .withComparator(SloObjective.Comparator.LESS_THAN_OR_EQUAL)
            .withThreshold(0.01)
    ));

var scenario = {
    name: 'slo-validation-run',
    profile: { stages: [ { type: 'VU', vus: 10, durationMillis: 30000 } ] },
    steps: [
        { request: { method: 'GET', path: '/api/health',
                     socketAddress: { host: 'target.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

(async function () {
    await client.runLoadScenario(scenario);   // register + start (requires loadGenerationEnabled=true)

    // ... let the run COMPLETE before asserting (poll getLoadScenario until state COMPLETED) ...

    // assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
    await client.verifySLO({
        name: 'checkout-slo',
        window: { type: 'LOOKBACK', lookbackMillis: 60000 },
        minimumSampleCount: 50,
        upstreamHosts: ['target.svc'],
        objectives: [
            { sli: 'LATENCY_P95', comparator: 'LESS_THAN', threshold: 200.0 },
            { sli: 'ERROR_RATE', comparator: 'LESS_THAN_OR_EQUAL', threshold: 0.01 }
        ]
    });
})();

scenario = LoadScenario(
    name="slo-validation-run",
    profile=LoadProfile(stages=[LoadStage.vu_stage(30000, vus=10)]),
    steps=[
        LoadStep(request=HttpRequest(method="GET", path="/api/health",
                                     socket_address=SocketAddress(host="target.svc", port=8080, scheme="HTTP"))),
    ],
)

client.run_load_scenario(scenario)   # register + start (requires loadGenerationEnabled=true)

# ... let the run COMPLETE before asserting (poll get_load_scenario until state COMPLETED) ...

# assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
client.verify_slo({
    "name": "checkout-slo",
    "window": {"type": "LOOKBACK", "lookbackMillis": 60000},
    "minimumSampleCount": 50,
    "upstreamHosts": ["target.svc"],
    "objectives": [
        {"sli": "LATENCY_P95", "comparator": "LESS_THAN", "threshold": 200.0},
        {"sli": "ERROR_RATE", "comparator": "LESS_THAN_OR_EQUAL", "threshold": 0.01},
    ],
})

scenario = LoadScenario.new(
  name: 'slo-validation-run',
  profile: LoadProfile.new(stages: [LoadStage.vu(30_000, vus: 10)]),
  steps: [
    LoadStep.new(request: HttpRequest.new(method: 'GET', path: '/api/health',
                                          socket_address: SocketAddress.new(host: 'target.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.run_load_scenario(scenario)   # register + start (requires loadGenerationEnabled=true)

# ... let the run COMPLETE before asserting (poll get_load_scenario until state COMPLETED) ...

# assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
client.verify_slo({
  'name' => 'checkout-slo',
  'window' => { 'type' => 'LOOKBACK', 'lookbackMillis' => 60_000 },
  'minimumSampleCount' => 50,
  'upstreamHosts' => ['target.svc'],
  'objectives' => [
    { 'sli' => 'LATENCY_P95', 'comparator' => 'LESS_THAN', 'threshold' => 200.0 },
    { 'sli' => 'ERROR_RATE', 'comparator' => 'LESS_THAN_OR_EQUAL', 'threshold' => 0.01 }
  ]
})

health := mockserver.Request().Method("GET").Path("/api/health").Build()
health.SocketAddress = &mockserver.SocketAddress{Host: "target.svc", Port: 8080, Scheme: "HTTP"}

scenario := mockserver.LoadScenario{
    Name: "slo-validation-run",
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.ConstantVusStage(10, 30000),
        },
    },
    Steps: []mockserver.LoadStep{ {Request: &health} },
}

client.RunLoadScenario(scenario)   // register + start (requires loadGenerationEnabled=true)

// ... let the run COMPLETE before asserting (poll GetLoadScenario until state COMPLETED) ...

// assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
client.VerifySLO(mockserver.SloCriteria{
    Name:               "checkout-slo",
    Window:             &mockserver.SloWindow{Type: "LOOKBACK", LookbackMillis: 60000},
    MinimumSampleCount: 50,
    UpstreamHosts:      []string{"target.svc"},
    Objectives: []mockserver.SloObjective{
        {Sli: "LATENCY_P95", Comparator: "LESS_THAN", Threshold: 200.0},
        {Sli: "ERROR_RATE", Comparator: "LESS_THAN_OR_EQUAL", Threshold: 0.01},
    },
})

var scenario = new LoadScenario
{
    Name = "slo-validation-run",
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(10, 30000) }
    },
    Steps = new List<LoadStep>
    {
        new() { Request = HttpRequest.Request().WithMethod("GET").WithPath("/api/health").Build() }
    }
};
scenario.Steps[0].Request.SocketAddress =
    new SocketAddress { Host = "target.svc", Port = 8080, Scheme = SocketScheme.HTTP };

await client.RunLoadScenarioAsync(scenario);   // register + start (requires loadGenerationEnabled=true)

// ... let the run COMPLETE before asserting (poll GetLoadScenarioAsync until state COMPLETED) ...

// assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
client.VerifySlo(new SloCriteria
{
    Name = "checkout-slo",
    Window = SloWindow.Lookback(60000),
    MinimumSampleCount = 50,
    UpstreamHosts = new List<string> { "target.svc" },
    Objectives = new List<SloObjective>
    {
        new() { Sli = Sli.LATENCY_P95, Comparator = SloComparator.LESS_THAN, Threshold = 200.0 },
        new() { Sli = Sli.ERROR_RATE, Comparator = SloComparator.LESS_THAN_OR_EQUAL, Threshold = 0.01 }
    }
});

use mockserver_client::{SloCriteria, SloObjective, SloWindow, SocketAddress};

let profile = LoadProfile::of(vec![LoadStage::vu_hold(10, 30_000)]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/api/health")
        .socket_address(SocketAddress::new("target.svc", 8080))),
];
let scenario = LoadScenario::new("slo-validation-run", profile, steps);

client.run_load_scenario(&scenario).unwrap();   // register + start (requires loadGenerationEnabled=true)

// ... let the run COMPLETE before asserting (poll get_load_scenario until state COMPLETED) ...

// assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
let criteria = SloCriteria::new(vec![
    SloObjective::new("LATENCY_P95", "LESS_THAN", 200.0),
    SloObjective::new("ERROR_RATE", "LESS_THAN_OR_EQUAL", 0.01),
])
    .name("checkout-slo")
    .window(SloWindow::lookback(60_000))
    .minimum_sample_count(50)
    .upstream_hosts(vec!["target.svc".to_string()]);
client.verify_slo(&criteria).unwrap();

$scenario = LoadScenario::scenario('slo-validation-run')
    ->profile(LoadProfile::of(
        LoadStage::vuHold(10, 30000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/api/health')
            ->socketAddress('target.svc', 8080, 'HTTP'),
    );

$client->runLoadScenario($scenario);   // register + start (requires loadGenerationEnabled=true)

// ... let the run COMPLETE before asserting (poll getLoadScenario until state COMPLETED) ...

// assert latency + error-rate SLOs held over the run (requires sloTrackingEnabled=true)
$client->verifySlo([
    'name' => 'checkout-slo',
    'window' => ['type' => 'LOOKBACK', 'lookbackMillis' => 60000],
    'minimumSampleCount' => 50,
    'upstreamHosts' => ['target.svc'],
    'objectives' => [
        ['sli' => 'LATENCY_P95', 'comparator' => 'LESS_THAN', 'threshold' => 200.0],
        ['sli' => 'ERROR_RATE', 'comparator' => 'LESS_THAN_OR_EQUAL', 'threshold' => 0.01],
    ],
]);

# Enable both features at startup:
#   docker run \
#     -e MOCKSERVER_LOAD_GENERATION_ENABLED=true \
#     -e MOCKSERVER_SLO_TRACKING_ENABLED=true \
#     mockserver/mockserver

# 1. Register, then start a load run (e.g. 10 VUs for 30 s)
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "slo-validation-run",
    "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 30000 } ] },
    "steps": [
      {
        "request": {
          "method": "GET",
          "path": "/api/health",
          "socketAddress": { "host": "target.svc", "port": 8080, "scheme": "HTTP" }
        }
      }
    ]
  }'
curl -s -X PUT http://localhost:1080/mockserver/loadScenario/start \
  -d '{ "name": "slo-validation-run" }'

# 2. Wait for the scenario to complete (poll GET /loadScenario/slo-validation-run until state = "COMPLETED")

# 3. Assert SLOs held during the run — returns 200 (PASS) or 406 (FAIL)
curl -s -w "\n%{http_code}" -X PUT http://localhost:1080/mockserver/verifySLO \
  -H "Content-Type: application/json" \
  -d '{
    "name": "checkout-slo",
    "window": { "type": "LOOKBACK", "lookbackMillis": 60000 },
    "minimumSampleCount": 50,
    "upstreamHosts": ["target.svc"],
    "objectives": [
      { "sli": "LATENCY_P95", "comparator": "LESS_THAN", "threshold": 200.0 },
      { "sli": "ERROR_RATE",  "comparator": "LESS_THAN_OR_EQUAL", "threshold": 0.01 }
    ]
  }'

import org.mockserver.model.SocketAddress;
import java.util.Map;

LoadScenario scenario = LoadScenario.loadScenario("checkout-load")
    .withLabels(Map.of("env", "staging", "region", "eu-west-1"))
    .withProfile(LoadProfile.of(
        LoadStage.constantVus(10, 30000)
    ))
    .withSteps(
        LoadStep.loadStep(request().withMethod("GET").withPath("/api/orders/$iteration.index")
                .withSocketAddress("orders.svc", 8080, SocketAddress.Scheme.HTTP))
            .withName("get-order")
            .withLabels(Map.of("team", "orders"))
    );

client.loadScenario(scenario);   // register (Prometheus needs the label keys allow-listed at startup)

var scenario = {
    name: 'checkout-load',
    labels: { env: 'staging', region: 'eu-west-1' },
    profile: { stages: [ { type: 'VU', vus: 10, durationMillis: 30000 } ] },
    steps: [
        { name: 'get-order', labels: { team: 'orders' },
          request: { method: 'GET', path: '/api/orders/$iteration.index',
                     socketAddress: { host: 'orders.svc', port: 8080, scheme: 'HTTP' } } }
    ]
};

await client.loadScenario(scenario);   // register (Prometheus needs the label keys allow-listed at startup)

scenario = LoadScenario(
    name="checkout-load",
    labels={"env": "staging", "region": "eu-west-1"},
    profile=LoadProfile(stages=[LoadStage.vu_stage(30000, vus=10)]),
    steps=[
        LoadStep(name="get-order", labels={"team": "orders"},
                 request=HttpRequest(method="GET", path="/api/orders/$iteration.index",
                                     socket_address=SocketAddress(host="orders.svc", port=8080, scheme="HTTP"))),
    ],
)

client.load_scenario(scenario)   # register (Prometheus needs the label keys allow-listed at startup)

scenario = LoadScenario.new(
  name: 'checkout-load',
  labels: { 'env' => 'staging', 'region' => 'eu-west-1' },
  profile: LoadProfile.new(stages: [LoadStage.vu(30_000, vus: 10)]),
  steps: [
    LoadStep.new(name: 'get-order', labels: { 'team' => 'orders' },
                 request: HttpRequest.new(method: 'GET', path: '/api/orders/$iteration.index',
                                          socket_address: SocketAddress.new(host: 'orders.svc', port: 8080, scheme: 'HTTP')))
  ]
)

client.load_scenario(scenario)   # register (Prometheus needs the label keys allow-listed at startup)

order := mockserver.Request().Method("GET").Path("/api/orders/$iteration.index").Build()
order.SocketAddress = &mockserver.SocketAddress{Host: "orders.svc", Port: 8080, Scheme: "HTTP"}

scenario := mockserver.LoadScenario{
    Name:   "checkout-load",
    Labels: map[string]string{"env": "staging", "region": "eu-west-1"},
    Profile: &mockserver.LoadProfile{
        Stages: []mockserver.LoadStage{
            mockserver.ConstantVusStage(10, 30000),
        },
    },
    Steps: []mockserver.LoadStep{
        {Name: "get-order", Request: &order, Labels: map[string]string{"team": "orders"}},
    },
}

client.LoadScenario(scenario)   // register (Prometheus needs the label keys allow-listed at startup)

var scenario = new LoadScenario
{
    Name = "checkout-load",
    Labels = new Dictionary<string, string> { ["env"] = "staging", ["region"] = "eu-west-1" },
    Profile = new LoadProfile
    {
        Stages = new List<LoadStage> { LoadStage.ConstantVus(10, 30000) }
    },
    Steps = new List<LoadStep>
    {
        new()
        {
            Name = "get-order",
            Request = HttpRequest.Request().WithMethod("GET").WithPath("/api/orders/$iteration.index").Build(),
            Labels = new Dictionary<string, string> { ["team"] = "orders" }
        }
    }
};
scenario.Steps[0].Request.SocketAddress =
    new SocketAddress { Host = "orders.svc", Port = 8080, Scheme = SocketScheme.HTTP };

await client.LoadScenarioAsync(scenario);   // register (Prometheus needs the label keys allow-listed at startup)

use mockserver_client::SocketAddress;

// Rust client: custom labels / step names are not exposed
let profile = LoadProfile::of(vec![LoadStage::vu_hold(10, 30_000)]);
let steps = vec![
    LoadStep::new(HttpRequest::new().method("GET").path("/api/orders/$iteration.index")
        .socket_address(SocketAddress::new("orders.svc", 8080))),
];
let scenario = LoadScenario::new("checkout-load", profile, steps);

client.load_scenario(&scenario).unwrap();   // register

$scenario = LoadScenario::scenario('checkout-load')
    ->labels(['env' => 'staging', 'region' => 'eu-west-1'])
    ->profile(LoadProfile::of(
        LoadStage::vuHold(10, 30000),
    ))
    ->addStep(
        HttpRequest::request()->method('GET')->path('/api/orders/$iteration.index')
            ->socketAddress('orders.svc', 8080, 'HTTP'),
        name: 'get-order',
        labels: ['team' => 'orders'],
    );

$client->loadScenario($scenario);   // register (Prometheus needs the label keys allow-listed at startup)

# Enable load generation with a custom label allowlist (Prometheus requires this at startup):
#   docker run \
#     -e MOCKSERVER_LOAD_GENERATION_ENABLED=true \
#     -e MOCKSERVER_LOAD_GENERATION_METRIC_LABELS=env,region \
#     mockserver/mockserver

# Register a scenario with scenario-level and step-level custom labels
curl -s -X PUT http://localhost:1080/mockserver/loadScenario \
  -H "Content-Type: application/json" \
  -d '{
    "name": "checkout-load",
    "labels": { "env": "staging", "region": "eu-west-1" },
    "profile": { "stages": [ { "type": "VU", "vus": 10, "durationMillis": 30000 } ] },
    "steps": [
      {
        "name": "get-order",
        "labels": { "team": "orders" },
        "request": { "method": "GET", "path": "/api/orders/$iteration.index",
                     "socketAddress": { "host": "orders.svc", "port": 8080, "scheme": "HTTP" } }
      }
    ]
  }'