toggl 0.3.0

Unofficial command-line interface for Toggl Track using the v9 API.
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
147
148
149
150
151
152
153

use crate::api::client::ApiClient;
use crate::credentials;
use crate::models;
use colored::Colorize;
use credentials::CredentialsStorage;
use models::ResultWithDefaultError;
use std::io::Write;

pub struct AuthenticationCommand;

const AUTH_SUCCEEDED_MESSAGE: &str = "Successfully authenticated for user with email:";

impl AuthenticationCommand {
    pub async fn execute<W: Write>(
        mut writer: W,
        api_client: impl ApiClient,
        credentials_storage: impl CredentialsStorage,
    ) -> ResultWithDefaultError<()> {
        let user = api_client.get_user().await?;
        credentials_storage.persist(user.api_token)?;
        writeln!(
            writer,
            "{} {}",
            AUTH_SUCCEEDED_MESSAGE.green(),
            user.email.green().bold(),
        )?;

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::api::client::MockApiClient;
    use crate::error;
    use credentials::MockCredentialsStorage;
    use error::{ApiError, StorageError};
    use models::User;
    use tokio_test::assert_err;
    use tokio_test::assert_ok;

    const MOCK_API_TOKEN: &str = "SOME_API_TOKEN_VALUE";
    const MOCK_EMAIL: &str = "toggl@user.org";
    const MOCK_USER_NAME: &str = "Toggl User";

    fn create_working_api_client() -> MockApiClient {
        let mut api_client = MockApiClient::new();
        let user = User {
            api_token: MOCK_API_TOKEN.to_string(),
            email: MOCK_EMAIL.to_string(),
            fullname: Some(MOCK_USER_NAME.to_string()),
            timezone: "UTC".to_string(),
            default_workspace_id: 1,
        };

        api_client
            .expect_get_user()
            .returning(move || Ok(user.clone()));

        api_client
    }

    fn create_failing_api_client() -> MockApiClient {
        let mut api_client = MockApiClient::new();
        api_client
            .expect_get_user()
            .returning(|| Err(Box::new(ApiError::Network)));

        api_client
    }

    fn create_working_credentials_storage() -> MockCredentialsStorage {
        let mut credentials_storage = MockCredentialsStorage::new();
        credentials_storage.expect_persist().returning(|_| Ok(()));
        credentials_storage
    }

    fn create_failing_credentials_storage() -> MockCredentialsStorage {
        let mut credentials_storage = MockCredentialsStorage::new();
        credentials_storage
            .expect_persist()
            .returning(|_| Err(Box::new(StorageError::Write)));
        credentials_storage
    }

    #[tokio::test]
    async fn a_valid_api_call_and_a_working_storage_returns_an_ok_result() {
        // Arrange
        let mut output = Vec::new();
        let api_client = create_working_api_client();
        let credentials_storage = create_working_credentials_storage();

        // Act
        let result =
            AuthenticationCommand::execute(&mut output, api_client, credentials_storage).await;

        // Assert
        assert_ok!(result);
    }

    #[tokio::test]
    async fn a_valid_api_call_and_a_working_storage_prints_a_success_message() {
        // Arrange
        let mut output = Vec::new();
        let api_client = create_working_api_client();
        let credentials_storage = create_working_credentials_storage();

        // Act
        let _ = AuthenticationCommand::execute(&mut output, api_client, credentials_storage).await;

        // Assert
        let expected_output = format!(
            "{} {}\n",
            AUTH_SUCCEEDED_MESSAGE.green(),
            MOCK_EMAIL.green().bold()
        );
        let actual_output = String::from_utf8(output)
            .unwrap_or_else(|_| panic!("empty output when {} was expected", expected_output));

        assert_eq!(expected_output, actual_output);
    }

    #[tokio::test]
    async fn a_failing_api_call_returns_an_error() {
        // Arrange
        let mut output = Vec::new();
        let api_client = create_failing_api_client();
        let credentials_storage = create_working_credentials_storage();

        // Act
        let result =
            AuthenticationCommand::execute(&mut output, api_client, credentials_storage).await;

        // Assert
        assert_err!(result);
    }

    #[tokio::test]
    async fn a_failing_storage_persist_call_returns_an_error() {
        // Arrange
        let mut output = Vec::new();
        let api_client = create_working_api_client();
        let credentials_storage = create_failing_credentials_storage();

        // Act
        let result =
            AuthenticationCommand::execute(&mut output, api_client, credentials_storage).await;

        // Assert
        assert_err!(result);
    }
}