chewy 0.3.0 → 0.4.0

data/spec/chewy/query/criteria_spec.rb

@@ -7,6 +7,7 @@ describe Chewy::Query::Criteria do
 
   its(:options) { should be_a Hash }
   its(:facets) { should == {} }
+  its(:aggregations) { should == {} }
   its(:queries) { should == [] }
   its(:filters) { should == [] }
   its(:sort) { should == [] }
@@ -15,6 +16,7 @@ describe Chewy::Query::Criteria do
 
   its(:none?){ should be_false }
   its(:facets?) { should be_false }
+  its(:aggregations?) { should be_false }
   its(:queries?) { should be_false }
   its(:filters?) { should be_false }
   its(:sort?) { should be_false }
@@ -30,6 +32,11 @@ describe Chewy::Query::Criteria do
     specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets }.to(field: 'hello') }
   end
 
+  describe '#update_aggregations' do
+    specify { expect { subject.update_aggregations(field: 'hello') }.to change { subject.aggregations? }.to(true) }
+    specify { expect { subject.update_aggregations(field: 'hello') }.to change { subject.aggregations }.to(field: 'hello') }
+  end
+
   describe '#update_queries' do
     specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries? }.to(true) }
     specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries }.to([field: 'hello']) }
@@ -97,6 +104,8 @@ describe Chewy::Query::Criteria do
       .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
     specify { subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
+    specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations.should == {field1: 'hello', field1: 'hello'} }
     specify { subject.tap { |c| c.update_queries(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
     specify { subject.tap { |c| c.update_filters(field1: 'hello') }
@@ -119,6 +128,8 @@ describe Chewy::Query::Criteria do
       .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
     specify { subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
+    specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations.should == {field1: 'hello', field1: 'hello'} }
     specify { subject.tap { |c| c.update_queries(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
     specify { subject.tap { |c| c.update_filters(field1: 'hello') }

data/spec/chewy/query/loading_spec.rb

@@ -16,10 +16,10 @@ describe Chewy::Query::Loading do
     before do
       stub_index(:places) do
         define_type City do
-          field :rating, type: 'number', value: ->(o){ o.rating }
+          field :rating, type: 'integer', value: ->(o){ o.rating }
         end
         define_type Country do
-          field :rating, type: 'number', value: ->(o){ o.rating }
+          field :rating, type: 'integer', value: ->(o){ o.rating }
         end
       end
     end

data/spec/chewy/query/pagination_spec.rb

@@ -7,7 +7,8 @@ describe Chewy::Query::Pagination do
   before do
     stub_index(:products) do
       define_type(:product) do
-        field :name, :age
+        field :name
+        field :age, type: 'integer'
       end
     end
   end
@@ -19,7 +20,7 @@ describe Chewy::Query::Pagination do
   let(:search) { ProductsIndex.order(:age) }
 
   describe '#per, #page' do
-    specify { search.map { |e| e.attributes.except('_score', '_explanation') }.should == data }
+    specify { search.map { |e| e.attributes.except('_score', '_explanation') }.should =~ data }
     specify { search.page(1).map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..2] }
     specify { search.page(2).map { |e| e.attributes.except('_score', '_explanation') }.should == data[3..5] }
     specify { search.page(2).per(4).map { |e| e.attributes.except('_score', '_explanation') }.should == data[4..7] }

data/spec/chewy/query_spec.rb

@@ -100,6 +100,70 @@ describe Chewy::Query do
     specify { subject.facets(term: {field: 'hello'}).should_not == subject }
     specify { subject.facets(term: {field: 'hello'}).criteria.facets.should include(term: {field: 'hello'}) }
     specify { expect { subject.facets(term: {field: 'hello'}) }.not_to change { subject.criteria.facets } }
+
+    context 'results' do
+      before { stub_model(:city) }
+      let(:cities) { 10.times.map { |i| City.create! name: "name#{i}", rating: i % 3 } }
+
+      context do
+        before do
+          stub_index(:cities) do
+            define_type :city do
+              field :rating, type: 'integer'
+            end
+          end
+        end
+
+        before { CitiesIndex::City.import! cities }
+
+        specify { CitiesIndex.facets.should == {} }
+        specify { CitiesIndex.facets(ratings: {terms: {field: 'rating'}}).facets.should == {
+          'ratings' => {
+            '_type' => 'terms', 'missing' => 0, 'total' => 10, 'other' => 0,
+            'terms' => [
+              {'term' => 0, 'count' => 4},
+              {'term' => 2, 'count' => 3},
+              {'term' => 1, 'count' => 3}
+            ]
+          }
+        } }
+      end
+    end
+  end
+
+  describe '#aggregations' do
+    specify { subject.aggregations(aggregation1: {field: 'hello'}).should be_a described_class }
+    specify { subject.aggregations(aggregation1: {field: 'hello'}).should_not == subject }
+    specify { subject.aggregations(aggregation1: {field: 'hello'}).criteria.aggregations.should include(aggregation1: {field: 'hello'}) }
+    specify { expect { subject.aggregations(aggregation1: {field: 'hello'}) }.not_to change { subject.criteria.aggregations } }
+
+    context 'results' do
+      before { stub_model(:city) }
+      let(:cities) { 10.times.map { |i| City.create! name: "name#{i}", rating: i % 3 } }
+
+      context do
+        before do
+          stub_index(:cities) do
+            define_type :city do
+              field :rating, type: 'integer'
+            end
+          end
+        end
+
+        before { CitiesIndex::City.import! cities }
+
+        specify { CitiesIndex.aggregations.should == {} }
+        specify { CitiesIndex.aggregations(ratings: {terms: {field: 'rating'}}).aggregations.should == {
+          'ratings' => {
+            'buckets' => [
+              {'key' => 0, 'doc_count' => 4},
+              {'key' => 1, 'doc_count' => 3},
+              {'key' => 2, 'doc_count' => 3}
+            ]
+          }
+        } }
+      end
+    end
   end
 
   describe '#filter' do
@@ -174,6 +238,12 @@ describe Chewy::Query do
     specify { subject.types([:product, :city]).types!(:country).criteria.types.should =~ ['country'] }
   end
 
+  describe '#aggregations' do
+    specify { subject.aggregations(attribute: {terms: {field: 'attribute'}}).should be_a described_class }
+    specify { subject.aggregations(attribute: {terms: {field: 'attribute'}}).should_not == subject }
+    specify { subject.aggregations(attribute: {terms: {field: 'attribute'}}).criteria.request_body[:body].should include(aggregations: {attribute: {terms: {field: 'attribute'}}}) }
+  end
+
   describe '#merge' do
     let(:query) { described_class.new(ProductsIndex) }
 
@@ -193,7 +263,7 @@ describe Chewy::Query do
             field :rating, type: 'integer'
             field :nested, type: 'object', value: ->{ {name: name} }
           end
-        end.tap(&:create!)
+        end
       end
 
       before { CitiesIndex::City.import! cities }
@@ -226,7 +296,7 @@ describe Chewy::Query do
               field :nested, type: 'object', value: ->{ {name: name} }
             end
           end
-        end.tap(&:create!)
+        end
       end
       before { CitiesIndex::City.import! cities }
 

data/spec/chewy/rspec/update_index_spec.rb

@@ -121,6 +121,32 @@ describe :update_index do
         }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: 1})
       }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
 
+      [
+        [{a: ['one', 'two']}, {a: ['one', 'two']}],
+        [{a: ['one', 'two']}, {a: ['two', 'one']}],
+        [{a: ['one', 'one', 'two']}, {a: ['one', 'two', 'one']}],
+        [{a: {b: ['one', 'one', 'two']}}, {a: {b: ['one', 'two', 'one']}}],
+        [{a: 1, b: 1}, {a: 1}]
+      ].each do |(data, with)|
+        specify { expect {
+          DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: data}}]
+        }.to update_index(DummiesIndex.dummy).and_reindex(42, with: with) }
+      end
+
+      [
+        [{a: ['one', 'two']}, {a: ['one', 'one', 'two']}],
+        [{a: ['one', 'one', 'two']}, {a: ['one', 'two']}],
+        [{a: ['one', 'two']}, {a: 1}],
+        [{a: 1}, {a: ['one', 'two']}],
+        [{a: 1}, {a: 1, b: 1}]
+      ].each do |(data, with)|
+        specify { expect {
+          expect {
+            DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: data}}]
+          }.to update_index(DummiesIndex.dummy).and_reindex(42, with: with)
+        }.to fail_matching('Expected document with id `42` to be reindexed') }
+      end
+
       context do
         let(:expectation) do
           expect { expect {

data/spec/chewy/type/adapter/active_record_spec.rb

@@ -24,7 +24,7 @@ describe Chewy::Type::Adapter::ActiveRecord do
 
     context do
       let!(:cities) { 3.times.map { |i| City.create! } }
-      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy!) } }
+      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) } }
       subject { described_class.new(City) }
 
       specify { import.should == [{index: cities}] }
