searchkick-hooopo 2.3.0

data/test/gemfiles/parallel_tests.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 5.0.0"
+gem "parallel_tests"

data/test/geo_shape_test.rb

@@ -0,0 +1,172 @@
+require_relative "test_helper"
+
+class GeoShapeTest < Minitest::Test
+  def setup
+    Region.destroy_all
+    store [
+      {
+        name: "Region A",
+        text: "The witch had a cat",
+        territory: {
+          type: "polygon",
+          coordinates: [[[30, 40], [35, 45], [40, 40], [40, 30], [30, 30], [30, 40]]]
+        }
+      },
+      {
+        name: "Region B",
+        text: "and a very tall hat",
+        territory: {
+          type: "polygon",
+          coordinates: [[[50, 60], [55, 65], [60, 60], [60, 50], [50, 50], [50, 60]]]
+        }
+      },
+      {
+        name: "Region C",
+        text: "and long ginger hair which she wore in a plait",
+        territory: {
+          type: "polygon",
+          coordinates: [[[10, 20], [15, 25], [20, 20], [20, 10], [10, 10], [10, 20]]]
+        }
+      }
+    ], Region
+  end
+
+  def test_circle
+    assert_search "*", ["Region A"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "circle",
+            coordinates: {lat: 28.0, lon: 38.0},
+            radius: "444000m"
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_envelope
+    assert_search "*", ["Region A"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            coordinates: [[28, 42], [32, 38]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_polygon
+    assert_search "*", ["Region A"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "polygon",
+            coordinates: [[[38, 42], [42, 42], [42, 38], [38, 38], [38, 42]]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_multipolygon
+    assert_search "*", ["Region A", "Region B"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "multipolygon",
+            coordinates: [
+              [[[38, 42], [42, 42], [42, 38], [38, 38], [38, 42]]],
+              [[[58, 62], [62, 62], [62, 58], [58, 58], [58, 62]]]
+            ]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_disjoint
+    assert_search "*", ["Region B", "Region C"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            relation: "disjoint",
+            coordinates: [[28, 42], [32, 38]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_within
+    assert_search "*", ["Region A"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            relation: "within",
+            coordinates: [[20,50], [50,20]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_search_math
+    assert_search "witch", ["Region A"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            coordinates: [[28, 42], [32, 38]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_search_no_match
+    assert_search "ginger hair", [], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            coordinates: [[28, 42], [32, 38]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_contains
+    skip if elasticsearch_below22?
+    assert_search "*", ["Region C"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            relation: "contains",
+            coordinates: [[12, 13], [13, 12]]
+          }
+        }
+      }
+    }, Region
+  end
+
+  def test_latlon
+    assert_search "*", ["Region A"], {
+      where: {
+        territory: {
+          geo_shape: {
+            type: "envelope",
+            coordinates: [{lat: 42, lon: 28}, {lat: 38, lon: 32}]
+          }
+        }
+      }
+    }, Region
+  end
+
+end

data/test/highlight_test.rb

@@ -0,0 +1,78 @@
+require_relative "test_helper"
+
+class HighlightTest < Minitest::Test
+  def test_basic
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <em>Cinema</em> Club", Product.search("cinema", fields: [:name], highlight: true).first.search_highlights[:name]
+  end
+
+  def test_tag
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <strong>Cinema</strong> Club", Product.search("cinema", fields: [:name], highlight: {tag: "<strong>"}).first.search_highlights[:name]
+  end
+
+  def test_tag_class
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <strong class='classy'>Cinema</strong> Club", Product.search("cinema", fields: [:name], highlight: {tag: "<strong class='classy'>"}).first.search_highlights[:name]
+  end
+
+  def test_multiple_fields
+    store [{name: "Two Door Cinema Club", color: "Cinema Orange"}]
+    highlights = Product.search("cinema", fields: [:name, :color], highlight: true).first.search_highlights
+    assert_equal "Two Door <em>Cinema</em> Club", highlights[:name]
+    assert_equal "<em>Cinema</em> Orange", highlights[:color]
+  end
+
+  def test_fields
+    store [{name: "Two Door Cinema Club", color: "Cinema Orange"}]
+    highlights = Product.search("cinema", fields: [:name, :color], highlight: {fields: [:name]}).first.search_highlights
+    assert_equal "Two Door <em>Cinema</em> Club", highlights[:name]
+    assert_nil highlights[:color]
+  end
+
+  def test_field_options
+    store_names ["Two Door Cinema Club are a Northern Irish indie rock band"]
+    fragment_size = ENV["MATCH"] == "word_start" ? 26 : 20
+    assert_equal "Two Door <em>Cinema</em> Club are", Product.search("cinema", fields: [:name], highlight: {fields: {name: {fragment_size: fragment_size}}}).first.search_highlights[:name]
+  end
+
+  def test_multiple_words
+    store_names ["Hello World Hello"]
+    assert_equal "<em>Hello</em> World <em>Hello</em>", Product.search("hello", fields: [:name], highlight: true).first.search_highlights[:name]
+  end
+
+  def test_encoder
+    store_names ["<b>Hello</b>"]
+    assert_equal "&lt;b&gt;<em>Hello</em>&lt;&#x2F;b&gt;", Product.search("hello", fields: [:name], highlight: {encoder: "html"}, misspellings: false).first.search_highlights[:name]
+  end
+
+  def test_word_middle
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <em>Cinema</em> Club", Product.search("ine", fields: [:name], match: :word_middle, highlight: true).first.search_highlights[:name]
+  end
+
+  def test_body
+    skip if ENV["MATCH"] == "word_start"
+    store_names ["Two Door Cinema Club"]
+    body = {
+      query: {
+        match: {
+          "name.analyzed" => "cinema"
+        }
+      },
+      highlight: {
+        pre_tags: ["<strong>"],
+        post_tags: ["</strong>"],
+        fields: {
+          "name.analyzed" => {}
+        }
+      }
+    }
+    assert_equal "Two Door <strong>Cinema</strong> Club", Product.search(body: body).first.search_highlights[:"name.analyzed"]
+  end
+
+  def test_legacy
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <em>Cinema</em> Club", Product.search("cinema", fields: [:name], highlight: true).with_details.first[1][:highlight][:name]
+  end
+end

data/test/index_test.rb

@@ -0,0 +1,153 @@
+require_relative "test_helper"
+
+class IndexTest < Minitest::Test
+  def setup
+    super
+    Region.destroy_all
+  end
+
+  def test_clean_indices
+    suffix = Searchkick.index_suffix ? "_#{Searchkick.index_suffix}" : ""
+    old_index = Searchkick::Index.new("products_test#{suffix}_20130801000000000")
+    different_index = Searchkick::Index.new("items_test#{suffix}_20130801000000000")
+
+    old_index.delete if old_index.exists?
+    different_index.delete if different_index.exists?
+
+    # create indexes
+    old_index.create
+    different_index.create
+
+    Product.searchkick_index.clean_indices
+
+    assert Product.searchkick_index.exists?
+    assert different_index.exists?
+    assert !old_index.exists?
+  end
+
+  def test_clean_indices_old_format
+    suffix = Searchkick.index_suffix ? "_#{Searchkick.index_suffix}" : ""
+    old_index = Searchkick::Index.new("products_test#{suffix}_20130801000000")
+    old_index.create
+
+    Product.searchkick_index.clean_indices
+
+    assert !old_index.exists?
+  end
+
+  def test_retain
+    Product.reindex
+    assert_equal 1, Product.searchkick_index.all_indices.size
+    Product.reindex(retain: true)
+    assert_equal 2, Product.searchkick_index.all_indices.size
+  end
+
+  def test_total_docs
+    store_names ["Product A"]
+    assert_equal 1, Product.searchkick_index.total_docs
+  end
+
+  def test_mapping
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(body: {query: {match: {name: "dollar"}}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(body: {query: {match: {name: "Dollar Tree"}}}).map(&:name)
+  end
+
+  def test_body
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(body: {query: {match: {name: "dollar"}}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(body: {query: {match: {name: "Dollar Tree"}}}, load: false).map(&:name)
+  end
+
+  def test_block
+    store_names ["Dollar Tree"]
+    products =
+      Product.search "boom" do |body|
+        body[:query] = {match_all: {}}
+      end
+    assert_equal ["Dollar Tree"], products.map(&:name)
+  end
+
+  def test_tokens
+    assert_equal ["dollar", "dollartre", "tree"], Product.searchkick_index.tokens("Dollar Tree", analyzer: "searchkick_index")
+  end
+
+  def test_tokens_analyzer
+    assert_equal ["dollar", "tree"], Product.searchkick_index.tokens("Dollar Tree", analyzer: "searchkick_search2")
+  end
+
+  def test_record_not_found
+    store_names ["Product A", "Product B"]
+    Product.where(name: "Product A").delete_all
+    assert_search "product", ["Product B"]
+  ensure
+    Product.reindex
+  end
+
+  def test_bad_mapping
+    Product.searchkick_index.delete
+    store_names ["Product A"]
+    assert_raises(Searchkick::InvalidQueryError) { Product.search "test" }
+  ensure
+    Product.reindex
+  end
+
+  def test_remove_blank_id
+    store_names ["Product A"]
+    Product.searchkick_index.remove(Product.new)
+    assert_search "product", ["Product A"]
+  ensure
+    Product.reindex
+  end
+
+  def test_missing_index
+    assert_raises(Searchkick::MissingIndexError) { Product.search("test", index_name: "not_found") }
+  end
+
+  def test_unsupported_version
+    raises_exception = ->(_) { raise Elasticsearch::Transport::Transport::Error, "[500] No query registered for [multi_match]" }
+    Searchkick.client.stub :search, raises_exception do
+      assert_raises(Searchkick::UnsupportedVersionError) { Product.search("test") }
+    end
+  end
+
+  def test_invalid_body
+    assert_raises(Searchkick::InvalidQueryError) { Product.search(body: {boom: true}) }
+  end
+
+  def test_transaction
+    skip unless defined?(ActiveRecord)
+    Product.transaction do
+      store_names ["Product A"]
+      raise ActiveRecord::Rollback
+    end
+    assert_search "*", []
+  end
+
+  def test_filterable
+    # skip for 5.0 since it throws
+    # Cannot search on field [alt_description] since it is not indexed.
+    skip unless elasticsearch_below50?
+    store [{name: "Product A", alt_description: "Hello"}]
+    assert_search "*", [], where: {alt_description: "Hello"}
+  end
+
+  def test_large_value
+    skip if nobrainer?
+    large_value = 1000.times.map { "hello" }.join(" ")
+    store [{name: "Product A", text: large_value}], Region
+    assert_search "product", ["Product A"], {}, Region
+    assert_search "hello", ["Product A"], {fields: [:name, :text]}, Region
+    assert_search "hello", ["Product A"], {}, Region
+  end
+
+  def test_very_large_value
+    skip if nobrainer? || elasticsearch_below22?
+    large_value = 10000.times.map { "hello" }.join(" ")
+    store [{name: "Product A", text: large_value}], Region
+    assert_search "product", ["Product A"], {}, Region
+    assert_search "hello", ["Product A"], {fields: [:name, :text]}, Region
+    # values that exceed ignore_above are not included in _all field :(
+    # assert_search "hello", ["Product A"], {}, Region
+  end
+end

data/test/inheritance_test.rb

@@ -0,0 +1,83 @@
+require_relative "test_helper"
+
+class InheritanceTest < Minitest::Test
+  def setup
+    skip if defined?(Cequel)
+    super
+  end
+
+  def test_child_reindex
+    store_names ["Max"], Cat
+    assert Dog.reindex
+    Animal.searchkick_index.refresh
+    assert_equal 1, Animal.search("*").size
+  end
+
+  def test_child_index_name
+    assert_equal "animals-#{Date.today.year}", Dog.searchkick_index.name
+  end
+
+  def test_child_search
+    store_names ["Bear"], Dog
+    store_names ["Bear"], Cat
+    assert_equal 1, Dog.search("bear").size
+  end
+
+  def test_parent_search
+    store_names ["Bear"], Dog
+    store_names ["Bear"], Cat
+    assert_equal 2, Animal.search("bear").size
+  end
+
+  def test_force_one_type
+    store_names ["Green Bear"], Dog
+    store_names ["Blue Bear"], Cat
+    assert_equal ["Blue Bear"], Animal.search("bear", type: [Cat]).map(&:name)
+  end
+
+  def test_force_multiple_types
+    store_names ["Green Bear"], Dog
+    store_names ["Blue Bear"], Cat
+    store_names ["Red Bear"], Animal
+    assert_equal ["Green Bear", "Blue Bear"], Animal.search("bear", type: [Dog, Cat]).map(&:name)
+  end
+
+  def test_child_autocomplete
+    store_names ["Max"], Cat
+    store_names ["Mark"], Dog
+    assert_equal ["Max"], Cat.search("ma", fields: [:name], match: :text_start).map(&:name)
+  end
+
+  def test_parent_autocomplete
+    store_names ["Max"], Cat
+    store_names ["Bear"], Dog
+    assert_equal ["Bear"], Animal.search("bea", fields: [:name], match: :text_start).map(&:name).sort
+  end
+
+  # def test_child_suggest
+  #   store_names ["Shark"], Cat
+  #   store_names ["Sharp"], Dog
+  #   assert_equal ["shark"], Cat.search("shar", fields: [:name], suggest: true).suggestions
+  # end
+
+  def test_parent_suggest
+    store_names ["Shark"], Cat
+    store_names ["Tiger"], Dog
+    assert_equal ["tiger"], Animal.search("tige", fields: [:name], suggest: true).suggestions.sort
+  end
+
+  def test_reindex
+    store_names ["Bear A"], Cat
+    store_names ["Bear B"], Dog
+    Animal.reindex
+    assert_equal 1, Dog.search("bear").size
+  end
+
+  # TODO move somewhere better
+
+  def test_multiple_indices
+    store_names ["Product A"]
+    store_names ["Product B"], Animal
+    assert_search "product", ["Product A", "Product B"], index_name: [Product.searchkick_index.name, Animal.searchkick_index.name], conversions: false
+  end
+end

data/test/marshal_test.rb

@@ -0,0 +1,8 @@
+require_relative "test_helper"
+
+class MarshalTest < Minitest::Test
+  def test_marshal
+    store_names ["Product A"]
+    assert Marshal.dump(Product.search("*", load: {dumpable: true}).results)
+  end
+end