chewy 0.4.1 → 0.5.0

data/spec/chewy/query_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
 describe Chewy::Query do
-  include ClassHelpers
-  before { Chewy.client.indices.delete index: '*' }
+  before do
+    Chewy.client.indices.delete index: '*'
+  end
 
   before do
     stub_index(:products) do
@@ -16,6 +17,10 @@ describe Chewy::Query do
 
   subject { described_class.new(ProductsIndex) }
 
+  context 'unexistent index' do
+    specify { subject.to_a.should == [] }
+  end
+
   context 'integration' do
     let(:products) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
     let(:cities) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
@@ -27,8 +32,11 @@ describe Chewy::Query do
     end
 
     specify { subject.count.should == 9 }
+    specify { subject.first._data.should be_a Hash }
     specify { subject.limit(6).count.should == 6 }
     specify { subject.offset(6).count.should == 3 }
+    specify { subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name.should == '<em>Name3</em>' }
+    specify { subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first._data['_source']['name'].should == 'Name3' }
     specify { subject.types(:product).count.should == 3 }
     specify { subject.types(:product, :country).count.should == 6 }
     specify { subject.filter(term: {age: 10}).count.should == 1 }
@@ -60,39 +68,25 @@ describe Chewy::Query do
     specify { expect { subject.filter_mode(:or) }.not_to change { subject.criteria.options } }
   end
 
+  describe '#post_filter_mode' do
+    specify { subject.post_filter_mode(:or).should be_a described_class }
+    specify { subject.post_filter_mode(:or).should_not == subject }
+    specify { subject.post_filter_mode(:or).criteria.options.should include(post_filter_mode: :or) }
+    specify { expect { subject.post_filter_mode(:or) }.not_to change { subject.criteria.options } }
+  end
+
   describe '#limit' do
     specify { subject.limit(10).should be_a described_class }
     specify { subject.limit(10).should_not == subject }
-    specify { subject.limit(10).criteria.options.should include(size: 10) }
-    specify { expect { subject.limit(10) }.not_to change { subject.criteria.options } }
+    specify { subject.limit(10).criteria.request_options.should include(size: 10) }
+    specify { expect { subject.limit(10) }.not_to change { subject.criteria.request_options } }
   end
 
   describe '#offset' do
     specify { subject.offset(10).should be_a described_class }
     specify { subject.offset(10).should_not == subject }
-    specify { subject.offset(10).criteria.options.should include(from: 10) }
-    specify { expect { subject.offset(10) }.not_to change { subject.criteria.options } }
-  end
-
-  describe '#none' do
-    specify { subject.none.should be_a described_class }
-    specify { subject.none.should_not == subject }
-    specify { subject.none.criteria.should be_none }
-
-    context do
-      before { described_class.any_instance.should_not_receive(:_response) }
-
-      specify { subject.none.to_a.should == [] }
-      specify { subject.query(match: 'hello').none.to_a.should == [] }
-      specify { subject.none.query(match: 'hello').to_a.should == [] }
-    end
-  end
-
-  describe '#query' do
-    specify { subject.query(match: 'hello').should be_a described_class }
-    specify { subject.query(match: 'hello').should_not == subject }
-    specify { subject.query(match: 'hello').criteria.queries.should include(match: 'hello') }
-    specify { expect { subject.query(match: 'hello') }.not_to change { subject.criteria.queries } }
+    specify { subject.offset(10).criteria.request_options.should include(from: 10) }
+    specify { expect { subject.offset(10) }.not_to change { subject.criteria.request_options } }
   end
 
   describe '#facets' do
@@ -105,29 +99,27 @@ describe Chewy::Query 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
+      before do
+        stub_index(:cities) do
+          define_type :city do
+            field :rating, type: 'integer'
           end
         end
+      end
 
-        before { CitiesIndex::City.import! cities }
+      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
+      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
 
@@ -156,9 +148,9 @@ describe Chewy::Query do
         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}
+              {'key' => 0, 'key_as_string' => '0', 'doc_count' => 4},
+              {'key' => 1, 'key_as_string' => '1', 'doc_count' => 3},
+              {'key' => 2, 'key_as_string' => '2', 'doc_count' => 3}
             ]
           }
         } }
@@ -166,6 +158,72 @@ describe Chewy::Query do
     end
   end
 
