pim-core 0.1.7

Core types, traits, and configuration for the Proximity Internet Mesh 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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use super::super::*;
use super::MINIMAL_CONFIG;

#[test]
fn bluetooth_defaults_to_disabled() {
    let config = Config::from_toml_str(MINIMAL_CONFIG).unwrap();
    assert!(!config.bluetooth.enabled);
    #[cfg(target_os = "macos")]
    assert_eq!(config.bluetooth.interface, "bridge0");
    #[cfg(not(target_os = "macos"))]
    assert_eq!(config.bluetooth.interface, "auto");
    assert!(config.bluetooth.radio_discovery_enabled);
    assert_eq!(config.bluetooth.device_name_prefix, "PIM-");
    assert_eq!(config.bluetooth.local_alias, "");
    assert!(config.bluetooth.connect_pan);
    assert!(!config.bluetooth.serve_nap);
    assert_eq!(config.bluetooth.nap_bridge, "br-bt");
    assert_eq!(config.bluetooth.nap_bridge_addr, "192.168.44.1/24");
    assert!(config.bluetooth.dhcp_enabled);
    assert!(config.bluetooth.dhcp_range.is_none());
    assert_eq!(config.bluetooth.dhcp_lease_time, "12h");
    assert!(config.bluetooth.dhcp_dns.is_none());
    assert!(config.bluetooth.request_dhcp);
    assert!(config.bluetooth.auto_discover_peers);
    assert_eq!(config.bluetooth.poll_interval_ms, 2_000);
    assert_eq!(config.bluetooth.scan_interval_ms, 5_000);
    assert_eq!(config.bluetooth.peer_discovery_interval_ms, 2_000);
    assert_eq!(config.bluetooth.bluetoothctl_timeout_s, 15);
    assert_eq!(config.bluetooth.discoverable_timeout_s, 180);
    assert_eq!(config.bluetooth.startup_timeout_ms, 15_000);
}

#[test]
fn bluetooth_enabled_round_trips() {
    let toml = r#"
[node]
name = "t"
[bluetooth]
enabled = true
radio_discovery_enabled = true
device_name_prefix = "PIM-"
local_alias = "PIM-t"
connect_pan = false
serve_nap = true
nap_bridge = "br-pan0"
auto_discover_peers = false
"#;
    let config = Config::from_toml_str(toml).unwrap();
    assert!(config.bluetooth.enabled);
    assert!(config.bluetooth.radio_discovery_enabled);
    assert_eq!(config.bluetooth.device_name_prefix, "PIM-");
    assert_eq!(config.bluetooth.local_alias, "PIM-t");
    assert!(!config.bluetooth.connect_pan);
    assert!(config.bluetooth.serve_nap);
    assert_eq!(config.bluetooth.nap_bridge, "br-pan0");
    assert!(!config.bluetooth.auto_discover_peers);
    let serialized = config.to_toml_string().unwrap();
    let reparsed = Config::from_toml_str(&serialized).unwrap();
    assert!(reparsed.bluetooth.enabled);
    assert!(!reparsed.bluetooth.connect_pan);
    assert!(reparsed.bluetooth.serve_nap);
    assert!(!reparsed.bluetooth.auto_discover_peers);
}

#[test]
fn bluetooth_custom_interface_and_timeouts_parse() {
    let toml = r#"
[node]
name = "t"
[bluetooth]
enabled = true
interface = "bnep1"
radio_discovery_enabled = true
device_name_prefix = "MESH-"
local_alias = "MESH-t"
connect_pan = true
serve_nap = false
nap_bridge = "br-bt"
auto_discover_peers = true
poll_interval_ms = 500
scan_interval_ms = 750
peer_discovery_interval_ms = 750
bluetoothctl_timeout_s = 20
discoverable_timeout_s = 60
startup_timeout_ms = 10000
"#;
    let config = Config::from_toml_str(toml).unwrap();
    assert_eq!(config.bluetooth.interface, "bnep1");
    assert!(config.bluetooth.radio_discovery_enabled);
    assert_eq!(config.bluetooth.device_name_prefix, "MESH-");
    assert_eq!(config.bluetooth.local_alias, "MESH-t");
    assert!(config.bluetooth.connect_pan);
    assert!(!config.bluetooth.serve_nap);
    assert_eq!(config.bluetooth.nap_bridge, "br-bt");
    assert!(config.bluetooth.auto_discover_peers);
    assert_eq!(config.bluetooth.poll_interval_ms, 500);
    assert_eq!(config.bluetooth.scan_interval_ms, 750);
    assert_eq!(config.bluetooth.peer_discovery_interval_ms, 750);
    assert_eq!(config.bluetooth.bluetoothctl_timeout_s, 20);
    assert_eq!(config.bluetooth.discoverable_timeout_s, 60);
    assert_eq!(config.bluetooth.startup_timeout_ms, 10_000);
}

#[test]
fn bluetooth_rfcomm_defaults_to_disabled() {
    let config = Config::from_toml_str(MINIMAL_CONFIG).unwrap();
    assert!(!config.bluetooth_rfcomm.enabled);
    assert_eq!(config.bluetooth_rfcomm.channel, 22);
    assert_eq!(config.bluetooth_rfcomm.device_name_prefix, "PIM-");
    assert!(config.bluetooth_rfcomm.outbound_enabled);
    assert_eq!(config.bluetooth_rfcomm.poll_interval_ms, 30_000);
    assert!(config.bluetooth_rfcomm.bridge_to_tcp);
}

#[test]
fn bluetooth_rfcomm_enabled_round_trips() {
    let toml = r#"
[node]
name = "t"

[bluetooth_rfcomm]
enabled = true
channel = 23
device_name_prefix = "MESH-"
outbound_enabled = false
poll_interval_ms = 15000
bridge_to_tcp = false
"#;
    let config = Config::from_toml_str(toml).unwrap();
    assert!(config.bluetooth_rfcomm.enabled);
    assert_eq!(config.bluetooth_rfcomm.channel, 23);
    assert_eq!(config.bluetooth_rfcomm.device_name_prefix, "MESH-");
    assert!(!config.bluetooth_rfcomm.outbound_enabled);
    assert_eq!(config.bluetooth_rfcomm.poll_interval_ms, 15_000);
    assert!(!config.bluetooth_rfcomm.bridge_to_tcp);

    let serialized = config.to_toml_string().unwrap();
    let reparsed = Config::from_toml_str(&serialized).unwrap();
    assert!(reparsed.bluetooth_rfcomm.enabled);
    assert_eq!(reparsed.bluetooth_rfcomm.channel, 23);
    assert_eq!(reparsed.bluetooth_rfcomm.device_name_prefix, "MESH-");
    assert!(!reparsed.bluetooth_rfcomm.outbound_enabled);
    assert_eq!(reparsed.bluetooth_rfcomm.poll_interval_ms, 15_000);
    assert!(!reparsed.bluetooth_rfcomm.bridge_to_tcp);
}