upleb.uk

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

summaryrefslogtreecommitdiff
path: root/tests/list.rs
diff options
context:
space:
mode:
Diffstat (limited to 'tests/list.rs')
-rw-r--r--tests/list.rs975
1 files changed, 975 insertions, 0 deletions
diff --git a/tests/list.rs b/tests/list.rs
new file mode 100644
index 0000000..0d1d4e9
--- /dev/null
+++ b/tests/list.rs
@@ -0,0 +1,975 @@
1use anyhow::Result;
2use futures::join;
3use serial_test::serial;
4use test_utils::{git::GitTestRepo, relay::Relay, *};
5
6static FEATURE_BRANCH_NAME_1: &str = "feature-example-t";
7static FEATURE_BRANCH_NAME_2: &str = "feature-example-f";
8static FEATURE_BRANCH_NAME_3: &str = "feature-example-c";
9static FEATURE_BRANCH_NAME_4: &str = "feature-example-d";
10
11static PR_TITLE_1: &str = "pr a";
12static PR_TITLE_2: &str = "pr b";
13static PR_TITLE_3: &str = "pr c";
14
15fn cli_tester_create_prs() -> Result<GitTestRepo> {
16 let git_repo = GitTestRepo::default();
17 git_repo.populate()?;
18 cli_tester_create_pr(
19 &git_repo,
20 FEATURE_BRANCH_NAME_1,
21 "a",
22 Some((PR_TITLE_1, "pr a description")),
23 )?;
24 cli_tester_create_pr(
25 &git_repo,
26 FEATURE_BRANCH_NAME_2,
27 "b",
28 Some((PR_TITLE_2, "pr b description")),
29 )?;
30 cli_tester_create_pr(
31 &git_repo,
32 FEATURE_BRANCH_NAME_3,
33 "c",
34 Some((PR_TITLE_3, "pr c description")),
35 )?;
36 Ok(git_repo)
37}
38
39fn create_and_populate_branch(
40 test_repo: &GitTestRepo,
41 branch_name: &str,
42 prefix: &str,
43 only_one_commit: bool,
44) -> Result<()> {
45 test_repo.checkout("main")?;
46 test_repo.create_branch(branch_name)?;
47 test_repo.checkout(branch_name)?;
48 std::fs::write(
49 test_repo.dir.join(format!("{}3.md", prefix)),
50 "some content",
51 )?;
52 test_repo.stage_and_commit(format!("add {}3.md", prefix).as_str())?;
53 if !only_one_commit {
54 std::fs::write(
55 test_repo.dir.join(format!("{}4.md", prefix)),
56 "some content",
57 )?;
58 test_repo.stage_and_commit(format!("add {}4.md", prefix).as_str())?;
59 }
60 Ok(())
61}
62
63fn cli_tester_create_pr(
64 test_repo: &GitTestRepo,
65 branch_name: &str,
66 prefix: &str,
67 cover_letter_title_and_description: Option<(&str, &str)>,
68) -> Result<()> {
69 create_and_populate_branch(test_repo, branch_name, prefix, false)?;
70
71 if let Some((title, description)) = cover_letter_title_and_description {
72 let mut p = CliTester::new_from_dir(
73 &test_repo.dir,
74 [
75 "--nsec",
76 TEST_KEY_1_NSEC,
77 "--password",
78 TEST_PASSWORD,
79 "--disable-cli-spinners",
80 "send",
81 "--title",
82 format!("\"{title}\"").as_str(),
83 "--description",
84 format!("\"{description}\"").as_str(),
85 ],
86 );
87 p.expect_end_eventually()?;
88 } else {
89 let mut p = CliTester::new_from_dir(
90 &test_repo.dir,
91 [
92 "--nsec",
93 TEST_KEY_1_NSEC,
94 "--password",
95 TEST_PASSWORD,
96 "--disable-cli-spinners",
97 "send",
98 "--no-cover-letter",
99 ],
100 );
101 p.expect_end_eventually()?;
102 }
103 Ok(())
104}
105
106mod when_main_branch_is_uptodate {
107 use super::*;
108
109 mod when_pr_branch_doesnt_exist {
110 use super::*;
111
112 mod when_main_is_checked_out {
113 use super::*;
114
115 mod when_first_pr_selected {
116 use super::*;
117
118 // TODO: test when other prs with the same name but from other repositories are
119 // present on relays
120 async fn prep_and_run() -> Result<(GitTestRepo, GitTestRepo)> {
121 // fallback (51,52) user write (53, 55) repo (55, 56)
122 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
123 Relay::new(8051, None, None),
124 Relay::new(8052, None, None),
125 Relay::new(8053, None, None),
126 Relay::new(8055, None, None),
127 Relay::new(8056, None, None),
128 );
129
130 r51.events.push(generate_test_key_1_relay_list_event());
131 r51.events.push(generate_test_key_1_metadata_event("fred"));
132 r51.events.push(generate_repo_ref_event());
133
134 r55.events.push(generate_repo_ref_event());
135 r55.events.push(generate_test_key_1_metadata_event("fred"));
136 r55.events.push(generate_test_key_1_relay_list_event());
137
138 let cli_tester_handle =
139 std::thread::spawn(move || -> Result<(GitTestRepo, GitTestRepo)> {
140 let originating_repo = cli_tester_create_prs()?;
141
142 let test_repo = GitTestRepo::default();
143 test_repo.populate()?;
144 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
145
146 p.expect("finding PRs...\r\n")?;
147 let mut c = p.expect_choice(
148 "All PRs",
149 vec![
150 format!("\"{PR_TITLE_1}\""),
151 format!("\"{PR_TITLE_2}\""),
152 format!("\"{PR_TITLE_3}\""),
153 ],
154 )?;
155 c.succeeds_with(0, true)?;
156 let mut confirm =
157 p.expect_confirm_eventually("check out branch?", Some(true))?;
158 confirm.succeeds_with(None)?;
159 p.expect_end_eventually_and_print()?;
160
161 for p in [51, 52, 53, 55, 56] {
162 relay::shutdown_relay(8000 + p)?;
163 }
164 Ok((originating_repo, test_repo))
165 });
166
167 // launch relay
168 let _ = join!(
169 r51.listen_until_close(),
170 r52.listen_until_close(),
171 r53.listen_until_close(),
172 r55.listen_until_close(),
173 r56.listen_until_close(),
174 );
175 let res = cli_tester_handle.join().unwrap()?;
176
177 Ok(res)
178 }
179
180 mod cli_prompts {
181 use super::*;
182 async fn run_async_prompts_to_choose_from_pr_titles() -> Result<()> {
183 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
184 Relay::new(8051, None, None),
185 Relay::new(8052, None, None),
186 Relay::new(8053, None, None),
187 Relay::new(8055, None, None),
188 Relay::new(8056, None, None),
189 );
190
191 r51.events.push(generate_test_key_1_relay_list_event());
192 r51.events.push(generate_test_key_1_metadata_event("fred"));
193 r51.events.push(generate_repo_ref_event());
194
195 r55.events.push(generate_repo_ref_event());
196 r55.events.push(generate_test_key_1_metadata_event("fred"));
197 r55.events.push(generate_test_key_1_relay_list_event());
198
199 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
200 cli_tester_create_prs()?;
201
202 let test_repo = GitTestRepo::default();
203 test_repo.populate()?;
204 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
205
206 p.expect("finding PRs...\r\n")?;
207 let mut c = p.expect_choice(
208 "All PRs",
209 vec![
210 format!("\"{PR_TITLE_1}\""),
211 format!("\"{PR_TITLE_2}\""),
212 format!("\"{PR_TITLE_3}\""),
213 ],
214 )?;
215 c.succeeds_with(0, true)?;
216 p.expect("finding commits...\r\n")?;
217 let mut confirm = p.expect_confirm("check out branch?", Some(true))?;
218 confirm.succeeds_with(None)?;
219 p.expect("checked out PR branch. pulled 2 new commits\r\n")?;
220 p.expect_end()?;
221
222 for p in [51, 52, 53, 55, 56] {
223 relay::shutdown_relay(8000 + p)?;
224 }
225 Ok(())
226 });
227
228 // launch relay
229 let _ = join!(
230 r51.listen_until_close(),
231 r52.listen_until_close(),
232 r53.listen_until_close(),
233 r55.listen_until_close(),
234 r56.listen_until_close(),
235 );
236 cli_tester_handle.join().unwrap()?;
237 println!("{:?}", r55.events);
238 Ok(())
239 }
240
241 #[tokio::test]
242 #[serial]
243 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
244 let _ = run_async_prompts_to_choose_from_pr_titles().await;
245 Ok(())
246 }
247 }
248
249 #[tokio::test]
250 #[serial]
251 async fn pr_branch_created_with_correct_name() -> Result<()> {
252 let (_, test_repo) = prep_and_run().await?;
253 assert_eq!(
254 vec![FEATURE_BRANCH_NAME_1, "main"],
255 test_repo.get_local_branch_names()?
256 );
257 Ok(())
258 }
259
260 #[tokio::test]
261 #[serial]
262 async fn pr_branch_checked_out() -> Result<()> {
263 let (_, test_repo) = prep_and_run().await?;
264 assert_eq!(
265 FEATURE_BRANCH_NAME_1,
266 test_repo.get_checked_out_branch_name()?,
267 );
268 Ok(())
269 }
270
271 #[tokio::test]
272 #[serial]
273 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
274 let (originating_repo, test_repo) = prep_and_run().await?;
275 assert_eq!(
276 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
277 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
278 );
279 Ok(())
280 }
281 }
282 mod when_third_pr_selected {
283 use super::*;
284
285 async fn prep_and_run() -> Result<(GitTestRepo, GitTestRepo)> {
286 // fallback (51,52) user write (53, 55) repo (55, 56)
287 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
288 Relay::new(8051, None, None),
289 Relay::new(8052, None, None),
290 Relay::new(8053, None, None),
291 Relay::new(8055, None, None),
292 Relay::new(8056, None, None),
293 );
294
295 r51.events.push(generate_test_key_1_relay_list_event());
296 r51.events.push(generate_test_key_1_metadata_event("fred"));
297 r51.events.push(generate_repo_ref_event());
298
299 r55.events.push(generate_repo_ref_event());
300 r55.events.push(generate_test_key_1_metadata_event("fred"));
301 r55.events.push(generate_test_key_1_relay_list_event());
302
303 let cli_tester_handle =
304 std::thread::spawn(move || -> Result<(GitTestRepo, GitTestRepo)> {
305 let originating_repo = cli_tester_create_prs()?;
306
307 let test_repo = GitTestRepo::default();
308 test_repo.populate()?;
309 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
310
311 p.expect("finding PRs...\r\n")?;
312 let mut c = p.expect_choice(
313 "All PRs",
314 vec![
315 format!("\"{PR_TITLE_1}\""),
316 format!("\"{PR_TITLE_2}\""),
317 format!("\"{PR_TITLE_3}\""),
318 ],
319 )?;
320 c.succeeds_with(2, true)?;
321 let mut confirm =
322 p.expect_confirm_eventually("check out branch?", Some(true))?;
323 confirm.succeeds_with(None)?;
324 p.expect_end_eventually_and_print()?;
325
326 for p in [51, 52, 53, 55, 56] {
327 relay::shutdown_relay(8000 + p)?;
328 }
329 Ok((originating_repo, test_repo))
330 });
331
332 // launch relay
333 let _ = join!(
334 r51.listen_until_close(),
335 r52.listen_until_close(),
336 r53.listen_until_close(),
337 r55.listen_until_close(),
338 r56.listen_until_close(),
339 );
340 let res = cli_tester_handle.join().unwrap()?;
341
342 Ok(res)
343 }
344
345 mod cli_prompts {
346 use super::*;
347 async fn run_async_prompts_to_choose_from_pr_titles() -> Result<()> {
348 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
349 Relay::new(8051, None, None),
350 Relay::new(8052, None, None),
351 Relay::new(8053, None, None),
352 Relay::new(8055, None, None),
353 Relay::new(8056, None, None),
354 );
355
356 r51.events.push(generate_test_key_1_relay_list_event());
357 r51.events.push(generate_test_key_1_metadata_event("fred"));
358 r51.events.push(generate_repo_ref_event());
359
360 r55.events.push(generate_repo_ref_event());
361 r55.events.push(generate_test_key_1_metadata_event("fred"));
362 r55.events.push(generate_test_key_1_relay_list_event());
363
364 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
365 cli_tester_create_prs()?;
366
367 let test_repo = GitTestRepo::default();
368 test_repo.populate()?;
369 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
370
371 p.expect("finding PRs...\r\n")?;
372 let mut c = p.expect_choice(
373 "All PRs",
374 vec![
375 format!("\"{PR_TITLE_1}\""),
376 format!("\"{PR_TITLE_2}\""),
377 format!("\"{PR_TITLE_3}\""),
378 ],
379 )?;
380 c.succeeds_with(2, true)?;
381 p.expect("finding commits...\r\n")?;
382 let mut confirm = p.expect_confirm("check out branch?", Some(true))?;
383 confirm.succeeds_with(None)?;
384 p.expect("checked out PR branch. pulled 2 new commits\r\n")?;
385 p.expect_end()?;
386
387 for p in [51, 52, 53, 55, 56] {
388 relay::shutdown_relay(8000 + p)?;
389 }
390 Ok(())
391 });
392
393 // launch relay
394 let _ = join!(
395 r51.listen_until_close(),
396 r52.listen_until_close(),
397 r53.listen_until_close(),
398 r55.listen_until_close(),
399 r56.listen_until_close(),
400 );
401 cli_tester_handle.join().unwrap()?;
402 println!("{:?}", r55.events);
403 Ok(())
404 }
405
406 #[tokio::test]
407 #[serial]
408 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
409 let _ = run_async_prompts_to_choose_from_pr_titles().await;
410 Ok(())
411 }
412 }
413
414 #[tokio::test]
415 #[serial]
416 async fn pr_branch_created_with_correct_name() -> Result<()> {
417 let (_, test_repo) = prep_and_run().await?;
418 assert_eq!(
419 vec![FEATURE_BRANCH_NAME_3, "main"],
420 test_repo.get_local_branch_names()?
421 );
422 Ok(())
423 }
424
425 #[tokio::test]
426 #[serial]
427 async fn pr_branch_checked_out() -> Result<()> {
428 let (_, test_repo) = prep_and_run().await?;
429 assert_eq!(
430 FEATURE_BRANCH_NAME_3,
431 test_repo.get_checked_out_branch_name()?,
432 );
433 Ok(())
434 }
435
436 #[tokio::test]
437 #[serial]
438 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
439 let (originating_repo, test_repo) = prep_and_run().await?;
440 assert_eq!(
441 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?,
442 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?,
443 );
444 Ok(())
445 }
446 }
447 mod when_forth_pr_has_no_cover_letter {
448 use super::*;
449
450 async fn prep_and_run() -> Result<(GitTestRepo, GitTestRepo)> {
451 // fallback (51,52) user write (53, 55) repo (55, 56)
452 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
453 Relay::new(8051, None, None),
454 Relay::new(8052, None, None),
455 Relay::new(8053, None, None),
456 Relay::new(8055, None, None),
457 Relay::new(8056, None, None),
458 );
459
460 r51.events.push(generate_test_key_1_relay_list_event());
461 r51.events.push(generate_test_key_1_metadata_event("fred"));
462 r51.events.push(generate_repo_ref_event());
463
464 r55.events.push(generate_repo_ref_event());
465 r55.events.push(generate_test_key_1_metadata_event("fred"));
466 r55.events.push(generate_test_key_1_relay_list_event());
467
468 let cli_tester_handle =
469 std::thread::spawn(move || -> Result<(GitTestRepo, GitTestRepo)> {
470 let originating_repo = cli_tester_create_prs()?;
471 cli_tester_create_pr(
472 &originating_repo,
473 FEATURE_BRANCH_NAME_4,
474 "d",
475 None,
476 )?;
477 let test_repo = GitTestRepo::default();
478 test_repo.populate()?;
479 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
480
481 p.expect("finding PRs...\r\n")?;
482 let mut c = p.expect_choice(
483 "All PRs",
484 vec![
485 format!("\"{PR_TITLE_1}\""),
486 format!("\"{PR_TITLE_2}\""),
487 format!("\"{PR_TITLE_3}\""),
488 format!("add d3.md"), // commit msg title
489 ],
490 )?;
491 c.succeeds_with(3, true)?;
492 let mut confirm =
493 p.expect_confirm_eventually("check out branch?", Some(true))?;
494 confirm.succeeds_with(None)?;
495 p.expect_end_eventually_and_print()?;
496
497 for p in [51, 52, 53, 55, 56] {
498 relay::shutdown_relay(8000 + p)?;
499 }
500 Ok((originating_repo, test_repo))
501 });
502
503 // launch relay
504 let _ = join!(
505 r51.listen_until_close(),
506 r52.listen_until_close(),
507 r53.listen_until_close(),
508 r55.listen_until_close(),
509 r56.listen_until_close(),
510 );
511 let res = cli_tester_handle.join().unwrap()?;
512
513 Ok(res)
514 }
515
516 mod cli_prompts {
517 use super::*;
518 async fn run_async_prompts_to_choose_from_pr_titles() -> Result<()> {
519 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
520 Relay::new(8051, None, None),
521 Relay::new(8052, None, None),
522 Relay::new(8053, None, None),
523 Relay::new(8055, None, None),
524 Relay::new(8056, None, None),
525 );
526
527 r51.events.push(generate_test_key_1_relay_list_event());
528 r51.events.push(generate_test_key_1_metadata_event("fred"));
529 r51.events.push(generate_repo_ref_event());
530
531 r55.events.push(generate_repo_ref_event());
532 r55.events.push(generate_test_key_1_metadata_event("fred"));
533 r55.events.push(generate_test_key_1_relay_list_event());
534
535 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
536 let originating_repo = cli_tester_create_prs()?;
537 cli_tester_create_pr(
538 &originating_repo,
539 FEATURE_BRANCH_NAME_4,
540 "d",
541 None,
542 )?;
543 let test_repo = GitTestRepo::default();
544 test_repo.populate()?;
545 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
546
547 p.expect("finding PRs...\r\n")?;
548 let mut c = p.expect_choice(
549 "All PRs",
550 vec![
551 format!("\"{PR_TITLE_1}\""),
552 format!("\"{PR_TITLE_2}\""),
553 format!("\"{PR_TITLE_3}\""),
554 format!("add d3.md"), // commit msg title
555 ],
556 )?;
557 c.succeeds_with(3, true)?;
558 p.expect("finding commits...\r\n")?;
559 let mut confirm = p.expect_confirm("check out branch?", Some(true))?;
560 confirm.succeeds_with(None)?;
561 p.expect("checked out PR branch. pulled 2 new commits\r\n")?;
562 p.expect_end()?;
563
564 for p in [51, 52, 53, 55, 56] {
565 relay::shutdown_relay(8000 + p)?;
566 }
567 Ok(())
568 });
569
570 // launch relay
571 let _ = join!(
572 r51.listen_until_close(),
573 r52.listen_until_close(),
574 r53.listen_until_close(),
575 r55.listen_until_close(),
576 r56.listen_until_close(),
577 );
578 cli_tester_handle.join().unwrap()?;
579 println!("{:?}", r55.events);
580 Ok(())
581 }
582
583 #[tokio::test]
584 #[serial]
585 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
586 let _ = run_async_prompts_to_choose_from_pr_titles().await;
587 Ok(())
588 }
589 }
590
591 #[tokio::test]
592 #[serial]
593 async fn pr_branch_created_with_correct_name() -> Result<()> {
594 let (_, test_repo) = prep_and_run().await?;
595 assert_eq!(
596 vec![FEATURE_BRANCH_NAME_4, "main"],
597 test_repo.get_local_branch_names()?
598 );
599 Ok(())
600 }
601
602 #[tokio::test]
603 #[serial]
604 async fn pr_branch_checked_out() -> Result<()> {
605 let (_, test_repo) = prep_and_run().await?;
606 assert_eq!(
607 FEATURE_BRANCH_NAME_4,
608 test_repo.get_checked_out_branch_name()?,
609 );
610 Ok(())
611 }
612
613 #[tokio::test]
614 #[serial]
615 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
616 let (originating_repo, test_repo) = prep_and_run().await?;
617 assert_eq!(
618 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_4)?,
619 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_4)?,
620 );
621 Ok(())
622 }
623 }
624 }
625 }
626
627 mod when_pr_branch_exists {
628 use super::*;
629
630 mod when_main_is_checked_out {
631 use super::*;
632
633 mod when_branch_is_up_to_date {
634 use super::*;
635 async fn prep_and_run() -> Result<(GitTestRepo, GitTestRepo)> {
636 // fallback (51,52) user write (53, 55) repo (55, 56)
637 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
638 Relay::new(8051, None, None),
639 Relay::new(8052, None, None),
640 Relay::new(8053, None, None),
641 Relay::new(8055, None, None),
642 Relay::new(8056, None, None),
643 );
644
645 r51.events.push(generate_test_key_1_relay_list_event());
646 r51.events.push(generate_test_key_1_metadata_event("fred"));
647 r51.events.push(generate_repo_ref_event());
648
649 r55.events.push(generate_repo_ref_event());
650 r55.events.push(generate_test_key_1_metadata_event("fred"));
651 r55.events.push(generate_test_key_1_relay_list_event());
652
653 let cli_tester_handle =
654 std::thread::spawn(move || -> Result<(GitTestRepo, GitTestRepo)> {
655 let originating_repo = cli_tester_create_prs()?;
656
657 let test_repo = GitTestRepo::default();
658 test_repo.populate()?;
659 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
660
661 create_and_populate_branch(
662 &test_repo,
663 FEATURE_BRANCH_NAME_1,
664 "a",
665 false,
666 )?;
667 test_repo.checkout("main")?;
668 p.expect("finding PRs...\r\n")?;
669 let mut c = p.expect_choice(
670 "All PRs",
671 vec![
672 format!("\"{PR_TITLE_1}\""),
673 format!("\"{PR_TITLE_2}\""),
674 format!("\"{PR_TITLE_3}\""),
675 ],
676 )?;
677 c.succeeds_with(0, true)?;
678 let mut confirm =
679 p.expect_confirm_eventually("check out branch?", Some(true))?;
680 confirm.succeeds_with(None)?;
681 p.expect_end_eventually_and_print()?;
682
683 for p in [51, 52, 53, 55, 56] {
684 relay::shutdown_relay(8000 + p)?;
685 }
686 Ok((originating_repo, test_repo))
687 });
688
689 // launch relay
690 let _ = join!(
691 r51.listen_until_close(),
692 r52.listen_until_close(),
693 r53.listen_until_close(),
694 r55.listen_until_close(),
695 r56.listen_until_close(),
696 );
697 let res = cli_tester_handle.join().unwrap()?;
698
699 Ok(res)
700 }
701
702 mod cli_prompts {
703 use super::*;
704 async fn run_async_prompts_to_choose_from_pr_titles() -> Result<()> {
705 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
706 Relay::new(8051, None, None),
707 Relay::new(8052, None, None),
708 Relay::new(8053, None, None),
709 Relay::new(8055, None, None),
710 Relay::new(8056, None, None),
711 );
712
713 r51.events.push(generate_test_key_1_relay_list_event());
714 r51.events.push(generate_test_key_1_metadata_event("fred"));
715 r51.events.push(generate_repo_ref_event());
716
717 r55.events.push(generate_repo_ref_event());
718 r55.events.push(generate_test_key_1_metadata_event("fred"));
719 r55.events.push(generate_test_key_1_relay_list_event());
720
721 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
722 cli_tester_create_prs()?;
723
724 let test_repo = GitTestRepo::default();
725 test_repo.populate()?;
726 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
727
728 create_and_populate_branch(
729 &test_repo,
730 FEATURE_BRANCH_NAME_1,
731 "a",
732 false,
733 )?;
734 test_repo.checkout("main")?;
735
736 p.expect("finding PRs...\r\n")?;
737 let mut c = p.expect_choice(
738 "All PRs",
739 vec![
740 format!("\"{PR_TITLE_1}\""),
741 format!("\"{PR_TITLE_2}\""),
742 format!("\"{PR_TITLE_3}\""),
743 ],
744 )?;
745 c.succeeds_with(0, true)?;
746 p.expect("finding commits...\r\n")?;
747 let mut confirm = p.expect_confirm("check out branch?", Some(true))?;
748 confirm.succeeds_with(None)?;
749 p.expect("checked out PR branch. no new commits to pull\r\n")?;
750 p.expect_end()?;
751
752 for p in [51, 52, 53, 55, 56] {
753 relay::shutdown_relay(8000 + p)?;
754 }
755 Ok(())
756 });
757
758 // launch relay
759 let _ = join!(
760 r51.listen_until_close(),
761 r52.listen_until_close(),
762 r53.listen_until_close(),
763 r55.listen_until_close(),
764 r56.listen_until_close(),
765 );
766 cli_tester_handle.join().unwrap()?;
767 println!("{:?}", r55.events);
768 Ok(())
769 }
770
771 #[tokio::test]
772 #[serial]
773 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
774 let _ = run_async_prompts_to_choose_from_pr_titles().await;
775 Ok(())
776 }
777 }
778
779 #[tokio::test]
780 #[serial]
781 async fn pr_branch_checked_out() -> Result<()> {
782 let (_, test_repo) = prep_and_run().await?;
783 assert_eq!(
784 FEATURE_BRANCH_NAME_1,
785 test_repo.get_checked_out_branch_name()?,
786 );
787 Ok(())
788 }
789 }
790
791 mod when_branch_is_behind {
792 use super::*;
793
794 async fn prep_and_run() -> Result<(GitTestRepo, GitTestRepo)> {
795 // fallback (51,52) user write (53, 55) repo (55, 56)
796 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
797 Relay::new(8051, None, None),
798 Relay::new(8052, None, None),
799 Relay::new(8053, None, None),
800 Relay::new(8055, None, None),
801 Relay::new(8056, None, None),
802 );
803
804 r51.events.push(generate_test_key_1_relay_list_event());
805 r51.events.push(generate_test_key_1_metadata_event("fred"));
806 r51.events.push(generate_repo_ref_event());
807
808 r55.events.push(generate_repo_ref_event());
809 r55.events.push(generate_test_key_1_metadata_event("fred"));
810 r55.events.push(generate_test_key_1_relay_list_event());
811
812 let cli_tester_handle =
813 std::thread::spawn(move || -> Result<(GitTestRepo, GitTestRepo)> {
814 let originating_repo = cli_tester_create_prs()?;
815
816 let test_repo = GitTestRepo::default();
817 test_repo.populate()?;
818 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
819
820 create_and_populate_branch(
821 &test_repo,
822 FEATURE_BRANCH_NAME_1,
823 "a",
824 true,
825 )?;
826 test_repo.checkout("main")?;
827
828 p.expect("finding PRs...\r\n")?;
829 let mut c = p.expect_choice(
830 "All PRs",
831 vec![
832 format!("\"{PR_TITLE_1}\""),
833 format!("\"{PR_TITLE_2}\""),
834 format!("\"{PR_TITLE_3}\""),
835 ],
836 )?;
837 c.succeeds_with(0, true)?;
838 let mut confirm =
839 p.expect_confirm_eventually("check out branch?", Some(true))?;
840 confirm.succeeds_with(None)?;
841 p.expect_end_eventually_and_print()?;
842
843 for p in [51, 52, 53, 55, 56] {
844 relay::shutdown_relay(8000 + p)?;
845 }
846 Ok((originating_repo, test_repo))
847 });
848
849 // launch relay
850 let _ = join!(
851 r51.listen_until_close(),
852 r52.listen_until_close(),
853 r53.listen_until_close(),
854 r55.listen_until_close(),
855 r56.listen_until_close(),
856 );
857 let res = cli_tester_handle.join().unwrap()?;
858
859 Ok(res)
860 }
861
862 mod cli_prompts {
863 use super::*;
864 async fn run_async_prompts_to_choose_from_pr_titles() -> Result<()> {
865 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
866 Relay::new(8051, None, None),
867 Relay::new(8052, None, None),
868 Relay::new(8053, None, None),
869 Relay::new(8055, None, None),
870 Relay::new(8056, None, None),
871 );
872
873 r51.events.push(generate_test_key_1_relay_list_event());
874 r51.events.push(generate_test_key_1_metadata_event("fred"));
875 r51.events.push(generate_repo_ref_event());
876
877 r55.events.push(generate_repo_ref_event());
878 r55.events.push(generate_test_key_1_metadata_event("fred"));
879 r55.events.push(generate_test_key_1_relay_list_event());
880
881 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
882 cli_tester_create_prs()?;
883
884 let test_repo = GitTestRepo::default();
885 test_repo.populate()?;
886 let mut p = CliTester::new_from_dir(&test_repo.dir, ["list"]);
887
888 create_and_populate_branch(
889 &test_repo,
890 FEATURE_BRANCH_NAME_1,
891 "a",
892 true,
893 )?;
894 test_repo.checkout("main")?;
895
896 p.expect("finding PRs...\r\n")?;
897 let mut c = p.expect_choice(
898 "All PRs",
899 vec![
900 format!("\"{PR_TITLE_1}\""),
901 format!("\"{PR_TITLE_2}\""),
902 format!("\"{PR_TITLE_3}\""),
903 ],
904 )?;
905 c.succeeds_with(0, true)?;
906 p.expect("finding commits...\r\n")?;
907 let mut confirm = p.expect_confirm("check out branch?", Some(true))?;
908 confirm.succeeds_with(None)?;
909 p.expect("checked out PR branch. pulled 1 new commits\r\n")?;
910 p.expect_end()?;
911
912 for p in [51, 52, 53, 55, 56] {
913 relay::shutdown_relay(8000 + p)?;
914 }
915 Ok(())
916 });
917
918 // launch relay
919 let _ = join!(
920 r51.listen_until_close(),
921 r52.listen_until_close(),
922 r53.listen_until_close(),
923 r55.listen_until_close(),
924 r56.listen_until_close(),
925 );
926 cli_tester_handle.join().unwrap()?;
927 println!("{:?}", r55.events);
928 Ok(())
929 }
930
931 #[tokio::test]
932 #[serial]
933 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
934 let _ = run_async_prompts_to_choose_from_pr_titles().await;
935 Ok(())
936 }
937 }
938
939 #[tokio::test]
940 #[serial]
941 async fn pr_branch_checked_out() -> Result<()> {
942 let (_, test_repo) = prep_and_run().await?;
943 assert_eq!(
944 FEATURE_BRANCH_NAME_1,
945 test_repo.get_checked_out_branch_name()?,
946 );
947 Ok(())
948 }
949
950 #[tokio::test]
951 #[serial]
952 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
953 let (originating_repo, test_repo) = prep_and_run().await?;
954 assert_eq!(
955 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
956 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
957 );
958 Ok(())
959 }
960 }
961
962 mod when_branch_is_ahead {
963 // use super::*;
964 // TODO latest commit in pr builds off an older commit in pr
965 // instead of previous.
966 // TODO current git user created commit on branch
967 }
968
969 mod when_latest_event_rebases_branch {
970 // use super::*;
971 // TODO
972 }
973 }
974 }
975}
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 02:03:56 +0000