searchkick 2.3.2 → 5.2.1

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

data/test/partial_reindex_test.rb

@@ -1,58 +0,0 @@
-require_relative "test_helper"
-
-class PartialReindexTest < Minitest::Test
-  def test_class_method
-    store [{name: "Hi", color: "Blue"}]
-
-    # normal search
-    assert_search "hi", ["Hi"], fields: [:name], load: false
-    assert_search "blue", ["Hi"], fields: [:color], load: false
-
-    # update
-    product = Product.first
-    product.name = "Bye"
-    product.color = "Red"
-    Searchkick.callbacks(false) do
-      product.save!
-    end
-    Product.searchkick_index.refresh
-
-    # index not updated
-    assert_search "hi", ["Hi"], fields: [:name], load: false
-    assert_search "blue", ["Hi"], fields: [:color], load: false
-
-    # partial reindex
-    Product.reindex(:search_name)
-
-    # name updated, but not color
-    assert_search "bye", ["Bye"], fields: [:name], load: false
-    assert_search "blue", ["Bye"], fields: [:color], load: false
-  end
-
-  def test_instance_method
-    store [{name: "Hi", color: "Blue"}]
-
-    # normal search
-    assert_search "hi", ["Hi"], fields: [:name], load: false
-    assert_search "blue", ["Hi"], fields: [:color], load: false
-
-    # update
-    product = Product.first
-    product.name = "Bye"
-    product.color = "Red"
-    Searchkick.callbacks(false) do
-      product.save!
-    end
-    Product.searchkick_index.refresh
-
-    # index not updated
-    assert_search "hi", ["Hi"], fields: [:name], load: false
-    assert_search "blue", ["Hi"], fields: [:color], load: false
-
-    product.reindex(:search_name, refresh: true)
-
-    # name updated, but not color
-    assert_search "bye", ["Bye"], fields: [:name], load: false
-    assert_search "blue", ["Bye"], fields: [:color], load: false
-  end
-end

data/test/query_test.rb

@@ -1,35 +0,0 @@
-require_relative "test_helper"
-
-class QueryTest < Minitest::Test
-  def test_basic
-    store_names ["Milk", "Apple"]
-    query = Product.search("milk", execute: false)
-    # query.body = {query: {match_all: {}}}
-    # query.body = {query: {match: {name: "Apple"}}}
-    query.body[:query] = {match_all: {}}
-    assert_equal ["Apple", "Milk"], query.map(&:name).sort
-    assert_equal ["Apple", "Milk"], query.execute.map(&:name).sort
-  end
-
-  def test_with_effective_min_score
-    store_names ["Milk", "Milk2"]
-    assert_search "milk", ["Milk"], body_options: {min_score: 1}
-  end
-
-  def test_with_uneffective_min_score
-    store_names ["Milk", "Milk2"]
-    assert_search "milk", ["Milk", "Milk2"], body_options: {min_score: 0.0001}
-  end
-
-  def test_default_timeout
-    assert_equal "6s", Product.search("*", execute: false).body[:timeout]
-  end
-
-  def test_timeout_override
-    assert_equal "1s", Product.search("*", body_options: {timeout: "1s"}, execute: false).body[:timeout]
-  end
-
-  def test_request_params
-    assert_equal "dfs_query_then_fetch", Product.search("*", request_params: {search_type: "dfs_query_then_fetch"}, execute: false).params[:search_type]
-  end
-end

data/test/records_test.rb

@@ -1,10 +0,0 @@
-require_relative "test_helper"
-
-class RecordsTest < Minitest::Test
-  def test_records
-    skip if cequel?
-
-    store_names ["Milk", "Apple"]
-    assert_equal Product.search("milk").records.where(name: "Milk").count, 1
-  end
-end

data/test/reindex_test.rb

@@ -1,64 +0,0 @@
-require_relative "test_helper"
-
-class ReindexTest < Minitest::Test
-  def test_scoped
-    skip if nobrainer? || cequel?
-
-    store_names ["Product A"]
-    Searchkick.callbacks(false) do
-      store_names ["Product B", "Product C"]
-    end
-    Product.where(name: "Product B").reindex(refresh: true)
-    assert_search "product", ["Product A", "Product B"]
-  end
-
-  def test_associations
-    skip if nobrainer? || cequel?
-
-    store_names ["Product A"]
-    store = Store.create!(name: "Test")
-    Product.create!(name: "Product B", store_id: store.id)
-    store.products.reindex(refresh: true)
-    assert_search "product", ["Product A", "Product B"]
-  end
-
-  def test_async
-    skip if !defined?(ActiveJob)
-
-    Searchkick.callbacks(false) do
-      store_names ["Product A"]
-    end
-    reindex = Product.reindex(async: true)
-    assert_search "product", [], conversions: false
-
-    index = Searchkick::Index.new(reindex[:index_name])
-    index.refresh
-    assert_equal 1, index.total_docs
-
-    Product.searchkick_index.promote(reindex[:index_name])
-    assert_search "product", ["Product A"]
-  end
-
-  def test_async_non_integer_pk
-    skip if !defined?(ActiveJob)
-
-    Sku.create(id: SecureRandom.hex, name: "Test")
-    reindex = Sku.reindex(async: true)
-    assert_search "sku", [], conversions: false
-
-    index = Searchkick::Index.new(reindex[:index_name])
-    index.refresh
-    assert_equal 1, index.total_docs
-  end
-
-  def test_refresh_interval
-    reindex = Product.reindex(refresh_interval: "30s", async: true, import: false)
-    index = Searchkick::Index.new(reindex[:index_name])
-    assert_nil Product.search_index.refresh_interval
-    assert_equal "30s", index.refresh_interval
-
-    Product.search_index.promote(index.name, update_refresh_interval: true)
-    assert_equal "1s", index.refresh_interval
-    assert_equal "1s", Product.search_index.refresh_interval
-  end
-end

