couch_potato 1.4.0 → 1.6.3

data/spec/unit/dirty_attributes_spec.rb

@@ -8,7 +8,7 @@ end
 
 describe 'dirty attribute tracking' do
   before(:each) do
-    @couchrest_db = stub('database', :save_doc => {'id' => '1', 'rev' => '2'}, :info => nil)
+    @couchrest_db = double('database', :save_doc => {'id' => '1', 'rev' => '2'}, :info => nil)
     @db = CouchPotato::Database.new(@couchrest_db)
   end
 
@@ -16,21 +16,21 @@ describe 'dirty attribute tracking' do
     it "should not save when nothing dirty" do
       plate = Plate.new :food => 'sushi'
       @db.save_document!(plate)
-      @couchrest_db.should_not_receive(:save_doc)
+      expect(@couchrest_db).not_to receive(:save_doc)
       @db.save_document(plate)
     end
 
     it "should return true when not dirty" do
       plate = Plate.new :food => 'sushi'
       @db.save_document!(plate)
-      @db.save_document(plate).should be_true
+      expect(@db.save_document(plate)).to be_truthy
     end
 
     it "should save when there are dirty attributes" do
       plate = Plate.new :food => 'sushi'
       @db.save_document!(plate)
       plate.food = 'burger'
-      @couchrest_db.should_receive(:save_doc)
+      expect(@couchrest_db).to receive(:save_doc)
       @db.save_document(plate)
     end
   end
@@ -44,7 +44,7 @@ describe 'dirty attribute tracking' do
     describe "access old values" do
       it "should return the old value" do
         @plate.food = 'burger'
-        @plate.food_was.should == 'sushi'
+        expect(@plate.food_was).to eq('sushi')
       end
 
       describe "with type BigDecimal" do
@@ -56,15 +56,15 @@ describe 'dirty attribute tracking' do
         end
         it "should not dup BigDecimal" do
 
-          lambda {
+          expect {
             Bowl.new :price => BigDecimal.new("5.23")
-          }.should_not raise_error(TypeError)
+          }.not_to raise_error
         end
 
         it "should return the old value" do
           bowl = Bowl.new :price => BigDecimal.new("5.23")
           bowl.price = BigDecimal.new("2.23")
-          bowl.price_was.should == 5.23
+          expect(bowl.price_was).to eq(5.23)
         end
 
       end
@@ -73,41 +73,41 @@ describe 'dirty attribute tracking' do
     describe "check for dirty" do
       it "should return true if attribute changed" do
         @plate.food = 'burger'
-        @plate.should be_food_changed
+        expect(@plate).to be_food_changed
       end
 
       it "should return false if attribute not changed" do
-        Plate.new.should_not be_food_changed
+        expect(Plate.new).not_to be_food_changed
       end
 
       it "should return true if forced dirty" do
         @plate.is_dirty
-        @plate.should be_dirty
+        expect(@plate).to be_dirty
       end
     end
   end
 
   describe "object loaded from database" do
     before(:each) do
