jsonapi 0.7.0

JSONAPI implementation
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

#[macro_use]
extern crate jsonapi;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
use jsonapi::array::JsonApiArray;
use jsonapi::model::*;

mod helper;
use helper::read_json_file;

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Author {
    id: String,
    name: String,
    books: Vec<Book>,
}
jsonapi_model!(Author; "authors"; has many books);

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Book {
    id: String,
    title: String,
    first_chapter: Chapter,
    chapters: Vec<Chapter>
}
jsonapi_model!(Book; "books"; has one first_chapter; has many chapters);

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Chapter {
    id: String,
    title: String,
    ordering: i32,
}
jsonapi_model!(Chapter; "chapters");

#[test]
fn to_jsonapi_document_and_back() {
    let book = Book {
        id: "1".into(),
        title: "The Fellowship of the Ring".into(),
        first_chapter: Chapter { id: "1".into(), title: "A Long-expected Party".into(), ordering: 1 },
        chapters: vec![
            Chapter { id: "1".into(), title: "A Long-expected Party".into(), ordering: 1 },
            Chapter { id: "2".into(), title: "The Shadow of the Past".into(), ordering: 2 },
            Chapter { id: "3".into(), title: "Three is Company".into(), ordering: 3 }
        ],
    };

    let doc = book.to_jsonapi_document();
    let json = serde_json::to_string(&doc).unwrap();
    let book_doc: DocumentData = serde_json::from_str(&json)
        .expect("Book DocumentData should be created from the book json");
    let book_again = Book::from_jsonapi_document(&book_doc)
        .expect("Book should be generated from the book_doc");

    assert_eq!(book, book_again);
}

#[test]
fn numeric_id() {
    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct NumericChapter {
        id: i32,
        title: String,
    }
    jsonapi_model!(NumericChapter; "numeric_chapter");

    let chapter = NumericChapter {
        id: 24,
        title: "The Riders of Rohan".into(),
    };

    let (res, _) = chapter.to_jsonapi_resource();
    assert_eq!(res.id, "24".to_string());

    let doc = chapter.to_jsonapi_document();
    assert!(doc.is_valid());
    match &doc {
        JsonApiDocument::Error(_) => assert!(false),
        JsonApiDocument::Data(x) => {
            assert_eq!(x.data, Some(PrimaryData::Single(Box::new(res))));
        }
    }

    let json = serde_json::to_string(&doc).unwrap();
    let _num_doc: JsonApiDocument = serde_json::from_str(&json)
        .expect("NumericChapter JsonApiDocument should be created from the chapter json");
}

#[test]
fn test_vec_to_jsonapi_document() {
    let chapters = vec![
        Chapter {
            id: "45".into(),
            title: "The Passing of the Grey Company".into(),
            ordering: 2,
        },
        Chapter {
            id: "46".into(),
            title: "The Muster of Rohan".into(),
            ordering: 3,
        },
    ];

    let doc = vec_to_jsonapi_document(chapters);
    assert!(doc.is_valid());
}

#[test]
fn from_jsonapi_document() {
    let json = ::read_json_file("data/author_tolkien.json");

    // TODO - is this the right thing that we want to test? Shold this cast into a JsonApiDocument
    // and detect if this was a data or an error?
    // Not sure that we want to immediately cast this into a "data" when we don't know if this isi
    // valid test file - it could be an error document for all we know... (that is equally valid)
    let author_doc: JsonApiDocument = serde_json::from_str(&json)
        .expect("Author DocumentData should be created from the author json");

    // This assumes that the fixture we're using is a "valid" document with data
    match author_doc {
        JsonApiDocument::Error(_) => assert!(false),
        JsonApiDocument::Data(doc) => {
            let author = Author::from_jsonapi_document(&doc)
                .expect("Author should be generated from the author_doc");

            let doc_again = author.to_jsonapi_document();
            assert!(doc_again.is_valid());
        }
    }
}