hb46pp 0.1.0

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

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

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, DiscoveryAnswer, DiscoveryResolver, ProvisioningOutcome, Transport, TransportRequest,
    TransportResponse,
};
#[cfg(feature = "default-client")]
use hb46pp::client::{DefaultClient, 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);
}

#[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 _ = constructor;
}

#[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>();
}