influxdb2 0.5.2

Influxdb 2 client library 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

//! Delete API

use chrono::NaiveDateTime;
use reqwest::Method;
use snafu::ResultExt;

use crate::{Client, Http, RequestError, ReqwestProcessing};

impl Client {
    /// Delete data points from a bucket matching specified parameters.
    ///
    /// Usage:
    ///
    /// ```
    /// use chrono::NaiveDate;
    /// use influxdb2::Client;
    ///
    /// async fn foo() {
    ///     let client = Client::new("some-host", "some-org", "some-token");
    ///     let start = NaiveDate::from_ymd(2020, 1, 1).and_hms(0, 0, 0);
    ///     let stop = NaiveDate::from_ymd(2020, 12, 31).and_hms(23, 59, 59);
    ///     let predicate = Some("_measurement=\"some-measurement\"".to_owned());
    ///     client.delete("some-bucket", start, stop, predicate).await.unwrap();
    /// }
    /// ```
    ///
    pub async fn delete(
        &self,
        bucket: &str,
        start: NaiveDateTime,
        stop: NaiveDateTime,
        predicate: Option<String>,
    ) -> Result<(), RequestError> {
        let delete_url = self.url("/api/v2/delete");

        let body = serde_json
        ::json!({
            "start": start.format("%Y-%m-%dT%H:%M:%SZ").to_string(),
            "stop": stop.format("%Y-%m-%dT%H:%M:%SZ").to_string(),
            "predicate": predicate,
        })
        .to_string();

        let response = self
            .request(Method::POST, &delete_url)
            .query(&[("bucket", bucket), ("org", &self.org)])
            .body(body)
            .send()
            .await
            .context(ReqwestProcessing)?;

        if !response.status().is_success() {
            let status = response.status();
            let text = response.text().await.context(ReqwestProcessing)?;
            Http { status, text }.fail()?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::NaiveDate;
    use mockito::mock;

    #[tokio::test]
    async fn delete_points() {
        let org = "some-org";
        let bucket = "some-bucket";
        let token = "some-token";

        let mock_server = mock(
                "POST",
                format!("/api/v2/delete?bucket={}&org={}", bucket, org).as_str(),
            )
            .match_header("Authorization", format!("Token {}", token).as_str())
            .match_body(
                "{\"predicate\":null,\"start\":\"2020-01-01T00:00:00Z\",\"stop\":\"2021-01-01T00:00:00Z\"}"
            )
            .create();

        let client = Client::new(mockito::server_url(), org, token);

        let start = NaiveDate::from_ymd(2020, 1, 1).and_hms(0, 0, 0);
        let stop = NaiveDate::from_ymd(2021, 1, 1).and_hms(0, 0, 0);
        let _result = client.delete(bucket, start, stop, None).await;

        mock_server.assert();
    }
}