appwrite 0.12.0

Appwrite SDK for Rust
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

//! DatabaseStatus model for Appwrite SDK

use serde::{Deserialize, Serialize};

/// Status
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(test, derive(Default))]
pub struct DatabaseStatus {
    /// Overall health status: healthy, degraded, or unhealthy.
    #[serde(rename = "health")]
    pub health: String,
    /// Whether the database is ready to accept connections.
    #[serde(rename = "ready")]
    pub ready: bool,
    /// Database engine: postgresql, mysql, mariadb, or mongodb.
    #[serde(rename = "engine")]
    pub engine: String,
    /// Database engine version.
    #[serde(rename = "version")]
    pub version: String,
    /// Database uptime in seconds.
    #[serde(rename = "uptime")]
    pub uptime: i64,
    /// Connection statistics.
    #[serde(rename = "connections")]
    pub connections: crate::models::DatabaseStatusConnections,
    /// List of database replicas and their status.
    #[serde(rename = "replicas")]
    pub replicas: Vec<crate::models::DatabaseStatusReplica>,
    /// Storage volume information.
    #[serde(rename = "volumes")]
    pub volumes: Vec<crate::models::DatabaseStatusVolume>,
}

impl DatabaseStatus {
    /// Get health
    pub fn health(&self) -> &String {
        &self.health
    }

    /// Get ready
    pub fn ready(&self) -> &bool {
        &self.ready
    }

    /// Get engine
    pub fn engine(&self) -> &String {
        &self.engine
    }

    /// Get version
    pub fn version(&self) -> &String {
        &self.version
    }

    /// Get uptime
    pub fn uptime(&self) -> &i64 {
        &self.uptime
    }

    /// Get connections
    pub fn connections(&self) -> &crate::models::DatabaseStatusConnections {
        &self.connections
    }

    /// Get replicas
    pub fn replicas(&self) -> &Vec<crate::models::DatabaseStatusReplica> {
        &self.replicas
    }

    /// Get volumes
    pub fn volumes(&self) -> &Vec<crate::models::DatabaseStatusVolume> {
        &self.volumes
    }

}

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

    #[test]
    fn test_database_status_creation() {
        let _model = <DatabaseStatus as Default>::default();
        let _ = _model.health();
        let _ = _model.ready();
        let _ = _model.engine();
        let _ = _model.version();
        let _ = _model.uptime();
        let _ = _model.connections();
        let _ = _model.replicas();
        let _ = _model.volumes();
    }

    #[test]
    fn test_database_status_serialization() {
        let model = <DatabaseStatus as Default>::default();
        let json = serde_json::to_string(&model);
        assert!(json.is_ok());

        let deserialized: Result<DatabaseStatus, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
    }
}