Load test any system
with a distributed cluster

var httpClient = new HttpClient();

var scenario = Scenario.Create("http_scenario", async context =>
{
    var request =
        Http.CreateRequest("GET", "https://nbomber.com")
            .WithHeader("Accept", "text/html")
            .WithBody(new StringContent("{ some JSON }"));
            
    var response = await Http.Send(httpClient, request);
    return response;
})
.WithLoadSimulations(
    Simulation.Inject(rate: 100,
                      interval: TimeSpan.FromSeconds(1),
                      during: TimeSpan.FromMinutes(3))
);

NBomberRunner
    .RegisterScenarios(scenario)
    .Run();

var scenario = Scenario.Create("mqtt_scenario", async ctx =>
{
    using var client = new MqttClient(new MqttFactory().CreateMqttClient());
    var topic = "/clients/" + ctx.ScenarioInfo.InstanceId;
    
    var connect = await Step.Run("connect", ctx, async () =>
    {
        var clientOptions = new MqttClientOptionsBuilder()
            .WithTcpServer("localhost")
            .WithClientId(ctx.ScenarioInfo.InstanceId)
            .Build();
    
        var response = await client.Connect(clientOptions);
        return response;
    });

    var subscribe = await Step.Run("subscribe", ctx, () => client.Subscribe(topic));

    var publish = await Step.Run("publish", ctx, async () =>
    {
        var msg = new MqttApplicationMessageBuilder()
            .WithTopic(topic)
            .WithPayload(payload)
            .Build();
        
        var response = await client.Publish(msg);
        return response;
    });

    var receive = await Step.Run("receive", ctx, async () =>
    {
        var response = await client.Receive();
        return response;
    });

    var disconnect = await Step.Run("disconnect", ctx, () => client.Disconnect());
    return Response.Ok();
});

var scenario = Scenario.Create("ping_pong_websockets", async ctx =>
{
    using var websocket = new WebSocket(new WebSocketConfig());

    var connect = await Step.Run("connect", ctx, async () =>
    {
        await websocket.Connect("ws://localhost:5233/ws");
        return Response.Ok();
    });

    var ping = await Step.Run("ping", ctx, async () =>
    {
        await websocket.Send(payload);
        return Response.Ok(sizeBytes: payload.Length);
    });
    
    var pong = await Step.Run("pong", ctx, async () =>
    {
        using var response = await websocket.Receive();
        return Response.Ok(sizeBytes: response.Data.Length);
    });
    
    var disconnect = await Step.Run("disconnect", ctx, async () =>
    {
        await websocket.Close();
        return Response.Ok();
    });
    return Response.Ok();
});

var redis = ConnectionMultiplexer.Connect("redis0:6380");
var db = redis.GetDatabase();
var random = new Random();

var scenario = Scenario.Create("redis_scenario", async context =>
{
    var userId = random.Next(1_000);
    byte[] data = await db.StringGetAsync($"user-{userId}");
    return Response.Ok(statusCode: "ok", sizeBytes: data.Length);
})
.WithLoadSimulations(
    Simulation.Inject(rate: 100,
                      interval: TimeSpan.FromSeconds(1),
                      during: TimeSpan.FromMinutes(3))
);
NBomberRunner
      .RegisterScenarios(scenario)
      .Run();