whois-that 0.1.2

A feature full whois client library with support for non-UTF8 responses
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

use crate::builder::WhoisBuilder;
use crate::whois::Whois;

#[cfg(feature = "serde")]
fn basic_whois_client() -> Whois {
    WhoisBuilder::default()
        .build()
        .expect("Should be able to build whois client")
}

#[cfg(feature = "serde")]
#[tokio::test]
async fn test_whois_client() {
    basic_whois_client();
}

#[cfg(feature = "serde")]
#[tokio::test]
async fn test_whois_builder() {
    Whois::builder()
        .build()
        .expect("Should be able to build whois client");
}

#[cfg(feature = "serde")]
async fn lookup(domain: &'static str) {
    let whois = basic_whois_client();

    let info = whois
        .whois_lookup(domain)
        .await
        .expect(&format!("Should be able to get whois data for {}", domain));

    println!("{}", &info);

    assert!(
        info.to_ascii_lowercase().contains(domain)
            || info
                .to_ascii_lowercase()
                .contains(&idna::domain_to_ascii(domain).expect("Should be able to get as ascii"))
    )
}

#[tokio::test]
#[cfg(feature = "serde")]
async fn test_simple_domain() {
    lookup("google.com").await;
}

#[tokio::test]
#[cfg(feature = "serde")]
async fn test_fail_rdap() {
    let whois = basic_whois_client();

    whois
        .whois_lookup("google.dev")
        .await
        .expect_err("Shouldn't be able to get whois data for google.dev");
}

#[tokio::test]
#[cfg(feature = "serde")]
#[cfg(feature = "decode-global")]
async fn test_simple_international() {
    lookup("registro.br").await;
}

#[tokio::test]
#[cfg(feature = "serde")]
#[cfg(feature = "decode-global")]
async fn test_simple_unicode() {
    lookup("xn--1lq68wkwbj6u.jp").await;
}

#[tokio::test]
#[cfg(feature = "serde")]
#[cfg(feature = "decode-global")]
async fn test_simple_unicode_unparsed() {
    lookup("öbb.at").await;
}