+  describe '#suggest' do
+    specify { subject.suggest(name1: {text: 'hello', term: {field: 'name'}}) }
+    specify { subject.suggest(name1: {text: 'hello'}).should_not == subject }
+    specify { subject.suggest(name1: {text: 'hello'}).criteria.suggest.should include(name1: {text: 'hello'}) }
+    specify { expect { subject.suggest(name1: {text: 'hello'}) }.not_to change { subject.criteria.suggest } }
+
+    context 'results' do
+      before { stub_model(:city) }
+      let(:cities) { 10.times.map { |i| City.create! name: "name#{i}" } }
+
+      context do
+        before do
+          stub_index(:cities) do
+            define_type :city do
+              field :name
+            end
+          end
+        end
+
+        before { CitiesIndex::City.import! cities }
+
+        specify { CitiesIndex.suggest.should == {} }
+        specify { CitiesIndex.suggest(name: {text: 'name', term: {field: 'name'}}).suggest.should == {
+          'name' => [
+            {'text' => 'name', 'offset' => 0, 'length' => 4, 'options' => [
+                {'text' => 'name0', 'score' => 0.75, 'freq' => 1},
+                {'text' => 'name1', 'score' => 0.75, 'freq' => 1},
+                {'text' => 'name2', 'score' => 0.75, 'freq' => 1},
+                {'text' => 'name3', 'score' => 0.75, 'freq' => 1},
+                {'text' => 'name4', 'score' => 0.75, 'freq' => 1}
+              ]
+            }
+          ] }
+        }
+      end
+    end
+  end
+
+  describe '#none' do
+    specify { subject.none.should be_a described_class }
+    specify { subject.none.should_not == subject }
+    specify { subject.none.criteria.should be_none }
+
+    context do
+      before { described_class.any_instance.should_not_receive(:_response) }
+
+      specify { subject.none.to_a.should == [] }
+      specify { subject.query(match: 'hello').none.to_a.should == [] }
+      specify { subject.none.query(match: 'hello').to_a.should == [] }
+    end
+  end
+
+  describe '#strategy' do
+    specify { subject.strategy('query_first').should be_a described_class }
+    specify { subject.strategy('query_first').should_not == subject }
+    specify { subject.strategy('query_first').criteria.options.should include(strategy: 'query_first') }
+    specify { expect { subject.strategy('query_first') }.not_to change { subject.criteria.options } }
+  end
+
+  describe '#query' do
+    specify { subject.query(match: 'hello').should be_a described_class }
+    specify { subject.query(match: 'hello').should_not == subject }
+    specify { subject.query(match: 'hello').criteria.queries.should include(match: 'hello') }
+    specify { expect { subject.query(match: 'hello') }.not_to change { subject.criteria.queries } }
+  end
+
   describe '#filter' do
     specify { subject.filter(term: {field: 'hello'}).should be_a described_class }
     specify { subject.filter(term: {field: 'hello'}).should_not == subject }
@@ -177,6 +235,17 @@ describe Chewy::Query do
     specify { subject.filter{ name == 'John' }.criteria.filters.should == [{term: {'name' => 'John'}}] }
   end
 
+  describe '#post_filter' do
+    specify { subject.post_filter(term: {field: 'hello'}).should be_a described_class }
+    specify { subject.post_filter(term: {field: 'hello'}).should_not == subject }
+    specify { expect { subject.post_filter(term: {field: 'hello'}) }.not_to change { subject.criteria.post_filters } }
+    specify { subject.post_filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.post_filters
+      .should == [{term: {field: 'hello'}}, {term: {field: 'world'}}] }
+
+    specify { expect { subject.post_filter{ name == 'John' } }.not_to change { subject.criteria.post_filters } }
+    specify { subject.post_filter{ name == 'John' }.criteria.post_filters.should == [{term: {'name' => 'John'}}] }
+  end
+
   describe '#order' do
     specify { subject.order(field: 'hello').should be_a described_class }
     specify { subject.order(field: 'hello').should_not == subject }
@@ -251,7 +320,7 @@ describe Chewy::Query do
       .should == [{term: {'name' => 'name'}}, {term: {'age' => 42}}] }
   end
 
