motorcortex-rust 0.5.0

Motorcortex Rust: a Rust client for the Motorcortex Core real-time control system (async + blocking).
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
123
124
125
126
127
128
129
130
131
132
133

//! `get_parameter` / `set_parameter` round-trip on the new `core::Request`.

use motorcortex_rust::core::Request;
use motorcortex_rust::{ConnectionOptions, StatusCode};

use crate::common::parameters::{test_values, test_vectors};
use crate::{CERT_PATH, URL_REQ};

#[tokio::test]
async fn test_async_broad_type_conversions() {
    // Dense matrix of set/get round-trips across every dtype the
    // server exposes and every Rust source type SetParameterValue
    // knows about. A regression in any converter surfaces here.
    let req = Request::connect_to(
        URL_REQ,
        ConnectionOptions::new(CERT_PATH.to_string(), 5000, 5000),
    )
    .await
    .expect("connect");
    req.request_parameter_tree().await.expect("tree");

    test_values(&req).await;
    test_vectors(&req).await;

    req.disconnect().await.expect("disconnect");
}

#[tokio::test]
async fn test_async_set_then_get_parameter_round_trip() {
    let req = Request::new();
    let opts = ConnectionOptions::new(CERT_PATH.to_string(), 5000, 5000);
    req.connect(URL_REQ, opts).await.expect("connect");
    req.request_parameter_tree().await.expect("tree populated");

    let status = req
        .set_parameter("root/Control/dummyDouble", 2.345f64)
        .await
        .expect("set RPC completes");
    assert_eq!(status, StatusCode::Ok);

    let read_back: f64 = req
        .get_parameter("root/Control/dummyDouble")
        .await
        .expect("get RPC completes");
    assert_eq!(read_back, 2.345);

    req.disconnect().await.expect("disconnect");
}

#[tokio::test]
async fn test_async_set_parameters_and_get_parameters_tuple() {
    // Batch write + read using tuple types, matching the shape of
    // legacy tests/integration/parameters.rs::test_parameter_list.
    let req = Request::new();
    let opts = ConnectionOptions::new(CERT_PATH.to_string(), 5000, 5000);
    req.connect(URL_REQ, opts).await.expect("connect");
    req.request_parameter_tree().await.expect("tree");

    let paths = [
        "root/Control/dummyBool",
        "root/Control/dummyDouble",
        "root/Control/dummyInt32",
    ];
    let written = (true, 1.999, 67i32);
    req.set_parameters(&paths, written)
        .await
        .expect("set_parameters");

    let read: (bool, f64, i32) = req
        .get_parameters(&paths)
        .await
        .expect("get_parameters");
    assert_eq!(read, written);

    req.disconnect().await.expect("disconnect");
}

#[tokio::test]
async fn test_async_single_element_tuple_round_trip() {
    // (true,) — one-element tuples hit the dedicated impl in
    // SetParameterTuple/GetParameterTuple and used to be a footgun.
    let req = Request::new();
    let opts = ConnectionOptions::new(CERT_PATH.to_string(), 5000, 5000);
    req.connect(URL_REQ, opts).await.expect("connect");
    req.request_parameter_tree().await.expect("tree");

    req.set_parameters(&["root/Control/dummyBool"], (true,))
        .await
        .expect("set_parameters");

    let (b,): (bool,) = req
        .get_parameters(&["root/Control/dummyBool"])
        .await
        .expect("get_parameters");
    assert!(b);

    req.disconnect().await.expect("disconnect");
}

#[tokio::test]
async fn test_async_set_parameter_cross_typed_reads() {
    // Same behaviour as legacy test_set_get_parameter: writing a
    // double and reading it back as f32 / i64 / String uses the
    // client-side dtype conversion.
    let req = Request::new();
    let opts = ConnectionOptions::new(CERT_PATH.to_string(), 5000, 5000);
    req.connect(URL_REQ, opts).await.expect("connect");
    req.request_parameter_tree().await.expect("tree");

    req.set_parameter("root/Control/dummyDouble", 7.0f64)
        .await
        .unwrap();

    let as_f32: f32 = req
        .get_parameter("root/Control/dummyDouble")
        .await
        .unwrap();
    assert_eq!(as_f32, 7.0);

    let as_i64: i64 = req
        .get_parameter("root/Control/dummyDouble")
        .await
        .unwrap();
    assert_eq!(as_i64, 7);

    let as_string: String = req
        .get_parameter("root/Control/dummyDouble")
        .await
        .unwrap();
    assert_eq!(as_string, "7");

    req.disconnect().await.expect("disconnect");
}