gitignore-template-generator 0.3.11

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

pub use crate::core::impls::GitignoreTemplateGenerator;
use crate::http_client::HttpClient;

#[derive(Clone, PartialEq, Debug)]
pub struct ProgramError {
    pub message: String,
    pub exit_status: i32,
    pub styled_message: Option<String>,
    pub error_kind: ErrorKind,
}

#[derive(Clone, PartialEq, Debug)]
pub enum ErrorKind {
    VersionInfos,
    HelpInfos,
    AuthorInfos,
    Other,
}

pub trait TemplateGenerator {
    fn generate_from_api(
        http_client: &impl HttpClient,
        template_names: &[String],
    ) -> Result<String, ProgramError>;
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::helper::make_string_vec;
    use crate::http_client::MockClient;

    mod gitignore_template_generator {
        use super::*;

        mod generate_from_api {
            use super::*;

            mod success {

                use super::*;

                #[test]
                fn it_generates_template_using_provided_client() {
                    let template_names = make_string_vec("rust python");
                    let generated_template = "all good";
                    let http_client = MockClient {
                        response: Ok(String::from(generated_template)),
                    };

                    let actual = GitignoreTemplateGenerator::generate_from_api(
                        &http_client,
                        &template_names,
                    );
                    let expected: Result<String, ProgramError> =
                        Ok(String::from(generated_template));

                    assert_eq!(actual, expected);
                }
            }

            mod failure {
                use crate::constant;

                use super::*;

                #[test]
                fn it_propagates_error_from_client_if_any() {
                    let template_names = make_string_vec("rust pyth");
                    let error_message = "all bad";
                    let http_client = MockClient {
                        response: Err(ProgramError {
                            message: String::from(error_message),
                            exit_status: constant::exit_status::GENERIC,
                            styled_message: None,
                            error_kind: ErrorKind::Other,
                        }),
                    };

                    let actual = GitignoreTemplateGenerator::generate_from_api(
                        &http_client,
                        &template_names,
                    );
                    let expected: Result<String, ProgramError> =
                        Err(ProgramError {
                            message: String::from(error_message),
                            exit_status: constant::exit_status::GENERIC,
                            styled_message: None,
                            error_kind: ErrorKind::Other,
                        });

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