nautobot 0.3.1

ergonomic rust client for Nautobot REST API
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

//! virtualization endpoints.
//!
//! basic usage:
//! ```no_run
//! # use nautobot::{Client, ClientConfig};
//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
//! # let client = Client::new(ClientConfig::new("https://nautobot.example.com", "token"))?;
//! let items = client.virtualization().cluster_groups().list(None).await?;
//! println!("{}", items.count);
//! # Ok(())
//! # }
//! ```

use crate::Client;
use crate::resource::Resource;

/// ClusterGroup model.
pub type ClusterGroup = crate::models::ClusterGroup;
/// ClusterType model.
pub type ClusterType = crate::models::ClusterType;
/// Cluster model.
pub type Cluster = crate::models::Cluster;
/// VmInterface model.
pub type VmInterface = crate::models::VmInterface;
/// VirtualMachine model.
pub type VirtualMachine = crate::models::VirtualMachine;

/// resource for virtualization/cluster-groups/.
pub type ClusterGroupsApi = Resource<crate::models::ClusterGroup>;
/// resource for virtualization/cluster-types/.
pub type ClusterTypesApi = Resource<crate::models::ClusterType>;
/// resource for virtualization/clusters/.
pub type ClustersApi = Resource<crate::models::Cluster>;
/// resource for virtualization/interfaces/.
pub type InterfacesApi = Resource<crate::models::VmInterface>;
/// resource for virtualization/virtual-machines/.
pub type VirtualMachinesApi = Resource<crate::models::VirtualMachine>;

/// api for virtualization endpoints.
#[derive(Clone)]
pub struct VirtualizationApi {
    client: Client,
}

impl VirtualizationApi {
    pub(crate) fn new(client: Client) -> Self {
        Self { client }
    }

    /// returns the cluster groups resource.
    pub fn cluster_groups(&self) -> ClusterGroupsApi {
        Resource::new(self.client.clone(), "virtualization/cluster-groups/")
    }

    /// returns the cluster types resource.
    pub fn cluster_types(&self) -> ClusterTypesApi {
        Resource::new(self.client.clone(), "virtualization/cluster-types/")
    }

    /// returns the clusters resource.
    pub fn clusters(&self) -> ClustersApi {
        Resource::new(self.client.clone(), "virtualization/clusters/")
    }

    /// returns the interfaces resource.
    pub fn interfaces(&self) -> InterfacesApi {
        Resource::new(self.client.clone(), "virtualization/interfaces/")
    }

    /// returns the virtual machines resource.
    pub fn virtual_machines(&self) -> VirtualMachinesApi {
        Resource::new(self.client.clone(), "virtualization/virtual-machines/")
    }
}

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

    fn test_client() -> Client {
        let config = ClientConfig::new("https://nautobot.example.com", "token");
        Client::new(config).unwrap()
    }

    fn assert_path<T>(resource: Resource<T>, expected: &str)
    where
        T: serde::de::DeserializeOwned,
    {
        let paginator = resource.paginate(None).unwrap();
        assert_eq!(paginator.next_url(), Some(expected));
    }

    #[test]
    fn virtualization_accessors_return_expected_paths() {
        let api = VirtualizationApi::new(test_client());

        assert_path(api.cluster_groups(), "virtualization/cluster-groups/");
        assert_path(api.cluster_types(), "virtualization/cluster-types/");
        assert_path(api.clusters(), "virtualization/clusters/");
        assert_path(api.interfaces(), "virtualization/interfaces/");
        assert_path(api.virtual_machines(), "virtualization/virtual-machines/");
    }
}