redis_ts 0.5.4

API for Redis time series types.
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

extern crate async_std;
use crate::async_command_tests::*;
use async_std::task;
use futures::Future;
mod async_command_tests;

fn block_on<F>(f: F) -> F::Output
where
    F: Future,
{
    task::block_on(f)
}

#[test]
fn testing_ts_create_info() {
    let res = block_on(ts_create_info("test_ts_create_info_async_std"));
    verify_ts_create_info(res, "test_ts_create_info_async_std");
}

#[test]
fn test_ts_add() {
    let res = block_on(ts_add("test_ts_add_async_std"));
    verify_ts_add(res);
}

#[test]
fn test_ts_add_now() {
    let res = block_on(ts_add_now("test_ts_add_now_async_std"));
    verify_ts_add_now(res);
}

#[test]
fn test_ts_add_create() {
    let _: () = block_on(ts_add_create("test_ts_add_create_async_std"));
}

#[test]
fn test_ts_add_replace() {
    let _: () = block_on(ts_add_replace("test_ts_add_replace_async_std"));
}

#[test]
fn test_ts_madd() {
    let _: () = block_on(ts_madd("test_ts_madd_async_std"));
}

#[test]
fn test_ts_incrby_now() {
    let _: () = block_on(ts_incrby_now("async_test_ts_incrby_now_std"));
}

#[test]
fn test_ts_decrby_now() {
    let _: () = block_on(ts_decrby_now("async_test_ts_decrby_now_std"));
}

#[test]
fn test_ts_incrby() {
    let _: () = block_on(ts_incrby("async_test_ts_incrby_std"));
}

#[test]
fn test_ts_decrby() {
    let _: () = block_on(ts_decrby("async_test_ts_decrby_std"));
}

#[test]
fn test_ts_incrby_create() {
    let _: () = block_on(ts_incrby_create("async_test_ts_incrby_create_std"));
}

#[test]
fn test_ts_decrby_create() {
    let _: () = block_on(ts_decrby_create("async_test_ts_decrby_create_std"));
}

#[test]
fn test_ts_create_delete_rule() {
    let _: () = block_on(ts_create_delete_rule(
        "async_test_ts_create_delete_rule_std",
    ));
}

#[test]
fn test_ts_get() {
    let _: () = block_on(ts_get("async_test_ts_get_std"));
}

#[test]
fn test_ts_mget() {
    let _: () = block_on(ts_mget("async_test_ts_mget_std"));
}

#[test]
fn test_ts_get_ts_info() {
    let _: () = block_on(ts_get_ts_info("async_test_ts_get_ts_info_std"));
}

#[test]
fn test_ts_alter() {
    let _: () = block_on(ts_alter("async_test_ts_alter_std"));
}

#[test]
fn test_ts_range() {
    let _: () = block_on(ts_range("async_test_ts_range_std"));
}

#[test]
fn test_ts_revrange() {
    let _: () = block_on(ts_revrange("async_test_ts_revrange_std"));
}

#[test]
fn test_ts_mrange() {
    let _: () = block_on(ts_mrange("async_test_ts_mrange_std"));
}

#[test]
fn test_ts_mrevrange() {
    let _: () = block_on(ts_mrevrange("async_test_ts_mrevrange_std"));
}

#[test]
fn test_ts_queryindex() {
    let _: () = block_on(ts_queryindex("async_test_ts_queryindex_std"));
}