product-os-request 0.0.55

Product OS : Request provides a fully featured HTTP request library combining elements of reqwest and hyper for async requests with a series of helper methods to allow for easier usage depending upon your needs for one-time or repeat usage.
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

// Test suite for Protocol and Proxy types
#![cfg(any(feature = "request", feature = "request_std"))]

use product_os_request::{Protocol, Proxy};

#[test]
fn test_protocol_clone() {
    let protocol = Protocol::HTTPS;
    let cloned = protocol.clone();
    assert_eq!(protocol, cloned);
}

#[test]
fn test_protocol_debug() {
    let protocol = Protocol::HTTP;
    let debug_str = format!("{:?}", protocol);
    assert_eq!(debug_str, "HTTP");
}

#[test]
fn test_protocol_equality() {
    assert_eq!(Protocol::HTTP, Protocol::HTTP);
    assert_ne!(Protocol::HTTP, Protocol::HTTPS);
    assert_eq!(Protocol::SOCKS5, Protocol::SOCKS5);
    assert_eq!(Protocol::ALL, Protocol::ALL);
}

#[test]
fn test_all_protocols() {
    let protocols = vec![
        Protocol::SOCKS5,
        Protocol::HTTP,
        Protocol::HTTPS,
        Protocol::ALL,
    ];

    for protocol in protocols {
        let _ = protocol.clone();
        let _ = format!("{:?}", protocol);
        assert_eq!(protocol, protocol);
    }
}

#[test]
fn test_proxy_construction() {
    let proxy = Proxy {
        protocol: Protocol::HTTP,
        address: String::from("127.0.0.1:8080"),
    };

    assert_eq!(proxy.protocol, Protocol::HTTP);
    assert_eq!(proxy.address, "127.0.0.1:8080");
}

#[test]
fn test_proxy_clone() {
    let proxy = Proxy {
        protocol: Protocol::HTTPS,
        address: String::from("proxy.example.com:443"),
    };

    let cloned = proxy.clone();
    assert_eq!(proxy.protocol, cloned.protocol);
    assert_eq!(proxy.address, cloned.address);
}

#[test]
fn test_proxy_debug() {
    let proxy = Proxy {
        protocol: Protocol::SOCKS5,
        address: String::from("socks.example.com:1080"),
    };

    let debug_str = format!("{:?}", proxy);
    assert!(debug_str.contains("SOCKS5"));
    assert!(debug_str.contains("socks.example.com:1080"));
}

#[test]
fn test_proxy_equality() {
    let proxy1 = Proxy {
        protocol: Protocol::HTTP,
        address: String::from("proxy1.com:8080"),
    };

    let proxy2 = Proxy {
        protocol: Protocol::HTTP,
        address: String::from("proxy1.com:8080"),
    };

    let proxy3 = Proxy {
        protocol: Protocol::HTTPS,
        address: String::from("proxy1.com:8080"),
    };

    assert_eq!(proxy1, proxy2);
    assert_ne!(proxy1, proxy3);
}

#[test]
fn test_proxy_with_all_protocols() {
    let protocols = vec![
        Protocol::SOCKS5,
        Protocol::HTTP,
        Protocol::HTTPS,
        Protocol::ALL,
    ];

    for protocol in protocols {
        let proxy = Proxy {
            protocol: protocol.clone(),
            address: String::from("test.proxy.com:8080"),
        };

        assert_eq!(proxy.protocol, protocol);
    }
}