add test cases for filter expressions with boolean

Author: oakmac

src/json_path/parser.clj

@@ -70,4 +70,4 @@
                  [:path pth]))))))
 
 (defn parse-path [path]
-  (parse (re-seq #"<=|>=|\.\.|[.*$@\[\]\(\)\"=<>]|\d+|[\w-\/]+|\?\(|!=|&&|true|false" path)))
+  (parse (re-seq #"<=|>=|\.\.|[.*$@\[\]\(\)\"=<>]|\d+|[\w-\/]+|\?\(|!=|&&|\|\||true|false" path)))

src/json_path/walker.clj

@@ -7,8 +7,12 @@
   (and (map? m)
        (contains? m :value)))
 
-(defn eval-bool-expr [op-form context operands]
-  (boolean (apply op-form (map #(eval-expr % context) operands))))
+;; NOTE: this function produces a runtime error when comparing things of different types
+;; ie: (< 3 "foo")
+;; Will need to coerce the types in order to get the "Filter expression with boolean or operator and value false"
+;; test case to pass
+(defn eval-bool-expr [comp-fn context operands]
+  (boolean (apply comp-fn (map #(eval-expr % context) operands))))
 
 (def boolean-ops
   "expression operands that result in a boolean result"

test/json_path/test/json_path_test.clj

@@ -1,5 +1,6 @@
 (ns json-path.test.json-path-test
-  [:use [json-path]
+  [:use
+   [json-path]
    [midje.sweet]])
 
 (unfinished)
@@ -24,9 +25,28 @@
                   {:bar "baz" :hello "world"}]}) => ["world"]
   (at-path "$.foo[?(@.id=$.id)].text"
            {:id 45, :foo [{:id 12, :text "bar"},
-                          {:id 45, :text "hello"}]}) => ["hello"]
+                                      {:id 45, :text "hello"}]}) => ["hello"]
   (at-path "$.foo[*].bar[*].baz"
-           {:foo [{:bar [{:baz "hello"}]}]}) => ["hello"])
+           {:foo [{:bar [{:baz "hello"}]}]}) => ["hello"]
+  (at-path "$[?(@.key>42 && @.key<44)]"
+           [{:key 42}, {:key 43}, {:key 44}]) => [{:key 43}]
+  (at-path "$[?(@.key>43 || @.key<43)]"
+           [{:key 42}, {:key 43}, {:key 44}]) => [{:key 42}, {:key 44}])
+
+  ;; TODO: add this case, comparator is blowing up comparing against different types
+  ;; "Filter expression with boolean or operator and value false"
+  ; (at-path "$[?(@.key>0 && false)]"
+  ;          [{:key 1}
+  ;           {:key 3}
+  ;           {:key "nice"}
+  ;           {:key true}
+  ;           {:key nil}
+  ;           {:key false}
+  ;           {:key {}}
+  ;           {:key []}
+  ;           {:key -1}
+  ;           {:key 0}
+  ;           {:key ""}]) => []
 
 (facts
   (-> (query "$.hello"
@@ -55,4 +75,10 @@
   (->> (query "$.foo[?(@.bar=\"baz\")].hello"
               {:foo [{:bar "wrong" :hello "goodbye"}
                      {:bar "baz" :hello "world"}]})
-       (map :path)) => '([:foo 1 :hello]))
+       (map :path)) => '([:foo 1 :hello])
+  (->> (query "$[?(@.key>42 && @.key<44)]"
+              [{:key 42}, {:key 43}, {:key 44}])
+       (map :value)) => [{:key 43}]
+  (->> (query "$[?(@.key>43 || @.key<43)]"
+              [{:key 42}, {:key 43}, {:key 44}])
+       (map :value)) => [{:key 42}, {:key 44}])

test/json_path/test/parser_test.clj

@@ -73,6 +73,28 @@
                                                                       [:child]
                                                                       [:key "bar"]]]
                                                               [:val 44]]]]]]
+  (parse-path "$[?(@.bar>42 && true)]") => [:path [[:root]]
+                                            [:selector [:filter
+                                                        [:and
+                                                         [:gt
+                                                          [:path [[:current]
+                                                                  [:child]
+                                                                  [:key "bar"]]]
+                                                          [:val 42]]
+                                                         [:bool [:val true]]]]]]
+  (parse-path "$[?(@.bar>42 || @.bar<44)]") => [:path [[:root]]
+                                                [:selector [:filter
+                                                            [:or
+                                                             [:gt
+                                                              [:path [[:current]
+                                                                      [:child]
+                                                                      [:key "bar"]]]
+                                                              [:val 42]]
+                                                             [:lt
+                                                              [:path [[:current]
+                                                                      [:child]
+                                                                      [:key "bar"]]]
+                                                              [:val 44]]]]]]
   (parse-path "$.foo[?(@.bar=\"baz\")].hello") => [:path [[:root] [:child] [:key "foo"]]
                                                    [:selector [:filter [:eq [:path [[:current]
                                                                                     [:child]