searchkick 2.3.2 → 4.4.1

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

data/test/sql_test.rb

@@ -1,214 +0,0 @@
-require_relative "test_helper"
-
-class SqlTest < Minitest::Test
-  def test_operator
-    store_names ["Honey"]
-    assert_search "fresh honey", []
-    assert_search "fresh honey", ["Honey"], operator: "or"
-  end
-
-  def test_operator_scoring
-    store_names ["Big Red Circle", "Big Green Circle", "Small Orange Circle"]
-    assert_order "big red circle", ["Big Red Circle", "Big Green Circle", "Small Orange Circle"], operator: "or"
-  end
-
-  def test_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"]
-  end
-
-  def test_fields
-    store [
-      {name: "red", color: "light blue"},
-      {name: "blue", color: "red fish"}
-    ]
-    assert_search "blue", ["red"], fields: ["color"]
-  end
-
-  def test_non_existent_field
-    store_names ["Milk"]
-    assert_search "milk", [], fields: ["not_here"]
-  end
-
-  def test_fields_both_match
-    store [
-      {name: "Blue A", color: "red"},
-      {name: "Blue B", color: "light blue"}
-    ]
-    assert_first "blue", "Blue B", fields: [:name, :color]
-  end
-
-  def test_big_decimal
-    store [
-      {name: "Product", latitude: 80.0}
-    ]
-    assert_search "product", ["Product"], where: {latitude: {gt: 79}}
-  end
-
-  # body_options
-
-  def test_body_options_should_merge_into_body
-    query = Product.search("*", body_options: {min_score: 1.0}, execute: false)
-    assert_equal 1.0, query.body[:min_score]
-  end
-
-  # load
-
-  def test_load_default
-    store_names ["Product A"]
-    assert_kind_of Product, Product.search("product").first
-  end
-
-  def test_load_false
-    store_names ["Product A"]
-    assert_kind_of Hash, Product.search("product", load: false).first
-  end
-
-  def test_load_false_methods
-    store_names ["Product A"]
-    assert_equal "Product A", Product.search("product", load: false).first.name
-  end
-
-  def test_load_false_with_includes
-    store_names ["Product A"]
-    assert_kind_of Hash, Product.search("product", load: false, includes: [:store]).first
-  end
-
-  def test_load_false_nested_object
-    aisle = {"id" => 1, "name" => "Frozen"}
-    store [{name: "Product A", aisle: aisle}]
-    assert_equal aisle, Product.search("product", load: false).first.aisle.to_hash
-  end
-
-  # select
-
-  def test_select
-    store [{name: "Product A", store_id: 1}]
-    result = Product.search("product", load: false, select: [:name, :store_id]).first
-    assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal "Product A", result.name
-    assert_equal 1, result.store_id
-  end
-
-  def test_select_array
-    store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", load: false, select: [:user_ids]).first
-    assert_equal [1, 2], result.user_ids
-  end
-
-  def test_select_single_field
-    store [{name: "Product A", store_id: 1}]
-    result = Product.search("product", load: false, select: :name).first
-    assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal "Product A", result.name
-    assert_nil result.store_id
-  end
-
-  def test_select_all
-    store [{name: "Product A", user_ids: [1, 2]}]
-    hit = Product.search("product", select: true).hits.first
-    assert_equal hit["_source"]["name"], "Product A"
-    assert_equal hit["_source"]["user_ids"], [1, 2]
-  end
-
-  def test_select_none
-    store [{name: "Product A", user_ids: [1, 2]}]
-    hit = Product.search("product", select: []).hits.first
-    assert_nil hit["_source"]
-    hit = Product.search("product", select: false).hits.first
-    assert_nil hit["_source"]
-  end
-
-  def test_select_include
-    skip unless elasticsearch_below50?
-    store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", load: false, select: {include: [:name]}).first
-    assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal "Product A", result.name
-    assert_nil result.store_id
-  end
-
-  def test_select_exclude
-    skip unless elasticsearch_below50?
-    store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select: {exclude: [:name]}).first
-    assert_nil result.name
-    assert_equal [1, 2], result.user_ids
-    assert_equal 1, result.store_id
-  end
-
-  def test_select_include_and_exclude
-    skip unless elasticsearch_below50?
-    # let's take this to the next level
-    store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select: {include: [:store_id], exclude: [:name]}).first
-    assert_equal 1, result.store_id
-    assert_nil result.name
-    assert_nil result.user_ids
-  end
-
-  def test_select_includes
-    skip if elasticsearch_below50?
-    store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", load: false, select: {includes: [:name]}).first
-    assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal "Product A", result.name
-    assert_nil result.store_id
-  end
-
-  def test_select_excludes
-    skip if elasticsearch_below50?
-    store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select: {excludes: [:name]}).first
-    assert_nil result.name
-    assert_equal [1, 2], result.user_ids
-    assert_equal 1, result.store_id
-  end
-
-  def test_select_include_and_excludes
-    skip if elasticsearch_below50?
-    # let's take this to the next level
-    store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select: {includes: [:store_id], excludes: [:name]}).first
-    assert_equal 1, result.store_id
-    assert_nil result.name
-    assert_nil result.user_ids
-  end
-
-  # nested
-
-  def test_nested_search
-    store [{name: "Product A", aisle: {"id" => 1, "name" => "Frozen"}}], Speaker
-    assert_search "frozen", ["Product A"], {fields: ["aisle.name"]}, Speaker
-  end
-
-  # other tests
-
-  def test_includes
-    skip unless defined?(ActiveRecord)
-    store_names ["Product A"]
-    assert Product.search("product", includes: [:store]).first.association(:store).loaded?
-  end
-
-  def test_model_includes
-    skip unless defined?(ActiveRecord)
-
-    store_names ["Product A"]
-    store_names ["Store A"], Store
-
-    associations = {Product => [:store], Store => [:products]}
-    result = Searchkick.search("*", index_name: [Product, Store], model_includes: associations)
-
-    assert_equal 2, result.length
-
-    result.group_by(&:class).each_pair do |klass, records|
-      assert records.first.association(associations[klass].first).loaded?
-    end
-  end
-end

