couch_potato 1.4.0 → 1.6.3

data/spec/unit/rspec_stub_db_spec.rb

@@ -1,66 +1,67 @@
 require 'spec_helper'
-require 'couch_potato/rspec'
+require 'couch_potato-rspec'
 
 class WithStubbedView
   include CouchPotato::Persistence
-  
-  view :stubbed_view, :key => :x
+
+  view :stubbed_view, key: :x
 end
 
-describe "stubbing the db" do
-  it "should replace CouchPotato.database with a stub" do
-    stub_db
-    CouchPotato.database.should be_a(RSpec::Mocks::Mock)
+describe 'stubbing the db' do
+  it 'replaces CouchPotato.database with a double' do
+    CouchPotato.stub_db
+
+    expect(CouchPotato.database).to be_a(RSpec::Mocks::Double)
   end
-  
-  it "should return the stub" do
-    db = stub_db
-    CouchPotato.database.should == db
+
+  it 'returns the stub' do
+    db = CouchPotato.stub_db
+
+    expect(CouchPotato.database).to eq(db)
   end
 end
 
-describe "stubbing a view" do
+describe 'stubbing a view' do
   before(:each) do
-    @db = stub_db
+    @db = CouchPotato.stub_db
     @db.stub_view(WithStubbedView, :stubbed_view).with('123').and_return([:result])
   end
-  
-  it "should stub the view to return a stub" do
-    WithStubbedView.stubbed_view('123').should be_a(RSpec::Mocks::Mock)
+
+  it 'stubs the view to return a double' do
+    expect(WithStubbedView.stubbed_view('123')).to be_a(RSpec::Mocks::Double)
   end
-  
-  it "should stub the database to return fake results when called with the stub" do
-    @db.view(WithStubbedView.stubbed_view('123')).should == [:result]
+
+  it 'stubs the database to return fake results when called with the stub' do
+    expect(@db.view(WithStubbedView.stubbed_view('123'))).to eq([:result])
   end
-  
-  it "stubs the database to return the first fake result" do
-    @db.first(WithStubbedView.stubbed_view('123')).should == :result
-    @db.first!(WithStubbedView.stubbed_view('123')).should == :result
+
+  it 'stubs the database to return the first fake result' do
+    expect(@db.first(WithStubbedView.stubbed_view('123'))).to eq(:result)
+    expect(@db.first!(WithStubbedView.stubbed_view('123'))).to eq(:result)
   end
-  
-  it "raises an error if there is no first result" do
+
+  it 'raises an error if there is no first result' do
     @db.stub_view(WithStubbedView, :stubbed_view).and_return([])
-    lambda {
+    expect do
       @db.first!(WithStubbedView.stubbed_view('123'))
-    }.should raise_error(CouchPotato::NotFound)
+    end.to raise_error(CouchPotato::NotFound)
   end
-  
+
   it "skips stubbing the first view (i.e. doesn't crash) if the fake result does not respond to first" do
     @db.stub_view(WithStubbedView, :stubbed_view).with('123').and_return(:results)
-    
-    @db.view(WithStubbedView.stubbed_view('123')).should == :results
+
+    expect(@db.view(WithStubbedView.stubbed_view('123'))).to eq(:results)
   end
-  
-  it "supports the block style return syntax with `with`" do
-    @db.stub_view(WithStubbedView, :stubbed_view).with('123') {:results}
-    
-    @db.view(WithStubbedView.stubbed_view('123')).should == :results
+
+  it 'supports the block style return syntax with `with`' do
+    @db.stub_view(WithStubbedView, :stubbed_view).with('123') { :results }
+
+    expect(@db.view(WithStubbedView.stubbed_view('123'))).to eq(:results)
   end
-  
-  it "supports the block style return syntax without `with`" do
-    @db.stub_view(WithStubbedView, :stubbed_view) {:results}
-    
-    @db.view(WithStubbedView.stubbed_view('123')).should == :results
+
+  it 'supports the block style return syntax without `with`' do
+    @db.stub_view(WithStubbedView, :stubbed_view) { :results }
+
+    expect(@db.view(WithStubbedView.stubbed_view('123'))).to eq(:results)
   end
-  
-end
+end

