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