@@ -54,9 +54,42 @@ describe Chewy::Type::Adapter::ActiveRecord do
         {delete: deleted.last(1).map(&:id)}] }
     end
 
-    context do
+    context 'custom primary_key' do
+      before { stub_model(:city) { self.primary_key = 'rating' } }
+      let!(:cities) { 3.times.map { |i| City.create! { |c| c.rating = i + 7 } } }
+      let!(:deleted) { 3.times.map { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
+      subject { described_class.new(City) }
+
+      specify { import.should == [{index: cities}] }
+
+      specify { import(City.order(:rating)).should == [{index: cities}] }
+      specify { import(City.order(:rating), batch_size: 2)
+        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+
+      specify { import(cities).should == [{index: cities}] }
+      specify { import(cities, batch_size: 2)
+          .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+      specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
+      specify { import(cities, deleted, batch_size: 2).should == [
+          {index: cities.first(2)},
+          {index: cities.last(1), delete: deleted.first(1)},
+          {delete: deleted.last(2)}] }
+
+      specify { import(cities.map(&:id)).should == [{index: cities}] }
+      specify { import(cities.map(&:id), batch_size: 2)
+        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+      specify { import(cities.map(&:id), deleted.map(&:id))
+        .should == [{index: cities}, {delete: deleted.map(&:id)}] }
+      specify { import(cities.map(&:id), deleted.map(&:id), batch_size: 2).should == [
+        {index: cities.first(2)},
+        {index: cities.last(1)},
+        {delete: deleted.first(2).map(&:id)},
+        {delete: deleted.last(1).map(&:id)}] }
+    end
+
+    context 'default scope' do
       let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
-      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy!) } }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) } }
       subject { described_class.new(City.where(country_id: 0)) }
 
       specify { import.should == [{index: cities.first(2)}] }
