Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_steel/tests/main.rs

2.5 KiB, 15 runs

created by r1870400018:1011, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! The main idea behind laying out tests this way is to ensure that the logger is shut down
2//! cleanly, after capturing all lingering messages.
3//!
4
5mod client;
6mod server;
7
8use oxedyne_fe2o3_core::{
9 prelude::*,
10 log::bot::FileConfig,
11};
12
13use std::time::Duration;
14
15
16fn setup_log() -> Outcome<()> {
17 let mut log_cfg = log_get_config!();
18 log_cfg.level = res!(LogLevel::from_str("trace"));
19 let file_cfg = FileConfig::new(
20 res!(std::env::current_dir()),
21 "steel_test".to_string(),
22 "log".to_string(),
23 0,
24 Some(1_048_576),
25 );
26 let log_path = file_cfg.path();
27 log_cfg.file = Some(file_cfg);
28 log_set_config!(log_cfg);
29 info!("Logging at {:?}", log_path);
30 Ok(())
31}
32
33#[tokio::main]
34async fn run_integrated() -> Outcome<()> {
35
36 let filter = "all";
37 let result = client::test_client(filter).await;
38 res!(result);
39 let result = server::test_server(filter).await;
40 res!(result);
41
42 Ok(())
43}
44
45/// Run as
46/// ```ignore
47/// cargo test server -- --nocapture
48/// ```
49#[test]
50fn server() -> Outcome<()> {
51
52 res!(setup_log());
53
54 let runtime = match tokio::runtime::Runtime::new() {
55 Ok(rt) => rt,
56 Err(e) => return Err(err!(e, "Failed to create Tokio runtime."; IO, Init)),
57 };
58
59 let outcome = runtime.block_on(async {
60 server::test_server("all").await
61 });
62
63 if let Err(e) = &outcome {
64 error!(e.clone());
65 }
66
67 log_finish_wait!();
68
69 outcome
70}
71
72/// Run as
73/// ```ignore
74/// cargo test client -- --nocapture
75/// ```
76#[test]
77fn client() -> Outcome<()> {
78
79 res!(setup_log());
80
81 let runtime = match tokio::runtime::Runtime::new() {
82 Ok(rt) => rt,
83 Err(e) => return Err(err!(e, "Failed to create Tokio runtime."; IO, Init)),
84 };
85
86 let outcome = runtime.block_on(async {
87 client::test_client("websocket").await
88 });
89
90 if let Err(e) = &outcome {
91 error!(e.clone());
92 }
93
94 log_finish_wait!();
95
96 outcome
97}
98
99/// Run as
100/// ```ignore
101/// cargo test integrated -- --nocapture
102/// ```
103#[tokio::test]
104async fn integrated() -> Outcome<()> {
105 res!(setup_log());
106
107 // Start the server in a separate task.
108 let server_handle = tokio::spawn(server::test_server("all"));
109
110 // Give the server a short time to start up.
111 tokio::time::sleep(Duration::from_millis(300)).await;
112
113 // Run the client test.
114 let client_result = client::test_client("websocket").await;
115
116 // Stop the server.
117 server_handle.abort();
118
119 // Check the results.
120 res!(client_result);
121
122 Ok(())
123}