chewdata 3.6.1

Extract Transform and Load data
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Find the number of elements form the response's header.
//!
//! ### Confirguration
//!
//! | key  | alias | Description                                                                                | Default Value   | Possible Values |
//! | ---- | ----- | ------------------------------------------------------------------------------------------ | --------------- | --------------- |
//! | type | -     | Required in order to use this counter.                                                     | `header`        | `header`        |
//! | name | -     | Header name where to find the total of records.                                             | `X-Total-Count` | String          |
//! | path | -     | The URL path to retrieve the total number of records. If `null`, it takes the connector path  by default. | `null`          | String          |
//!
//! ### Example
//!
//!  ```json
//!  [
//!      {
//!          "type": "read",
//!          "connector":{
//!              "type": "curl",
//!              "endpoint": "{{ CURL_ENDPOINT }}",
//!              "path": "/get?next={{ paginator.next }}",
//!              "method": "get",
//!              "paginator": {
//!                  "type": "offset",
//!                  "limit": 100,
//!                  "skip": 0,
//!                  "count": null
//!              },
//!              "counter": {
//!                  "type": "header",
//!                  "name": "X-Total-Count",
//!                  "path": "/count"
//!              }
//!          }
//!      }
//!  ]
//!  ```
use crate::connector::curl::Curl;
use serde::{Deserialize, Serialize};
use std::io::Result;

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct Header {
    pub name: String,
    pub path: Option<String>,
}

impl Default for Header {
    fn default() -> Self {
        Header {
            name: "Content-Length".to_string(),
            path: None,
        }
    }
}

impl Header {
    pub fn new(name: String, path: Option<String>) -> Self {
        Header { name, path }
    }
    /// To retrieve the number of items from the response's header and return `None` if the counter is unable to count.
    ///
    /// # Examples
    ///
    /// ```
    /// use chewdata::connector::curl::Curl;
    /// use chewdata::connector::counter::curl::header::Header;
    /// use smol::prelude::*;
    /// use std::io;
    /// use http::Method;
    ///
    /// use macro_rules_attribute::apply;
    /// use smol_macros::main;
    ///
    /// #[apply(main!)]
    /// async fn main() -> io::Result<()> {
    ///     let mut connector = Curl::default();
    ///     connector.endpoint = "http://localhost:8080".to_string();
    ///     connector.method = Method::GET;
    ///     connector.path = "/get".to_string();
    ///
    ///     let mut counter = Header::default();
    ///     counter.name = "Content-Length".to_string();
    ///     assert!(Some(0) < counter.count(&connector).await.unwrap(), "Counter count() must return a value upper than 0.");
    ///
    ///     Ok(())
    /// }
    /// ```
    #[instrument(name = "header::count")]
    pub async fn count(&self, connector: &Curl) -> Result<Option<usize>> {
        let mut connector = connector.clone();

        if let Some(ref path) = self.path {
            connector.path = path.clone();
        }

        let headers = connector.headers().await?;

        for (key, value) in headers {
            if self.name.eq_ignore_ascii_case(&key) {
                return Ok(match String::from_utf8_lossy(&value).parse::<usize>() {
                    Ok(count) => {
                        trace!(size = count, "Count with success");
                        Some(count)
                    }
                    Err(_) => {
                        trace!("Can't count");
                        None
                    }
                });
            }
        }

        Ok(None)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use http::Method;
    use macro_rules_attribute::apply;
    use smol_macros::test;

    #[apply(test!)]
    async fn count_return_value() {
        let mut connector = Curl::default();
        connector.endpoint = "http://localhost:8080".to_string();
        connector.method = Method::GET;
        connector.path = "/get".to_string();
        let mut counter = Header::default();
        counter.name = "Content-Length".to_string();
        assert!(
            Some(0) < counter.count(&connector).await.unwrap(),
            "Counter must return a value upper than 0."
        );
    }
    #[apply(test!)]
    async fn count_not_return_value() {
        let mut connector = Curl::default();
        connector.endpoint = "http://localhost:8080".to_string();
        connector.method = Method::GET;
        connector.path = "/get".to_string();
        let mut counter = Header::default();
        counter.name = "not_found".to_string();
        assert_eq!(None, counter.count(&connector).await.unwrap());
    }
}