search_flip 2.0.0.beta2 → 2.0.0.beta3

data/spec/search_flip/response_spec.rb

@@ -0,0 +1,185 @@
+
+require File.expand_path("../spec_helper", __dir__)
+
+RSpec.describe SearchFlip::Response do
+  describe "#total_count" do
+    it "returns the number of results" do
+      ProductIndex.import create_list(:product, 3)
+
+      expect(ProductIndex.total_count).to eq(3)
+      expect(ProductIndex.total_entries).to eq(3)
+    end
+  end
+
+  describe "#current_page" do
+    it "returns the current page number" do
+      expect(ProductIndex.match_all.current_page).to eq(1)
+
+      ProductIndex.import create_list(:product, 3)
+
+      expect(ProductIndex.paginate(page: 1, per_page: 2).current_page).to eq(1)
+      expect(ProductIndex.paginate(page: 2, per_page: 2).current_page).to eq(2)
+      expect(ProductIndex.paginate(page: 3, per_page: 2).current_page).to eq(3)
+    end
+  end
+
+  describe "#total_pages" do
+    it "returns the number of total pages" do
+      expect(ProductIndex.paginate(page: 1, per_page: 2).total_pages).to eq(1)
+
+      ProductIndex.import create_list(:product, 3)
+
+      expect(ProductIndex.paginate(page: 1, per_page: 2).total_pages).to eq(2)
+    end
+  end
+
+  describe "#previous_page" do
+    it "returns the previous page number" do
+      ProductIndex.import create_list(:product, 3)
+
+      expect(ProductIndex.paginate(page: 1, per_page: 2).previous_page).to be_nil
+      expect(ProductIndex.paginate(page: 2, per_page: 2).previous_page).to eq(1)
+      expect(ProductIndex.paginate(page: 3, per_page: 2).previous_page).to eq(2)
+    end
+  end
+
+  describe "#next_page" do
+    it "returns the next page number" do
+      ProductIndex.import create_list(:product, 3)
+
+      expect(ProductIndex.paginate(page: 1, per_page: 2).next_page).to eq(2)
+      expect(ProductIndex.paginate(page: 2, per_page: 2).next_page).to be_nil
+    end
+  end
+
+  describe "#first_page?" do
+    it "returns whether or not the current page is the first page" do
+      ProductIndex.import create(:product)
+
+      expect(ProductIndex.paginate(page: 1).first_page?).to eq(true)
+      expect(ProductIndex.paginate(page: 2).first_page?).to eq(false)
+    end
+  end
+
+  describe "#last_page?" do
+    it "returns whether or not the current page is the last page" do
+      ProductIndex.import create_list(:product, 31)
+
+      expect(ProductIndex.paginate(page: 2).last_page?).to eq(true)
+      expect(ProductIndex.paginate(page: 1).last_page?).to eq(false)
+    end
+  end
+
+  describe "#out_of_range?" do
+    it "returns whether or not the current page is out of range" do
+      ProductIndex.import create(:product)
+
+      expect(ProductIndex.paginate(page: 2).out_of_range?).to eq(true)
+      expect(ProductIndex.paginate(page: 1).out_of_range?).to eq(false)
+    end
+  end
+
+  describe "#results" do
+    it "returns the current results" do
+      products = create_list(:product, 3)
+
+      ProductIndex.import products
+
+      expect(ProductIndex.match_all.results.map(&:id).to_set).to eq(products.map(&:id).to_set)
+    end
+  end
+
+  describe "#hits" do
+    it "returns the current hits" do
+      ProductIndex.import create_list(:product, 3)
+
+      response = ProductIndex.match_all.response
+
+      expect(response.hits).to be_present
+      expect(response.hits).to eq(response.raw_response["hits"])
+    end
+  end
+
+  describe "#scroll_id" do
+    it "returns the current scroll id" do
+      ProductIndex.import create_list(:product, 3)
+
+      response = ProductIndex.scroll.response
+
+      expect(response.scroll_id).to be_present
+      expect(response.scroll_id).to eq(response.raw_response["_scroll_id"])
+    end
+  end
+
+  describe "#records" do
+    it "returns the records for the current hits" do
+      products = create_list(:product, 3)
+
+      ProductIndex.import products
+
+      expect(ProductIndex.match_all.records.to_set).to eq(products.to_set)
+    end
+  end
+
+  describe "#ids" do
+    it "returns the ids for the current hits" do
+      products = create_list(:product, 3)
+
+      ProductIndex.import products
+
+      response = ProductIndex.match_all.response
+
+      expect(response.ids.to_set).to eq(products.map(&:id).map(&:to_s).to_set)
+      expect(response.ids).to eq(response.raw_response["hits"]["hits"].map { |hit| hit["_id"] })
+    end
+  end
+
+  describe "#took" do
+    it "returns the took value" do
+      ProductIndex.import create_list(:product, 3)
+
+      response = ProductIndex.match_all.response
+
+      expect(response.took).to be_present
+      expect(response.took).to eq(response.raw_response["took"])
+    end
+  end
+
+  describe "#aggregations" do
+    it "returns a convenient version of the aggregations" do
+      product1 = create(:product, price: 10, category: "category1")
+      product2 = create(:product, price: 20, category: "category2")
+      product3 = create(:product, price: 30, category: "category1")
+
+      ProductIndex.import [product1, product2, product3]
+
+      query = ProductIndex.aggregate(:category) do |aggregation|
+        aggregation.aggregate(price_sum: { sum: { field: "price" } })
+      end
+
+      aggregations = query.aggregations(:category).each_with_object({}) { |(key, agg), hash| hash[key] = agg.doc_count }
+      expect(aggregations).to eq("category1" => 2, "category2" => 1)
+
+      expect(query.aggregations(:category)["category1"].price_sum.value).to eq(40)
+      expect(query.aggregations(:category)["category2"].price_sum.value).to eq(20)
+    end
+
+    it "returns the raw aggregations if no key is specified" do
+      product1 = create(:product, category: "category1")
+      product2 = create(:product, category: "category2")
+      product3 = create(:product, category: "category1")
+
+      ProductIndex.import [product1, product2, product3]
+
+      query = ProductIndex.aggregate(:category)
+
+      expected = [
+        { "doc_count" => 2, "key" => "category1" },
+        { "doc_count" => 1, "key" => "category2" }
+      ]
+
+      expect(query.aggregations["category"]["buckets"]).to eq(expected)
+    end
+  end
+end
+

