elasticquery 0.1.2 → 0.1.3

data/lib/elasticquery/version.rb

@@ -1,4 +1,4 @@
 module Elasticquery
   # Current gem version
-  VERSION = "0.1.2"
+  VERSION = "0.1.3".freeze
 end

data/test/base_test.rb

@@ -21,7 +21,7 @@ class TestBase < MiniTest::Test
 
   def test_filters_is_empty_by_default
     query = Elasticquery::Base.new
-    assert_empty query.filters
+    assert_empty query.rules
   end
 
   def test_extract_params
@@ -34,20 +34,20 @@ class TestBase < MiniTest::Test
   end
 
   def test_filters_proc
-    assert_equal 2, @query.filters.first.call
+    assert_equal 2, @query.rules.first.call
   end
 
   def test_should_have_term_rule_included
     assert_respond_to @query, :term
   end
 
-  def test_filters_as_array
+  def test_rules_as_array
     klass = Class.new(Elasticquery::Base)
     klass.filtered { 1 + 1 }
     klass.filtered { 2 + 2 }
 
     query = klass.new
-    assert_equal 2, query.filters.count
+    assert_equal 2, query.rules.count
   end
 
   def test_should_execute_code_in_instance_context

data/test/builder_test.rb

@@ -18,24 +18,40 @@ class TestAllBaseQueries < MiniTest::Test
     assert_respond_to self, :term
   end
 
+  def test_have_terms
+    assert_respond_to self, :terms
+  end
+
   def test_have_search
     assert_respond_to self, :search
   end
 
-  def test_defined_instances_return_sel
-    assert_equal self, term
+  def test_have_multi_match
+    assert_respond_to self, :multi_match
   end
 
-  def test_push_hash_term_to_query
-    term a: 1
-    search b: 2
-    term c: 3
-    assert_equal 3, query.size
+  def test_have_range
+    assert_respond_to self, :range
+  end
+
+  def test_have_range
+    assert_respond_to self, :exists
+  end
+
+  def test_have_range
+    assert_respond_to self, :with
+  end
+
+  def test_defined_instances_return_self
+    @query.expect :push_filter, true, [Elasticquery::Filters::Term]
+
+    assert_equal self, filters { term(a: 1) }
+    assert @query.verify
   end
 
   private
 
   def clear_query
-    @query = []
+    @query = MiniTest::Mock.new
   end
 end

data/test/es_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'elasticsearch/model'
+require 'elasticquery/es'
+
+class Searchable
+  include Elasticsearch::Model
+end
+
+class NotSearchable
+end
+
+class TestEs < MiniTest::Test
+  def setup
+    Searchable.extend Elasticquery::Es
+    @model = Searchable
+  end
+
+  def test_raise_error_for_not_searchable_class
+    assert_raises Elasticquery::EsNotSupported do
+      NotSearchable.extend Elasticquery::Es
+    end
+  end
+end

data/test/filters/exists_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+require "elasticquery/filters/exists"
+
+class TestExistsFilter < MiniTest::Test
+
+  def test_valid_filter_has_present_field_name
+    filter = Elasticquery::Filters::Exists.new "user"
+    assert filter.valid?
+  end
+
+  def test_invalid_filter_has_blank_field_name
+    filter = Elasticquery::Filters::Exists.new ""
+    refute filter.valid?
+  end
+
+  def test_invalid_filter_has_no_field
+    filter = Elasticquery::Filters::Exists.new
+    refute filter.valid?
+  end
+
+  def test_to_hash_returns_elastic_rule
+    filter = Elasticquery::Filters::Exists.new "user"
+    assert_equal filter.to_hash, {exists: {field: "user"}}
+  end
+
+  def test_to_not_hash_returns_missing
+    filter = Elasticquery::Filters::Exists.new "user"
+    assert_equal filter.to_not_hash, {missing: {field: "user"}}
+  end
+end

data/test/filters/not_test.rb

@@ -17,37 +17,50 @@ class NotFilter < MiniTest::Test
     assert_instance_of Proc, @filter.to_hash
   end
 
+  def test_valid_return_proc
+    assert_instance_of Proc, @filter.valid?
+  end
+
+  def test_valid_proxy_to_previous_filter
+    filter_class = MiniTest::Mock.new
+    filter_class.expect :valid?, true
+    previous_filter = MiniTest::Mock.new
+    previous_filter.expect :dup_with, filter_class, [{a: 1}]
+
+    @filters = [previous_filter, "current-not-filter"]
+    assert instance_exec &@filter.valid?
+
+    assert filter_class.verify
+    assert previous_filter.verify
+  end
+
   def test_to_hash_change_last_term_filter_value
     filter_class = MiniTest::Mock.new
     filter_class.expect :valid?, true
