searchkick 2.3.2 → 4.4.1

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

data/test/model_test.rb

@@ -1,42 +0,0 @@
-require_relative "test_helper"
-
-class ModelTest < Minitest::Test
-  def test_disable_callbacks_model
-    store_names ["product a"]
-
-    Product.disable_search_callbacks
-    assert !Product.search_callbacks?
-
-    store_names ["product b"]
-    assert_search "product", ["product a"]
-
-    Product.enable_search_callbacks
-    Product.reindex
-
-    assert_search "product", ["product a", "product b"]
-  end
-
-  def test_disable_callbacks_global
-    # make sure callbacks default to on
-    assert Searchkick.callbacks?
-
-    store_names ["product a"]
-
-    Searchkick.disable_callbacks
-    assert !Searchkick.callbacks?
-
-    store_names ["product b"]
-    assert_search "product", ["product a"]
-
-    Searchkick.enable_callbacks
-    Product.reindex
-
-    assert_search "product", ["product a", "product b"]
-  end
-
-  def test_multiple_models
-    store_names ["Product A"]
-    store_names ["Product B"], Speaker
-    assert_equal Product.all.to_a + Speaker.all.to_a, Searchkick.search("product", index_name: [Product, Speaker], fields: [:name], order: "name").to_a
-  end
-end

data/test/multi_search_test.rb

@@ -1,36 +0,0 @@
-require_relative "test_helper"
-
-class MultiSearchTest < Minitest::Test
-  def test_basic
-    store_names ["Product A"]
-    store_names ["Store A"], Store
-    products = Product.search("*", execute: false)
-    stores = Store.search("*", execute: false)
-    Searchkick.multi_search([products, stores])
-    assert_equal ["Product A"], products.map(&:name)
-    assert_equal ["Store A"], stores.map(&:name)
-  end
-
-  def test_error
-    store_names ["Product A"]
-    products = Product.search("*", execute: false)
-    stores = Store.search("*", order: [:bad_field], execute: false)
-    Searchkick.multi_search([products, stores])
-    assert !products.error
-    assert stores.error
-  end
-
-  def test_misspellings_below_unmet
-    store_names ["abc", "abd", "aee"]
-    products = Product.search("abc", misspellings: {below: 2}, execute: false)
-    Searchkick.multi_search([products])
-    assert_equal ["abc"], products.map(&:name)
-  end
-
-  def test_misspellings_below_unmet_retry
-    store_names ["abc", "abd", "aee"]
-    products = Product.search("abc", misspellings: {below: 2}, execute: false)
-    Searchkick.multi_search([products], retry_misspellings: true)
-    assert_equal ["abc", "abd"], products.map(&:name)
-  end
-end

data/test/multi_tenancy_test.rb

@@ -1,22 +0,0 @@
-require_relative "test_helper"
-
-class MultiTenancyTest < Minitest::Test
-  def setup
-    skip unless defined?(Apartment)
-  end
-
-  def test_basic
-    Apartment::Tenant.switch!("tenant1")
-    store_names ["Product A"], Tenant
-    Apartment::Tenant.switch!("tenant2")
-    store_names ["Product B"], Tenant
-    Apartment::Tenant.switch!("tenant1")
-    assert_search "product", ["Product A"], {load: false}, Tenant
-    Apartment::Tenant.switch!("tenant2")
-    assert_search "product", ["Product B"], {load: false}, Tenant
-  end
-
-  def teardown
-    Apartment::Tenant.reset if defined?(Apartment)
-  end
-end

data/test/order_test.rb

@@ -1,46 +0,0 @@
-require_relative "test_helper"
-
-class OrderTest < Minitest::Test
-  def test_order_hash
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product D", "Product C", "Product B", "Product A"], order: {name: :desc}
-  end
-
-  def test_order_string
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product A", "Product B", "Product C", "Product D"], order: "name"
-  end
-
-  def test_order_id
-    skip if cequel?
-
-    store_names ["Product A", "Product B"]
-    product_a = Product.where(name: "Product A").first
-    product_b = Product.where(name: "Product B").first
-    assert_order "product", [product_a, product_b].sort_by(&:id).map(&:name), order: {id: :asc}
-  end
-
-  def test_order_multiple
-    store [
-      {name: "Product A", color: "blue", store_id: 1},
-      {name: "Product B", color: "red", store_id: 3},
-      {name: "Product C", color: "red", store_id: 2}
-    ]
-    assert_order "product", ["Product A", "Product B", "Product C"], order: {color: :asc, store_id: :desc}
-  end
-
-  def test_order_ignore_unmapped
-    skip unless elasticsearch_below50?
-    assert_order "product", [], order: {not_mapped: {ignore_unmapped: true}}, conversions: false
-  end
-
-  def test_order_unmapped_type
-    skip if elasticsearch_below50?
-    assert_order "product", [], order: {not_mapped: {unmapped_type: "long"}}, conversions: false
-  end
-
-  def test_order_array
-    store [{name: "San Francisco", latitude: 37.7833, longitude: -122.4167}]
-    assert_order "francisco", ["San Francisco"], order: [{_geo_distance: {location: "0,0"}}]
-  end
-end

data/test/pagination_test.rb

@@ -1,70 +0,0 @@
-require_relative "test_helper"
-
-class PaginationTest < Minitest::Test
-  def test_limit
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product A", "Product B"], order: {name: :asc}, limit: 2
-  end
-
-  def test_no_limit
-    names = 20.times.map { |i| "Product #{i}" }
-    store_names names
-    assert_search "product", names
-  end
-
-  def test_offset
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product C", "Product D"], order: {name: :asc}, offset: 2
-  end
-
-  def test_pagination
-    store_names ["Product A", "Product B", "Product C", "Product D", "Product E", "Product F"]
-    products = Product.search("product", order: {name: :asc}, page: 2, per_page: 2, padding: 1)
-    assert_equal ["Product D", "Product E"], products.map(&:name)
-    assert_equal "product", products.entry_name
-    assert_equal 2, products.current_page
-    assert_equal 1, products.padding
-    assert_equal 2, products.per_page
-    assert_equal 2, products.size
-    assert_equal 2, products.length
-    assert_equal 3, products.total_pages
-    assert_equal 6, products.total_count
-    assert_equal 6, products.total_entries
-    assert_equal 2, products.limit_value
-    assert_equal 3, products.offset_value
-    assert_equal 3, products.offset
-    assert_equal 3, products.next_page
-    assert_equal 1, products.previous_page
-    assert_equal 1, products.prev_page
-    assert !products.first_page?
-    assert !products.last_page?
-    assert !products.empty?
-    assert !products.out_of_range?
-    assert products.any?
-  end
-
-  def test_pagination_nil_page
-    store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
-    products = Product.search("product", order: {name: :asc}, page: nil, per_page: 2)
-    assert_equal ["Product A", "Product B"], products.map(&:name)
-    assert_equal 1, products.current_page
-    assert products.first_page?
-  end
-
-  def test_kaminari
-    skip unless defined?(Kaminari)
-
-    require "action_view"
-
-    I18n.load_path = Dir["test/support/kaminari.yml"]
-    I18n.backend.load_translations
-
-    view = ActionView::Base.new
-
-    store_names ["Product A"]
-    assert_equal "Displaying <b>1</b> product", view.page_entries_info(Product.search("product"))
-
-    store_names ["Product B"]
-    assert_equal "Displaying <b>all 2</b> products", view.page_entries_info(Product.search("product"))
-  end
-end