data/spec/search_flip/to_json_spec.rb

@@ -0,0 +1,29 @@
+
+require File.expand_path("../spec_helper", __dir__)
+require "search_flip/to_json"
+
+RSpec.describe "to_json" do
+  it "uses the correct format for Time" do
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      expect(Time.now.utc.to_json).to eq("\"2018-01-01T12:00:00.000000Z\"")
+    end
+  end
+
+  it "uses the correct format for Date" do
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      expect(Date.today.to_json).to eq("\"2018-01-01\"")
+    end
+  end
+
+  it "uses the correct format for DateTime" do
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      expect(Time.now.utc.to_json).to eq("\"2018-01-01T12:00:00.000000Z\"")
+    end
+  end
+
+  it "uses the correct format for TimeWithZone" do
+    Timecop.freeze Time.parse("2018-01-01 12:00:00 UTC") do
+      expect(Time.find_zone("UTC").now.to_json).to eq("\"2018-01-01T12:00:00.000000Z\"")
+    end
+  end
+end

data/{test/test_helper.rb → spec/spec_helper.rb}

@@ -1,16 +1,25 @@
 
-require "minitest"
-require "minitest/autorun"
-require "webmock/minitest"
-require "mocha/minitest"
 require "search_flip"
+require "webmock/rspec"
 require "active_record"
 require "factory_bot"
 require "timecop"
 require "yaml"
 
+require File.expand_path("delegate_matcher", __dir__)
+
 WebMock.allow_net_connect!
 
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+
+  config.before do
+    TestIndex.delete_index if TestIndex.index_exists?
+    ProductIndex.match_all.delete
+    Product.delete_all
+  end
+end
+
 ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 
 SearchFlip::Config[:auto_refresh] = true
@@ -169,75 +178,3 @@ end
 
 TestIndex.delete_index if TestIndex.index_exists?
 
-class SearchFlip::TestCase < MiniTest::Test
-  include FactoryBot::Syntax::Methods
-
-  def self.should_delegate_method(method, to:, subject:, as: method)
-    define_method :"test_delegate_#{method}_to_#{to}" do
-      assert subject.respond_to?(method), "subject doesn't respond to #{method}"
-
-      target = subject.send(to)
-
-      assert target.respond_to?(as), "#{to} doesn't respond to #{as}"
-
-      params = Array.new(subject.method(method).arity.abs) { |i| "param-#{i}" }
-
-      mock_target = mock
-      mock_target.expects(as).with(*params)
-
-      subject.stubs(to).returns(mock_target)
-
-      subject.send(method, *params)
-    end
-  end
-
-  def self.should_delegate_methods(*methods, to:, subject:)
-    methods.each do |method|
-      should_delegate_method method, to: to, subject: subject
-    end
-  end
-
-  def assert_difference(expressions, difference = 1, &block)
-    callables = Array(expressions).map { |e| -> { eval(e, block.binding) } }
-
-    before = callables.map(&:call)
-
-    res = yield
-
-    Array(expressions).zip(callables).each_with_index do |(code, callable), i|
-      assert_equal before[i] + difference, callable.call, "#{code.inspect} didn't change by #{difference}"
-    end
-
-    res
-  end
-
-  def assert_no_difference(expressions, &block)
-    assert_difference(expressions, 0, &block)
-  end
-
-  def assert_not_nil(object)
-    assert !object.nil?, "shouldn't be nil"
-  end
-
-  def assert_present(object)
-    assert object.present?, "should be present"
-  end
-
-  def assert_blank(object)
-    assert object.blank?, "should be blank"
-  end
-
-  def refute_present(object)
-    refute object.present?, "shouldn't be present"
-  end
-
-  def refute_blank(object)
-    refute object.blank?, "shouldn't be blank"
-  end
-
-  def setup
-    ProductIndex.match_all.delete
-    Product.delete_all
-    TestIndex.delete_index if TestIndex.index_exists?
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: search_flip
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.beta3
 platform: ruby
 authors:
 - Benjamin Vetter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-27 00:00:00.000000000 Z
