hb46pp 0.1.3

Client library for the HTTP-Based IPv4 over IPv6 Provisioning Protocol
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

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

#[cfg(any(feature = "default-client", feature = "default-transport"))]
use std::time::Duration;
use std::{
    convert::Infallible,
    future::{self, Future},
};

#[cfg(feature = "default-resolver")]
use hb46pp::client::DefaultDiscoveryResolver;
#[cfg(feature = "default-transport")]
use hb46pp::client::DefaultTransport;
use hb46pp::client::{
    Client, ClientError, DiscoveryAnswer, DiscoveryResolver, ProvisioningAuthenticationPolicy,
    ProvisioningOutcome, RetryAction, Transport, TransportRequest, TransportResponse,
};
#[cfg(feature = "default-client")]
use hb46pp::client::{DefaultClient, DefaultClientBuilder, DefaultClientError};

struct FakeResolver;

impl DiscoveryResolver for FakeResolver {
    type Error = Infallible;

    fn lookup_txt(
        &self,
        _name: &str,
    ) -> impl Future<Output = Result<DiscoveryAnswer, Self::Error>> {
        future::ready(Ok(DiscoveryAnswer::NotFound))
    }
}

struct FakeTransport;

impl Transport for FakeTransport {
    type Error = Infallible;

    fn send_once(
        &self,
        _request: TransportRequest,
    ) -> impl Future<Output = Result<TransportResponse, Self::Error>> {
        future::ready(Ok(TransportResponse::new(
            200,
            None,
            None,
            br#"{"order":[]}"#.to_vec(),
        )))
    }
}

#[test]
fn downstream_crates_can_implement_transport() {
    fn accepts_transport(_: &impl Transport) {}

    accepts_transport(&FakeTransport);
}

#[test]
fn downstream_crates_can_implement_discovery_resolver() {
    fn accepts_resolver(_: &impl DiscoveryResolver) {}

    accepts_resolver(&FakeResolver);
}

#[test]
fn downstream_crates_can_construct_client() {
    let _client = Client::new(FakeResolver, FakeTransport)
        .with_authentication_policy(ProvisioningAuthenticationPolicy::AllowUnauthenticated);
}

#[test]
fn downstream_crates_can_inspect_next_attempt_window() {
    let window = ProvisioningOutcome::NotFound.next_attempt_window();

    assert!(window.min() <= window.max());
}

#[cfg(feature = "default-client")]
#[test]
fn downstream_crates_can_construct_the_default_client() {
    let constructor: fn() -> Result<DefaultClient, DefaultClientError> = DefaultClient::try_new;
    let builder_constructor: fn() -> DefaultClientBuilder = DefaultClient::builder;

    let _ = constructor;
    let _ = builder_constructor()
        .request_timeout(Duration::from_secs(10))
        .authentication_policy(ProvisioningAuthenticationPolicy::AllowUnauthenticated)
        .max_redirects(2);
}

#[cfg(feature = "default-resolver")]
#[test]
fn downstream_crates_can_use_the_default_resolver() {
    fn accepts_resolver_type<R: DiscoveryResolver>() {}

    accepts_resolver_type::<DefaultDiscoveryResolver>();
}

#[cfg(feature = "default-transport")]
#[test]
fn downstream_crates_can_use_the_default_transport() {
    fn accepts_transport_type<T: Transport>() {}

    accepts_transport_type::<DefaultTransport>();

    let timeout_constructor: fn(Duration) -> Result<DefaultTransport, reqwest::Error> =
        DefaultTransport::new_with_request_timeout;
    let _ = timeout_constructor;
}

#[test]
fn downstream_crates_can_inspect_retry_actions() {
    let action = ClientError::UnexpectedRecordCount(2)
        .retry_action()
        .unwrap();

    assert!(matches!(&action, RetryAction::DisableMigration(_)));

    let window = action.window();
    assert!(window.min() <= window.max());
}