data/test/suggest_test.rb

@@ -1,95 +0,0 @@
-require_relative "test_helper"
-
-class SuggestTest < Minitest::Test
-  def test_basic
-    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
-    assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark", fields: [:name]
-  end
-
-  def test_perfect
-    store_names ["Tiger Shark", "Great White Shark"]
-    assert_suggest "Tiger Shark", nil, fields: [:name] # no correction
-  end
-
-  def test_phrase
-    store_names ["Big Tiger Shark", "Tiger Sharp Teeth", "Tiger Sharp Mind"]
-    assert_suggest "How to catch a big tiger shar", "how to catch a big tiger shark", fields: [:name]
-  end
-
-  def test_without_option
-    store_names ["hi"] # needed to prevent ElasticsearchException - seed 668
-    assert_raises(RuntimeError) { Product.search("hi").suggestions }
-  end
-
-  def test_multiple_fields
-    store [
-      {name: "Shark", color: "Sharp"},
-      {name: "Shark", color: "Sharp"}
-    ]
-    assert_suggest_all "shar", ["shark", "sharp"]
-  end
-
-  def test_multiple_fields_highest_score_first
-    store [
-      {name: "Tiger Shark", color: "Sharp"}
-    ]
-    assert_suggest "tiger shar", "tiger shark"
-  end
-
-  def test_multiple_fields_same_value
-    store [
-      {name: "Shark", color: "Shark"}
-    ]
-    assert_suggest_all "shar", ["shark"]
-  end
-
-  def test_fields_option
-    store [
-      {name: "Shark", color: "Sharp"}
-    ]
-    assert_suggest_all "shar", ["shark"], fields: [:name]
-  end
-
-  def test_fields_option_multiple
-    store [
-      {name: "Shark"}
-    ]
-    assert_suggest "shar", "shark", fields: [:name, :unknown]
-  end
-
-  def test_fields_partial_match
-    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
-    assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark", fields: [{name: :word_start}]
-  end
-
-  def test_fields_partial_match_boost
-    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
-    assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark", fields: [{"name^2" => :word_start}]
-  end
-
-  def test_multiple_models
-    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
-    assert_equal "how big is a tiger shark", Searchkick.search("How Big is a Tigre Shar", suggest: [:name], fields: [:name]).suggestions.first
-  end
-
-  def test_multiple_models_no_fields
-    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
-    assert_raises(ArgumentError) { Searchkick.search("How Big is a Tigre Shar", suggest: true) }
-  end
-
-  protected
-
-  def assert_suggest(term, expected, options = {})
-    result = Product.search(term, options.merge(suggest: true)).suggestions.first
-    if expected.nil?
-      assert_nil result
-    else
-      assert_equal expected, result
-    end
-  end
-
-  # any order
-  def assert_suggest_all(term, expected, options = {})
-    assert_equal expected.sort, Product.search(term, options.merge(suggest: true)).suggestions.sort
-  end
-end

