searchkick_bharthur 0.0.1

data/test/boost_test.rb

@@ -0,0 +1,144 @@
+require_relative "test_helper"
+
+class BoostTest < Minitest::Test
+  # conversions
+
+  def test_conversions
+    store [
+      {name: "Tomato A", conversions: {"tomato" => 1}},
+      {name: "Tomato B", conversions: {"tomato" => 2}},
+      {name: "Tomato C", conversions: {"tomato" => 3}}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"]
+  end
+
+  def test_conversions_stemmed
+    store [
+      {name: "Tomato A", conversions: {"tomato" => 1, "tomatos" => 1, "Tomatoes" => 1}},
+      {name: "Tomato B", conversions: {"tomato" => 2}}
+    ]
+    assert_order "tomato", ["Tomato A", "Tomato B"]
+  end
+
+  # global boost
+
+  def test_boost
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost: "orders_count"
+  end
+
+  def test_boost_zero
+    store [
+      {name: "Zero Boost", orders_count: 0}
+    ]
+    assert_order "zero", ["Zero Boost"], boost: "orders_count"
+  end
+
+  def test_conversions_weight
+    store [
+      {name: "Product Boost", orders_count: 20},
+      {name: "Product Conversions", conversions: {"product" => 10}}
+    ]
+    assert_order "product", ["Product Conversions", "Product Boost"], boost: "orders_count"
+  end
+
+  def test_user_id
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2, 3]},
+      {name: "Tomato C"},
+      {name: "Tomato D"}
+    ]
+    assert_first "tomato", "Tomato B", user_id: 2
+  end
+
+  def test_personalize
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2, 3]},
+      {name: "Tomato C"},
+      {name: "Tomato D"}
+    ]
+    assert_first "tomato", "Tomato B", personalize: {user_ids: 2}
+  end
+
+  def test_boost_fields
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10", "color"]
+  end
+
+  def test_boost_fields_decimal
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10.5", "color"]
+  end
+
+  def test_boost_fields_word_start
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: [{"name^10" => :word_start}, "color"]
+  end
+
+  def test_boost_by
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: [:orders_count]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: {orders_count: {factor: 10}}
+  end
+
+  def test_boost_by_boost_mode_multiply
+    store [
+      {name: "Tomato A", found_rate: 0.9},
+      {name: "Tomato B"},
+      {name: "Tomato C", found_rate: 0.5}
+    ]
+
+    assert_order "tomato", ["Tomato B", "Tomato A", "Tomato C"], boost_by: {found_rate: {boost_mode: "multiply"}}
+  end
+
+  def test_boost_where
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2]},
+      {name: "Tomato C", user_ids: [3]}
+    ]
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: 2}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: 1..2}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: [1, 4]}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: 2, factor: 10}}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: [1, 4], factor: 10}}
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_where: {user_ids: [{value: 1, factor: 10}, {value: 3, factor: 20}]}
+  end
+
+  def test_boost_by_distance
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: [37, -122], scale: "1000mi"}
+  end
+
+  def test_boost_by_distance_hash
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: {lat: 37, lon: -122}, scale: "1000mi"}
+  end
+end

data/test/callbacks_test.rb

@@ -0,0 +1,27 @@
+require_relative "test_helper"
+
+class CallbacksTest < Minitest::Test
+  def test_true_create
+    Searchkick.callbacks(true) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"]
+  end
+
+  def test_false_create
+    Searchkick.callbacks(false) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", []
+  end
+
+  def test_bulk_create
+    Searchkick.callbacks(:bulk) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"]
+  end
+end

data/test/ci/before_install.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+gem install bundler
+
+sudo apt-get purge elasticsearch
+if [[ $ELASTICSEARCH_VERSION == 1* ]]; then
+  wget https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-$ELASTICSEARCH_VERSION.deb
+else
+  wget https://download.elastic.co/elasticsearch/release/org/elasticsearch/distribution/deb/elasticsearch/$ELASTICSEARCH_VERSION/elasticsearch-$ELASTICSEARCH_VERSION.deb
+fi
+sudo dpkg -i elasticsearch-$ELASTICSEARCH_VERSION.deb
+sudo service elasticsearch start
+
+if [ -n "$NOBRAINER" ]; then
+  source /etc/lsb-release && echo "deb http://download.rethinkdb.com/apt $DISTRIB_CODENAME main" | sudo tee /etc/apt/sources.list.d/rethinkdb.list
+  wget -qO- http://download.rethinkdb.com/apt/pubkey.gpg | sudo apt-key add -
+  sudo apt-get update -q
+  sudo apt-get install rethinkdb
+  sudo cp /etc/rethinkdb/default.conf.sample /etc/rethinkdb/instances.d/instance1.conf
+  sudo service rethinkdb restart
+fi