-      couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil)
+      couchrest_db = double('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil)
       @plate = CouchPotato::Database.new(couchrest_db).load_document '1'
     end
 
     describe "access old values" do
       it "should return the old value" do
         @plate.food = 'burger'
-        @plate.food_was.should == 'sushi'
+        expect(@plate.food_was).to eq('sushi')
       end
     end
 
     describe "check for dirty" do
       it "should return true if attribute changed" do
         @plate.food = 'burger'
-        @plate.should be_food_changed
+        expect(@plate).to be_food_changed
       end
 
       it "should return false if attribute not changed" do
-        @plate.should_not be_food_changed
+        expect(@plate).not_to be_food_changed
       end
     end
   end
@@ -115,21 +115,21 @@ describe 'dirty attribute tracking' do
 
   describe "after save" do
     it "should reset all attributes to not dirty" do
-      couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil, :save_doc => {})
+      couchrest_db = double('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil, :save_doc => {})
       db = CouchPotato::Database.new(couchrest_db)
       @plate = db.load_document '1'
       @plate.food = 'burger'
       db.save! @plate
-      @plate.should_not be_food_changed
+      expect(@plate).not_to be_food_changed
     end
 
     it "should reset a forced dirty state" do
-      couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil, :save_doc => {'rev' =>  '3'})
+      couchrest_db = double('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil, :save_doc => {'rev' =>  '3'})
       db = CouchPotato::Database.new(couchrest_db)
       @plate = db.load_document '1'
       @plate.is_dirty
       db.save! @plate
-      @plate.should_not be_dirty
+      expect(@plate).not_to be_dirty
     end
   end
 

data/spec/unit/forbidden_attributes_protection_spec.rb

@@ -16,13 +16,13 @@ begin
       it 'raises no error when passing permitted attributes' do
         expect {
           Child.new ActionController::Parameters.new(:text => 'xx').permit!
-        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+        }.to_not raise_error
       end
 
       it "raises no error when passing attributes that don't respond to permitted?" do
         expect {
           Child.new :text => 'xx'
-        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+        }.to_not raise_error
       end
     end
 
@@ -38,13 +38,13 @@ begin
       it 'raises no error when passing permitted attributes' do
         expect {
           subject.attributes = ActionController::Parameters.new(:text => 'xx').permit!
-        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+        }.to_not raise_error
       end
 
       it "raises no error when passing attributes that don't respond to permitted?" do
         expect {
           subject.attributes = {:text => 'xx'}
-        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+        }.to_not raise_error
       end
     end
   end

data/spec/unit/initialize_spec.rb

@@ -2,37 +2,55 @@ require 'spec_helper'
 
 class Document
   include CouchPotato::Persistence
-  
+
   property :title
   property :content
 end
 
-describe "new" do
-  context "without arguments" do
+describe 'new' do
+  context 'without arguments' do
     subject { Document.new }
 
-    it { should be_a(Document) }
-    its(:title) { should be_nil }
-    its(:content) { should be_nil }
+    it { is_expected.to be_a(Document) }
+
+    it 'has no title' do
+      expect(subject.title).to be_nil
+    end
+
+    it 'has no content' do
+      expect(subject.content).to be_nil
+    end
   end
 
-  context "with an argument hash" do
-    subject { Document.new(:title => 'My Title') }
+  context 'with an argument hash' do
+    subject { Document.new(title: 'My Title') }
+
+    it { is_expected.to be_a(Document) }
 
-    it { should be_a(Document) }
-    its(:title) { should == 'My Title'}
-    its(:content) { should be_nil }
+    it 'has a title' do
+      expect(subject.title).to eql('My Title')
+    end
+
+    it 'has no content' do
+      expect(subject.content).to be_nil
+    end
   end
 
-  context "yielding to a block" do
-    subject {
-      Document.new(:title => 'My Title') do |doc|
+  context 'yielding to a block' do
+    subject do
+      Document.new(title: 'My Title') do |doc|
         doc.content = 'My Content'
       end
-    }
+    end
+
+    it { is_expected.to be_a(Document) }
 
-    it { should be_a(Document) }
-    its(:title) { should == 'My Title'}
-    its(:content) { should == 'My Content'}
+    it 'has a title' do
+      expect(subject.title).to eql('My Title')
+    end
+
+    it 'has a content' do
+      expect(subject.content).to eql('My Content')
+    end
   end
-end
+end

data/spec/unit/json_spec.rb

@@ -10,12 +10,12 @@ describe CouchPotato::Persistence::Json do
   context '#to_hash' do
     it "should inject JSON.create_id into the hash representation of a persistent object" do
       sake = Drink.new(:alcohol => "18%")
-      sake.to_hash[JSON.create_id].should eql("Drink")
+      expect(sake.to_hash[JSON.create_id]).to eql("Drink")
     end
     
     it "should not include _attachments if there are none" do
       sake = Drink.new(:alcohol => "18%")
-      sake.to_hash.keys.should_not include('_attachments')
+      expect(sake.to_hash.keys).not_to include('_attachments')
     end
     
   end
@@ -23,8 +23,8 @@ describe CouchPotato::Persistence::Json do
   context '.json_create' do
     it 'should assign the _document' do
       sake = Drink.json_create({"alcohol" => "18%"})
-      sake._document.should == {"alcohol" => "18%"}
+      expect(sake._document).to eq({"alcohol" => "18%"})
     end
   end
   
-end
+end

data/spec/unit/lists_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
 describe CouchPotato::View::Lists, '.list' do
-  it "should make the list function available via .lists" do
+  it 'should make the list function available via .lists' do
     clazz = Class.new
     clazz.send :include, CouchPotato::View::Lists
     clazz.list 'my_list', '<list_code>'
-    
-    clazz.lists('my_list').should == '<list_code>'
+
+    expect(clazz.lists('my_list')).to eq('<list_code>')
   end
-  
-  it "should make the list available to subclasses" do
+
+  it 'should make the list available to subclasses' do
     clazz = Class.new
     clazz.send :include, CouchPotato::View::Lists
     clazz.list 'my_list', '<list_code>'
     sub_clazz = Class.new clazz
-    
-    sub_clazz.lists('my_list').should == '<list_code>'
+
+    expect(sub_clazz.lists('my_list')).to eq('<list_code>')
   end
-end
+end

data/spec/unit/model_view_spec_spec.rb

@@ -26,12 +26,12 @@ end
 describe CouchPotato::View::ModelViewSpec, '#map_function' do
   it "should include conditions" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:conditions => 'doc.closed = true'}, {}
