aboutsummaryrefslogtreecommitdiffstats
path: root/tests/schema_tests.rs
diff options
context:
space:
mode:
authorYigit Sever2021-04-22 20:15:40 +0300
committerYigit Sever2021-04-25 23:04:39 +0300
commit32b49380880aab00057b8a663b5327d6f58def3a (patch)
tree059dc128813a93679233f5489cf1a42b2ea0374d /tests/schema_tests.rs
parent97b2f6c796fd2af1c338725884189685a82adc01 (diff)
downloadgradecoin-32b49380880aab00057b8a663b5327d6f58def3a.tar.gz
gradecoin-32b49380880aab00057b8a663b5327d6f58def3a.tar.bz2
gradecoin-32b49380880aab00057b8a663b5327d6f58def3a.zip
Implement nicenet
- There are bot accounts that return what you sent them - Sending a transaction generates some coin out of thin air - No more one tx per person per block limit - Unused transactions do not disappear anymore
Diffstat (limited to 'tests/schema_tests.rs')
-rw-r--r--tests/schema_tests.rs608
1 files changed, 304 insertions, 304 deletions
diff --git a/tests/schema_tests.rs b/tests/schema_tests.rs
index 4240a5f..072cb2b 100644
--- a/tests/schema_tests.rs
+++ b/tests/schema_tests.rs
@@ -1,310 +1,310 @@
1#[cfg(test)] 1// #[cfg(test)]
2mod tests { 2// mod tests {
3 use gradecoin::schema::*; 3// use gradecoin::schema::*;
4 use serde_test::{assert_tokens, Token}; 4// use serde_test::{assert_tokens, Token};
5 use chrono::NaiveDate; 5// use chrono::NaiveDate;
6 6
7 #[test] 7// #[test]
8 fn claims_serialize_correctly() { 8// fn claims_serialize_correctly() {
9 let claims = Claims { 9// let claims = Claims {
10 tha: "hashed_string".to_owned(), 10// tha: "hashed_string".to_owned(),
11 iat: 0, 11// iat: 0,
12 exp: 100, 12// exp: 100,
13 }; 13// };
14 assert_tokens( 14// assert_tokens(
15 &claims, 15// &claims,
16 &[ 16// &[
17 Token::Struct{name: "Claims", len: 3}, 17// Token::Struct{name: "Claims", len: 3},
18 Token::String("tha"), 18// Token::String("tha"),
19 Token::String("hashed_string"), 19// Token::String("hashed_string"),
20 Token::String("iat"), 20// Token::String("iat"),
21 Token::U64(0), 21// Token::U64(0),
22 Token::String("exp"), 22// Token::String("exp"),
23 Token::U64(100), 23// Token::U64(100),
24 Token::StructEnd, 24// Token::StructEnd,
25 ] 25// ]
26 ) 26// )
27 } 27// }
28 28
29 #[test] 29// #[test]
30 fn claims_deserialize_correctly() { 30// fn claims_deserialize_correctly() {
31 let data = r#"{"tha":"hashed_string","iat":0,"exp":100}"#; 31// let data = r#"{"tha":"hashed_string","iat":0,"exp":100}"#;
32 let claims: Claims = serde_json::from_str(data).unwrap(); 32// let claims: Claims = serde_json::from_str(data).unwrap();
33 let expected_claims = Claims { 33// let expected_claims = Claims {
34 tha: "hashed_string".to_owned(), 34// tha: "hashed_string".to_owned(),
35 iat: 0, 35// iat: 0,
36 exp: 100, 36// exp: 100,
37 }; 37// };
38 assert_eq!(claims, expected_claims); 38// assert_eq!(claims, expected_claims);
39 } 39// }
40 40
41 #[test] 41// #[test]
42 fn transaction_serialize_correctly() { 42// fn transaction_serialize_correctly() {
43 let transaction = Transaction { 43// let transaction = Transaction {
44 by: "source".to_owned(), 44// by: "source".to_owned(),
45 source: "source".to_owned(), 45// source: "source".to_owned(),
46 target: "target".to_owned(), 46// target: "target".to_owned(),
47 amount: 0, 47// amount: 0,
48 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 48// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
49 }; 49// };
50 50
51 assert_tokens( 51// assert_tokens(
52 &transaction, 52// &transaction,
53 &[ 53// &[
54 Token::Struct{name: "Transaction", len: 5}, 54// Token::Struct{name: "Transaction", len: 5},
55 Token::String("by"), 55// Token::String("by"),
56 Token::String("source"), 56// Token::String("source"),
57 Token::String("source"), 57// Token::String("source"),
58 Token::String("source"), 58// Token::String("source"),
59 Token::String("target"), 59// Token::String("target"),
60 Token::String("target"), 60// Token::String("target"),
61 Token::String("amount"), 61// Token::String("amount"),
62 Token::I32(0), 62// Token::I32(0),
63 Token::String("timestamp"), 63// Token::String("timestamp"),
64 Token::String("2021-04-02T04:02:42"), 64// Token::String("2021-04-02T04:02:42"),
65 Token::StructEnd, 65// Token::StructEnd,
66 ] 66// ]
67 ) 67// )
68 } 68// }
69 69
70 #[test] 70// #[test]
71 fn transaction_deserialize_correctly() { 71// fn transaction_deserialize_correctly() {
72 let data = r#"{"by":"source","source":"source","target":"target","amount":0,"timestamp":"2021-04-02T04:02:42"}"#; 72// let data = r#"{"by":"source","source":"source","target":"target","amount":0,"timestamp":"2021-04-02T04:02:42"}"#;
73 let transaction: Transaction = serde_json::from_str(data).unwrap(); 73// let transaction: Transaction = serde_json::from_str(data).unwrap();
74 let expected_transaction = Transaction { 74// let expected_transaction = Transaction {
75 by: "source".to_owned(), 75// by: "source".to_owned(),
76 source: "source".to_owned(), 76// source: "source".to_owned(),
77 target: "target".to_owned(), 77// target: "target".to_owned(),
78 amount: 0, 78// amount: 0,
79 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 79// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
80 }; 80// };
81 81
82 assert_eq!(transaction, expected_transaction); 82// assert_eq!(transaction, expected_transaction);
83 } 83// }
84 84
85 #[test] 85// #[test]
86 fn block_serialize_correctly() { 86// fn block_serialize_correctly() {
87 let block = Block { 87// let block = Block {
88 transaction_list: vec!["transaction1".to_owned()], 88// transaction_list: vec!["transaction1".to_owned()],
89 nonce: 0, 89// nonce: 0,
90 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 90// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
91 hash: "hash".to_owned() 91// hash: "hash".to_owned()
92 }; 92// };
93 93
94 assert_tokens( 94// assert_tokens(
95 &block, 95// &block,
96 &[ 96// &[
97 Token::Struct{name: "Block", len: 4}, 97// Token::Struct{name: "Block", len: 4},
98 Token::String("transaction_list"), 98// Token::String("transaction_list"),
99 Token::Seq {len: Some(1)}, 99// Token::Seq {len: Some(1)},
100 Token::String("transaction1"), 100// Token::String("transaction1"),
101 Token::SeqEnd, 101// Token::SeqEnd,
102 Token::String("nonce"), 102// Token::String("nonce"),
103 Token::U32(0), 103// Token::U32(0),
104 Token::String("timestamp"), 104// Token::String("timestamp"),
105 Token::String("2021-04-02T04:02:42"), 105// Token::String("2021-04-02T04:02:42"),
106 Token::String("hash"), 106// Token::String("hash"),
107 Token::String("hash"), 107// Token::String("hash"),
108 Token::StructEnd, 108// Token::StructEnd,
109 ] 109// ]
110 ) 110// )
111 } 111// }
112 112
113 #[test] 113// #[test]
114 fn block_deserialize_correctly() { 114// fn block_deserialize_correctly() {
115 let expected_block = Block { 115// let expected_block = Block {
116 transaction_list: vec!["transaction1".to_owned()], 116// transaction_list: vec!["transaction1".to_owned()],
117 nonce: 0, 117// nonce: 0,
118 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 118// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
119 hash: "hash".to_owned() 119// hash: "hash".to_owned()
120 }; 120// };
121 let data = r#"{"transaction_list":["transaction1"],"nonce":0,"timestamp":"2021-04-02T04:02:42","hash":"hash"}"#; 121// let data = r#"{"transaction_list":["transaction1"],"nonce":0,"timestamp":"2021-04-02T04:02:42","hash":"hash"}"#;
122 let block: Block = serde_json::from_str(data).unwrap(); 122// let block: Block = serde_json::from_str(data).unwrap();
123 123
124 assert_eq!(block, expected_block); 124// assert_eq!(block, expected_block);
125 125
126 } 126// }
127 127
128 #[test] 128// #[test]
129 fn block_serialize_when_vec_emptpy() { 129// fn block_serialize_when_vec_emptpy() {
130 let block = Block { 130// let block = Block {
131 transaction_list: vec![], 131// transaction_list: vec![],
132 nonce: 0, 132// nonce: 0,
133 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 133// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
134 hash: "hash".to_owned() 134// hash: "hash".to_owned()
135 }; 135// };
136 136
137 let json = serde_json::to_string(&block).unwrap(); 137// let json = serde_json::to_string(&block).unwrap();
138 assert_eq!(json, r#"{"nonce":0,"timestamp":"2021-04-02T04:02:42","hash":"hash"}"#) 138// assert_eq!(json, r#"{"nonce":0,"timestamp":"2021-04-02T04:02:42","hash":"hash"}"#)
139 } 139// }
140 140
141 #[test] 141// #[test]
142 fn naked_block_serialize_correctly() { 142// fn naked_block_serialize_correctly() {
143 let naked_block = NakedBlock { 143// let naked_block = NakedBlock {
144 transaction_list: vec!["transaction1".to_owned()], 144// transaction_list: vec!["transaction1".to_owned()],
145 nonce: 0, 145// nonce: 0,
146 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 146// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
147 }; 147// };
148 148
149 assert_tokens( 149// assert_tokens(
150 &naked_block, 150// &naked_block,
151 &[ 151// &[
152 Token::Struct{name: "NakedBlock", len: 3}, 152// Token::Struct{name: "NakedBlock", len: 3},
153 Token::String("transaction_list"), 153// Token::String("transaction_list"),
154 Token::Seq {len: Some(1)}, 154// Token::Seq {len: Some(1)},
155 Token::String("transaction1"), 155// Token::String("transaction1"),
156 Token::SeqEnd, 156// Token::SeqEnd,
157 Token::String("nonce"), 157// Token::String("nonce"),
158 Token::U32(0), 158// Token::U32(0),
159 Token::String("timestamp"), 159// Token::String("timestamp"),
160 Token::String("2021-04-02T04:02:42"), 160// Token::String("2021-04-02T04:02:42"),
161 Token::StructEnd, 161// Token::StructEnd,
162 ] 162// ]
163 ) 163// )
164 } 164// }
165 165
166 #[test] 166// #[test]
167 fn naked_block_deserialize_correctly() { 167// fn naked_block_deserialize_correctly() {
168 let expected_naked_block = NakedBlock { 168// let expected_naked_block = NakedBlock {
169 transaction_list: vec!["transaction1".to_owned()], 169// transaction_list: vec!["transaction1".to_owned()],
170 nonce: 0, 170// nonce: 0,
171 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 171// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
172 }; 172// };
173 let data = r#"{"transaction_list":["transaction1"],"nonce":0,"timestamp":"2021-04-02T04:02:42"}"#; 173// let data = r#"{"transaction_list":["transaction1"],"nonce":0,"timestamp":"2021-04-02T04:02:42"}"#;
174 let naked_block: NakedBlock = serde_json::from_str(data).unwrap(); 174// let naked_block: NakedBlock = serde_json::from_str(data).unwrap();
175 175
176 assert_eq!(naked_block, expected_naked_block); 176// assert_eq!(naked_block, expected_naked_block);
177 177
178 } 178// }
179 179
180 #[test] 180// #[test]
181 fn naked_block_serialize_when_vec_emptpy() { 181// fn naked_block_serialize_when_vec_emptpy() {
182 let naked_block = NakedBlock { 182// let naked_block = NakedBlock {
183 transaction_list: vec![], 183// transaction_list: vec![],
184 nonce: 0, 184// nonce: 0,
185 timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42), 185// timestamp: NaiveDate::from_ymd(2021, 4, 2).and_hms(4, 2, 42),
186 }; 186// };
187 187
188 let json = serde_json::to_string(&naked_block).unwrap(); 188// let json = serde_json::to_string(&naked_block).unwrap();
189 assert_eq!(json, r#"{"nonce":0,"timestamp":"2021-04-02T04:02:42"}"#) 189// assert_eq!(json, r#"{"nonce":0,"timestamp":"2021-04-02T04:02:42"}"#)
190 } 190// }
191 191
192 #[test] 192// #[test]
193 fn user_serialize_correctly() { 193// fn user_serialize_correctly() {
194 let user = User { 194// let user = User {
195 user_id: MetuId::new("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(), 195// user_id: MetuId::new("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(),
196 public_key: "public_key".to_owned(), 196// public_key: "public_key".to_owned(),
197 balance: 0 197// balance: 0
198 }; 198// };
199 199
200 assert_tokens( 200// assert_tokens(
201 &user, 201// &user,
202 &[ 202// &[
203 Token::Struct{name: "User", len: 3}, 203// Token::Struct{name: "User", len: 3},
204 Token::String("user_id"), 204// Token::String("user_id"),
205 Token::Struct {name: "MetuId", len: 2}, 205// Token::Struct {name: "MetuId", len: 2},
206 Token::String("id"), 206// Token::String("id"),
207 Token::String("e254275"), 207// Token::String("e254275"),
208 Token::String("passwd"), 208// Token::String("passwd"),
209 Token::String("DtNX1qk4YF4saRH"), 209// Token::String("DtNX1qk4YF4saRH"),
210 Token::StructEnd, 210// Token::StructEnd,
211 Token::String("public_key"), 211// Token::String("public_key"),
212 Token::String("public_key"), 212// Token::String("public_key"),
213 Token::String("balance"), 213// Token::String("balance"),
214 Token::I32(0), 214// Token::I32(0),
215 Token::StructEnd, 215// Token::StructEnd,
216 ] 216// ]
217 ) 217// )
218 } 218// }
219 219
220 #[test] 220// #[test]
221 fn user_deserialize_correctly() { 221// fn user_deserialize_correctly() {
222 let expected_user = User { 222// let expected_user = User {
223 user_id: MetuId::new("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(), 223// user_id: MetuId::new("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(),
224 public_key: "public_key".to_owned(), 224// public_key: "public_key".to_owned(),
225 balance: 0 225// balance: 0
226 }; 226// };
227 let data = r#"{"user_id":{"id":"e254275","passwd":"DtNX1qk4YF4saRH"},"public_key":"public_key","balance":0}"#; 227// let data = r#"{"user_id":{"id":"e254275","passwd":"DtNX1qk4YF4saRH"},"public_key":"public_key","balance":0}"#;
228 let user: User = serde_json::from_str(data).unwrap(); 228// let user: User = serde_json::from_str(data).unwrap();
229 229
230 assert_eq!(user, expected_user); 230// assert_eq!(user, expected_user);
231 231
232 } 232// }
233 233
234 #[test] 234// #[test]
235 fn metu_id_serialize_correctly() { 235// fn metu_id_serialize_correctly() {
236 let metu_id = MetuId::new ("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(); 236// let metu_id = MetuId::new ("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap();
237 237
238 assert_tokens( 238// assert_tokens(
239 &metu_id, 239// &metu_id,
240 &[ 240// &[
241 Token::Struct{name: "MetuId", len: 2}, 241// Token::Struct{name: "MetuId", len: 2},
242 Token::String("id"), 242// Token::String("id"),
243 Token::String("e254275"), 243// Token::String("e254275"),
244 Token::String("passwd"), 244// Token::String("passwd"),
245 Token::String("DtNX1qk4YF4saRH"), 245// Token::String("DtNX1qk4YF4saRH"),
246 Token::StructEnd, 246// Token::StructEnd,
247 ] 247// ]
248 ) 248// )
249 } 249// }
250 250
251 #[test] 251// #[test]
252 fn metu_id_deserialize_correctly() { 252// fn metu_id_deserialize_correctly() {
253 let expected_metu_id = MetuId::new ("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap(); 253// let expected_metu_id = MetuId::new ("e254275".to_owned(), "DtNX1qk4YF4saRH".to_owned()).unwrap();
254 let data = r#"{"id":"e254275","passwd":"DtNX1qk4YF4saRH"}"#; 254// let data = r#"{"id":"e254275","passwd":"DtNX1qk4YF4saRH"}"#;
255 let metu_id: MetuId = serde_json::from_str(data).unwrap(); 255// let metu_id: MetuId = serde_json::from_str(data).unwrap();
256 256
257 assert_eq!(metu_id, expected_metu_id); 257// assert_eq!(metu_id, expected_metu_id);
258 } 258// }
259 259
260 #[test] 260// #[test]
261 fn auth_request_serialize_correctly() { 261// fn auth_request_serialize_correctly() {
262 let auth_request = AuthRequest { 262// let auth_request = AuthRequest {
263 student_id: "e254275".to_owned(), 263// student_id: "e254275".to_owned(),
264 passwd: "DtNX1qk4YF4saRH".to_owned(), 264// passwd: "DtNX1qk4YF4saRH".to_owned(),
265 public_key: "public_key".to_owned() 265// public_key: "public_key".to_owned()
266 }; 266// };
267 267
268 assert_tokens( 268// assert_tokens(
269 &auth_request, 269// &auth_request,
270 &[ 270// &[
271 Token::Struct{name: "AuthRequest", len: 3}, 271// Token::Struct{name: "AuthRequest", len: 3},
272 Token::String("student_id"), 272// Token::String("student_id"),
273 Token::String("e254275"), 273// Token::String("e254275"),
274 Token::String("passwd"), 274// Token::String("passwd"),
275 Token::String("DtNX1qk4YF4saRH"), 275// Token::String("DtNX1qk4YF4saRH"),
276 Token::String("public_key"), 276// Token::String("public_key"),
277 Token::String("public_key"), 277// Token::String("public_key"),
278 Token::StructEnd, 278// Token::StructEnd,
279 ] 279// ]
280 ) 280// )
281 } 281// }
282 282
283 #[test] 283// #[test]
284 fn auth_request_deserialize_correctly() { 284// fn auth_request_deserialize_correctly() {
285 let expected_auth_request = AuthRequest { 285// let expected_auth_request = AuthRequest {
286 student_id: "e254275".to_owned(), 286// student_id: "e254275".to_owned(),
287 passwd: "DtNX1qk4YF4saRH".to_owned(), 287// passwd: "DtNX1qk4YF4saRH".to_owned(),
288 public_key: "public_key".to_owned() 288// public_key: "public_key".to_owned()
289 }; 289// };
290 let data = r#"{"student_id":"e254275","passwd":"DtNX1qk4YF4saRH","public_key":"public_key"}"#; 290// let data = r#"{"student_id":"e254275","passwd":"DtNX1qk4YF4saRH","public_key":"public_key"}"#;
291 let auth_request: AuthRequest = serde_json::from_str(data).unwrap(); 291// let auth_request: AuthRequest = serde_json::from_str(data).unwrap();
292 292
293 assert_eq!(auth_request, expected_auth_request); 293// assert_eq!(auth_request, expected_auth_request);
294 294
295 } 295// }
296 296
297 297
298 298
299 299
300 300
301 301
302 302
303 303
304 304
305 305
306 306
307 307
308 308
309 309
310} \ No newline at end of file 310// }
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-11-22 05:03:54 +0000