gcloud_spanner/admin/instance/
mod.rs

1pub mod instance_admin_client;
2
3#[cfg(test)]
4mod tests {
5    use serial_test::serial;
6    use time::OffsetDateTime;
7
8    use google_cloud_gax::conn::{ConnectionManager, ConnectionOptions, Environment};
9    use google_cloud_googleapis::spanner::admin::instance::v1::instance::State;
10
11    use google_cloud_googleapis::spanner::admin::instance::v1::{
12        CreateInstanceRequest, DeleteInstanceRequest, GetInstanceConfigRequest, GetInstanceRequest, Instance,
13        ListInstanceConfigsRequest, ListInstancesRequest,
14    };
15    use google_cloud_longrunning::autogen::operations_client::OperationsClient;
16
17    use crate::admin::instance::instance_admin_client::InstanceAdminClient;
18    use crate::apiv1::conn_pool::{AUDIENCE, SPANNER};
19
20    async fn new_client() -> InstanceAdminClient {
21        let conn_pool = ConnectionManager::new(
22            1,
23            SPANNER,
24            AUDIENCE,
25            &Environment::Emulator("localhost:9010".to_string()),
26            &ConnectionOptions::default(),
27        )
28        .await
29        .unwrap();
30        let lro_client = OperationsClient::new(conn_pool.conn()).await.unwrap();
31        InstanceAdminClient::new(conn_pool.conn(), lro_client)
32    }
33
34    async fn create_instance() -> Instance {
35        let client = new_client().await;
36        let instance_id = format!("test{}ut", OffsetDateTime::now_utc().unix_timestamp_nanos());
37        let name = format!("projects/local-project/instances/{instance_id}");
38        let request = CreateInstanceRequest {
39            parent: "projects/local-project".to_string(),
40            instance_id: instance_id.to_string(),
41            instance: Some(Instance {
42                name: name.to_string(),
43                config: "".to_string(),
44                display_name: "test-instance-ut".to_string(),
45                node_count: 0,
46                processing_units: 0,
47                replica_compute_capacity: vec![],
48                autoscaling_config: None,
49                state: 0,
50                labels: Default::default(),
51                instance_type: 0,
52                endpoint_uris: vec![],
53                create_time: None,
54                update_time: None,
55                free_instance_metadata: None,
56                edition: 0,
57                default_backup_schedule_type: 0,
58            }),
59        };
60
61        let creation_result = match client.create_instance(request, None).await {
62            Ok(mut res) => res.wait(None).await,
63            Err(err) => panic!("err: {err:?}"),
64        };
65        match creation_result {
66            Ok(res) => res.unwrap(),
67            Err(err) => panic!("err: {err:?}"),
68        }
69    }
70
71    #[tokio::test]
72    #[serial]
73    async fn test_create_instance() {
74        let instance = create_instance().await;
75        assert_eq!(instance.state, State::Ready as i32);
76    }
77
78    #[tokio::test]
79    #[serial]
80    async fn test_get_instance() {
81        let client = new_client().await;
82        let name = "projects/local-project/instances/test-instance".to_string();
83        let request = GetInstanceRequest {
84            name: name.clone(),
85            field_mask: None,
86        };
87
88        match client.get_instance(request, None).await {
89            Ok(res) => {
90                let instance = res.into_inner();
91                assert_eq!(instance.name, name);
92            }
93            Err(err) => panic!("err: {err:?}"),
94        };
95    }
96
97    #[tokio::test]
98    #[serial]
99    async fn test_delete_instance() {
100        let instance = create_instance().await;
101        let client = new_client().await;
102        let request = DeleteInstanceRequest {
103            name: instance.name.to_string(),
104        };
105        let _ = client.delete_instance(request, None).await.unwrap();
106    }
107
108    #[tokio::test]
109    #[serial]
110    async fn test_list_instances() {
111        let client = new_client().await;
112        let request = ListInstancesRequest {
113            parent: "projects/local-project".to_string(),
114            page_size: 1,
115            page_token: "".to_string(),
116            filter: "".to_string(),
117            instance_deadline: None,
118        };
119
120        match client.list_instances(request, None).await {
121            Ok(res) => {
122                println!("size = {}", res.len());
123                assert!(!res.is_empty());
124            }
125            Err(err) => panic!("err: {err:?}"),
126        };
127    }
128
129    #[tokio::test]
130    #[serial]
131    async fn test_list_instance_configs() {
132        let client = new_client().await;
133        let request = ListInstanceConfigsRequest {
134            parent: "projects/local-project".to_string(),
135            page_size: 1,
136            page_token: "".to_string(),
137        };
138
139        match client.list_instance_configs(request, None).await {
140            Ok(res) => {
141                println!("size = {}", res.len());
142                assert!(!res.is_empty());
143            }
144            Err(err) => panic!("err: {err:?}"),
145        };
146    }
147
148    #[tokio::test]
149    #[serial]
150    async fn test_get_instance_config() {
151        let client = new_client().await;
152        let name = "projects/local-project/instanceConfigs/emulator-config".to_string();
153        let request = GetInstanceConfigRequest { name: name.clone() };
154
155        match client.get_instance_config(request, None).await {
156            Ok(res) => {
157                let instance = res;
158                assert_eq!(instance.name, name);
159            }
160            Err(err) => panic!("err: {err:?}"),
161        };
162    }
163}
gcloud_spanner/admin/instance/mod.rs

gcloud_spanner/admin/instance/
mod.rs
