Merge branch 'master' into reindex_refactor

Andrew Kane
2 parents 0e3ddf8b ca27d8e4
Showing 9 changed files with 141 additions and 102 deletions Show diff stats
.travis.yml
lib/searchkick.rb
lib/searchkick/index_options.rb
test/callbacks_test.rb
test/gemfiles/activerecord50.gemfile
test/gemfiles/activerecord51.gemfile
test/gemfiles/activerecord52.gemfile
test/reindex_test.rb
test/test_helper.rb
 dist: bionic
 language: ruby
-rvm: 2.6
 gemfile:
   - Gemfile
 services:
@@ -18,20 +17,26 @@ cache:
 env:
   - ELASTICSEARCH_VERSION=7.6.1
 jdk: openjdk10
-matrix:
+jobs:
   include:
-    - gemfile: Gemfile
-    - gemfile: test/gemfiles/activerecord52.gemfile
+    - rvm: 2.7
+      gemfile: Gemfile
+    - rvm: 2.6
+      gemfile: test/gemfiles/activerecord52.gemfile
       env: ELASTICSEARCH_VERSION=7.0.0
-    - gemfile: test/gemfiles/activerecord51.gemfile
+    - rvm: 2.5
+      gemfile: test/gemfiles/activerecord51.gemfile
       env: ELASTICSEARCH_VERSION=6.8.7
-    - gemfile: test/gemfiles/activerecord50.gemfile
+    - rvm: 2.4
+      gemfile: test/gemfiles/activerecord50.gemfile
       env: ELASTICSEARCH_VERSION=6.0.0
-    - gemfile: test/gemfiles/mongoid7.gemfile
+    - rvm: 2.7
+      gemfile: test/gemfiles/mongoid7.gemfile
       services:
         - mongodb
         - redis-server
-    - gemfile: test/gemfiles/mongoid6.gemfile
+    - rvm: 2.6
+      gemfile: test/gemfiles/mongoid6.gemfile
       services:
         - mongodb
         - redis-server
+# dependencies
 require "active_support"
 require "active_support/core_ext/hash/deep_merge"
 require "elasticsearch"
 require "hashie"
+# modules
 require "searchkick/bulk_indexer"
 require "searchkick/index"
 require "searchkick/indexer"
@@ -17,6 +19,7 @@ require &quot;searchkick/record_indexer&quot;
 require "searchkick/results"
 require "searchkick/version"
+# integrations
 require "searchkick/railtie" if defined?(Rails)
 require "searchkick/logging" if defined?(ActiveSupport::Notifications)
@@ -27,6 +30,7 @@ module Searchkick
   autoload :ProcessQueueJob, "searchkick/process_queue_job"
   autoload :ReindexV2Job,    "searchkick/reindex_v2_job"
+  # errors
   class Error < StandardError; end
   class MissingIndexError < Error; end
   class UnsupportedVersionError < Error; end
@@ -27,9 +27,6 @@ module Searchkick
         default_analyzer = :searchkick_index
         keyword_mapping = {type: "keyword"}
-        index_true_value = true
-        index_false_value = false
-
         keyword_mapping[:ignore_above] = options[:ignore_above] || 30000
         settings = {
@@ -356,13 +353,13 @@ module Searchkick
         mapping_options[:searchable].delete("_all")
-        analyzed_field_options = {type: default_type, index: index_true_value, analyzer: default_analyzer}
+        analyzed_field_options = {type: default_type, index: true, analyzer: default_analyzer}
         mapping_options.values.flatten.uniq.each do |field|
           fields = {}
           if options.key?(:filterable) && !mapping_options[:filterable].include?(field)
-            fields[field] = {type: default_type, index: index_false_value}
+            fields[field] = {type: default_type, index: false}
           else
             fields[field] = keyword_mapping
           end
@@ -378,7 +375,7 @@ module Searchkick
             mapping_options.except(:highlight, :searchable, :filterable, :word).each do |type, f|
               if options[:match] == type || f.include?(field)
-                fields[type] = {type: default_type, index: index_true_value, analyzer: "searchkick_#{type}_index"}
+                fields[type] = {type: default_type, index: true, analyzer: "searchkick_#{type}_index"}
               end
             end
           end
@@ -418,12 +415,12 @@ module Searchkick
         }
         if options.key?(:filterable)
