chewy 0.5.2 → 0.6.0

data/spec/chewy/fields/root_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Fields::Root do
-  specify { described_class.new('name').value.should be_a(Proc) }
+  specify { expect(described_class.new('name').value).to be_a(Proc) }
   # TODO: add 'should_behave_like base_field'
 
   subject(:field) { described_class.new('product') }
@@ -16,7 +16,7 @@ describe Chewy::Fields::Root do
       field.dynamic_template template_42: {mapping: {}, match: ''}
       field.dynamic_template /hello\..*/
 
-      field.mappings_hash.should == {product: {dynamic_templates: [
+      expect(field.mappings_hash).to eq({product: {dynamic_templates: [
         {template_1: {mapping: {type: 'string'}, match: 'hello'}},
         {template_2: {mapping: {}, match_mapping_type: 'integer', match: 'hello*'}},
         {template_3: {mapping: {}, path_match: 'hello.*'}},
@@ -24,7 +24,7 @@ describe Chewy::Fields::Root do
         {template_5: {mapping: {}, match: 'hello.*', match_pattern: 'regexp'}},
         {template_42: {mapping: {}, match: ''}},
         {template_7: {mapping: {}, path_match: 'hello\..*', match_pattern: 'regexp'}}
-      ]}}
+      ]}})
     end
 
     context do
@@ -34,10 +34,10 @@ describe Chewy::Fields::Root do
 
       specify do
         field.dynamic_template 'hello', type: 'string'
-        field.mappings_hash.should == {product: {dynamic_templates: [
+        expect(field.mappings_hash).to eq({product: {dynamic_templates: [
           {template_42: {mapping: {}, match: ''}},
           {template_1: {mapping: {type: 'string'}, match: 'hello'}}
-        ]}}
+        ]}})
       end
     end
   end

data/spec/chewy/index/actions_spec.rb

@@ -1,56 +1,56 @@
 require 'spec_helper'
 
 describe Chewy::Index::Actions do
-  before { Chewy.client.indices.delete index: '*' }
+  before { Chewy.massacre }
 
   before { stub_index :dummies }
 
   describe '.exists?' do
-    specify { DummiesIndex.exists?.should eq(false) }
+    specify { expect(DummiesIndex.exists?).to eq(false) }
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.exists?.should eq(true) }
+      specify { expect(DummiesIndex.exists?).to eq(true) }
     end
   end
 
   describe '.create' do
-    specify { DummiesIndex.create["acknowledged"].should eq(true) }
-    specify { DummiesIndex.create('2013')["acknowledged"].should eq(true) }
+    specify { expect(DummiesIndex.create["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.create('2013')["acknowledged"]).to eq(true) }
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.create.should eq(false) }
-      specify { DummiesIndex.create('2013').should eq(false) }
+      specify { expect(DummiesIndex.create).to eq(false) }
+      specify { expect(DummiesIndex.create('2013')).to eq(false) }
     end
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
-      specify { DummiesIndex.create('2013').should eq(false) }
-      specify { DummiesIndex.create('2014')["acknowledged"].should eq(true) }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
+      specify { expect(DummiesIndex.create('2013')).to eq(false) }
+      specify { expect(DummiesIndex.create('2014')["acknowledged"]).to eq(true) }
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { DummiesIndex.indexes.should =~ ['dummies_2013', 'dummies_2014'] }
+        specify { expect(DummiesIndex.indexes).to match_array(['dummies_2013', 'dummies_2014']) }
       end
     end
 
     context do
       before { DummiesIndex.create '2013', alias: false }
-      specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == [] }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq([]) }
     end
   end
 
   describe '.create!' do
-    specify { DummiesIndex.create!["acknowledged"].should eq(true) }
-    specify { DummiesIndex.create!('2013')["acknowledged"].should eq(true) }
+    specify { expect(DummiesIndex.create!["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.create!('2013')["acknowledged"]).to eq(true) }
 
     context do
       before { DummiesIndex.create }
@@ -60,68 +60,68 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create! '2013' }
-      specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify { expect { DummiesIndex.create!('2013') }.to raise_error }
-      specify { DummiesIndex.create!('2014')["acknowledged"].should eq(true) }
+      specify { expect(DummiesIndex.create!('2014')["acknowledged"]).to eq(true) }
 
       context do
         before { DummiesIndex.create! '2014' }
-        specify { DummiesIndex.indexes.should =~ ['dummies_2013', 'dummies_2014'] }
+        specify { expect(DummiesIndex.indexes).to match_array(['dummies_2013', 'dummies_2014']) }
       end
     end
 
     context do
       before { DummiesIndex.create! '2013', alias: false }
-      specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == [] }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+      specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq([]) }
     end
   end
 
   describe '.delete' do
