searchkick 3.1.0 → 3.1.1

data/test/index_test.rb

@@ -1,168 +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_incompatible_options
-    assert_raises(ArgumentError) do
-      Store.search(body: {query: {match: {name: "dollar"}}}, where: {id: 1})
-    end
-  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_output nil, /\[searchkick\] WARNING: Records in search index do not exist in database/ do
-      assert_search "product", ["Product B"]
-    end
-  ensure
-    Product.reindex
-  end
-
-  def test_bad_mapping
-    Product.searchkick_index.delete
-    store_names ["Product A"]
-    error = assert_raises(Searchkick::InvalidQueryError) { Product.search "test" }
-    assert_equal "Bad mapping - run Product.reindex", error.message
-  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.
-    store [{name: "Product A", alt_description: "Hello"}]
-    assert_raises(Searchkick::InvalidQueryError) do
-      assert_search "*", [], where: {alt_description: "Hello"}
-    end
-  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
-    assert_search "hello", ["Product A"], {}, Region
-  end
-
-  def test_very_large_value
-    skip if nobrainer?
-    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,82 +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
-    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 2, Animal.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/language_test.rb

@@ -1,79 +0,0 @@
-require_relative "test_helper"
-
-class LanguageTest < Minitest::Test
-  def setup
-    skip unless ENV["LANGUAGE"]
-
-    Song.destroy_all
-  end
-
-  def test_chinese
-    # requires https://github.com/medcl/elasticsearch-analysis-ik
-    with_options(Song, language: "chinese") do
-      store_names ["中华人民共和国国歌"], Song
-      assert_language_search "中华人民共和国", ["中华人民共和国国歌"]
-      assert_language_search "国歌", ["中华人民共和国国歌"]
-      assert_language_search "人", []
-    end
-  end
-
-  # experimental
-  def test_smartcn
-    # requires https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/analysis-smartcn.html
-    with_options(Song, language: "smartcn") do
-      store_names ["中华人民共和国国歌"], Song
-      assert_language_search "中华人民共和国", ["中华人民共和国国歌"]
-      # assert_language_search "国歌", ["中华人民共和国国歌"]
-      assert_language_search "人", []
-    end
-  end
-
-  def test_japanese
-    # requires https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/analysis-kuromoji.html
-    with_options(Song, language: "japanese") do
-      store_names ["JR新宿駅の近くにビールを飲みに行こうか"], Song
-      assert_language_search "飲む", ["JR新宿駅の近くにビールを飲みに行こうか"]
-      assert_language_search "jr", ["JR新宿駅の近くにビールを飲みに行こうか"]
-      assert_language_search "新", []
-    end
-  end
-
-  def test_korean
-    # requires https://github.com/open-korean-text/elasticsearch-analysis-openkoreantext
-    with_options(Song, language: "korean") do
-      store_names ["한국어를 처리하는 예시입니닼ㅋㅋ"], Song
-      assert_language_search "처리", ["한국어를 처리하는 예시입니닼ㅋㅋ"]
-      assert_language_search "한국어", ["한국어를 처리하는 예시입니닼ㅋㅋ"]
-      assert_language_search "를", []
-    end
-  end
-
-  def test_polish
-    # requires https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/analysis-stempel.html
-    with_options(Song, language: "polish") do
-      store_names ["polski"], Song
-      assert_language_search "polskimi", ["polski"]
-    end
-  end
-
-  def test_ukrainian
-    # requires https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/analysis-ukrainian.html
-    with_options(Song, language: "ukrainian") do
-      store_names ["ресторани"], Song
-      assert_language_search "ресторан", ["ресторани"]
-    end
-  end
-
-  def test_vietnamese
-    # requires https://github.com/duydo/elasticsearch-analysis-vietnamese
-    with_options(Song, language: "vietnamese") do
-      store_names ["công nghệ thông tin Việt Nam"], Song
-      assert_language_search "công nghệ thông tin", ["công nghệ thông tin Việt Nam"]
-      assert_language_search "công", []
-    end
-  end
-
-  def assert_language_search(term, expected)
-    assert_search term, expected, {misspellings: false}, Song
-  end
-end

data/test/marshal_test.rb

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

data/test/match_test.rb

@@ -1,293 +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_operator
-    store_names ["fresh", "honey"]
-    assert_search "fresh honey", ["fresh", "honey"], {operator: "or"}
-    assert_search "fresh honey", [], {operator: "and"}
-    assert_search "fresh honey", ["fresh", "honey"], {operator: :or}
-  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"]
-
-    # need to specify field
-    # as transposition option isn't supported for multi_match queries
-    # until Elasticsearch 6.1
-    assert_search "zuccihni", [], misspellings: {transpositions: false}, fields: [:name]
-  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"], fields: [{name: :exact}]
-  end
-
-  def test_exclude_same_exact
-    store_names ["Butter Tub", "Peanut Butter Tub"]
-    assert_search "Butter Tub", ["Butter Tub"], exclude: ["Peanut Butter Tub"], fields: [{name: :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_again
-    store_names ["Social entrepreneurs don't have it easy raising capital"]
-    assert_search "social entrepreneurs don't have it easy raising capital", ["Social entrepreneurs don't have it easy raising capital"], 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, fields: [:name]
-  end
-
-  def test_dynamic_fields
-    store_names ["Red Bull"], Speaker
-    assert_search "redbull", ["Red Bull"], {fields: [:name]}, Speaker
-  end
-
-  def test_unsearchable
-    skip
-    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