use crate::types::{
FilePatch, Involvement, PrNumber, PrSummary, RepoId, Result, ReviewComment, Verdict,
};
pub trait Forge {
fn search(&self, lane: Involvement, limit: usize) -> Result<Vec<PrSummary>>;
fn pull_request(&self, repo: &RepoId, number: PrNumber) -> Result<PrSummary>;
fn files(&self, repo: &RepoId, number: PrNumber) -> Result<Vec<FilePatch>>;
fn comments(&self, repo: &RepoId, number: PrNumber) -> Result<Vec<ReviewComment>>;
}
pub trait ForgeReview {
fn submit_review(&self, repo: &RepoId, number: PrNumber, verdict: &Verdict) -> Result<()>;
}
#[derive(Debug, Default)]
pub struct MockForge {
prs: Vec<PrSummary>,
files: Vec<(PrNumber, FilePatch)>,
comments: Vec<(PrNumber, ReviewComment)>,
pub submitted: std::cell::RefCell<Vec<(RepoId, PrNumber, Verdict)>>,
fail_reads_with: Option<crate::ForgeError>,
}
impl MockForge {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn with_pr(mut self, pr: PrSummary) -> Self {
self.prs.push(pr);
self
}
#[must_use]
pub fn with_file(mut self, number: PrNumber, patch: FilePatch) -> Self {
self.files.push((number, patch));
self
}
#[must_use]
pub fn with_comment(mut self, number: PrNumber, c: ReviewComment) -> Self {
self.comments.push((number, c));
self
}
#[must_use]
pub fn failing(mut self, e: crate::ForgeError) -> Self {
self.fail_reads_with = Some(e);
self
}
#[must_use]
pub fn submitted_count(&self) -> usize {
self.submitted.borrow().len()
}
fn guard(&self) -> Result<()> {
match &self.fail_reads_with {
Some(e) => Err(e.clone()),
None => Ok(()),
}
}
}
impl Forge for MockForge {
fn search(&self, _lane: Involvement, limit: usize) -> Result<Vec<PrSummary>> {
self.guard()?;
Ok(self.prs.iter().take(limit).cloned().collect())
}
fn pull_request(&self, repo: &RepoId, number: PrNumber) -> Result<PrSummary> {
self.guard()?;
self.prs
.iter()
.find(|p| p.repo == *repo && p.number == number)
.cloned()
.ok_or_else(|| crate::ForgeError::Backend {
operation: "pull_request",
detail: format_missing(repo, number),
})
}
fn files(&self, _repo: &RepoId, number: PrNumber) -> Result<Vec<FilePatch>> {
self.guard()?;
Ok(self
.files
.iter()
.filter(|(n, _)| *n == number)
.map(|(_, f)| f.clone())
.collect())
}
fn comments(&self, _repo: &RepoId, number: PrNumber) -> Result<Vec<ReviewComment>> {
self.guard()?;
Ok(self
.comments
.iter()
.filter(|(n, _)| *n == number)
.map(|(_, c)| c.clone())
.collect())
}
}
impl ForgeReview for MockForge {
fn submit_review(&self, repo: &RepoId, number: PrNumber, verdict: &Verdict) -> Result<()> {
self.submitted
.borrow_mut()
.push((repo.clone(), number, verdict.clone()));
Ok(())
}
}
fn format_missing(repo: &RepoId, number: PrNumber) -> String {
let mut s = String::from("no such pull request: ");
s.push_str(&repo.owner);
s.push('/');
s.push_str(&repo.name);
s.push('#');
s.push_str(&number.0.to_string());
s
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::PrState;
fn pr(n: u64) -> PrSummary {
PrSummary {
repo: RepoId::parse("pleme-io/metsuke").unwrap(),
number: PrNumber(n),
title: "a change".into(),
author: "drzzln".into(),
state: PrState::Open,
draft: false,
updated_at: "2026-08-03T00:00:00Z".into(),
url: "https://example.invalid".into(),
}
}
#[test]
fn the_mock_returns_what_it_was_seeded_with() {
let f = MockForge::new().with_pr(pr(1)).with_pr(pr(2));
assert_eq!(f.search(Involvement::ReviewRequested, 10).unwrap().len(), 2);
assert_eq!(f.search(Involvement::ReviewRequested, 1).unwrap().len(), 1);
}
#[test]
fn a_missing_pr_is_an_error_not_an_empty_default() {
let f = MockForge::new();
let repo = RepoId::parse("pleme-io/metsuke").unwrap();
let e = f.pull_request(&repo, PrNumber(9)).unwrap_err();
assert!(
e.to_string().contains("pleme-io/metsuke#9"),
"the error must name what was missing; got: {e}"
);
}
#[test]
fn submitting_records_the_exact_verdict() {
let f = MockForge::new();
let repo = RepoId::parse("pleme-io/metsuke").unwrap();
f.submit_review(&repo, PrNumber(3), &Verdict::Approve("lgtm".into()))
.unwrap();
let got = f.submitted.borrow();
assert_eq!(got.len(), 1);
assert_eq!(got[0].1, PrNumber(3));
assert_eq!(got[0].2, Verdict::Approve("lgtm".into()));
}
#[test]
fn a_failing_mock_fails_reads_and_the_error_survives() {
let f = MockForge::new()
.with_pr(pr(1))
.failing(crate::ForgeError::NotAuthenticated {
detail: "gh auth login".into(),
});
let e = f.search(Involvement::Authored, 10).unwrap_err();
assert!(matches!(e, crate::ForgeError::NotAuthenticated { .. }));
}
}