search_flip 1.1.0 → 2.0.0.beta

data/lib/search_flip/model.rb

@@ -8,7 +8,7 @@ module SearchFlip
     module ClassMethods
       def notifies_index(index)
         if respond_to?(:after_commit)
-          after_commit { |record| record.destroyed? ? index.delete(record) : index.import(record)}
+          after_commit { |record| record.destroyed? ? index.delete(record) : index.import(record) }
         else
           after_save { |record| index.import(record) }
           after_touch { |record| index.import(record) } if respond_to?(:after_touch)

data/lib/search_flip/post_filterable.rb

@@ -42,10 +42,12 @@ module SearchFlip
     # @return [SearchFlip::Criteria] A newly created extended criteria
 
     def post_search(q, options = {})
-      raise(SearchFlip::NotSupportedError) if SearchFlip.version.to_i < 2
+      raise(SearchFlip::NotSupportedError) if target.connection.version.to_i < 2
 
       fresh.tap do |criteria|
-        criteria.post_search_values = (post_search_values || []) + [query_string: { query: q, :default_operator => :AND }.merge(options)] if q.to_s.strip.length > 0
+        if q.to_s.strip.length > 0
+          criteria.post_search_values = (post_search_values || []) + [query_string: { query: q, default_operator: :AND }.merge(options)]
+        end
       end
     end
 
@@ -105,7 +107,7 @@ module SearchFlip
     # @return [SearchFlip::Criteria] A newly created extended criteria
 
     def post_where_not(hash)
-      hash.inject(fresh) do |memo, (key,value)|
+      hash.inject(fresh) do |memo, (key, value)|
         if value.is_a?(Array)
           memo.post_must_not terms: { key => value }
         elsif value.is_a?(Range)

data/lib/search_flip/response.rb

@@ -153,7 +153,7 @@ module SearchFlip
       return nil if current_page >= total_pages
       return 1 if current_page < 1
 
-      return current_page + 1
+      current_page + 1
     end
 
     # Returns the results, ie hits, wrapped in a SearchFlip::Result object

data/lib/search_flip/version.rb

@@ -1,5 +1,5 @@
 
 module SearchFlip
-  VERSION = "1.1.0"
+  VERSION = "2.0.0.beta"
 end
 

data/search_flip.gemspec

@@ -1,7 +1,8 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'search_flip/version'
+
+require "search_flip/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "search_flip"
@@ -18,17 +19,17 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "activerecord", ">= 3.0"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "factory_bot"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "mocha"
-  spec.add_development_dependency "factory_bot"
-  spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "activerecord", ">= 3.0"
-  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sqlite3", "~> 1.3.6"
   spec.add_development_dependency "timecop"
+  spec.add_development_dependency "webmock"
 
-  spec.add_dependency "http"
   spec.add_dependency "hashie"
+  spec.add_dependency "http"
   spec.add_dependency "oj"
 end

data/test/search_flip/aggregation_test.rb

@@ -1,5 +1,5 @@
 
-require File.expand_path("../../test_helper", __FILE__)
+require File.expand_path("../test_helper", __dir__)
 
 class SearchFlip::AggregationTest < SearchFlip::TestCase
   def test_where
@@ -15,7 +15,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.where(title: "title").where(description: "description").aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_where_with_array
@@ -28,10 +29,14 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
     ProductIndex.import [product1, product2, product3, product4, product5]
 
     query = ProductIndex.aggregate(category: {}) do |aggregation|
-      aggregation.where(title: ["title1", "title2", "title3", "title4"]).where(description: ["description1", "description2", "description3"]).aggregate(:category)
+      aggregation
+        .where(title: ["title1", "title2", "title3", "title4"])
+        .where(description: ["description1", "description2", "description3"])
+        .aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_where_with_range
@@ -44,10 +49,11 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
     ProductIndex.import [product1, product2, product3, product4, product5]
 
     query = ProductIndex.aggregate(category: {}) do |aggregation|
-      aggregation.where(title: "title1" .. "title3").where(price: 100 .. 200).aggregate(:category)
+      aggregation.where(title: "title1".."title3").where(price: 100..200).aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_where_not
@@ -63,7 +69,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.where_not(title: "title4").where_not(title: "title5").aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_where_not_with_array
@@ -81,7 +88,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.where_not(title: ["title1", "title2"]).where_not(title: ["title6", "title7"]).aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_where_not_with_range
@@ -96,10 +104,11 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
     ProductIndex.import [product1, product2, product3, product4, product5, product6, product7]
 
     query = ProductIndex.aggregate(category: {}) do |aggregation|
