1use derive_builder::Builder;
13use reqwest::Method;
14use std::borrow::Cow;
15
16use crate::api::{Endpoint, NoPagination, ReturnsJsonResponse};
17use serde::Serialize;
18
19#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
23pub struct IssueRelation {
24 pub id: u64,
26 pub issue_id: u64,
28 pub issue_to_id: u64,
30 pub relation_type: IssueRelationType,
32 pub delay: Option<u64>,
34}
35
36#[derive(Debug, Clone, Builder)]
38#[builder(setter(strip_option))]
39pub struct ListIssueRelations {
40 issue_id: u64,
42}
43
44impl ReturnsJsonResponse for ListIssueRelations {}
45impl NoPagination for ListIssueRelations {}
46
47impl ListIssueRelations {
48 #[must_use]
50 pub fn builder() -> ListIssueRelationsBuilder {
51 ListIssueRelationsBuilder::default()
52 }
53}
54
55impl Endpoint for ListIssueRelations {
56 fn method(&self) -> Method {
57 Method::GET
58 }
59
60 fn endpoint(&self) -> Cow<'static, str> {
61 format!("issues/{}/relations.json", self.issue_id).into()
62 }
63}
64
65#[derive(Debug, Clone, Builder)]
67#[builder(setter(strip_option))]
68pub struct GetIssueRelation {
69 id: u64,
71}
72
73impl ReturnsJsonResponse for GetIssueRelation {}
74impl NoPagination for GetIssueRelation {}
75
76impl GetIssueRelation {
77 #[must_use]
79 pub fn builder() -> GetIssueRelationBuilder {
80 GetIssueRelationBuilder::default()
81 }
82}
83
84impl Endpoint for GetIssueRelation {
85 fn method(&self) -> Method {
86 Method::GET
87 }
88
89 fn endpoint(&self) -> Cow<'static, str> {
90 format!("relations/{}.json", self.id).into()
91 }
92}
93
94#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Deserialize, Serialize)]
96#[serde(rename_all = "snake_case")]
97pub enum IssueRelationType {
98 Relates,
100 Duplicates,
102 Duplicated,
104 Blocks,
106 Blocked,
108 Precedes,
110 Follows,
112 CopiedTo,
114 CopiedFrom,
116}
117
118#[serde_with::skip_serializing_none]
120#[derive(Debug, Clone, Builder, Serialize)]
121#[builder(setter(strip_option))]
122pub struct CreateIssueRelation {
123 #[serde(skip_serializing)]
125 issue_from_id: u64,
126 issue_to_id: u64,
128 relation_type: IssueRelationType,
130 #[builder(default)]
132 delay: Option<u64>,
133}
134
135impl ReturnsJsonResponse for CreateIssueRelation {}
136impl NoPagination for CreateIssueRelation {}
137
138impl CreateIssueRelation {
139 #[must_use]
141 pub fn builder() -> CreateIssueRelationBuilder {
142 CreateIssueRelationBuilder::default()
143 }
144}
145
146impl Endpoint for CreateIssueRelation {
147 fn method(&self) -> Method {
148 Method::POST
149 }
150
151 fn endpoint(&self) -> Cow<'static, str> {
152 format!("issues/{}/relations.json", self.issue_from_id).into()
153 }
154
155 fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
156 Ok(Some((
157 "application/json",
158 serde_json::to_vec(&RelationWrapper::<Self> {
159 relation: (*self).to_owned(),
160 })?,
161 )))
162 }
163}
164
165#[derive(Debug, Clone, Builder)]
167#[builder(setter(strip_option))]
168pub struct DeleteIssueRelation {
169 id: u64,
171}
172
173impl DeleteIssueRelation {
174 #[must_use]
176 pub fn builder() -> DeleteIssueRelationBuilder {
177 DeleteIssueRelationBuilder::default()
178 }
179}
180
181impl Endpoint for DeleteIssueRelation {
182 fn method(&self) -> Method {
183 Method::DELETE
184 }
185
186 fn endpoint(&self) -> Cow<'static, str> {
187 format!("relations/{}.json", self.id).into()
188 }
189}
190
191#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
193pub struct RelationsWrapper<T> {
194 pub relations: Vec<T>,
196}
197
198#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
201pub struct RelationWrapper<T> {
202 pub relation: T,
204}
205
206#[cfg(test)]
207mod test {
208 use super::*;
209 use crate::api::issues::test::ISSUES_LOCK;
210 use crate::api::issues::{CreateIssue, Issue, IssueWrapper};
211 use crate::api::test_helpers::{create_issue, with_project};
212 use pretty_assertions::assert_eq;
213 use std::error::Error;
214 use tokio::sync::RwLock;
215 use tracing_test::traced_test;
216
217 static ISSUE_RELATION_LOCK: RwLock<()> = RwLock::const_new(());
220
221 fn with_issue_relation<F>(name: &str, f: F) -> Result<(), Box<dyn Error>>
224 where
225 F: FnOnce(&crate::api::Redmine, u64, u64) -> Result<(), Box<dyn Error>>,
226 {
227 let _w_issues = ISSUES_LOCK.blocking_write();
228 let _w_issue_relation = ISSUE_RELATION_LOCK.blocking_write();
229 with_project(name, |redmine, project_id, _name| {
230 let issue1 = create_issue(redmine, project_id, "Test issue 1")?;
231 let issue2 = create_issue(redmine, project_id, "Test issue 2")?;
232 let create_endpoint = super::CreateIssueRelation::builder()
233 .issue_from_id(issue1.id)
234 .issue_to_id(issue2.id)
235 .relation_type(IssueRelationType::Precedes)
236 .delay(2)
237 .build()?;
238 let RelationWrapper { relation }: RelationWrapper<IssueRelation> =
239 redmine.json_response_body::<_, _>(&create_endpoint)?;
240 f(redmine, issue1.id, relation.id)
241 })
242 }
243
244 #[function_name::named]
245 #[traced_test]
246 #[test]
247 fn test_list_issue_relations_no_pagination() -> Result<(), Box<dyn Error>> {
248 let name = format!("unittest_{}", function_name!());
249 with_issue_relation(&name, |redmine, issue_id, relation_id| {
250 let endpoint = ListIssueRelations::builder().issue_id(issue_id).build()?;
251 let RelationsWrapper { relations } =
252 redmine.json_response_body::<_, RelationsWrapper<IssueRelation>>(&endpoint)?;
253 assert!(relations.iter().any(|r| r.id == relation_id));
254 Ok(())
255 })
256 }
257
258 #[function_name::named]
259 #[traced_test]
260 #[test]
261 fn test_get_issue_relation() -> Result<(), Box<dyn Error>> {
262 let name = format!("unittest_{}", function_name!());
263 with_issue_relation(&name, |redmine, _issue_id, relation_id| {
264 let endpoint = GetIssueRelation::builder().id(relation_id).build()?;
265 redmine.json_response_body::<_, RelationWrapper<IssueRelation>>(&endpoint)?;
266 Ok(())
267 })
268 }
269
270 #[function_name::named]
271 #[traced_test]
272 #[test]
273 fn test_create_issue_relation() -> Result<(), Box<dyn Error>> {
274 let _w_issues = ISSUES_LOCK.blocking_write();
275 let _w_issue_relation = ISSUE_RELATION_LOCK.blocking_write();
276 let name = format!("unittest_{}", function_name!());
277 with_project(&name, |redmine, project_id, _name| {
278 let create_issue1_endpoint = CreateIssue::builder()
279 .project_id(project_id)
280 .subject("Test issue 1")
281 .build()?;
282 let IssueWrapper { issue: issue1 }: IssueWrapper<Issue> =
283 redmine.json_response_body::<_, _>(&create_issue1_endpoint)?;
284 let create_issue2_endpoint = CreateIssue::builder()
285 .project_id(project_id)
286 .subject("Test issue 2")
287 .build()?;
288 let IssueWrapper { issue: issue2 }: IssueWrapper<Issue> =
289 redmine.json_response_body::<_, _>(&create_issue2_endpoint)?;
290 let create_endpoint = super::CreateIssueRelation::builder()
291 .issue_from_id(issue1.id)
292 .issue_to_id(issue2.id)
293 .relation_type(IssueRelationType::Relates)
294 .build()?;
295 redmine.json_response_body::<_, RelationWrapper<IssueRelation>>(&create_endpoint)?;
296 Ok(())
297 })?;
298 Ok(())
299 }
300
301 #[function_name::named]
302 #[traced_test]
303 #[test]
304 fn test_delete_issue_relation() -> Result<(), Box<dyn Error>> {
305 let _w_issues = ISSUES_LOCK.blocking_write();
306 let _w_issue_relation = ISSUE_RELATION_LOCK.blocking_write();
307 let name = format!("unittest_{}", function_name!());
308 with_project(&name, |redmine, project_id, _name| {
309 let create_issue1_endpoint = CreateIssue::builder()
310 .project_id(project_id)
311 .subject("Test issue 1")
312 .build()?;
313 let IssueWrapper { issue: issue1 }: IssueWrapper<Issue> =
314 redmine.json_response_body::<_, _>(&create_issue1_endpoint)?;
315 let create_issue2_endpoint = CreateIssue::builder()
316 .project_id(project_id)
317 .subject("Test issue 2")
318 .build()?;
319 let IssueWrapper { issue: issue2 }: IssueWrapper<Issue> =
320 redmine.json_response_body::<_, _>(&create_issue2_endpoint)?;
321 let create_endpoint = super::CreateIssueRelation::builder()
322 .issue_from_id(issue1.id)
323 .issue_to_id(issue2.id)
324 .relation_type(IssueRelationType::Relates)
325 .build()?;
326 let RelationWrapper { relation }: RelationWrapper<IssueRelation> =
327 redmine.json_response_body::<_, _>(&create_endpoint)?;
328 let id = relation.id;
329 let delete_endpoint = super::DeleteIssueRelation::builder().id(id).build()?;
330 redmine.ignore_response_body::<_>(&delete_endpoint)?;
331 Ok(())
332 })?;
333 Ok(())
334 }
335
336 #[function_name::named]
341 #[traced_test]
342 #[test]
343 fn test_completeness_issue_relation_type() -> Result<(), Box<dyn Error>> {
344 let name = format!("unittest_{}", function_name!());
345 with_issue_relation(&name, |redmine, issue_id, _relation_id| {
346 let endpoint = ListIssueRelations::builder().issue_id(issue_id).build()?;
347 let RelationsWrapper { relations: values } =
348 redmine.json_response_body::<_, RelationsWrapper<serde_json::Value>>(&endpoint)?;
349 assert!(!values.is_empty());
350 for value in values {
351 let o: IssueRelation = serde_json::from_value(value.clone())?;
352 let reserialized = serde_json::to_value(o)?;
353 assert_eq!(value, reserialized);
354 }
355 Ok(())
356 })
357 }
358}