flatbed 0.0.2

Rust HTTP framework with FlatBuffer codegen, built on Hyper
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

//! Verifies the compile-time type registry populated by `TypeSchema` /
//! `EnumSchema` submissions in generated code, including tables reachable only
//! by nesting rather than as a route request/response.

#[path = "../src/generated/test_flatbed.rs"]
#[allow(warnings, clippy::all)]
mod generated;

use flatbed::{get_enum_schema, get_type_schema};

#[test]
fn every_table_is_registered_including_nested_only() {
    for name in [
        "TestRequest",
        "TestResponse",
        "Address", // reachable only by nesting
        "UserRequest",
        "UserResponse",
        "AddressBook",
        "LogEvent",
    ] {
        let ty = get_type_schema(name).unwrap_or_else(|| panic!("type {name} not registered"));
        assert_eq!(ty.name, name);
        assert_eq!(ty.namespace, "test");
    }
}

#[test]
fn field_descriptors_carry_fbs_type_id_and_requiredness() {
    let ur = get_type_schema("UserRequest").expect("UserRequest not registered");

    // Field ids are the FlatBuffer vtable slots, sequential in declaration
    // order for these implicit-id schemas.
    let ids: Vec<u16> = ur.fields.iter().map(|f| f.field_id).collect();
    assert_eq!(ids, vec![0, 1, 2]);

    let address = ur
        .fields
        .iter()
        .find(|f| f.name == "address")
        .expect("address field missing");
    assert_eq!(address.fbs_type, "Address");
    assert!(!address.required);

    let age = ur.fields.iter().find(|f| f.name == "age").unwrap();
    assert_eq!(age.fbs_type, "int32");
    assert!(age.required);
}

#[test]
fn vector_and_scalar_fbs_types_are_preserved() {
    let book = get_type_schema("AddressBook").expect("AddressBook not registered");
    let addresses = book.fields.iter().find(|f| f.name == "addresses").unwrap();
    assert_eq!(addresses.fbs_type, "[Address]");
    assert!(!addresses.required);
}

#[test]
fn enums_are_registered_with_variants_in_value_order() {
    let sev = get_enum_schema("Severity").expect("Severity not registered");
    assert_eq!(sev.namespace, "test");
    assert_eq!(sev.variants, ["Info", "Warning", "Error"]);
}

#[test]
fn registry_has_no_bare_name_collisions() {
    flatbed::validate_type_registry().expect("test schema type/enum names are unique");
}