-      aggregation.where_not(price: 100 .. 150).where_not(title: "title6" .. "title7").aggregate(:category)
+      aggregation.where_not(price: 100..150).where_not(title: "title6".."title7").aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_filter
@@ -112,10 +121,11 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
     ProductIndex.import [product1, product2, product3, product4, product5]
 
     query = ProductIndex.aggregate(category: {}) do |aggregation|
-      aggregation.filter(range: { price: { gte: 100, lte: 200 }}).filter(term: { title: "title" }).aggregate(:category)
+      aggregation.filter(range: { price: { gte: 100, lte: 200 } }).filter(term: { title: "title" }).aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_range
@@ -133,7 +143,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.range(:price, gte: 100, lte: 200).range(:title, gte: "title1", lte: "title3").aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_match_all
@@ -147,7 +158,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.match_all.aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_exists
@@ -163,7 +175,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.exists(:title).exists(:price).aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_exists_not
@@ -179,7 +192,8 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
       aggregation.exists_not(:title).exists_not(:price).aggregate(:category)
     end
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).category.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
   end
 
   def test_aggregate
@@ -193,15 +207,19 @@ class SearchFlip::AggregationTest < SearchFlip::TestCase
     ProductIndex.import [product1, product2, product3, product4, product5, product6]
 
     query = ProductIndex.aggregate(:category) do |aggregation|
-      aggregation.aggregate(:title) do |_aggregation|
-        _aggregation.aggregate(price: { sum: { field: "price" }})
+      aggregation.aggregate(:title) do |aggregation2|
+        aggregation2.aggregate(price: { sum: { field: "price" } })
       end
     end
 
-    assert_equal Hash["category1" => 3, "category2" => 3], query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 3, "category2" => 3],
+      query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
 
-    assert_equal Hash["title1" => 2, "title2" => 1], query.aggregations(:category)["category1"].title.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
-    assert_equal Hash["title1" => 1, "title2" => 2], query.aggregations(:category)["category2"].title.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+    assert_equal Hash["title1" => 2, "title2" => 1],
+      query.aggregations(:category)["category1"].title.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
+
+    assert_equal Hash["title1" => 1, "title2" => 2],
+      query.aggregations(:category)["category2"].title.buckets.each_with_object({}) { |bucket, hash| hash[bucket[:key]] = bucket.doc_count }
 
     assert_equal 30, query.aggregations(:category)["category1"].title.buckets.detect { |bucket| bucket[:key] == "title1" }.price.value
     assert_equal 15, query.aggregations(:category)["category1"].title.buckets.detect { |bucket| bucket[:key] == "title2" }.price.value

data/test/search_flip/bulk_test.rb

@@ -1,5 +1,5 @@
 
-require File.expand_path("../../test_helper", __FILE__)
+require File.expand_path("../test_helper", __dir__)
 
 class SearchFlip::BulkTest < SearchFlip::TestCase
   def test_bulk

data/test/search_flip/connection_test.rb

