upleb.uk

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

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