1use uuid::Uuid;
2
3use crate::dto::{OwnerName, RepositoryName};
4use crate::error::RepositoryError;
5use crate::model::{RepositoryOwnerType, RepositoryVisibility};
6
7#[derive(Debug, Clone)]
8pub struct CreateRepositoryRequest {
9    pub name: RepositoryName,
10    pub user_id: Uuid,
11    pub owner_name: OwnerName,
12    pub owner_type: RepositoryOwnerType,
13    pub visibility: RepositoryVisibility,
14}
15
16impl CreateRepositoryRequest {
17    pub fn new(
18        repo_name: &str,
19        user_id: Uuid,
20        owner_name: &str,
21        owner_type: &str,
22        visibility: &str,
23    ) -> Result<Self, RepositoryError> {
24        Ok(Self {
25            name: RepositoryName::try_new(repo_name)
26                .map_err(|e| RepositoryError::InvalidRepositoryName(e.to_string()))?,
27            user_id,
28            owner_name: OwnerName::try_new(owner_name)
29                .map_err(|e| RepositoryError::InvalidOwnerName(e.to_string()))?,
30            owner_type: owner_type.try_into()?,
31            visibility: visibility.try_into()?,
32        })
33    }
34}
35
36#[cfg(test)]
37mod tests {
38    use super::*;
39
40    #[test]
41    fn valid_request() {
42        let user_id = Uuid::new_v4();
43        let request =
44            CreateRepositoryRequest::new("my-repo", user_id, "johndoe", "user", "public").unwrap();
45
46        assert_eq!(request.name.as_ref(), "my-repo");
47        assert_eq!(request.user_id, user_id);
48        assert_eq!(request.owner_name.as_ref(), "johndoe");
49        assert_eq!(request.owner_type, RepositoryOwnerType::User);
50        assert_eq!(request.visibility, RepositoryVisibility::Public);
51    }
52
53    #[test]
54    fn valid_private_org_repository() {
55        let user_id = Uuid::new_v4();
56        let request =
57            CreateRepositoryRequest::new("repo", user_id, "myorg", "organization", "private")
58                .unwrap();
59
60        assert_eq!(request.owner_type, RepositoryOwnerType::Organization);
61        assert_eq!(request.visibility, RepositoryVisibility::Private);
62    }
63
64    #[test]
65    fn strips_git_suffix_from_repo_name() {
66        let user_id = Uuid::new_v4();
67        let request =
68            CreateRepositoryRequest::new("my-repo.git", user_id, "johndoe", "user", "public")
69                .unwrap();
70
71        assert_eq!(request.name.as_ref(), "my-repo");
72    }
73
74    #[test]
75    fn rejects_invalid_repo_name() {
76        let user_id = Uuid::new_v4();
77        let result =
78            CreateRepositoryRequest::new("invalid/repo", user_id, "johndoe", "user", "public");
79
80        assert!(matches!(
81            result,
82            Err(RepositoryError::InvalidRepositoryName(_))
83        ));
84    }
85
86    #[test]
87    fn rejects_invalid_owner_name() {
88        let user_id = Uuid::new_v4();
89        let result =
90            CreateRepositoryRequest::new("my-repo", user_id, "invalid@owner", "user", "public");
91
92        assert!(matches!(result, Err(RepositoryError::InvalidOwnerName(_))));
93    }
94
95    #[test]
96    fn rejects_invalid_owner_type() {
97        let user_id = Uuid::new_v4();
98        let result =
99            CreateRepositoryRequest::new("my-repo", user_id, "johndoe", "invalid", "public");
100
101        assert!(matches!(result, Err(RepositoryError::InvalidOwnerType(_))));
102    }
103
104    #[test]
105    fn rejects_invalid_visibility() {
106        let user_id = Uuid::new_v4();
107        let result = CreateRepositoryRequest::new("my-repo", user_id, "johndoe", "user", "invalid");
108
109        assert!(matches!(result, Err(RepositoryError::InvalidVisibility(_))));
110    }
111}
112