@@ -0,0 +1,70 @@
+
+require File.expand_path("../test_helper", __dir__)
+
+class SearchFlip::ConnectionTest < SearchFlip::TestCase
+  def test_base_url
+    assert_equal SearchFlip::Connection.new(base_url: "base url").base_url, "base url"
+  end
+
+  def test_msearch
+    ProductIndex.import create(:product)
+    CommentIndex.import create(:comment)
+
+    responses = SearchFlip::Connection.new.msearch([ProductIndex.match_all, CommentIndex.match_all])
+
+    assert_equal 2, responses.size
+    assert_equal 1, responses[0].total_entries
+    assert_equal 1, responses[1].total_entries
+  end
+
+  def test_update_aliases
+    connection = SearchFlip::Connection.new
+
+    assert connection.update_aliases(actions: [add: { index: "products", alias: "alias1" }])
+    assert connection.update_aliases(actions: [remove: { index: "products", alias: "alias1" }])
+  end
+
+  def test_get_index_aliases
+    connection = SearchFlip::Connection.new
+
+    connection.update_aliases(actions: [
+      { add: { index: "comments", alias: "alias1" } },
+      { add: { index: "products", alias: "alias2" } },
+      { add: { index: "products", alias: "alias3" } }
+    ])
+
+    assert_equal connection.get_aliases.keys.sort, ["comments", "products"].sort
+    assert_equal connection.get_aliases["products"]["aliases"].keys, ["alias2", "alias3"]
+    assert_equal connection.get_aliases["comments"]["aliases"].keys, ["alias1"]
+    assert_equal connection.get_aliases(index_name: "products").keys, ["products"]
+    assert_equal connection.get_aliases(index_name: "comments,products").keys.sort, ["comments", "products"]
+    assert_equal connection.get_aliases(alias_name: "alias1,alias2").keys.sort, ["comments", "products"]
+    assert_equal connection.get_aliases(alias_name: "alias1,alias2")["products"]["aliases"].keys, ["alias2"]
+  ensure
+    connection.update_aliases(actions: [
+      { remove: { index: "comments", alias: "alias1" } },
+      { remove: { index: "products", alias: "alias2" } },
+      { remove: { index: "products", alias: "alias3" } }
+    ])
+  end
+
+  def test_alias_exists?
+    connection = SearchFlip::Connection.new
+
+    refute connection.alias_exists?(:some_alias)
+
+    connection.update_aliases(actions: [add: { index: "products", alias: "some_alias" }])
+
+    assert connection.alias_exists?(:some_alias)
+  ensure
+    connection.update_aliases(actions: [remove: { index: "products", alias: "some_alias" }])
+  end
+
+  def test_get_indices
+    connection = SearchFlip::Connection.new
+
+    assert_equal connection.get_indices.map { |index| index["index"] }.sort, ["comments", "products"]
+    assert_equal connection.get_indices("com*").map { |index| index["index"] }.sort, ["comments"]
+  end
+end
+

data/test/search_flip/criteria_test.rb

@@ -1,9 +1,10 @@
 
-require File.expand_path("../../test_helper", __FILE__)
+require File.expand_path("../test_helper", __dir__)
 
 class SearchFlip::CriteriaTest < SearchFlip::TestCase
-  should_delegate_methods :total_entries, :current_page, :previous_page, :prev_page, :next_page, :first_page?, :last_page?, :out_of_range?,
-    :total_pages, :hits, :ids, :count, :size, :length, :took, :aggregations, :suggestions, :scope, :results, :records, :scroll_id, :raw_response,
+  should_delegate_methods :total_entries, :current_page, :previous_page, :prev_page, :next_page,
+    :first_page?, :last_page?, :out_of_range?, :total_pages, :hits, :ids, :count, :size, :length,
+    :took, :aggregations, :suggestions, :scope, :results, :records, :scroll_id, :raw_response,
     to: :response, subject: SearchFlip::Criteria.new(target: ProductIndex)
 
   def test_merge
@@ -13,7 +14,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query = ProductIndex.where(price: 50 .. 250).aggregate(:category).merge(ProductIndex.where(category: "category1"))
+    query = ProductIndex.where(price: 50..250).aggregate(:category).merge(ProductIndex.where(category: "category1"))
 
     assert_includes query.records, product1
     refute_includes query.records, product2
@@ -23,7 +24,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
   def test_criteria
     criteria = ProductIndex.criteria
 
-    assert criteria.criteria === criteria
+    assert_equal criteria.criteria.object_id, criteria.object_id
   end
 
   def test_timeout
@@ -49,7 +50,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query1 = ProductIndex.where(price: 100 .. 200)
+    query1 = ProductIndex.where(price: 100..200)
     query2 = query1.where(category: "category1")
 
     assert_includes query1.records, product1
@@ -82,7 +83,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [expected1, expected2, rejected]
 
-    records = ProductIndex.where(price: 100 .. 200).records
+    records = ProductIndex.where(price: 100..200).records
 
     assert_includes records, expected1
     assert_includes records, expected2
@@ -108,7 +109,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query1 = ProductIndex.where_not(price: 250 .. 350)
+    query1 = ProductIndex.where_not(price: 250..350)
     query2 = query1.where_not(category: "category2")
 
     assert_includes query1.records, product1
@@ -141,7 +142,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [expected, rejected1, rejected2]
 
