searchkick 2.3.2 → 5.2.1

data/test/highlight_test.rb

@@ -1,78 +0,0 @@
-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 : 21
-    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

@@ -1,166 +0,0 @@
-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_body_warning
-    assert_output(nil, "The body option replaces the entire body, so the following options are ignored: where\n") { Store.search(body: {query: {match: {name: "dollar"}}}, where: {id: 1}) }
-  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_filterable_non_string
-    store [{name: "Product A", store_id: 1}]
-    assert_search "*", ["Product A"], where: {store_id: 1}
-  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
-
-    # needs fields for ES 6
-    if elasticsearch_below60?
-      assert_search "hello", ["Product A"], {}, Region
-    end
-  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

@@ -1,83 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

data/test/match_test.rb

@@ -1,276 +0,0 @@
-require_relative "test_helper"
-
-class MatchTest < 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
-    # Note: "2% Milk" doesn't get matched in ES below 5.1.1
-    # This could be a bug since it has an edit distance of 1
-    store_names ["1% 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
-
-  def test_misspelling_zucchini_transposition
-    store_names ["zucchini"]
-    assert_search "zuccihni", ["zucchini"]
-    assert_search "zuccihni", [], misspellings: {transpositions: false}
-  end
-
-  def test_misspelling_lasagna
-    store_names ["lasagna"]
-    assert_search "lasanga", ["lasagna"], misspellings: {transpositions: true}
-    assert_search "lasgana", ["lasagna"], misspellings: {transpositions: true}
-    assert_search "lasaang", [], misspellings: {transpositions: true} # triple transposition, shouldn't work
-    assert_search "lsagana", [], misspellings: {transpositions: true} # triple transposition, shouldn't work
-  end
-
-  def test_misspelling_lasagna_pasta
-    store_names ["lasagna pasta"]
-    assert_search "lasanga", ["lasagna pasta"], misspellings: {transpositions: true}
-    assert_search "lasanga pasta", ["lasagna pasta"], misspellings: {transpositions: true}
-    assert_search "lasanga pasat", ["lasagna pasta"], misspellings: {transpositions: true} # both words misspelled with a transposition should still work
-  end
-
-  def test_misspellings_word_start
-    store_names ["Sriracha"]
-    assert_search "siracha", ["Sriracha"], fields: [{name: :word_start}]
-  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
-
-  # butter
-
-  def test_exclude_butter
-    store_names ["Butter Tub", "Peanut Butter Tub"]
-    assert_search "butter", ["Butter Tub"], exclude: ["peanut butter"]
-  end
-
-  def test_exclude_butter_word_start
-    store_names ["Butter Tub", "Peanut Butter Tub"]
-    assert_search "butter", ["Butter Tub"], exclude: ["peanut butter"], match: :word_start
-  end
-
-  def test_exclude_butter_exact
-    store_names ["Butter Tub", "Peanut Butter Tub"]
-    assert_search "butter", [], exclude: ["peanut butter"], match: :exact
-  end
-
-  def test_exclude_same_exact
-    store_names ["Butter Tub", "Peanut Butter Tub"]
-    assert_search "Butter Tub", [], exclude: ["Butter Tub"], match: :exact
-  end
-
-  def test_exclude_egg_word_start
-    store_names ["eggs", "eggplant"]
-    assert_search "egg", ["eggs"], exclude: ["eggplant"], match: :word_start
-  end
-
-  def test_exclude_string
-    store_names ["Butter Tub", "Peanut Butter Tub"]
-    assert_search "butter", ["Butter Tub"], exclude: "peanut butter"
-  end
-
-  # other
-
-  def test_all
-    store_names ["Product A", "Product B"]
-    assert_search "*", ["Product A", "Product B"]
-  end
-
-  def test_no_arguments
-    store_names []
-    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_apostrophe
-    store_names ["Ben and Jerry's"]
-    assert_search "ben and jerrys", ["Ben and Jerry's"]
-  end
-
-  def test_apostrophe_search
-    store_names ["Ben and Jerrys"]
-    assert_search "ben and jerry's", ["Ben and Jerrys"]
-  end
-
-  def test_ampersand_index
-    store_names ["Ben & Jerry's"]
-    assert_search "ben and jerrys", ["Ben & Jerry's"]
-  end
-
-  def test_ampersand_search
-    store_names ["Ben and Jerry's"]
-    assert_search "ben & jerrys", ["Ben and Jerry's"]
-  end
-
-  def test_phrase
-    store_names ["Fresh Honey", "Honey Fresh"]
-    assert_search "fresh honey", ["Fresh Honey"], match: :phrase
-  end
-
-  def test_phrase_order
-    store_names ["Wheat Bread", "Whole Wheat Bread"]
-    assert_order "wheat bread", ["Wheat Bread", "Whole Wheat Bread"], match: :phrase
-  end
-
-  def test_dynamic_fields
-    store_names ["Red Bull"], Speaker
-    assert_search "redbull", ["Red Bull"], {fields: [:name]}, Speaker
-  end
-
-  def test_unsearchable
-    store [
-      {name: "Unsearchable", description: "Almond"}
-    ]
-    assert_search "almond", []
-  end
-
-  def test_unsearchable_where
-    store [
-      {name: "Unsearchable", description: "Almond"}
-    ]
-    assert_search "*", ["Unsearchable"], where: {description: "Almond"}
-  end
-
-  def test_emoji
-    skip unless defined?(EmojiParser)
-    store_names ["Banana"]
-    assert_search "🍌", ["Banana"], emoji: true
-  end
-
-  def test_emoji_multiple
-    skip unless defined?(EmojiParser)
-    store_names ["Ice Cream Cake"]
-    assert_search "🍨🍰", ["Ice Cream Cake"], emoji: true
-  end
-end

data/test/misspellings_test.rb

@@ -1,56 +0,0 @@
-require_relative "test_helper"
-
-class MisspellingsTest < Minitest::Test
-  def test_misspellings
-    store_names ["abc", "abd", "aee"]
-    assert_search "abc", ["abc"], misspellings: false
-  end
-
-  def test_misspellings_distance
-    store_names ["abbb", "aabb"]
-    assert_search "aaaa", ["aabb"], misspellings: {distance: 2}
-  end
-
-  def test_misspellings_prefix_length
-    store_names ["ap", "api", "apt", "any", "nap", "ah", "ahi"]
-    assert_search "ap", ["ap"], misspellings: {prefix_length: 2}
-    assert_search "api", ["ap", "api", "apt"], misspellings: {prefix_length: 2}
-  end
-
-  def test_misspellings_prefix_length_operator
-    store_names ["ap", "api", "apt", "any", "nap", "ah", "aha"]
-    assert_search "ap ah", ["ap", "ah"], operator: "or", misspellings: {prefix_length: 2}
-    assert_search "api ahi", ["ap", "api", "apt", "ah", "aha"], operator: "or", misspellings: {prefix_length: 2}
-  end
-
-  def test_misspellings_fields_operator
-    store [
-      {name: "red", color: "red"},
-      {name: "blue", color: "blue"},
-      {name: "cyan", color: "blue green"},
-      {name: "magenta", color: "red blue"},
-      {name: "green", color: "green"}
-    ]
-    assert_search "red blue", ["red", "blue", "cyan", "magenta"], operator: "or", fields: ["color"], misspellings: false
-  end
-
-  def test_misspellings_below_unmet
-    store_names ["abc", "abd", "aee"]
-    assert_search "abc", ["abc", "abd"], misspellings: {below: 2}
-  end
-
-  def test_misspellings_below_unmet_result
-    store_names ["abc", "abd", "aee"]
-    assert Product.search("abc", misspellings: {below: 2}).misspellings?
-  end
-
-  def test_misspellings_below_met
-    store_names ["abc", "abd", "aee"]
-    assert_search "abc", ["abc"], misspellings: {below: 1}
-  end
-
-  def test_misspellings_below_met_result
-    store_names ["abc", "abd", "aee"]
-    assert !Product.search("abc", misspellings: {below: 1}).misspellings?
-  end
-end