data/test/support/kaminari.yml

@@ -1,21 +0,0 @@
-en:
-  views:
-    pagination:
-      first: "« First"
-      last: "Last »"
-      previous: "‹ Prev"
-      next: "Next ›"
-      truncate: "…"
-  helpers:
-    page_entries_info:
-      entry:
-        zero: "entries"
-        one: "entry"
-        other: "entries"
-      one_page:
-        display_entries:
-          zero: "No %{entry_name} found"
-          one: "Displaying <b>1</b> %{entry_name}"
-          other: "Displaying <b>all %{count}</b> %{entry_name}"
-      more_pages:
-        display_entries: "Displaying %{entry_name} <b>%{first}&nbsp;-&nbsp;%{last}</b> of <b>%{total}</b> in total"

data/test/synonyms_test.rb

@@ -1,67 +0,0 @@
-require_relative "test_helper"
-
-class SynonymsTest < Minitest::Test
-  def test_bleach
-    store_names ["Clorox Bleach", "Kroger Bleach"]
-    assert_search "clorox", ["Clorox Bleach", "Kroger Bleach"]
-  end
-
-  def test_saran_wrap
-    store_names ["Saran Wrap", "Kroger Plastic Wrap"]
-    assert_search "saran wrap", ["Saran Wrap", "Kroger Plastic Wrap"]
-  end
-
-  def test_burger_buns
-    store_names ["Hamburger Buns"]
-    assert_search "burger buns", ["Hamburger Buns"]
-  end
-
-  def test_bandaids
-    store_names ["Band-Aid", "Kroger 12-Pack Bandages"]
-    assert_search "bandaids", ["Band-Aid", "Kroger 12-Pack Bandages"]
-  end
-
-  def test_qtips
-    store_names ["Q Tips", "Kroger Cotton Swabs"]
-    assert_search "q tips", ["Q Tips", "Kroger Cotton Swabs"]
-  end
-
-  def test_reverse
-    store_names ["Scallions"]
-    assert_search "green onions", ["Scallions"]
-  end
-
-  def test_exact
-    store_names ["Green Onions", "Yellow Onions"]
-    assert_search "scallion", ["Green Onions"]
-  end
-
-  def test_stemmed
-    store_names ["Green Onions", "Yellow Onions"]
-    assert_search "scallions", ["Green Onions"]
-  end
-
-  def test_word_start
-    store_names ["Clorox Bleach", "Kroger Bleach"]
-    assert_search "clorox", ["Clorox Bleach", "Kroger Bleach"], fields: [{name: :word_start}]
-  end
-
-  def test_wordnet
-    skip unless ENV["TEST_WORDNET"]
-    store_names ["Creature", "Beast", "Dragon"], Animal
-    assert_search "animal", ["Creature", "Beast"], {}, Animal
-  end
-
-  def test_directional
-    store_names ["Lightbulb", "Green Onions", "Led"]
-    assert_search "led", ["Lightbulb", "Led"]
-    assert_search "Lightbulb", ["Lightbulb"]
-    assert_search "Halogen Lamp", ["Lightbulb"]
-    assert_search "onions", ["Green Onions"]
-  end
-
-  def test_case
-    store_names ["Uppercase"]
-    assert_search "lowercase", ["Uppercase"]
-  end
-end