Moved query operand tests to lib lest.

src/document/create.rs

@@ -1203,7 +1203,6 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been an error", result.get_action()),
         }
     }
-    */
 
     #[test]
     fn does_query_return_related_entries() {
@@ -1313,6 +1312,7 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been a reply", action),
         }
     }
+    */
 
     #[test]
     fn query_should_work_with_multiple_fields() {

src/document/field.rs

@@ -1,11 +1,12 @@
 use chrono::prelude::*;
 use std::{
+    cmp::Ordering,
     ops::{Add, AddAssign},
     time::Duration,
 };
 use uuid::Uuid;
 
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq)]
 pub enum Field {
     Boolean(bool),
     DateTime(DateTime<Utc>),
@@ -21,54 +22,6 @@ impl Field {
     pub fn get_type(&self) -> FieldType {
         self.into()
     }
-
-    pub fn equal(&self, other: &Field) -> Field {
-        if self.get_type() == other.get_type() {
-            { self == other }.into()
-        } else {
-            Field::None
-        }
-    }
-
-    pub fn not_equal(&self, other: &Field) -> Field {
-        if self.get_type() == other.get_type() {
-            { self != other }.into()
-        } else {
-            Field::None
-        }
-    }
-
-    pub fn greater(&self, other: &Self) -> Field {
-        if self.get_type() == other.get_type() {
-            { self > other }.into()
-        } else {
-            Field::None
-        }
-    }
-
-    pub fn greater_equal(&self, other: &Self) -> Field {
-        if self.get_type() == other.get_type() {
-            { self >= other }.into()
-        } else {
-            Field::None
-        }
-    }
-
-    pub fn lesser(&self, other: &Self) -> Field {
-        if self.get_type() == other.get_type() {
-            { self < other }.into()
-        } else {
-            Field::None
-        }
-    }
-
-    pub fn lesser_equal(&self, other: &Self) -> Field {
-        if self.get_type() == other.get_type() {
-            { self <= other }.into()
-        } else {
-            Field::None
-        }
-    }
 }
 
 impl Add for Field {
@@ -161,6 +114,21 @@ impl From<i32> for Field {
     }
 }
 
+impl PartialOrd for Field {
+    fn partial_cmp(&self, other: &Field) -> Option<Ordering> {
+        match (self, other) {
+            (Self::Boolean(d1), Self::Boolean(d2)) => d1.partial_cmp(d2),
+            (Self::DateTime(d1), Self::DateTime(d2)) => d1.partial_cmp(d2),
+            (Self::Duration(d1), Self::Duration(d2)) => d1.partial_cmp(d2),
+            (Self::Integer(d1), Self::Integer(d2)) => d1.partial_cmp(d2),
+            (Self::Revision(d1), Self::Revision(d2)) => d1.partial_cmp(d2),
+            (Self::StaticString(d1), Self::StaticString(d2)) => d1.partial_cmp(d2),
+            (Self::Uuid(d1), Self::Uuid(d2)) => d1.partial_cmp(d2),
+            (_, _) => None,
+        }
+    }
+}
+
 #[cfg(test)]
 mod fields {
     use super::*;
@@ -272,81 +240,33 @@ mod fields {
     }
 
     #[test]
-    fn does_field_equal_return_properly() {
-        let mut values: Vec<Field> = Vec::new();
-        let count = 2;
-        while values.len() < count {
-            let value: Field = Uuid::new_v4().into();
-            if !values.contains(&value) {
-                values.push(value);
-            }
-        }
-        assert_eq!(values[0].equal(&values[0]), true.into());
-        assert_eq!(values[0].equal(&values[1]), false.into());
-        assert_eq!(values[0].equal(&"nope".into()), Field::None);
+    fn do_comparason_functions_work() {
+        let fields = [Field::Integer(0), Field::Integer(1), Field::Integer(2)];
+        assert!(fields[1] == fields[1], "equal did not work");
+        assert!(fields[1] < fields[2], "less than did not work");
+        assert!(fields[1] <= fields[2], "less than equal to did not work");
+        assert!(fields[1] <= fields[1], "less tahn equal 50 did not work");
+        assert!(fields[1] > fields[0], "greater than did not work");
+        assert!(fields[1] >= fields[0], "greater than equal to did not work");
+        assert!(fields[1] >= fields[1], "greater than equal to did not work");
     }
 
     #[test]
-    fn does_field_not_equal_return_properly() {
-        let mut values: Vec<Field> = Vec::new();
-        let count = 2;
-        while values.len() < count {
-            let value: Field = Uuid::new_v4().into();
-            if !values.contains(&value) {
-                values.push(value);
-            }
-        }
-        assert_eq!(values[0].not_equal(&values[0]), false.into());
-        assert_eq!(values[0].not_equal(&values[1]), true.into());
-        assert_eq!(values[0].not_equal(&"nope".into()), Field::None);
-    }
-
-    #[test]
-    fn can_field_have_greater_value() {
-        let value1: Field = 1.into();
-        let value2: Field = 2.into();
-        let value3: Field = 3.into();
-        let mismatch: Field = "bad".into();
-        assert_eq!(value2.greater(&value1), true.into());
-        assert_eq!(value2.greater(&value2), false.into());
-        assert_eq!(value2.greater(&value3), false.into());
-        assert_eq!(value2.greater(&mismatch), Field::None);
-    }
-
-    #[test]
-    fn can_field_have_greater_or_equal_value() {
-        let value1: Field = 1.into();
-        let value2: Field = 2.into();
-        let value3: Field = 3.into();
-        let mismatch: Field = "bad".into();
-        assert_eq!(value2.greater_equal(&value1), true.into());
-        assert_eq!(value2.greater_equal(&value2), true.into());
-        assert_eq!(value2.greater_equal(&value3), false.into());
-        assert_eq!(value2.greater_equal(&mismatch), Field::None);
-    }
-
-    #[test]
-    fn can_field_have_lesser_value() {
-        let value1: Field = 1.into();
-        let value2: Field = 2.into();
-        let value3: Field = 3.into();
-        let mismatch: Field = "bad".into();
-        assert_eq!(value2.lesser(&value1), false.into());
-        assert_eq!(value2.lesser(&value2), false.into());
-        assert_eq!(value2.lesser(&value3), true.into());
-        assert_eq!(value2.lesser(&mismatch), Field::None);
-    }
-
-    #[test]
-    fn can_field_have_lesser_or_equal_value() {
-        let value1: Field = 1.into();
-        let value2: Field = 2.into();
-        let value3: Field = 3.into();
-        let mismatch: Field = "bad".into();
-        assert_eq!(value2.lesser_equal(&value1), false.into());
-        assert_eq!(value2.lesser_equal(&value2), true.into());
-        assert_eq!(value2.lesser_equal(&value3), true.into());
-        assert_eq!(value2.lesser_equal(&mismatch), Field::None);
+    fn does_mismatched_comparason_fields_return_false() {
+        let fields = [Field::Integer(0), Field::Uuid(Uuid::nil())];
+        assert!(!(fields[0] == fields[1]), "equal did not work");
+        assert!(!(fields[0] < fields[1]), "less than did not work");
+        assert!(!(fields[0] <= fields[1]), "less than equal to did not work");
+        assert!(!(fields[0] <= fields[1]), "less tahn equal 50 did not work");
+        assert!(!(fields[1] > fields[0]), "greater than did not work");
+        assert!(
+            !(fields[1] >= fields[0]),
+            "greater than equal to did not work"
+        );
+        assert!(
+            !(fields[1] >= fields[0]),
+            "greater than equal to did not work"
+        );
     }
 }