+date: 2019-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -53,21 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -214,21 +200,25 @@ files:
 - lib/search_flip/to_json.rb
 - lib/search_flip/version.rb
 - search_flip.gemspec
-- test/search_flip/aggregation_test.rb
-- test/search_flip/bulk_test.rb
-- test/search_flip/connection_test.rb
-- test/search_flip/criteria_test.rb
-- test/search_flip/http_client_test.rb
-- test/search_flip/index_test.rb
-- test/search_flip/model_test.rb
-- test/search_flip/response_test.rb
-- test/search_flip/to_json_test.rb
-- test/test_helper.rb
+- spec/delegate_matcher.rb
+- spec/search_flip/aggregation_spec.rb
+- spec/search_flip/bulk_spec.rb
+- spec/search_flip/connection_spec.rb
+- spec/search_flip/criteria_spec.rb
+- spec/search_flip/http_client_spec.rb
+- spec/search_flip/index_spec.rb
+- spec/search_flip/model_spec.rb
+- spec/search_flip/response_spec.rb
+- spec/search_flip/to_json_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/mrkamel/search_flip
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |
+  Thanks for using search_flip!
+  When upgrading from 1.x to 2.x, please check out
+  https://github.com/mrkamel/search_flip/blob/master/UPDATING.md
 rdoc_options: []
 require_paths:
 - lib
@@ -249,13 +239,14 @@ signing_key:
 specification_version: 4
 summary: Powerful ElasticSearch client library to easily build complex queries
 test_files:
-- test/search_flip/aggregation_test.rb
-- test/search_flip/bulk_test.rb
-- test/search_flip/connection_test.rb
-- test/search_flip/criteria_test.rb
-- test/search_flip/http_client_test.rb
-- test/search_flip/index_test.rb
-- test/search_flip/model_test.rb
-- test/search_flip/response_test.rb
-- test/search_flip/to_json_test.rb
-- test/test_helper.rb
+- spec/delegate_matcher.rb
+- spec/search_flip/aggregation_spec.rb
+- spec/search_flip/bulk_spec.rb
+- spec/search_flip/connection_spec.rb
+- spec/search_flip/criteria_spec.rb
+- spec/search_flip/http_client_spec.rb
+- spec/search_flip/index_spec.rb
+- spec/search_flip/model_spec.rb
+- spec/search_flip/response_spec.rb
+- spec/search_flip/to_json_spec.rb
+- spec/spec_helper.rb

data/test/search_flip/aggregation_test.rb

