nextcloud-goa 0.1.1

GNOME Online Accounts integration for the Nextcloud Rust SDK
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

//! Nextcloud account discovered via GNOME Online Accounts.

use std::fmt;

use nextcloud_auth::BasicAuth;
use nextcloud_sdk_core::ServerUrl;

/// A Nextcloud or ownCloud account discovered via GNOME Online Accounts.
///
/// This type holds account metadata along with assembled [`BasicAuth`] credentials
/// retrieved from the desktop session's secure credential store.
#[derive(Clone)]
pub struct GoaAccount {
    id: String,
    username: String,
    server_url: ServerUrl,
    auth: BasicAuth,
    presentation_identity: String,
}

impl GoaAccount {
    /// Creates a new [`GoaAccount`].
    pub fn new(
        id: impl Into<String>,
        username: impl Into<String>,
        server_url: ServerUrl,
        auth: BasicAuth,
        presentation_identity: impl Into<String>,
    ) -> Self {
        Self {
            id: id.into(),
            username: username.into(),
            server_url,
            auth,
            presentation_identity: presentation_identity.into(),
        }
    }

    /// The GNOME Online Accounts internal identifier (e.g. `account_1234`).
    pub fn id(&self) -> &str {
        &self.id
    }

    /// The user name associated with the account.
    pub fn username(&self) -> &str {
        &self.username
    }

    /// The base URL of the Nextcloud instance.
    pub fn server_url(&self) -> &ServerUrl {
        &self.server_url
    }

    /// The basic authentication credentials for API requests.
    pub fn auth(&self) -> &BasicAuth {
        &self.auth
    }

    /// Presentation identity suitable for displaying in a user interface.
    pub fn presentation_identity(&self) -> &str {
        &self.presentation_identity
    }
}

impl fmt::Debug for GoaAccount {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GoaAccount")
            .field("id", &self.id)
            .field("username", &self.username)
            .field("server_url", &self.server_url)
            .field("auth", &"[REDACTED]")
            .field("presentation_identity", &self.presentation_identity)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use nextcloud_auth::{AppPassword, BasicAuth, SecretString};
    use nextcloud_sdk_core::ServerUrl;

    use super::GoaAccount;

    fn sample_account() -> GoaAccount {
        let secret = SecretString::new("super-secret-password".to_owned());
        let creds = AppPassword::new("alice", secret);
        let auth = BasicAuth::from_app_password(creds);
        let url = ServerUrl::parse("https://cloud.example.com").unwrap();

        GoaAccount::new(
            "account_1234",
            "alice",
            url,
            auth,
            "alice@cloud.example.com",
        )
    }

    #[test]
    fn getters_return_expected_values() {
        let account = sample_account();

        assert_eq!(account.id(), "account_1234");
        assert_eq!(account.username(), "alice");
        assert_eq!(account.server_url().as_str(), "https://cloud.example.com");
        assert_eq!(account.presentation_identity(), "alice@cloud.example.com");
        assert_eq!(account.auth().credentials().user(), "alice");
    }

    #[test]
    fn debug_redacts_auth_and_secrets() {
        let account = sample_account();
        let debug_repr = format!("{account:?}");

        assert!(debug_repr.contains("account_1234"));
        assert!(debug_repr.contains("alice"));
        assert!(debug_repr.contains("https://cloud.example.com"));
        assert!(debug_repr.contains("alice@cloud.example.com"));
        assert!(debug_repr.contains("[REDACTED]"));

        // Ensure password plaintext or basic auth base64 never appears
        assert!(!debug_repr.contains("super-secret-password"));
        assert!(!debug_repr.contains("Basic "));
    }
}