@@ -83,12 +116,12 @@ describe Chewy::Type::Adapter::ActiveRecord do
 
     context 'error handling' do
       let!(:cities) { 3.times.map { |i| City.create! } }
-      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy!) } }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) } }
       let(:ids) { (cities + deleted).map(&:id) }
       subject { described_class.new(City) }
 
       let(:data_comparer) do
-        ->(id, data) { object = (data[:index] || data[:delete]).first; (object.try(:id) || object) != id }
+        ->(id, data) { object = (data[:index] || data[:delete]).first; (object.respond_to?(:id) ? object.id : object) != id }
       end
 
       context 'implicit scope' do
@@ -136,26 +169,53 @@ describe Chewy::Type::Adapter::ActiveRecord do
   end
 
   describe '#load' do
-    let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
-    let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy!) } }
-
-    let(:type) { double(type_name: 'user') }
-
-    subject { described_class.new(City) }
-
-    specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type).should == cities }
-    specify { subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type).should == cities.reverse }
-    specify { subject.load(deleted.map { |c| double(id: c.id) }, _type: type).should == [nil, nil] }
-    specify { subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type).should == [*cities, nil, nil] }
-    specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(country_id: 0) })
-      .should == cities.first(2) + [nil] }
-    specify { subject.load(cities.map { |c| double(id: c.id) },
-      _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}})
-      .should == [nil, nil] + cities.last(1) }
-    specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1))
-      .should == [nil, nil] + cities.last(1) }
-    specify { subject.load(cities.map { |c| double(id: c.id) },
-      _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}})
-      .should == cities.first(2) + [nil] }
+    context do
+      let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) } }
+
+      let(:type) { double(type_name: 'user') }
+
+      subject { described_class.new(City) }
+
+      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type).should == cities }
+      specify { subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type).should == cities.reverse }
+      specify { subject.load(deleted.map { |c| double(id: c.id) }, _type: type).should == [nil, nil] }
+      specify { subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type).should == [*cities, nil, nil] }
+      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(country_id: 0) })
+        .should == cities.first(2) + [nil] }
+      specify { subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}})
+        .should == [nil, nil] + cities.last(1) }
+      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1))
+        .should == [nil, nil] + cities.last(1) }
+      specify { subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}})
+        .should == cities.first(2) + [nil] }
+    end
+
+    context 'custom primary_key' do
+      before { stub_model(:city) { self.primary_key = 'rating' } }
+      let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) { |c| c.rating = i + 7 } } }
+      let!(:deleted) { 2.times.map { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
+
+      let(:type) { double(type_name: 'user') }
+
+      subject { described_class.new(City) }
+
+      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type).should == cities }
+      specify { subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type).should == cities.reverse }
+      specify { subject.load(deleted.map { |c| double(id: c.id) }, _type: type).should == [nil, nil] }
+      specify { subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type).should == [*cities, nil, nil] }
+      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(country_id: 0) })
+        .should == cities.first(2) + [nil] }
+      specify { subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}})
+        .should == [nil, nil] + cities.last(1) }
+      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1))
+        .should == [nil, nil] + cities.last(1) }
+      specify { subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}})
+        .should == cities.first(2) + [nil] }
+    end
   end
 end

