actrpc-core 0.1.0

Core types and traits for ActRPC.
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

use std::collections::HashMap;

use actrpc_core::{
    DescribeParams, DescribeValue,
    descriptor::{
        traits::{DescribeParams as _, DescribeValue as _},
        types::{ParamsDescriptor, PrimitiveDescriptor, ValueDescriptor},
    },
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, DescribeValue)]
struct ValueStruct {
    enabled: bool,
    name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, DescribeParams)]
struct ParamsStruct {
    required_name: String,
    optional_count: Option<i32>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, DescribeValue)]
enum UnionValue {
    Text(String),
    Count(i32),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, DescribeValue)]
struct MapHolder {
    labels: HashMap<String, String>,
}

#[test]
fn describe_value_struct_produces_object_descriptor() {
    let descriptor = ValueStruct::describe_value();

    match descriptor {
        ValueDescriptor::Object(obj) => {
            assert_eq!(obj.fields.len(), 2);
            assert_eq!(obj.fields[0].name, "enabled");
            assert_eq!(
                obj.fields[0].ty,
                ValueDescriptor::Primitive(PrimitiveDescriptor::Bool)
            );
            assert_eq!(obj.fields[1].name, "name");
            assert_eq!(
                obj.fields[1].ty,
                ValueDescriptor::Primitive(PrimitiveDescriptor::String)
            );
        }
        other => panic!("expected object descriptor, got {other:?}"),
    }
}

#[test]
fn describe_params_struct_separates_required_and_optional_fields() {
    let descriptor = ParamsStruct::describe_params().expect("descriptor");

    match descriptor {
        ParamsDescriptor::Object(obj) => {
            assert_eq!(obj.required_fields.len(), 1);
            assert_eq!(obj.optional_fields.len(), 1);

            assert_eq!(obj.required_fields[0].name, "required_name");
            assert_eq!(
                obj.required_fields[0].ty,
                ValueDescriptor::Primitive(PrimitiveDescriptor::String)
            );

            assert_eq!(obj.optional_fields[0].name, "optional_count");
            assert_eq!(
                obj.optional_fields[0].ty,
                ValueDescriptor::Primitive(PrimitiveDescriptor::Integer)
            );
        }
        other => panic!("expected params object descriptor, got {other:?}"),
    }
}

#[test]
fn describe_value_enum_produces_oneof_descriptor() {
    let descriptor = UnionValue::describe_value();

    match descriptor {
        ValueDescriptor::OneOf(values) => {
            assert_eq!(values.len(), 2);
            assert_eq!(
                values[0],
                ValueDescriptor::Primitive(PrimitiveDescriptor::String)
            );
            assert_eq!(
                values[1],
                ValueDescriptor::Primitive(PrimitiveDescriptor::Integer)
            );
        }
        other => panic!("expected oneof descriptor, got {other:?}"),
    }
}

#[test]
fn describe_value_map_produces_map_descriptor() {
    let descriptor = MapHolder::describe_value();

    match descriptor {
        ValueDescriptor::Object(obj) => {
            assert_eq!(obj.fields.len(), 1);
            assert_eq!(obj.fields[0].name, "labels");

            match &obj.fields[0].ty {
                ValueDescriptor::Map(inner) => {
                    assert_eq!(
                        **inner,
                        ValueDescriptor::Primitive(PrimitiveDescriptor::String)
                    );
                }
                other => panic!("expected map descriptor, got {other:?}"),
            }
        }
        other => panic!("expected object descriptor, got {other:?}"),
    }
}