-    spec.map_function.should include('if(doc.ruby_class && doc.ruby_class == \'Object\' && (doc.closed = true))')
+    expect(spec.map_function).to include('if(doc.ruby_class && doc.ruby_class == \'Object\' && (doc.closed = true))')
   end
 
   it 'generates an erlang map function with a single key if the language is erlang' do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:key => :name, :language => :erlang}, {}
-    spec.map_function.should eql_ignoring_indentation(<<-ERL
+    expect(spec.map_function).to eql_ignoring_indentation(<<-ERL
       fun({Doc}) ->
         case proplists:get_value(<<"ruby_class">>, Doc) of
         <<"Object">> ->
@@ -47,7 +47,7 @@ describe CouchPotato::View::ModelViewSpec, '#map_function' do
 
   it 'generates an erlang map function with a composite key if the language is erlang' do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:key => [:code, :name], :language => :erlang}, {}
-    spec.map_function.should eql_ignoring_indentation(<<-ERL
+    expect(spec.map_function).to eql_ignoring_indentation(<<-ERL
       fun({Doc}) ->
         case proplists:get_value(<<"ruby_class">>, Doc) of
         <<"Object">> ->
@@ -64,50 +64,50 @@ describe CouchPotato::View::ModelViewSpec, '#map_function' do
 
   it 'does not support conditions in erlang' do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:language => :erlang, :conditions => 'abc'}, {}
-    lambda {
+    expect {
       spec.map_function
-    }.should raise_error(NotImplementedError)
+    }.to raise_error(NotImplementedError)
   end
 
   it 'does not support a custom emit value in erlang' do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:language => :erlang, :emit_value => :count}, {}
-    lambda {
+    expect {
       spec.map_function
-    }.should raise_error(NotImplementedError)
+    }.to raise_error(NotImplementedError)
   end
 
   it "should not include conditions when they are nil" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {}, {}
-    spec.map_function.should include('if(doc.ruby_class && doc.ruby_class == \'Object\')')
+    expect(spec.map_function).to include('if(doc.ruby_class && doc.ruby_class == \'Object\')')
   end
 
   it "should have a custom emit value when specified as symbol" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:emit_value => :count}, {}
