confers 0.4.1

Production-ready Rust configuration library with zero boilerplate
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Integration tests for Consul remote configuration source.
//!
//! These tests require a running Consul instance. Use Docker Compose to start:
//! ```bash
//! docker-compose -f docker-compose.test.yml up -d consul
//! ```
//!
//! Run tests with: `cargo test --features consul --test integration_consul`

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

mod common;

use std::time::Duration;

use confers::remote::{ConsulSourceBuilder, PolledSource};

/// Test that Consul source can connect and fetch configuration.
#[tokio::test]
async fn test_consul_source_connect() {
    // Skip if Consul is not available
    if !common::is_service_available(
        "http://127.0.0.1:8500/v1/status/leader",
        Duration::from_secs(2),
    )
    .await
    {
        eprintln!("Skipping test: Consul not available");
        return;
    }

    let source = ConsulSourceBuilder::new()
        .address("127.0.0.1:8500")
        .prefix("test-config")
        .interval(Duration::from_secs(10))
        .build()
        .expect("Failed to build Consul source");

    // Try to poll - should return empty or error if no config exists
    let result = source.poll().await;

    // Should not panic - either returns config or error that config not found
    match result {
        Ok(config) => {
            println!("Got config: {:?}", config);
        }
        Err(e) => {
            // Expected if no config exists yet
            println!("Expected error (no config): {:?}", e);
        }
    }
}

/// Test Consul source with token authentication.
#[tokio::test]
async fn test_consul_source_with_token() {
    if !common::is_service_available(
        "http://127.0.0.1:8500/v1/status/leader",
        Duration::from_secs(2),
    )
    .await
    {
        eprintln!("Skipping test: Consul not available");
        return;
    }

    // First create a test token (empty for dev mode)
    let source = ConsulSourceBuilder::new()
        .address("127.0.0.1:8500")
        .prefix("test-config")
        .build()
        .expect("Failed to build Consul source");

    let result = source.poll().await;
    // Just verify it doesn't panic
    println!("Poll result: {:?}", result);
}

/// Test Consul source configuration parsing.
#[tokio::test]
async fn test_consul_source_parse_config() {
    if !common::is_service_available(
        "http://127.0.0.1:8500/v1/status/leader",
        Duration::from_secs(2),
    )
    .await
    {
        eprintln!("Skipping test: Consul not available");
        return;
    }

    // Write test config to Consul using HTTP API directly
    use reqwest::Client as HttpClient;

    let http_client = HttpClient::new();

    // Write a test key
    let put_result: Result<reqwest::Response, _> = http_client
        .put("http://127.0.0.1:8500/v1/kv/test-config/app")
        .body(r#"{"host": "localhost", "port": 8080}"#)
        .send()
        .await;

    if put_result.is_err() {
        eprintln!("Failed to write test config to Consul");
        return;
    }

    // Now read it back
    let source = ConsulSourceBuilder::new()
        .address("127.0.0.1:8500")
        .prefix("test-config")
        .build()
        .expect("Failed to build Consul source");

    let result = source.poll().await;

    match result {
        Ok(config) => {
            // Verify we got some config
            println!("Got config: {:?}", config);
            // Verify the config contains expected keys
            assert!(!config.is_empty(), "Config should not be empty");
        }
        Err(e) => {
            println!("Error: {:?}", e);
        }
    }

    // Cleanup - delete the test key
    let _ = http_client
        .delete("http://127.0.0.1:8500/v1/kv/test-config")
        .send()
        .await;
}