data/test/dangerous_reindex_test.rb

@@ -0,0 +1,27 @@
+require_relative "test_helper"
+
+class DangerousReindexTest < Minitest::Test
+  def setup
+    skip if mongoid2? || nobrainer? || activerecord_below41?
+    super
+  end
+
+  def test_dangerous_reindex
+    assert_raises(Searchkick::DangerousOperation) { Product.where(id: [1, 2, 3]).reindex }
+  end
+
+  def test_dangerous_index_associations
+    Store.create!(name: "Test")
+    assert_raises(Searchkick::DangerousOperation) { Store.first.products.reindex }
+  end
+
+  def test_dangerous_reindex_accepted
+    store_names ["Product A", "Product B"]
+    Product.where(name: "Product A").reindex(accept_danger: true)
+    assert_search "product", ["Product A"]
+  end
+
+  def test_dangerous_reindex_inheritance
+    assert_raises(Searchkick::DangerousOperation) { Dog.where(id: [1, 2, 3]).reindex }
+  end
+end

data/test/facets_test.rb

@@ -0,0 +1,90 @@
+require_relative "test_helper"
+
+class FacetsTest < Minitest::Test
+  def setup
+    skip unless elasticsearch_below20?
+    super
+    store [
+      {name: "Product Show", latitude: 37.7833, longitude: 12.4167, store_id: 1, in_stock: true, color: "blue", price: 21, created_at: 2.days.ago},
+      {name: "Product Hide", latitude: 29.4167, longitude: -98.5000, store_id: 2, in_stock: false, color: "green", price: 25, created_at: 2.days.from_now},
+      {name: "Product B", latitude: 43.9333, longitude: -122.4667, store_id: 2, in_stock: false, color: "red", price: 5},
+      {name: "Foo", latitude: 43.9333, longitude: 12.4667, store_id: 3, in_stock: false, color: "yellow", price: 15}
+    ]
+  end
+
+  def test_basic
+    assert_equal ({1 => 1, 2 => 2}), store_facet(facets: [:store_id])
+  end
+
+  def test_where
+    assert_equal ({1 => 1}), store_facet(facets: {store_id: {where: {in_stock: true}}})
+  end
+
+  def test_field
+    assert_equal ({1 => 1, 2 => 2}), store_facet(facets: {store_id: {}})
+    assert_equal ({1 => 1, 2 => 2}), store_facet(facets: {store_id: {field: "store_id"}})
+    assert_equal ({1 => 1, 2 => 2}), store_facet({facets: {store_id_new: {field: "store_id"}}}, "store_id_new")
+  end
+
+  def test_limit
+    facet = Product.search("Product", facets: {store_id: {limit: 1}}).facets["store_id"]
+    assert_equal 1, facet["terms"].size
+    assert_equal 3, facet["total"]
+    assert_equal 1, facet["other"]
+  end
+
+  def test_ranges
+    price_ranges = [{to: 10}, {from: 10, to: 20}, {from: 20}]
+    facet = Product.search("Product", facets: {price: {ranges: price_ranges}}).facets["price"]
+
+    assert_equal 3, facet["ranges"].size
+    assert_equal 10.0, facet["ranges"][0]["to"]
+    assert_equal 20.0, facet["ranges"][2]["from"]
+    assert_equal 1, facet["ranges"][0]["count"]
+    assert_equal 0, facet["ranges"][1]["count"]
+    assert_equal 2, facet["ranges"][2]["count"]
+  end
+
+  def test_ranges_dates
+    ranges = [{to: 1.day.ago}, {from: 1.day.ago, to: 1.day.from_now}, {from: 1.day.from_now}]
+    facet = Product.search("Product", facets: {created_at: {ranges: ranges}}).facets["created_at"]
+
+    assert_equal 1, facet["ranges"][0]["count"]
+    assert_equal 1, facet["ranges"][1]["count"]
+    assert_equal 1, facet["ranges"][2]["count"]
+  end
+
+  def test_where_no_smart_facets
+    assert_equal ({2 => 2}), store_facet(where: {color: "red"}, facets: {store_id: {where: {in_stock: false}}})
+  end
+
+  def test_smart_facets
+    assert_equal ({1 => 1}), store_facet(where: {in_stock: true}, facets: [:store_id], smart_facets: true)
+  end
+
+  def test_smart_facets_where
+    assert_equal ({2 => 1}), store_facet(where: {color: "red"}, facets: {store_id: {where: {in_stock: false}}}, smart_facets: true)
+  end
+
+  def test_smart_facets_skip_facet
+    assert_equal ({1 => 1, 2 => 2}), store_facet(where: {store_id: 2}, facets: [:store_id], smart_facets: true)
+  end
+
+  def test_smart_facets_skip_facet_complex
+    assert_equal ({1 => 1, 2 => 1}), store_facet(where: {store_id: 2, price: {gt: 5}}, facets: [:store_id], smart_facets: true)
+  end
+
+  def test_stats_facets
+    skip if Gem::Version.new(Searchkick.server_version) >= Gem::Version.new("1.4.0")
+    options = {where: {store_id: 2}, facets: {store_id: {stats: true}}}
+    facets = Product.search("Product", options).facets["store_id"]["terms"]
+    expected_facets_keys = %w(term count total_count min max total mean)
+    assert_equal expected_facets_keys, facets.first.keys
+  end
+
+  protected
+
+  def store_facet(options, facet_key = "store_id")
+    Hash[Product.search("Product", options).facets[facet_key]["terms"].map { |v| [v["term"], v["count"]] }]
+  end
+end