-          dynamic_fields["{name}"] = {type: default_type, index: index_false_value}
+          dynamic_fields["{name}"] = {type: default_type, index: false}
         end
         unless options[:searchable]
           if options[:match] && options[:match] != :word
-            dynamic_fields[options[:match]] = {type: default_type, index: index_true_value, analyzer: "searchkick_#{options[:match]}_index"}
+            dynamic_fields[options[:match]] = {type: default_type, index: true, analyzer: "searchkick_#{options[:match]}_index"}
           end
           if word
@@ -1,59 +0,0 @@
-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
-
-  def test_queue
-    skip unless defined?(ActiveJob) && defined?(Redis)
-
-    reindex_queue = Product.searchkick_index.reindex_queue
-    reindex_queue.clear
-
-    Searchkick.callbacks(:queue) do
-      store_names ["Product A", "Product B"]
-    end
-    Product.searchkick_index.refresh
-    assert_search "product", [], load: false, conversions: false
-    assert_equal 2, reindex_queue.length
-
-    Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
-    Product.searchkick_index.refresh
-    assert_search "product", ["Product A", "Product B"], load: false
-    assert_equal 0, reindex_queue.length
-
-    Searchkick.callbacks(:queue) do
-      Product.where(name: "Product B").destroy_all
-      Product.create!(name: "Product C")
-    end
-    Product.searchkick_index.refresh
-    assert_search "product", ["Product A", "Product B"], load: false
-    assert_equal 2, reindex_queue.length
-
-    Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
-    Product.searchkick_index.refresh
-    assert_search "product", ["Product A", "Product C"], load: false
-    assert_equal 0, reindex_queue.length
-  end
-end
@@ -6,3 +6,4 @@ gemspec path: &quot;../../&quot;
 gem "sqlite3", "~> 1.3.0"
 gem "activerecord", "~> 5.0.0"
 gem "actionpack", "~> 5.0.0"
+gem "activejob", "~> 5.0.0", require: "active_job"
@@ -6,3 +6,4 @@ gemspec path: &quot;../../&quot;
 gem "sqlite3"
 gem "activerecord", "~> 5.1.0"
 gem "actionpack", "~> 5.1.0"
+gem "activejob", "~> 5.1.0", require: "active_job"
@@ -6,3 +6,4 @@ gemspec path: &quot;../../&quot;
 gem "sqlite3"
 gem "activerecord", "~> 5.2.0"
 gem "actionpack", "~> 5.2.0"
+gem "activejob", "~> 5.2.0", require: "active_job"
 require_relative "test_helper"
 class ReindexTest < Minitest::Test
-  def setup
-    super
-    Sku.destroy_all
+  def test_record_inline
+    store_names ["Product A", "Product B"], reindex: false
+
+    product = Product.find_by!(name: "Product A")
+    product.reindex(refresh: true)
+    assert_search "product", ["Product A"]
   end
-  def test_scoped
+  def test_record_async
+    store_names ["Product A", "Product B"], reindex: false
+
+    product = Product.find_by!(name: "Product A")
+    product.reindex(mode: :async)
+    Product.search_index.refresh
+    assert_search "product", ["Product A"]
+  end
+
+  def test_record_queue
+    skip unless defined?(ActiveJob) && defined?(Redis)
+
+    reindex_queue = Product.searchkick_index.reindex_queue
+    reindex_queue.clear
+
+    store_names ["Product A", "Product B"], reindex: false
+
+    product = Product.find_by!(name: "Product A")
+    product.reindex(mode: :queue)
+    Product.search_index.refresh
+    assert_search "product", []
+
+    Searchkick::ProcessQueueJob.perform_now(class_name: "Product")
+    Product.search_index.refresh
+    assert_search "product", ["Product A"]
+  end
+
+  def test_relation_inline
     skip if nobrainer? || cequel?
     store_names ["Product A"]
