ruva 0.19.4

Rust Library For Event Driven Message Handling
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
133
134
135

use ruva::*;

#[test]
fn test_serialize() {
	#[aggregate(Deserialize, Clone)]
	pub struct SerializeTest {
		#[adapter_ignore]
		id: i32,
		#[serde(skip_serializing)]
		name: String,
		foo: i32,
	}
	let aggregate = SerializeTest::default();
	let serialized = serde_json::to_string(&aggregate).unwrap();
	assert_eq!(serialized, "{\"id\":0,\"foo\":0}");

	// deserialize
	let _: SerializeTest = serde_json::from_str("{\"id\":0,\"foo\":0,\"name\":\"whatever\"}").unwrap();
}

#[test]
fn test_serialize_with_explicit_derive_macros() {
	#[aggregate]
	#[derive(Default, Debug, Serialize, Deserialize)]
	pub struct SerializeTest {
		#[adapter_ignore]
		id: i32,
		#[serde(skip_serializing)]
		name: String,
		foo: i32,
	}
	let aggregate = SerializeTest::default();
	let serialized = serde_json::to_string(&aggregate).unwrap();
	assert_eq!(serialized, "{\"id\":0,\"foo\":0}");
}

#[test]
fn test_adapter_accessible() {
	#[aggregate]
	pub struct TestStruct {
		#[adapter_ignore]
		id: i32,
		#[serde(skip_serializing)]
		name: String,
		foo: i32,
	}
	let adapter = TestStructAdapter::default();
	let serialized = serde_json::to_string(&adapter).unwrap();
	assert_eq!(serialized, "{\"foo\":0}");
}

#[test]
fn test_conversion() {
	#[aggregate]
	pub struct ConversionStruct {
		#[adapter_ignore]
		id: i32,
		#[serde(skip_serializing)]
		name: String,
		foo: i32,
	}
	let aggregate = ConversionStruct {
		name: "migo".into(),
		foo: 2,
		id: 1,
		..Default::default()
	};
	assert_eq!(aggregate.id, 1);
	let converted_adapter = ConversionStructAdapter::from(aggregate);

	assert_eq!(converted_adapter.name, "migo");
	assert_eq!(converted_adapter.foo, 2);

	let converted_struct = ConversionStruct::from(converted_adapter);
	assert_eq!(converted_struct.name, "migo");
	assert_eq!(converted_struct.foo, 2);
}

#[test]
fn test_when_there_is_no_apdater_ignore_attr() {
	#[aggregate]
	pub struct TestStruct {
		id: i32,
		name: String,
		some_other_field: i32,
	}

	let non_adapter = TestStruct::default();
	let non_adapter_serialized = serde_json::to_string(&non_adapter).unwrap();
	assert_eq!(non_adapter_serialized, "{\"id\":0,\"name\":\"\",\"some_other_field\":0}");

	let adapter = TestStructAdapter::default();
	let adapter_serialized = serde_json::to_string(&adapter).unwrap();
	assert_eq!(adapter_serialized, "{\"id\":0,\"name\":\"\",\"some_other_field\":0}");
}

#[test]
fn test_generic_aggregate() {
	#[derive(Default, Debug, Serialize, Deserialize)]
	struct Unset;

	#[aggregate]
	struct MyStruct<T = Unset> {
		name: String,
		age: i32,

		#[adapter_ignore]
		sub_type: T,
	}

	impl MyStruct<String> {
		fn do_something_with_string(&self) -> String {
			self.sub_type.clone()
		}
	}

	let my_struct = MyStruct::<String> {
		name: "migo".into(),
		age: 2,
		sub_type: "sub_type".into(),
		..Default::default()
	};
	assert_eq!(my_struct.do_something_with_string(), "sub_type");
	assert_eq!(my_struct.name, "migo");
	assert_eq!(my_struct.age, 2);

	let adapter = MyStructAdapter::from(my_struct);
	assert_eq!(adapter.name, "migo");
	assert_eq!(adapter.age, 2);

	let my_struct: MyStruct<String> = adapter.into();
	assert_eq!(my_struct.name, "migo");
	assert_eq!(my_struct.age, 2);
	assert!(my_struct.sub_type.is_empty());
}