@@ -1,230 +0,0 @@
-
-require File.expand_path("../test_helper", __dir__)
-
-class SearchFlip::AggregationTest < SearchFlip::TestCase
-  def test_where
-    product1 = create(:product, category: "category1", title: "title", description: "description")
-    product2 = create(:product, category: "category2", title: "title", description: "description")
-    product3 = create(:product, category: "category1", title: "title", description: "description")
-    product4 = create(:product, category: "category2", title: "title", description: "other")
-    product5 = create(:product, category: "category1", title: "other", description: "description")
-
-    ProductIndex.import [product1, product2, product3, product4, product5]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_where_with_array
-    product1 = create(:product, category: "category1", title: "title1", description: "description1")
-    product2 = create(:product, category: "category2", title: "title2", description: "description2")
-    product3 = create(:product, category: "category1", title: "title3", description: "description3")
-    product4 = create(:product, category: "category2", title: "title4", description: "other")
-    product5 = create(:product, category: "category1", title: "other", description: "description")
-
-    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)
-    end
-
-    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
-    product1 = create(:product, category: "category1", title: "title1", price: 100)
-    product2 = create(:product, category: "category2", title: "title2", price: 150)
-    product3 = create(:product, category: "category1", title: "title3", price: 200)
-    product4 = create(:product, category: "category2", title: "title4", price: 250)
-    product5 = create(:product, category: "category1", title: "other", price: 200)
-
-    ProductIndex.import [product1, product2, product3, product4, product5]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_where_not
-    product1 = create(:product, category: "category1", title: "title1")
-    product2 = create(:product, category: "category2", title: "title2")
-    product3 = create(:product, category: "category1", title: "title3")
-    product4 = create(:product, category: "category2", title: "title4")
-    product5 = create(:product, category: "category1", title: "title5")
-
-    ProductIndex.import [product1, product2, product3, product4, product5]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_where_not_with_array
-    product1 = create(:product, category: "category1", title: "title1")
-    product2 = create(:product, category: "category2", title: "title2")
-    product3 = create(:product, category: "category1", title: "title3")
-    product4 = create(:product, category: "category2", title: "title4")
-    product5 = create(:product, category: "category1", title: "title5")
-    product6 = create(:product, category: "category2", title: "title6")
-    product7 = create(:product, category: "category1", title: "title7")
-
-    ProductIndex.import [product1, product2, product3, product4, product5, product6, product7]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_where_not_with_range
-    product1 = create(:product, category: "category1", title: "title1", price: 100)
-    product2 = create(:product, category: "category2", title: "title2", price: 150)
-    product3 = create(:product, category: "category1", title: "title3", price: 200)
-    product4 = create(:product, category: "category2", title: "title4", price: 250)
-    product5 = create(:product, category: "category1", title: "title5", price: 300)
-    product6 = create(:product, category: "category2", title: "title6", price: 350)
-    product7 = create(:product, category: "category1", title: "title7", price: 400)
-
-    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)
-    end
-
-    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
-    product1 = create(:product, category: "category1", title: "title", price: 100)
-    product2 = create(:product, category: "category2", title: "title", price: 150)
-    product3 = create(:product, category: "category1", title: "title", price: 200)
-    product4 = create(:product, category: "category2", title: "other", price: 200)
-    product5 = create(:product, category: "category1", title: "title", price: 250)
-
-    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)
-    end
-
-    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
-    product1 = create(:product, category: "category1", title: "title1", price: 100)
-    product2 = create(:product, category: "category2", title: "title2", price: 150)
-    product3 = create(:product, category: "category1", title: "title3", price: 200)
-    product4 = create(:product, category: "category2", title: "title4", price: 250)
-    product5 = create(:product, category: "category1", title: "title5", price: 300)
-    product6 = create(:product, category: "category2", title: "title6", price: 350)
-    product7 = create(:product, category: "category1", title: "title7", price: 400)
-
-    ProductIndex.import [product1, product2, product3, product4, product5, product6, product7]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_match_all
-    product1 = create(:product, category: "category1")
-    product2 = create(:product, category: "category2")
-    product3 = create(:product, category: "category1")
-
-    ProductIndex.import [product1, product2, product3]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_exists
-    product1 = create(:product, category: "category1", title: "title1", price: 10)
-    product2 = create(:product, category: "category2", title: "title2")
-    product3 = create(:product, category: "category1", title: "title3", price: 20)
-    product4 = create(:product, category: "category2", title: "title4", price: 30)
-    product5 = create(:product, category: "category1", price: 40)
-
-    ProductIndex.import [product1, product2, product3, product4, product5]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_exists_not
-    product1 = create(:product, category: "category1")
-    product2 = create(:product, category: "category2", title: "title2")
-    product3 = create(:product, category: "category1")
-    product4 = create(:product, category: "category2")
-    product5 = create(:product, category: "category1", price: 40)
-
-    ProductIndex.import [product1, product2, product3, product4, product5]
-
-    query = ProductIndex.aggregate(category: {}) do |aggregation|
-      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 }
-  end
-
-  def test_aggregate
-    product1 = create(:product, category: "category1", title: "title1", price: 10)
-    product2 = create(:product, category: "category1", title: "title2", price: 15)
-    product3 = create(:product, category: "category1", title: "title1", price: 20)
-    product4 = create(:product, category: "category2", title: "title2", price: 25)
-    product5 = create(:product, category: "category2", title: "title1", price: 30)
-    product6 = create(:product, category: "category2", title: "title2", price: 35)
-
-    ProductIndex.import [product1, product2, product3, product4, product5, product6]
-
-    query = ProductIndex.aggregate(:category) do |aggregation|
-      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["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
-    assert_equal 30, query.aggregations(:category)["category2"].title.buckets.detect { |bucket| bucket[:key] == "title1" }.price.value
-    assert_equal 60, query.aggregations(:category)["category2"].title.buckets.detect { |bucket| bucket[:key] == "title2" }.price.value
-  end
-end
-