ftr 0.7.0

A fast, parallel ICMP traceroute with ASN lookup, reverse DNS, and ISP detection
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
153

//! Integration test for the new service-oriented API

use ftr::Ftr;
use std::net::IpAddr;

#[tokio::test]
async fn test_ftr_convenience_methods() {
    let ftr = Ftr::new();

    // Test ASN lookup with a public IP
    let ip: IpAddr = "8.8.8.8".parse().unwrap();
    let result = ftr.lookup_asn(ip).await;

    // Only skip in CI environments where network may be unreliable
    if std::env::var("CI").is_ok() && result.is_err() {
        eprintln!(
            "Skipping test in CI due to network error: {:?}",
            result.err()
        );
        return;
    }

    assert!(result.is_ok(), "ASN lookup failed: {:?}", result.err());
    let asn_info = result.unwrap();

    // Print actual values for debugging CI issues
    eprintln!("DEBUG: ASN lookup for 8.8.8.8 returned:");
    eprintln!("  ASN: {}", asn_info.asn);
    eprintln!("  Name: '{}'", asn_info.name);
    eprintln!("  Prefix: '{}'", asn_info.prefix);
    eprintln!("  Country: '{}'", asn_info.country_code);
    eprintln!("  Registry: '{}'", asn_info.registry);

    assert_eq!(asn_info.asn, 15169);

    // More flexible check for Google's ASN - handle various possible formats
    let name_upper = asn_info.name.to_uppercase();
    let is_google_asn =
        name_upper.contains("GOOGLE") || name_upper.contains("GOOGL") || asn_info.asn == 15169; // Accept AS15169 even if name is empty/missing

    assert!(
        is_google_asn,
        "Expected Google ASN (15169) or recognizable name, got: '{}' (ASN: {})",
        asn_info.name, asn_info.asn
    );

    // Test reverse DNS lookup
    let dns_ip: IpAddr = "8.8.8.8".parse().unwrap();
    let result = ftr.lookup_rdns(dns_ip).await;
    if let Ok(hostname) = result {
        assert!(hostname.contains("dns.google") || hostname.contains("google"));
    }
    // It's okay if reverse DNS fails in test environment
}

#[tokio::test]
async fn test_service_isolation() {
    // Create two Ftr instances
    let ftr1 = Ftr::new();
    let ftr2 = Ftr::new();

    // Perform lookups on both
    let ip: IpAddr = "1.1.1.1".parse().unwrap();

    let result1 = ftr1.lookup_asn(ip).await;
    let result2 = ftr2.lookup_asn(ip).await;

    // Only skip in CI environments where network may be unreliable
    if std::env::var("CI").is_ok() && (result1.is_err() || result2.is_err()) {
        eprintln!("Skipping test in CI due to network error");
        return;
    }

    // Both should succeed independently
    assert!(result1.is_ok(), "First lookup failed: {:?}", result1.err());
    assert!(result2.is_ok(), "Second lookup failed: {:?}", result2.err());

    // Results should be the same (same IP = same ASN)
    assert_eq!(result1.unwrap().asn, result2.unwrap().asn);
}

#[tokio::test]
async fn test_cache_clearing() {
    let ftr = Ftr::new();

    // Perform a lookup to populate caches
    let ip: IpAddr = "8.8.4.4".parse().unwrap();
    let first_result = ftr.lookup_asn(ip).await;

    // Only skip in CI environments where network may be unreliable
    if std::env::var("CI").is_ok() && first_result.is_err() {
        eprintln!("Skipping cache test in CI due to network error");
        return;
    }

    // Clear all caches
    ftr.clear_all_caches().await;

    // Should still work after clearing
    let result = ftr.lookup_asn(ip).await;

    // Only skip in CI environments where network may be unreliable
    if std::env::var("CI").is_ok() && result.is_err() {
        eprintln!("Skipping cache test in CI due to network error after clear");
        return;
    }

    assert!(
        result.is_ok(),
        "Lookup after cache clear failed: {:?}",
        result.err()
    );
}

#[tokio::test]
async fn test_direct_service_access() {
    let ftr = Ftr::new();

    // Access ASN service directly (no locking needed)
    let asn_service = &ftr.services.asn;

    let ip: IpAddr = "1.1.1.1".parse().unwrap();
    let result = asn_service.lookup(ip).await;

    // Only skip in CI environments where network may be unreliable
    if std::env::var("CI").is_ok() && result.is_err() {
        eprintln!(
            "Skipping test in CI due to network error: {:?}",
            result.err()
        );
        return;
    }

    assert!(result.is_ok(), "ASN lookup failed: {:?}", result.err());

    // Check cache stats
    let stats = asn_service.cache_stats().await;
    assert!(!stats.is_empty); // Should have at least one entry after lookup
}

#[tokio::test]
async fn test_private_ip_handling() {
    let ftr = Ftr::new();

    // Test with private IP
    let private_ip: IpAddr = "192.168.1.1".parse().unwrap();
    let result = ftr.lookup_asn(private_ip).await;

    assert!(result.is_ok());
    let asn_info = result.unwrap();
    assert_eq!(asn_info.asn, 0); // Private IPs have ASN 0
    assert_eq!(asn_info.name, "Private Network");
}