-  describe 'to_a' do
+  describe '#to_a' do
     before { stub_model(:city) }
     let(:cities) { 3.times.map { |i| City.create! name: "name#{i}", rating: i } }
 
@@ -282,8 +351,8 @@ describe Chewy::Query do
       specify { CitiesIndex.all.first._score.should be > 0 }
       specify { CitiesIndex.query(match: {name: 'name0'}).first._score.should be > 0 }
 
-      specify { CitiesIndex.order(:rating).first._explanation.should be_nil }
-      specify { CitiesIndex.order(:rating).explain.first._explanation.should be_present }
+      specify { CitiesIndex.order(:rating).first._data['_explanation'].should be_nil }
+      specify { CitiesIndex.order(:rating).explain.first._data['_explanation'].should be_present }
     end
 
     context 'sourceless' do

data/spec/chewy/rspec/update_index_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe :update_index do
-  include ClassHelpers
   before { Chewy.client.indices.delete index: '*' }
 
   before do

data/spec/chewy/runtime/version_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Chewy::Runtime::Version do
+  describe '#major' do
+    specify { described_class.new('1.2.3').major.should == 1 }
+    specify { described_class.new('1.2').major.should == 1 }
+    specify { described_class.new(1.2).major.should == 1 }
+    specify { described_class.new('1').major.should == 1 }
+    specify { described_class.new('').major.should == 0 }
+  end
+
+  describe '#minor' do
+    specify { described_class.new('1.2.3').minor.should == 2 }
+    specify { described_class.new('1.2').minor.should == 2 }
+    specify { described_class.new(1.2).minor.should == 2 }
+    specify { described_class.new('1').minor.should == 0 }
+  end
+
+  describe '#patch' do
+    specify { described_class.new('1.2.3').patch.should == 3 }
+    specify { described_class.new('1.2.3.pre1').patch.should == 3 }
+    specify { described_class.new('1.2').patch.should == 0 }
+    specify { described_class.new(1.2).patch.should == 0 }
+  end
+
+  describe '#to_s' do
+    specify { described_class.new('1.2.3').to_s.should == '1.2.3' }
+    specify { described_class.new('1.2.3.pre1').to_s.should == '1.2.3' }
+    specify { described_class.new('1.2').to_s.should == '1.2.0' }
+    specify { described_class.new(1.2).to_s.should == '1.2.0' }
+    specify { described_class.new('1').to_s.should == '1.0.0' }
+    specify { described_class.new('').to_s.should == '0.0.0' }
+  end
+
+  describe '#<=>' do
+    specify { described_class.new('1.2.3').should == '1.2.3' }
+    specify { described_class.new('1.2.3').should be < '1.2.4' }
+    specify { described_class.new('1.2.3').should be < '1.2.10' }
+    specify { described_class.new('1.10.2').should be == '1.10.2' }
+    specify { described_class.new('1.10.2').should be > '1.7.2' }
+    specify { described_class.new('2.10.2').should be > '1.7.2' }
+    specify { described_class.new('1.10.2').should be < '2.7.2' }
+    specify { described_class.new('1.10.2').should be < described_class.new('2.7.2') }
+    specify { described_class.new('1.10.2').should be < 2.7 }
+    specify { described_class.new('1.10.2').should be < 1.11 }
+    specify { described_class.new('1.2.0').should be == '1.2' }
+  end
+end

data/spec/chewy/runtime_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Chewy::Runtime do
+  describe '.version' do
+    specify { described_class.version.should be_a(described_class::Version) }
+    specify { described_class.version.should be >= '1.0' }
+    specify { described_class.version.should be < '1.3' }
+  end
+end

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

@@ -7,12 +7,26 @@ describe Chewy::Type::Adapter::ActiveRecord do
     specify { described_class.new(City).name.should == 'City' }
     specify { described_class.new(City.order(:id)).name.should == 'City' }
     specify { described_class.new(City, name: 'town').name.should == 'Town' }
+
+    context do
+      before { stub_model('namespace/city') }
+
+      specify { described_class.new(Namespace::City).name.should == 'City' }
+      specify { described_class.new(Namespace::City.order(:id)).name.should == 'City' }
+    end
   end
 
   describe '#type_name' do
     specify { described_class.new(City).type_name.should == 'city' }
     specify { described_class.new(City.order(:id)).type_name.should == 'city' }
     specify { described_class.new(City, name: 'town').type_name.should == 'town' }
