gitignore-template-generator 0.3.3

A binary crate to generate templates for .gitignore files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

pub use crate::http_client::impls::{MockClient, UreqClient};

#[derive(Clone, PartialEq, Debug)]
pub struct ProgramError {
    pub message: String,
    pub exit_status: i32,
}

pub trait HttpClient {
    fn get(&self, url: &str) -> Result<String, ProgramError>;
}

#[cfg(test)]
mod tests {
    use super::*;
    use mockito::Server;

    mod ureq_client {
        use super::*;

        mod get {
            use super::*;

            #[test]
            fn it_fetches_data_correctly_with_ureq_client() {
                let api_response = "gitignore template for rust";
                let mut server = Server::new();
                let base_url = server.url();
                let uri = "/api/rust";

                let mock = server
                    .mock("GET", uri)
                    .with_status(200)
                    .with_body(api_response)
                    .create();

                let client = UreqClient::default();
                let expected: Result<String, ProgramError> =
                    Ok(String::from(api_response));
                let actual = client.get(&format!("{base_url}{uri}"));

                mock.assert();
                assert_eq!(actual, expected);
            }

            #[test]
            fn it_fetches_data_correctly_with_ureq_client_and_server_url() {
                let api_response = "gitignore template for rust";
                let mut server = Server::new();
                let base_url = server.url();
                let uri = "/api/rust";

                let mock = server
                    .mock("GET", uri)
                    .with_status(200)
                    .with_body(api_response)
                    .create();

                let client = UreqClient {
                    server_url: base_url,
                };
                let expected: Result<String, ProgramError> =
                    Ok(String::from(api_response));
                let actual = client.get(uri);

                mock.assert();
                assert_eq!(actual, expected);
            }

            #[test]
            fn it_gracefully_fails_if_non_200_response_with_ureq_client() {
                let api_response = "error response";
                let mut server = Server::new();
                let base_url = server.url();
                let uri = "/api/rust";

                let mock = server
                    .mock("GET", uri)
                    .with_status(400)
                    .with_body(api_response)
                    .create();

                let client = UreqClient::default();
                let expected: Result<String, ProgramError> = Err(
                    ProgramError {
                        message: String::from(
                            "An error occurred during the API call: http status: 400",
                        ),
                        exit_status: 2,
                    },
                );
                let actual = client.get(&format!("{base_url}{uri}"));

                mock.assert();
                assert_eq!(actual, expected);
            }

            #[test]
            fn it_gracefully_fails_if_body_parsing_issue_with_ureq_client() {
                let mut server = Server::new();
                let base_url = server.url();
                let uri = "/api/rust";

                let mock = server
                    .mock("GET", uri)
                    .with_status(200)
                    .with_body(vec![0, 159, 146, 150])
                    .create();

                let client = UreqClient::default();
                let expected: Result<String, ProgramError> =
                    Err(ProgramError {
                        message: String::from(
                            "An error occurred during body parsing",
                        ),
                        exit_status: 3,
                    });
                let actual = client.get(&format!("{base_url}{uri}"));

                mock.assert();
                assert_eq!(actual, expected);
            }
        }
    }

    mod mock_client {
        use super::*;

        mod get {
            use super::*;

            #[test]
            fn it_returns_given_result_with_mock_client() {
                let client = MockClient {
                    response: Ok(String::from("success response")),
                };

                let expected: Result<String, ProgramError> =
                    Ok(String::from("success response"));
                let actual = client.get("/api/rust");

                assert_eq!(actual, expected);
            }
        }
    }
}