-    expected = {query: {filtered: {filter: {and: [{term: {a: 1, b: 2}}]}}}}
-    filter_class.expect :to_hash, expected
+    expected = {not: {filter: {term: {a: 1, b: 2}}}}
+    filter_class.expect :to_not_hash, expected
     previous_filter = MiniTest::Mock.new
     previous_filter.expect :dup_with, filter_class, [{a: 1}]
 
-    @filters = [previous_filter]
+    @filters = [previous_filter, "current-not-filter"]
     result = instance_exec &@filter.to_hash
-    expected = {query: {filtered: {filter: {and: [{not: {filter: {term: {a: 1, b: 2}}}}]}}}}
     assert_equal result, expected
 
-    assert filter_class.verify
     assert previous_filter.verify
   end
 
   def test_to_hash_change_last_range_filter_value
     filter_class = MiniTest::Mock.new
     filter_class.expect :valid?, true
-    expected = {query: {filtered: {filter: {and: [{range: {a: {lte: 1}}}]}}}}
-    filter_class.expect :to_hash, expected
+    expected = {not: {filter: {range: {a: {lte: 1}}}}}
+    filter_class.expect :to_not_hash, expected
     previous_filter = MiniTest::Mock.new
     previous_filter.expect :dup_with, filter_class, [{a: 1}]
 
-    @filters = [previous_filter]
+    @filters = [previous_filter, "current-not-filter"]
     result = instance_exec &@filter.to_hash
-    expected = {query: {filtered: {filter: {and: [{not: {filter: {range: {a: {lte: 1}}}}}]}}}}
     assert_equal result, expected
 
-    assert filter_class.verify
     assert previous_filter.verify
   end
 

data/test/filters/range_test.rb

@@ -29,33 +29,27 @@ class RangeFilter < MiniTest::Test
 
   def test_to_hash_should_return_query
     filter = Elasticquery::Filters::Range.new :year, lte: 1, gte: 0
-    assert_equal({query: {filtered: {filter: {and: [{range: {year: {lte: 1, gte: 0}}}]}}}}, filter.to_hash)
+    assert_equal({range: {year: {lte: 1, gte: 0}}}, filter.to_hash)
   end
 
   def test_to_hash_with_one_param
     filter = Elasticquery::Filters::Range.new :year, lte: 1
-    assert_equal({query: {filtered: {filter: {and: [{range: {year: {lte: 1}}}]}}}}, filter.to_hash)
+    assert_equal({range: {year: {lte: 1}}}, filter.to_hash)
   end
 
   def test_to_hash_support_cache_option
     filter = Elasticquery::Filters::Range.new :year, lte: 1, _cache: true
-    assert_equal({query: {filtered: {filter: {and: [{range: {year: {_cache: true, lte: 1}}}]}}}}, filter.to_hash)
+    assert_equal({range: {year: {_cache: true, lte: 1}}}, filter.to_hash)
   end
 
   def test_to_hash_support_execution_option
     filter = Elasticquery::Filters::Range.new :year, lte: 1, gte: 0, execution: "fielddata"
-    assert_equal({query: {filtered: {filter: {and: [{range: {year: {lte: 1, gte: 0, execution: "fielddata"}}}]}}}}, filter.to_hash)
+    assert_equal({range: {year: {lte: 1, gte: 0, execution: "fielddata"}}}, filter.to_hash)
   end
 
   def test_to_hash_skip_unnesessary_options
     filter = Elasticquery::Filters::Range.new :year, lte: 1, _cache: true, extra: false
-    assert_equal({query: {filtered: {filter: {and: [{range: {year: { _cache: true, lte: 1}}}]}}}}, filter.to_hash)
-  end
-
-  def test_to_hash_is_empty_if_invalid
-    filter = Elasticquery::Filters::Range.new "year"
-    refute filter.valid?
-    assert_equal filter.to_hash, {}
+    assert_equal({range: {year: { _cache: true, lte: 1}}}, filter.to_hash)
   end
 
   def test_dup_with_return_new_range_filter