+
+    context do
+      before { stub_model('namespace/city') }
+
+      specify { described_class.new(Namespace::City).type_name.should == 'city' }
+      specify { described_class.new(Namespace::City.order(:id)).type_name.should == 'city' }
+    end
   end
 
   describe '#import' do
@@ -43,6 +57,7 @@ describe Chewy::Type::Adapter::ActiveRecord do
           {delete: deleted.last(2)}] }
 
       specify { import(cities.map(&:id)).should == [{index: cities}] }
+      specify { import(deleted.map(&:id)).should == [{delete: deleted.map(&:id)}] }
       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))
@@ -52,6 +67,43 @@ describe Chewy::Type::Adapter::ActiveRecord do
         {index: cities.last(1)},
         {delete: deleted.first(2).map(&:id)},
         {delete: deleted.last(1).map(&:id)}] }
+
+      context do
+        before { deleted.map { |object| object.stub(delete_from_index?: true, destroyed?: true) } }
+        specify { import(deleted).should == [{delete: deleted}] }
+      end
+
+      context do
+        before { deleted.map { |object| object.stub(delete_from_index?: true, destroyed?: false) } }
+        specify { import(deleted).should == [{delete: deleted}] }
+      end
+
+      context do
+        before { deleted.map { |object| object.stub(delete_from_index?: false, destroyed?: true) } }
+        specify { import(deleted).should == [{delete: deleted}] }
+      end
+
+      context do
+        before { deleted.map { |object| object.stub(delete_from_index?: false, destroyed?: false) } }
+        specify { import(deleted).should == [{index: deleted}] }
+      end
+    end
+
+    describe '#delete_from_index?' do
+      before do
+        stub_model(:city) do
+          def delete_from_index?
+            rating == 42
+          end
+        end
+      end
+      let!(:cities) { 3.times.map { |i| City.create! } }
+      let!(:deleted) { 3.times.map { |i| City.create!(rating: 42) } }
+      subject { described_class.new(City) }
+
+      specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
+      specify { import(cities.map(&:id), deleted.map(&:id))
+        .should == [{index: cities, delete: deleted}] }
     end
 
     context 'custom primary_key' do

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

@@ -8,6 +8,12 @@ describe Chewy::Type::Adapter::Object do
     specify { described_class.new(:products).name.should == 'Products' }
     specify { described_class.new(Product).name.should == 'Product' }
     specify { described_class.new(Product, name: 'house').name.should == 'House' }
+
+    context do
+      before { stub_class('namespace/product') }
+
+      specify { described_class.new(Namespace::Product).name.should == 'Product' }
+    end
   end
 
   describe '#type_name' do
@@ -15,6 +21,12 @@ describe Chewy::Type::Adapter::Object do
     specify { described_class.new(:products).type_name.should == 'products' }
     specify { described_class.new(Product).type_name.should == 'product' }
     specify { described_class.new(Product, name: 'house').type_name.should == 'house' }
+
+    context do
+      before { stub_class('namespace/product') }
+
+      specify { described_class.new(Namespace::Product).type_name.should == 'product' }
+    end
   end
 
   describe '#import' do
@@ -41,6 +53,27 @@ describe Chewy::Type::Adapter::Object do
           {index: objects.first(2)},
           {index: objects.last(1), delete: deleted.first(1)},
           {delete: deleted.last(1)}] }
+
+      context do
+        let(:deleted) { 2.times.map { |i| double(delete_from_index?: true, destroyed?: true) } }
+        specify { import(deleted).should == [{delete: deleted}] }
+      end
+
+      context do
+        let(:deleted) { 2.times.map { |i| double(delete_from_index?: true, destroyed?: false) } }
+        specify { import(deleted).should == [{delete: deleted}] }
+      end
+
+
+      context do
+        let(:deleted) { 2.times.map { |i| double(delete_from_index?: false, destroyed?: true) } }
+        specify { import(deleted).should == [{delete: deleted}] }
+      end
+
+      context do
+        let(:deleted) { 2.times.map { |i| double(delete_from_index?: false, destroyed?: false) } }
+        specify { import(deleted).should == [{index: deleted}] }
+      end
     end
 
     context do