1#[derive(Debug, Hash, Clone, PartialEq, Eq, PartialOrd, Ord)]
5pub enum AbstractQuery<K, V> {
6 And(Vec<Self>),
8 Or(Vec<Self>),
10 Not(Box<Self>),
12 Eq(K, V),
14 Neq(K, V),
16 Gt(K, V),
18 Gte(K, V),
20 Lt(K, V),
22 Lte(K, V),
24 Like(K, V),
26 In(K, Vec<V>),
28 Exist(Vec<K>),
30}
31
32pub type Query = AbstractQuery<String, String>;
34
35impl<K, V> AbstractQuery<K, V> {
36 pub fn optimise(self) -> Option<Self> {
38 match self {
39 Self::Not(boxed_query) => match boxed_query.optimise() {
40 None => None,
41 Some(Self::Not(nested_query)) => Some(*nested_query),
42 Some(other) => Some(Self::Not(Box::new(other))),
43 },
44 Self::And(subqueries) => {
45 let mut subqueries: Vec<Self> = subqueries
46 .into_iter()
47 .flat_map(|query| query.optimise())
48 .collect();
49
50 match subqueries.len() {
51 0 => None,
52 1 => Some(subqueries.remove(0)),
53 _ => Some(Self::And(subqueries)),
54 }
55 }
56 Self::Or(subqueries) => {
57 let mut subqueries: Vec<Self> = subqueries
58 .into_iter()
59 .flat_map(|query| query.optimise())
60 .collect();
61
62 match subqueries.len() {
63 0 => None,
64 1 => Some(subqueries.remove(0)),
65 _ => Some(Self::Or(subqueries)),
66 }
67 }
68 Self::In(key, mut targets) if targets.len() == 1 => {
69 Some(Self::Eq(key, targets.remove(0)))
70 }
71 other => Some(other),
72 }
73 }
74
75 pub fn map_names<RK, E>(
77 self,
78 mut f: impl FnMut(K) -> Result<RK, E>,
79 ) -> Result<AbstractQuery<RK, V>, E> {
80 self.map(&mut f, &mut |_k, v| Ok(v))
81 }
82
83 pub fn map_values<RV, E>(
85 self,
86 mut f: impl FnMut(&K, V) -> Result<RV, E>,
87 ) -> Result<AbstractQuery<K, RV>, E> {
88 self.map(&mut |k| Ok(k), &mut f)
89 }
90
91 pub fn map<RK, RV, KF, VF, E>(
93 self,
94 kf: &mut KF,
95 vf: &mut VF,
96 ) -> Result<AbstractQuery<RK, RV>, E>
97 where
98 KF: FnMut(K) -> Result<RK, E>,
99 VF: FnMut(&K, V) -> Result<RV, E>,
100 {
101 match self {
102 Self::Eq(tag_name, tag_value) => {
103 let tag_value = vf(&tag_name, tag_value)?;
104 Ok(AbstractQuery::<RK, RV>::Eq(kf(tag_name)?, tag_value))
105 }
106 Self::Neq(tag_name, tag_value) => {
107 let tag_value = vf(&tag_name, tag_value)?;
108 Ok(AbstractQuery::<RK, RV>::Neq(kf(tag_name)?, tag_value))
109 }
110 Self::Gt(tag_name, tag_value) => {
111 let tag_value = vf(&tag_name, tag_value)?;
112 Ok(AbstractQuery::<RK, RV>::Gt(kf(tag_name)?, tag_value))
113 }
114 Self::Gte(tag_name, tag_value) => {
115 let tag_value = vf(&tag_name, tag_value)?;
116 Ok(AbstractQuery::<RK, RV>::Gte(kf(tag_name)?, tag_value))
117 }
118 Self::Lt(tag_name, tag_value) => {
119 let tag_value = vf(&tag_name, tag_value)?;
120 Ok(AbstractQuery::<RK, RV>::Lt(kf(tag_name)?, tag_value))
121 }
122 Self::Lte(tag_name, tag_value) => {
123 let tag_value = vf(&tag_name, tag_value)?;
124 Ok(AbstractQuery::<RK, RV>::Lte(kf(tag_name)?, tag_value))
125 }
126 Self::Like(tag_name, tag_value) => {
127 let tag_value = vf(&tag_name, tag_value)?;
128 Ok(AbstractQuery::<RK, RV>::Like(kf(tag_name)?, tag_value))
129 }
130 Self::In(tag_name, tag_values) => {
131 let tag_values = tag_values
132 .into_iter()
133 .map(|value| vf(&tag_name, value))
134 .collect::<Result<Vec<_>, E>>()?;
135 Ok(AbstractQuery::<RK, RV>::In(kf(tag_name)?, tag_values))
136 }
137 Self::Exist(tag_names) => Ok(AbstractQuery::<RK, RV>::Exist(
138 tag_names.into_iter().try_fold(vec![], |mut v, tag_name| {
139 v.push(kf(tag_name)?);
140 Result::<_, E>::Ok(v)
141 })?,
142 )),
143 Self::And(subqueries) => {
144 let subqueries = subqueries
145 .into_iter()
146 .map(|query| query.map(kf, vf))
147 .collect::<Result<Vec<_>, E>>()?;
148 Ok(AbstractQuery::<RK, RV>::And(subqueries))
149 }
150 Self::Or(subqueries) => {
151 let subqueries = subqueries
152 .into_iter()
153 .map(|query| query.map(kf, vf))
154 .collect::<Result<Vec<_>, E>>()?;
155 Ok(AbstractQuery::<RK, RV>::Or(subqueries))
156 }
157 Self::Not(boxed_query) => Ok(AbstractQuery::<RK, RV>::Not(Box::new(
158 boxed_query.map(kf, vf)?,
159 ))),
160 }
161 }
162}
163
164impl<K, V> Default for AbstractQuery<K, V> {
165 fn default() -> Self {
166 Self::And(Vec::new())
167 }
168}
169
170#[cfg(feature = "serde_support")]
171mod serde_support {
172 use std::string;
173
174 use serde::ser::{Serialize, Serializer};
175 use serde::{de, Deserialize, Deserializer};
176 use serde_json::{self, json, Value as JsonValue};
177
178 use super::{AbstractQuery, Query};
179
180 impl<K, V> Serialize for AbstractQuery<K, V>
181 where
182 for<'a> &'a K: Into<String>,
183 V: Serialize,
184 {
185 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
186 where
187 S: Serializer,
188 {
189 self.to_value().serialize(serializer)
190 }
191 }
192
193 impl<'de> Deserialize<'de> for Query {
194 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
195 where
196 D: Deserializer<'de>,
197 {
198 let v = JsonValue::deserialize(deserializer)?;
199
200 match v {
201 JsonValue::Object(map) => parse_query(map).map_err(de::Error::missing_field),
202 JsonValue::Array(array) => {
203 let mut res: Vec<JsonValue> = Vec::new();
205 for sub_query in array {
206 let sub_query: serde_json::Map<String, JsonValue> = sub_query
207 .as_object()
208 .ok_or_else(|| de::Error::custom("Restriction is invalid"))?
209 .clone()
210 .into_iter()
211 .filter(|(_, v)| !v.is_null())
212 .collect();
213
214 if !sub_query.is_empty() {
215 res.push(JsonValue::Object(sub_query));
216 }
217 }
218
219 let mut map = serde_json::Map::new();
220 map.insert("$or".to_string(), JsonValue::Array(res));
221
222 parse_query(map).map_err(de::Error::custom)
223 }
224 _ => Err(de::Error::missing_field(
225 "Restriction must be either object or array",
226 )),
227 }
228 }
229 }
230
231 impl<K, V> AbstractQuery<K, V>
232 where
233 for<'a> &'a K: Into<String>,
234 V: Serialize,
235 {
236 fn to_value(&self) -> JsonValue {
237 match self {
238 Self::Eq(ref tag_name, ref tag_value) => json!({ tag_name: tag_value }),
239 Self::Neq(ref tag_name, ref tag_value) => json!({tag_name: {"$neq": tag_value}}),
240 Self::Gt(ref tag_name, ref tag_value) => json!({tag_name: {"$gt": tag_value}}),
241 Self::Gte(ref tag_name, ref tag_value) => json!({tag_name: {"$gte": tag_value}}),
242 Self::Lt(ref tag_name, ref tag_value) => json!({tag_name: {"$lt": tag_value}}),
243 Self::Lte(ref tag_name, ref tag_value) => json!({tag_name: {"$lte": tag_value}}),
244 Self::Like(ref tag_name, ref tag_value) => json!({tag_name: {"$like": tag_value}}),
245 Self::In(ref tag_name, ref tag_values) => json!({tag_name: {"$in":tag_values}}),
246 Self::Exist(ref tag_names) => {
247 json!({ "$exist": tag_names.iter().map(Into::into).collect::<Vec<String>>() })
248 }
249 Self::And(ref queries) => {
250 if !queries.is_empty() {
251 json!({
252 "$and": queries.iter().map(|q| q.to_value()).collect::<Vec<JsonValue>>()
253 })
254 } else {
255 json!({})
256 }
257 }
258 Self::Or(ref queries) => {
259 if !queries.is_empty() {
260 json!({
261 "$or": queries.iter().map(|q| q.to_value()).collect::<Vec<JsonValue>>()
262 })
263 } else {
264 json!({})
265 }
266 }
267 Self::Not(ref query) => json!({"$not": query.to_value()}),
268 }
269 }
270 }
271
272 impl string::ToString for Query {
273 fn to_string(&self) -> String {
274 self.to_value().to_string()
275 }
276 }
277
278 fn parse_query(map: serde_json::Map<String, JsonValue>) -> Result<Query, &'static str> {
279 let mut operators: Vec<Query> = Vec::new();
280
281 for (key, value) in map {
282 if let Some(operator_) = parse_operator(key, value)? {
283 operators.push(operator_);
284 }
285 }
286
287 let query = if operators.len() == 1 {
288 operators.remove(0)
289 } else {
290 Query::And(operators)
291 };
292
293 Ok(query)
294 }
295
296 fn parse_operator(key: String, value: JsonValue) -> Result<Option<Query>, &'static str> {
297 match (key.as_str(), value) {
298 ("$and", JsonValue::Array(values)) => {
299 if values.is_empty() {
300 Ok(None)
301 } else {
302 let operators: Vec<Query> = parse_list_operators(values)?;
303 Ok(Some(Query::And(operators)))
304 }
305 }
306 ("$and", _) => Err("$and must be array of JSON objects"),
307 ("$or", JsonValue::Array(values)) => {
308 if values.is_empty() {
309 Ok(None)
310 } else {
311 let operators: Vec<Query> = parse_list_operators(values)?;
312 Ok(Some(Query::Or(operators)))
313 }
314 }
315 ("$or", _) => Err("$or must be array of JSON objects"),
316 ("$not", JsonValue::Object(map)) => {
317 let operator = parse_query(map)?;
318 Ok(Some(Query::Not(Box::new(operator))))
319 }
320 ("$not", _) => Err("$not must be JSON object"),
321 ("$exist", JsonValue::String(key)) => Ok(Some(Query::Exist(vec![key]))),
322 ("$exist", JsonValue::Array(keys)) => {
323 if keys.is_empty() {
324 Ok(None)
325 } else {
326 let mut ks = vec![];
327 for key in keys {
328 if let JsonValue::String(key) = key {
329 ks.push(key);
330 } else {
331 return Err("$exist must be used with a string or array of strings");
332 }
333 }
334 Ok(Some(Query::Exist(ks)))
335 }
336 }
337 ("$exist", _) => Err("$exist must be used with a string or array of strings"),
338 (_, JsonValue::String(value)) => Ok(Some(Query::Eq(key, value))),
339 (_, JsonValue::Object(map)) => {
340 if map.len() == 1 {
341 let (operator_name, value) = map.into_iter().next().unwrap();
342 parse_single_operator(operator_name, key, value).map(Some)
343 } else {
344 Err("value must be JSON object of length 1")
345 }
346 }
347 (_, _) => Err("Unsupported value"),
348 }
349 }
350
351 fn parse_list_operators(operators: Vec<JsonValue>) -> Result<Vec<Query>, &'static str> {
352 let mut out_operators: Vec<Query> = Vec::with_capacity(operators.len());
353
354 for value in operators.into_iter() {
355 if let JsonValue::Object(map) = value {
356 let subquery = parse_query(map)?;
357 out_operators.push(subquery);
358 } else {
359 return Err("operator must be array of JSON objects");
360 }
361 }
362
363 Ok(out_operators)
364 }
365
366 fn parse_single_operator(
367 operator_name: String,
368 key: String,
369 value: JsonValue,
370 ) -> Result<Query, &'static str> {
371 match (&*operator_name, value) {
372 ("$neq", JsonValue::String(value_)) => Ok(Query::Neq(key, value_)),
373 ("$neq", _) => Err("$neq must be used with string"),
374 ("$gt", JsonValue::String(value_)) => Ok(Query::Gt(key, value_)),
375 ("$gt", _) => Err("$gt must be used with string"),
376 ("$gte", JsonValue::String(value_)) => Ok(Query::Gte(key, value_)),
377 ("$gte", _) => Err("$gte must be used with string"),
378 ("$lt", JsonValue::String(value_)) => Ok(Query::Lt(key, value_)),
379 ("$lt", _) => Err("$lt must be used with string"),
380 ("$lte", JsonValue::String(value_)) => Ok(Query::Lte(key, value_)),
381 ("$lte", _) => Err("$lte must be used with string"),
382 ("$like", JsonValue::String(value_)) => Ok(Query::Like(key, value_)),
383 ("$like", _) => Err("$like must be used with string"),
384 ("$in", JsonValue::Array(values)) => {
385 let mut target_values: Vec<String> = Vec::with_capacity(values.len());
386
387 for v in values.into_iter() {
388 if let JsonValue::String(s) = v {
389 target_values.push(s);
390 } else {
391 return Err("$in must be used with array of strings");
392 }
393 }
394
395 Ok(Query::In(key, target_values))
396 }
397 ("$in", _) => Err("$in must be used with array of strings"),
398 (_, _) => Err("Unknown operator"),
399 }
400 }
401}
402
403#[cfg(test)]
404mod tests {
405 use super::*;
406 use rand::distributions::Alphanumeric;
407 use rand::{thread_rng, Rng};
408 use serde_json::json;
409
410 fn _random_string(len: usize) -> String {
411 String::from_utf8(thread_rng().sample_iter(&Alphanumeric).take(len).collect()).unwrap()
412 }
413
414 #[test]
416 fn test_simple_operator_empty_json_parse() {
417 let json = "{}";
418
419 let query: Query = ::serde_json::from_str(json).unwrap();
420
421 let expected = Query::And(vec![]);
422
423 assert_eq!(query, expected);
424 }
425
426 #[test]
427 fn test_simple_operator_explicit_empty_and_parse() {
428 let json = r#"{"$and":[]}"#;
429
430 let query: Query = ::serde_json::from_str(json).unwrap();
431
432 let expected = Query::And(vec![]);
433
434 assert_eq!(query, expected);
435 }
436
437 #[test]
438 fn test_simple_operator_empty_or_parse() {
439 let json = r#"{"$or":[]}"#;
440
441 let query: Query = ::serde_json::from_str(json).unwrap();
442
443 let expected = Query::And(vec![]);
444
445 assert_eq!(query, expected);
446 }
447
448 #[test]
449 fn test_simple_operator_empty_not_parse() {
450 let json = r#"{"$not":{}}"#;
451
452 let query: Query = ::serde_json::from_str(json).unwrap();
453
454 let expected = Query::Not(Box::new(Query::And(vec![])));
455
456 assert_eq!(query, expected);
457 }
458
459 #[test]
460 fn test_simple_operator_eq_plaintext_parse() {
461 let name1 = _random_string(10);
462 let value1 = _random_string(10);
463
464 let json = format!(r#"{{"{}":"{}"}}"#, name1, value1);
465
466 let query: Query = ::serde_json::from_str(&json).unwrap();
467
468 let expected = Query::Eq(name1, value1);
469
470 assert_eq!(query, expected);
471 }
472
473 #[test]
474 fn test_simple_operator_neq_parse() {
475 let name1 = _random_string(10);
476 let value1 = _random_string(10);
477
478 let json = format!(r#"{{"{}":{{"$neq":"{}"}}}}"#, name1, value1);
479
480 let query: Query = ::serde_json::from_str(&json).unwrap();
481
482 let expected = Query::Neq(name1, value1);
483
484 assert_eq!(query, expected);
485 }
486
487 #[test]
488 fn test_simple_operator_gt_parse() {
489 let name1 = _random_string(10);
490 let value1 = _random_string(10);
491
492 let json = format!(r#"{{"{}":{{"$gt":"{}"}}}}"#, name1, value1);
493
494 let query: Query = ::serde_json::from_str(&json).unwrap();
495
496 let expected = Query::Gt(name1, value1);
497
498 assert_eq!(query, expected);
499 }
500
501 #[test]
502 fn test_simple_operator_gte_parse() {
503 let name1 = _random_string(10);
504 let value1 = _random_string(10);
505
506 let json = format!(r#"{{"{}":{{"$gte":"{}"}}}}"#, name1, value1);
507
508 let query: Query = ::serde_json::from_str(&json).unwrap();
509
510 let expected = Query::Gte(name1, value1);
511
512 assert_eq!(query, expected);
513 }
514
515 #[test]
516 fn test_simple_operator_lt_parse() {
517 let name1 = _random_string(10);
518 let value1 = _random_string(10);
519
520 let json = format!(r#"{{"{}":{{"$lt":"{}"}}}}"#, name1, value1);
521
522 let query: Query = ::serde_json::from_str(&json).unwrap();
523
524 let expected = Query::Lt(name1, value1);
525
526 assert_eq!(query, expected);
527 }
528
529 #[test]
530 fn test_simple_operator_lte_plaintext_parse() {
531 let name1 = _random_string(10);
532 let value1 = _random_string(10);
533
534 let json = format!(r#"{{"{}":{{"$lte":"{}"}}}}"#, name1, value1);
535
536 let query: Query = ::serde_json::from_str(&json).unwrap();
537
538 let expected = Query::Lte(name1, value1);
539
540 assert_eq!(query, expected);
541 }
542
543 #[test]
544 fn test_simple_operator_like_parse() {
545 let name1 = _random_string(10);
546 let value1 = _random_string(10);
547
548 let json = format!(r#"{{"{}":{{"$like":"{}"}}}}"#, name1, value1);
549
550 let query: Query = ::serde_json::from_str(&json).unwrap();
551
552 let expected = Query::Like(name1, value1);
553
554 assert_eq!(query, expected);
555 }
556
557 #[test]
558 fn test_simple_operator_in_plaintext_parse() {
559 let name1 = _random_string(10);
560 let value1 = _random_string(10);
561
562 let json = format!(r#"{{"{}":{{"$in":["{}"]}}}}"#, name1, value1);
563
564 let query: Query = ::serde_json::from_str(&json).unwrap();
565
566 let expected = Query::In(name1, vec![value1]);
567
568 assert_eq!(query, expected);
569 }
570
571 #[test]
572 fn test_simple_operator_in_plaintexts_parse() {
573 let name1 = _random_string(10);
574 let value1 = _random_string(10);
575 let value2 = _random_string(10);
576 let value3 = _random_string(10);
577
578 let json = format!(
579 r#"{{"{}":{{"$in":["{}","{}","{}"]}}}}"#,
580 name1, value1, value2, value3
581 );
582
583 let query: Query = ::serde_json::from_str(&json).unwrap();
584
585 let expected = Query::In(name1, vec![value1, value2, value3]);
586
587 assert_eq!(query, expected);
588 }
589
590 #[test]
591 fn test_exist_parse_string() {
592 let name1 = _random_string(10);
593
594 let json = format!(r#"{{"$exist":"{}"}}"#, name1);
595
596 let query: Query = ::serde_json::from_str(&json).unwrap();
597
598 let expected = Query::Exist(vec![name1]);
599
600 assert_eq!(query, expected);
601 }
602
603 #[test]
604 fn test_exist_parse_array() {
605 let name1 = _random_string(10);
606 let name2 = _random_string(10);
607
608 let json = format!(r#"{{"$exist":["{}","{}"]}}"#, name1, name2);
609
610 let query: Query = ::serde_json::from_str(&json).unwrap();
611
612 let expected = Query::Exist(vec![name1, name2]);
613
614 assert_eq!(query, expected);
615 }
616
617 #[test]
618 fn test_and_exist() {
619 let name1 = _random_string(10);
620 let name2 = _random_string(10);
621
622 let json = format!(
623 r#"{{"$and":[{{"$exist":"{}"}},{{"$exist":"{}"}}]}}"#,
624 name1, name2
625 );
626
627 let query: Query = ::serde_json::from_str(&json).unwrap();
628
629 let expected = Query::And(vec![Query::Exist(vec![name1]), Query::Exist(vec![name2])]);
630
631 assert_eq!(query, expected);
632 }
633
634 #[test]
635 fn test_and_with_one_eq_parse() {
636 let name1 = _random_string(10);
637 let value1 = _random_string(10);
638
639 let json = format!(r#"{{"$and":[{{"{}":"{}"}}]}}"#, name1, value1);
640
641 let query: Query = ::serde_json::from_str(&json).unwrap();
642
643 let expected = Query::And(vec![Query::Eq(name1, value1)]);
644
645 assert_eq!(query, expected);
646 }
647
648 #[test]
649 fn test_and_with_one_neq_parse() {
650 let name1 = _random_string(10);
651 let value1 = _random_string(10);
652
653 let json = format!(r#"{{"$and":[{{"{}":{{"$neq":"{}"}}}}]}}"#, name1, value1);
654
655 let query: Query = ::serde_json::from_str(&json).unwrap();
656
657 let expected = Query::And(vec![Query::Neq(name1, value1)]);
658
659 assert_eq!(query, expected);
660 }
661
662 #[test]
663 fn test_and_with_one_gt_parse() {
664 let name1 = _random_string(10);
665 let value1 = _random_string(10);
666
667 let json = format!(r#"{{"$and":[{{"{}":{{"$gt":"{}"}}}}]}}"#, name1, value1);
668
669 let query: Query = ::serde_json::from_str(&json).unwrap();
670
671 let expected = Query::And(vec![Query::Gt(name1, value1)]);
672
673 assert_eq!(query, expected);
674 }
675
676 #[test]
677 fn test_and_with_one_gte_parse() {
678 let name1 = _random_string(10);
679 let value1 = _random_string(10);
680
681 let json = format!(r#"{{"$and":[{{"{}":{{"$gte":"{}"}}}}]}}"#, name1, value1);
682
683 let query: Query = ::serde_json::from_str(&json).unwrap();
684
685 let expected = Query::And(vec![Query::Gte(name1, value1)]);
686
687 assert_eq!(query, expected);
688 }
689
690 #[test]
691 fn test_and_with_one_lt_parse() {
692 let name1 = _random_string(10);
693 let value1 = _random_string(10);
694
695 let json = format!(r#"{{"$and":[{{"{}":{{"$lt":"{}"}}}}]}}"#, name1, value1);
696
697 let query: Query = ::serde_json::from_str(&json).unwrap();
698
699 let expected = Query::And(vec![Query::Lt(name1, value1)]);
700
701 assert_eq!(query, expected);
702 }
703
704 #[test]
705 fn test_and_with_one_lte_parse() {
706 let name1 = _random_string(10);
707 let value1 = _random_string(10);
708
709 let json = format!(r#"{{"$and":[{{"{}":{{"$lte":"{}"}}}}]}}"#, name1, value1);
710
711 let query: Query = ::serde_json::from_str(&json).unwrap();
712
713 let expected = Query::And(vec![Query::Lte(name1, value1)]);
714
715 assert_eq!(query, expected);
716 }
717
718 #[test]
719 fn test_and_with_one_like_parse() {
720 let name1 = _random_string(10);
721 let value1 = _random_string(10);
722
723 let json = format!(r#"{{"$and":[{{"{}":{{"$like":"{}"}}}}]}}"#, name1, value1);
724
725 let query: Query = ::serde_json::from_str(&json).unwrap();
726
727 let expected = Query::And(vec![Query::Like(name1, value1)]);
728
729 assert_eq!(query, expected);
730 }
731
732 #[test]
733 fn test_and_with_one_in_parse() {
734 let name1 = _random_string(10);
735 let value1 = _random_string(10);
736
737 let json = format!(r#"{{"$and":[{{"{}":{{"$in":["{}"]}}}}]}}"#, name1, value1);
738
739 let query: Query = ::serde_json::from_str(&json).unwrap();
740
741 let expected = Query::And(vec![Query::In(name1, vec![value1])]);
742
743 assert_eq!(query, expected);
744 }
745
746 #[test]
747 fn test_and_with_one_not_eq_parse() {
748 let name1 = _random_string(10);
749 let value1 = _random_string(10);
750
751 let json = format!(r#"{{"$and":[{{"$not":{{"{}":"{}"}}}}]}}"#, name1, value1);
752
753 let query: Query = ::serde_json::from_str(&json).unwrap();
754
755 let expected = Query::And(vec![Query::Not(Box::new(Query::Eq(name1, value1)))]);
756
757 assert_eq!(query, expected);
758 }
759
760 #[test]
761 fn test_short_and_with_multiple_eq_parse() {
762 let name1 = _random_string(10);
763 let value1 = _random_string(10);
764 let name2 = _random_string(10);
765 let value2 = _random_string(10);
766 let name3 = _random_string(10);
767 let value3 = _random_string(10);
768
769 let json = format!(
770 r#"{{"{}":"{}","{}":"{}","{}":"{}"}}"#,
771 name1, value1, name2, value2, name3, value3,
772 );
773
774 let query: Query = ::serde_json::from_str(&json).unwrap();
775 let mut clauses = vec![
776 Query::Eq(name1, value1),
777 Query::Eq(name2, value2),
778 Query::Eq(name3, value3),
779 ];
780 clauses.sort();
781
782 let expected = Query::And(clauses);
783
784 assert_eq!(query, expected);
785 }
786
787 #[test]
788 fn test_and_with_multiple_eq_parse() {
789 let name1 = _random_string(10);
790 let value1 = _random_string(10);
791 let name2 = _random_string(10);
792 let value2 = _random_string(10);
793 let name3 = _random_string(10);
794 let value3 = _random_string(10);
795
796 let json = format!(
797 r#"{{"$and":[{{"{}":"{}"}},{{"{}":"{}"}},{{"{}":"{}"}}]}}"#,
798 name1, value1, name2, value2, name3, value3,
799 );
800
801 let query: Query = ::serde_json::from_str(&json).unwrap();
802
803 let expected = Query::And(vec![
804 Query::Eq(name1, value1),
805 Query::Eq(name2, value2),
806 Query::Eq(name3, value3),
807 ]);
808
809 assert_eq!(query, expected);
810 }
811
812 #[test]
813 fn test_and_with_multiple_neq_parse() {
814 let name1 = _random_string(10);
815 let value1 = _random_string(10);
816 let name2 = _random_string(10);
817 let value2 = _random_string(10);
818 let name3 = _random_string(10);
819 let value3 = _random_string(10);
820
821 let json = format!(
822 r#"{{"$and":[{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}}]}}"#,
823 name1, value1, name2, value2, name3, value3,
824 );
825
826 let query: Query = ::serde_json::from_str(&json).unwrap();
827
828 let expected = Query::And(vec![
829 Query::Neq(name1, value1),
830 Query::Neq(name2, value2),
831 Query::Neq(name3, value3),
832 ]);
833
834 assert_eq!(query, expected);
835 }
836
837 #[test]
838 fn test_and_with_multiple_gt_parse() {
839 let name1 = _random_string(10);
840 let value1 = _random_string(10);
841 let name2 = _random_string(10);
842 let value2 = _random_string(10);
843 let name3 = _random_string(10);
844 let value3 = _random_string(10);
845
846 let json = format!(
847 r#"{{"$and":[{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}}]}}"#,
848 name1, value1, name2, value2, name3, value3,
849 );
850
851 let query: Query = ::serde_json::from_str(&json).unwrap();
852
853 let expected = Query::And(vec![
854 Query::Gt(name1, value1),
855 Query::Gt(name2, value2),
856 Query::Gt(name3, value3),
857 ]);
858
859 assert_eq!(query, expected);
860 }
861
862 #[test]
863 fn test_and_with_multiple_gte_parse() {
864 let name1 = _random_string(10);
865 let value1 = _random_string(10);
866 let name2 = _random_string(10);
867 let value2 = _random_string(10);
868 let name3 = _random_string(10);
869 let value3 = _random_string(10);
870
871 let json = format!(
872 r#"{{"$and":[{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}}]}}"#,
873 name1, value1, name2, value2, name3, value3,
874 );
875
876 let query: Query = ::serde_json::from_str(&json).unwrap();
877
878 let expected = Query::And(vec![
879 Query::Gte(name1, value1),
880 Query::Gte(name2, value2),
881 Query::Gte(name3, value3),
882 ]);
883
884 assert_eq!(query, expected);
885 }
886
887 #[test]
888 fn test_and_with_multiple_lt_parse() {
889 let name1 = _random_string(10);
890 let value1 = _random_string(10);
891 let name2 = _random_string(10);
892 let value2 = _random_string(10);
893 let name3 = _random_string(10);
894 let value3 = _random_string(10);
895
896 let json = format!(
897 r#"{{"$and":[{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}}]}}"#,
898 name1, value1, name2, value2, name3, value3,
899 );
900
901 let query: Query = ::serde_json::from_str(&json).unwrap();
902
903 let expected = Query::And(vec![
904 Query::Lt(name1, value1),
905 Query::Lt(name2, value2),
906 Query::Lt(name3, value3),
907 ]);
908
909 assert_eq!(query, expected);
910 }
911
912 #[test]
913 fn test_and_with_multiple_lte_parse() {
914 let name1 = _random_string(10);
915 let value1 = _random_string(10);
916 let name2 = _random_string(10);
917 let value2 = _random_string(10);
918 let name3 = _random_string(10);
919 let value3 = _random_string(10);
920
921 let json = format!(
922 r#"{{"$and":[{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}}]}}"#,
923 name1, value1, name2, value2, name3, value3,
924 );
925
926 let query: Query = ::serde_json::from_str(&json).unwrap();
927
928 let expected = Query::And(vec![
929 Query::Lte(name1, value1),
930 Query::Lte(name2, value2),
931 Query::Lte(name3, value3),
932 ]);
933
934 assert_eq!(query, expected);
935 }
936
937 #[test]
938 fn test_and_with_multiple_like_parse() {
939 let name1 = _random_string(10);
940 let value1 = _random_string(10);
941 let name2 = _random_string(10);
942 let value2 = _random_string(10);
943 let name3 = _random_string(10);
944 let value3 = _random_string(10);
945
946 let json = format!(
947 r#"{{"$and":[{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}}]}}"#,
948 name1, value1, name2, value2, name3, value3,
949 );
950
951 let query: Query = ::serde_json::from_str(&json).unwrap();
952
953 let expected = Query::And(vec![
954 Query::Like(name1, value1),
955 Query::Like(name2, value2),
956 Query::Like(name3, value3),
957 ]);
958
959 assert_eq!(query, expected);
960 }
961
962 #[test]
963 fn test_and_with_multiple_in_parse() {
964 let name1 = _random_string(10);
965 let value1 = _random_string(10);
966 let name2 = _random_string(10);
967 let value2 = _random_string(10);
968 let name3 = _random_string(10);
969 let value3 = _random_string(10);
970
971 let json = format!(
972 r#"{{"$and":[{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}}]}}"#,
973 name1, value1, name2, value2, name3, value3,
974 );
975
976 let query: Query = ::serde_json::from_str(&json).unwrap();
977
978 let expected = Query::And(vec![
979 Query::In(name1, vec![value1]),
980 Query::In(name2, vec![value2]),
981 Query::In(name3, vec![value3]),
982 ]);
983
984 assert_eq!(query, expected);
985 }
986
987 #[test]
988 fn test_and_with_multiple_not_eq_parse() {
989 let name1 = _random_string(10);
990 let value1 = _random_string(10);
991 let name2 = _random_string(10);
992 let value2 = _random_string(10);
993 let name3 = _random_string(10);
994 let value3 = _random_string(10);
995
996 let json = format!(
997 r#"{{"$and":[{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
998 name1, value1, name2, value2, name3, value3,
999 );
1000
1001 let query: Query = ::serde_json::from_str(&json).unwrap();
1002
1003 let expected = Query::And(vec![
1004 Query::Not(Box::new(Query::Eq(name1, value1))),
1005 Query::Not(Box::new(Query::Eq(name2, value2))),
1006 Query::Not(Box::new(Query::Eq(name3, value3))),
1007 ]);
1008
1009 assert_eq!(query, expected);
1010 }
1011
1012 #[test]
1013 fn test_and_with_multiple_mixed_parse() {
1014 let name1 = _random_string(10);
1015 let value1 = _random_string(10);
1016 let name2 = _random_string(10);
1017 let value2 = _random_string(10);
1018 let name3 = _random_string(10);
1019 let value3 = _random_string(10);
1020 let name4 = _random_string(10);
1021 let value4 = _random_string(10);
1022 let name5 = _random_string(10);
1023 let value5 = _random_string(10);
1024 let name6 = _random_string(10);
1025 let value6 = _random_string(10);
1026 let name7 = _random_string(10);
1027 let value7 = _random_string(10);
1028 let name8 = _random_string(10);
1029 let value8a = _random_string(10);
1030 let value8b = _random_string(10);
1031 let name9 = _random_string(10);
1032 let value9 = _random_string(10);
1033
1034 let json = format!(
1035 r#"{{"$and":[{{"{}":"{}"}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$in":["{}","{}"]}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
1036 name1,
1037 value1,
1038 name2,
1039 value2,
1040 name3,
1041 value3,
1042 name4,
1043 value4,
1044 name5,
1045 value5,
1046 name6,
1047 value6,
1048 name7,
1049 value7,
1050 name8,
1051 value8a,
1052 value8b,
1053 name9,
1054 value9,
1055 );
1056
1057 let query: Query = ::serde_json::from_str(&json).unwrap();
1058
1059 let expected = Query::And(vec![
1060 Query::Eq(name1, value1),
1061 Query::Neq(name2, value2),
1062 Query::Gt(name3, value3),
1063 Query::Gte(name4, value4),
1064 Query::Lt(name5, value5),
1065 Query::Lte(name6, value6),
1066 Query::Like(name7, value7),
1067 Query::In(name8, vec![value8a, value8b]),
1068 Query::Not(Box::new(Query::Eq(name9, value9))),
1069 ]);
1070
1071 assert_eq!(query, expected);
1072 }
1073
1074 #[test]
1075 fn test_or_with_one_eq_parse() {
1076 let name1 = _random_string(10);
1077 let value1 = _random_string(10);
1078
1079 let json = format!(r#"{{"$or":[{{"{}":"{}"}}]}}"#, name1, value1);
1080
1081 let query: Query = ::serde_json::from_str(&json).unwrap();
1082
1083 let expected = Query::Or(vec![Query::Eq(name1, value1)]);
1084
1085 assert_eq!(query, expected);
1086 }
1087
1088 #[test]
1089 fn test_or_with_one_neq_parse() {
1090 let name1 = _random_string(10);
1091 let value1 = _random_string(10);
1092
1093 let json = format!(r#"{{"$or":[{{"{}":{{"$neq":"{}"}}}}]}}"#, name1, value1);
1094
1095 let query: Query = ::serde_json::from_str(&json).unwrap();
1096
1097 let expected = Query::Or(vec![Query::Neq(name1, value1)]);
1098
1099 assert_eq!(query, expected);
1100 }
1101
1102 #[test]
1103 fn test_or_with_one_gt_parse() {
1104 let name1 = _random_string(10);
1105 let value1 = _random_string(10);
1106
1107 let json = format!(r#"{{"$or":[{{"{}":{{"$gt":"{}"}}}}]}}"#, name1, value1);
1108
1109 let query: Query = ::serde_json::from_str(&json).unwrap();
1110
1111 let expected = Query::Or(vec![Query::Gt(name1, value1)]);
1112
1113 assert_eq!(query, expected);
1114 }
1115
1116 #[test]
1117 fn test_or_with_one_gte_parse() {
1118 let name1 = _random_string(10);
1119 let value1 = _random_string(10);
1120
1121 let json = format!(r#"{{"$or":[{{"{}":{{"$gte":"{}"}}}}]}}"#, name1, value1);
1122
1123 let query: Query = ::serde_json::from_str(&json).unwrap();
1124
1125 let expected = Query::Or(vec![Query::Gte(name1, value1)]);
1126
1127 assert_eq!(query, expected);
1128 }
1129
1130 #[test]
1131 fn test_or_with_one_lt_parse() {
1132 let name1 = _random_string(10);
1133 let value1 = _random_string(10);
1134
1135 let json = format!(r#"{{"$or":[{{"{}":{{"$lt":"{}"}}}}]}}"#, name1, value1);
1136
1137 let query: Query = ::serde_json::from_str(&json).unwrap();
1138
1139 let expected = Query::Or(vec![Query::Lt(name1, value1)]);
1140
1141 assert_eq!(query, expected);
1142 }
1143
1144 #[test]
1145 fn test_or_with_one_lte_parse() {
1146 let name1 = _random_string(10);
1147 let value1 = _random_string(10);
1148
1149 let json = format!(r#"{{"$or":[{{"{}":{{"$lte":"{}"}}}}]}}"#, name1, value1);
1150
1151 let query: Query = ::serde_json::from_str(&json).unwrap();
1152
1153 let expected = Query::Or(vec![Query::Lte(name1, value1)]);
1154
1155 assert_eq!(query, expected);
1156 }
1157
1158 #[test]
1159 fn test_or_with_one_like_parse() {
1160 let name1 = _random_string(10);
1161 let value1 = _random_string(10);
1162
1163 let json = format!(r#"{{"$or":[{{"{}":{{"$like":"{}"}}}}]}}"#, name1, value1);
1164
1165 let query: Query = ::serde_json::from_str(&json).unwrap();
1166
1167 let expected = Query::Or(vec![Query::Like(name1, value1)]);
1168
1169 assert_eq!(query, expected);
1170 }
1171
1172 #[test]
1173 fn test_or_with_one_in_parse() {
1174 let name1 = _random_string(10);
1175 let value1 = _random_string(10);
1176
1177 let json = format!(r#"{{"$or":[{{"{}":{{"$in":["{}"]}}}}]}}"#, name1, value1);
1178
1179 let query: Query = ::serde_json::from_str(&json).unwrap();
1180
1181 let expected = Query::Or(vec![Query::In(name1, vec![value1])]);
1182
1183 assert_eq!(query, expected);
1184 }
1185
1186 #[test]
1187 fn test_or_with_one_not_eq_parse() {
1188 let name1 = _random_string(10);
1189 let value1 = _random_string(10);
1190
1191 let json = format!(r#"{{"$or":[{{"$not":{{"{}":"{}"}}}}]}}"#, name1, value1);
1192
1193 let query: Query = ::serde_json::from_str(&json).unwrap();
1194
1195 let expected = Query::Or(vec![Query::Not(Box::new(Query::Eq(name1, value1)))]);
1196
1197 assert_eq!(query, expected);
1198 }
1199
1200 #[test]
1201 fn test_or_with_multiple_eq_parse() {
1202 let name1 = _random_string(10);
1203 let value1 = _random_string(10);
1204 let name2 = _random_string(10);
1205 let value2 = _random_string(10);
1206 let name3 = _random_string(10);
1207 let value3 = _random_string(10);
1208
1209 let json = format!(
1210 r#"{{"$or":[{{"{}":"{}"}},{{"{}":"{}"}},{{"{}":"{}"}}]}}"#,
1211 name1, value1, name2, value2, name3, value3,
1212 );
1213
1214 let query: Query = ::serde_json::from_str(&json).unwrap();
1215
1216 let expected = Query::Or(vec![
1217 Query::Eq(name1, value1),
1218 Query::Eq(name2, value2),
1219 Query::Eq(name3, value3),
1220 ]);
1221
1222 assert_eq!(query, expected);
1223 }
1224
1225 #[test]
1226 fn test_or_with_multiple_neq_parse() {
1227 let name1 = _random_string(10);
1228 let value1 = _random_string(10);
1229 let name2 = _random_string(10);
1230 let value2 = _random_string(10);
1231 let name3 = _random_string(10);
1232 let value3 = _random_string(10);
1233
1234 let json = format!(
1235 r#"{{"$or":[{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}}]}}"#,
1236 name1, value1, name2, value2, name3, value3,
1237 );
1238
1239 let query: Query = ::serde_json::from_str(&json).unwrap();
1240
1241 let expected = Query::Or(vec![
1242 Query::Neq(name1, value1),
1243 Query::Neq(name2, value2),
1244 Query::Neq(name3, value3),
1245 ]);
1246
1247 assert_eq!(query, expected);
1248 }
1249
1250 #[test]
1251 fn test_or_with_multiple_gt_parse() {
1252 let name1 = _random_string(10);
1253 let value1 = _random_string(10);
1254 let name2 = _random_string(10);
1255 let value2 = _random_string(10);
1256 let name3 = _random_string(10);
1257 let value3 = _random_string(10);
1258
1259 let json = format!(
1260 r#"{{"$or":[{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}}]}}"#,
1261 name1, value1, name2, value2, name3, value3,
1262 );
1263
1264 let query: Query = ::serde_json::from_str(&json).unwrap();
1265
1266 let expected = Query::Or(vec![
1267 Query::Gt(name1, value1),
1268 Query::Gt(name2, value2),
1269 Query::Gt(name3, value3),
1270 ]);
1271
1272 assert_eq!(query, expected);
1273 }
1274
1275 #[test]
1276 fn test_or_with_multiple_gte_parse() {
1277 let name1 = _random_string(10);
1278 let value1 = _random_string(10);
1279 let name2 = _random_string(10);
1280 let value2 = _random_string(10);
1281 let name3 = _random_string(10);
1282 let value3 = _random_string(10);
1283
1284 let json = format!(
1285 r#"{{"$or":[{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}}]}}"#,
1286 name1, value1, name2, value2, name3, value3,
1287 );
1288
1289 let query: Query = ::serde_json::from_str(&json).unwrap();
1290
1291 let expected = Query::Or(vec![
1292 Query::Gte(name1, value1),
1293 Query::Gte(name2, value2),
1294 Query::Gte(name3, value3),
1295 ]);
1296
1297 assert_eq!(query, expected);
1298 }
1299
1300 #[test]
1301 fn test_or_with_multiple_lt_parse() {
1302 let name1 = _random_string(10);
1303 let value1 = _random_string(10);
1304 let name2 = _random_string(10);
1305 let value2 = _random_string(10);
1306 let name3 = _random_string(10);
1307 let value3 = _random_string(10);
1308
1309 let json = format!(
1310 r#"{{"$or":[{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}}]}}"#,
1311 name1, value1, name2, value2, name3, value3,
1312 );
1313
1314 let query: Query = ::serde_json::from_str(&json).unwrap();
1315
1316 let expected = Query::Or(vec![
1317 Query::Lt(name1, value1),
1318 Query::Lt(name2, value2),
1319 Query::Lt(name3, value3),
1320 ]);
1321
1322 assert_eq!(query, expected);
1323 }
1324
1325 #[test]
1326 fn test_or_with_multiple_lte_parse() {
1327 let name1 = _random_string(10);
1328 let value1 = _random_string(10);
1329 let name2 = _random_string(10);
1330 let value2 = _random_string(10);
1331 let name3 = _random_string(10);
1332 let value3 = _random_string(10);
1333
1334 let json = format!(
1335 r#"{{"$or":[{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}}]}}"#,
1336 name1, value1, name2, value2, name3, value3,
1337 );
1338
1339 let query: Query = ::serde_json::from_str(&json).unwrap();
1340
1341 let expected = Query::Or(vec![
1342 Query::Lte(name1, value1),
1343 Query::Lte(name2, value2),
1344 Query::Lte(name3, value3),
1345 ]);
1346
1347 assert_eq!(query, expected);
1348 }
1349
1350 #[test]
1351 fn test_or_with_multiple_like_parse() {
1352 let name1 = _random_string(10);
1353 let value1 = _random_string(10);
1354 let name2 = _random_string(10);
1355 let value2 = _random_string(10);
1356 let name3 = _random_string(10);
1357 let value3 = _random_string(10);
1358
1359 let json = format!(
1360 r#"{{"$or":[{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}}]}}"#,
1361 name1, value1, name2, value2, name3, value3,
1362 );
1363
1364 let query: Query = ::serde_json::from_str(&json).unwrap();
1365
1366 let expected = Query::Or(vec![
1367 Query::Like(name1, value1),
1368 Query::Like(name2, value2),
1369 Query::Like(name3, value3),
1370 ]);
1371
1372 assert_eq!(query, expected);
1373 }
1374
1375 #[test]
1376 fn test_or_with_multiple_in_parse() {
1377 let name1 = _random_string(10);
1378 let value1 = _random_string(10);
1379 let name2 = _random_string(10);
1380 let value2 = _random_string(10);
1381 let name3 = _random_string(10);
1382 let value3 = _random_string(10);
1383
1384 let json = format!(
1385 r#"{{"$or":[{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}}]}}"#,
1386 name1, value1, name2, value2, name3, value3,
1387 );
1388
1389 let query: Query = ::serde_json::from_str(&json).unwrap();
1390
1391 let expected = Query::Or(vec![
1392 Query::In(name1, vec![value1]),
1393 Query::In(name2, vec![value2]),
1394 Query::In(name3, vec![value3]),
1395 ]);
1396
1397 assert_eq!(query, expected);
1398 }
1399
1400 #[test]
1401 fn test_or_with_multiple_not_eq_parse() {
1402 let name1 = _random_string(10);
1403 let value1 = _random_string(10);
1404 let name2 = _random_string(10);
1405 let value2 = _random_string(10);
1406 let name3 = _random_string(10);
1407 let value3 = _random_string(10);
1408
1409 let json = format!(
1410 r#"{{"$or":[{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
1411 name1, value1, name2, value2, name3, value3,
1412 );
1413
1414 let query: Query = ::serde_json::from_str(&json).unwrap();
1415
1416 let expected = Query::Or(vec![
1417 Query::Not(Box::new(Query::Eq(name1, value1))),
1418 Query::Not(Box::new(Query::Eq(name2, value2))),
1419 Query::Not(Box::new(Query::Eq(name3, value3))),
1420 ]);
1421
1422 assert_eq!(query, expected);
1423 }
1424
1425 #[test]
1426 fn test_or_with_multiple_mixed_parse() {
1427 let name1 = _random_string(10);
1428 let value1 = _random_string(10);
1429 let name2 = _random_string(10);
1430 let value2 = _random_string(10);
1431 let name3 = _random_string(10);
1432 let value3 = _random_string(10);
1433 let name4 = _random_string(10);
1434 let value4 = _random_string(10);
1435 let name5 = _random_string(10);
1436 let value5 = _random_string(10);
1437 let name6 = _random_string(10);
1438 let value6 = _random_string(10);
1439 let name7 = _random_string(10);
1440 let value7 = _random_string(10);
1441 let name8 = _random_string(10);
1442 let value8a = _random_string(10);
1443 let value8b = _random_string(10);
1444 let name9 = _random_string(10);
1445 let value9 = _random_string(10);
1446
1447 let json = format!(
1448 r#"{{"$or":[{{"{}":"{}"}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$in":["{}","{}"]}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
1449 name1,
1450 value1,
1451 name2,
1452 value2,
1453 name3,
1454 value3,
1455 name4,
1456 value4,
1457 name5,
1458 value5,
1459 name6,
1460 value6,
1461 name7,
1462 value7,
1463 name8,
1464 value8a,
1465 value8b,
1466 name9,
1467 value9,
1468 );
1469
1470 let query: Query = ::serde_json::from_str(&json).unwrap();
1471
1472 let expected = Query::Or(vec![
1473 Query::Eq(name1, value1),
1474 Query::Neq(name2, value2),
1475 Query::Gt(name3, value3),
1476 Query::Gte(name4, value4),
1477 Query::Lt(name5, value5),
1478 Query::Lte(name6, value6),
1479 Query::Like(name7, value7),
1480 Query::In(name8, vec![value8a, value8b]),
1481 Query::Not(Box::new(Query::Eq(name9, value9))),
1482 ]);
1483
1484 assert_eq!(query, expected);
1485 }
1486
1487 #[test]
1488 fn test_not_with_one_eq_parse() {
1489 let name1 = _random_string(10);
1490 let value1 = _random_string(10);
1491
1492 let json = format!(r#"{{"$not":{{"{}":"{}"}}}}"#, name1, value1);
1493
1494 let query: Query = ::serde_json::from_str(&json).unwrap();
1495
1496 let expected = Query::Not(Box::new(Query::Eq(name1, value1)));
1497
1498 assert_eq!(query, expected);
1499 }
1500
1501 #[test]
1502 fn test_not_with_one_neq_parse() {
1503 let name1 = _random_string(10);
1504 let value1 = _random_string(10);
1505
1506 let json = format!(r#"{{"$not":{{"{}":{{"$neq":"{}"}}}}}}"#, name1, value1);
1507
1508 let query: Query = ::serde_json::from_str(&json).unwrap();
1509
1510 let expected = Query::Not(Box::new(Query::Neq(name1, value1)));
1511
1512 assert_eq!(query, expected);
1513 }
1514
1515 #[test]
1516 fn test_not_with_one_gt_parse() {
1517 let name1 = _random_string(10);
1518 let value1 = _random_string(10);
1519
1520 let json = format!(r#"{{"$not":{{"{}":{{"$gt":"{}"}}}}}}"#, name1, value1);
1521
1522 let query: Query = ::serde_json::from_str(&json).unwrap();
1523
1524 let expected = Query::Not(Box::new(Query::Gt(name1, value1)));
1525
1526 assert_eq!(query, expected);
1527 }
1528
1529 #[test]
1530 fn test_not_with_one_gte_parse() {
1531 let name1 = _random_string(10);
1532 let value1 = _random_string(10);
1533
1534 let json = format!(r#"{{"$not":{{"{}":{{"$gte":"{}"}}}}}}"#, name1, value1);
1535
1536 let query: Query = ::serde_json::from_str(&json).unwrap();
1537
1538 let expected = Query::Not(Box::new(Query::Gte(name1, value1)));
1539
1540 assert_eq!(query, expected);
1541 }
1542
1543 #[test]
1544 fn test_not_with_one_lt_parse() {
1545 let name1 = _random_string(10);
1546 let value1 = _random_string(10);
1547
1548 let json = format!(r#"{{"$not":{{"{}":{{"$lt":"{}"}}}}}}"#, name1, value1);
1549
1550 let query: Query = ::serde_json::from_str(&json).unwrap();
1551
1552 let expected = Query::Not(Box::new(Query::Lt(name1, value1)));
1553
1554 assert_eq!(query, expected);
1555 }
1556
1557 #[test]
1558 fn test_not_with_one_lte_parse() {
1559 let name1 = _random_string(10);
1560 let value1 = _random_string(10);
1561
1562 let json = format!(r#"{{"$not":{{"{}":{{"$lte":"{}"}}}}}}"#, name1, value1);
1563
1564 let query: Query = ::serde_json::from_str(&json).unwrap();
1565
1566 let expected = Query::Not(Box::new(Query::Lte(name1, value1)));
1567
1568 assert_eq!(query, expected);
1569 }
1570
1571 #[test]
1572 fn test_not_with_one_like_parse() {
1573 let name1 = _random_string(10);
1574 let value1 = _random_string(10);
1575
1576 let json = format!(r#"{{"$not":{{"{}":{{"$like":"{}"}}}}}}"#, name1, value1);
1577
1578 let query: Query = ::serde_json::from_str(&json).unwrap();
1579
1580 let expected = Query::Not(Box::new(Query::Like(name1, value1)));
1581
1582 assert_eq!(query, expected);
1583 }
1584
1585 #[test]
1586 fn test_not_with_one_in_parse() {
1587 let name1 = _random_string(10);
1588 let value1 = _random_string(10);
1589
1590 let json = format!(r#"{{"$not":{{"{}":{{"$in":["{}"]}}}}}}"#, name1, value1);
1591
1592 let query: Query = ::serde_json::from_str(&json).unwrap();
1593
1594 let expected = Query::Not(Box::new(Query::In(name1, vec![value1])));
1595
1596 assert_eq!(query, expected);
1597 }
1598
1599 #[test]
1600 fn test_and_or_not_complex_case_parse() {
1601 let name1 = _random_string(10);
1602 let value1 = _random_string(10);
1603 let name2 = _random_string(10);
1604 let value2 = _random_string(10);
1605 let name3 = _random_string(10);
1606 let value3 = _random_string(10);
1607 let name4 = _random_string(10);
1608 let value4 = _random_string(10);
1609 let name5 = _random_string(10);
1610 let value5 = _random_string(10);
1611 let name6 = _random_string(10);
1612 let value6 = _random_string(10);
1613 let name7 = _random_string(10);
1614 let value7 = _random_string(10);
1615 let name8 = _random_string(10);
1616 let value8 = _random_string(10);
1617
1618 let json = format!(
1619 r#"{{"$not":{{"$and":[{{"{}":"{}"}},{{"$or":[{{"{}":{{"$gt":"{}"}}}},{{"$not":{{"{}":{{"$lte":"{}"}}}}}},{{"$and":[{{"{}":{{"$lt":"{}"}}}},{{"$not":{{"{}":{{"$gte":"{}"}}}}}}]}}]}},{{"$not":{{"{}":{{"$like":"{}"}}}}}},{{"$and":[{{"{}":"{}"}},{{"$not":{{"{}":{{"$neq":"{}"}}}}}}]}}]}}}}"#,
1620 name1,
1621 value1,
1622 name2,
1623 value2,
1624 name3,
1625 value3,
1626 name4,
1627 value4,
1628 name5,
1629 value5,
1630 name6,
1631 value6,
1632 name7,
1633 value7,
1634 name8,
1635 value8,
1636 );
1637
1638 let query: Query = ::serde_json::from_str(&json).unwrap();
1639
1640 let expected = Query::Not(Box::new(Query::And(vec![
1641 Query::Eq(name1, value1),
1642 Query::Or(vec![
1643 Query::Gt(name2, value2),
1644 Query::Not(Box::new(Query::Lte(name3, value3))),
1645 Query::And(vec![
1646 Query::Lt(name4, value4),
1647 Query::Not(Box::new(Query::Gte(name5, value5))),
1648 ]),
1649 ]),
1650 Query::Not(Box::new(Query::Like(name6, value6))),
1651 Query::And(vec![
1652 Query::Eq(name7, value7),
1653 Query::Not(Box::new(Query::Neq(name8, value8))),
1654 ]),
1655 ])));
1656
1657 assert_eq!(query, expected);
1658 }
1659
1660 #[test]
1662 fn test_simple_operator_empty_and_to_string() {
1663 let query = Query::And(vec![]);
1664
1665 let json = ::serde_json::to_string(&query).unwrap();
1666
1667 let expected = "{}";
1668
1669 assert_eq!(json, expected);
1670 }
1671
1672 #[test]
1673 fn test_simple_operator_empty_or_to_string() {
1674 let query = Query::Or(vec![]);
1675
1676 let json = ::serde_json::to_string(&query).unwrap();
1677
1678 let expected = "{}";
1679
1680 assert_eq!(json, expected);
1681 }
1682
1683 #[test]
1684 fn test_simple_operator_empty_not_to_string() {
1685 let query = Query::Not(Box::new(Query::And(vec![])));
1686
1687 let json = ::serde_json::to_string(&query).unwrap();
1688
1689 let expected = r#"{"$not":{}}"#;
1690
1691 assert_eq!(json, expected);
1692 }
1693
1694 #[test]
1695 fn test_simple_operator_eq_to_string() {
1696 let name1 = _random_string(10);
1697 let value1 = _random_string(10);
1698
1699 let query = Query::Eq(name1.clone(), value1.clone());
1700
1701 let json = ::serde_json::to_string(&query).unwrap();
1702
1703 let expected = format!(r#"{{"{}":"{}"}}"#, name1, value1);
1704
1705 assert_eq!(json, expected);
1706 }
1707
1708 #[test]
1709 fn test_simple_operator_neq_to_string() {
1710 let name1 = _random_string(10);
1711 let value1 = _random_string(10);
1712
1713 let query = Query::Neq(name1.clone(), value1.clone());
1714
1715 let json = ::serde_json::to_string(&query).unwrap();
1716
1717 let expected = format!(r#"{{"{}":{{"$neq":"{}"}}}}"#, name1, value1);
1718
1719 assert_eq!(json, expected);
1720 }
1721
1722 #[test]
1723 fn test_simple_operator_gt_plaintext_to_string() {
1724 let name1 = _random_string(10);
1725 let value1 = _random_string(10);
1726
1727 let query = Query::Gt(name1.clone(), value1.clone());
1728
1729 let json = ::serde_json::to_string(&query).unwrap();
1730
1731 let expected = format!(r#"{{"{}":{{"$gt":"{}"}}}}"#, name1, value1);
1732
1733 assert_eq!(json, expected);
1734 }
1735
1736 #[test]
1737 fn test_simple_operator_gte_to_string() {
1738 let name1 = _random_string(10);
1739 let value1 = _random_string(10);
1740
1741 let query = Query::Gte(name1.clone(), value1.clone());
1742
1743 let json = ::serde_json::to_string(&query).unwrap();
1744
1745 let expected = format!(r#"{{"{}":{{"$gte":"{}"}}}}"#, name1, value1);
1746
1747 assert_eq!(json, expected);
1748 }
1749
1750 #[test]
1751 fn test_simple_operator_lt_to_string() {
1752 let name1 = _random_string(10);
1753 let value1 = _random_string(10);
1754
1755 let query = Query::Lt(name1.clone(), value1.clone());
1756
1757 let json = ::serde_json::to_string(&query).unwrap();
1758
1759 let expected = format!(r#"{{"{}":{{"$lt":"{}"}}}}"#, name1, value1);
1760
1761 assert_eq!(json, expected);
1762 }
1763
1764 #[test]
1765 fn test_simple_operator_lte_to_string() {
1766 let name1 = _random_string(10);
1767 let value1 = _random_string(10);
1768
1769 let query = Query::Lte(name1.clone(), value1.clone());
1770
1771 let json = ::serde_json::to_string(&query).unwrap();
1772
1773 let expected = format!(r#"{{"{}":{{"$lte":"{}"}}}}"#, name1, value1);
1774
1775 assert_eq!(json, expected);
1776 }
1777
1778 #[test]
1779 fn test_simple_operator_like_to_string() {
1780 let name1 = _random_string(10);
1781 let value1 = _random_string(10);
1782
1783 let query = Query::Like(name1.clone(), value1.clone());
1784
1785 let json = ::serde_json::to_string(&query).unwrap();
1786
1787 let expected = format!(r#"{{"{}":{{"$like":"{}"}}}}"#, name1, value1);
1788
1789 assert_eq!(json, expected);
1790 }
1791
1792 #[test]
1793 fn test_simple_operator_in_to_string() {
1794 let name1 = _random_string(10);
1795 let value1 = _random_string(10);
1796
1797 let query = Query::In(name1.clone(), vec![value1.clone()]);
1798
1799 let json = ::serde_json::to_string(&query).unwrap();
1800
1801 let expected = format!(r#"{{"{}":{{"$in":["{}"]}}}}"#, name1, value1);
1802
1803 assert_eq!(json, expected);
1804 }
1805
1806 #[test]
1807 fn test_simple_operator_in_multimply_to_string() {
1808 let name1 = _random_string(10);
1809 let value1 = _random_string(10);
1810 let value2 = _random_string(10);
1811 let value3 = _random_string(10);
1812
1813 let query = Query::In(
1814 name1.clone(),
1815 vec![value1.clone(), value2.clone(), value3.clone()],
1816 );
1817
1818 let json = ::serde_json::to_string(&query).unwrap();
1819
1820 let expected = format!(
1821 r#"{{"{}":{{"$in":["{}","{}","{}"]}}}}"#,
1822 name1, value1, value2, value3
1823 );
1824
1825 assert_eq!(json, expected);
1826 }
1827
1828 #[test]
1829 fn test_and_with_one_eq_to_string() {
1830 let name1 = _random_string(10);
1831 let value1 = _random_string(10);
1832
1833 let query = Query::And(vec![Query::Eq(name1.clone(), value1.clone())]);
1834
1835 let json = ::serde_json::to_string(&query).unwrap();
1836
1837 let expected = format!(r#"{{"$and":[{{"{}":"{}"}}]}}"#, name1, value1);
1838
1839 assert_eq!(json, expected);
1840 }
1841
1842 #[test]
1843 fn test_and_with_one_neq_to_string() {
1844 let name1 = _random_string(10);
1845 let value1 = _random_string(10);
1846
1847 let query = Query::And(vec![Query::Neq(name1.clone(), value1.clone())]);
1848
1849 let json = ::serde_json::to_string(&query).unwrap();
1850
1851 let expected = format!(r#"{{"$and":[{{"{}":{{"$neq":"{}"}}}}]}}"#, name1, value1);
1852
1853 assert_eq!(json, expected);
1854 }
1855
1856 #[test]
1857 fn test_and_with_one_gt_to_string() {
1858 let name1 = _random_string(10);
1859 let value1 = _random_string(10);
1860
1861 let query = Query::And(vec![Query::Gt(name1.clone(), value1.clone())]);
1862
1863 let json = ::serde_json::to_string(&query).unwrap();
1864
1865 let expected = format!(r#"{{"$and":[{{"{}":{{"$gt":"{}"}}}}]}}"#, name1, value1);
1866
1867 assert_eq!(json, expected);
1868 }
1869
1870 #[test]
1871 fn test_and_with_one_gte_to_string() {
1872 let name1 = _random_string(10);
1873 let value1 = _random_string(10);
1874
1875 let query = Query::And(vec![Query::Gte(name1.clone(), value1.clone())]);
1876
1877 let json = ::serde_json::to_string(&query).unwrap();
1878
1879 let expected = format!(r#"{{"$and":[{{"{}":{{"$gte":"{}"}}}}]}}"#, name1, value1);
1880
1881 assert_eq!(json, expected);
1882 }
1883
1884 #[test]
1885 fn test_and_with_one_lt_to_string() {
1886 let name1 = _random_string(10);
1887 let value1 = _random_string(10);
1888
1889 let query = Query::And(vec![Query::Lt(name1.clone(), value1.clone())]);
1890
1891 let json = ::serde_json::to_string(&query).unwrap();
1892
1893 let expected = format!(r#"{{"$and":[{{"{}":{{"$lt":"{}"}}}}]}}"#, name1, value1);
1894
1895 assert_eq!(json, expected);
1896 }
1897
1898 #[test]
1899 fn test_and_with_one_lte_to_string() {
1900 let name1 = _random_string(10);
1901 let value1 = _random_string(10);
1902
1903 let query = Query::And(vec![Query::Lte(name1.clone(), value1.clone())]);
1904
1905 let json = ::serde_json::to_string(&query).unwrap();
1906
1907 let expected = format!(r#"{{"$and":[{{"{}":{{"$lte":"{}"}}}}]}}"#, name1, value1);
1908
1909 assert_eq!(json, expected);
1910 }
1911
1912 #[test]
1913 fn test_and_with_one_like_to_string() {
1914 let name1 = _random_string(10);
1915 let value1 = _random_string(10);
1916
1917 let query = Query::And(vec![Query::Like(name1.clone(), value1.clone())]);
1918
1919 let json = ::serde_json::to_string(&query).unwrap();
1920
1921 let expected = format!(r#"{{"$and":[{{"{}":{{"$like":"{}"}}}}]}}"#, name1, value1);
1922
1923 assert_eq!(json, expected);
1924 }
1925
1926 #[test]
1927 fn test_and_with_one_in_to_string() {
1928 let name1 = _random_string(10);
1929 let value1 = _random_string(10);
1930
1931 let query = Query::And(vec![Query::In(name1.clone(), vec![value1.clone()])]);
1932
1933 let json = ::serde_json::to_string(&query).unwrap();
1934
1935 let expected = format!(r#"{{"$and":[{{"{}":{{"$in":["{}"]}}}}]}}"#, name1, value1);
1936
1937 assert_eq!(json, expected);
1938 }
1939
1940 #[test]
1941 fn test_and_with_one_not_eq_to_string() {
1942 let name1 = _random_string(10);
1943 let value1 = _random_string(10);
1944
1945 let query = Query::And(vec![Query::Not(Box::new(Query::Eq(
1946 name1.clone(),
1947 value1.clone(),
1948 )))]);
1949
1950 let json = ::serde_json::to_string(&query).unwrap();
1951
1952 let expected = format!(r#"{{"$and":[{{"$not":{{"{}":"{}"}}}}]}}"#, name1, value1);
1953
1954 assert_eq!(json, expected);
1955 }
1956
1957 #[test]
1958 fn test_and_with_multiple_eq_to_string() {
1959 let name1 = _random_string(10);
1960 let value1 = _random_string(10);
1961 let name2 = _random_string(10);
1962 let value2 = _random_string(10);
1963 let name3 = _random_string(10);
1964 let value3 = _random_string(10);
1965
1966 let query = Query::And(vec![
1967 Query::Eq(name1.clone(), value1.clone()),
1968 Query::Eq(name2.clone(), value2.clone()),
1969 Query::Eq(name3.clone(), value3.clone()),
1970 ]);
1971
1972 let json = ::serde_json::to_string(&query).unwrap();
1973
1974 let expected = format!(
1975 r#"{{"$and":[{{"{}":"{}"}},{{"{}":"{}"}},{{"{}":"{}"}}]}}"#,
1976 name1, value1, name2, value2, name3, value3,
1977 );
1978
1979 assert_eq!(json, expected);
1980 }
1981
1982 #[test]
1983 fn test_and_with_multiple_neq_to_string() {
1984 let name1 = _random_string(10);
1985 let value1 = _random_string(10);
1986 let name2 = _random_string(10);
1987 let value2 = _random_string(10);
1988 let name3 = _random_string(10);
1989 let value3 = _random_string(10);
1990
1991 let query = Query::And(vec![
1992 Query::Neq(name1.clone(), value1.clone()),
1993 Query::Neq(name2.clone(), value2.clone()),
1994 Query::Neq(name3.clone(), value3.clone()),
1995 ]);
1996
1997 let json = ::serde_json::to_string(&query).unwrap();
1998
1999 let expected = format!(
2000 r#"{{"$and":[{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}}]}}"#,
2001 name1, value1, name2, value2, name3, value3,
2002 );
2003
2004 assert_eq!(json, expected);
2005 }
2006
2007 #[test]
2008 fn test_and_with_multiple_gt_to_string() {
2009 let name1 = _random_string(10);
2010 let value1 = _random_string(10);
2011 let name2 = _random_string(10);
2012 let value2 = _random_string(10);
2013 let name3 = _random_string(10);
2014 let value3 = _random_string(10);
2015
2016 let query = Query::And(vec![
2017 Query::Gt(name1.clone(), value1.clone()),
2018 Query::Gt(name2.clone(), value2.clone()),
2019 Query::Gt(name3.clone(), value3.clone()),
2020 ]);
2021
2022 let json = ::serde_json::to_string(&query).unwrap();
2023
2024 let expected = format!(
2025 r#"{{"$and":[{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}}]}}"#,
2026 name1, value1, name2, value2, name3, value3,
2027 );
2028
2029 assert_eq!(json, expected);
2030 }
2031
2032 #[test]
2033 fn test_and_with_multiple_gte_to_string() {
2034 let name1 = _random_string(10);
2035 let value1 = _random_string(10);
2036 let name2 = _random_string(10);
2037 let value2 = _random_string(10);
2038 let name3 = _random_string(10);
2039 let value3 = _random_string(10);
2040
2041 let query = Query::And(vec![
2042 Query::Gte(name1.clone(), value1.clone()),
2043 Query::Gte(name2.clone(), value2.clone()),
2044 Query::Gte(name3.clone(), value3.clone()),
2045 ]);
2046
2047 let json = ::serde_json::to_string(&query).unwrap();
2048
2049 let expected = format!(
2050 r#"{{"$and":[{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}}]}}"#,
2051 name1, value1, name2, value2, name3, value3,
2052 );
2053
2054 assert_eq!(json, expected);
2055 }
2056
2057 #[test]
2058 fn test_and_with_multiple_lt_to_string() {
2059 let name1 = _random_string(10);
2060 let value1 = _random_string(10);
2061 let name2 = _random_string(10);
2062 let value2 = _random_string(10);
2063 let name3 = _random_string(10);
2064 let value3 = _random_string(10);
2065
2066 let query = Query::And(vec![
2067 Query::Lt(name1.clone(), value1.clone()),
2068 Query::Lt(name2.clone(), value2.clone()),
2069 Query::Lt(name3.clone(), value3.clone()),
2070 ]);
2071
2072 let json = ::serde_json::to_string(&query).unwrap();
2073
2074 let expected = format!(
2075 r#"{{"$and":[{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}}]}}"#,
2076 name1, value1, name2, value2, name3, value3,
2077 );
2078
2079 assert_eq!(json, expected);
2080 }
2081
2082 #[test]
2083 fn test_and_with_multiple_lte_to_string() {
2084 let name1 = _random_string(10);
2085 let value1 = _random_string(10);
2086 let name2 = _random_string(10);
2087 let value2 = _random_string(10);
2088 let name3 = _random_string(10);
2089 let value3 = _random_string(10);
2090
2091 let query = Query::And(vec![
2092 Query::Lte(name1.clone(), value1.clone()),
2093 Query::Lte(name2.clone(), value2.clone()),
2094 Query::Lte(name3.clone(), value3.clone()),
2095 ]);
2096
2097 let json = ::serde_json::to_string(&query).unwrap();
2098
2099 let expected = format!(
2100 r#"{{"$and":[{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}}]}}"#,
2101 name1, value1, name2, value2, name3, value3,
2102 );
2103
2104 assert_eq!(json, expected);
2105 }
2106
2107 #[test]
2108 fn test_and_with_multiple_like_to_string() {
2109 let name1 = _random_string(10);
2110 let value1 = _random_string(10);
2111 let name2 = _random_string(10);
2112 let value2 = _random_string(10);
2113 let name3 = _random_string(10);
2114 let value3 = _random_string(10);
2115
2116 let query = Query::And(vec![
2117 Query::Like(name1.clone(), value1.clone()),
2118 Query::Like(name2.clone(), value2.clone()),
2119 Query::Like(name3.clone(), value3.clone()),
2120 ]);
2121
2122 let json = ::serde_json::to_string(&query).unwrap();
2123
2124 let expected = format!(
2125 r#"{{"$and":[{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}}]}}"#,
2126 name1, value1, name2, value2, name3, value3,
2127 );
2128
2129 assert_eq!(json, expected);
2130 }
2131
2132 #[test]
2133 fn test_and_with_multiple_in_to_string() {
2134 let name1 = _random_string(10);
2135 let value1 = _random_string(10);
2136 let name2 = _random_string(10);
2137 let value2 = _random_string(10);
2138 let name3 = _random_string(10);
2139 let value3 = _random_string(10);
2140
2141 let query = Query::And(vec![
2142 Query::In(name1.clone(), vec![value1.clone()]),
2143 Query::In(name2.clone(), vec![value2.clone()]),
2144 Query::In(name3.clone(), vec![value3.clone()]),
2145 ]);
2146
2147 let json = ::serde_json::to_string(&query).unwrap();
2148
2149 let expected = format!(
2150 r#"{{"$and":[{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}}]}}"#,
2151 name1, value1, name2, value2, name3, value3,
2152 );
2153
2154 assert_eq!(json, expected);
2155 }
2156
2157 #[test]
2158 fn test_and_with_multiple_not_eq_to_string() {
2159 let name1 = _random_string(10);
2160 let value1 = _random_string(10);
2161 let name2 = _random_string(10);
2162 let value2 = _random_string(10);
2163 let name3 = _random_string(10);
2164 let value3 = _random_string(10);
2165
2166 let query = Query::And(vec![
2167 Query::Not(Box::new(Query::Eq(name1.clone(), value1.clone()))),
2168 Query::Not(Box::new(Query::Eq(name2.clone(), value2.clone()))),
2169 Query::Not(Box::new(Query::Eq(name3.clone(), value3.clone()))),
2170 ]);
2171
2172 let json = ::serde_json::to_string(&query).unwrap();
2173
2174 let expected = format!(
2175 r#"{{"$and":[{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
2176 name1, value1, name2, value2, name3, value3,
2177 );
2178
2179 assert_eq!(json, expected);
2180 }
2181
2182 #[test]
2183 fn test_and_with_multiple_mixed_to_string() {
2184 let name1 = _random_string(10);
2185 let value1 = _random_string(10);
2186 let name2 = _random_string(10);
2187 let value2 = _random_string(10);
2188 let name3 = _random_string(10);
2189 let value3 = _random_string(10);
2190 let name4 = _random_string(10);
2191 let value4 = _random_string(10);
2192 let name5 = _random_string(10);
2193 let value5 = _random_string(10);
2194 let name6 = _random_string(10);
2195 let value6 = _random_string(10);
2196 let name7 = _random_string(10);
2197 let value7 = _random_string(10);
2198 let name8 = _random_string(10);
2199 let value8a = _random_string(10);
2200 let value8b = _random_string(10);
2201 let name9 = _random_string(10);
2202 let value9 = _random_string(10);
2203
2204 let query = Query::And(vec![
2205 Query::Eq(name1.clone(), value1.clone()),
2206 Query::Neq(name2.clone(), value2.clone()),
2207 Query::Gt(name3.clone(), value3.clone()),
2208 Query::Gte(name4.clone(), value4.clone()),
2209 Query::Lt(name5.clone(), value5.clone()),
2210 Query::Lte(name6.clone(), value6.clone()),
2211 Query::Like(name7.clone(), value7.clone()),
2212 Query::In(name8.clone(), vec![value8a.clone(), value8b.clone()]),
2213 Query::Not(Box::new(Query::Eq(name9.clone(), value9.clone()))),
2214 ]);
2215
2216 let json = ::serde_json::to_string(&query).unwrap();
2217
2218 let expected = format!(
2219 r#"{{"$and":[{{"{}":"{}"}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$in":["{}","{}"]}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
2220 name1,
2221 value1,
2222 name2,
2223 value2,
2224 name3,
2225 value3,
2226 name4,
2227 value4,
2228 name5,
2229 value5,
2230 name6,
2231 value6,
2232 name7,
2233 value7,
2234 name8,
2235 value8a,
2236 value8b,
2237 name9,
2238 value9,
2239 );
2240
2241 assert_eq!(json, expected);
2242 }
2243
2244 #[test]
2245 fn test_or_with_one_eq_to_string() {
2246 let name1 = _random_string(10);
2247 let value1 = _random_string(10);
2248
2249 let query = Query::Or(vec![Query::Eq(name1.clone(), value1.clone())]);
2250
2251 let json = ::serde_json::to_string(&query).unwrap();
2252
2253 let expected = format!(r#"{{"$or":[{{"{}":"{}"}}]}}"#, name1, value1);
2254
2255 assert_eq!(json, expected);
2256 }
2257
2258 #[test]
2259 fn test_or_with_one_neq_to_string() {
2260 let name1 = _random_string(10);
2261 let value1 = _random_string(10);
2262
2263 let query = Query::Or(vec![Query::Neq(name1.clone(), value1.clone())]);
2264
2265 let json = ::serde_json::to_string(&query).unwrap();
2266
2267 let expected = format!(r#"{{"$or":[{{"{}":{{"$neq":"{}"}}}}]}}"#, name1, value1);
2268
2269 assert_eq!(json, expected);
2270 }
2271
2272 #[test]
2273 fn test_or_with_one_gt_to_string() {
2274 let name1 = _random_string(10);
2275 let value1 = _random_string(10);
2276
2277 let query = Query::Or(vec![Query::Gt(name1.clone(), value1.clone())]);
2278
2279 let json = ::serde_json::to_string(&query).unwrap();
2280
2281 let expected = format!(r#"{{"$or":[{{"{}":{{"$gt":"{}"}}}}]}}"#, name1, value1);
2282 assert_eq!(json, expected);
2283 }
2284
2285 #[test]
2286 fn test_or_with_one_gte_to_string() {
2287 let name1 = _random_string(10);
2288 let value1 = _random_string(10);
2289
2290 let query = Query::Or(vec![Query::Gte(name1.clone(), value1.clone())]);
2291
2292 let json = ::serde_json::to_string(&query).unwrap();
2293
2294 let expected = format!(r#"{{"$or":[{{"{}":{{"$gte":"{}"}}}}]}}"#, name1, value1);
2295
2296 assert_eq!(json, expected);
2297 }
2298
2299 #[test]
2300 fn test_or_with_one_lt_to_string() {
2301 let name1 = _random_string(10);
2302 let value1 = _random_string(10);
2303
2304 let query = Query::Or(vec![Query::Lt(name1.clone(), value1.clone())]);
2305
2306 let json = ::serde_json::to_string(&query).unwrap();
2307
2308 let expected = format!(r#"{{"$or":[{{"{}":{{"$lt":"{}"}}}}]}}"#, name1, value1);
2309
2310 assert_eq!(json, expected);
2311 }
2312
2313 #[test]
2314 fn test_or_with_one_lte_to_string() {
2315 let name1 = _random_string(10);
2316 let value1 = _random_string(10);
2317
2318 let query = Query::Or(vec![Query::Lte(name1.clone(), value1.clone())]);
2319
2320 let json = ::serde_json::to_string(&query).unwrap();
2321
2322 let expected = format!(r#"{{"$or":[{{"{}":{{"$lte":"{}"}}}}]}}"#, name1, value1);
2323
2324 assert_eq!(json, expected);
2325 }
2326
2327 #[test]
2328 fn test_or_with_one_like_to_string() {
2329 let name1 = _random_string(10);
2330 let value1 = _random_string(10);
2331
2332 let query = Query::Or(vec![Query::Like(name1.clone(), value1.clone())]);
2333
2334 let json = ::serde_json::to_string(&query).unwrap();
2335
2336 let expected = format!(r#"{{"$or":[{{"{}":{{"$like":"{}"}}}}]}}"#, name1, value1);
2337
2338 assert_eq!(json, expected);
2339 }
2340
2341 #[test]
2342 fn test_or_with_one_in_to_string() {
2343 let name1 = _random_string(10);
2344 let value1 = _random_string(10);
2345
2346 let query = Query::Or(vec![Query::In(name1.clone(), vec![value1.clone()])]);
2347
2348 let json = ::serde_json::to_string(&query).unwrap();
2349
2350 let expected = format!(r#"{{"$or":[{{"{}":{{"$in":["{}"]}}}}]}}"#, name1, value1);
2351
2352 assert_eq!(json, expected);
2353 }
2354
2355 #[test]
2356 fn test_or_with_one_not_eq_to_string() {
2357 let name1 = _random_string(10);
2358 let value1 = _random_string(10);
2359
2360 let query = Query::Or(vec![Query::Not(Box::new(Query::Eq(
2361 name1.clone(),
2362 value1.clone(),
2363 )))]);
2364
2365 let json = ::serde_json::to_string(&query).unwrap();
2366
2367 let expected = format!(r#"{{"$or":[{{"$not":{{"{}":"{}"}}}}]}}"#, name1, value1);
2368
2369 assert_eq!(json, expected);
2370 }
2371
2372 #[test]
2373 fn test_or_with_multiple_eq_to_string() {
2374 let name1 = _random_string(10);
2375 let value1 = _random_string(10);
2376 let name2 = _random_string(10);
2377 let value2 = _random_string(10);
2378 let name3 = _random_string(10);
2379 let value3 = _random_string(10);
2380
2381 let query = Query::Or(vec![
2382 Query::Eq(name1.clone(), value1.clone()),
2383 Query::Eq(name2.clone(), value2.clone()),
2384 Query::Eq(name3.clone(), value3.clone()),
2385 ]);
2386
2387 let json = ::serde_json::to_string(&query).unwrap();
2388
2389 let expected = format!(
2390 r#"{{"$or":[{{"{}":"{}"}},{{"{}":"{}"}},{{"{}":"{}"}}]}}"#,
2391 name1, value1, name2, value2, name3, value3,
2392 );
2393
2394 assert_eq!(json, expected);
2395 }
2396
2397 #[test]
2398 fn test_or_with_multiple_neq_to_string() {
2399 let name1 = _random_string(10);
2400 let value1 = _random_string(10);
2401 let name2 = _random_string(10);
2402 let value2 = _random_string(10);
2403 let name3 = _random_string(10);
2404 let value3 = _random_string(10);
2405
2406 let query = Query::Or(vec![
2407 Query::Neq(name1.clone(), value1.clone()),
2408 Query::Neq(name2.clone(), value2.clone()),
2409 Query::Neq(name3.clone(), value3.clone()),
2410 ]);
2411
2412 let json = ::serde_json::to_string(&query).unwrap();
2413
2414 let expected = format!(
2415 r#"{{"$or":[{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$neq":"{}"}}}}]}}"#,
2416 name1, value1, name2, value2, name3, value3,
2417 );
2418
2419 assert_eq!(json, expected);
2420 }
2421
2422 #[test]
2423 fn test_or_with_multiple_gt_to_string() {
2424 let name1 = _random_string(10);
2425 let value1 = _random_string(10);
2426 let name2 = _random_string(10);
2427 let value2 = _random_string(10);
2428 let name3 = _random_string(10);
2429 let value3 = _random_string(10);
2430
2431 let query = Query::Or(vec![
2432 Query::Gt(name1.clone(), value1.clone()),
2433 Query::Gt(name2.clone(), value2.clone()),
2434 Query::Gt(name3.clone(), value3.clone()),
2435 ]);
2436
2437 let json = ::serde_json::to_string(&query).unwrap();
2438
2439 let expected = format!(
2440 r#"{{"$or":[{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gt":"{}"}}}}]}}"#,
2441 name1, value1, name2, value2, name3, value3,
2442 );
2443
2444 assert_eq!(json, expected);
2445 }
2446
2447 #[test]
2448 fn test_or_with_multiple_gte_to_string() {
2449 let name1 = _random_string(10);
2450 let value1 = _random_string(10);
2451 let name2 = _random_string(10);
2452 let value2 = _random_string(10);
2453 let name3 = _random_string(10);
2454 let value3 = _random_string(10);
2455
2456 let query = Query::Or(vec![
2457 Query::Gte(name1.clone(), value1.clone()),
2458 Query::Gte(name2.clone(), value2.clone()),
2459 Query::Gte(name3.clone(), value3.clone()),
2460 ]);
2461
2462 let json = ::serde_json::to_string(&query).unwrap();
2463
2464 let expected = format!(
2465 r#"{{"$or":[{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$gte":"{}"}}}}]}}"#,
2466 name1, value1, name2, value2, name3, value3,
2467 );
2468
2469 assert_eq!(json, expected);
2470 }
2471
2472 #[test]
2473 fn test_or_with_multiple_lt_to_string() {
2474 let name1 = _random_string(10);
2475 let value1 = _random_string(10);
2476 let name2 = _random_string(10);
2477 let value2 = _random_string(10);
2478 let name3 = _random_string(10);
2479 let value3 = _random_string(10);
2480
2481 let query = Query::Or(vec![
2482 Query::Lt(name1.clone(), value1.clone()),
2483 Query::Lt(name2.clone(), value2.clone()),
2484 Query::Lt(name3.clone(), value3.clone()),
2485 ]);
2486
2487 let json = ::serde_json::to_string(&query).unwrap();
2488
2489 let expected = format!(
2490 r#"{{"$or":[{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lt":"{}"}}}}]}}"#,
2491 name1, value1, name2, value2, name3, value3,
2492 );
2493
2494 assert_eq!(json, expected);
2495 }
2496
2497 #[test]
2498 fn test_or_with_multiple_lte_to_string() {
2499 let name1 = _random_string(10);
2500 let value1 = _random_string(10);
2501 let name2 = _random_string(10);
2502 let value2 = _random_string(10);
2503 let name3 = _random_string(10);
2504 let value3 = _random_string(10);
2505
2506 let query = Query::Or(vec![
2507 Query::Lte(name1.clone(), value1.clone()),
2508 Query::Lte(name2.clone(), value2.clone()),
2509 Query::Lte(name3.clone(), value3.clone()),
2510 ]);
2511
2512 let json = ::serde_json::to_string(&query).unwrap();
2513
2514 let expected = format!(
2515 r#"{{"$or":[{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$lte":"{}"}}}}]}}"#,
2516 name1, value1, name2, value2, name3, value3,
2517 );
2518
2519 assert_eq!(json, expected);
2520 }
2521
2522 #[test]
2523 fn test_or_with_multiple_like_to_string() {
2524 let name1 = _random_string(10);
2525 let value1 = _random_string(10);
2526 let name2 = _random_string(10);
2527 let value2 = _random_string(10);
2528 let name3 = _random_string(10);
2529 let value3 = _random_string(10);
2530
2531 let query = Query::Or(vec![
2532 Query::Like(name1.clone(), value1.clone()),
2533 Query::Like(name2.clone(), value2.clone()),
2534 Query::Like(name3.clone(), value3.clone()),
2535 ]);
2536
2537 let json = ::serde_json::to_string(&query).unwrap();
2538
2539 let expected = format!(
2540 r#"{{"$or":[{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$like":"{}"}}}}]}}"#,
2541 name1, value1, name2, value2, name3, value3,
2542 );
2543
2544 assert_eq!(json, expected);
2545 }
2546
2547 #[test]
2548 fn test_or_with_multiple_in_to_string() {
2549 let name1 = _random_string(10);
2550 let value1 = _random_string(10);
2551 let name2 = _random_string(10);
2552 let value2 = _random_string(10);
2553 let name3 = _random_string(10);
2554 let value3 = _random_string(10);
2555
2556 let query = Query::Or(vec![
2557 Query::In(name1.clone(), vec![value1.clone()]),
2558 Query::In(name2.clone(), vec![value2.clone()]),
2559 Query::In(name3.clone(), vec![value3.clone()]),
2560 ]);
2561
2562 let json = ::serde_json::to_string(&query).unwrap();
2563
2564 let expected = format!(
2565 r#"{{"$or":[{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}},{{"{}":{{"$in":["{}"]}}}}]}}"#,
2566 name1, value1, name2, value2, name3, value3,
2567 );
2568
2569 assert_eq!(json, expected);
2570 }
2571
2572 #[test]
2573 fn test_or_with_multiple_not_eq_to_string() {
2574 let name1 = _random_string(10);
2575 let value1 = _random_string(10);
2576 let name2 = _random_string(10);
2577 let value2 = _random_string(10);
2578 let name3 = _random_string(10);
2579 let value3 = _random_string(10);
2580
2581 let query = Query::Or(vec![
2582 Query::Not(Box::new(Query::Eq(name1.clone(), value1.clone()))),
2583 Query::Not(Box::new(Query::Eq(name2.clone(), value2.clone()))),
2584 Query::Not(Box::new(Query::Eq(name3.clone(), value3.clone()))),
2585 ]);
2586
2587 let json = ::serde_json::to_string(&query).unwrap();
2588
2589 let expected = format!(
2590 r#"{{"$or":[{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
2591 name1, value1, name2, value2, name3, value3,
2592 );
2593
2594 assert_eq!(json, expected);
2595 }
2596
2597 #[test]
2598 fn test_or_with_multiple_mixed_to_string() {
2599 let name1 = _random_string(10);
2600 let value1 = _random_string(10);
2601 let name2 = _random_string(10);
2602 let value2 = _random_string(10);
2603 let name3 = _random_string(10);
2604 let value3 = _random_string(10);
2605 let name4 = _random_string(10);
2606 let value4 = _random_string(10);
2607 let name5 = _random_string(10);
2608 let value5 = _random_string(10);
2609 let name6 = _random_string(10);
2610 let value6 = _random_string(10);
2611 let name7 = _random_string(10);
2612 let value7 = _random_string(10);
2613 let name8 = _random_string(10);
2614 let value8a = _random_string(10);
2615 let value8b = _random_string(10);
2616 let name9 = _random_string(10);
2617 let value9 = _random_string(10);
2618
2619 let query = Query::Or(vec![
2620 Query::Eq(name1.clone(), value1.clone()),
2621 Query::Neq(name2.clone(), value2.clone()),
2622 Query::Gt(name3.clone(), value3.clone()),
2623 Query::Gte(name4.clone(), value4.clone()),
2624 Query::Lt(name5.clone(), value5.clone()),
2625 Query::Lte(name6.clone(), value6.clone()),
2626 Query::Like(name7.clone(), value7.clone()),
2627 Query::In(name8.clone(), vec![value8a.clone(), value8b.clone()]),
2628 Query::Not(Box::new(Query::Eq(name9.clone(), value9.clone()))),
2629 ]);
2630
2631 let json = ::serde_json::to_string(&query).unwrap();
2632
2633 let expected = format!(
2634 r#"{{"$or":[{{"{}":"{}"}},{{"{}":{{"$neq":"{}"}}}},{{"{}":{{"$gt":"{}"}}}},{{"{}":{{"$gte":"{}"}}}},{{"{}":{{"$lt":"{}"}}}},{{"{}":{{"$lte":"{}"}}}},{{"{}":{{"$like":"{}"}}}},{{"{}":{{"$in":["{}","{}"]}}}},{{"$not":{{"{}":"{}"}}}}]}}"#,
2635 name1,
2636 value1,
2637 name2,
2638 value2,
2639 name3,
2640 value3,
2641 name4,
2642 value4,
2643 name5,
2644 value5,
2645 name6,
2646 value6,
2647 name7,
2648 value7,
2649 name8,
2650 value8a,
2651 value8b,
2652 name9,
2653 value9,
2654 );
2655
2656 assert_eq!(json, expected);
2657 }
2658
2659 #[test]
2660 fn test_not_with_one_eq_to_string() {
2661 let name1 = _random_string(10);
2662 let value1 = _random_string(10);
2663
2664 let query = Query::Not(Box::new(Query::Eq(name1.clone(), value1.clone())));
2665
2666 let json = ::serde_json::to_string(&query).unwrap();
2667
2668 let expected = format!(r#"{{"$not":{{"{}":"{}"}}}}"#, name1, value1);
2669
2670 assert_eq!(json, expected);
2671 }
2672
2673 #[test]
2674 fn test_not_with_one_neq_to_string() {
2675 let name1 = _random_string(10);
2676 let value1 = _random_string(10);
2677
2678 let query = Query::Not(Box::new(Query::Neq(name1.clone(), value1.clone())));
2679
2680 let json = ::serde_json::to_string(&query).unwrap();
2681
2682 let expected = format!(r#"{{"$not":{{"{}":{{"$neq":"{}"}}}}}}"#, name1, value1);
2683
2684 assert_eq!(json, expected);
2685 }
2686
2687 #[test]
2688 fn test_not_with_one_gt_to_string() {
2689 let name1 = _random_string(10);
2690 let value1 = _random_string(10);
2691
2692 let query = Query::Not(Box::new(Query::Gt(name1.clone(), value1.clone())));
2693
2694 let json = ::serde_json::to_string(&query).unwrap();
2695
2696 let expected = format!(r#"{{"$not":{{"{}":{{"$gt":"{}"}}}}}}"#, name1, value1);
2697
2698 assert_eq!(json, expected);
2699 }
2700
2701 #[test]
2702 fn test_not_with_one_gte_to_string() {
2703 let name1 = _random_string(10);
2704 let value1 = _random_string(10);
2705
2706 let query = Query::Not(Box::new(Query::Gte(name1.clone(), value1.clone())));
2707
2708 let json = ::serde_json::to_string(&query).unwrap();
2709
2710 let expected = format!(r#"{{"$not":{{"{}":{{"$gte":"{}"}}}}}}"#, name1, value1);
2711
2712 assert_eq!(json, expected);
2713 }
2714
2715 #[test]
2716 fn test_not_with_one_lt_to_string() {
2717 let name1 = _random_string(10);
2718 let value1 = _random_string(10);
2719
2720 let query = Query::Not(Box::new(Query::Lt(name1.clone(), value1.clone())));
2721
2722 let json = ::serde_json::to_string(&query).unwrap();
2723
2724 let expected = format!(r#"{{"$not":{{"{}":{{"$lt":"{}"}}}}}}"#, name1, value1);
2725
2726 assert_eq!(json, expected);
2727 }
2728
2729 #[test]
2730 fn test_not_with_one_lte_to_string() {
2731 let name1 = _random_string(10);
2732 let value1 = _random_string(10);
2733
2734 let query = Query::Not(Box::new(Query::Lte(name1.clone(), value1.clone())));
2735
2736 let json = ::serde_json::to_string(&query).unwrap();
2737
2738 let expected = format!(r#"{{"$not":{{"{}":{{"$lte":"{}"}}}}}}"#, name1, value1);
2739
2740 assert_eq!(json, expected);
2741 }
2742
2743 #[test]
2744 fn test_not_with_one_like_to_string() {
2745 let name1 = _random_string(10);
2746 let value1 = _random_string(10);
2747
2748 let query = Query::Not(Box::new(Query::Like(name1.clone(), value1.clone())));
2749
2750 let json = ::serde_json::to_string(&query).unwrap();
2751
2752 let expected = format!(r#"{{"$not":{{"{}":{{"$like":"{}"}}}}}}"#, name1, value1);
2753
2754 assert_eq!(json, expected);
2755 }
2756
2757 #[test]
2758 fn test_not_with_one_in_to_string() {
2759 let name1 = _random_string(10);
2760 let value1 = _random_string(10);
2761
2762 let query = Query::Not(Box::new(Query::In(name1.clone(), vec![value1.clone()])));
2763
2764 let json = ::serde_json::to_string(&query).unwrap();
2765
2766 let expected = format!(r#"{{"$not":{{"{}":{{"$in":["{}"]}}}}}}"#, name1, value1);
2767
2768 assert_eq!(json, expected);
2769 }
2770
2771 #[test]
2772 fn test_and_or_not_complex_case_to_string() {
2773 let name1 = _random_string(10);
2774 let value1 = _random_string(10);
2775 let name2 = _random_string(10);
2776 let value2 = _random_string(10);
2777 let name3 = _random_string(10);
2778 let value3 = _random_string(10);
2779 let name4 = _random_string(10);
2780 let value4 = _random_string(10);
2781 let name5 = _random_string(10);
2782 let value5 = _random_string(10);
2783 let name6 = _random_string(10);
2784 let value6 = _random_string(10);
2785 let name7 = _random_string(10);
2786 let value7 = _random_string(10);
2787 let name8 = _random_string(10);
2788 let value8 = _random_string(10);
2789
2790 let query = Query::Not(Box::new(Query::And(vec![
2791 Query::Eq(name1.clone(), value1.clone()),
2792 Query::Or(vec![
2793 Query::Gt(name2.clone(), value2.clone()),
2794 Query::Not(Box::new(Query::Lte(name3.clone(), value3.clone()))),
2795 Query::And(vec![
2796 Query::Lt(name4.clone(), value4.clone()),
2797 Query::Not(Box::new(Query::Gte(name5.clone(), value5.clone()))),
2798 ]),
2799 ]),
2800 Query::Not(Box::new(Query::Like(name6.clone(), value6.clone()))),
2801 Query::And(vec![
2802 Query::Eq(name7.clone(), value7.clone()),
2803 Query::Not(Box::new(Query::Neq(name8.clone(), value8.clone()))),
2804 ]),
2805 ])));
2806
2807 let json = ::serde_json::to_string(&query).unwrap();
2808
2809 let expected = format!(
2810 r#"{{"$not":{{"$and":[{{"{}":"{}"}},{{"$or":[{{"{}":{{"$gt":"{}"}}}},{{"$not":{{"{}":{{"$lte":"{}"}}}}}},{{"$and":[{{"{}":{{"$lt":"{}"}}}},{{"$not":{{"{}":{{"$gte":"{}"}}}}}}]}}]}},{{"$not":{{"{}":{{"$like":"{}"}}}}}},{{"$and":[{{"{}":"{}"}},{{"$not":{{"{}":{{"$neq":"{}"}}}}}}]}}]}}}}"#,
2811 name1,
2812 value1,
2813 name2,
2814 value2,
2815 name3,
2816 value3,
2817 name4,
2818 value4,
2819 name5,
2820 value5,
2821 name6,
2822 value6,
2823 name7,
2824 value7,
2825 name8,
2826 value8,
2827 );
2828
2829 assert_eq!(json, expected);
2830 }
2831
2832 #[test]
2833 fn test_old_format() {
2834 let name1 = _random_string(10);
2835 let name2 = _random_string(10);
2836 let value1 = _random_string(10);
2837 let value2 = _random_string(10);
2838
2839 let json = format!(
2840 r#"[{{"{}":"{}"}}, {{"{}":"{}"}}]"#,
2841 name1, value1, name2, value2
2842 );
2843
2844 let query: Query = ::serde_json::from_str(&json).unwrap();
2845
2846 let expected = Query::Or(vec![Query::Eq(name1, value1), Query::Eq(name2, value2)]);
2847
2848 assert_eq!(query, expected);
2849 }
2850
2851 #[test]
2852 fn test_old_format_empty() {
2853 let json = r#"[]"#;
2854
2855 let query: Query = ::serde_json::from_str(json).unwrap();
2856
2857 let expected = Query::And(vec![]);
2858
2859 assert_eq!(query, expected);
2860 }
2861
2862 #[test]
2863 fn test_old_format_with_nulls() {
2864 let name1 = _random_string(10);
2865 let name2 = _random_string(10);
2866 let value1 = _random_string(10);
2867
2868 let json = json!(vec![
2869 json!({ name1.clone(): value1 }),
2870 json!({ name2: ::serde_json::Value::Null })
2871 ])
2872 .to_string();
2873
2874 let query: Query = ::serde_json::from_str(&json).unwrap();
2875
2876 let expected = Query::Or(vec![Query::Eq(name1, value1)]);
2877
2878 assert_eq!(query, expected);
2879 }
2880
2881 #[test]
2882 fn test_optimise_and() {
2883 let json = r#"{}"#;
2884
2885 let query: Query = ::serde_json::from_str(json).unwrap();
2886
2887 assert_eq!(query.optimise(), None);
2888 }
2889
2890 #[test]
2891 fn test_optimise_or() {
2892 let json = r#"[]"#;
2893
2894 let query: Query = ::serde_json::from_str(json).unwrap();
2895
2896 assert_eq!(query.optimise(), None);
2897 }
2898
2899 #[test]
2900 fn test_optimise_single_nested_and() {
2901 let json = json!({
2902 "$and": [
2903 {
2904 "$and": []
2905 }
2906 ]
2907 })
2908 .to_string();
2909
2910 let query: Query = ::serde_json::from_str(&json).unwrap();
2911
2912 assert_eq!(query.optimise(), None);
2913 }
2914
2915 #[test]
2916 fn test_optimise_several_nested_and() {
2917 let json = json!({
2918 "$and": [
2919 {
2920 "$and": []
2921 },
2922 {
2923 "$and": []
2924 }
2925 ]
2926 })
2927 .to_string();
2928
2929 let query: Query = ::serde_json::from_str(&json).unwrap();
2930
2931 assert_eq!(query.optimise(), None);
2932 }
2933
2934 #[test]
2935 fn test_optimise_single_nested_or() {
2936 let json = json!({
2937 "$and": [
2938 {
2939 "$or": []
2940 }
2941 ]
2942 })
2943 .to_string();
2944
2945 let query: Query = ::serde_json::from_str(&json).unwrap();
2946
2947 assert_eq!(query.optimise(), None);
2948 }
2949
2950 #[test]
2951 fn test_optimise_several_nested_or() {
2952 let json = json!({
2953 "$and": [
2954 {
2955 "$or": []
2956 },
2957 {
2958 "$or": []
2959 }
2960 ]
2961 })
2962 .to_string();
2963
2964 let query: Query = ::serde_json::from_str(&json).unwrap();
2965
2966 assert_eq!(query.optimise(), None);
2967 }
2968}