gitflow_gitcode/
review.rs1use async_trait::async_trait;
8use gitflow_core::{
9 CoreError, Result, Session,
10 review::{ReviewData, ReviewProvider, ReviewState},
11};
12use tracing::debug;
13
14use crate::error::parse_gitcode_error;
15
16const REVIEW_FIELDS: &str = "id,state,body,author,submittedAt";
18
19#[derive(Debug, Clone)]
32pub struct GitCodeReviewProvider {
33 repo: String,
35}
36
37impl GitCodeReviewProvider {
38 #[must_use]
42 pub fn new(repo: impl Into<String>) -> Self {
43 Self { repo: repo.into() }
44 }
45
46 #[must_use]
50 pub fn with_session(session: &Session) -> Self {
51 Self {
52 repo: session.repo.clone(),
53 }
54 }
55}
56
57#[async_trait]
58impl ReviewProvider for GitCodeReviewProvider {
59 async fn comment(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
60 debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --comment`");
61
62 let output = tokio::process::Command::new(crate::gitcode_binary())
63 .args(["pr", "review"])
64 .arg(pr_number.to_string())
65 .arg("--comment")
66 .arg("--body")
67 .arg(body)
68 .arg("--repo")
69 .arg(&self.repo)
70 .arg("--json")
71 .arg(REVIEW_FIELDS)
72 .output()
73 .await
74 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
75
76 if !output.status.success() {
77 return Err(parse_gitcode_error(&output.stderr).into());
78 }
79
80 let review: ReviewData =
81 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
82
83 Ok(review)
84 }
85
86 async fn approve(&self, pr_number: u64, body: Option<&str>) -> Result<ReviewData> {
87 debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --approve`");
88
89 let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
90 cmd.args(["pr", "review"])
91 .arg(pr_number.to_string())
92 .arg("--approve")
93 .arg("--repo")
94 .arg(&self.repo)
95 .arg("--json")
96 .arg(REVIEW_FIELDS);
97
98 if let Some(b) = body {
99 cmd.arg("--body").arg(b);
100 }
101
102 let output = cmd
103 .output()
104 .await
105 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
106
107 if !output.status.success() {
108 return Err(parse_gitcode_error(&output.stderr).into());
109 }
110
111 let review: ReviewData =
112 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
113
114 Ok(review)
115 }
116
117 async fn request_changes(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
118 debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --request-changes`");
119
120 let output = tokio::process::Command::new(crate::gitcode_binary())
121 .args(["pr", "review"])
122 .arg(pr_number.to_string())
123 .arg("--request-changes")
124 .arg("--body")
125 .arg(body)
126 .arg("--repo")
127 .arg(&self.repo)
128 .arg("--json")
129 .arg(REVIEW_FIELDS)
130 .output()
131 .await
132 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
133
134 if !output.status.success() {
135 return Err(parse_gitcode_error(&output.stderr).into());
136 }
137
138 let review: ReviewData =
139 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
140
141 Ok(review)
142 }
143
144 async fn submit_review(
145 &self,
146 pr_number: u64,
147 event: ReviewState,
148 body: Option<&str>,
149 ) -> Result<ReviewData> {
150 debug!(repo = %self.repo, number = pr_number, ?event, "spawning `gc pr review`");
151
152 let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
153 cmd.args(["pr", "review"])
154 .arg(pr_number.to_string())
155 .arg("--repo")
156 .arg(&self.repo)
157 .arg("--json")
158 .arg(REVIEW_FIELDS);
159
160 match event {
161 ReviewState::Approved => {
162 cmd.arg("--approve");
163 }
164 ReviewState::ChangesRequested => {
165 cmd.arg("--request-changes");
166 }
167 ReviewState::Commented => {
168 cmd.arg("--comment");
169 }
170 }
171
172 if let Some(b) = body {
173 cmd.arg("--body").arg(b);
174 }
175
176 let output = cmd
177 .output()
178 .await
179 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
180
181 if !output.status.success() {
182 return Err(parse_gitcode_error(&output.stderr).into());
183 }
184
185 let review: ReviewData =
186 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
187
188 Ok(review)
189 }
190}
191
192#[cfg(test)]
193mod tests {
194 use super::*;
195
196 #[test]
197 fn test_should_construct_gitcode_review_provider() {
198 let provider = GitCodeReviewProvider::new("octocat/hello-world");
199 assert_eq!(provider.repo, "octocat/hello-world");
200 }
201
202 #[test]
203 fn test_should_construct_gitcode_review_provider_from_string() {
204 let repo = String::from("octocat/hello-world");
205 let provider = GitCodeReviewProvider::new(repo);
206 assert_eq!(provider.repo, "octocat/hello-world");
207 }
208
209 #[test]
210 fn test_should_deserialize_review_data_from_gc_output() {
211 let gc_json = br#"{
212 "id": 2001,
213 "state": "approved",
214 "body": "Looks great, LGTM!",
215 "author": {"login": "reviewer", "id": "42"},
216 "submittedAt": "2026-05-20T14:30:00Z"
217 }"#;
218
219 let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData JSON");
220 assert_eq!(review.id, 2001);
221 assert_eq!(review.state, ReviewState::Approved);
222 assert_eq!(review.body.as_deref(), Some("Looks great, LGTM!"));
223 assert_eq!(review.author.login, "reviewer");
224 assert_eq!(review.author.id, "42");
225 }
226
227 #[test]
228 fn test_should_deserialize_changes_requested_review_from_gc_output() {
229 let gc_json = br#"{
230 "id": 2002,
231 "state": "changes_requested",
232 "body": "Please fix the error handling",
233 "author": {"login": "senior-dev", "id": "7"},
234 "submittedAt": "2026-05-21T09:00:00Z"
235 }"#;
236
237 let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData");
238 assert_eq!(review.state, ReviewState::ChangesRequested);
239 assert_eq!(
240 review.body.as_deref(),
241 Some("Please fix the error handling")
242 );
243 }
244
245 #[test]
246 fn test_should_deserialize_commented_review_from_gc_output() {
247 let gc_json = br#"{
248 "id": 2003,
249 "state": "commented",
250 "body": null,
251 "author": {"login": "observer", "id": "15"},
252 "submittedAt": "2026-05-22T11:00:00Z"
253 }"#;
254
255 let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData");
256 assert_eq!(review.state, ReviewState::Commented);
257 assert!(review.body.is_none());
258 }
259
260 #[test]
261 fn test_should_debug_format_provider() {
262 let provider = GitCodeReviewProvider::new("octocat/hello-world");
263 let debug = format!("{provider:?}");
264 assert!(debug.contains("GitCodeReviewProvider"));
265 assert!(debug.contains("octocat/hello-world"));
266 }
267
268 #[test]
269 fn test_should_create_provider_with_different_repos() {
270 let r1 = GitCodeReviewProvider::new("org/repo-a");
271 let r2 = GitCodeReviewProvider::new("org/repo-b");
272 assert_eq!(r1.repo, "org/repo-a");
273 assert_eq!(r2.repo, "org/repo-b");
274 }
275
276 #[test]
277 fn test_should_clone_gitcode_review_provider() {
278 let original = GitCodeReviewProvider::new("owner/repo");
279 let cloned = original.clone();
280 assert_eq!(original.repo, cloned.repo);
281 }
282}