angrydutchman.peedee.es
forked from
atscan.net/plcbundle-rs
High-performance implementation of plcbundle written in Rust
tree.fail
1mod common;
2
3use anyhow::Result;
4use std::sync::Arc;
5
6#[tokio::test]
7async fn test_server_endpoints() -> Result<()> {
8 let dir = common::setup_temp_dir()?;
9 let manager = common::setup_manager(&dir.path().to_path_buf())?;
10 let manager = Arc::new(manager);
11 let port = 3030;
12 let server_handle = common::start_test_server(Arc::clone(&manager), port).await?;
13
14 let client = reqwest::Client::new();
15 let base_url = format!("http://127.0.0.1:{}", port);
16
17 // Test root endpoint
18 let res = client.get(format!("{}/", base_url)).send().await?;
19 assert!(res.status().is_success());
20 let body = res.text().await?;
21 assert!(body.contains("plcbundle server"));
22
23 // Test status endpoint
24 let res = client.get(format!("{}/status", base_url)).send().await?;
25 assert!(res.status().is_success());
26 let json: serde_json::Value = res.json().await?;
27 assert_eq!(json["server"]["version"], "test");
28
29 // Test debug endpoints
30 let debug_endpoints = vec!["memory", "didindex", "resolver"];
31 for endpoint in debug_endpoints {
32 let url = format!("{}/debug/{}", base_url, endpoint);
33 let res = client.get(&url).send().await?;
34 assert!(res.status().is_success());
35 if endpoint == "memory" {
36 let body = res.text().await?;
37 assert!(body.contains("Memory Stats"));
38 } else {
39 let _: serde_json::Value = res.json().await?;
40 }
41 }
42
43 server_handle.abort();
44 Ok(())
45}
46
47#[tokio::test]
48async fn test_server_did_endpoints() -> Result<()> {
49 let dir = common::setup_temp_dir()?;
50 let dir_path = dir.path().to_path_buf();
51
52 // Initialize repo and add a dummy bundle with DID operations
53 common::setup_manager(&dir_path)?;
54 common::add_dummy_bundle(&dir_path)?;
55
56 // Create manager that loads the index and build DID index for lookups
57 let manager = plcbundle::BundleManager::new(dir_path, ())?;
58 let manager = Arc::new(manager);
59 // Build DID index so the resolver can find operations in bundles
60 manager
61 .batch_update_did_index_async(1, manager.get_last_bundle(), false)
62 .await?;
63 let port = 3032;
64 let server_handle = common::start_test_server(Arc::clone(&manager), port).await?;
65
66 let client = reqwest::Client::new();
67 let base_url = format!("http://127.0.0.1:{}", port);
68
69 // Test DID document endpoint (first DID from dummy bundle)
70 let first_did = "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa";
71 let res = client
72 .get(format!("{}/{}", base_url, first_did))
73 .send()
74 .await?;
75 let status = res.status();
76 let header_x_request_type = res
77 .headers()
78 .get("x-request-type")
79 .and_then(|v| v.to_str().ok())
80 .map(|s| s.to_string());
81 let header_x_did = res
82 .headers()
83 .get("x-did")
84 .and_then(|v| v.to_str().ok())
85 .map(|s| s.to_string());
86 let body_text = res.text().await?;
87 if !status.is_success() {
88 panic!("DID document request failed: {}\n{}", status, body_text);
89 }
90 assert_eq!(header_x_request_type.unwrap(), "did");
91 assert_eq!(header_x_did.unwrap(), first_did);
92 let json: serde_json::Value = serde_json::from_str(&body_text)?;
93 assert_eq!(json["id"], first_did);
94
95 // Test DID data endpoint
96 let res = client
97 .get(format!(
98 "{}/did:plc:aaaaaaaaaaaaaaaaaaaaaaaa/data",
99 base_url
100 ))
101 .send()
102 .await?;
103 let status = res.status();
104 let body_text = res.text().await?;
105 if !status.is_success() {
106 panic!("DID data request failed: {}\n{}", status, body_text);
107 }
108 let json: serde_json::Value = serde_json::from_str(&body_text)?;
109 assert_eq!(json["did"], "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa");
110
111 // Test DID audit log endpoint
112 let res = client
113 .get(format!(
114 "{}/did:plc:aaaaaaaaaaaaaaaaaaaaaaaa/log/audit",
115 base_url
116 ))
117 .send()
118 .await?;
119 let status = res.status();
120 let body_text = res.text().await?;
121 if !status.is_success() {
122 panic!("DID audit log request failed: {}\n{}", status, body_text);
123 }
124 let json: serde_json::Value = serde_json::from_str(&body_text)?;
125 assert!(json.is_array());
126 assert!(!json.as_array().unwrap().is_empty());
127 assert_eq!(
128 json.as_array().unwrap()[0]["did"],
129 "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa"
130 );
131
132 server_handle.abort();
133 Ok(())
134}
135
136#[tokio::test]
137async fn test_server_data_endpoints() -> Result<()> {
138 let dir = common::setup_temp_dir()?;
139 let dir_path = dir.path().to_path_buf();
140
141 // 1. Initialize repo
142 common::setup_manager(&dir_path)?;
143
144 // 2. Add dummy bundle to the index file
145 common::add_dummy_bundle(&dir_path)?;
146
147 // 3. Create a new manager that will load the modified index
148 let manager = plcbundle::BundleManager::new(dir_path, ())?;
149 let manager = Arc::new(manager);
150 // Ensure DID index is available for data/op lookups
151 manager
152 .batch_update_did_index_async(1, manager.get_last_bundle(), false)
153 .await?;
154 let port = 3031;
155 let server_handle = common::start_test_server(Arc::clone(&manager), port).await?;
156
157 let client = reqwest::Client::new();
158 let base_url = format!("http://127.0.0.1:{}", port);
159
160 // Test index.json endpoint
161 let res = client
162 .get(format!("{}/index.json", base_url))
163 .send()
164 .await?;
165 println!("Testing endpoint: /index.json, status: {}", res.status());
166 assert!(res.status().is_success());
167 let json: serde_json::Value = res.json().await?;
168 assert_eq!(json["bundles"].as_array().unwrap().len(), 1);
169
170 // Test bundle endpoint
171 let res = client.get(format!("{}/bundle/1", base_url)).send().await?;
172 println!("Testing endpoint: /bundle/1, status: {}", res.status());
173 assert!(res.status().is_success());
174 let json: serde_json::Value = res.json().await?;
175 assert_eq!(json["bundle_number"], 1);
176
177 // Test data endpoint
178 let res = client.get(format!("{}/data/1", base_url)).send().await?;
179 println!("Testing endpoint: /data/1, status: {}", res.status());
180 assert!(res.status().is_success());
181 let body = res.bytes().await?;
182 assert!(!body.is_empty());
183
184 // Test jsonl endpoint
185 let res = client.get(format!("{}/jsonl/1", base_url)).send().await?;
186 println!("Testing endpoint: /jsonl/1, status: {}", res.status());
187 assert!(res.status().is_success());
188 let body = res.text().await?;
189 assert!(body.contains("did:plc:aaaaaaaaaaaaaaaaaaaaaaaa"));
190
191 // Test op endpoint
192 let res = client.get(format!("{}/op/1:0", base_url)).send().await?;
193 println!("Testing endpoint: /op/1:0, status: {}", res.status());
194 assert!(res.status().is_success());
195 let json: serde_json::Value = res.json().await?;
196 assert_eq!(json["did"], "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa");
197
198 // Test mempool endpoint (not available when sync_mode=false)
199 let res = client.get(format!("{}/mempool", base_url)).send().await?;
200 println!("Testing endpoint: /mempool, status: {}", res.status());
201 assert_eq!(res.status().as_u16(), 404);
202
203 server_handle.abort();
204 Ok(())
205}