couch_potato 1.4.0 → 1.6.3

data/spec/unit/callbacks_spec.rb

@@ -33,13 +33,13 @@ describe 'callbacks' do
     it "should call the callbacks of the super class" do
       tree = AppleTree.new :leaf_count => 1
       tree.valid?
-      tree.leaf_count.should == 2
+      expect(tree.leaf_count).to eq(2)
     end
 
     it "should call the callbacks of the child class" do
       tree = AppleTree.new :leaf_count => 1
       tree.valid?
-      tree.should be_watered
+      expect(tree).to be_watered
     end
   end
   

data/spec/unit/couch_potato_spec.rb

@@ -10,19 +10,19 @@ describe CouchPotato, 'full_url_to_database' do
 
   it "should add the default localhost and port if only a name is set" do
     CouchPotato::Config.database_name = 'test'
-    CouchPotato.full_url_to_database.should == 'http://127.0.0.1:5984/test'
+    expect(CouchPotato.full_url_to_database).to eq('http://127.0.0.1:5984/test')
   end
 
   it "should return the set url" do
     CouchPotato::Config.database_name = 'http://db.local/test'
-    CouchPotato.full_url_to_database.should == 'http://db.local/test'
+    expect(CouchPotato.full_url_to_database).to eq('http://db.local/test')
   end
 end
 
 describe CouchPotato, 'use' do
   it 'should return the db object' do
     db = CouchPotato.use("testdb")
-    db.couchrest_database.root.should == 'http://127.0.0.1:5984/testdb'
+    expect(db.couchrest_database.root.to_s).to eq('http://127.0.0.1:5984/testdb')
   end
 end
 

data/spec/unit/create_spec.rb

@@ -9,29 +9,29 @@ describe "create" do
     
     def create_comment
       comment = Comment.new :title => 'my_title'
-      CouchPotato::Database.new(stub('database', :save_doc => {'rev' => '123', 'id' => '456'}, :info => nil)).save_document!(comment)
+      CouchPotato::Database.new(double('database', :save_doc => {'rev' => '123', 'id' => '456'}, :info => nil)).save_document!(comment)
       comment
     end
 
     it "should assign the id" do
-      create_comment._id.should == '456'
+      expect(create_comment._id).to eq('456')
     end
 
     it "should assign the revision" do
-      create_comment._rev.should == '123'
+      expect(create_comment._rev).to eq('123')
     end
 
     it "should set created at in the current time zone" do
       Time.zone = 'Europe/Berlin'
       Timecop.travel Time.zone.parse('2010-01-01 12:00 +0100') do
-        create_comment.created_at.to_s.should == '2010-01-01 12:00:00 +0100'
+        expect(create_comment.created_at.to_s).to eq('2010-01-01 12:00:00 +0100')
       end
     end
 
     it "should set updated at in the current time zone" do
       Time.zone = 'Europe/Berlin'
       Timecop.travel Time.zone.parse('2010-01-01 12:00 +0100') do
-        create_comment.updated_at.to_s.should == '2010-01-01 12:00:00 +0100'
+        expect(create_comment.updated_at.to_s).to eq('2010-01-01 12:00:00 +0100')
       end
     end
   end
@@ -39,30 +39,30 @@ describe "create" do
   describe "fails" do
     before(:each) do
       @comment = Comment.new
-      CouchPotato::Database.new(stub('database', :info => nil)).save_document(@comment)
+      CouchPotato::Database.new(double('database', :info => nil)).save_document(@comment)
     end
 
     it "should not assign an id" do
-      @comment._id.should be_nil
+      expect(@comment._id).to be_nil
     end
 
     it "should not assign a revision" do
-      @comment._rev.should be_nil
+      expect(@comment._rev).to be_nil
     end
 
     it "should not set created at" do
-      @comment.created_at.should be_nil
+      expect(@comment.created_at).to be_nil
     end
 
     it "should set updated at" do
-      @comment.updated_at.should be_nil
+      expect(@comment.updated_at).to be_nil
     end
     
     describe "with bank" do
       it "should raise an exception" do
-        lambda {
+        expect {
           @comment.save!
-        }.should raise_error
+        }.to raise_error
       end
     end
   end

data/spec/unit/custom_views_spec.rb

@@ -9,7 +9,7 @@ describe CouchPotato::View::CustomViews do
   end
   
   it "should use a custom viewspec class" do
-    MyViewSpec.should_receive(:new)
+    expect(MyViewSpec).to receive(:new)
     ModelWithView.all
   end
 end

data/spec/unit/database_spec.rb

