json-api 0.4.1

Idiomatic types for building a robust JSON API
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 json_api;
#[macro_use]
extern crate ordermap;

use json_api::Error;
use json_api::query::{self, Direction, Query};
use ordermap::OrderMap;

type Mapping = OrderMap<&'static str, Query>;

fn from_mapping() -> Result<Mapping, Error> {
    Ok(ordermap!{
        "" => Default::default(),
        "fields%5Barticles%5D=title" => Query::builder()
            .fields("articles", vec!["title"])
            .build()?,
        concat!(
            "fields%5Barticles%5D=body%2Ctitle%2Cpublished-at&",
            "fields%5Bcomments%5D=body&",
            "fields%5Busers%5D=name",
        ) => Query::builder()
            .fields("articles", vec!["body", "title", "published-at"])
            .fields("comments", vec!["body"])
            .fields("users", vec!["name"])
            .build()?,
        "filter%5Busers.name%5D=Alfred+Pennyworth" => Query::builder()
            .filter("users.name", "Alfred Pennyworth")
            .build()?,
        "include=author" => Query::builder()
            .include("author")
            .build()?,
        "include=author%2Ccomments%2Ccomments.author" => Query::builder()
            .include("author")
            .include("comments")
            .include("comments.author")
            .build()?,
        "page%5Bnumber%5D=0" => Query::builder()
            .page(1, None)
            .build()?,
        "page%5Bnumber%5D=1" => Query::builder()
            .page(1, None)
            .build()?,
        "page%5Bsize%5D=10" => Query::builder()
            .page(1, Some(10))
            .build()?,
        "page%5Bnumber%5D=2&page%5Bsize%5D=15" => Query::builder()
            .page(2, Some(15))
            .build()?,
        "sort=-published-at" => Query::builder()
            .sort("published-at", Direction::Desc)
            .build()?,
        "sort=published-at%2C-title" => Query::builder()
            .sort("published-at", Direction::Asc)
            .sort("title", Direction::Desc)
            .build()?,
        "sort=published-at%2C-title%2C-author.name" => Query::builder()
            .sort("published-at", Direction::Asc)
            .sort("title", Direction::Desc)
            .sort("author.name", Direction::Desc)
            .build()?,
        concat!(
            "fields%5Barticles%5D=body%2Ctitle%2Cpublished-at&",
            "fields%5Bcomments%5D=body&",
            "fields%5Busers%5D=name&",
            "filter%5Busers.name%5D=Alfred+Pennyworth&",
            "include=author%2Ccomments%2Ccomments.author&",
            "page%5Bnumber%5D=2&page%5Bsize%5D=15&",
            "sort=published-at%2C-title%2C-author.name",
        ) => Query::builder()
            .fields("articles", vec!["body", "title", "published-at"])
            .fields("comments", vec!["body"])
            .fields("users", vec!["name"])
            .filter("users.name", "Alfred Pennyworth")
            .include("author")
            .include("comments")
            .include("comments.author")
            .page(2, Some(15))
            .sort("published-at", Direction::Asc)
            .sort("title", Direction::Desc)
            .sort("author.name", Direction::Desc)
            .build()?,
    })
}

fn to_mapping() -> Result<Mapping, Error> {
    let mapping = from_mapping()?
        .into_iter()
        .map(|(key, value)| match key {
            "page%5Bnumber%5D=0" | "page%5Bnumber%5D=1" => ("", value),
            _ => (key, value),
        })
        .collect();

    Ok(mapping)
}

#[test]
fn query_from_slice() {
    for (source, expected) in from_mapping().unwrap() {
        let actual = query::from_slice(source.as_bytes()).unwrap();
        assert_eq!(actual, expected);
    }
}

#[test]
fn query_from_str() {
    for (source, expected) in from_mapping().unwrap() {
        let actual = query::from_str(source).unwrap();
        assert_eq!(actual, expected);
    }
}

#[test]
fn query_to_string() {
    for (expected, source) in to_mapping().unwrap() {
        let actual = query::to_string(&source).unwrap();
        assert_eq!(actual, expected);
    }
}

#[test]
fn query_to_vec() {
    for (expected, source) in to_mapping().unwrap() {
        let actual = query::to_vec(&source).unwrap();
        assert_eq!(actual, expected.to_owned().into_bytes());
    }
}