@@ -63,4 +57,9 @@ class RangeFilter < MiniTest::Test
     new_filter = filter.dup_with "month", gte: 12
     assert_kind_of Elasticquery::Filters::Range, new_filter
   end
+
+  def test_not_hash_to_returns_terms_not
+    filter = Elasticquery::Filters::Range.new :year, lte: 1
+    assert_equal({not: {filter: {range: {year: {lte: 1}}}}}, filter.to_not_hash)
+  end
 end

data/test/filters/term_test.rb

@@ -1,7 +1,7 @@
 require "test_helper"
 require "elasticquery/filters/term"
 
-class TestTermfilter < MiniTest::Test
+class TestTermFilter < MiniTest::Test
 
   def test_valid_filter_should_have_one_key
     filter = Elasticquery::Filters::Term.new a: 1
@@ -30,18 +30,17 @@ class TestTermfilter < MiniTest::Test
 
   def test_to_hash_should_pass__cache_options
     filter = Elasticquery::Filters::Term.new a: 1, _cache: true
-    assert_equal({query: {filtered: {filter: {and: [{term: {a: 1, _cache: true}}]}}}}, filter.to_hash)
+    assert_equal({term: {a: 1, _cache: true}}, filter.to_hash)
   end
 
   def test_to_hash_should_return_es_query
     filter = Elasticquery::Filters::Term.new a: 1
-    assert_equal({query: {filtered: {filter: {and: [{term: {a: 1}}]}}}}, filter.to_hash)
+    assert_equal({term: {a: 1}}, filter.to_hash)
   end
 
-  def test_to_hash_is_empty_if_invalid
-    filter = Elasticquery::Filters::Term.new
-    refute filter.valid?
-    assert_equal filter.to_hash, {}
+  def test_not_to_hash_should_return_terms_not_query
+    filter = Elasticquery::Filters::Term.new a: 1
+    assert_equal({not: {filter: {term: {a: 1}}}}, filter.to_not_hash)
   end
 
   def test_dup_with_return_new_term_filter

data/test/filters/terms_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+require "elasticquery/filters/terms"
+
+class TestTermsFilter < MiniTest::Test
+
+  def test_valid_filter_should_have_one_key
+    filter = Elasticquery::Filters::Terms.new a: 1
+    assert filter.valid?
+  end
+
+  def test_invalid_filter_should_have_no_keys
+    filter = Elasticquery::Filters::Terms.new
+    refute filter.valid?
+  end
+
+  def test_valid_filter_should_have_2_and_more_keys
+    filter = Elasticquery::Filters::Terms.new a: 1, b: 2
+    assert filter.valid?
+  end
+
+  def test_valid_filter_could_have_cache_option
+    filter = Elasticquery::Filters::Terms.new a: 1, _cache: false
+    assert filter.valid?
+  end
+
+  def test_invalid_with_all_blank_values
+    filter = Elasticquery::Filters::Terms.new a: "", b: nil
+    refute filter.valid?
+  end
+
+  def test_valid_filter_could_have_execution_option
+    filter = Elasticquery::Filters::Terms.new a: [1,2], b: 2, execution: "or"
+    assert filter.valid?
+  end
+
+  def test_to_hash_should_pass_all_valid_conditions
+    filter = Elasticquery::Filters::Terms.new a: 42, b: "42"
+    assert_equal({terms: {a: 42, b: "42"}}, filter.to_hash)
+  end
+
+  def test_to_not_hash_should_returns_terms_not_condition
+    filter = Elasticquery::Filters::Terms.new a: 42, b: "42"
+    assert_equal({not: {filter: {terms: {a: 42, b: "42"}}}}, filter.to_not_hash)
+  end
+
+  def test_to_hash_should_skip_blank_values
+    filter = Elasticquery::Filters::Terms.new a: 42, b: "", execution: "bool"
+    assert_equal({terms: {a: 42, execution: "bool"}}, filter.to_hash)
+  end
+end

data/test/integration/chainable_call_test.rb

@@ -8,23 +8,23 @@ class TestChainableCalls < MiniTest::Test
   end
 
   def test_sign_call_return_itself
-    assert_kind_of Elasticquery::Base, @query.term(a: 1)
+    assert_kind_of Elasticquery::Base, @query.filters.term(a: 1)
   end
 
   def test_apply_query
-    query = @query.term(a: 1).term(b: 3)
+    query = @query.filters.term(a: 1).term(b: 3)
     assert_equal query.build, query: {filtered: {filter: {and: [{term: {a: 1}}, {term: {b: 3}}]}}}
   end
 
   def test_with_not_filter
