sep2_client 0.1.0

A Rust library for building IEEE 2030.5 Clients
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

#![cfg(feature = "messaging")]
use sep2_client::{
    client::{Client, SEPResponse},
    pubsub::{ClientNotifServer, RouteCallback},
};
use sep2_common::packages::{dcap::DeviceCapability, edev::EndDevice, pubsub::Notification};
use std::{
    convert::Infallible,
    future::{self, Future},
    time::Duration,
};

fn test_setup() -> Client {
    Client::new_https(
        // Point to Notif Server
        "https://127.0.0.1:1338",
        "../certs/client_cert.pem",
        "../certs/client_private_key.pem",
        "../certs/rootCA.pem",
        None,
        None,
    )
    .unwrap()
}

#[derive(Clone)]
struct DCAPHandler;

impl RouteCallback<DeviceCapability> for DCAPHandler {
    fn callback(
        &self,
        _: Notification<DeviceCapability>,
    ) -> impl Future<Output = SEPResponse> + Send {
        async move { SEPResponse::Created(None) }
    }
}

#[tokio::test]
async fn run_notif_server() {
    let client = ClientNotifServer::new("127.0.0.1:1338")
        .unwrap()
        .with_https(
            "../certs/server_cert.pem",
            "../certs/server_private_key.pem",
            "../certs/rootCA.pem",
        )
        .unwrap()
        .add("/dcap", DCAPHandler)
        .add("/edev", |_: Notification<EndDevice>| async move {
            SEPResponse::Created(None)
        });
    tokio::spawn(client.run(future::pending::<Infallible>()));
    tokio::time::sleep(Duration::from_secs(4)).await;
}

#[tokio::test]
async fn basic_post() {
    let notif: Notification<DeviceCapability> = Default::default();
    let client = test_setup();
    // Valid
    assert!(matches!(
        client.post("/dcap", &notif).await.unwrap(),
        SEPResponse::Created(None)
    ));
    assert!(matches!(
        client.post("/edev", &notif).await.unwrap(),
        SEPResponse::Created(None)
    ));
    // Bad method
    assert!(matches!(
        client.put("/edev", &notif).await.unwrap(),
        SEPResponse::MethodNotAllowed(_),
    ));
    assert!(matches!(
        client.delete("/edev").await.unwrap(),
        SEPResponse::MethodNotAllowed(_),
    ));
    assert!(client.get::<EndDevice>("/edev").await.is_err());
    // Bad route
    assert!(matches!(
        client.post("/bad_route", &notif).await.unwrap(),
        SEPResponse::NotFound,
    ));
    assert!(matches!(
        client.post("", &notif).await.unwrap(),
        SEPResponse::NotFound,
    ));
    assert!(matches!(
        client.post("/", &notif).await.unwrap(),
        SEPResponse::NotFound,
    ));
}