-    spec.map_function.should include(%{emit(doc[''], doc['count'])})
+    expect(spec.map_function).to include(%{emit(doc[''], doc['count'])})
   end
 
   it "should have a custom emit value when specified as string" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:emit_value => "doc['a'] + doc['b']"}, {}
-    spec.map_function.should include("emit(doc[''], doc['a'] + doc['b'])")
+    expect(spec.map_function).to include("emit(doc[''], doc['a'] + doc['b'])")
   end
 
   it "should have a custom emit value when specified as integer" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:emit_value => 7}, {}
-    spec.map_function.should include("emit(doc[''], 7)")
+    expect(spec.map_function).to include("emit(doc[''], 7)")
   end
 
   it "should have a custom emit value when specified as float" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:emit_value => 7.2}, {}
-    spec.map_function.should include("emit(doc[''], 7.2")
+    expect(spec.map_function).to include("emit(doc[''], 7.2")
   end
 
   it "should have a emit value of 1 when nothing is specified" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {}, {}
-    spec.map_function.should include("emit(doc[''], 1")
+    expect(spec.map_function).to include("emit(doc[''], 1")
   end
 
   it "should raise exception when emit value cannot be handled" do
     spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:emit_value => []}, {}
-    lambda { spec.map_function }.should raise_error
+    expect { spec.map_function }.to raise_error
   end
 end

data/spec/unit/persistence_spec.rb

@@ -18,23 +18,23 @@ describe "persistence" do
 
       none_dude22 = NoneDude.new(:id => "22", :name => "foo")
 
-      dude22.should eql(dude22)
-      dude22.should_not eql(none_dude22)
-      dude22.should_not eql(dude11)
+      expect(dude22).to eql(dude22)
+      expect(dude22).not_to eql(none_dude22)
+      expect(dude22).not_to eql(dude11)
     end
 
     it "should handle new objects without id to be never equal" do
       dude = Dude.new(:name => "foo")
       dude22 = Dude.new(:id => "22", :name => "foo")
 
-      dude.should_not eql(Dude.new(:name => "foo"))
-      dude22.should_not eql(Dude.new(:name => "foo"))
+      expect(dude).not_to eql(Dude.new(:name => "foo"))
+      expect(dude22).not_to eql(Dude.new(:name => "foo"))
     end
 
     it "should handle same object references to be equal" do
       dude = Dude.new(:name => "foo")
 
-      dude.should eql(dude)
+      expect(dude).to eql(dude)
     end
   end
 end

data/spec/unit/properties_view_spec_spec.rb

@@ -20,25 +20,25 @@ describe CouchPotato::View::PropertiesViewSpec do
   end
 
   it "should map the given properties" do
-    Contract.by_date.should map(
+    expect(Contract.by_date).to map(
       Contract.new(:date => '2010-01-01', :_id => '1')
     ).to(['1', {"date" => "2010-01-01"}])
   end
 
   it "should reduce to the number of documents" do
-    Contract.by_date.should reduce(
+    expect(Contract.by_date).to reduce(
       ['1', {"date" => "2010-01-01"}], ['2', {"date" => "2010-01-02"}]
     ).to(2)
   end
 
   it "should rereduce the number of documents" do
-    Contract.by_date.should rereduce(
+    expect(Contract.by_date).to rereduce(
       nil, [12, 13]
     ).to(25)
   end
 
   it 'always uses javascript' do
     CouchPotato::Config.default_language = :erlang
-    CouchPotato::View::PropertiesViewSpec.new(Contract, 'all', {}, {}).language.should == :javascript
+    expect(CouchPotato::View::PropertiesViewSpec.new(Contract, 'all', {}, {}).language).to eq(:javascript)
   end
 end

data/spec/unit/rspec_matchers_spec.rb

@@ -1,79 +1,79 @@
 require 'spec_helper'
-require 'couch_potato/rspec'
+require 'couch_potato-rspec'
 
 describe CouchPotato::RSpec::MapToMatcher do
 
   describe "basic map function" do
     before(:each) do
-      @view_spec = stub(:map_function => "function(doc) {emit(doc.name, doc.tags.length);}")
+      @view_spec = double(:map_function => "function(doc) {emit(doc.name, doc.tags.length);}")
     end
 
     it "should pass if the given function emits the expected javascript" do
-      @view_spec.should map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2])
+      expect(@view_spec).to map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2])
     end
 
     it "should not pass if the given function emits different javascript" do
