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