-    Searchkick.callbacks(false) do
-      store_names ["Product B", "Product C"]
-    end
+    store_names ["Product B", "Product C"], reindex: false
     Product.where(name: "Product B").reindex(refresh: true)
     assert_search "product", ["Product A", "Product B"]
   end
-  def test_associations
+  def test_relation_associations
     skip if nobrainer? || cequel?
     store_names ["Product A"]
@@ -27,12 +55,18 @@ class ReindexTest &lt; Minitest::Test
     assert_search "product", ["Product A", "Product B"]
   end
-  def test_async
+  def test_relation_async
+    skip "Not available yet"
+  end
+
+  def test_relation_queue
+    skip "Not available yet"
+  end
+
+  def test_full_async
     skip unless defined?(ActiveJob)
-    Searchkick.callbacks(false) do
-      store_names ["Product A"]
-    end
+    store_names ["Product A"], reindex: false
     reindex = Product.reindex(async: true)
     assert_search "product", [], conversions: false
@@ -48,12 +82,10 @@ class ReindexTest &lt; Minitest::Test
     assert_search "product", ["Product A"]
   end
-  def test_async_wait
+  def test_full_async_wait
     skip unless defined?(ActiveJob) && defined?(Redis)
-    Searchkick.callbacks(false) do
-      store_names ["Product A"]
-    end
+    store_names ["Product A"], reindex: false
     capture_io do
       Product.reindex(async: {wait: true})
@@ -62,7 +94,7 @@ class ReindexTest &lt; Minitest::Test
     assert_search "product", ["Product A"]
   end
-  def test_async_non_integer_pk
+  def test_full_async_non_integer_pk
     skip unless defined?(ActiveJob)
     Sku.create(id: SecureRandom.hex, name: "Test")
@@ -72,9 +104,11 @@ class ReindexTest &lt; Minitest::Test
     index = Searchkick::Index.new(reindex[:index_name])
     index.refresh
     assert_equal 1, index.total_docs
+  ensure
+    Sku.destroy_all
   end
-  def test_refresh_interval
+  def test_full_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
@@ -85,17 +119,64 @@ class ReindexTest &lt; Minitest::Test
     assert_equal "1s", Product.search_index.refresh_interval
   end
-  def test_resume
+  def test_full_resume
     assert Product.reindex(resume: true)
   end
-  def test_refresh_full_reindex
+  def test_full_refresh
     Product.reindex(refresh: true)
   end
-  def test_partial_async
+  def test_full_partial_async
     store_names ["Product A"]
     # warn for now
     Product.reindex(:search_name, async: true)
   end
+
+  def test_callbacks_false
+    Searchkick.callbacks(false) do
+      store_names ["Product A", "Product B"]
+    end
+    assert_search "product", []
+  end
+
+  def test_callbacks_bulk
+    Searchkick.callbacks(:bulk) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.search_index.refresh
+    assert_search "product", ["Product A", "Product B"]
+  end
+
+  def test_callbacks_queue
+    skip unless defined?(ActiveJob) && defined?(Redis)
+
+    reindex_queue = Product.searchkick_index.reindex_queue
+    reindex_queue.clear
+
+    Searchkick.callbacks(:queue) do
+      store_names ["Product A", "Product B"]
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", [], load: false, conversions: false
+    assert_equal 2, reindex_queue.length
+
+    Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"], load: false
+    assert_equal 0, reindex_queue.length
+
+    Searchkick.callbacks(:queue) do
+      Product.where(name: "Product B").destroy_all
+      Product.create!(name: "Product C")
+    end
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product B"], load: false
+    assert_equal 2, reindex_queue.length
+
+    Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
+    Product.searchkick_index.refresh
+    assert_search "product", ["Product A", "Product C"], load: false
+    assert_equal 0, reindex_queue.length
+  end
 end
@@ -71,15 +71,23 @@ class Minitest::Test
   protected
-  def store(documents, klass = Product)
-    documents.shuffle.each do |document|
-      klass.create!(document)
+  def store(documents, klass = Product, reindex: true)
+    if reindex
+      documents.shuffle.each do |document|
+        klass.create!(document)
+      end
+      klass.searchkick_index.refresh
+    else
+      Searchkick.callbacks(false) do
+        documents.shuffle.each do |document|
+          klass.create!(document)
+        end
+      end
     end
