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

use crate::traits::IDatabase;

use warp::{Filter, Rejection, Reply};

/// GET /api/v0/:String/:usize/:usize
pub fn get(
  db: std::sync::Arc<std::sync::RwLock<dyn IDatabase>>,
) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone {
  warp::path!("api" / "v0" / String / usize / usize).and(warp::get()).map(
    move |id: String, start: usize, end: usize| {
      let mut lock = db.write().unwrap();
      let data = lock.get_range(&id, start, end);

      if !data.is_empty() {
        let mut result: String = Default::default();
        result += "[";
        for item in data {
          result +=
            &format!("{},", std::str::from_utf8(&item).unwrap_or_default());
        }
        result.pop();
        result += "]";

        return warp::hyper::Response::builder()
          .status(warp::http::StatusCode::OK)
          .body(result);
      }

      warp::hyper::Response::builder()
        .status(warp::http::StatusCode::NOT_FOUND)
        .body(Default::default())
    },
  )
}

#[tokio::test]
async fn test_get() {
  let database_test_factory =
    crate::db::DatabaseTestFactory::new(".temp/test/sensor_range/test_get");

  for db in database_test_factory.get_instance().values() {
    let api = super::endpoints((*db).clone());

    let id = "test-0";
    let n = 10;

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/0/{n}"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 404);

    db.write()
      .unwrap()
      .post(&id, serde_json::json!({ "id": &id }).to_string().as_bytes());

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/0/0"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 200);
    assert_eq!(
      serde_json::from_slice::<serde_json::Value>(resp.body()).unwrap(),
      serde_json::json!([{ "id": &id }])
    );

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/0/1"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 200);
    assert_eq!(
      serde_json::from_slice::<serde_json::Value>(resp.body()).unwrap(),
      serde_json::json!([{ "id": &id }])
    );

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/0/{n}"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 200);
    assert_eq!(
      serde_json::from_slice::<serde_json::Value>(resp.body()).unwrap(),
      serde_json::json!([{ "id": &id }])
    );

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/2/{n}"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 404);

    for _ in 0..n - 1 {
      db.write()
        .unwrap()
        .post(&id, serde_json::json!({ "id0": &id }).to_string().as_bytes());
    }

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/0/{n}"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 200);
    assert_eq!(
      serde_json::from_slice::<serde_json::Value>(resp.body())
        .unwrap()
        .as_array()
        .unwrap()
        .len(),
      n
    );

    let resp = warp::test::request()
      .method("GET")
      .path(&format!("/api/v0/{id}/{n}/0"))
      .reply(&api)
      .await;
    assert_eq!(resp.status(), 404);
  }
}