strest 0.1.10

Blazing-fast async HTTP load tester in Rust - lock-free design, real-time stats, distributed runs, and optional chart exports for high-load API testing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::*;
use crate::domain::run::{LoadMode, ProtocolKind};

#[derive(Clone)]
struct FakeAdapter;

impl ProtocolAdapter for FakeAdapter {
    fn protocol(&self) -> ProtocolKind {
        ProtocolKind::Http
    }

    fn display_name(&self) -> &'static str {
        "fake-http"
    }

    fn executes_traffic(&self) -> bool {
        true
    }

    fn supports_stateful_connections(&self) -> bool {
        true
    }

    fn supported_load_modes(&self) -> &'static [LoadMode] {
        &[
            LoadMode::Arrival,
            LoadMode::Step,
            LoadMode::Ramp,
            LoadMode::Jitter,
            LoadMode::Burst,
            LoadMode::Soak,
        ]
    }
}

impl TransportAdapter for FakeAdapter {}

#[test]
fn builtins_register_http_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Http).is_some());
    assert!(registry.supports_execution(ProtocolKind::Http));
    assert!(registry.supports_load_mode(ProtocolKind::Http, LoadMode::Soak));
}

#[test]
fn builtins_mark_websocket_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Websocket).is_some());
    assert!(registry.supports_execution(ProtocolKind::Websocket));
}

#[test]
fn builtins_mark_grpc_unary_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::GrpcUnary).is_some());
    assert!(registry.supports_execution(ProtocolKind::GrpcUnary));
}

#[test]
fn builtins_mark_grpc_streaming_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::GrpcStreaming).is_some());
    assert!(registry.supports_execution(ProtocolKind::GrpcStreaming));
}

#[test]
fn builtins_mark_quic_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Quic).is_some());
    assert!(registry.supports_execution(ProtocolKind::Quic));
}

#[test]
fn builtins_mark_mqtt_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Mqtt).is_some());
    assert!(registry.supports_execution(ProtocolKind::Mqtt));
}

#[test]
fn builtins_mark_enet_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Enet).is_some());
    assert!(registry.supports_execution(ProtocolKind::Enet));
}

#[test]
fn builtins_mark_kcp_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Kcp).is_some());
    assert!(registry.supports_execution(ProtocolKind::Kcp));
}

#[test]
fn builtins_mark_raknet_as_executable() {
    let registry = ProtocolRegistry::with_builtins();
    assert!(registry.adapter(ProtocolKind::Raknet).is_some());
    assert!(registry.supports_execution(ProtocolKind::Raknet));
}

#[test]
fn duplicate_registration_is_rejected() {
    let mut registry = ProtocolRegistry::with_builtins();
    let second = registry.register_adapter(FakeAdapter);
    assert!(second.is_err());
}

#[test]
fn example_adapters_are_registerable() {
    let mut registry = ProtocolRegistry::with_builtins();
    let game = examples::GameUdpPlugin;
    let chat = examples::ChatWebSocketPlugin;
    let mqtt = examples::TelemetryMqttPlugin;

    assert!(registry.register_adapter(game).is_err());
    assert!(registry.register_adapter(chat).is_err());
    assert!(registry.register_adapter(mqtt).is_err());
}