-      @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 3])
+      expect(@view_spec).not_to map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 3])
     end
   end
 
   describe "functions emitting multiple times" do
     before(:each) do
-      @view_spec = stub(:map_function => "function(doc) {emit(doc.name, doc.tags.length); emit(doc.tags[0], doc.tags[1])};")
+      @view_spec = double(:map_function => "function(doc) {emit(doc.name, doc.tags.length); emit(doc.tags[0], doc.tags[1])};")
     end
 
     it "should pass if the given function emits the expected javascript" do
-      @view_spec.should map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['person', 'male'])
+      expect(@view_spec).to map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['person', 'male'])
     end
 
     it "should return false if the given function emits different javascript" do
-      @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['male', 'person'])
+      expect(@view_spec).not_to map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['male', 'person'])
     end
   end
 
   it "should work with date emit values" do
-    spec = stub(:map_function => "function(doc) { emit(null, new Date(1368802800000)); }")
-    spec.should map({}).to([nil, "2013-05-17T15:00:00.000Z"])
+    spec = double(:map_function => "function(doc) { emit(null, new Date(1368802800000)); }")
+    expect(spec).to map({}).to([nil, "2013-05-17T15:00:00.000Z"])
   end
 
   it "should work with commonJS modules that use 'exports'" do
-    spec = stub(
+    spec = double(
       :map_function => "function(doc) { var test = require('views/lib/test'); emit(null, test.test); }",
       :lib => {:test => "exports.test = 'test';"}
     )
-    spec.should map({}).to([nil, "test"])
+    expect(spec).to map({}).to([nil, "test"])
   end
 
   it "should work with commonJS modules that use 'module.exports'" do
-    spec = stub(
+    spec = double(
       :map_function => "function(doc) { var test = require('views/lib/test'); emit(null, test.test); }",
       :lib => {:test => "module.exports.test = 'test';"}
     )
-    spec.should map({}).to([nil, "test"])
+    expect(spec).to map({}).to([nil, "test"])
   end
 
   describe "failing specs" do
     before(:each) do
-      @view_spec = stub(:map_function => "function(doc) {emit(doc.name, null)}")
+      @view_spec = double(:map_function => "function(doc) {emit(doc.name, null)}")
     end
 
     it "should have a nice error message for failing should" do
-      lambda {
-        @view_spec.should map({:name => 'bill'}).to(['linus', nil])
-      }.should raise_error('Expected to map to [["linus", nil]] but got [["bill", nil]].')
+      expect {
+        expect(@view_spec).to map({:name => 'bill'}).to(['linus', nil])
+      }.to raise_error('Expected to map to [["linus", nil]] but got [["bill", nil]].')
     end
 
     it "should have a nice error message for failing should not" do
-      lambda {
-        @view_spec.should_not map({:name => 'bill'}).to(['bill', nil])
-      }.should raise_error('Expected not to map to [["bill", nil]] but did.')
+      expect {
+        expect(@view_spec).not_to map({:name => 'bill'}).to(['bill', nil])
+      }.to raise_error('Expected not to map to [["bill", nil]] but did.')
     end
   end
 end
 
 describe CouchPotato::RSpec::ReduceToMatcher do
   before(:each) do
-    @view_spec = stub(:reduce_function => "function(keys, values, rereduce) {
+    @view_spec = double(:reduce_function => "function(keys, values, rereduce) {
       if(rereduce) {
         return(sum(values) * 2);
       } else {
@@ -83,47 +83,47 @@ describe CouchPotato::RSpec::ReduceToMatcher do
   end
 
   it "should pass if the given function return the expected javascript" do
-    @view_spec.should reduce([], [1, 2, 3]).to(6)
+    expect(@view_spec).to reduce([], [1, 2, 3]).to(6)
   end
 
   it "should not pass if the given function returns different javascript" do
-    @view_spec.should_not reduce([], [1, 2, 3]).to(7)
+    expect(@view_spec).not_to reduce([], [1, 2, 3]).to(7)
   end
 
   it "should work with date return values" do
-    spec = stub(:reduce_function => "function() { return new Date(1368802800000); }")
-    spec.should reduce([], []).to("2013-05-17T15:00:00.000Z")
+    spec = double(:reduce_function => "function() { return new Date(1368802800000); }")
+    expect(spec).to reduce([], []).to("2013-05-17T15:00:00.000Z")
   end
 
   describe "rereduce" do
     it "should pass if the given function return the expected javascript" do
-      @view_spec.should rereduce([], [1, 2, 3]).to(12)
+      expect(@view_spec).to rereduce([], [1, 2, 3]).to(12)
     end
 
     it "should not pass if the given function returns different javascript" do
-      @view_spec.should_not rereduce([], [1, 2, 3]).to(13)
+      expect(@view_spec).not_to rereduce([], [1, 2, 3]).to(13)
     end
   end
 
   describe 'failing specs' do
 
     it "should have a nice error message for failing should" do
-      lambda {
-        @view_spec.should reduce([], [1, 2, 3]).to(7)
-      }.should raise_error('Expected to reduce to 7 but got 6.')
+      expect {
+        expect(@view_spec).to reduce([], [1, 2, 3]).to(7)
+      }.to raise_error('Expected to reduce to 7 but got 6.')
     end
 
     it "should have a nice error message for failing should not" do
-      lambda {
-        @view_spec.should_not reduce([], [1, 2, 3]).to(6)
-      }.should raise_error('Expected not to reduce to 6 but did.')
+      expect {
+        expect(@view_spec).not_to reduce([], [1, 2, 3]).to(6)
+      }.to raise_error('Expected not to reduce to 6 but did.')
     end
   end
 end
 
 describe CouchPotato::RSpec::MapReduceToMatcher do
   before(:each) do
-    @view_spec = stub(
+    @view_spec = double(
       :map_function => "function(doc) {
           for (var i in doc.numbers)
             emit([doc.age, doc.name], doc.numbers[i]);
@@ -140,48 +140,48 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
   end
 
   it "should handle date return values" do
-    spec = stub(:map_function => "function() { emit(null, null); }",
+    spec = double(:map_function => "function() { emit(null, null); }",
       :reduce_function => "function() { return new Date(1368802800000); }")
-    spec.should map_reduce({}).to({"key" => nil, "value" => "2013-05-17T15:00:00.000Z"})
+    expect(spec).to map_reduce({}).to({"key" => nil, "value" => "2013-05-17T15:00:00.000Z"})
   end
 
   it "should handle CommonJS requires for modules that use 'exports'" do
-    spec = stub(
+    spec = double(
       :map_function => "function() { var test = require('views/lib/test'); emit(null, test.test); }",
       :reduce_function => "function(keys, values) { return 'test' }",
       :lib => {:test => "exports.test = 'test'"})
-    spec.should map_reduce({}).to({"key" => nil, "value" => "test"})
+    expect(spec).to map_reduce({}).to({"key" => nil, "value" => "test"})
   end
 
   it "should handle CommonJS requires for modules that use 'module.exports'" do
-    spec = stub(
+    spec = double(
       :map_function => "function() { var test = require('views/lib/test'); emit(null, test.test); }",
       :reduce_function => "function(keys, values) { return 'test' }",
       :lib => {:test => "module.exports.test = 'test'"})
-    spec.should map_reduce({}).to({"key" => nil, "value" => "test"})
+    expect(spec).to map_reduce({}).to({"key" => nil, "value" => "test"})
   end
 
   it "should handle sum function" do
-    spec = stub(
+    spec = double(
       :map_function => "function(doc) { emit(null, doc.age); }",
       :reduce_function => "function(keys, values) { return sum(values); }")
-    spec.should map_reduce(@docs).to({"key" => nil, "value" => 103})
+    expect(spec).to map_reduce(@docs).to({"key" => nil, "value" => 103})
   end
 
   context "without grouping" do
     it "should not group by key by default" do
-      @view_spec.should map_reduce(@docs).to({"key" => nil, "value" => 8})
+      expect(@view_spec).to map_reduce(@docs).to({"key" => nil, "value" => 8})
     end
 
     it "should group by key with :group => false" do
-      @view_spec.should map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
+      expect(@view_spec).to map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
     end
   end
 
   context "with grouping" do
     [true, "exact"].each do |group_value|
       it "should group by the full key with option :group => #{group_value}" do
-        @view_spec.should map_reduce(@docs).with_options(:group => group_value).to(
+        expect(@view_spec).to map_reduce(@docs).with_options(:group => group_value).to(
           {"key" => [25, "a"], "value" => 2},
           {"key" => [25, "b"], "value" => 4},
           {"key" => [26, "c"], "value" => 6},
@@ -190,7 +190,7 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
     end
 
     it "should group by parts of the keys based on the :group_level option" do
-      @view_spec.should map_reduce(@docs).with_options(:group_level => 1).to(
+      expect(@view_spec).to map_reduce(@docs).with_options(:group_level => 1).to(
         {"key" => [25], "value" => 4},
         {"key" => [26], "value" => 6},
         {"key" => [27], "value" => 8})
@@ -199,7 +199,7 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
 
   describe "rereducing" do
     before :each do
-      @view_spec = stub(:map_function => "function(doc) {
+      @view_spec = double(:map_function => "function(doc) {
           emit(doc.name, doc.number);
         }",
         :reduce_function => "function (keys, values, rereduce) {
@@ -215,7 +215,7 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
     end
 
     it "should reduce and rereduce for a single emit" do
-      @view_spec.should map_reduce({:name => "a", :number => 1}).to({"key" => nil, "value" => {"rereduce_values" => [[1]]}})
+      expect(@view_spec).to map_reduce({:name => "a", :number => 1}).to({"key" => nil, "value" => {"rereduce_values" => [[1]]}})
     end
 
     it "should split and reduce each half of emitted values separately and rereduce the results" do
@@ -224,7 +224,7 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
         {:name => "a", :number => 2},
         {:name => "a", :number => 3},
         {:name => "a", :number => 4}]
-      @view_spec.should map_reduce(docs).to({"key" => nil, "value" => {"rereduce_values" => [[1, 2], [3, 4]]}})
+      expect(@view_spec).to map_reduce(docs).to({"key" => nil, "value" => {"rereduce_values" => [[1, 2], [3, 4]]}})
     end
 
     it "should correctly split and rereduce with an odd number of emits" do
@@ -232,43 +232,43 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
         {:name => "a", :number => 1},
         {:name => "a", :number => 2},
         {:name => "a", :number => 3}]
-      @view_spec.should map_reduce(docs).to({"key" => nil, "value" => {"rereduce_values" => [[1], [2, 3]]}})
+      expect(@view_spec).to map_reduce(docs).to({"key" => nil, "value" => {"rereduce_values" => [[1], [2, 3]]}})
     end
   end
 
   describe "failing specs" do
     it "should have a nice error message for failing should" do
-      lambda {
-        @view_spec.should map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 9})
-      }.should raise_error('Expected to map/reduce to [{"key"=>nil, "value"=>9}] but got [{"key"=>nil, "value"=>8}].')
+      expect {
+        expect(@view_spec).to map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 9})
+      }.to raise_error('Expected to map/reduce to [{"key"=>nil, "value"=>9}] but got [{"key"=>nil, "value"=>8}].')
     end
 
     it "should have a nice error message for failing should not" do
-      lambda {
-        @view_spec.should_not map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
-      }.should raise_error('Expected not to map/reduce to [{"key"=>nil, "value"=>8}] but did.')
+      expect {
+        expect(@view_spec).not_to map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
+      }.to raise_error('Expected not to map/reduce to [{"key"=>nil, "value"=>8}] but did.')
     end
   end
 
   describe "couchdb built-in reduce functions" do
     describe "_sum" do
       it "should return the sum of emitted values" do
-        spec = stub(:map_function => @view_spec.map_function, :reduce_function => "_sum")
-        spec.should map_reduce(@docs).to({"key" => nil, "value" => 36})
+        spec = double(:map_function => @view_spec.map_function, :reduce_function => "_sum")
+        expect(spec).to map_reduce(@docs).to({"key" => nil, "value" => 36})
       end
     end
 
     describe "_count" do
       it "should return the count of emitted values" do
-        spec = stub(:map_function => @view_spec.map_function, :reduce_function => "_count")
-        spec.should map_reduce(@docs).to({"key" => nil, "value" => 8})
+        spec = double(:map_function => @view_spec.map_function, :reduce_function => "_count")
+        expect(spec).to map_reduce(@docs).to({"key" => nil, "value" => 8})
       end
     end
 
     describe "_stats" do
       it "should return the numerical statistics of emitted values" do
-        spec = stub(:map_function => @view_spec.map_function, :reduce_function => "_stats")
-        spec.should map_reduce(@docs).to({
+        spec = double(:map_function => @view_spec.map_function, :reduce_function => "_stats")
+        expect(spec).to map_reduce(@docs).to({
             "key" => nil,
             "value" => {
               "sum" => 36,
@@ -285,33 +285,33 @@ end
 
 describe CouchPotato::RSpec::ListAsMatcher do
   before(:each) do
-    @view_spec = stub(:list_function => "function() {var row = getRow(); send(JSON.stringify([{text: row.text + ' world'}]));}")
+    @view_spec = double(:list_function => "function() {var row = getRow(); send(JSON.stringify([{text: row.text + ' world'}]));}")
   end
 
   it "should pass if the function return the expected json" do
-    @view_spec.should list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
+    expect(@view_spec).to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
   end
 
   it "should not pass if the function does not return the expected json" do
-    @view_spec.should_not list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
+    expect(@view_spec).not_to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
   end
 
   it "should work with date values" do
-    spec = stub(:list_function => "function() { send(JSON.stringify([{date: new Date(1368802800000)}])); }")
-    spec.should list({"rows" => [{}]}).as([{"date" => "2013-05-17T15:00:00.000Z"}])
+    spec = double(:list_function => "function() { send(JSON.stringify([{date: new Date(1368802800000)}])); }")
+    expect(spec).to list({"rows" => [{}]}).as([{"date" => "2013-05-17T15:00:00.000Z"}])
   end
 
   describe "failing specs" do
     it "should have a nice error message for failing should" do
-      lambda {
-        @view_spec.should list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
-      }.should raise_error('Expected to list as [{"text"=>"hello there"}] but got [{"text"=>"hello world"}].')
+      expect {
+        expect(@view_spec).to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
+      }.to raise_error('Expected to list as [{"text"=>"hello there"}] but got [{"text"=>"hello world"}].')
     end
 
     it "should have a nice error message for failing should not" do
-      lambda {
-        @view_spec.should_not list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
-      }.should raise_error('Expected to not list as [{"text"=>"hello world"}] but did.')
+      expect {
+        expect(@view_spec).not_to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
+      }.to raise_error('Expected to not list as [{"text"=>"hello world"}] but did.')
     end
   end
 end