1use uuid::Uuid;
2
3use crate::dto::{OwnerName, RepositoryName};
4use crate::error::QuestionError;
5
6#[derive(Debug, Clone)]
7pub struct CreateQuestionRequest {
8    pub author_id: Uuid,
9    pub owner: OwnerName,
10    pub repo: RepositoryName,
11    pub title: String,
12    pub body: String,
13}
14
15impl CreateQuestionRequest {
16    pub fn new(
17        author_id: Uuid,
18        owner: &str,
19        repo: &str,
20        title: String,
21        body: String,
22    ) -> Result<Self, QuestionError> {
23        Ok(Self {
24            author_id,
25            owner: OwnerName::try_new(owner)
26                .map_err(|e| QuestionError::InvalidOwnerName(e.to_string()))?,
27            repo: RepositoryName::try_new(repo)
28                .map_err(|e| QuestionError::InvalidOwnerName(e.to_string()))?,
29            title,
30            body,
31        })
32    }
33
34    pub fn get_repo_path(&self) -> String {
35        format!("{}/{}", self.owner.as_ref(), self.repo.as_ref())
36    }
37}
38
39#[cfg(test)]
40mod tests {
41    use super::*;
42
43    #[test]
44    fn valid_request() {
45        let author_id = Uuid::new_v4();
46        let request = CreateQuestionRequest::new(
47            author_id,
48            "johndoe",
49            "my-repo",
50            "Question title".to_string(),
51            "Question body".to_string(),
52        )
53        .unwrap();
54
55        assert_eq!(request.author_id, author_id);
56        assert_eq!(request.owner.as_ref(), "johndoe");
57        assert_eq!(request.repo.as_ref(), "my-repo");
58        assert_eq!(request.title, "Question title");
59        assert_eq!(request.body, "Question body");
60    }
61
62    #[test]
63    fn get_repo_path_formats_correctly() {
64        let author_id = Uuid::new_v4();
65        let request = CreateQuestionRequest::new(
66            author_id,
67            "johndoe",
68            "my-repo",
69            "Title".to_string(),
70            "Body".to_string(),
71        )
72        .unwrap();
73
74        assert_eq!(request.get_repo_path(), "johndoe/my-repo");
75    }
76
77    #[test]
78    fn sanitizes_owner_and_repo_to_lowercase() {
79        let author_id = Uuid::new_v4();
80        let request = CreateQuestionRequest::new(
81            author_id,
82            "JohnDoe",
83            "MyRepo",
84            "Title".to_string(),
85            "Body".to_string(),
86        )
87        .unwrap();
88
89        assert_eq!(request.get_repo_path(), "johndoe/myrepo");
90    }
91
92    #[test]
93    fn rejects_invalid_owner() {
94        let author_id = Uuid::new_v4();
95        let result = CreateQuestionRequest::new(
96            author_id,
97            "invalid@owner",
98            "my-repo",
99            "Title".to_string(),
100            "Body".to_string(),
101        );
102
103        assert!(matches!(result, Err(QuestionError::InvalidOwnerName(_))));
104    }
105
106    #[test]
107    fn rejects_invalid_repo() {
108        let author_id = Uuid::new_v4();
109        let result = CreateQuestionRequest::new(
110            author_id,
111            "johndoe",
112            "invalid/repo",
113            "Title".to_string(),
114            "Body".to_string(),
115        );
116
117        assert!(matches!(result, Err(QuestionError::InvalidOwnerName(_))));
118    }
119}
120