upleb.uk

Public git repos — served from a NIP-34 GRASP relay at git.upleb.uk

summaryrefslogtreecommitdiff
path: root/tests/ngit_init.rs
diff options
context:
space:
mode:
authorDanConwayDev <DanConwayDev@protonmail.com>2025-10-28 13:19:24 +0000
committerDanConwayDev <DanConwayDev@protonmail.com>2025-10-28 13:19:24 +0000
commita287f53132c91eaa3ba8d5e9c2bec80587316aad (patch)
tree54a3237486b435f4f798d1af01d6340c8a626bb4 /tests/ngit_init.rs
parentdcbe6f9d9e14290c856b0118ab17f3be804ac14e (diff)
test: refactor to use rstest more efficient test runs
Identified high value areas to use rstest that would benefit most and refactored them
Diffstat (limited to 'tests/ngit_init.rs')
-rw-r--r--tests/ngit_init.rs360
1 files changed, 187 insertions, 173 deletions
diff --git a/tests/ngit_init.rs b/tests/ngit_init.rs
index 1a23177..f6b30ef 100644
--- a/tests/ngit_init.rs
+++ b/tests/ngit_init.rs
@@ -1,5 +1,6 @@
1use anyhow::Result; 1use anyhow::Result;
2use nostr_sdk::Kind; 2use nostr_sdk::Kind;
3use rstest::*;
3use serial_test::serial; 4use serial_test::serial;
4use test_utils::{git::GitTestRepo, *}; 5use test_utils::{git::GitTestRepo, *};
5 6
@@ -120,68 +121,107 @@ mod when_repo_not_previously_claimed {
120 121
121 use super::*; 122 use super::*;
122 123
124 #[derive(Clone)]
125 pub struct SentToCorrectRelaysScenario {
126 pub r51_repo_event_count: usize,
127 pub r52_repo_event_count: usize,
128 pub r53_repo_event_count: usize,
129 pub r55_repo_event_count: usize,
130 pub r56_repo_event_count: usize,
131 pub r57_repo_event_count: usize,
132 }
133
134 #[fixture]
135 async fn scenario() -> SentToCorrectRelaysScenario {
136 let (r51, r52, r53, r55, r56, r57) =
137 prep_run_init().await.expect("prep_run_init failed");
138
139 // Extract event counts for verification
140 let r51_repo_event_count = r51
141 .events
142 .iter()
143 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
144 .count();
145 let r52_repo_event_count = r52
146 .events
147 .iter()
148 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
149 .count();
150 let r53_repo_event_count = r53
151 .events
152 .iter()
153 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
154 .count();
155 let r55_repo_event_count = r55
156 .events
157 .iter()
158 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
159 .count();
160 let r56_repo_event_count = r56
161 .events
162 .iter()
163 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
164 .count();
165 let r57_repo_event_count = r57
166 .events
167 .iter()
168 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
169 .count();
170
171 SentToCorrectRelaysScenario {
172 r51_repo_event_count,
173 r52_repo_event_count,
174 r53_repo_event_count,
175 r55_repo_event_count,
176 r56_repo_event_count,
177 r57_repo_event_count,
178 }
179 }
180
181 #[rstest]
123 #[tokio::test] 182 #[tokio::test]
124 #[serial] 183 #[serial]
125 async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> { 184 async fn only_1_repository_kind_event_sent_to_user_relays(
126 let (_, _, r53, r55, _, _) = prep_run_init().await?; 185 #[future] scenario: SentToCorrectRelaysScenario,
127 for relay in [&r53, &r55] { 186 ) -> Result<()> {
128 assert_eq!( 187 let s = scenario.await;
129 relay 188 assert_eq!(s.r53_repo_event_count, 1);
130 .events 189 assert_eq!(s.r55_repo_event_count, 1);
131 .iter()
132 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
133 .count(),
134 1,
135 );
136 }
137 Ok(()) 190 Ok(())
138 } 191 }
139 192
193 #[rstest]
140 #[tokio::test] 194 #[tokio::test]
141 #[serial] 195 #[serial]
142 async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> { 196 async fn only_1_repository_kind_event_sent_to_specified_repo_relays(
143 let (_, _, _, r55, r56, _) = prep_run_init().await?; 197 #[future] scenario: SentToCorrectRelaysScenario,
144 for relay in [&r55, &r56] { 198 ) -> Result<()> {
145 assert_eq!( 199 let s = scenario.await;
146 relay 200 assert_eq!(s.r55_repo_event_count, 1);
147 .events 201 assert_eq!(s.r56_repo_event_count, 1);
148 .iter()
149 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
150 .count(),
151 1,
152 );
153 }
154 Ok(()) 202 Ok(())
155 } 203 }
156 204
205 #[rstest]
157 #[tokio::test] 206 #[tokio::test]
158 #[serial] 207 #[serial]
159 async fn only_1_repository_kind_event_sent_to_fallback_relays() -> Result<()> { 208 async fn only_1_repository_kind_event_sent_to_fallback_relays(
160 let (r51, r52, _, _, _, _) = prep_run_init().await?; 209 #[future] scenario: SentToCorrectRelaysScenario,
161 for relay in [&r51, &r52] { 210 ) -> Result<()> {
162 assert_eq!( 211 let s = scenario.await;
163 relay 212 assert_eq!(s.r51_repo_event_count, 1);
164 .events 213 assert_eq!(s.r52_repo_event_count, 1);
165 .iter()
166 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
167 .count(),
168 1,
169 );
170 }
171 Ok(()) 214 Ok(())
172 } 215 }
173 216
217 #[rstest]
174 #[tokio::test] 218 #[tokio::test]
175 #[serial] 219 #[serial]
176 async fn only_1_repository_kind_event_sent_to_blaster_relays() -> Result<()> { 220 async fn only_1_repository_kind_event_sent_to_blaster_relays(
177 let (_, _, _, _, _, r57) = prep_run_init().await?; 221 #[future] scenario: SentToCorrectRelaysScenario,
178 assert_eq!( 222 ) -> Result<()> {
179 r57.events 223 let s = scenario.await;
180 .iter() 224 assert_eq!(s.r57_repo_event_count, 1);
181 .filter(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
182 .count(),
183 1,
184 );
185 Ok(()) 225 Ok(())
186 } 226 }
187 } 227 }
@@ -271,179 +311,153 @@ mod when_repo_not_previously_claimed {
271 mod tags_as_specified_in_args { 311 mod tags_as_specified_in_args {
272 use super::*; 312 use super::*;
273 313
314 #[derive(Clone)]
315 pub struct TagsAsSpecifiedScenario {
316 pub event: nostr::Event,
317 }
318
319 #[fixture]
320 async fn scenario() -> TagsAsSpecifiedScenario {
321 let (_, _, r53, _r55, _r56, _r57) =
322 prep_run_init().await.expect("prep_run_init failed");
323
324 // Extract the GitRepoAnnouncement event (should be same on all relays)
325 let event = r53
326 .events
327 .iter()
328 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
329 .expect("GitRepoAnnouncement event not found")
330 .clone();
331
332 TagsAsSpecifiedScenario { event }
333 }
334
335 #[rstest]
274 #[tokio::test] 336 #[tokio::test]
275 #[serial] 337 #[serial]
276 async fn d_replaceable_event_identifier() -> Result<()> { 338 async fn d_replaceable_event_identifier(
277 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 339 #[future] scenario: TagsAsSpecifiedScenario,
278 for relay in [&r53, &r55, &r56, &r57] { 340 ) -> Result<()> {
279 let event: &nostr::Event = relay 341 let s = scenario.await;
280 .events 342 assert!(
281 .iter() 343 s.event.tags.iter().any(
282 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
283 .unwrap();
284
285 assert!(event.tags.iter().any(
286 |t| t.as_slice()[0].eq("d") && t.as_slice()[1].eq("example-identifier") 344 |t| t.as_slice()[0].eq("d") && t.as_slice()[1].eq("example-identifier")
287 )); 345 )
288 } 346 );
289 Ok(()) 347 Ok(())
290 } 348 }
291 349
350 #[rstest]
292 #[tokio::test] 351 #[tokio::test]
293 #[serial] 352 #[serial]
294 async fn earliest_unique_commit_as_reference_with_euc_marker() -> Result<()> { 353 async fn earliest_unique_commit_as_reference_with_euc_marker(
295 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 354 #[future] scenario: TagsAsSpecifiedScenario,
296 for relay in [&r53, &r55, &r56, &r57] { 355 ) -> Result<()> {
297 let event: &nostr::Event = relay 356 let s = scenario.await;
298 .events 357 assert!(s.event.tags.iter().any(|t| t.as_slice()[0].eq("r")
299 .iter() 358 && t.as_slice()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")
300 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) 359 && t.as_slice()[2].eq("euc")));
301 .unwrap();
302
303 assert!(event.tags.iter().any(|t| t.as_slice()[0].eq("r")
304 && t.as_slice()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")
305 && t.as_slice()[2].eq("euc")));
306 }
307 Ok(()) 360 Ok(())
308 } 361 }
309 362
363 #[rstest]
310 #[tokio::test] 364 #[tokio::test]
311 #[serial] 365 #[serial]
312 async fn name() -> Result<()> { 366 async fn name(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
313 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 367 let s = scenario.await;
314 for relay in [&r53, &r55, &r56, &r57] { 368 assert!(
315 let event: &nostr::Event = relay 369 s.event
316 .events 370 .tags
317 .iter() 371 .iter()
318 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) 372 .any(|t| t.as_slice()[0].eq("name") && t.as_slice()[1].eq("example-name"))
319 .unwrap(); 373 );
320
321 assert!(
322 event
323 .tags
324 .iter()
325 .any(|t| t.as_slice()[0].eq("name")
326 && t.as_slice()[1].eq("example-name"))
327 );
328 }
329 Ok(()) 374 Ok(())
330 } 375 }
331 376
377 #[rstest]
332 #[tokio::test] 378 #[tokio::test]
333 #[serial] 379 #[serial]
334 async fn alt() -> Result<()> { 380 async fn alt(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
335 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 381 let s = scenario.await;
336 for relay in [&r53, &r55, &r56, &r57] { 382 assert!(s.event.tags.iter().any(|t| t.as_slice()[0].eq("alt")
337 let event: &nostr::Event = relay 383 && t.as_slice()[1].eq("git repository: example-name")));
338 .events
339 .iter()
340 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
341 .unwrap();
342
343 assert!(event.tags.iter().any(|t| t.as_slice()[0].eq("alt")
344 && t.as_slice()[1].eq("git repository: example-name")));
345 }
346 Ok(()) 384 Ok(())
347 } 385 }
348 386
387 #[rstest]
349 #[tokio::test] 388 #[tokio::test]
350 #[serial] 389 #[serial]
351 async fn description() -> Result<()> { 390 async fn description(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
352 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 391 let s = scenario.await;
353 for relay in [&r53, &r55, &r56, &r57] { 392 assert!(
354 let event: &nostr::Event = relay 393 s.event
355 .events 394 .tags
356 .iter() 395 .iter()
357 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) 396 .any(|t| t.as_slice()[0].eq("description")
358 .unwrap(); 397 && t.as_slice()[1].eq("example-description"))
359 398 );
360 assert!(event.tags.iter().any(|t| t.as_slice()[0].eq("description")
361 && t.as_slice()[1].eq("example-description")));
362 }
363 Ok(()) 399 Ok(())
364 } 400 }
365 401
402 #[rstest]
366 #[tokio::test] 403 #[tokio::test]
367 #[serial] 404 #[serial]
368 async fn git_server() -> Result<()> { 405 async fn git_server(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
369 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 406 let s = scenario.await;
370 for relay in [&r53, &r55, &r56, &r57] { 407 assert!(
371 let event: &nostr::Event = relay 408 s.event.tags.iter().any(|t| t.as_slice()[0].eq("clone")
372 .events 409 && t.as_slice()[1].eq("https://git.myhosting.com/my-repo.git")) /* todo check it defaults to origin */
373 .iter() 410 );
374 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement))
375 .unwrap();
376
377 assert!(
378 event.tags.iter().any(|t| t.as_slice()[0].eq("clone")
379 && t.as_slice()[1].eq("https://git.myhosting.com/my-repo.git")) /* todo check it defaults to origin */
380 );
381 }
382 Ok(()) 411 Ok(())
383 } 412 }
384 413
414 #[rstest]
385 #[tokio::test] 415 #[tokio::test]
386 #[serial] 416 #[serial]
387 async fn relays() -> Result<()> { 417 async fn relays(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
388 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 418 let s = scenario.await;
389 for relay in [&r53, &r55, &r56, &r57] { 419 let relays_tag = s
390 let event: &nostr::Event = relay 420 .event
391 .events 421 .tags
392 .iter() 422 .iter()
393 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) 423 .find(|t| t.as_slice()[0].eq("relays"))
394 .unwrap(); 424 .unwrap()
395 let relays_tag = event 425 .as_slice();
396 .tags 426 assert_eq!(relays_tag[1], "ws://localhost:8055",);
397 .iter() 427 assert_eq!(relays_tag[2], "ws://localhost:8056",);
398 .find(|t| t.as_slice()[0].eq("relays"))
399 .unwrap()
400 .as_slice();
401 assert_eq!(relays_tag[1], "ws://localhost:8055",);
402 assert_eq!(relays_tag[2], "ws://localhost:8056",);
403 }
404 Ok(()) 428 Ok(())
405 } 429 }
406 430
431 #[rstest]
407 #[tokio::test] 432 #[tokio::test]
408 #[serial] 433 #[serial]
409 async fn web() -> Result<()> { 434 async fn web(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
410 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 435 let s = scenario.await;
411 for relay in [&r53, &r55, &r56, &r57] { 436 let web_tag = s
412 let event: &nostr::Event = relay 437 .event
413 .events 438 .tags
414 .iter() 439 .iter()
415 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) 440 .find(|t| t.as_slice()[0].eq("web"))
416 .unwrap(); 441 .unwrap()
417 let web_tag = event 442 .as_slice();
418 .tags 443 assert_eq!(web_tag[1], "https://exampleproject.xyz",);
419 .iter() 444 assert_eq!(web_tag[2], "https://gitworkshop.dev/123",);
420 .find(|t| t.as_slice()[0].eq("web"))
421 .unwrap()
422 .as_slice();
423 assert_eq!(web_tag[1], "https://exampleproject.xyz",);
424 assert_eq!(web_tag[2], "https://gitworkshop.dev/123",);
425 }
426 Ok(()) 445 Ok(())
427 } 446 }
428 447
448 #[rstest]
429 #[tokio::test] 449 #[tokio::test]
430 #[serial] 450 #[serial]
431 async fn maintainers() -> Result<()> { 451 async fn maintainers(#[future] scenario: TagsAsSpecifiedScenario) -> Result<()> {
432 let (_, _, r53, r55, r56, r57) = prep_run_init().await?; 452 let s = scenario.await;
433 for relay in [&r53, &r55, &r56, &r57] { 453 let maintainers_tag = s
434 let event: &nostr::Event = relay 454 .event
435 .events 455 .tags
436 .iter() 456 .iter()
437 .find(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) 457 .find(|t| t.as_slice()[0].eq("maintainers"))
438 .unwrap(); 458 .unwrap()
439 let maintainers_tag = event 459 .as_slice();
440 .tags 460 assert_eq!(maintainers_tag[1], TEST_KEY_1_KEYS.public_key().to_string());
441 .iter()
442 .find(|t| t.as_slice()[0].eq("maintainers"))
443 .unwrap()
444 .as_slice();
445 assert_eq!(maintainers_tag[1], TEST_KEY_1_KEYS.public_key().to_string());
446 }
447 Ok(()) 461 Ok(())
448 } 462 }
449 } 463 }
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 17:58:37 +0000