Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit cba862d

Browse files
Empty2k12Empty2k12
authoredFeb 7, 2020
Release v0.0.6 (#47)
* Prepare Release 0.0.6 * Format and Lint Fixes
1 parent 1b0cae1 commit cba862d

File tree

5 files changed

+245
-266
lines changed

5 files changed

+245
-266
lines changed
 

‎CHANGELOG.md

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
77

88
## [Unreleased]
99

10+
## [0.0.6] - 2020-02-07
11+
1012
### Changed
1113

12-
- Rewrite to `async` / `await`. Rust 1.39 is now the minimum required Rust version.
14+
- Rewrite to `async` / `await`. Rust 1.39 is now the minimum required Rust version.
1315

1416
## [0.0.5] - 2019-08-16
1517

@@ -58,7 +60,8 @@ This release removes the prefix `InfluxDb` of most types in this library and ree
5860
- Improved Test Coverage: There's now even more tests verifying correctness of the crate (#5)
5961
- It's no longer necessary to supply a wildcard generic when working with serde*integration: `client.json_query::<Weather>(query)` instead of `client.json_query::<Weather, *>(query)`
6062

61-
[unreleased]: https://github.com/Empty2k12/influxdb-rust/compare/v0.0.5...HEAD
63+
[unreleased]: https://github.com/Empty2k12/influxdb-rust/compare/v0.0.6...HEAD
64+
[0.0.5]: https://github.com/Empty2k12/influxdb-rust/compare/v0.0.5...v0.0.6
6265
[0.0.5]: https://github.com/Empty2k12/influxdb-rust/compare/v0.0.5...v0.0.5
6366
[0.0.4]: https://github.com/Empty2k12/influxdb-rust/compare/v0.0.3...v0.0.4
6467
[0.0.3]: https://github.com/Empty2k12/influxdb-rust/compare/v0.0.2...v0.0.3

‎Cargo.toml

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "influxdb"
3-
version = "0.0.5"
3+
version = "0.0.6"
44
authors = ["Gero Gerke <11deutron11@gmail.com>"]
55
edition = "2018"
66
description = "InfluxDB Driver for Rust"
@@ -14,17 +14,17 @@ repository = "https://github.com/Empty2k12/influxdb-rust"
1414
travis-ci = { repository = "Empty2k12/influxdb-rust", branch = "master" }
1515

1616
[dependencies]
17-
chrono = { version = "0.4.9", optional = true }
18-
failure = "0.1.5"
19-
futures = "0.3.1"
20-
reqwest = { version = "0.10", features = ["json"] }
21-
serde = { version = "1.0.92", features = ["derive"], optional = true }
22-
serde_json = { version = "1.0", optional = true }
17+
chrono = { version = "0.4.10", optional = true }
18+
failure = "0.1.6"
19+
futures = "0.3.4"
20+
reqwest = { version = "0.10.1", features = ["json"] }
21+
serde = { version = "1.0.104", features = ["derive"], optional = true }
22+
serde_json = { version = "1.0.46", optional = true }
2323

2424
[features]
2525
use-serde = ["serde", "serde_json"]
2626
chrono_timestamps = ["chrono"]
2727
default = ["use-serde"]
2828

2929
[dev-dependencies]
30-
tokio = { version = "0.2", features = ["macros"] }
30+
tokio = { version = "0.2.11", features = ["macros"] }

‎README.md

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,8 @@ Pull requests are always welcome. See [Contributing](https://github.com/Empty2k1
4040
- Running multiple queries in one request (e.g. `SELECT * FROM weather_berlin; SELECT * FROM weather_london`)
4141
- Authenticated and Unauthenticated Connections
4242
- Optional conversion between `Timestamp` and `Chrono::DateTime<Utc>` via `chrono_timestamps` compilation feature
43+
- `async`/`await` support
44+
4345
### Planned Features
4446

4547
- Read Query Builder instead of supplying raw queries
@@ -50,7 +52,7 @@ Pull requests are always welcome. See [Contributing](https://github.com/Empty2k1
5052
Add the following to your `Cargo.toml`
5153

5254
```toml
53-
influxdb = "0.0.5"
55+
influxdb = "0.0.6"
5456
```
5557

5658
For an example with using Serde deserialization, please refer to [serde_integration](crate::integrations::serde_integration)

‎src/lib.rs

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,8 @@
1111
//! - Running multiple queries in one request (e.g. `SELECT * FROM weather_berlin; SELECT * FROM weather_london`)
1212
//! - Authenticated and Unauthenticated Connections
1313
//! - Optional conversion between `Timestamp` and `Chrono::DateTime<Utc>` via `chrono_timestamps` compilation feature
14+
//! - `async`/`await` support
15+
//!
1416
//! ## Planned Features
1517
//!
1618
//! - Read Query Builder instead of supplying raw queries
@@ -21,7 +23,7 @@
2123
//! Add the following to your `Cargo.toml`
2224
//!
2325
//! ```toml
24-
//! influxdb = "0.0.5"
26+
//! influxdb = "0.0.6"
2527
//! ```
2628
//!
2729
//! For an example with using Serde deserialization, please refer to [serde_integration](crate::integrations::serde_integration)

‎tests/integration_tests.rs

Lines changed: 226 additions & 254 deletions
Original file line numberDiff line numberDiff line change
@@ -101,43 +101,39 @@ async fn test_authed_write_and_read() {
101101
const TEST_NAME: &str = "test_authed_write_and_read";
102102

103103
run_test(
104-
|| {
105-
async move {
106-
let client =
107-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
108-
let query = format!("CREATE DATABASE {}", TEST_NAME);
109-
client
110-
.query(&Query::raw_read_query(query))
111-
.await
112-
.expect("could not setup db");
113-
114-
let client =
115-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
116-
let write_query = Query::write_query(Timestamp::Hours(11), "weather")
117-
.add_field("temperature", 82);
118-
let write_result = client.query(&write_query).await;
119-
assert_result_ok(&write_result);
120-
121-
let read_query = Query::raw_read_query("SELECT * FROM weather");
122-
let read_result = client.query(&read_query).await;
123-
assert_result_ok(&read_result);
124-
assert!(
125-
!read_result.unwrap().contains("error"),
126-
"Data contained a database error"
127-
);
128-
}
104+
|| async move {
105+
let client =
106+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
107+
let query = format!("CREATE DATABASE {}", TEST_NAME);
108+
client
109+
.query(&Query::raw_read_query(query))
110+
.await
111+
.expect("could not setup db");
112+
113+
let client =
114+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
115+
let write_query =
116+
Query::write_query(Timestamp::Hours(11), "weather").add_field("temperature", 82);
117+
let write_result = client.query(&write_query).await;
118+
assert_result_ok(&write_result);
119+
120+
let read_query = Query::raw_read_query("SELECT * FROM weather");
121+
let read_result = client.query(&read_query).await;
122+
assert_result_ok(&read_result);
123+
assert!(
124+
!read_result.unwrap().contains("error"),
125+
"Data contained a database error"
126+
);
129127
},
130-
|| {
131-
async move {
132-
let client =
133-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
134-
let query = format!("DROP DATABASE {}", TEST_NAME);
135-
136-
client
137-
.query(&Query::raw_read_query(query))
138-
.await
139-
.expect("could not clean up db");
140-
}
128+
|| async move {
129+
let client =
130+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
131+
let query = format!("DROP DATABASE {}", TEST_NAME);
132+
133+
client
134+
.query(&Query::raw_read_query(query))
135+
.await
136+
.expect("could not clean up db");
141137
},
142138
)
143139
.await;
@@ -151,65 +147,61 @@ async fn test_wrong_authed_write_and_read() {
151147
const TEST_NAME: &str = "test_wrong_authed_write_and_read";
152148

153149
run_test(
154-
|| {
155-
async move {
156-
let client =
157-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
158-
let query = format!("CREATE DATABASE {}", TEST_NAME);
159-
client
160-
.query(&Query::raw_read_query(query))
161-
.await
162-
.expect("could not setup db");
163-
164-
let client = Client::new("http://localhost:9086", TEST_NAME)
165-
.with_auth("wrong_user", "password");
166-
let write_query = Query::write_query(Timestamp::Hours(11), "weather")
167-
.add_field("temperature", 82);
168-
let write_result = client.query(&write_query).await;
169-
assert_result_err(&write_result);
170-
match write_result {
171-
Err(Error::AuthorizationError) => {}
172-
_ => panic!(format!(
173-
"Should be an AuthorizationError: {}",
174-
write_result.unwrap_err()
175-
)),
176-
}
150+
|| async move {
151+
let client =
152+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
153+
let query = format!("CREATE DATABASE {}", TEST_NAME);
154+
client
155+
.query(&Query::raw_read_query(query))
156+
.await
157+
.expect("could not setup db");
158+
159+
let client =
160+
Client::new("http://localhost:9086", TEST_NAME).with_auth("wrong_user", "password");
161+
let write_query =
162+
Query::write_query(Timestamp::Hours(11), "weather").add_field("temperature", 82);
163+
let write_result = client.query(&write_query).await;
164+
assert_result_err(&write_result);
165+
match write_result {
166+
Err(Error::AuthorizationError) => {}
167+
_ => panic!(format!(
168+
"Should be an AuthorizationError: {}",
169+
write_result.unwrap_err()
170+
)),
171+
}
177172

178-
let read_query = Query::raw_read_query("SELECT * FROM weather");
179-
let read_result = client.query(&read_query).await;
180-
assert_result_err(&read_result);
181-
match read_result {
182-
Err(Error::AuthorizationError) => {}
183-
_ => panic!(format!(
184-
"Should be an AuthorizationError: {}",
185-
read_result.unwrap_err()
186-
)),
187-
}
173+
let read_query = Query::raw_read_query("SELECT * FROM weather");
174+
let read_result = client.query(&read_query).await;
175+
assert_result_err(&read_result);
176+
match read_result {
177+
Err(Error::AuthorizationError) => {}
178+
_ => panic!(format!(
179+
"Should be an AuthorizationError: {}",
180+
read_result.unwrap_err()
181+
)),
182+
}
188183

189-
let client = Client::new("http://localhost:9086", TEST_NAME)
190-
.with_auth("nopriv_user", "password");
191-
let read_query = Query::raw_read_query("SELECT * FROM weather");
192-
let read_result = client.query(&read_query).await;
193-
assert_result_err(&read_result);
194-
match read_result {
195-
Err(Error::AuthenticationError) => {}
196-
_ => panic!(format!(
197-
"Should be an AuthenticationError: {}",
198-
read_result.unwrap_err()
199-
)),
200-
}
184+
let client = Client::new("http://localhost:9086", TEST_NAME)
185+
.with_auth("nopriv_user", "password");
186+
let read_query = Query::raw_read_query("SELECT * FROM weather");
187+
let read_result = client.query(&read_query).await;
188+
assert_result_err(&read_result);
189+
match read_result {
190+
Err(Error::AuthenticationError) => {}
191+
_ => panic!(format!(
192+
"Should be an AuthenticationError: {}",
193+
read_result.unwrap_err()
194+
)),
201195
}
202196
},
203-
|| {
204-
async move {
205-
let client =
206-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
207-
let query = format!("DROP DATABASE {}", TEST_NAME);
208-
client
209-
.query(&Query::raw_read_query(query))
210-
.await
211-
.expect("could not clean up db");
212-
}
197+
|| async move {
198+
let client =
199+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
200+
let query = format!("DROP DATABASE {}", TEST_NAME);
201+
client
202+
.query(&Query::raw_read_query(query))
203+
.await
204+
.expect("could not clean up db");
213205
},
214206
)
215207
.await;
@@ -223,50 +215,46 @@ async fn test_non_authed_write_and_read() {
223215
const TEST_NAME: &str = "test_non_authed_write_and_read";
224216

225217
run_test(
226-
|| {
227-
async move {
228-
let client =
229-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
230-
let query = format!("CREATE DATABASE {}", TEST_NAME);
231-
client
232-
.query(&Query::raw_read_query(query))
233-
.await
234-
.expect("could not setup db");
235-
let non_authed_client = Client::new("http://localhost:9086", TEST_NAME);
236-
let write_query = Query::write_query(Timestamp::Hours(11), "weather")
237-
.add_field("temperature", 82);
238-
let write_result = non_authed_client.query(&write_query).await;
239-
assert_result_err(&write_result);
240-
match write_result {
241-
Err(Error::AuthorizationError) => {}
242-
_ => panic!(format!(
243-
"Should be an AuthorizationError: {}",
244-
write_result.unwrap_err()
245-
)),
246-
}
218+
|| async move {
219+
let client =
220+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
221+
let query = format!("CREATE DATABASE {}", TEST_NAME);
222+
client
223+
.query(&Query::raw_read_query(query))
224+
.await
225+
.expect("could not setup db");
226+
let non_authed_client = Client::new("http://localhost:9086", TEST_NAME);
227+
let write_query =
228+
Query::write_query(Timestamp::Hours(11), "weather").add_field("temperature", 82);
229+
let write_result = non_authed_client.query(&write_query).await;
230+
assert_result_err(&write_result);
231+
match write_result {
232+
Err(Error::AuthorizationError) => {}
233+
_ => panic!(format!(
234+
"Should be an AuthorizationError: {}",
235+
write_result.unwrap_err()
236+
)),
237+
}
247238

248-
let read_query = Query::raw_read_query("SELECT * FROM weather");
249-
let read_result = non_authed_client.query(&read_query).await;
250-
assert_result_err(&read_result);
251-
match read_result {
252-
Err(Error::AuthorizationError) => {}
253-
_ => panic!(format!(
254-
"Should be an AuthorizationError: {}",
255-
read_result.unwrap_err()
256-
)),
257-
}
239+
let read_query = Query::raw_read_query("SELECT * FROM weather");
240+
let read_result = non_authed_client.query(&read_query).await;
241+
assert_result_err(&read_result);
242+
match read_result {
243+
Err(Error::AuthorizationError) => {}
244+
_ => panic!(format!(
245+
"Should be an AuthorizationError: {}",
246+
read_result.unwrap_err()
247+
)),
258248
}
259249
},
260-
|| {
261-
async move {
262-
let client =
263-
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
264-
let query = format!("DROP DATABASE {}", TEST_NAME);
265-
client
266-
.query(&Query::raw_read_query(query))
267-
.await
268-
.expect("could not clean up db");
269-
}
250+
|| async move {
251+
let client =
252+
Client::new("http://localhost:9086", TEST_NAME).with_auth("admin", "password");
253+
let query = format!("DROP DATABASE {}", TEST_NAME);
254+
client
255+
.query(&Query::raw_read_query(query))
256+
.await
257+
.expect("could not clean up db");
270258
},
271259
)
272260
.await;
@@ -280,28 +268,24 @@ async fn test_write_and_read_field() {
280268
const TEST_NAME: &str = "test_write_field";
281269

282270
run_test(
283-
|| {
284-
async move {
285-
create_db(TEST_NAME).await.expect("could not setup db");
286-
let client = create_client(TEST_NAME);
287-
let write_query = Query::write_query(Timestamp::Hours(11), "weather")
288-
.add_field("temperature", 82);
289-
let write_result = client.query(&write_query).await;
290-
assert_result_ok(&write_result);
291-
292-
let read_query = Query::raw_read_query("SELECT * FROM weather");
293-
let read_result = client.query(&read_query).await;
294-
assert_result_ok(&read_result);
295-
assert!(
296-
!read_result.unwrap().contains("error"),
297-
"Data contained a database error"
298-
);
299-
}
271+
|| async move {
272+
create_db(TEST_NAME).await.expect("could not setup db");
273+
let client = create_client(TEST_NAME);
274+
let write_query =
275+
Query::write_query(Timestamp::Hours(11), "weather").add_field("temperature", 82);
276+
let write_result = client.query(&write_query).await;
277+
assert_result_ok(&write_result);
278+
279+
let read_query = Query::raw_read_query("SELECT * FROM weather");
280+
let read_result = client.query(&read_query).await;
281+
assert_result_ok(&read_result);
282+
assert!(
283+
!read_result.unwrap().contains("error"),
284+
"Data contained a database error"
285+
);
300286
},
301-
|| {
302-
async move {
303-
delete_db(TEST_NAME).await.expect("could not clean up db");
304-
}
287+
|| async move {
288+
delete_db(TEST_NAME).await.expect("could not clean up db");
305289
},
306290
)
307291
.await;
@@ -355,12 +339,10 @@ async fn test_write_and_read_option() {
355339
);
356340
}
357341
},
358-
|| {
359-
async move {
360-
delete_db("test_write_and_read_option")
361-
.await
362-
.expect("could not clean up db");
363-
}
342+
|| async move {
343+
delete_db("test_write_and_read_option")
344+
.await
345+
.expect("could not clean up db");
364346
},
365347
)
366348
.await;
@@ -412,10 +394,8 @@ async fn test_json_query() {
412394
);
413395
}
414396
},
415-
|| {
416-
async move {
417-
delete_db(TEST_NAME).await.expect("could not clean up db");
418-
}
397+
|| async move {
398+
delete_db(TEST_NAME).await.expect("could not clean up db");
419399
},
420400
)
421401
.await;
@@ -433,41 +413,37 @@ async fn test_json_query_vec() {
433413
const TEST_NAME: &str = "test_json_query_vec";
434414

435415
run_test(
436-
|| {
437-
async move {
438-
create_db(TEST_NAME).await.expect("could not setup db");
439-
440-
let client = create_client(TEST_NAME);
441-
let write_query1 = Query::write_query(Timestamp::Hours(11), "temperature_vec")
442-
.add_field("temperature", 16);
443-
let write_query2 = Query::write_query(Timestamp::Hours(12), "temperature_vec")
444-
.add_field("temperature", 17);
445-
let write_query3 = Query::write_query(Timestamp::Hours(13), "temperature_vec")
446-
.add_field("temperature", 18);
447-
448-
let _write_result = client.query(&write_query1).await;
449-
let _write_result2 = client.query(&write_query2).await;
450-
let _write_result2 = client.query(&write_query3).await;
451-
452-
#[derive(Deserialize, Debug, PartialEq)]
453-
struct Weather {
454-
time: String,
455-
temperature: i32,
456-
}
457-
458-
let query = Query::raw_read_query("SELECT * FROM temperature_vec");
459-
let result = client
460-
.json_query(query)
461-
.await
462-
.and_then(|mut db_result| db_result.deserialize_next::<Weather>());
463-
assert_result_ok(&result);
464-
assert_eq!(result.unwrap().series[0].values.len(), 3);
416+
|| async move {
417+
create_db(TEST_NAME).await.expect("could not setup db");
418+
419+
let client = create_client(TEST_NAME);
420+
let write_query1 = Query::write_query(Timestamp::Hours(11), "temperature_vec")
421+
.add_field("temperature", 16);
422+
let write_query2 = Query::write_query(Timestamp::Hours(12), "temperature_vec")
423+
.add_field("temperature", 17);
424+
let write_query3 = Query::write_query(Timestamp::Hours(13), "temperature_vec")
425+
.add_field("temperature", 18);
426+
427+
let _write_result = client.query(&write_query1).await;
428+
let _write_result2 = client.query(&write_query2).await;
429+
let _write_result2 = client.query(&write_query3).await;
430+
431+
#[derive(Deserialize, Debug, PartialEq)]
432+
struct Weather {
433+
time: String,
434+
temperature: i32,
465435
}
436+
437+
let query = Query::raw_read_query("SELECT * FROM temperature_vec");
438+
let result = client
439+
.json_query(query)
440+
.await
441+
.and_then(|mut db_result| db_result.deserialize_next::<Weather>());
442+
assert_result_ok(&result);
443+
assert_eq!(result.unwrap().series[0].values.len(), 3);
466444
},
467-
|| {
468-
async move {
469-
delete_db(TEST_NAME).await.expect("could not clean up db");
470-
}
445+
|| async move {
446+
delete_db(TEST_NAME).await.expect("could not clean up db");
471447
},
472448
)
473449
.await;
@@ -484,68 +460,64 @@ async fn test_serde_multi_query() {
484460
const TEST_NAME: &str = "test_serde_multi_query";
485461

486462
run_test(
487-
|| {
488-
async move {
489-
create_db(TEST_NAME).await.expect("could not setup db");
490-
491-
#[derive(Deserialize, Debug, PartialEq)]
492-
struct Temperature {
493-
time: String,
494-
temperature: i32,
495-
}
496-
497-
#[derive(Deserialize, Debug, PartialEq)]
498-
struct Humidity {
499-
time: String,
500-
humidity: i32,
501-
}
502-
503-
let client = create_client(TEST_NAME);
504-
let write_query = Query::write_query(Timestamp::Hours(11), "temperature")
505-
.add_field("temperature", 16);
506-
let write_query2 =
507-
Query::write_query(Timestamp::Hours(11), "humidity").add_field("humidity", 69);
508-
509-
let write_result = client.query(&write_query).await;
510-
let write_result2 = client.query(&write_query2).await;
511-
assert_result_ok(&write_result);
512-
assert_result_ok(&write_result2);
513-
514-
let result = client
515-
.json_query(
516-
Query::raw_read_query("SELECT * FROM temperature")
517-
.add_query("SELECT * FROM humidity"),
518-
)
519-
.await
520-
.and_then(|mut db_result| {
521-
let temp = db_result.deserialize_next::<Temperature>()?;
522-
let humidity = db_result.deserialize_next::<Humidity>()?;
463+
|| async move {
464+
create_db(TEST_NAME).await.expect("could not setup db");
523465

524-
Ok((temp, humidity))
525-
});
526-
assert_result_ok(&result);
466+
#[derive(Deserialize, Debug, PartialEq)]
467+
struct Temperature {
468+
time: String,
469+
temperature: i32,
470+
}
527471

528-
let (temp, humidity) = result.unwrap();
529-
assert_eq!(
530-
temp.series[0].values[0],
531-
Temperature {
532-
time: "1970-01-01T11:00:00Z".to_string(),
533-
temperature: 16
534-
},
535-
);
536-
assert_eq!(
537-
humidity.series[0].values[0],
538-
Humidity {
539-
time: "1970-01-01T11:00:00Z".to_string(),
540-
humidity: 69
541-
}
542-
);
472+
#[derive(Deserialize, Debug, PartialEq)]
473+
struct Humidity {
474+
time: String,
475+
humidity: i32,
543476
}
477+
478+
let client = create_client(TEST_NAME);
479+
let write_query = Query::write_query(Timestamp::Hours(11), "temperature")
480+
.add_field("temperature", 16);
481+
let write_query2 =
482+
Query::write_query(Timestamp::Hours(11), "humidity").add_field("humidity", 69);
483+
484+
let write_result = client.query(&write_query).await;
485+
let write_result2 = client.query(&write_query2).await;
486+
assert_result_ok(&write_result);
487+
assert_result_ok(&write_result2);
488+
489+
let result = client
490+
.json_query(
491+
Query::raw_read_query("SELECT * FROM temperature")
492+
.add_query("SELECT * FROM humidity"),
493+
)
494+
.await
495+
.and_then(|mut db_result| {
496+
let temp = db_result.deserialize_next::<Temperature>()?;
497+
let humidity = db_result.deserialize_next::<Humidity>()?;
498+
499+
Ok((temp, humidity))
500+
});
501+
assert_result_ok(&result);
502+
503+
let (temp, humidity) = result.unwrap();
504+
assert_eq!(
505+
temp.series[0].values[0],
506+
Temperature {
507+
time: "1970-01-01T11:00:00Z".to_string(),
508+
temperature: 16
509+
},
510+
);
511+
assert_eq!(
512+
humidity.series[0].values[0],
513+
Humidity {
514+
time: "1970-01-01T11:00:00Z".to_string(),
515+
humidity: 69
516+
}
517+
);
544518
},
545-
|| {
546-
async move {
547-
delete_db(TEST_NAME).await.expect("could not clean up db");
548-
}
519+
|| async move {
520+
delete_db(TEST_NAME).await.expect("could not clean up db");
549521
},
550522
)
551523
.await;

0 commit comments

Comments
 (0)
Please sign in to comment.