-    specify { DummiesIndex.delete.should eq(false) }
-    specify { DummiesIndex.delete('dummies_2013').should eq(false) }
+    specify { expect(DummiesIndex.delete).to eq(false) }
+    specify { expect(DummiesIndex.delete('dummies_2013')).to eq(false) }
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.delete["acknowledged"].should eq(true) }
+      specify { expect(DummiesIndex.delete["acknowledged"]).to eq(true) }
 
       context do
         before { DummiesIndex.delete }
-        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
       end
     end
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { DummiesIndex.delete('2013')["acknowledged"].should eq(true) }
+      specify { expect(DummiesIndex.delete('2013')["acknowledged"]).to eq(true) }
 
       context do
         before { DummiesIndex.delete('2013') }
-        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
-        specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
       end
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { DummiesIndex.delete["acknowledged"].should eq(true) }
+        specify { expect(DummiesIndex.delete["acknowledged"]).to eq(true) }
 
         context do
           before { DummiesIndex.delete }
-          specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
         end
 
         context do
           before { DummiesIndex.delete('2014') }
-          specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
         end
       end
     end
@@ -133,149 +133,149 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.delete!["acknowledged"].should eq(true) }
+      specify { expect(DummiesIndex.delete!["acknowledged"]).to eq(true) }
 
       context do
         before { DummiesIndex.delete! }
-        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
       end
     end
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { DummiesIndex.delete!('2013')["acknowledged"].should eq(true) }
+      specify { expect(DummiesIndex.delete!('2013')["acknowledged"]).to eq(true) }
 
       context do
         before { DummiesIndex.delete!('2013') }
-        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
-        specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
       end
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { DummiesIndex.delete!["acknowledged"].should eq(true) }
+        specify { expect(DummiesIndex.delete!["acknowledged"]).to eq(true) }
 
         context do
           before { DummiesIndex.delete! }
-          specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
         end
 
         context do
           before { DummiesIndex.delete!('2014') }
-          specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
         end
       end
     end
   end
 
   describe '.purge' do
-    specify { DummiesIndex.purge["acknowledged"].should eq(true) }
-    specify { DummiesIndex.purge('2013')["acknowledged"].should eq(true) }
+    specify { expect(DummiesIndex.purge["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.purge('2013')["acknowledged"]).to eq(true) }
 
     context do
       before { DummiesIndex.purge }
-      specify { DummiesIndex.should be_exists }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == [] }
+      specify { expect(DummiesIndex).to be_exists }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq([]) }
 
       context do
         before { DummiesIndex.purge }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == [] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq([]) }
       end
 
       context do
         before { DummiesIndex.purge('2013') }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       end
     end
 
     context do
       before { DummiesIndex.purge('2013') }
-      specify { DummiesIndex.should be_exists }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      specify { expect(DummiesIndex).to be_exists }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
 
       context do
         before { DummiesIndex.purge }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == [] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq([]) }
       end
 
       context do
         before { DummiesIndex.purge('2014') }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == ['dummies_2014'] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies_2014']) }
       end
     end
   end
 
   describe '.purge!' do
-    specify { DummiesIndex.purge!["acknowledged"].should eq(true) }
-    specify { DummiesIndex.purge!('2013')["acknowledged"].should eq(true) }
+    specify { expect(DummiesIndex.purge!["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.purge!('2013')["acknowledged"]).to eq(true) }
 
     context do
       before { DummiesIndex.purge! }
-      specify { DummiesIndex.should be_exists }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == [] }
+      specify { expect(DummiesIndex).to be_exists }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq([]) }
 
       context do
         before { DummiesIndex.purge! }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == [] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq([]) }
       end
 
       context do
         before { DummiesIndex.purge!('2013') }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       end
     end
 
     context do
       before { DummiesIndex.purge!('2013') }
-      specify { DummiesIndex.should be_exists }
-      specify { DummiesIndex.aliases.should == [] }
-      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      specify { expect(DummiesIndex).to be_exists }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
 
       context do
         before { DummiesIndex.purge! }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == [] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq([]) }
       end
 
       context do
         before { DummiesIndex.purge!('2014') }
-        specify { DummiesIndex.should be_exists }
-        specify { DummiesIndex.aliases.should == [] }
-        specify { DummiesIndex.indexes.should == ['dummies_2014'] }
+        specify { expect(DummiesIndex).to be_exists }
+        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies_2014']) }
       end
     end
   end
 
-  describe '.import' do
+  describe '.import', :orm do
     before do
       stub_model(:city)
       stub_index(:cities) do
         define_type City
       end
     end