-    records = ProductIndex.where_not(price: 200 .. 300).records
+    records = ProductIndex.where_not(price: 200..300).records
 
     assert_includes records, expected
     refute_includes records, rejected1
@@ -167,7 +168,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query1 = ProductIndex.filter(range: { price: { gte: 100, lte: 200 }})
+    query1 = ProductIndex.filter(range: { price: { gte: 100, lte: 200 } })
     query2 = query1.filter(term: { category: "category1" })
 
     assert_includes query1.records, product1
@@ -210,6 +211,15 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     assert_includes records, expected2
   end
 
+  def test_execute
+    connection = SearchFlip::Connection.new(base_url: "http://localhost:1234")
+
+    stub_request(:post, "http://localhost:1234/products/products/_search")
+      .to_return(status: 200, body: "{}", headers: { content_type: "application/json" })
+
+    assert_equal ProductIndex.match_all.execute(connection: connection).raw_response, {}
+  end
+
   def test_exists
     product1 = create(:product, title: "title1", description: "description1")
     product2 = create(:product, title: "title2", description: nil)
@@ -249,7 +259,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
   end
 
   def test_post_search
-    return if SearchFlip.version.to_i < 2
+    return if ProductIndex.connection.version.to_i < 2
 
     product1 = create(:product, title: "title1", category: "category1")
     product2 = create(:product, title: "title2", category: "category2")
@@ -268,8 +278,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_where
@@ -279,7 +292,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query1 = ProductIndex.aggregate(:category).post_where(price: 100 .. 200)
+    query1 = ProductIndex.aggregate(:category).post_where(price: 100..200)
     query2 = query1.post_where(category: "category1")
 
     assert_includes query1.records, product1
@@ -290,8 +303,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_where_with_array
@@ -307,7 +323,8 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     assert_includes query.records, expected2
     refute_includes query.records, rejected
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_where_with_range
@@ -317,13 +334,14 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [expected1, expected2, rejected]
 
-    query = ProductIndex.aggregate(:category).post_where(price: 100 .. 200)
+    query = ProductIndex.aggregate(:category).post_where(price: 100..200)
 
     assert_includes query.records, expected1
     assert_includes query.records, expected2
     refute_includes query.records, rejected
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_where_not
@@ -333,7 +351,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query1 = ProductIndex.aggregate(:category).post_where_not(price: 250 .. 350)
+    query1 = ProductIndex.aggregate(:category).post_where_not(price: 250..350)
     query2 = query1.post_where_not(category: "category2")
 
     assert_includes query1.records, product1
@@ -344,8 +362,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_where_not_with_array
@@ -361,7 +382,8 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query.records, rejected1
     refute_includes query.records, rejected2
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_where_not_with_range
@@ -371,13 +393,14 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [expected, rejected1, rejected2]
 
-    query = ProductIndex.aggregate(:category).post_where_not(price: 200 .. 300)
+    query = ProductIndex.aggregate(:category).post_where_not(price: 200..300)
 
     assert_includes query.records, expected
     refute_includes query.records, rejected1
     refute_includes query.records, rejected2
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_filter
@@ -387,7 +410,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [product1, product2, product3]
 
-    query1 = ProductIndex.aggregate(:category).post_filter(range: { price: { gte: 100, lte: 200 }})
+    query1 = ProductIndex.aggregate(:category).post_filter(range: { price: { gte: 100, lte: 200 } })
     query2 = query1.post_filter(term: { category: "category1" })
 
     assert_includes query1.records, product1
@@ -398,8 +421,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_range
@@ -420,8 +446,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     assert_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_exists
@@ -442,8 +471,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_post_exists_not
@@ -464,8 +496,11 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product2
     refute_includes query2.records, product3
 
-    assert_equal Hash["category1" => 2, "category2" => 1], query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
-    assert_equal Hash["category1" => 2, "category2" => 1], query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query1.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+
+    assert_equal Hash["category1" => 2, "category2" => 1],
+      query2.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
   end
 
   def test_aggregate
@@ -473,7 +508,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     ProductIndex.import create_list(:product, 2, category: "category2", price: 20)
     ProductIndex.import create_list(:product, 1, category: "category3", price: 30)
 
