Skip to main content

codama_nodes/
constant_node.rs

1use crate::{CamelCaseString, ConstantNode, Docs, TypeNode, ValueNode};
2
3impl ConstantNode {
4    pub fn new<T, U, V>(name: T, r#type: U, value: V) -> Self
5    where
6        T: Into<CamelCaseString>,
7        U: Into<TypeNode>,
8        V: Into<ValueNode>,
9    {
10        Self {
11            name: name.into(),
12            docs: Docs::default(),
13            r#type: Box::new(r#type.into()),
14            value: Box::new(value.into()),
15        }
16    }
17}
18
19#[cfg(test)]
20mod tests {
21    use super::*;
22    use crate::{NumberTypeNode, NumberValueNode, StringTypeNode, StringValueNode, U64};
23    use pretty_assertions::assert_eq;
24
25    #[test]
26    fn new() {
27        let node = ConstantNode::new(
28            "max_items",
29            NumberTypeNode::le(U64),
30            NumberValueNode::new(100u64),
31        );
32        assert_eq!(node.name, CamelCaseString::new("maxItems"));
33        assert_eq!(node.docs, Docs::default());
34        assert_eq!(*node.r#type, TypeNode::Number(NumberTypeNode::le(U64)));
35        assert_eq!(*node.value, ValueNode::Number(NumberValueNode::new(100u64)));
36    }
37
38    #[test]
39    fn direct_instantiation() {
40        let node = ConstantNode {
41            name: "appName".into(),
42            docs: Docs::default(),
43            r#type: Box::new(StringTypeNode::utf8().into()),
44            value: Box::new(StringValueNode::new("MyApp").into()),
45        };
46        assert_eq!(node.name, CamelCaseString::new("appName"));
47        assert_eq!(node.docs, Docs::default());
48        assert_eq!(*node.r#type, TypeNode::String(StringTypeNode::utf8()));
49        assert_eq!(
50            *node.value,
51            ValueNode::String(StringValueNode::new("MyApp"))
52        );
53    }
54
55    #[test]
56    fn to_json() {
57        let node = ConstantNode::new(
58            "maxItems",
59            NumberTypeNode::le(U64),
60            NumberValueNode::new(100u64),
61        );
62        let json = serde_json::to_string(&node).unwrap();
63        assert_eq!(
64            json,
65            r#"{"kind":"constantNode","name":"maxItems","type":{"kind":"numberTypeNode","format":"u64","endian":"le"},"value":{"kind":"numberValueNode","number":100}}"#
66        );
67    }
68
69    #[test]
70    fn from_json() {
71        let json = r#"{"kind":"constantNode","name":"maxItems","type":{"kind":"numberTypeNode","format":"u64","endian":"le"},"value":{"kind":"numberValueNode","number":100}}"#;
72        let node: ConstantNode = serde_json::from_str(json).unwrap();
73        assert_eq!(
74            node,
75            ConstantNode::new(
76                "maxItems",
77                NumberTypeNode::le(U64),
78                NumberValueNode::new(100u64)
79            )
80        );
81    }
82
83    #[test]
84    fn to_json_with_docs() {
85        let mut node = ConstantNode::new(
86            "maxItems",
87            NumberTypeNode::le(U64),
88            NumberValueNode::new(100u64),
89        );
90        node.docs = Docs::new().add_doc("Maximum number of items.");
91        let json = serde_json::to_string(&node).unwrap();
92        assert_eq!(
93            json,
94            r#"{"kind":"constantNode","name":"maxItems","docs":["Maximum number of items."],"type":{"kind":"numberTypeNode","format":"u64","endian":"le"},"value":{"kind":"numberValueNode","number":100}}"#
95        );
96    }
97}