@@ -22,42 +22,42 @@ describe CouchPotato::Database, 'full_url_to_database' do
 
   it "should return the full URL when it starts with https" do
     CouchPotato::Config.database_name = "https://example.com/database"
-    CouchPotato.full_url_to_database.should == 'https://example.com/database'
+    expect(CouchPotato.full_url_to_database).to eq('https://example.com/database')
   end
 
   it "should return the full URL when it starts with http" do
     CouchPotato::Config.database_name = "http://example.com/database"
-    CouchPotato.full_url_to_database.should == 'http://example.com/database'
+    expect(CouchPotato.full_url_to_database).to eq('http://example.com/database')
   end
 
   it "should use localhost when no protocol was specified" do
     CouchPotato::Config.database_name = "database"
-    CouchPotato.full_url_to_database.should == 'http://127.0.0.1:5984/database'
+    expect(CouchPotato.full_url_to_database).to eq('http://127.0.0.1:5984/database')
   end
 end
 
 describe CouchPotato::Database, 'load' do
 
-  let(:couchrest_db) { stub('couchrest db', :info => nil).as_null_object }
+  let(:couchrest_db) { double('couchrest db', :info => nil).as_null_object }
   let(:db) { CouchPotato::Database.new couchrest_db }
 
   it "should raise an exception if nil given" do
-    lambda {
+    expect {
       db.load nil
-    }.should raise_error("Can't load a document without an id (got nil)")
+    }.to raise_error("Can't load a document without an id (got nil)")
   end
 
   it "should set itself on the model" do
-    user = mock('user').as_null_object
-    DbTestUser.stub!(:new).and_return(user)
-    couchrest_db.stub(:get).and_return DbTestUser.json_create({JSON.create_id => 'DbTestUser'})
-    user.should_receive(:database=).with(db)
+    user = double('user').as_null_object
+    allow(DbTestUser).to receive(:new).and_return(user)
+    allow(couchrest_db).to receive(:get).and_return DbTestUser.json_create({JSON.create_id => 'DbTestUser'})
+    expect(user).to receive(:database=).with(db)
     db.load '1'
   end
 
   it "should load namespaced models" do
-    couchrest_db.stub(:get).and_return Parent::Child.json_create({JSON.create_id => 'Parent::Child'})
-    db.load('1').class.should == Parent::Child
+    allow(couchrest_db).to receive(:get).and_return Parent::Child.json_create({JSON.create_id => 'Parent::Child'})
+    expect(db.load('1').class).to eq(Parent::Child)
   end
 
   context "when several ids given" do
@@ -68,32 +68,32 @@ describe CouchPotato::Database, 'load' do
     end
 
     before(:each) do
-      couchrest_db.stub(:bulk_load) { response }
+      allow(couchrest_db).to receive(:bulk_load) { response }
     end
 
     it "requests the couchrest bulk method" do
-      couchrest_db.should_receive(:bulk_load).with(['1', '2', '3'])
+      expect(couchrest_db).to receive(:bulk_load).with(['1', '2', '3'])
       db.load ['1', '2', '3']
     end
 
     it "returns only found documents" do
-      db.load(['1', '2', '3']).should have(2).items
+      expect(db.load(['1', '2', '3']).size).to eq(2)
     end
 
     it "writes itself to each of the documents" do
       db.load(['1', '2', '3']).each do |doc|
-        doc.database.should eql(db)
+        expect(doc.database).to eql(db)
       end
     end
 
     it 'does not write itself to a document that has no database= method' do
-      doc1 = stub(:doc1)
-      doc1.stub(:respond_to?).with(:database=) { false }
-      couchrest_db.stub(:bulk_load) do
+      doc1 = double(:doc1)
+      allow(doc1).to receive(:respond_to?).with(:database=) { false }
+      allow(couchrest_db).to receive(:bulk_load) do
         {"rows" => [{'doc' => doc1}]}
       end
 
-      doc1.should_not_receive(:database=)
+      expect(doc1).not_to receive(:database=)
 
       db.load(['1'])
     end
@@ -102,19 +102,19 @@ end
 
 describe CouchPotato::Database, 'load!' do
 
-  let(:db) { CouchPotato::Database.new(stub('couchrest db', :info => nil).as_null_object) }
+  let(:db) { CouchPotato::Database.new(double('couchrest db', :info => nil).as_null_object) }
 
   it "should raise an error if no document found" do
-    db.couchrest_database.stub(:get).and_raise(RestClient::ResourceNotFound)
-    lambda {
+    allow(db.couchrest_database).to receive(:get).and_return(nil)
+    expect {
       db.load! '1'
-    }.should raise_error(CouchPotato::NotFound)
+    }.to raise_error(CouchPotato::NotFound)
   end
 
   it 'returns the found document' do