-    query = @query.search("hi").term.not(a: 1, _cache: true)
-    assert_equal query.build, {query: {filtered: {query: {multi_match: {fields: "_all", operator: "and", type: "best_fields", query: "hi"}}, filter: {and: [{not: {filter: {term: {a: 1, _cache: true}}}}]}}}}
+    query = @query.queries.search("hi").filters.term.not(a: 1, _cache: true)
+    assert_equal query.build, {query: {filtered: {query: {bool: {must: [{multi_match: {fields: "_all", operator: "and", type: "best_fields", query: "hi"}}]}}, filter: {and: [{not: {filter: {term: {a: 1, _cache: true}}}}]}}}}
   end
 
   def test_apply_kinds_of_query
-    query = @query.term(a: 1).search("hello", operator: "or").build
+    query = @query.filters.term(a: 1).queries.search("hello", operator: "or").build
     terms = query[:query][:filtered][:filter][:and]
-    search = query[:query][:filtered][:query][:multi_match]
+    search = query[:query][:filtered][:query][:bool][:must][0][:multi_match]
     assert_equal terms, [{term: {a: 1}}]
     assert_equal search, {fields: "_all", operator: "or", type: "best_fields", query: "hello"}
   end

data/test/integration/exists_case_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+require "elasticquery"
+
+class TestExistsCase < MiniTest::Test
+  class UserQuery < Elasticquery::Base
+    filtered do |params|
+      queries do
+        search params[:query]
+      end
+      filters do
+        exists params[:required]
+        with.not params[:missing]
+      end
+    end
+  end
+
+  class SimpleUserQuery < Elasticquery::Base
+    filtered do |params|
+      filters do
+        without params[:missing]
+        missing params[:another_missing]
+      end
+    end
+  end
+
+  def test_simple_setup
+    params = {query: "Mark", required: "name"}
+    actual = UserQuery.new(params).build
+
+    expected_queries = [{multi_match: {fields: "_all", operator: "and", type: "best_fields", query: "Mark"}}]
+    expected_filters = [{exists: {field: "name"}}]
+    assert_equal expected_queries, actual[:query][:filtered][:query][:bool][:must]
+    assert_equal expected_filters, actual[:query][:filtered][:filter][:and]
+  end
+
+  def test_exists_not_use_missing
+    params = {query: "Mark", missing: "deleted_at"}
+    actual = UserQuery.new(params).build
+    expected_filters = [{missing: {field: "deleted_at"}}]
+    assert_equal expected_filters, actual[:query][:filtered][:filter][:and]
+  end
+
+  def test_without_support
+    params = {missing: "deleted_at"}
+    actual = SimpleUserQuery.new(params).build
+    expected_filters = [{missing: {field: "deleted_at"}}]
+    assert_equal expected_filters, actual[:query][:filtered][:filter][:and]
+  end
+
+  def test_missing_support
+    params = {another_missing: "deleted_at"}
+    actual = SimpleUserQuery.new(params).build
+    expected_filters = [{missing: {field: "deleted_at"}}]
+    assert_equal expected_filters, actual[:query][:filtered][:filter][:and]
+  end
+end

data/test/integration/not_case_test.rb

@@ -4,20 +4,26 @@ require "elasticquery"
 class TestNotCase < MiniTest::Test
   class PostQuery < Elasticquery::Base
     filtered do |param|
-      term.not id: params[:id]
+      filters do
+        term.not id: params[:id]
+      end
     end
   end
 
   class PostRangeQuery < Elasticquery::Base
     filtered do |param|
-      term published: true
-      range.not :age, lte: params[:year]
+      filters do
+        term published: true
+        range.not :age, lte: params[:year], _cache: false
+      end
     end
   end
 
   class InvalidQuery < Elasticquery::Base
     filtered do |param|
-      term.not
+      filters do
+        term.not
+      end
     end
   end
 
@@ -36,7 +42,7 @@ class TestNotCase < MiniTest::Test
   def test_range_case
     params = {year: 2015}
     actual = PostRangeQuery.new(params).build
-    expected = [{term: {published: true}}, {not: {filter: {range: {age: {lte: 2015}}}}}]
+    expected = [{term: {published: true}}, {not: {filter: {range: {age: {lte: 2015, _cache: false}}}}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
 end