test(core): Add core integration tests

crates/core/src/lexer.rs

@@ -196,23 +196,23 @@ mod tests {
 
     #[test]
     #[should_panic]
-    fn pos_integer_fails_when_bigger_than_u64() {
+    fn pos_integer_fails_when_bigger_than_u64_max() {
         let input = "18446744073709551616"; // u64::MAX + 1
         get_next_token(&input);
     }
 
     #[rstest]
     #[case::neg_integer("-5", -5)]
     #[case::zero("-0", 0)]
-    #[case::neg_integer_max("-9223372036854775808", i64::MIN)]
+    #[case::i64_min("-9223372036854775808", i64::MIN)]
     fn neg_integer_parses(#[case] input: &str, #[case] expected: i64) {
         let expected = Token::NegInteger(expected);
         assert_next_token(input, expected);
     }
 
     #[test]
     #[should_panic]
-    fn neg_integer_fails_when_smaller_than_i64() {
+    fn neg_integer_fails_when_smaller_than_i64_min() {
         let input = "-9223372036854775809"; // i64::MIN - 1
         get_next_token(&input);
     }
@@ -261,4 +261,17 @@ mod tests {
         let input = r#"'Java Script'"#;
         get_next_token(input);
     }
+
+    #[test]
+    fn unknown_character_error() {
+        let input = "$";
+
+        let mut lexer = Token::lexer(input);
+        let token = lexer.next().expect("There should be at least one token");
+
+        assert!(matches!(token, Err(Error::UnknownCharacter)));
+    }
+
+    // TODO: Add more tests for various consecutive tokens. For example,
+    // Two consecutive strings, two consecutive floats, etc.
 }

crates/core/src/parser.rs

@@ -438,3 +438,31 @@ impl FromStr for Query {
         Parser::new(s).parse()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    // TODO: add more parser tests
+
+    #[test]
+    #[should_panic]
+    fn same_alias() {
+        r#"{
+            id: alias
+            models: alias
+        }"#
+        .parse::<Query>()
+        .unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn alias_collides_with_existent_field() {
+        r#"{
+            id: models
+            models
+        }"#
+        .parse::<Query>()
+        .unwrap();
+    }
+}

crates/core/src/query/query_arguments.rs

@@ -9,7 +9,7 @@ use super::{
     QueryKey,
 };
 use derive_getters::Getters;
-use derive_more::{Constructor, Display};
+use derive_more::Constructor;
 use regex::Regex;
 use serde_json::Value;
 use thiserror::Error;
@@ -466,14 +466,16 @@ impl QueryArguments {
 }
 
 impl<'a> QueryArgument {
+    // TODO: Maybe we should return false and not default to NULL.
     const DEFAULT_INSPECTED_VALUE: Cow<'static, Value> = Cow::Owned(Value::Null);
 
     fn satisfies(&'a self, value: &Value, context: &Context<'a>) -> Result<bool, Error<'a>> {
         let argument_key = self.key();
 
         let inspected_value = match argument_key.inspect(value, context) {
             Ok(value) => value,
-            // TODO: only return null value for the KeyNotFound error?
+            // TODO: only return null value for the KeyNotFound error?  Check the test with this TODO at the not_equal.rs test
+
             // TODO: the query inspection should not use InternalError, it is too generic
             Err(error @ InternalError::KeyNotFound(_)) => {
                 log::info!("{error}, using null value");

crates/core/tests/array_filtering/equal.rs

@@ -0,0 +1,199 @@
+use gq_core::query::Query;
+use rstest::rstest;
+use serde_json::{json, Value};
+
+use crate::fixtures::{ai_models, products, programming_languages};
+
+#[rstest]
+fn string_argument_value(programming_languages: Value) {
+    let query: Query = r#"languages(name = "JavaScript")"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "JavaScript",
+            "popular": true,
+            "year": 1995
+        }
+    ]);
+
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn integer_argument_value(programming_languages: Value) {
+    let query: Query = r#"languages(year = 1995)"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "JavaScript",
+            "popular": true,
+            "year": 1995
+        },
+        {
+            "name": "Java",
+            "popular": false,
+            "year": 1995
+        }
+    ]);
+
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn float_argument_value(products: Value) {
+    let query: Query = r#"products(price = 14.95)"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "Product 2",
+            "quantity": 5,
+            "price": 14.95
+        }
+    ]);
+
+    let result = query.apply(products).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn boolean_argument_value(programming_languages: Value) {
+    let query: Query = r#"languages(popular = true)"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "JavaScript",
+            "popular": true,
+            "year": 1995
+        },
+        {
+            "name": "Rust",
+            "popular": true,
+            "year": 2010
+        }
+    ]);
+
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn null_argument_value(ai_models: Value) {
+    let query: Query = r#"models(score = null)"#.parse().unwrap();
+    let expected = json!([
+        {
+          "name": "Claude",
+          "openSource": false,
+          "score": null
+        }
+    ]);
+
+    let result = query.apply(ai_models).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn float_argument_value_with_null_field_value(ai_models: Value) {
+    let query: Query = r#"models(score = 88.7)"#.parse().unwrap();
+    let expected = json!([
+        {
+          "name": "LLAMA",
+          "openSource": true,
+          "score": 88.7,
+          "tags": ["Text Generation", "Open Source"]
+        }
+    ]);
+
+    let result = query.apply(ai_models).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn array_field_value_includes_argument_value(ai_models: Value) {
+    let query: Query = r#"models(tags = "Text Generation")"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "GPT-4O",
+            "openSource": false,
+            "score": 71.49,
+            "tags": ["NLP", "Text Generation"]
+        },
+        {
+          "name": "LLAMA",
+          "openSource": true,
+          "score": 88.7,
+          "tags": ["Text Generation", "Open Source"]
+        }
+    ]);
+
+    let result = query.apply(ai_models).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn array_field_value_includes_multiple_argument_value(ai_models: Value) {
+    let query: Query = r#"models(tags = "NLP", tags = "Text Generation")"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "GPT-4O",
+            "openSource": false,
+            "score": 71.49,
+            "tags": ["NLP", "Text Generation"]
+        },
+    ]);
+
+    let result = query.apply(ai_models).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn multiple_arguments(programming_languages: Value) {
+    let query: Query = r#"languages(popular = true, year = 1995)"#.parse().unwrap();
+    let expected = json!([
+        {
+            "name": "JavaScript",
+            "popular": true,
+            "year": 1995
+        }
+    ]);
+
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+#[rstest]
+fn value_not_found(programming_languages: Value) {
+    let query: Query = r#"languages(name = "value_not_found")"#.parse().unwrap();
+    let expected = json!([]);
+
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+// TODO: Assert that a warning is logged
+#[rstest]
+fn missing_field(programming_languages: Value) {
+    let query: Query = r#"languages(missing_field = 5)"#.parse().unwrap();
+    let expected = json!([]);
+
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}
+
+// TODO: assert that a warning is logged
+#[rstest]
+fn incomparable_types_error(programming_languages: Value) {
+    let query: Query = r#"languages(name = 1995)"#.parse().unwrap();
+    let expected = json!([]);
+    let result = query.apply(programming_languages).unwrap();
+
+    assert_eq!(result, expected);
+}