ip-discovery 0.5.0

A lightweight, high-performance library for detecting public IP addresses via DNS, HTTP, and STUN protocols
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Integration tests - require network access
//!
//! Run with: `cargo test --test integration -- --ignored`

use ip_discovery::{Config, Protocol, Strategy};
use std::time::Duration;

#[cfg(feature = "tokio")]
use ip_discovery::{get_ip, get_ip_with, get_ipv4};

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_get_ip_default() {
    let result = get_ip().await;
    assert!(result.is_ok(), "get_ip() failed: {:?}", result.err());
    let result = result.unwrap();
    assert!(!result.ip.is_loopback());
    assert!(!result.ip.is_unspecified());
    assert!(!result.provider.is_empty());
}

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_get_ipv4() {
    let result = get_ipv4().await;
    assert!(result.is_ok(), "get_ipv4() failed: {:?}", result.err());
    assert!(result.unwrap().ip.is_ipv4());
}

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_stun_only() {
    let config = Config::builder()
        .protocols(&[Protocol::Stun])
        .timeout(Duration::from_secs(5))
        .build();
    let result = get_ip_with(config).await;
    assert!(result.is_ok(), "STUN failed: {:?}", result.err());
}

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_dns_only() {
    let config = Config::builder()
        .protocols(&[Protocol::Dns])
        .timeout(Duration::from_secs(5))
        .build();
    let result = get_ip_with(config).await;
    assert!(result.is_ok(), "DNS failed: {:?}", result.err());
}

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_http_only() {
    let config = Config::builder()
        .protocols(&[Protocol::Http])
        .timeout(Duration::from_secs(10))
        .build();
    let result = get_ip_with(config).await;
    assert!(result.is_ok(), "HTTP failed: {:?}", result.err());
}

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_race_strategy() {
    let config = Config::builder()
        .strategy(Strategy::Race)
        .timeout(Duration::from_secs(10))
        .build();
    let result = get_ip_with(config).await;
    assert!(result.is_ok(), "Race failed: {:?}", result.err());
}

#[cfg(feature = "tokio")]
#[tokio::test]
#[ignore = "requires network"]
async fn test_consensus_strategy() {
    let config = Config::builder()
        .strategy(Strategy::Consensus { min_agree: 2 })
        .timeout(Duration::from_secs(10))
        .build();
    let result = get_ip_with(config).await;
    assert!(result.is_ok(), "Consensus failed: {:?}", result.err());
}

// ── Synchronous Blocking Integration Tests ──────────────────────────────

#[test]
#[ignore = "requires network"]
fn test_blocking_get_ip_default() {
    let result = ip_discovery::blocking::get_ip();
    assert!(
        result.is_ok(),
        "blocking::get_ip() failed: {:?}",
        result.err()
    );
    let result = result.unwrap();
    assert!(!result.ip.is_loopback());
    assert!(!result.ip.is_unspecified());
    assert!(!result.provider.is_empty());
}

#[test]
#[ignore = "requires network"]
fn test_blocking_get_ipv4() {
    let result = ip_discovery::blocking::get_ipv4();
    assert!(
        result.is_ok(),
        "blocking::get_ipv4() failed: {:?}",
        result.err()
    );
    assert!(result.unwrap().ip.is_ipv4());
}

#[test]
#[ignore = "requires network"]
fn test_blocking_stun_only() {
    let config = Config::builder()
        .protocols(&[Protocol::Stun])
        .timeout(Duration::from_secs(5))
        .build();
    let result = ip_discovery::blocking::get_ip_with(config);
    assert!(result.is_ok(), "blocking STUN failed: {:?}", result.err());
}

#[test]
#[ignore = "requires network"]
fn test_blocking_dns_only() {
    let config = Config::builder()
        .protocols(&[Protocol::Dns])
        .timeout(Duration::from_secs(5))
        .build();
    let result = ip_discovery::blocking::get_ip_with(config);
    assert!(result.is_ok(), "blocking DNS failed: {:?}", result.err());
}

#[test]
#[ignore = "requires network"]
fn test_blocking_race_strategy() {
    let config = Config::builder()
        .strategy(Strategy::Race)
        .timeout(Duration::from_secs(10))
        .build();
    let result = ip_discovery::blocking::get_ip_with(config);
    assert!(result.is_ok(), "blocking Race failed: {:?}", result.err());
}