data/test/gemfiles/activerecord31.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 3.1.0"

data/test/gemfiles/activerecord32.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 3.2.0"

data/test/gemfiles/activerecord40.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.0.0"
+gem "activejob_backport"

data/test/gemfiles/activerecord41.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.1.0"
+gem "activejob_backport"

data/test/gemfiles/activerecord50.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 5.0.0.rc1"

data/test/gemfiles/apartment.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "sqlite3"
+gem "activerecord", "~> 4.2.0"
+gem "apartment"

data/test/gemfiles/mongoid2.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 2"
+gem "bson_ext"

data/test/gemfiles/mongoid3.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 3.1.0"

data/test/gemfiles/mongoid4.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 4.0.0"
+gem "activejob_backport"

data/test/gemfiles/mongoid5.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "mongoid", "~> 5.0.0"
+gem "activejob_backport"

data/test/gemfiles/nobrainer.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in searchkick.gemspec
+gemspec path: "../../"
+
+gem "nobrainer", "0.27.0"

data/test/highlight_test.rb

@@ -0,0 +1,63 @@
+require_relative "test_helper"
+
+class HighlightTest < Minitest::Test
+  def test_basic
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <em>Cinema</em> Club", Product.search("cinema", fields: [:name], highlight: true).with_details.first[1][:highlight][:name]
+  end
+
+  def test_tag
+    store_names ["Two Door Cinema Club"]
+    assert_equal "Two Door <strong>Cinema</strong> Club", Product.search("cinema", fields: [:name], highlight: {tag: "<strong>"}).with_details.first[1][:highlight][:name]
+  end
+
+  def test_multiple_fields
+    store [{name: "Two Door Cinema Club", color: "Cinema Orange"}]
+    highlight = Product.search("cinema", fields: [:name, :color], highlight: true).with_details.first[1][:highlight]
+    assert_equal "Two Door <em>Cinema</em> Club", highlight[:name]
+    assert_equal "<em>Cinema</em> Orange", highlight[:color]
+  end
+
+  def test_fields
+    store [{name: "Two Door Cinema Club", color: "Cinema Orange"}]
+    highlight = Product.search("cinema", fields: [:name, :color], highlight: {fields: [:name]}).with_details.first[1][:highlight]
+    assert_equal "Two Door <em>Cinema</em> Club", highlight[:name]
+    assert_equal nil, highlight[:color]
+  end
+
+  def test_field_options
+    store_names ["Two Door Cinema Club are a Northern Irish indie rock band"]
+    fragment_size = ENV["MATCH"] == "word_start" ? 26 : 20
+    assert_equal "Two Door <em>Cinema</em> Club are", Product.search("cinema", fields: [:name], highlight: {fields: {name: {fragment_size: fragment_size}}}).with_details.first[1][:highlight][:name]
+  end
+
+  def test_multiple_words
+    store_names ["Hello World Hello"]
+    assert_equal "<em>Hello</em> World <em>Hello</em>", Product.search("hello", fields: [:name], highlight: true).with_details.first[1][:highlight][:name]
+  end
+
+  def test_encoder
+    store_names ["<b>Hello</b>"]
+    assert_equal "&lt;b&gt;<em>Hello</em>&lt;&#x2F;b&gt;", Product.search("hello", fields: [:name], highlight: {encoder: "html"}, misspellings: false).with_details.first[1][:highlight][:name]
+  end
+
+  def test_json
+    skip if ENV["MATCH"] == "word_start"
+    store_names ["Two Door Cinema Club"]
+    json = {
+      query: {
+        match: {
+          "name.analyzed" => "cinema"
+        }
+      },
+      highlight: {
+        pre_tags: ["<strong>"],
+        post_tags: ["</strong>"],
+        fields: {
+          "name.analyzed" => {}
+        }
+      }
+    }
+    assert_equal "Two Door <strong>Cinema</strong> Club", Product.search(json: json).with_details.first[1][:highlight][:"name.analyzed"]
+  end
+end

