Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
334
crates/luxe-tui/src/app/commands/tests/github.rs
Normal file
334
crates/luxe-tui/src/app/commands/tests/github.rs
Normal file
@@ -0,0 +1,334 @@
|
||||
//! GitHub posts — a review posted to a pull request, and the conversation read back.
|
||||
|
||||
use super::*;
|
||||
|
||||
/// A post fixture with its engine channel in hand, and the post's request id.
|
||||
pub(super) fn post_fixture(
|
||||
) -> (App, mpsc::Receiver<Action>, luxe_core::guided_review::PullRequestPostId) {
|
||||
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewPullRequestPost)
|
||||
.expect("pull request post fixture");
|
||||
let (engine_tx, engine_rx) = mpsc::channel(8);
|
||||
app.engine_tx = engine_tx;
|
||||
let request_id =
|
||||
app.guided_review_workspace.github_post.as_ref().expect("post preview").request_id.clone();
|
||||
(app, engine_rx, request_id)
|
||||
}
|
||||
|
||||
/// A pull request's review finishes on GitHub: Alt+Enter asks GitHub what the preview needs rather
|
||||
/// than opening the local finish choices, and Alt+U offers to check it out for the agent.
|
||||
#[test]
|
||||
fn finishing_a_pull_request_review_asks_github_and_alt_u_offers_a_worktree() {
|
||||
let mut app =
|
||||
seeded_app("nord", FixtureScenario::GuidedReviewPullRequest).expect("pull request fixture");
|
||||
let (engine_tx, mut engine_rx) = mpsc::channel(8);
|
||||
app.engine_tx = engine_tx;
|
||||
|
||||
assert!(dispatch_action(&mut app, UiAction::ReviewFinish));
|
||||
|
||||
assert!(app.guided_review_workspace.finish_review_choice.is_none());
|
||||
let post = app.guided_review_workspace.github_post.as_ref().expect("post preview");
|
||||
assert!(post.prepared.is_none(), "nothing to preview until GitHub answers");
|
||||
let Ok(Action::PreparePullRequestPost { request_id, .. }) = engine_rx.try_recv() else {
|
||||
panic!("expected the engine to be asked");
|
||||
};
|
||||
assert_eq!(request_id, post.request_id);
|
||||
|
||||
// Alt+U cannot reach an agent that has not got the code: it offers to check it out instead
|
||||
app.guided_review_workspace.github_post = None;
|
||||
app.update(crate::app::Msg::GuidedReviewOpenSendPreview);
|
||||
assert!(app.guided_review_workspace.send_preview.is_none());
|
||||
assert!(app.guided_review_workspace.pull_request_fix.is_some());
|
||||
}
|
||||
|
||||
/// Confirming names the preview it shows, with the verdict on screen and the session revision the
|
||||
/// preview was drawn from, so the engine posts that and nothing else; it plans the post with the
|
||||
/// same function over the same comments, and refuses if they moved. While it is in flight the
|
||||
/// dialog cannot be closed, since closing it would drop the answer that says where it landed.
|
||||
#[test]
|
||||
fn confirming_posts_the_preview_it_shows_and_holds_the_dialog_open() {
|
||||
let (mut app, mut engine_rx, prepared) = post_fixture();
|
||||
assert!(crate::app::github_post_plan(&app).expect("prepared").is_ok(), "postable");
|
||||
let verdict = app.guided_review_workspace.github_post.as_ref().expect("preview").verdict;
|
||||
let revision = app.review.session().expect("session").revision;
|
||||
|
||||
app.update(crate::app::Msg::GuidedReviewConfirmGithubPost);
|
||||
|
||||
let Ok(Action::PostPullRequestReview { request_id, verdict: sent, session_revision }) =
|
||||
engine_rx.try_recv()
|
||||
else {
|
||||
panic!("expected a post");
|
||||
};
|
||||
assert_eq!(request_id, prepared, "the preview the engine read, not a new attempt");
|
||||
assert_eq!(sent, verdict);
|
||||
assert_eq!(session_revision, revision);
|
||||
|
||||
app.update(crate::app::Msg::GuidedReviewCancelGithubPost);
|
||||
assert!(app.guided_review_workspace.github_post.as_ref().is_some_and(|post| post.posting));
|
||||
app.update(crate::app::Msg::GuidedReviewConfirmGithubPost);
|
||||
assert!(engine_rx.try_recv().is_err(), "a second press does not post twice");
|
||||
}
|
||||
|
||||
/// GitHub refuses an author's verdict on their own pull request, so the preview offers a comment
|
||||
/// and nothing else once it knows.
|
||||
#[test]
|
||||
fn an_authors_own_pull_request_offers_only_a_comment() {
|
||||
let (mut app, _engine_rx, _) = post_fixture();
|
||||
let post = app.guided_review_workspace.github_post.as_mut().expect("post preview");
|
||||
post.prepared = None;
|
||||
let request_id = post.request_id.clone();
|
||||
|
||||
app.update(crate::app::Msg::Engine(luxe_core::event::Event::PullRequestPostPrepared {
|
||||
request_id,
|
||||
patches: Vec::new(),
|
||||
head_moved: false,
|
||||
own_pull_request: true,
|
||||
}));
|
||||
app.update(crate::app::Msg::GuidedReviewMoveGithubVerdict(true));
|
||||
|
||||
let post = app.guided_review_workspace.github_post.as_ref().expect("post preview");
|
||||
assert_eq!(post.verdict, luxe_core::github::ReviewEvent::Comment);
|
||||
assert_eq!(post.verdicts(), &[luxe_core::github::ReviewEvent::Comment]);
|
||||
}
|
||||
|
||||
/// A post that landed marks what it carried and records the verdict, in one save; an answer for an
|
||||
/// attempt nobody is waiting on changes nothing.
|
||||
#[test]
|
||||
fn a_landed_post_marks_its_comments_and_a_stale_answer_is_ignored() {
|
||||
let (mut app, mut engine_rx, _) = post_fixture();
|
||||
let shown = crate::app::github_post_plan(&app).expect("prepared").expect("postable");
|
||||
let finding_ids: Vec<_> = shown.placed.iter().map(|placed| placed.finding_id.clone()).collect();
|
||||
app.update(crate::app::Msg::GuidedReviewConfirmGithubPost);
|
||||
let Ok(Action::PostPullRequestReview { request_id, .. }) = engine_rx.try_recv() else {
|
||||
panic!("expected a post");
|
||||
};
|
||||
|
||||
app.update(crate::app::Msg::Engine(luxe_core::event::Event::PullRequestReviewPosted {
|
||||
request_id: luxe_core::guided_review::PullRequestPostId::new(),
|
||||
github_review_id: 1,
|
||||
url: "https://example.invalid/stale".into(),
|
||||
finding_ids: finding_ids.clone(),
|
||||
}));
|
||||
assert!(engine_rx.try_recv().is_err(), "a stale answer saves nothing");
|
||||
assert!(app.guided_review_workspace.github_post.is_some());
|
||||
|
||||
let url = "https://github.com/acme/notify/pull/42#pullrequestreview-9".to_owned();
|
||||
app.update(crate::app::Msg::Engine(luxe_core::event::Event::PullRequestReviewPosted {
|
||||
request_id,
|
||||
github_review_id: 9,
|
||||
url: url.clone(),
|
||||
finding_ids: finding_ids.clone(),
|
||||
}));
|
||||
|
||||
assert!(app.guided_review_workspace.github_post.is_none());
|
||||
assert_eq!(app.guided_review_workspace.posted_review_url.as_deref(), Some(url.as_str()));
|
||||
// The engine marked what went and recorded the verdict as it posted; the TUI sends nothing,
|
||||
// and takes the marks when the desk's save arrives
|
||||
assert!(engine_rx.try_recv().is_err());
|
||||
assert!(!finding_ids.is_empty());
|
||||
}
|
||||
|
||||
/// A failure keeps the preview open with GitHub's reason, and posting again is allowed.
|
||||
#[test]
|
||||
fn a_failed_post_says_why_and_can_be_tried_again() {
|
||||
let (mut app, mut engine_rx, _) = post_fixture();
|
||||
app.update(crate::app::Msg::GuidedReviewConfirmGithubPost);
|
||||
let Ok(Action::PostPullRequestReview { request_id, .. }) = engine_rx.try_recv() else {
|
||||
panic!("expected a post");
|
||||
};
|
||||
|
||||
app.update(crate::app::Msg::Engine(luxe_core::event::Event::PullRequestPostFailed {
|
||||
request_id,
|
||||
message: "GitHub refused the review: Line could not be resolved.".into(),
|
||||
}));
|
||||
|
||||
let post = app.guided_review_workspace.github_post.as_ref().expect("still open");
|
||||
assert!(!post.posting);
|
||||
assert!(post.error.as_deref().is_some_and(|error| error.contains("Line could not")));
|
||||
app.update(crate::app::Msg::GuidedReviewConfirmGithubPost);
|
||||
assert!(matches!(engine_rx.try_recv(), Ok(Action::PostPullRequestReview { .. })));
|
||||
}
|
||||
|
||||
/// Requesting changes with nothing to say is refused before anything is sent.
|
||||
#[test]
|
||||
fn requesting_changes_without_a_summary_sends_nothing() {
|
||||
let (mut app, mut engine_rx, _) = post_fixture();
|
||||
let session = app.review.session_mut().expect("session");
|
||||
session.findings.retain(|finding| {
|
||||
!matches!(finding.anchor, luxe_core::guided_review::FindingAnchor::Review)
|
||||
|| finding.severity == luxe_core::guided_review::FindingSeverity::Question
|
||||
});
|
||||
|
||||
app.update(crate::app::Msg::GuidedReviewConfirmGithubPost);
|
||||
|
||||
assert!(engine_rx.try_recv().is_err());
|
||||
assert!(!app.guided_review_workspace.github_post.as_ref().expect("open").posting);
|
||||
assert!(
|
||||
app.status.toast().is_some_and(|toast| toast.starts_with("Requesting changes needs")),
|
||||
"{:?}",
|
||||
app.status.toast()
|
||||
);
|
||||
}
|
||||
|
||||
/// The verdict steps through what is on offer both ways and wraps at either end.
|
||||
#[test]
|
||||
fn the_verdict_steps_both_ways_and_wraps() {
|
||||
use luxe_core::github::ReviewEvent::{Approve, Comment, RequestChanges};
|
||||
let (mut app, _engine_rx, _) = post_fixture();
|
||||
let post = app.guided_review_workspace.github_post.as_mut().expect("post preview");
|
||||
post.verdict = Comment;
|
||||
let mut forward = Vec::new();
|
||||
for _ in 0..3 {
|
||||
post.move_verdict(true);
|
||||
forward.push(post.verdict);
|
||||
}
|
||||
assert_eq!(forward, [Approve, RequestChanges, Comment]);
|
||||
let mut back = Vec::new();
|
||||
for _ in 0..3 {
|
||||
post.move_verdict(false);
|
||||
back.push(post.verdict);
|
||||
}
|
||||
assert_eq!(back, [RequestChanges, Approve, Comment]);
|
||||
}
|
||||
|
||||
/// Request changes needs a summary, and the preview is where it is written: `c` there opens a
|
||||
/// comment on the review as a whole, over the preview, and once it is saved the preview posts it.
|
||||
#[test]
|
||||
fn a_summary_is_written_from_the_preview_and_posts_with_it() {
|
||||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||||
let (mut app, mut engine_rx, _) = post_fixture();
|
||||
let session = app.review.session_mut().expect("session");
|
||||
session.findings.retain(|finding| {
|
||||
!matches!(finding.anchor, luxe_core::guided_review::FindingAnchor::Review)
|
||||
|| finding.severity == luxe_core::guided_review::FindingSeverity::Question
|
||||
});
|
||||
assert!(matches!(
|
||||
crate::app::github_post_plan(&app),
|
||||
Some(Err(luxe_core::guided_review::PostPlanError::NeedsBody))
|
||||
));
|
||||
|
||||
app.update(crate::app::Msg::Key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)));
|
||||
let draft = app.guided_review_workspace.finding_draft.as_ref().expect("summary composer");
|
||||
assert_eq!(draft.anchor, luxe_core::guided_review::FindingAnchor::Review);
|
||||
for character in "Bound the redirects.".chars() {
|
||||
app.update(crate::app::Msg::Key(KeyEvent::new(
|
||||
KeyCode::Char(character),
|
||||
KeyModifiers::NONE,
|
||||
)));
|
||||
}
|
||||
assert!(app.guided_review_workspace.github_post.is_some(), "typing stays in the composer");
|
||||
app.update(crate::app::Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::CONTROL)));
|
||||
let Ok(Action::EditReview {
|
||||
request_id,
|
||||
edit: luxe_core::engine::ReviewEdit::Comment { draft, .. },
|
||||
..
|
||||
}) = engine_rx.try_recv()
|
||||
else {
|
||||
panic!("expected the summary to be sent to the review desk");
|
||||
};
|
||||
// What the desk stores for it, answering this edit
|
||||
let mut stored = app.review.session.clone().expect("session");
|
||||
stored
|
||||
.add_finding(luxe_core::guided_review::ReviewFinding {
|
||||
id: luxe_core::guided_review::FindingId::new(),
|
||||
label: String::new(),
|
||||
anchor: draft.anchor,
|
||||
severity: draft.severity,
|
||||
title: draft.title,
|
||||
body: draft.body,
|
||||
proposed_fix: draft.proposed_fix,
|
||||
state: luxe_core::guided_review::FindingState::Draft,
|
||||
thread: Vec::new(),
|
||||
posted: None,
|
||||
github_thread: None,
|
||||
})
|
||||
.expect("the summary is a valid comment");
|
||||
app.update(crate::app::Msg::Engine(luxe_core::event::Event::ReviewSessionSaved {
|
||||
request_id,
|
||||
session: Box::new(stored),
|
||||
}));
|
||||
|
||||
let plan = crate::app::github_post_plan(&app).expect("prepared").expect("postable now");
|
||||
assert_eq!(plan.review.body, "Bound the redirects.");
|
||||
assert!(app.guided_review_workspace.finding_draft.is_none());
|
||||
}
|
||||
|
||||
/// `/pr` opens the branch's pull request in its card and asks for the overview. Its threads are
|
||||
/// work to do: once the overview lands, `t` opens them in a review against the working tree, as
|
||||
/// `/pr` used to on its own. A merged one has nothing left to resolve, and a branch with no pull
|
||||
/// request gets the sentence saying so.
|
||||
#[test]
|
||||
fn slash_pr_opens_the_card_and_its_threads_are_a_key_away() {
|
||||
use luxe_core::github::overview::{Overview, PullRequestOverview};
|
||||
use luxe_core::github::{CheckRollup, PullRequestState, PullRequestStatus, ReviewDecision};
|
||||
use luxe_core::workspace::PullRequestPresence;
|
||||
let registry = crate::commands::CommandRegistry::all();
|
||||
for (state, opens) in [(PullRequestState::Open, true), (PullRequestState::Merged, false)] {
|
||||
let mut app = seeded_app("nord", FixtureScenario::DockWide).expect("fixture app");
|
||||
let (engine_tx, mut engine_rx) = mpsc::channel(8);
|
||||
app.engine_tx = engine_tx;
|
||||
app.workspace.as_mut().expect("workspace").pull_request =
|
||||
PullRequestPresence::Found(PullRequestStatus {
|
||||
number: 146,
|
||||
title: "Round trip".into(),
|
||||
url: "https://github.com/acme/app/pull/146".into(),
|
||||
state,
|
||||
draft: false,
|
||||
review_decision: None,
|
||||
checks: CheckRollup::default(),
|
||||
unresolved_threads: 2,
|
||||
head_oid: "f6195af".into(),
|
||||
stack: None,
|
||||
});
|
||||
|
||||
run(&mut app, ®istry.parse_slash("/pr").expect("/pr parses"));
|
||||
assert_eq!(app.overlays.pull_request_card.as_ref().map(|card| card.number), Some(146));
|
||||
let asked = std::iter::from_fn(|| engine_rx.try_recv().ok()).any(|action| {
|
||||
matches!(
|
||||
action,
|
||||
Action::ReadGithubOverview { repository: None, number: 146, pull_request: true }
|
||||
)
|
||||
});
|
||||
assert!(asked, "the card asks for its overview");
|
||||
|
||||
let overview = PullRequestOverview {
|
||||
number: 146,
|
||||
state,
|
||||
review_decision: Some(ReviewDecision::ChangesRequested),
|
||||
unresolved_threads: 2,
|
||||
viewer: luxe_core::github::overview::Viewer {
|
||||
author: true,
|
||||
can_push: true,
|
||||
can_merge: true,
|
||||
},
|
||||
..crate::fixture::pull_request_overview()
|
||||
};
|
||||
app.update(crate::app::Msg::Engine(luxe_core::event::Event::GithubOverviewRead {
|
||||
repository: None,
|
||||
number: 146,
|
||||
overview: Some(Overview::PullRequest(Box::new(overview))),
|
||||
error: None,
|
||||
local: None,
|
||||
}));
|
||||
app.update(key(crossterm::event::KeyCode::Char('t')));
|
||||
let loaded =
|
||||
std::iter::from_fn(|| engine_rx.try_recv().ok()).find_map(|action| match action {
|
||||
Action::LoadGuidedReview { target, .. } => Some(target),
|
||||
_ => None,
|
||||
});
|
||||
assert_eq!(
|
||||
loaded,
|
||||
opens.then_some(luxe_core::guided_review::ReviewTarget::OwnPullRequest { number: 146 }),
|
||||
"{state:?}"
|
||||
);
|
||||
assert_eq!(app.overlays.pull_request_card.is_none(), opens, "acting leaves the card");
|
||||
}
|
||||
|
||||
let mut app = seeded_app("nord", FixtureScenario::DockWide).expect("fixture app");
|
||||
app.workspace.as_mut().expect("workspace").pull_request = PullRequestPresence::None;
|
||||
run(&mut app, ®istry.parse_slash("/pr").expect("/pr parses"));
|
||||
assert!(app.overlays.pull_request_card.is_none());
|
||||
assert!(matches!(
|
||||
app.convo.last().map(|item| item.block()),
|
||||
Some(ConvoBlock::System(text)) if text == "This branch has no pull request on GitHub."
|
||||
));
|
||||
}
|
||||
Reference in New Issue
Block a user