searchkick-sinneduy 0.9.0

data/test/facets_test.rb

@@ -0,0 +1,91 @@
+require_relative "test_helper"
+require "active_support/core_ext"
+
+class TestFacets < Minitest::Test
+
+  def setup
+    super
+    store [
+      {name: "Product Show", latitude: 37.7833, longitude: 12.4167, store_id: 1, in_stock: true, color: "blue", price: 21, created_at: 2.days.ago},
+      {name: "Product Hide", latitude: 29.4167, longitude: -98.5000, store_id: 2, in_stock: false, color: "green", price: 25, created_at: 2.days.from_now},
+      {name: "Product B", latitude: 43.9333, longitude: -122.4667, store_id: 2, in_stock: false, color: "red", price: 5},
+      {name: "Foo", latitude: 43.9333, longitude: 12.4667, store_id: 3, in_stock: false, color: "yellow", price: 15}
+    ]
+  end
+
+  def test_basic
+    assert_equal ({1 => 1, 2 => 2}), store_facet(facets: [:store_id])
+  end
+
+  def test_where
+    assert_equal ({1 => 1}), store_facet(facets: {store_id: {where: {in_stock: true}}})
+  end
+
+  def test_field
+    assert_equal ({1 => 1, 2 => 2}), store_facet(facets: {store_id: {}})
+    assert_equal ({1 => 1, 2 => 2}), store_facet(facets: {store_id: {field: "store_id"}})
+    assert_equal ({1 => 1, 2 => 2}), store_facet({facets: {store_id_new: {field: "store_id"}}}, "store_id_new")
+  end
+
+  def test_limit
+    facet = Product.search("Product", facets: {store_id: {limit: 1}}).facets["store_id"]
+    assert_equal 1, facet["terms"].size
+    assert_equal 3, facet["total"]
+    assert_equal 1, facet["other"]
+  end
+
+  def test_ranges
+    price_ranges = [{to: 10}, {from: 10, to: 20}, {from: 20}]
+    facet = Product.search("Product", facets: {price: {ranges: price_ranges}}).facets["price"]
+
+    assert_equal 3, facet["ranges"].size
+    assert_equal 10.0, facet["ranges"][0]["to"]
+    assert_equal 20.0, facet["ranges"][2]["from"]
+    assert_equal 1, facet["ranges"][0]["count"]
+    assert_equal 0, facet["ranges"][1]["count"]
+    assert_equal 2, facet["ranges"][2]["count"]
+  end
+
+  def test_ranges_dates
+    ranges = [{to: 1.day.ago}, {from: 1.day.ago, to: 1.day.from_now}, {from: 1.day.from_now}]
+    facet = Product.search("Product", facets: {created_at: {ranges: ranges}}).facets["created_at"]
+
+    assert_equal 1, facet["ranges"][0]["count"]
+    assert_equal 1, facet["ranges"][1]["count"]
+    assert_equal 1, facet["ranges"][2]["count"]
+  end
+
+  def test_where_no_smart_facets
+    assert_equal ({2 => 2}), store_facet(where: {color: "red"}, facets: {store_id: {where: {in_stock: false}}})
+  end
+
+  def test_smart_facets
+    assert_equal ({1 => 1}), store_facet(where: {in_stock: true}, facets: [:store_id], smart_facets: true)
+  end
+
+  def test_smart_facets_where
+    assert_equal ({2 => 1}), store_facet(where: {color: "red"}, facets: {store_id: {where: {in_stock: false}}}, smart_facets: true)
+  end
+
+  def test_smart_facets_skip_facet
+    assert_equal ({1 => 1, 2 => 2}), store_facet(where: {store_id: 2}, facets: [:store_id], smart_facets: true)
+  end
+
+  def test_smart_facets_skip_facet_complex
+    assert_equal ({1 => 1, 2 => 1}), store_facet(where: {store_id: 2, price: {gt: 5}}, facets: [:store_id], smart_facets: true)
+  end
+
+  def test_stats_facets
+    options = {where: {store_id: 2}, facets: {store_id: {stats: true}}}
+    facets = Product.search("Product", options).facets["store_id"]["terms"]
+    expected_facets_keys = %w[term count total_count min max total mean]
+    assert_equal expected_facets_keys, facets.first.keys
+  end
+
+  protected
+
+  def store_facet(options, facet_key="store_id")
+    Hash[Product.search("Product", options).facets[facet_key]["terms"].map { |v| [v["term"], v["count"]] }]
+  end
+
+end