data/test/index_test.rb

@@ -0,0 +1,120 @@
+require_relative "test_helper"
+
+class IndexTest < Minitest::Test
+  def test_clean_indices
+    old_index = Searchkick::Index.new("products_test_20130801000000000")
+    different_index = Searchkick::Index.new("items_test_20130801000000000")
+
+    old_index.delete if old_index.exists?
+    different_index.delete if different_index.exists?
+
+    # create indexes
+    old_index.create
+    different_index.create
+
+    Product.clean_indices
+
+    assert Product.searchkick_index.exists?
+    assert different_index.exists?
+    assert !old_index.exists?
+  end
+
+  def test_clean_indices_old_format
+    old_index = Searchkick::Index.new("products_test_20130801000000")
+    old_index.create
+
+    Product.clean_indices
+
+    assert !old_index.exists?
+  end
+
+  def test_mapping
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(query: {match: {name: "Dollar Tree"}}).map(&:name)
+  end
+
+  def test_json
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(json: {query: {match: {name: "Dollar Tree"}}}, load: false).map(&:name)
+  end
+
+  def test_body
+    store_names ["Dollar Tree"], Store
+    assert_equal [], Store.search(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_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")
+  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_search "product", ["Product B"]
+  ensure
+    Product.reindex
+  end
+
+  def test_bad_mapping
+    Product.searchkick_index.delete
+    store_names ["Product A"]
+    assert_raises(Searchkick::InvalidQueryError) { Product.search "test" }
+  ensure
+    Product.reindex
+  end
+
+  def test_remove_blank_id
+    store_names ["Product A"]
+    Product.searchkick_index.remove(OpenStruct.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.new("[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_query
+    assert_raises(Searchkick::InvalidQueryError) { Product.search(query: {boom: true}) }
+  end
+
+  def test_transaction
+    skip unless defined?(ActiveRecord)
+    Product.transaction do
+      store_names ["Product A"]
+      raise ActiveRecord::Rollback
+    end
+    assert_search "product", []
+  end
+
+  def test_analyzed_only
+    skip if nobrainer?
+    large_value = 10000.times.map { "hello" }.join(" ")
+    store [{name: "Product A", alt_description: large_value}]
+    assert_search "product", ["Product A"]
+  end
+end

data/test/inheritance_test.rb

@@ -0,0 +1,78 @@
+require_relative "test_helper"
+
+class InheritanceTest < Minitest::Test
+  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], autocomplete: true).map(&:name)
+  end
+
+  def test_parent_autocomplete
+    store_names ["Max"], Cat
+    store_names ["Bear"], Dog
+    assert_equal ["Bear"], Animal.search("bea", fields: [:name], autocomplete: true).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