rkt 0.6.0

Web framework with a focus on usability, security, extensibility, and speed. (Community Fork)
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

#![cfg(feature = "msgpack")]

extern crate rkt;

use std::borrow::Cow;

use rkt::local::blocking::Client;
use rkt::serde::msgpack::{self, Compact, MsgPack};
use rkt::{Build, Rocket};

#[derive(serde::Serialize, serde::Deserialize, PartialEq, Eq)]
struct Person<'r> {
    name: &'r str,
    age: u8,
    gender: Gender,
}

#[derive(serde::Serialize, serde::Deserialize, PartialEq, Eq)]
enum Gender {
    Male,
    Female,
    NonBinary,
}

#[rkt::post("/named", data = "<person>")]
fn named(person: MsgPack<Person<'_>>) -> MsgPack<Person<'_>> {
    person
}

#[rkt::post("/compact", data = "<person>")]
fn compact(person: MsgPack<Person<'_>>) -> Compact<Person<'_>> {
    MsgPack(person.into_inner())
}

fn rocket() -> Rocket<Build> {
    rkt::build().mount("/", rkt::routes![named, compact])
}

// The object we're going to roundtrip through the API.
const OBJECT: Person<'static> = Person {
    name: "Cal",
    age: 17,
    gender: Gender::NonBinary,
};

// [ "Cal", 17, "NonBinary" ]
const COMPACT_BYTES: &[u8] = &[
    147, 163, 67, 97, 108, 17, 169, 78, 111, 110, 66, 105, 110, 97, 114, 121,
];

// { "name": "Cal", "age": 17, "gender": "NonBinary" }
const NAMED_BYTES: &[u8] = &[
    131, 164, 110, 97, 109, 101, 163, 67, 97, 108, 163, 97, 103, 101, 17, 166, 103, 101, 110, 100,
    101, 114, 169, 78, 111, 110, 66, 105, 110, 97, 114, 121,
];

#[test]
fn check_roundtrip() {
    let client = Client::debug(rocket()).unwrap();
    let inputs: &[(&'static str, Cow<'static, [u8]>)] = &[
        ("objpack", msgpack::to_vec(&OBJECT).unwrap().into()),
        ("named bytes", NAMED_BYTES.into()),
        ("compact bytes", COMPACT_BYTES.into()),
    ];

    for (name, input) in inputs {
        let compact = client.post("/compact").body(input).dispatch();
        assert_eq!(
            compact.into_bytes().unwrap(),
            COMPACT_BYTES,
            "{name} mismatch"
        );

        let named = client.post("/named").body(input).dispatch();
        assert_eq!(named.into_bytes().unwrap(), NAMED_BYTES, "{name} mismatch");
    }
}