Buttplug sex toy control library
buttplug.io
1// Buttplug Rust Source Code File - See https://buttplug.io for more info.
2//
3// Copyright 2016-2024 Nonpolynomial Labs LLC. All rights reserved.
4//
5// Licensed under the BSD 3-Clause license. See LICENSE file in the project root
6// for full license information.
7
8mod delay_device_communication_manager;
9pub mod test_server;
10pub use test_server::ButtplugTestServer;
11pub mod device_test;
12pub mod test_device_manager;
13pub use delay_device_communication_manager::DelayDeviceCommunicationManagerBuilder;
14pub mod channel_transport;
15use buttplug_client::ButtplugClient;
16use buttplug_client_in_process::ButtplugInProcessClientConnectorBuilder;
17use buttplug_server::{
18 ButtplugServer,
19 ButtplugServerBuilder,
20 device::{
21 ServerDeviceManagerBuilder,
22 hardware::communication::HardwareCommunicationManagerBuilder,
23 },
24};
25use buttplug_server_device_config::{DeviceConfigurationManager, load_protocol_configs};
26pub use test_device_manager::{
27 TestDeviceChannelHost,
28 TestDeviceCommunicationManagerBuilder,
29 TestHardwareEvent,
30};
31
32use crate::util::test_device_manager::TestDeviceIdentifier;
33
34pub fn create_test_dcm() -> DeviceConfigurationManager {
35 load_protocol_configs(&None, &None, false)
36 .expect("If this fails, the whole library goes with it.")
37 .finish()
38 .expect("If this fails, the whole library goes with it.")
39}
40
41#[allow(dead_code)]
42pub fn setup_logging() {
43 tracing_subscriber::fmt::init();
44}
45
46#[allow(dead_code)]
47pub fn test_server() -> ButtplugServer {
48 ButtplugServerBuilder::new(
49 ServerDeviceManagerBuilder::new(create_test_dcm())
50 .finish()
51 .unwrap(),
52 )
53 .finish()
54 .unwrap()
55}
56
57#[allow(dead_code)]
58pub async fn test_client() -> ButtplugClient {
59 let connector = ButtplugInProcessClientConnectorBuilder::default()
60 .server(test_server())
61 .finish();
62
63 let client = ButtplugClient::new("Test Client");
64 assert!(!client.connected());
65 client
66 .connect(connector)
67 .await
68 .expect("Test, assuming infallible.");
69 assert!(client.connected());
70 client
71}
72
73#[allow(dead_code)]
74pub async fn test_client_with_device() -> (ButtplugClient, TestDeviceChannelHost) {
75 let mut builder = TestDeviceCommunicationManagerBuilder::default();
76 let device = builder.add_test_device(&TestDeviceIdentifier::new("Massage Demo", None));
77
78 let mut dm_builder = ServerDeviceManagerBuilder::new(create_test_dcm());
79 dm_builder.comm_manager(builder);
80
81 let server_builder = ButtplugServerBuilder::new(dm_builder.finish().unwrap());
82
83 let connector = ButtplugInProcessClientConnectorBuilder::default()
84 .server(server_builder.finish().unwrap())
85 .finish();
86
87 let client = ButtplugClient::new("Test Client");
88 assert!(!client.connected());
89 client
90 .connect(connector)
91 .await
92 .expect("Test, assuming infallible.");
93 assert!(client.connected());
94 (client, device)
95}
96
97#[allow(dead_code)]
98pub async fn test_client_with_device_and_custom_dcm(
99 identifier: &TestDeviceIdentifier,
100 dcm: DeviceConfigurationManager,
101) -> (ButtplugClient, TestDeviceChannelHost) {
102 let mut builder = TestDeviceCommunicationManagerBuilder::default();
103 let device = builder.add_test_device(identifier);
104
105 let mut dm_builder = ServerDeviceManagerBuilder::new(dcm);
106 dm_builder.comm_manager(builder);
107
108 let server_builder = ButtplugServerBuilder::new(dm_builder.finish().unwrap());
109
110 let connector = ButtplugInProcessClientConnectorBuilder::default()
111 .server(server_builder.finish().unwrap())
112 .finish();
113
114 let client = ButtplugClient::new("Test Client");
115 assert!(!client.connected());
116 client
117 .connect(connector)
118 .await
119 .expect("Test, assuming infallible.");
120 assert!(client.connected());
121 (client, device)
122}
123
124#[allow(dead_code)]
125pub async fn test_client_with_delayed_device_manager() -> ButtplugClient {
126 let builder = DelayDeviceCommunicationManagerBuilder::default();
127
128 let mut dm_builder = ServerDeviceManagerBuilder::new(create_test_dcm());
129 dm_builder.comm_manager(builder);
130
131 let server_builder = ButtplugServerBuilder::new(dm_builder.finish().unwrap());
132
133 let connector = ButtplugInProcessClientConnectorBuilder::default()
134 .server(server_builder.finish().unwrap())
135 .finish();
136
137 let client = ButtplugClient::new("Test Client");
138 assert!(!client.connected());
139 client
140 .connect(connector)
141 .await
142 .expect("Test, assuming infallible.");
143 assert!(client.connected());
144 client
145}
146
147#[allow(dead_code)]
148pub fn test_server_with_comm_manager<T>(dcm: T) -> ButtplugServer
149where
150 T: HardwareCommunicationManagerBuilder + 'static,
151{
152 let mut dm_builder = ServerDeviceManagerBuilder::new(create_test_dcm());
153 dm_builder.comm_manager(dcm);
154
155 ButtplugServerBuilder::new(dm_builder.finish().unwrap())
156 .finish()
157 .unwrap()
158}
159
160#[allow(dead_code)]
161pub fn test_server_with_device(device_type: &str) -> (ButtplugServer, TestDeviceChannelHost) {
162 let mut builder = TestDeviceCommunicationManagerBuilder::default();
163 let device = builder.add_test_device(&TestDeviceIdentifier::new(device_type, None));
164
165 (test_server_with_comm_manager(builder), device)
166}
167
168#[allow(dead_code)]
169pub fn test_server_v4_with_device(device_type: &str) -> (ButtplugServer, TestDeviceChannelHost) {
170 let mut builder = TestDeviceCommunicationManagerBuilder::default();
171 let device = builder.add_test_device(&TestDeviceIdentifier::new(device_type, None));
172
173 (test_server_with_comm_manager(builder), device)
174}