vantus 0.3.0

Macro-first async Rust backend framework with explicit composition, typed extraction, and hardened HTTP defaults.
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

#![cfg(feature = "cli")]

use clap::Parser;
use vantus::{CliError, CliFeatureDefaults, IdGeneratorKind, RuntimeMode, ServerCli};

#[test]
fn cli_parses_runtime_mode_and_feature_toggles() {
    let cli = ServerCli::parse_from([
        "vantus-demo",
        "--mode",
        "production",
        "--web-platform",
        "--no-observability",
        "--id-generator",
        "atomic",
    ]);

    assert_eq!(cli.effective_mode(), RuntimeMode::Production);
    assert!(cli.web_platform_enabled(false));
    assert!(!cli.observability_enabled(true));
    assert_eq!(cli.id_generator_kind(), IdGeneratorKind::Atomic);
}

#[test]
fn cli_requires_complete_rate_limit_configuration() {
    let cli = ServerCli::parse_from(["vantus-demo", "--rate-limit-capacity", "100"]);
    let error = cli
        .startup_plan(CliFeatureDefaults::default())
        .expect_err("rate limiting should require all fields");

    assert_eq!(error, CliError::IncompleteRateLimit);
}

#[test]
fn cli_renders_human_readable_startup_plan() {
    let cli = ServerCli::parse_from([
        "vantus-demo",
        "--mode",
        "development",
        "--observability",
        "--request-timeout-ms",
        "2500",
        "--dry-run",
    ]);
    let plan = cli
        .startup_plan(CliFeatureDefaults {
            web_platform: true,
            observability: false,
        })
        .expect("plan should render");

    assert!(plan.contains("mode=development"), "{plan}");
    assert!(plan.contains("environment=development (mode)"), "{plan}");
    assert!(plan.contains("web_platform=true (default)"), "{plan}");
    assert!(plan.contains("observability=true (cli)"), "{plan}");
    assert!(plan.contains("request_timeout_ms=2500 (cli)"), "{plan}");
    assert!(plan.contains("dry_run=true"), "{plan}");
}

#[test]
fn cli_marks_config_backed_runtime_values_as_pending() {
    let cli = ServerCli::parse_from(["vantus-demo"]);
    let plan = cli
        .startup_plan(CliFeatureDefaults::default())
        .expect("plan should render");

    assert!(
        plan.contains("environment=development (env/default)"),
        "{plan}"
    );
    assert!(plan.contains("env_prefix=APP (default)"), "{plan}");
    assert!(
        plan.contains("max_body_bytes=<config/default: 65536> (pending)"),
        "{plan}"
    );
    assert!(
        plan.contains("request_timeout_ms=<config/default: 5000> (pending)"),
        "{plan}"
    );
}

#[test]
fn cli_rejects_zero_rate_limit_capacity() {
    let cli = ServerCli::parse_from([
        "vantus-demo",
        "--rate-limit-capacity",
        "0",
        "--rate-limit-refill-tokens",
        "10",
        "--rate-limit-refill-seconds",
        "60",
    ]);
    let error = cli
        .startup_plan(CliFeatureDefaults::default())
        .expect_err("zero capacity should be rejected");

    assert_eq!(error, CliError::InvalidRateLimitCapacity);
}

#[test]
fn cli_rejects_zero_rate_limit_refill_tokens() {
    let cli = ServerCli::parse_from([
        "vantus-demo",
        "--rate-limit-capacity",
        "10",
        "--rate-limit-refill-tokens",
        "0",
        "--rate-limit-refill-seconds",
        "60",
    ]);
    let error = cli
        .startup_plan(CliFeatureDefaults::default())
        .expect_err("zero refill tokens should be rejected");

    assert_eq!(error, CliError::InvalidRateLimitRefillTokens);
}