1use async_trait::async_trait;
8use chrono::{DateTime, Utc};
9use serde::{Deserialize, Serialize};
10
11use crate::{Result, types::UserSummary};
12
13#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
20#[serde(rename_all = "snake_case")]
21pub enum ReviewState {
22 #[serde(alias = "APPROVED")]
24 Approved,
25 #[serde(alias = "CHANGES_REQUESTED")]
27 ChangesRequested,
28 #[serde(alias = "COMMENTED")]
30 Commented,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(rename_all = "camelCase")]
39pub struct ReviewData {
40 pub id: u64,
42 pub state: ReviewState,
44 #[serde(skip_serializing_if = "Option::is_none")]
46 pub body: Option<String>,
47 pub author: UserSummary,
49 #[serde(skip_serializing_if = "Option::is_none")]
51 pub submitted_at: Option<DateTime<Utc>>,
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(rename_all = "camelCase")]
59pub struct ReviewCommentData {
60 pub id: u64,
62 #[serde(skip_serializing_if = "Option::is_none")]
64 pub path: Option<String>,
65 pub body: String,
67 #[serde(skip_serializing_if = "Option::is_none")]
69 pub line: Option<u32>,
70 #[serde(skip_serializing_if = "Option::is_none")]
72 pub diff_hunk: Option<String>,
73 pub author: UserSummary,
75 pub created_at: DateTime<Utc>,
77}
78
79#[async_trait]
91pub trait ReviewProvider: std::fmt::Debug + Send + Sync {
92 async fn comment(&self, pr_number: u64, body: &str) -> Result<ReviewData>;
98
99 async fn approve(&self, pr_number: u64, body: Option<&str>) -> Result<ReviewData>;
107
108 async fn request_changes(&self, pr_number: u64, body: &str) -> Result<ReviewData>;
116
117 async fn submit_review(
126 &self,
127 pr_number: u64,
128 event: ReviewState,
129 body: Option<&str>,
130 ) -> Result<ReviewData>;
131}
132
133#[cfg(test)]
134mod tests {
135 use super::*;
136
137 fn sample_review_json() -> &'static str {
138 r#"{
139 "id": 2001,
140 "state": "approved",
141 "body": "Looks great, LGTM!",
142 "author": {"login": "reviewer", "id": "42"},
143 "submittedAt": "2026-05-20T14:30:00Z"
144 }"#
145 }
146
147 fn sample_review_comment_json() -> &'static str {
148 r#"{
149 "id": 3001,
150 "path": "src/main.rs",
151 "body": "Consider using `Result` here",
152 "line": 42,
153 "diffHunk": "@@ -40,3 +40,5 @@ fn main()",
154 "author": {"login": "alice", "id": "7"},
155 "createdAt": "2026-05-19T10:00:00Z"
156 }"#
157 }
158
159 #[test]
160 fn test_should_deserialize_review_data_from_json() {
161 let json = sample_review_json();
162 let review: ReviewData = serde_json::from_str(json).expect("valid ReviewData JSON");
163
164 assert_eq!(review.id, 2001);
165 assert_eq!(review.state, ReviewState::Approved);
166 assert_eq!(review.body.as_deref(), Some("Looks great, LGTM!"));
167 assert_eq!(review.author.login, "reviewer");
168 assert_eq!(review.author.id, "42");
169 }
170
171 #[test]
172 fn test_should_roundtrip_review_data_via_serde() {
173 let json = sample_review_json();
174 let review: ReviewData = serde_json::from_str(json).expect("deserialize");
175 let re_serialized = serde_json::to_string(&review).expect("serialize");
176 let round_tripped: ReviewData =
177 serde_json::from_str(&re_serialized).expect("re-deserialize");
178
179 assert_eq!(round_tripped.id, review.id);
180 assert_eq!(round_tripped.state, review.state);
181 assert_eq!(round_tripped.body, review.body);
182 assert_eq!(round_tripped.author.login, review.author.login);
183 assert_eq!(round_tripped.submitted_at, review.submitted_at);
184 }
185
186 #[test]
187 fn test_should_deserialize_review_comment_data_from_json() {
188 let json = sample_review_comment_json();
189 let comment: ReviewCommentData =
190 serde_json::from_str(json).expect("valid ReviewCommentData JSON");
191
192 assert_eq!(comment.id, 3001);
193 assert_eq!(comment.path.as_deref(), Some("src/main.rs"));
194 assert_eq!(comment.body, "Consider using `Result` here");
195 assert_eq!(comment.line, Some(42));
196 assert_eq!(
197 comment.diff_hunk.as_deref(),
198 Some("@@ -40,3 +40,5 @@ fn main()")
199 );
200 assert_eq!(comment.author.login, "alice");
201 assert_eq!(comment.author.id, "7");
202 }
203
204 #[test]
205 fn test_should_roundtrip_review_comment_data_via_serde() {
206 let json = sample_review_comment_json();
207 let comment: ReviewCommentData = serde_json::from_str(json).expect("deserialize");
208 let re_serialized = serde_json::to_string(&comment).expect("serialize");
209 let round_tripped: ReviewCommentData =
210 serde_json::from_str(&re_serialized).expect("re-deserialize");
211
212 assert_eq!(round_tripped.id, comment.id);
213 assert_eq!(round_tripped.path, comment.path);
214 assert_eq!(round_tripped.body, comment.body);
215 assert_eq!(round_tripped.line, comment.line);
216 assert_eq!(round_tripped.diff_hunk, comment.diff_hunk);
217 assert_eq!(round_tripped.author.login, comment.author.login);
218 assert_eq!(round_tripped.author.id, comment.author.id);
219 assert_eq!(round_tripped.created_at, comment.created_at);
220 }
221
222 #[test]
223 fn test_should_serialize_review_comment_skips_null_fields() {
224 let comment = ReviewCommentData {
225 id: 1,
226 path: None,
227 body: "file-level comment".into(),
228 line: None,
229 diff_hunk: None,
230 author: UserSummary {
231 login: "bob".into(),
232 id: "3".to_string(),
233 },
234 created_at: "2026-01-01T00:00:00Z".parse().expect("valid date"),
235 };
236 let json = serde_json::to_string(&comment).expect("serialize");
237 assert!(!json.contains("null"));
238 assert!(!json.contains("\"path\":"));
239 assert!(!json.contains("\"line\":"));
240 assert!(!json.contains("\"diffHunk\":"));
241 assert!(json.contains("\"body\":\"file-level comment\""));
242 }
243
244 #[test]
245 fn test_should_serialize_review_state_to_snake_case() {
246 let json = serde_json::to_string(&ReviewState::Approved).expect("serialize");
247 assert_eq!(json, "\"approved\"");
248
249 let json = serde_json::to_string(&ReviewState::ChangesRequested).expect("serialize");
250 assert_eq!(json, "\"changes_requested\"");
251
252 let json = serde_json::to_string(&ReviewState::Commented).expect("serialize");
253 assert_eq!(json, "\"commented\"");
254 }
255
256 #[test]
257 fn test_should_deserialize_review_state_from_snake_case() {
258 let state: ReviewState = serde_json::from_str("\"approved\"").expect("deserialize");
259 assert_eq!(state, ReviewState::Approved);
260
261 let state: ReviewState =
262 serde_json::from_str("\"changes_requested\"").expect("deserialize");
263 assert_eq!(state, ReviewState::ChangesRequested);
264
265 let state: ReviewState = serde_json::from_str("\"commented\"").expect("deserialize");
266 assert_eq!(state, ReviewState::Commented);
267 }
268
269 #[test]
270 fn test_should_deserialize_review_state_from_github_uppercase() {
271 let state: ReviewState = serde_json::from_str("\"APPROVED\"").expect("deserialize");
272 assert_eq!(state, ReviewState::Approved);
273
274 let state: ReviewState =
275 serde_json::from_str("\"CHANGES_REQUESTED\"").expect("deserialize");
276 assert_eq!(state, ReviewState::ChangesRequested);
277
278 let state: ReviewState = serde_json::from_str("\"COMMENTED\"").expect("deserialize");
279 assert_eq!(state, ReviewState::Commented);
280 }
281
282 #[test]
283 fn test_should_derive_clone_and_copy_for_review_state() {
284 let state = ReviewState::Approved;
285 let cloned = state;
286 let copied = state;
287 assert_eq!(state, cloned);
288 assert_eq!(state, copied);
289 }
290
291 #[test]
292 fn test_should_derive_debug_for_review_state() {
293 let debug = format!("{:?}", ReviewState::ChangesRequested);
294 assert_eq!(debug, "ChangesRequested");
295 }
296
297 #[test]
298 fn test_should_derive_eq_for_review_state() {
299 assert_eq!(ReviewState::Approved, ReviewState::Approved);
300 assert_ne!(ReviewState::Approved, ReviewState::ChangesRequested);
301 }
302
303 #[test]
304 fn test_should_deserialize_review_data_with_null_body() {
305 let json = r#"{
306 "id": 10,
307 "state": "commented",
308 "body": null,
309 "author": {"login": "u", "id": "1"},
310 "submittedAt": "2026-06-01T00:00:00Z"
311 }"#;
312 let review: ReviewData = serde_json::from_str(json).expect("deserialize");
313 assert_eq!(review.state, ReviewState::Commented);
314 assert!(review.body.is_none());
315 }
316}