1use async_trait::async_trait;
8use chrono::{DateTime, Utc};
9use serde::{Deserialize, Serialize};
10
11use crate::{
12 Result,
13 types::{
14 CommentData, MergeResult, MergeStrategy, State, UserSummary, deserialize_u64_or_string,
15 },
16};
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
23#[serde(rename_all = "camelCase")]
24pub struct PrData {
25 #[serde(deserialize_with = "deserialize_u64_or_string")]
27 pub number: u64,
28 pub title: String,
30 #[serde(skip_serializing_if = "Option::is_none")]
32 pub body: Option<String>,
33 pub state: State,
35 #[serde(alias = "isDraft")]
37 pub draft: bool,
38 pub author: UserSummary,
40 #[serde(alias = "baseRefName")]
42 pub base_branch: String,
43 #[serde(alias = "headRefName")]
45 pub head_branch: String,
46 pub created_at: DateTime<Utc>,
48 pub updated_at: DateTime<Utc>,
50 pub url: String,
52}
53
54#[derive(Debug, Clone)]
56pub struct CreatePrArgs {
57 pub title: String,
59 pub body: Option<String>,
61 pub head: String,
63 pub base: String,
65 pub draft: bool,
67 pub repo: Option<String>,
69}
70
71#[derive(Debug, Clone, Default)]
75pub struct ListPrArgs {
76 pub state: Option<State>,
78 pub limit: Option<u32>,
80}
81
82#[async_trait]
93pub trait PrProvider: std::fmt::Debug + Send + Sync {
94 async fn create(&self, args: CreatePrArgs) -> Result<PrData>;
100
101 async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>>;
107
108 async fn view(&self, number: u64) -> Result<PrData>;
114
115 async fn close(&self, number: u64) -> Result<PrData>;
121
122 async fn reopen(&self, number: u64) -> Result<PrData>;
128
129 async fn comment(&self, number: u64, body: &str) -> Result<CommentData>;
135
136 async fn merge(&self, number: u64, strategy: Option<MergeStrategy>) -> Result<MergeResult>;
145
146 async fn checkout(&self, number: u64) -> Result<()>;
152
153 async fn mark_ready(&self, number: u64) -> Result<PrData>;
159
160 async fn mark_wip(&self, number: u64) -> Result<PrData>;
166
167 async fn sync_branch(&self, number: u64) -> Result<()>;
173}
174
175#[cfg(test)]
176mod tests {
177 use super::*;
178
179 fn sample_pr_json() -> &'static str {
181 r#"{
182 "number": 101,
183 "title": "Add feature X",
184 "body": "Implements X per spec.",
185 "state": "open",
186 "draft": false,
187 "author": {"login": "alice", "id": "7"},
188 "baseBranch": "main",
189 "headBranch": "feature/x",
190 "createdAt": "2026-02-10T08:00:00Z",
191 "updatedAt": "2026-02-11T12:30:00Z",
192 "url": "https://github.com/octocat/hello-world/pull/101"
193 }"#
194 }
195
196 #[test]
197 fn test_should_deserialize_pr_data_from_gh_cli_json() {
198 let json = sample_pr_json();
199 let pr: PrData = serde_json::from_str(json).expect("valid PrData JSON");
200
201 assert_eq!(pr.number, 101);
202 assert_eq!(pr.title, "Add feature X");
203 assert_eq!(pr.body.as_deref(), Some("Implements X per spec."));
204 assert_eq!(pr.state, State::Open);
205 assert!(!pr.draft);
206 assert_eq!(pr.author.login, "alice");
207 assert_eq!(pr.author.id, "7");
208 assert_eq!(pr.base_branch, "main");
209 assert_eq!(pr.head_branch, "feature/x");
210 assert_eq!(pr.url, "https://github.com/octocat/hello-world/pull/101");
211 }
212
213 #[test]
214 fn test_should_roundtrip_pr_data_via_serde() {
215 let json = sample_pr_json();
216 let pr: PrData = serde_json::from_str(json).expect("deserialize");
217 let re_serialized = serde_json::to_string(&pr).expect("serialize");
218 let round_tripped: PrData = serde_json::from_str(&re_serialized).expect("re-deserialize");
219
220 assert_eq!(round_tripped.number, pr.number);
221 assert_eq!(round_tripped.title, pr.title);
222 assert_eq!(round_tripped.body, pr.body);
223 assert_eq!(round_tripped.state, pr.state);
224 assert_eq!(round_tripped.draft, pr.draft);
225 assert_eq!(round_tripped.base_branch, pr.base_branch);
226 assert_eq!(round_tripped.head_branch, pr.head_branch);
227 assert_eq!(round_tripped.url, pr.url);
228 assert_eq!(round_tripped.created_at, pr.created_at);
229 assert_eq!(round_tripped.updated_at, pr.updated_at);
230 }
231
232 #[test]
233 fn test_should_deserialize_draft_pr_with_null_body() {
234 let json = r#"{
235 "number": 5,
236 "title": "WIP experiment",
237 "body": null,
238 "state": "open",
239 "draft": true,
240 "author": {"login": "bob", "id": "9"},
241 "baseBranch": "main",
242 "headBranch": "wip",
243 "createdAt": "2026-04-01T00:00:00Z",
244 "updatedAt": "2026-04-02T00:00:00Z",
245 "url": "https://example.com/pull/5"
246 }"#;
247 let pr: PrData = serde_json::from_str(json).expect("deserialize");
248 assert!(pr.draft);
249 assert!(pr.body.is_none());
250 assert_eq!(pr.state, State::Open);
251 }
252
253 #[test]
254 fn test_should_omit_none_body_on_serialize() {
255 let json = sample_pr_json();
256 let mut pr: PrData = serde_json::from_str(json).expect("deserialize");
257 pr.body = None;
258 let serialized = serde_json::to_string(&pr).expect("serialize");
259 assert!(!serialized.contains("\"body\":null"));
261 assert!(!serialized.contains("\"body\": null"));
262 }
263
264 #[test]
265 fn test_should_serialize_camel_case_fields() {
266 let json = sample_pr_json();
267 let pr: PrData = serde_json::from_str(json).expect("deserialize");
268 let serialized = serde_json::to_string(&pr).expect("serialize");
269 assert!(serialized.contains("\"baseBranch\""));
271 assert!(serialized.contains("\"headBranch\""));
272 assert!(serialized.contains("\"createdAt\""));
273 assert!(serialized.contains("\"updatedAt\""));
274 assert!(!serialized.contains("\"base_branch\""));
276 assert!(!serialized.contains("\"head_branch\""));
277 }
278
279 #[test]
280 fn test_list_pr_args_default_is_empty() {
281 let args = ListPrArgs::default();
282 assert!(args.state.is_none());
283 assert!(args.limit.is_none());
284 }
285}