-    klass.searchkick_index.refresh
   end
-  def store_names(names, klass = Product)
-    store names.map { |name| {name: name} }, klass
+  def store_names(names, klass = Product, reindex: true)
+    store names.map { |name| {name: name} }, klass, reindex: reindex
   end
   # no order
	@@ -1,59 +0,0 @@	@@ -1,59 +0,0 @@
1	-require_relative "test_helper"
2	-
3	-class CallbacksTest < Minitest::Test
4	- def test_true_create
5	- Searchkick.callbacks(true) do
6	- store_names ["Product A", "Product B"]
7	- end
8	- Product.searchkick_index.refresh
9	- assert_search "product", ["Product A", "Product B"]
10	- end
11	-
12	- def test_false_create
13	- Searchkick.callbacks(false) do
14	- store_names ["Product A", "Product B"]
15	- end
16	- Product.searchkick_index.refresh
17	- assert_search "product", []
18	- end
19	-
20	- def test_bulk_create
21	- Searchkick.callbacks(:bulk) do
22	- store_names ["Product A", "Product B"]
23	- end
24	- Product.searchkick_index.refresh
25	- assert_search "product", ["Product A", "Product B"]
26	- end
27	-
28	- def test_queue
29	- skip unless defined?(ActiveJob) && defined?(Redis)
30	-
31	- reindex_queue = Product.searchkick_index.reindex_queue
32	- reindex_queue.clear
33	-
34	- Searchkick.callbacks(:queue) do
35	- store_names ["Product A", "Product B"]
36	- end
37	- Product.searchkick_index.refresh
38	- assert_search "product", [], load: false, conversions: false
39	- assert_equal 2, reindex_queue.length
40	-
41	- Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
42	- Product.searchkick_index.refresh
43	- assert_search "product", ["Product A", "Product B"], load: false
44	- assert_equal 0, reindex_queue.length
45	-
46	- Searchkick.callbacks(:queue) do
47	- Product.where(name: "Product B").destroy_all
48	- Product.create!(name: "Product C")
49	- end
50	- Product.searchkick_index.refresh
51	- assert_search "product", ["Product A", "Product B"], load: false
52	- assert_equal 2, reindex_queue.length
53	-
54	- Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
55	- Product.searchkick_index.refresh
56	- assert_search "product", ["Product A", "Product C"], load: false
57	- assert_equal 0, reindex_queue.length
58	- end
59	-end
	@@ -6,3 +6,4 @@ gemspec path: "../../"		@@ -6,3 +6,4 @@ gemspec path: "../../"
6	gem "sqlite3", "~> 1.3.0"	6	gem "sqlite3", "~> 1.3.0"
7	gem "activerecord", "~> 5.0.0"	7	gem "activerecord", "~> 5.0.0"
8	gem "actionpack", "~> 5.0.0"	8	gem "actionpack", "~> 5.0.0"
		9	+gem "activejob", "~> 5.0.0", require: "active_job"
	@@ -6,3 +6,4 @@ gemspec path: "../../"		@@ -6,3 +6,4 @@ gemspec path: "../../"
6	gem "sqlite3"	6	gem "sqlite3"
7	gem "activerecord", "~> 5.1.0"	7	gem "activerecord", "~> 5.1.0"
8	gem "actionpack", "~> 5.1.0"	8	gem "actionpack", "~> 5.1.0"
		9	+gem "activejob", "~> 5.1.0", require: "active_job"
1	require_relative "test_helper"	1	require_relative "test_helper"
2		2
3	class ReindexTest < Minitest::Test	3	class ReindexTest < Minitest::Test
4	- def setup
5	- super
6	- Sku.destroy_all	4	+ def test_record_inline
		5	+ store_names ["Product A", "Product B"], reindex: false
		6	+
		7	+ product = Product.find_by!(name: "Product A")
		8	+ product.reindex(refresh: true)
		9	+ assert_search "product", ["Product A"]