-    doc = stub(:doc).as_null_object
-    db.couchrest_database.stub(:get) {doc}
-    db.load!('1').should == doc
+    doc = double(:doc).as_null_object
+    allow(db.couchrest_database).to receive(:get) {doc}
+    expect(db.load!('1')).to eq(doc)
   end
 
   context "when several ids given" do
@@ -127,33 +127,33 @@ describe CouchPotato::Database, 'load!' do
     end
 
     before(:each) do
-      db.stub(:load).and_return(docs)
+      allow(db).to receive(:load).and_return(docs)
     end
 
     it "raises an exception when not all documents could be found" do
-      lambda {
+      expect {
         db.load! ['1', '2', '3', '4']
-      }.should raise_error(CouchPotato::NotFound, '3, 4')
+      }.to raise_error(CouchPotato::NotFound, '3, 4')
     end
 
     it "raises no exception when all documents are found" do
       docs << DbTestUser.new(:id => '3')
-      lambda {
+      expect {
         db.load! ['1', '2', '3']
-      }.should_not raise_error(CouchPotato::NotFound)
+      }.not_to raise_error
     end
   end
 end
 
 describe CouchPotato::Database, 'save_document' do
   before(:each) do
-    @db = CouchPotato::Database.new(stub('couchrest db').as_null_object)
+    @db = CouchPotato::Database.new(double('couchrest db').as_null_object)
   end
 
   it "should set itself on the model for a new object before doing anything else" do
-    @db.stub(:valid_document?).and_return false
-    user = stub('user', :new? => true).as_null_object
-    user.should_receive(:database=).with(@db)
+    allow(@db).to receive(:valid_document?).and_return false
+    user = double('user', :new? => true).as_null_object
+    expect(user).to receive(:database=).with(@db)
     @db.save_document user
   end
 
@@ -164,33 +164,33 @@ describe CouchPotato::Database, 'save_document' do
   end
 
   it "should return false when creating a new document and the validations failed" do
-    CouchPotato.database.save_document(Category.new).should == false
+    expect(CouchPotato.database.save_document(Category.new)).to eq(false)
   end
 
   it "should return false when saving an existing document and the validations failed" do
     category = Category.new(:name => "pizza")
-    CouchPotato.database.save_document(category).should == true
+    expect(CouchPotato.database.save_document(category)).to eq(true)
     category.name = nil
-    CouchPotato.database.save_document(category).should == false
+    expect(CouchPotato.database.save_document(category)).to eq(false)
   end
 
   describe "when creating with validate options" do
     it "should not run the validations when saved with false" do
       category = Category.new
       @db.save_document(category, false)
-      category.new?.should == false
+      expect(category.new?).to eq(false)
     end
 
     it "should run the validations when saved with true" do
       category = Category.new
       @db.save_document(category, true)
-      category.new?.should == true
+      expect(category.new?).to eq(true)
     end
 
     it "should run the validations when saved with default" do
       category = Category.new
       @db.save_document(category)
-      category.new?.should == true
+      expect(category.new?).to eq(true)
     end
   end
 
@@ -198,29 +198,29 @@ describe CouchPotato::Database, 'save_document' do
     it "should not run the validations when saved with false" do
       category = Category.new(:name => 'food')
       @db.save_document(category)
-      category.new?.should be_false
+      expect(category.new?).to be_falsey
       category.name = nil
       @db.save_document(category, false)
-      category.dirty?.should be_false
+      expect(category.dirty?).to be_falsey
     end
 
     it "should run the validations when saved with true" do
       category = Category.new(:name => "food")
       @db.save_document(category)
-      category.new?.should == false
+      expect(category.new?).to eq(false)
       category.name = nil
       @db.save_document(category, true)
-      category.dirty?.should == true
-      category.valid?.should == false
+      expect(category.dirty?).to eq(true)
+      expect(category.valid?).to eq(false)
     end
 
     it "should run the validations when saved with default" do
       category = Category.new(:name => "food")
       @db.save_document(category)
-      category.new?.should == false
+      expect(category.new?).to eq(false)
       category.name = nil
       @db.save_document(category)
-      category.dirty?.should == true
+      expect(category.dirty?).to eq(true)
     end
   end
 
@@ -241,23 +241,23 @@ describe CouchPotato::Database, 'save_document' do
     it "should keep errors added in before_validation_on_* callbacks when creating a new object" do
       spock = Vulcan.new(:name => 'spock')
       @db.save_document(spock)