data/spec/unit/string_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe String, 'camelize' do
   it "should camelize a string" do
-    'my_string'.camelize.should == 'MyString'
+    expect('my_string'.camelize).to eq('MyString')
   end
 end

data/spec/unit/time_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Time, 'to_json' do
   it "should convert to utc and format the time in a way that i can use it for sorting in couchdb" do
     time = Time.parse('2009-01-01 11:12:23 +0200')
-    time.to_json.should == "\"2009/01/01 09:12:23 +0000\""
+    expect(time.to_json).to eq("\"2009/01/01 09:12:23 +0000\"")
   end
 end
 
 describe Time, 'as_json' do
   it "should format it in the same way as to_json does so i can use this to do queries over time attributes" do
     time = Time.parse('2009-01-01 11:12:23 +0200')
-    time.as_json.should == "2009/01/01 09:12:23 +0000"
+    expect(time.as_json).to eq("2009/01/01 09:12:23 +0000")
   end
 end

data/spec/unit/validation_spec.rb

@@ -6,7 +6,7 @@ describe 'CouchPotato Validation' do
     it "should description" do
       model_class = Class.new
       model_class.send(:include, CouchPotato::Persistence)
-      model_class.new.errors.should respond_to(:errors)
+      expect(model_class.new.errors).to respond_to(:errors)
     end
   end
 

data/spec/unit/view_query_spec.rb

@@ -1,21 +1,20 @@
 require 'spec_helper'
 
 describe CouchPotato::View::ViewQuery, 'query_view!' do
+  let(:db) { double 'db', :get => nil, view: nil, :save_doc => nil,
+    connection: double.as_null_object, name: nil }
+
   before(:each) do
-    CouchRest.stub(:get => nil)
     CouchPotato::View::ViewQuery.clear_cache
   end
 
-  it "does not pass a key if conditions are empty" do
-    db = mock 'db', :get => nil, :save_doc => nil
-    db.should_receive(:view).with(anything, {})
+  it 'does not pass a key if conditions are empty' do
+    expect(db).to receive(:view).with(anything, {})
     CouchPotato::View::ViewQuery.new(db, '', {:view0 => {}}).query_view!
   end
 
   it 'updates a view if it does not exist' do
-    db = mock 'db', :get => nil, :view => nil
-
-    db.should_receive(:save_doc).with(
+    expect(db).to receive(:save_doc).with(
       'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}, 'lib' => {'test' => '<lib_code>'}},
       'lists' => {},
       "_id" => "_design/design",
@@ -26,21 +25,19 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
   end
 
   it 'only updates a view once' do
-    db = double :db, view: nil
-    db.stub(:get).and_return({'views' => {}}, {'views' => {}, x: 1}) # return something different on the second call otherwise it would never try to update the views twice
+    allow(db).to receive(:get).and_return({'views' => {}}, {'views' => {}, x: 1}) # return something different on the second call otherwise it would never try to update the views twice
     query = CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}})
 
-    db.should_receive(:save_doc).once
+    expect(db).to receive(:save_doc).once
 
     2.times { query.query_view! }
   end
 
   it 'updates a view again after clearing the view cache' do
-    db = double :db, view: nil
-    db.stub(:get).and_return({'views' => {}}, {'views' => {}, x: 1}) # return something different on the second call otherwise it would never try to update the views twice
+    allow(db).to receive(:get).and_return({'views' => {}}, {'views' => {}, x: 1}) # return something different on the second call otherwise it would never try to update the views twice
     query = CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}})
 
-    db.should_receive(:save_doc).twice
+    expect(db).to receive(:save_doc).twice
 
     query.query_view!
     CouchPotato::View::ViewQuery.clear_cache
@@ -48,9 +45,7 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
   end
 
   it 'updates a view in erlang if it does not exist' do