data/spec/chewy/type/import_spec.rb

@@ -122,7 +122,7 @@ describe Chewy::Type::Import do
             define_type City do
               field :name, type: 'object'
             end
-          end.tap(&:create!)
+          end
         end
 
         specify do
@@ -152,7 +152,7 @@ describe Chewy::Type::Import do
             define_type City do
               field :name, type: 'object'
             end
-          end.tap(&:create!)
+          end
         end
 
         specify { city.import(dummy_cities).should be_false }
@@ -166,7 +166,7 @@ describe Chewy::Type::Import do
             define_type City do
               field :name, type: 'object', value: ->{ name == 'name1' ? name : {name: name} }
             end
-          end.tap(&:create!)
+          end
         end
 
         specify { city.import(dummy_cities).should be_false }
@@ -185,7 +185,7 @@ describe Chewy::Type::Import do
           define_type City do
             field :name, type: 'object'
           end
-        end.tap(&:create!)
+        end
       end
 
       specify { expect { city.import!(dummy_cities) }.to raise_error Chewy::FailedImport }

data/spec/spec_helper.rb

@@ -27,7 +27,14 @@ ActiveRecord::Schema.define do
   end
 end
 
-Chewy.configuration = {host: 'localhost:9250', index: {number_of_shards: 1, number_of_replicas: 0}}
+Chewy.configuration = {
+  host: 'localhost:9250',
+  wait_for_status: 'green',
+  index: {
+    number_of_shards: 1,
+    number_of_replicas: 0
+  }
+}
 
 RSpec.configure do |config|
   config.mock_with :rspec

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - pyromaniac
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-04 00:00:00.000000000 Z
+date: 2014-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
 description: Chewy provides functionality for Elasticsearch index handling, documents
   import mappings and chainable query DSL
 email:
@@ -155,6 +155,8 @@ files:
 - Rakefile
 - chewy.gemspec
 - filters
+- gemfiles/Gemfile.rails-3.2
+- gemfiles/Gemfile.rails-4.0
 - lib/chewy.rb
 - lib/chewy/config.rb
 - lib/chewy/errors.rb
@@ -268,7 +270,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Elasticsearch ODM client wrapper