-      spock.errors[:validation].should == ['failed']
+      expect(spock.errors[:validation]).to eq(['failed'])
     end
 
     it "should keep errors added in before_validation_on_* callbacks when creating a new object" do
       spock = Vulcan.new(:name => 'spock')
       @db.save_document(spock, false)
-      spock.new?.should == false
+      expect(spock.new?).to eq(false)
       spock.name = "spock's father"
       @db.save_document(spock)
-      spock.errors[:validation].should == ['failed']
+      expect(spock.errors[:validation]).to eq(['failed'])
     end
 
     it "should keep errors generated from normal validations together with errors set in normal validations" do
       spock = Vulcan.new
       @db.save_document(spock)
-      spock.errors[:validation].should == ['failed']
-      spock.errors[:name].first.should =~ /can't be (empty|blank)/
+      expect(spock.errors[:validation]).to eq(['failed'])
+      expect(spock.errors[:name].first).to match(/can't be (empty|blank)/)
     end
 
     it "should clear errors on subsequent, valid saves when creating" do
@@ -266,7 +266,7 @@ describe CouchPotato::Database, 'save_document' do
 
       spock.name = 'Spock'
       @db.save_document(spock)
-      spock.errors[:name].should == []
+      expect(spock.errors[:name]).to eq([])
     end
 
     it "should clear errors on subsequent, valid saves when updating" do
@@ -275,11 +275,11 @@ describe CouchPotato::Database, 'save_document' do
 
       spock.name = nil
       @db.save_document(spock)
-      spock.errors[:name].first.should =~ /can't be (empty|blank)/
+      expect(spock.errors[:name].first).to match(/can't be (empty|blank)/)
 
       spock.name = 'Spock'
       @db.save_document(spock)
-      spock.errors[:name].should == []
+      expect(spock.errors[:name]).to eq([])
     end
 
   end
@@ -287,59 +287,59 @@ end
 
 describe CouchPotato::Database, 'first' do
   before(:each) do
-    @couchrest_db = stub('couchrest db').as_null_object
+    @couchrest_db = double('couchrest db').as_null_object
     @db = CouchPotato::Database.new(@couchrest_db)
-    @result = stub('result')
-    @spec = stub('view spec', :process_results => [@result]).as_null_object
-    CouchPotato::View::ViewQuery.stub(:new => stub('view query', :query_view! => {'rows' => [@result]}))
+    @result = double('result')
+    @spec = double('view spec', :process_results => [@result]).as_null_object
+    allow(CouchPotato::View::ViewQuery).to receive_messages(:new => double('view query', :query_view! => {'rows' => [@result]}))
   end
 
   it "should return the first result from a view query" do
-    @db.first(@spec).should == @result
+    expect(@db.first(@spec)).to eq(@result)
   end
 
   it "should return nil if there are no results" do
-    @spec.stub(:process_results => [])
-    @db.first(@spec).should be_nil
+    allow(@spec).to receive_messages(:process_results => [])
+    expect(@db.first(@spec)).to be_nil
   end
 end
 
 describe CouchPotato::Database, 'first!' do
   before(:each) do
-    @couchrest_db = stub('couchrest db').as_null_object
+    @couchrest_db = double('couchrest db').as_null_object
     @db = CouchPotato::Database.new(@couchrest_db)
-    @result = stub('result')
-    @spec = stub('view spec', :process_results => [@result]).as_null_object
-    CouchPotato::View::ViewQuery.stub(:new => stub('view query', :query_view! => {'rows' => [@result]}))
+    @result = double('result')
+    @spec = double('view spec', :process_results => [@result]).as_null_object
+    allow(CouchPotato::View::ViewQuery).to receive_messages(:new => double('view query', :query_view! => {'rows' => [@result]}))
   end
 
   it "returns the first result from a view query" do
-    @db.first!(@spec).should == @result
+    expect(@db.first!(@spec)).to eq(@result)
   end
 
   it "raises an error if there are no results" do
-    @spec.stub(:process_results => [])
-    lambda {
+    allow(@spec).to receive_messages(:process_results => [])
+    expect {
       @db.first!(@spec)
-    }.should raise_error(CouchPotato::NotFound)
+    }.to raise_error(CouchPotato::NotFound)
   end
 end
 
 describe CouchPotato::Database, 'view' do
   before(:each) do
-    @couchrest_db = stub('couchrest db').as_null_object
+    @couchrest_db = double('couchrest db').as_null_object
     @db = CouchPotato::Database.new(@couchrest_db)
-    @result = stub('result')
-    @spec = stub('view spec', :process_results => [@result]).as_null_object
-    CouchPotato::View::ViewQuery.stub(:new => stub('view query', :query_view! => {'rows' => [@result]}))
+    @result = double('result')
+    @spec = double('view spec', :process_results => [@result]).as_null_object
+    allow(CouchPotato::View::ViewQuery).to receive_messages(:new => double('view query', :query_view! => {'rows' => [@result]}))
   end
 
   it "initialzes a view query with map/reduce/list/lib funtions" do
-    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+    allow(@spec).to receive_messages(:design_document => 'design_doc', :view_name => 'my_view',
       :map_function => '<map_code>', :reduce_function => '<reduce_code>',
       :lib => {:test => '<test_code>'},
       :list_name => 'my_list', :list_function => '<list_code>', :language => 'javascript')
-    CouchPotato::View::ViewQuery.should_receive(:new).with(
+    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
       @couchrest_db,
       'design_doc',
       {'my_view' => {
@@ -353,11 +353,11 @@ describe CouchPotato::Database, 'view' do
   end
 
   it "initialzes a view query with map/reduce/list funtions" do
-    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+    allow(@spec).to receive_messages(:design_document => 'design_doc', :view_name => 'my_view',
       :map_function => '<map_code>', :reduce_function => '<reduce_code>',
       :lib => nil, :list_name => 'my_list', :list_function => '<list_code>',
       :language => 'javascript')
-    CouchPotato::View::ViewQuery.should_receive(:new).with(
+    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
       @couchrest_db,
       'design_doc',
       {'my_view' => {
@@ -371,11 +371,11 @@ describe CouchPotato::Database, 'view' do
   end
 
   it "initialzes a view query with only map/reduce/lib functions" do
-    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+    allow(@spec).to receive_messages(:design_document => 'design_doc', :view_name => 'my_view',
       :map_function => '<map_code>', :reduce_function => '<reduce_code>',
       :list_name => nil, :list_function => nil,
-      :lib => {:test => '<test_code>'}).as_null_object
-    CouchPotato::View::ViewQuery.should_receive(:new).with(
+      :lib => {:test => '<test_code>'})
+    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
       @couchrest_db,
       'design_doc',
       {'my_view' => {
@@ -386,10 +386,10 @@ describe CouchPotato::Database, 'view' do
   end
 
   it "initialzes a view query with only map/reduce functions" do
-    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+    allow(@spec).to receive_messages(:design_document => 'design_doc', :view_name => 'my_view',
       :map_function => '<map_code>', :reduce_function => '<reduce_code>',
-      :lib => nil, :list_name => nil, :list_function => nil).as_null_object
-    CouchPotato::View::ViewQuery.should_receive(:new).with(
+      :lib => nil, :list_name => nil, :list_function => nil)
+    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
       @couchrest_db,
       'design_doc',
       {'my_view' => {
@@ -400,21 +400,21 @@ describe CouchPotato::Database, 'view' do
   end
 
   it "sets itself on returned results that have an accessor" do
-    @result.stub(:respond_to?).with(:database=).and_return(true)
-    @result.should_receive(:database=).with(@db)
+    allow(@result).to receive(:respond_to?).with(:database=).and_return(true)
+    expect(@result).to receive(:database=).with(@db)
     @db.view(@spec)
   end
 
   it "does not set itself on returned results that don't have an accessor" do
-    @result.stub(:respond_to?).with(:database=).and_return(false)
-    @result.should_not_receive(:database=).with(@db)
+    allow(@result).to receive(:respond_to?).with(:database=).and_return(false)
+    expect(@result).not_to receive(:database=).with(@db)
     @db.view(@spec)
   end
 
   it "does not try to set itself on result sets that are not collections" do
-    lambda {
-      @spec.stub(:process_results => 1)
-    }.should_not raise_error
+    expect {
+      allow(@spec).to receive_messages(:process_results => 1)
+    }.not_to raise_error
 
     @db.view(@spec)
   end
@@ -423,10 +423,10 @@ end
 describe CouchPotato::Database, '#destroy' do
   it 'does not try to delete an already deleted document' do
     couchrest_db = double(:couchrest_db)
-    couchrest_db.stub(:delete_doc).and_raise(RestClient::Conflict)
+    allow(couchrest_db).to receive(:delete_doc).and_raise(CouchRest::Conflict)
     db = CouchPotato::Database.new couchrest_db
     document = double(:document, reload: nil).as_null_object
-    document.stub(:run_callbacks).and_yield
+    allow(document).to receive(:run_callbacks).and_yield
 
     expect {
       db.destroy document