data/test/reindex_v2_job_test.rb

@@ -1,32 +0,0 @@
-require_relative "test_helper"
-
-class ReindexV2JobTest < Minitest::Test
-  def setup
-    skip unless defined?(ActiveJob)
-    super
-    Searchkick.disable_callbacks
-  end
-
-  def teardown
-    Searchkick.enable_callbacks
-  end
-
-  def test_create
-    product = Product.create!(name: "Boom")
-    Product.searchkick_index.refresh
-    assert_search "*", []
-    Searchkick::ReindexV2Job.perform_later("Product", product.id.to_s)
-    Product.searchkick_index.refresh
-    assert_search "*", ["Boom"]
-  end
-
-  def test_destroy
-    product = Product.create!(name: "Boom")
-    Product.reindex
-    assert_search "*", ["Boom"]
-    product.destroy
-    Searchkick::ReindexV2Job.perform_later("Product", product.id.to_s)
-    Product.searchkick_index.refresh
-    assert_search "*", []
-  end
-end

data/test/routing_test.rb

@@ -1,23 +0,0 @@
-require_relative "test_helper"
-
-class RoutingTest < Minitest::Test
-  def test_routing_query
-    query = Store.search("Dollar Tree", routing: "Dollar Tree", execute: false)
-    assert_equal query.params[:routing], "Dollar Tree"
-  end
-
-  def test_routing_mappings
-    index_options = Store.searchkick_index.index_options
-    assert_equal index_options[:mappings][:_default_][:_routing], required: true
-  end
-
-  def test_routing_correct_node
-    store_names ["Dollar Tree"], Store
-    assert_search "*", ["Dollar Tree"], {routing: "Dollar Tree"}, Store
-  end
-
-  def test_routing_incorrect_node
-    store_names ["Dollar Tree"], Store
-    assert_search "*", ["Dollar Tree"], {routing: "Boom"}, Store
-  end
-end

data/test/should_index_test.rb

@@ -1,32 +0,0 @@
-require_relative "test_helper"
-
-class ShouldIndexTest < Minitest::Test
-  def test_basic
-    store_names ["INDEX", "DO NOT INDEX"]
-    assert_search "index", ["INDEX"]
-  end
-
-  def test_default_true
-    assert Animal.new.should_index?
-  end
-
-  def test_change_to_true
-    store_names ["DO NOT INDEX"]
-    assert_search "index", []
-    product = Product.first
-    product.name = "INDEX"
-    product.save!
-    Product.searchkick_index.refresh
-    assert_search "index", ["INDEX"]
-  end
-
-  def test_change_to_false
-    store_names ["INDEX"]
-    assert_search "index", ["INDEX"]
-    product = Product.first
-    product.name = "DO NOT INDEX"
-    product.save!
-    Product.searchkick_index.refresh
-    assert_search "index", []
-  end
-end

data/test/similar_test.rb

@@ -1,28 +0,0 @@
-require_relative "test_helper"
-
-class SimilarTest < Minitest::Test
-  def test_similar
-    store_names ["Annie's Naturals Organic Shiitake & Sesame Dressing"]
-    assert_search "Annie's Naturals Shiitake & Sesame Vinaigrette", ["Annie's Naturals Organic Shiitake & Sesame Dressing"], similar: true
-  end
-
-  def test_fields
-    store_names ["1% Organic Milk", "2% Organic Milk", "Popcorn"]
-    assert_equal ["2% Organic Milk"], Product.where(name: "1% Organic Milk").first.similar(fields: ["name"]).map(&:name)
-  end
-
-  def test_order
-    store_names ["Lucerne Milk Chocolate Fat Free", "Clover Fat Free Milk"]
-    assert_order "Lucerne Fat Free Chocolate Milk", ["Lucerne Milk Chocolate Fat Free", "Clover Fat Free Milk"], similar: true
-  end
-
-  def test_limit
-    store_names ["1% Organic Milk", "2% Organic Milk", "Fat Free Organic Milk", "Popcorn"]
-    assert_equal ["2% Organic Milk"], Product.where(name: "1% Organic Milk").first.similar(fields: ["name"], order: ["name"], limit: 1).map(&:name)
-  end
-
-  def test_per_page
-    store_names ["1% Organic Milk", "2% Organic Milk", "Fat Free Organic Milk", "Popcorn"]
-    assert_equal ["2% Organic Milk"], Product.where(name: "1% Organic Milk").first.similar(fields: ["name"], order: ["name"], per_page: 1).map(&:name)
-  end
-end