searchkick-hooopo 2.3.0

data/test/reindex_v2_job_test.rb

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

@@ -0,0 +1,23 @@
+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", ["Dollar Tree"], {routing: "Dollar Tree"}, Store
+  end
+
+  def test_routing_incorrect_node
+    store_names ["Dollar Tree"], Store
+    assert_search "dollar", ["Dollar Tree"], {routing: "Boom"}, Store
+  end
+end

data/test/should_index_test.rb

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

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

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

data/test/suggest_test.rb

@@ -0,0 +1,85 @@
+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
+
+  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/synonyms_test.rb

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