7	end	10	end
8		11
9	- def test_scoped	12	+ def test_record_async
		13	+ store_names ["Product A", "Product B"], reindex: false
		14	+
		15	+ product = Product.find_by!(name: "Product A")
		16	+ product.reindex(mode: :async)
		17	+ Product.search_index.refresh
		18	+ assert_search "product", ["Product A"]
		19	+ end
		20	+
		21	+ def test_record_queue
		22	+ skip unless defined?(ActiveJob) && defined?(Redis)
		23	+
		24	+ reindex_queue = Product.searchkick_index.reindex_queue
		25	+ reindex_queue.clear
		26	+
		27	+ store_names ["Product A", "Product B"], reindex: false
		28	+
		29	+ product = Product.find_by!(name: "Product A")
		30	+ product.reindex(mode: :queue)
		31	+ Product.search_index.refresh
		32	+ assert_search "product", []
		33	+
		34	+ Searchkick::ProcessQueueJob.perform_now(class_name: "Product")
		35	+ Product.search_index.refresh
		36	+ assert_search "product", ["Product A"]
		37	+ end
		38	+
		39	+ def test_relation_inline
10	skip if nobrainer? \|\| cequel?	40	skip if nobrainer? \|\| cequel?
11		41
12	store_names ["Product A"]	42	store_names ["Product A"]
13	- Searchkick.callbacks(false) do
14	- store_names ["Product B", "Product C"]
15	- end	43	+ store_names ["Product B", "Product C"], reindex: false
16	Product.where(name: "Product B").reindex(refresh: true)	44	Product.where(name: "Product B").reindex(refresh: true)
17	assert_search "product", ["Product A", "Product B"]	45	assert_search "product", ["Product A", "Product B"]
18	end	46	end
19		47
20	- def test_associations	48	+ def test_relation_associations
21	skip if nobrainer? \|\| cequel?	49	skip if nobrainer? \|\| cequel?
22		50
23	store_names ["Product A"]	51	store_names ["Product A"]
	@@ -27,12 +55,18 @@ class ReindexTest < Minitest::Test		@@ -27,12 +55,18 @@ class ReindexTest < Minitest::Test
27	assert_search "product", ["Product A", "Product B"]	55	assert_search "product", ["Product A", "Product B"]
28	end	56	end
29		57
30	- def test_async	58	+ def test_relation_async
		59	+ skip "Not available yet"
		60	+ end
		61	+
		62	+ def test_relation_queue
		63	+ skip "Not available yet"
		64	+ end
		65	+
		66	+ def test_full_async
31	skip unless defined?(ActiveJob)	67	skip unless defined?(ActiveJob)
32		68
33	- Searchkick.callbacks(false) do
34	- store_names ["Product A"]
35	- end	69	+ store_names ["Product A"], reindex: false
36	reindex = Product.reindex(async: true)	70	reindex = Product.reindex(async: true)
37	assert_search "product", [], conversions: false	71	assert_search "product", [], conversions: false
38		72
	@@ -48,12 +82,10 @@ class ReindexTest < Minitest::Test		@@ -48,12 +82,10 @@ class ReindexTest < Minitest::Test
48	assert_search "product", ["Product A"]	82	assert_search "product", ["Product A"]
49	end	83	end
50		84
51	- def test_async_wait	85	+ def test_full_async_wait
52	skip unless defined?(ActiveJob) && defined?(Redis)	86	skip unless defined?(ActiveJob) && defined?(Redis)
53		87
54	- Searchkick.callbacks(false) do
55	- store_names ["Product A"]
56	- end	88	+ store_names ["Product A"], reindex: false
57		89
58	capture_io do	90	capture_io do
59	Product.reindex(async: {wait: true})	91	Product.reindex(async: {wait: true})
	@@ -62,7 +94,7 @@ class ReindexTest < Minitest::Test		@@ -62,7 +94,7 @@ class ReindexTest < Minitest::Test