-    db = mock 'db', :get => nil, :view => nil
-
-    db.should_receive(:save_doc).with(
+    expect(db).to receive(:save_doc).with(
       'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
       'lists' => {}, "_id" => "_design/design", "language" => "erlang")
 
@@ -60,48 +55,48 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
   end
 
   it "does not update a view when the views object haven't changed" do
-    db = mock 'db', :get => {'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
-    db.should_not_receive(:save_doc)
+    allow(db).to receive(:get).and_return({'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}})
+    expect(db).not_to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, nil).query_view!
   end
 
   it "does not update a view when the list function hasn't changed" do
-    db = mock 'db', :get => {'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}, 'lists' => {'list0' => '<list_code>'}}, :view => nil
-    db.should_not_receive(:save_doc)
+    allow(db).to receive(:get).and_return({'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}, 'lists' => {'list0' => '<list_code>'}})
+    expect(db).not_to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list0 => '<list_code>').query_view!
   end
 
   it "does not update a view when the lib function hasn't changed" do
-    db = mock 'db', :get => {'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}, 'lib' => {'test' => '<lib_code>'}}}, :view => nil
+    allow(db).to receive(:get).and_return({'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}, 'lib' => {'test' => '<lib_code>'}}})
 
-    db.should_not_receive(:save_doc)
+    expect(db).not_to receive(:save_doc)
 
     CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, {'test' => "<lib_code>"}).query_view!
   end
 
-  it "updates a view when the map function has changed" do
-    db = mock 'db', :get => {'views' => {'view2' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
-    db.should_receive(:save_doc)
+  it 'updates a view when the map function has changed' do
+    allow(db).to receive(:get).and_return({'views' => {'view2' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}})
+    expect(db).to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', :view2 => {:map => '<new map_code>', :reduce => '<reduce_code>'}).query_view!
   end
 
-  it "updates a view when the map function has changed" do
-    db = mock 'db', :get => {'views' => {'view3' => {'map' => '<map_code>'}}}, :view => nil
-    db.should_receive(:save_doc)
+  it 'updates a view when the map function has changed' do
+    allow(db).to receive(:get).and_return({'views' => {'view3' => {'map' => '<map_code>'}}})
+    expect(db).to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', :view3 => {:map => '<new map_code>'}).query_view!
   end
 
-  it "updates a view when the lib hash has changed" do
-    db = mock 'db', :get => {'views' => {'view4' => {'map' => '<map_code>'}}}, 'lib' => {'test' => "<test_lib>"}, :view => nil
+  it 'updates a view when the lib hash has changed' do
+    allow(db).to receive(:get).and_return({'views' => {'view4' => {'map' => '<map_code>'}}}, 'lib' => {'test' => "<test_lib>"})
 
-    db.should_receive(:save_doc)
+    expect(db).to receive(:save_doc)
 
     CouchPotato::View::ViewQuery.new(db, 'design', {:view4 => {:map => '<map_code>'}}, nil, {:test => "<test_lib>"}).query_view!
   end
 
   it "doesn't override libs with different names" do
-    db = mock 'db', :get => {'views' => {'view5' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}}, :view => nil
-    db.should_receive(:save_doc).with({
+    allow(db).to receive(:get).and_return({'views' => {'view5' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}})
+    expect(db).to receive(:save_doc).with({
       'views' => {
         'view5' => {'map' => '<map_code>'},
         'lib' => {'test' => '<test_lib>', 'test1' => '<test1_lib>'}
@@ -110,10 +105,10 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     CouchPotato::View::ViewQuery.new(db, 'design', {:view5 => {:map => '<map_code>'}}, nil, {'test1' => '<test1_lib>'}).query_view!
   end
 
-  it "overrides libs with the same name" do
-    db = mock 'db', :get => {'views' => {'view6' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}}, :view => nil
+  it 'overrides libs with the same name' do
+    allow(db).to receive(:get).and_return({'views' => {'view6' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}})
 
-    db.should_receive(:save_doc).with({
+    expect(db).to receive(:save_doc).with({
       'views' => {
         'view6' => {'map' => '<map_code>'},
         'lib' => {'test' => '<test1_lib>'}
@@ -123,56 +118,56 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     CouchPotato::View::ViewQuery.new(db, 'design', {:view6 => {:map => '<map_code>'}}, nil, {'test' => '<test1_lib>'}).query_view!
   end
 
-  it "does not pass in reduce or lib keys if there is no lib or reduce object" do
-    db = mock 'db', :get => {'views' => {}}, :view => nil
-    db.should_receive(:save_doc).with('views' => {'view7' => {'map' => '<map code>'}})
+  it 'does not pass in reduce or lib keys if there is no lib or reduce object' do
+    allow(db).to receive(:get).and_return({'views' => {}})
+    expect(db).to receive(:save_doc).with('views' => {'view7' => {'map' => '<map code>'}})
     CouchPotato::View::ViewQuery.new(db, 'design', :view7 => {:map => '<map code>', :reduce => nil}).query_view!
   end
 
-  it "updates a view when the reduce function has changed" do
-    db = mock 'db', :get => {'views' => {'view8' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
-    db.should_receive(:save_doc)
+  it 'updates a view when the reduce function has changed' do
+    allow(db).to receive(:get).and_return({'views' => {'view8' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}})
+    expect(db).to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', :view8 => {:map => '<map_code>', :reduce => '<new reduce_code>'}).query_view!
   end
 
-  it "updates a view when the list function has changed" do
-    db = mock 'db', :get => {
+  it 'updates a view when the list function has changed' do
+    allow(db).to receive(:get).and_return({
       'views' => {'view9' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
       'lists' => {'list1' => '<list_code>'}
-      }, :view => nil
-    db.should_receive(:save_doc)
+      })
+    expect(db).to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', {:view9 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
   end
 
   it "updates a view when there wasn't a list function but now there is one" do
-    db = mock 'db', :get => {
+    allow(db).to receive(:get).and_return({
       'views' => {'view10' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
-      }, :view => nil
-    db.should_receive(:save_doc)
+      })
+    expect(db).to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', {:view10 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
   end
 
   it "does not update a view when there is a list function but no list function is passed" do
-    db = mock 'db', :get => {
+    allow(db).to receive(:get).and_return({
       'views' => {'view11' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
       'lists' => {'list1' => '<list_code>'}
-      }, :view => nil
-    db.should_not_receive(:save_doc)
+      })
+    expect(db).not_to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', {:view11 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
   end
 
   it "does not update a view when there were no lists before and no list function is passed" do
-    db = mock 'db', :get => {
+    allow(db).to receive(:get).and_return({
       'views' => {'view12' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
-      }, :view => nil
-    db.should_not_receive(:save_doc)
+      })
+    expect(db).not_to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', {:view12 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
   end
 
-  it "queries CouchRest directly when querying a list" do
-    db = stub('db').as_null_object
-    CouchRest.should_receive(:get).with('http://127.0.0.1:5984/couch_potato_test/_design/my_design/_list/list1/view13?key=1')
+  it "queries the database directly when querying a list" do
+    allow(db).to receive(:name){'my_database'}
+
+    expect(db.connection).to receive(:get).with('/my_database/_design/my_design/_list/list1/view13?key=1')
     CouchPotato::View::ViewQuery.new(db, 'my_design', {:view13 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!(:key => 1)
   end
-
 end

data/spec/update_spec.rb

@@ -14,27 +14,27 @@ describe "create" do
     old_rev = @comment._rev
     @comment.title = 'xyz'
     CouchPotato.database.save_document! @comment
-    @comment._rev.should_not == old_rev
-    @comment._rev.should_not be_nil
+    expect(@comment._rev).not_to eq(old_rev)
+    expect(@comment._rev).not_to be_nil
   end
   
   it "should not update created at" do
     old_created_at = @comment.created_at
     @comment.title = 'xyz'
     CouchPotato.database.save_document! @comment
-    @comment.created_at.should == old_created_at
+    expect(@comment.created_at).to eq(old_created_at)
   end
   
   it "should update updated at" do
     old_updated_at = @comment.updated_at
     @comment.title = 'xyz'
     CouchPotato.database.save_document! @comment
-    @comment.updated_at.should > old_updated_at
+    expect(@comment.updated_at).to be > old_updated_at
   end
   
   it "should update the attributes" do
     @comment.title = 'new title'
     CouchPotato.database.save_document! @comment
-    CouchPotato.couchrest_database.get("#{@comment.id}").title.should == 'new title'
+    expect(CouchPotato.couchrest_database.get("#{@comment.id}").title).to eq('new title')
   end
 end

data/spec/view_updates_spec.rb

@@ -9,20 +9,20 @@ describe "automatic view updates" do
   it "should update a view that doesn't match the given functions" do
     CouchPotato::View::ViewQuery.new(@db, 'test_design1', {'test_view' => {:map => 'function(doc) {}', :reduce => 'function() {}'}}, nil).query_view! # create view
     CouchPotato::View::ViewQuery.new(@db, 'test_design1', {'test_view' => {:map => 'function(doc) {emit(doc.id, null)}', :reduce => 'function(key, values) {return sum(values)}'}}, nil).query_view!
-    CouchPotato.database.load('_design/test_design1')['views']['test_view'].should == {
+    expect(CouchPotato.database.load('_design/test_design1')['views']['test_view']).to eq({
       'map' => 'function(doc) {emit(doc.id, null)}',
       'reduce' => 'function(key, values) {return sum(values)}'
-    }
+    })
   end
   
   it "should only update a view once to avoid writing the view for every request" do
     CouchPotato::View::ViewQuery.new(@db, 'test_design2', {'test_view' => {:map => 'function(doc) {}', :reduce => 'function() {}'}}, nil).query_view! # create view
     CouchPotato::View::ViewQuery.new(@db, 'test_design2', {'test_view' => {:map => 'function(doc) {emit(doc.id, null)}', :reduce => 'function(key, values) {return sum(values)}'}}, nil).query_view!
     CouchPotato::View::ViewQuery.new(@db, 'test_design2', {'test_view' => {:map => 'function(doc) {}', :reduce => 'function() {}'}}, nil).query_view!
-    CouchPotato.database.load('_design/test_design2')['views']['test_view'].should == {
+    expect(CouchPotato.database.load('_design/test_design2')['views']['test_view']).to eq({
       'map' => 'function(doc) {emit(doc.id, null)}',
       'reduce' => 'function(key, values) {return sum(values)}'
-    }
+    })
   end
   
 end

data/spec/views_spec.rb

@@ -46,7 +46,7 @@ describe 'views' do
       @db.save_document build
 
       results = @db.view(ErlangBuild.by_name('erlang'))
-      results.should == [build]
+      expect(results).to eq([build])
     end
 
     it 'does not crash couchdb when a document does not have the key' do
@@ -54,7 +54,7 @@ describe 'views' do
       @db.couchrest_database.save_doc build
 
       results = @db.view(ErlangBuild.by_name(:key => nil))
-      results.size.should == 1
+      expect(results.size).to eq(1)
     end
 
     it 'builds views with composite keys' do
@@ -62,7 +62,7 @@ describe 'views' do
       @db.save_document build
 
       results = @db.view(ErlangBuild.by_name_and_code(['erlang', '123']))
-      results.should == [build]
+      expect(results).to eq([build])
     end
 
     it 'can reduce over erlang views' do
@@ -70,72 +70,72 @@ describe 'views' do
       @db.save_document build
 
       results = @db.view(ErlangBuild.by_name(:reduce => true))
-      results.should == 1
+      expect(results).to eq(1)
     end
   end
 
   it "should return instances of the class" do
     @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
     results = @db.view(Build.timeline)
-    results.map(&:class).should == [Build]
+    expect(results.map(&:class)).to eq([Build])
   end
 
   it "should return the ids if there document was not included" do
     build = Build.new(:state => 'success', :time => '2008-01-01')
     @db.save_document build
     results = @db.view(Build.timeline(:include_docs => false))
-    results.should == [build.id]
+    expect(results).to eq([build.id])
   end
 
   it "should pass the view options to the view query" do
-    query = mock 'query'
-    CouchPotato::View::ViewQuery.stub!(:new).and_return(query)
-    query.should_receive(:query_view!).with(hash_including(:key => 1)).and_return('rows' => [])
+    query = double 'query'
+    allow(CouchPotato::View::ViewQuery).to receive(:new).and_return(query)
+    expect(query).to receive(:query_view!).with(hash_including(:key => 1)).and_return('rows' => [])
     @db.view Build.timeline(:key => 1)
   end
 
   it "should not return documents that don't have a matching JSON.create_id" do
     CouchPotato.couchrest_database.save_doc({:time => 'x'})
-    @db.view(Build.timeline).should == []
+    expect(@db.view(Build.timeline)).to eq([])
   end
 
   it "should count documents" do
     @db.save_document! Build.new(:state => 'success', :time => '2008-01-01')
-    @db.view(Build.count(:reduce => true)).should == 1
+    expect(@db.view(Build.count(:reduce => true))).to eq(1)
   end
 
   it "should count zero documents" do
-    @db.view(Build.count(:reduce => true)).should == 0
+    expect(@db.view(Build.count(:reduce => true))).to eq(0)
   end
 
   describe "with multiple keys" do
     it "should return the documents with matching keys" do
       build = Build.new(:state => 'success', :time => '2008-01-01')
       @db.save! build
-      @db.view(Build.timeline(:keys => ['2008-01-01'])).should == [build]
+      expect(@db.view(Build.timeline(:keys => ['2008-01-01']))).to eq([build])
     end
 
     it "should not return documents with non-matching keys" do
       build = Build.new(:state => 'success', :time => '2008-01-01')
       @db.save! build
-      @db.view(Build.timeline(:keys => ['2008-01-02'])).should be_empty
+      expect(@db.view(Build.timeline(:keys => ['2008-01-02']))).to be_empty
     end
   end
 
   describe "properties defined" do
     it "assigns the configured properties" do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')
-      @db.view(Build.minimal_timeline).first.state.should eql('success')
+      expect(@db.view(Build.minimal_timeline).first.state).to eql('success')
     end
 
     it "does not assign the properties not configured" do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')
-      @db.view(Build.minimal_timeline).first.time.should be_nil
+      expect(@db.view(Build.minimal_timeline).first.time).to be_nil
     end
 
     it "assigns the id even if it is not configured" do
       id = CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')['id']
-      @db.view(Build.minimal_timeline).first._id.should eql(id)
+      expect(@db.view(Build.minimal_timeline).first._id).to eql(id)
     end
   end
 
@@ -143,49 +143,49 @@ describe 'views' do
     it "should assign all properties to the objects by default" do
       id = CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build'})['id']
       result = @db.view(Build.timeline).first
-      result.state.should == 'success'
-      result.time.should == '2008-01-01'
-      result._id.should == id
+      expect(result.state).to eq('success')
+      expect(result.time).to eq('2008-01-01')
+      expect(result._id).to eq(id)
     end
   end
 
   describe "map function given" do
     it "should still return instances of the class" do
       CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
-      @db.view(Build.custom_timeline).map(&:class).should == [Build]
+      expect(@db.view(Build.custom_timeline).map(&:class)).to eq([Build])
     end
 
     it "should assign the properties from the value" do
       CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
-      @db.view(Build.custom_timeline).map(&:state).should == ['custom_success']
+      expect(@db.view(Build.custom_timeline).map(&:state)).to eq(['custom_success'])
     end
 
     it "should assign the id" do
       doc = CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
-      @db.view(Build.custom_timeline).map(&:_id).should == [doc['id']]
+      expect(@db.view(Build.custom_timeline).map(&:_id)).to eq([doc['id']])
     end
 
     it "should leave the other properties blank" do
       CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
-      @db.view(Build.custom_timeline).map(&:time).should == [nil]
+      expect(@db.view(Build.custom_timeline).map(&:time)).to eq([nil])
     end
 
     describe "that returns null documents" do
       it "should return instances of the class" do
         CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
-        @db.view(Build.custom_timeline_returns_docs).map(&:class).should == [Build]
+        expect(@db.view(Build.custom_timeline_returns_docs).map(&:class)).to eq([Build])
       end
 
       it "should assign the properties from the value" do
         CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
-        @db.view(Build.custom_timeline_returns_docs).map(&:state).should == ['success']
+        expect(@db.view(Build.custom_timeline_returns_docs).map(&:state)).to eq(['success'])
       end
 
       it "should still return instance of class if document included JSON.create_id" do
         CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => "Build"})
         view_data = @db.view(Build.custom_timeline_returns_docs)
-        view_data.map(&:class).should == [Build]
-        view_data.map(&:state).should == ['success']
+        expect(view_data.map(&:class)).to eq([Build])
+        expect(view_data.map(&:state)).to eq(['success'])
       end
     end
 
@@ -193,14 +193,14 @@ describe 'views' do
       it "should still assign the id" do
         doc = CouchPotato.couchrest_database.save_doc({})
         CouchPotato.couchrest_database.save_doc({:foreign_key => doc['id']})
-        @db.view(Build.custom_with_reduce).map(&:_id).should == [doc['id']]
+        expect(@db.view(Build.custom_with_reduce).map(&:_id)).to eq([doc['id']])
       end
 
       describe "when the additional reduce function is a typical count" do
         it "should parse the reduce count" do
           doc = CouchPotato.couchrest_database.save_doc({})
           CouchPotato.couchrest_database.save_doc({:foreign_key => doc['id']})
-          @db.view(Build.custom_count_with_reduce(:reduce => true)).should == 2
+          expect(@db.view(Build.custom_count_with_reduce(:reduce => true))).to eq(2)
         end
       end
     end
@@ -208,10 +208,10 @@ describe 'views' do
 
   describe "with array as key" do
     it "should create a map function with the composite key" do
-      CouchPotato::View::ViewQuery.should_receive(:new) do |db, design_name, view, list|
-        view['key_array_timeline'][:map].should match(/emit\(\[doc\['time'\], doc\['state'\]\]/)
+      expect(CouchPotato::View::ViewQuery).to receive(:new) do |db, design_name, view, list|
+        expect(view['key_array_timeline'][:map]).to match(/emit\(\[doc\['time'\], doc\['state'\]\]/)
 
-        stub('view query', :query_view! => {'rows' => []})
+        double('view query', :query_view! => {'rows' => []})
       end
       @db.view Build.key_array_timeline
     end
@@ -220,18 +220,18 @@ describe 'views' do
   describe "raw view" do
     it "should return the raw data" do
       @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
-      @db.view(Build.raw)['rows'][0]['value'].should == 'success'
+      expect(@db.view(Build.raw)['rows'][0]['value']).to eq('success')
     end
 
     it "should return filtred raw data" do
       @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
-      @db.view(Build.filtered_raw).should == ['success']
+      expect(@db.view(Build.filtered_raw)).to eq(['success'])
     end
 
     it "should pass view options declared in the view declaration to the query" do
-     view_query = mock 'view_query'
-     CouchPotato::View::ViewQuery.stub!(:new).and_return(view_query)
-     view_query.should_receive(:query_view!).with(hash_including(:group => true)).and_return({'rows' => []})
+     view_query = double 'view_query'
+     allow(CouchPotato::View::ViewQuery).to receive(:new).and_return(view_query)
+     expect(view_query).to receive(:query_view!).with(hash_including(:group => true)).and_return({'rows' => []})
      @db.view(Build.with_view_options)
     end
   end
@@ -239,15 +239,15 @@ describe 'views' do
   describe "inherited views" do
     it "should support parent views for objects of the subclass" do
       @db.save_document CustomBuild.new(:state => 'success', :time => '2008-01-01')
-      @db.view(CustomBuild.timeline).size.should == 1
-      @db.view(CustomBuild.timeline).first.should be_kind_of(CustomBuild)
+      expect(@db.view(CustomBuild.timeline).size).to eq(1)
+      expect(@db.view(CustomBuild.timeline).first).to be_kind_of(CustomBuild)
     end
 
     it "should return instances of subclasses as well if a special view exists" do
       @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
       @db.save_document CustomBuild.new(:state => 'success', :time => '2008-01-01', :server => 'Jenkins')
       results = @db.view(Build.all)
-      results.map(&:class).should == [CustomBuild, Build]
+      expect(results.map(&:class)).to eq([CustomBuild, Build])
     end
   end
 
@@ -275,12 +275,12 @@ describe 'views' do
 
     it "should use the list function declared at class level" do
       @db.save! Coworker.new(:name => 'joe')
-      @db.view(Coworker.all_with_list).first.name.should == 'joe doe'
+      expect(@db.view(Coworker.all_with_list).first.name).to eq('joe doe')
     end
 
     it "should use the list function passed at runtime" do
       @db.save! Coworker.new(:name => 'joe')
-      @db.view(Coworker.all(:list => :append_doe)).first.name.should == 'joe doe'
+      expect(@db.view(Coworker.all(:list => :append_doe)).first.name).to eq('joe doe')
     end
   end