-    query = ProductIndex.aggregate(:category, size: 2).aggregate(price_sum: { sum: { field: "price" }})
+    query = ProductIndex.aggregate(:category, size: 2).aggregate(price_sum: { sum: { field: "price" } })
 
     category_aggregations = query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
     price_aggregation = query.aggregations(:price_sum).value
@@ -487,7 +522,8 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     ProductIndex.import create_list(:product, 2, category: "category2")
     ProductIndex.import create_list(:product, 1, category: "category3")
 
-    aggregations = ProductIndex.aggregate(category: { terms: { field: :category }}).aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+    query = ProductIndex.aggregate(category: { terms: { field: :category } })
+    aggregations = query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
 
     assert_equal Hash["category1" => 3, "category2" => 2, "category3" => 1], aggregations
   end
@@ -498,7 +534,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     ProductIndex.import create_list(:product, 1, category: "category3", price: 25)
 
     query = ProductIndex.aggregate(:category) do |aggregation|
-      aggregation.aggregate(price_sum: { sum: { field: "price" }})
+      aggregation.aggregate(price_sum: { sum: { field: "price" } })
     end
 
     category_aggregations = query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
@@ -509,7 +545,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
   end
 
   def test_profile
-    return if SearchFlip.version.to_i < 2
+    return if ProductIndex.connection.version.to_i < 2
 
     assert_not_nil ProductIndex.profile(true).raw_response["profile"]
   end
@@ -689,7 +725,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     assert_equal [product1, product3].to_set, ProductIndex.search("Title1 OR Title3").records.to_set
     assert_equal [product1, product3].to_set, ProductIndex.search("Title1 Title3", default_operator: :OR).records.to_set
     assert_equal [product1], ProductIndex.search("Title1 OR Title2").search("Title1 OR Title3").records
-    assert_equal [product1], ProductIndex.search("Title1 OR Title3").where(price: 5 .. 15).records
+    assert_equal [product1], ProductIndex.search("Title1 OR Title3").where(price: 5..15).records
   end
 
   def test_unscope
@@ -725,7 +761,10 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     assert_equal ["Title2 <em>highlight</em>"], results[1].highlight.title
     assert_equal ["Description2 <em>highlight</em>"], results[1].highlight.description
 
-    results = ProductIndex.sort(:id).highlight(:title, require_field_match: true).highlight(:description, require_field_match: true).search("title:highlight").results
+    query = ProductIndex.sort(:id).search("title:highlight")
+    query = query.highlight(:title, require_field_match: true).highlight(:description, require_field_match: true)
+
+    results = query.results
 
     assert_equal ["Title1 <em>highlight</em>"], results[0].highlight.title
     assert_nil results[0].highlight.description
@@ -739,7 +778,8 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import product
 
-    assert_equal "description", ProductIndex.suggest(:suggestion, text: "Desciption", term: { field: "description" }).suggestions(:suggestion).first["text"]
+    assert_equal "description",
+      ProductIndex.suggest(:suggestion, text: "Desciption", term: { field: "description" }).suggestions(:suggestion).first["text"]
   end
 
   def test_find_in_batches
@@ -752,7 +792,8 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [expected1, expected2, expected3, rejected]
 
-    assert_equal [[expected1, expected2], [expected3]], ProductIndex.where(title: "expected").sort(:rank).find_in_batches(batch_size: 2).to_a
+    assert_equal [[expected1, expected2], [expected3]],
+      ProductIndex.where(title: "expected").sort(:rank).find_in_batches(batch_size: 2).to_a
   end
 
   def test_find_results_in_batches
@@ -765,7 +806,9 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     ProductIndex.import [expected1, expected2, expected3, rejected]
 
-    assert_equal [[expected1.id, expected2.id], [expected3.id]], ProductIndex.where(title: "expected").sort(:rank).find_results_in_batches(batch_size: 2).map { |batch| batch.map(&:id) }
+    actual = ProductIndex.where(title: "expected").sort(:rank).find_results_in_batches(batch_size: 2).map { |batch| batch.map(&:id) }
+
+    assert_equal [[expected1.id, expected2.id], [expected3.id]], actual
   end
 
   def test_find_each
@@ -799,7 +842,7 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
 
     assert_not_nil query.instance_variable_get(:@response)
 
-    refute query.fresh === query
+    refute_equal query.fresh.object_id, query.object_id
     assert_nil query.fresh.instance_variable_get(:@response)
   end