-    let!(:dummy_cities) { 3.times.map { |i| City.create(name: "name#{i}") } }
+    let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
 
-    specify { CitiesIndex.import.should == true }
+    specify { expect(CitiesIndex.import).to eq(true) }
 
     context do
       before do
@@ -286,20 +286,20 @@ describe Chewy::Index::Actions do
         end
       end
 
-      specify { CitiesIndex.import(city: dummy_cities).should == false }
+      specify { expect(CitiesIndex.import(city: dummy_cities)).to eq(false) }
     end
   end
 
-  describe '.import!' do
+  describe '.import!', :orm do
     before do
       stub_model(:city)
       stub_index(:cities) do
         define_type City
       end
     end
-    let!(:dummy_cities) { 3.times.map { |i| City.create(name: "name#{i}") } }
+    let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
 
-    specify { CitiesIndex.import!.should == true }
+    specify { expect(CitiesIndex.import!).to eq(true) }
 
     context do
       before do
@@ -314,7 +314,7 @@ describe Chewy::Index::Actions do
     end
   end
 
-  describe '.reset!' do
+  describe '.reset!', :orm do
     before do
       stub_model(:city)
       stub_index(:cities) do
@@ -322,58 +322,58 @@ describe Chewy::Index::Actions do
       end
     end
 
-    before { City.create!(name: 'Moscow') }
+    before { City.create!(id: 1, name: 'Moscow') }
 
-    specify { CitiesIndex.reset!.should eq(true) }
-    specify { CitiesIndex.reset!('2013').should eq(true) }
+    specify { expect(CitiesIndex.reset!).to eq(true) }
+    specify { expect(CitiesIndex.reset!('2013')).to eq(true) }
 
     context do
       before { CitiesIndex.reset! }
 
-      specify { CitiesIndex.all.should have(1).item }
-      specify { CitiesIndex.aliases.should == [] }
-      specify { CitiesIndex.indexes.should == [] }
+      specify { expect(CitiesIndex.all).to have(1).item }
+      specify { expect(CitiesIndex.aliases).to eq([]) }
+      specify { expect(CitiesIndex.indexes).to eq([]) }
 
       context do
         before { CitiesIndex.reset!('2013') }
 
-        specify { CitiesIndex.all.should have(1).item }
-        specify { CitiesIndex.aliases.should == [] }
-        specify { CitiesIndex.indexes.should == ['cities_2013'] }
+        specify { expect(CitiesIndex.all).to have(1).item }
+        specify { expect(CitiesIndex.aliases).to eq([]) }
+        specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
       end
 
       context do
         before { CitiesIndex.reset! }
 
-        specify { CitiesIndex.all.should have(1).item }
-        specify { CitiesIndex.aliases.should == [] }
-        specify { CitiesIndex.indexes.should == [] }
+        specify { expect(CitiesIndex.all).to have(1).item }
+        specify { expect(CitiesIndex.aliases).to eq([]) }
+        specify { expect(CitiesIndex.indexes).to eq([]) }
       end
     end
 
     context do
       before { CitiesIndex.reset!('2013') }
 
-      specify { CitiesIndex.all.should have(1).item }
-      specify { CitiesIndex.aliases.should == [] }
-      specify { CitiesIndex.indexes.should == ['cities_2013'] }
+      specify { expect(CitiesIndex.all).to have(1).item }
+      specify { expect(CitiesIndex.aliases).to eq([]) }
+      specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
 
       context do
         before { CitiesIndex.reset!('2014') }
 
-        specify { CitiesIndex.all.should have(1).item }
-        specify { CitiesIndex.aliases.should == [] }
-        specify { CitiesIndex.indexes.should == ['cities_2014'] }
-        specify { Chewy.client.indices.exists(index: 'cities_2013').should eq(false) }
+        specify { expect(CitiesIndex.all).to have(1).item }
+        specify { expect(CitiesIndex.aliases).to eq([]) }
+        specify { expect(CitiesIndex.indexes).to eq(['cities_2014']) }
+        specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
       end
 
       context do
         before { CitiesIndex.reset! }
 
-        specify { CitiesIndex.all.should have(1).item }
-        specify { CitiesIndex.aliases.should == [] }
-        specify { CitiesIndex.indexes.should == [] }
-        specify { Chewy.client.indices.exists(index: 'cities_2013').should eq(false) }
+        specify { expect(CitiesIndex.all).to have(1).item }
+        specify { expect(CitiesIndex.aliases).to eq([]) }
+        specify { expect(CitiesIndex.indexes).to eq([]) }
+        specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
       end
     end
   end