62	assert_search "product", ["Product A"]	94	assert_search "product", ["Product A"]
63	end	95	end
64		96
65	- def test_async_non_integer_pk	97	+ def test_full_async_non_integer_pk
66	skip unless defined?(ActiveJob)	98	skip unless defined?(ActiveJob)
67		99
68	Sku.create(id: SecureRandom.hex, name: "Test")	100	Sku.create(id: SecureRandom.hex, name: "Test")
	@@ -72,9 +104,11 @@ class ReindexTest < Minitest::Test		@@ -72,9 +104,11 @@ class ReindexTest < Minitest::Test
72	index = Searchkick::Index.new(reindex[:index_name])	104	index = Searchkick::Index.new(reindex[:index_name])
73	index.refresh	105	index.refresh
74	assert_equal 1, index.total_docs	106	assert_equal 1, index.total_docs
		107	+ ensure
		108	+ Sku.destroy_all
75	end	109	end
76		110
77	- def test_refresh_interval	111	+ def test_full_refresh_interval
78	reindex = Product.reindex(refresh_interval: "30s", async: true, import: false)	112	reindex = Product.reindex(refresh_interval: "30s", async: true, import: false)
79	index = Searchkick::Index.new(reindex[:index_name])	113	index = Searchkick::Index.new(reindex[:index_name])
80	assert_nil Product.search_index.refresh_interval	114	assert_nil Product.search_index.refresh_interval
	@@ -85,17 +119,64 @@ class ReindexTest < Minitest::Test		@@ -85,17 +119,64 @@ class ReindexTest < Minitest::Test
85	assert_equal "1s", Product.search_index.refresh_interval	119	assert_equal "1s", Product.search_index.refresh_interval
86	end	120	end
87		121
88	- def test_resume	122	+ def test_full_resume
89	assert Product.reindex(resume: true)	123	assert Product.reindex(resume: true)
90	end	124	end
91		125
92	- def test_refresh_full_reindex	126	+ def test_full_refresh
93	Product.reindex(refresh: true)	127	Product.reindex(refresh: true)
94	end	128	end
95		129
96	- def test_partial_async	130	+ def test_full_partial_async
97	store_names ["Product A"]	131	store_names ["Product A"]
98	# warn for now	132	# warn for now
99	Product.reindex(:search_name, async: true)	133	Product.reindex(:search_name, async: true)
100	end	134	end
		135	+
		136	+ def test_callbacks_false
		137	+ Searchkick.callbacks(false) do
		138	+ store_names ["Product A", "Product B"]
		139	+ end
		140	+ assert_search "product", []
		141	+ end
		142	+
		143	+ def test_callbacks_bulk
		144	+ Searchkick.callbacks(:bulk) do
		145	+ store_names ["Product A", "Product B"]
		146	+ end
		147	+ Product.search_index.refresh
		148	+ assert_search "product", ["Product A", "Product B"]
		149	+ end
		150	+
		151	+ def test_callbacks_queue
		152	+ skip unless defined?(ActiveJob) && defined?(Redis)
		153	+
		154	+ reindex_queue = Product.searchkick_index.reindex_queue
		155	+ reindex_queue.clear
		156	+
		157	+ Searchkick.callbacks(:queue) do
		158	+ store_names ["Product A", "Product B"]
		159	+ end
		160	+ Product.searchkick_index.refresh
		161	+ assert_search "product", [], load: false, conversions: false
		162	+ assert_equal 2, reindex_queue.length
		163	+
		164	+ Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
		165	+ Product.searchkick_index.refresh
		166	+ assert_search "product", ["Product A", "Product B"], load: false
		167	+ assert_equal 0, reindex_queue.length
		168	+
		169	+ Searchkick.callbacks(:queue) do
		170	+ Product.where(name: "Product B").destroy_all
		171	+ Product.create!(name: "Product C")
		172	+ end
		173	+ Product.searchkick_index.refresh
		174	+ assert_search "product", ["Product A", "Product B"], load: false
		175	+ assert_equal 2, reindex_queue.length
		176	+
		177	+ Searchkick::ProcessQueueJob.perform_later(class_name: "Product")
		178	+ Product.searchkick_index.refresh
		179	+ assert_search "product", ["Product A", "Product C"], load: false
		180	+ assert_equal 0, reindex_queue.length
		181	+ end
101	end	182	end