data/test/highlight_test.rb

@@ -0,0 +1,58 @@
+require_relative "test_helper"
+
+class TestHighlight < 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).with_details.first[1][:highlight][: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>"}).with_details.first[1][:highlight][:name]
+  end
+
+  def test_multiple_fields
+    store [{name: "Two Door Cinema Club", color: "Cinema Orange"}]
+    highlight = Product.search("cinema", fields: [:name, :color], highlight: true).with_details.first[1][:highlight]
+    assert_equal "Two Door <em>Cinema</em> Club", highlight[:name]
+    assert_equal "<em>Cinema</em> Orange", highlight[:color]
+  end
+
+  def test_fields
+    store [{name: "Two Door Cinema Club", color: "Cinema Orange"}]
+    highlight = Product.search("cinema", fields: [:name, :color], highlight: {fields: [:name]}).with_details.first[1][:highlight]
+    assert_equal "Two Door <em>Cinema</em> Club", highlight[:name]
+    assert_equal nil, highlight[:color]
+  end
+
+  def test_field_options
+    store_names ["Two Door Cinema Club are a Northern Irish indie rock band"]
+    assert_equal "Two Door <em>Cinema</em> Club are", Product.search("cinema", fields: [:name], highlight: {fields: {name: {fragment_size: 20}}}).with_details.first[1][:highlight][: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).with_details.first[1][:highlight][:name]
+  end
+
+  def test_json
+    store_names ["Two Door Cinema Club"]
+    json = {
+      query: {
+        match: {
+          _all: "cinema"
+        }
+      },
+      highlight: {
+        pre_tags: ["<strong>"],
+        post_tags: ["</strong>"],
+        fields: {
+          "name.analyzed" => {}
+        }
+      }
+    }
+    assert_equal "Two Door <strong>Cinema</strong> Club", Product.search(json: json).with_details.first[1][:highlight][:"name.analyzed"]
+  end
+
+end

data/test/index_test.rb

@@ -0,0 +1,119 @@
+require_relative "test_helper"
+
+class TestIndex < Minitest::Test
+
+  def test_clean_indices
+    old_index = Searchkick::Index.new("products_test_20130801000000000")
+    different_index = Searchkick::Index.new("items_test_20130801000000000")
+
+    old_index.delete if old_index.exists?
+    different_index.delete if different_index.exists?
+
+    # create indexes
+    old_index.create
+    different_index.create
+
+    Product.clean_indices
+
+    assert Product.searchkick_index.exists?
+    assert different_index.exists?
+    assert !old_index.exists?
+  end
+
+  def test_clean_indices_old_format
+    old_index = Searchkick::Index.new("products_test_20130801000000")
+    old_index.create
+
+    Product.clean_indices
+
+    assert !old_index.exists?
+  end
+
+  def test_mapping
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(query: {match: {name: "Dollar Tree"}}).map(&:name)
+  end
+
+  def test_json
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(json: {query: {match: {name: "Dollar Tree"}}}, load: false).map(&:name)
+  end
+
+  def test_body
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(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")
+  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(OpenStruct.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 = ->(s) { raise Elasticsearch::Transport::Transport::Error.new("[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_query
+    assert_raises(Searchkick::InvalidQueryError) { Product.search(query: {}) }
+  end
+
+  if defined?(ActiveRecord)
+
+    def test_transaction
+      Product.transaction do
+        store_names ["Product A"]
+        raise ActiveRecord::Rollback
+      end
+
+      assert_search "product", []
+    end
+
+  end
+
+end

data/test/inheritance_test.rb

@@ -0,0 +1,80 @@
+require_relative "test_helper"
+
+class TestInheritance < Minitest::Test
+
+  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], autocomplete: true).map(&:name)
+  end
+
+  def test_parent_autocomplete
+    store_names ["Max"], Cat
+    store_names ["Bear"], Dog
+    assert_equal ["Bear"], Animal.search("bea", fields: [:name], autocomplete: true).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/match_test.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+
+require_relative "test_helper"
+
+class TestMatch < Minitest::Test
+
+  # exact
+
+  def test_match
+    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
+    assert_search "milk", ["Milk", "Whole Milk", "Fat Free Milk"]
+  end
+
+  def test_case
+    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
+    assert_search "MILK", ["Milk", "Whole Milk", "Fat Free Milk"]
+  end
+
+  def test_cheese_space_in_index
+    store_names ["Pepper Jack Cheese Skewers"]
+    assert_search "pepperjack cheese skewers", ["Pepper Jack Cheese Skewers"]
+  end
+
+  # def test_cheese_space_in_query
+  #   store_names ["Pepperjack Cheese Skewers"]
+  #   assert_search "pepper jack cheese skewers", ["Pepperjack Cheese Skewers"]
+  # end
+
+  def test_middle_token
+    store_names ["Dish Washer Amazing Organic Soap"]
+    assert_search "dish soap", ["Dish Washer Amazing Organic Soap"]
+  end
+
+  def test_middle_token_wine
+    store_names ["Beringer Wine Founders Estate Chardonnay"]
+    assert_search "beringer chardonnay", ["Beringer Wine Founders Estate Chardonnay"]
+  end
+
+  def test_percent
+    store_names ["1% Milk", "2% Milk", "Whole Milk"]
+    assert_search "1%", ["1% Milk"]
+  end
+
+  # ascii
+
+  def test_jalapenos
+    store_names ["Jalapeño"]
+    assert_search "jalapeno", ["Jalapeño"]
+  end
+
+  def test_swedish
+    store_names ["ÅÄÖ"]
+    assert_search "aao", ["ÅÄÖ"]
+  end
+
+  # stemming
+
+  def test_stemming
+    store_names ["Whole Milk", "Fat Free Milk", "Milk"]
+    assert_search "milks", ["Milk", "Whole Milk", "Fat Free Milk"]
+  end
+
+  # fuzzy
+
+  def test_misspelling_sriracha
+    store_names ["Sriracha"]
+    assert_search "siracha", ["Sriracha"]
+  end
+
+  def test_misspelling_multiple
+    store_names ["Greek Yogurt", "Green Onions"]
+    assert_search "greed", ["Greek Yogurt", "Green Onions"]
+  end
+
+  def test_short_word
+    store_names ["Finn"]
+    assert_search "fin", ["Finn"]
+  end
+
+  def test_edit_distance_two
+    store_names ["Bingo"]
+    assert_search "bin", []
+    assert_search "bingooo", []
+    assert_search "mango", []
+  end
+
+  def test_edit_distance_one
+    store_names ["Bingo"]
+    assert_search "bing", ["Bingo"]
+    assert_search "bingoo", ["Bingo"]
+    assert_search "ringo", ["Bingo"]
+  end
+
+  def test_edit_distance_long_word
+    store_names ["thisisareallylongword"]
+    assert_search "thisisareallylongwor", ["thisisareallylongword"] # missing letter
+    assert_search "thisisareelylongword", [] # edit distance = 2
+  end
+
+  def test_misspelling_tabasco
+    store_names ["Tabasco"]
+    assert_search "tobasco", ["Tabasco"]
+  end
+
+  def test_misspelling_zucchini
+    store_names ["Zucchini"]
+    assert_search "zuchini", ["Zucchini"]
+  end
+
+  def test_misspelling_ziploc
+    store_names ["Ziploc"]
+    assert_search "zip lock", ["Ziploc"]
+  end
+
+  # spaces
+
+  def test_spaces_in_field
+    store_names ["Red Bull"]
+    assert_search "redbull", ["Red Bull"]
+  end
+
+  def test_spaces_in_query
+    store_names ["Dishwasher"]
+    assert_search "dish washer", ["Dishwasher"]
+  end
+
+  def test_spaces_three_words
+    store_names ["Dish Washer Soap", "Dish Washer"]
+    assert_search "dish washer soap", ["Dish Washer Soap"]
+  end
+
+  def test_spaces_stemming
+    store_names ["Almond Milk"]
+    assert_search "almondmilks", ["Almond Milk"]
+  end
+
+  def test_all
+    store_names ["Product A", "Product B"]
+    assert_search "*", ["Product A", "Product B"]
+  end
+
+  def test_no_arguments
+    assert_equal [], Product.search.to_a
+  end
+
+  def test_no_term
+    store_names ["Product A"]
+    assert_equal ["Product A"], Product.search(where: {name: "Product A"}).map(&:name)
+  end
+
+  def test_to_be_or_not_to_be
+    store_names ["to be or not to be"]
+    assert_search "to be", ["to be or not to be"]
+  end
+
+  def test_unsearchable
+    store [
+      {name: "Unsearchable", description: "Almond"}
+    ]
+    assert_search "almond", []
+  end
+
+end