couchrest_model 2.1.0.rc1 → 2.2.0.beta1

data/spec/unit/inherited_spec.rb

@@ -18,15 +18,15 @@ end
 
 describe "Using chained inheritance without CouchRest::Model::Base" do
   it "should preserve inheritable attributes" do
-    PlainParent.foo.should == :bar
-    PlainChild.foo.should == :bar
+    expect(PlainParent.foo).to eq(:bar)
+    expect(PlainChild.foo).to eq(:bar)
   end
 end
 
 describe "Using chained inheritance with CouchRest::Model::Base" do
   it "should preserve inheritable attributes" do
-    ExtendedParent.foo.should == :bar
-    ExtendedChild.foo.should == :bar
+    expect(ExtendedParent.foo).to eq(:bar)
+    expect(ExtendedChild.foo).to eq(:bar)
   end
 end
 

data/spec/unit/persistence_spec.rb

@@ -11,17 +11,17 @@ describe CouchRest::Model::Persistence do
 
     it "should instantialize" do
       doc = Article.build_from_database({'_id' => 'testitem1', '_rev' => 123, 'couchrest-type' => 'Article', 'name' => 'my test'})
-      doc.class.should eql(Article)
+      expect(doc.class).to eql(Article)
     end
 
     it "should instantialize of same class if no couchrest-type included from DB" do
       doc = Article.build_from_database({'_id' => 'testitem1', '_rev' => 123, 'name' => 'my test'})
-      doc.class.should eql(Article)
+      expect(doc.class).to eql(Article)
     end
 
     it "should instantiate document of different type" do
       doc = Article.build_from_database({'_id' => 'testitem2', '_rev' => 123, Article.model_type_key => 'WithTemplateAndUniqueID', 'name' => 'my test'})
-      doc.class.should eql(WithTemplateAndUniqueID)
+      expect(doc.class).to eql(WithTemplateAndUniqueID)
     end
 
   end
@@ -32,16 +32,16 @@ describe CouchRest::Model::Persistence do
       @obj.name = "should be easily saved and retrieved"
       @obj.save!
       saved_obj = WithDefaultValues.get!(@obj.id)
-      saved_obj.should_not be_nil
+      expect(saved_obj).not_to be_nil
     end
 
     it "should parse the Time attributes automatically" do
       @obj.name = "should parse the Time attributes automatically"
-      @obj.set_by_proc.should be_an_instance_of(Time)
+      expect(@obj.set_by_proc).to be_an_instance_of(Time)
       @obj.save
-      @obj.set_by_proc.should be_an_instance_of(Time)
+      expect(@obj.set_by_proc).to be_an_instance_of(Time)
       saved_obj = WithDefaultValues.get(@obj.id)
-      saved_obj.set_by_proc.should be_an_instance_of(Time)
+      expect(saved_obj.set_by_proc).to be_an_instance_of(Time)
     end
   end
  
@@ -52,49 +52,49 @@ describe CouchRest::Model::Persistence do
     end
    
     it "should accept true or false on save for validation" do
-      @sobj.should_receive(:valid?)
+      expect(@sobj).to receive(:valid?)
       @sobj.save(true)
     end
 
     it "should accept hash with validation option" do
-      @sobj.should_receive(:valid?)
+      expect(@sobj).to receive(:valid?)
       @sobj.save(:validate => true)
     end
 
     it "should not call validation when option is false" do
-      @sobj.should_not_receive(:valid?)
+      expect(@sobj).not_to receive(:valid?)
       @sobj.save(false)
     end
 
     it "should not call validation when option :validate is false" do
-      @sobj.should_not_receive(:valid?)
+      expect(@sobj).not_to receive(:valid?)
       @sobj.save(:validate => false)
     end
 
     it "should instantialize and save a document" do
       article = Article.create(:title => 'my test')
-      article.title.should == 'my test'
-      article.should_not be_new
+      expect(article.title).to eq('my test')
+      expect(article).not_to be_new
     end 
     
     it "yields new instance to block before saving (#create)" do
       article = Article.create{|a| a.title = 'my create init block test'}
-      article.title.should == 'my create init block test'
-      article.should_not be_new
+      expect(article.title).to eq('my create init block test')
+      expect(article).not_to be_new
     end 
 
     it "yields new instance to block before saving (#create!)" do
       article = Article.create{|a| a.title = 'my create bang init block test'}
-      article.title.should == 'my create bang init block test'
-      article.should_not be_new
+      expect(article.title).to eq('my create bang init block test')
+      expect(article).not_to be_new
     end 
 
     it "should trigger the create callbacks" do
       doc = WithCallBacks.create(:name => 'my other test') 
-      doc.run_before_create.should be_true
-      doc.run_after_create.should be_true
-      doc.run_before_save.should be_true
-      doc.run_after_save.should be_true
+      expect(doc.run_before_create).to be_truthy
+      expect(doc.run_after_create).to be_truthy
+      expect(doc.run_before_save).to be_truthy
+      expect(doc.run_after_save).to be_truthy
     end
 
   end
@@ -102,46 +102,46 @@ describe CouchRest::Model::Persistence do
   describe "saving a model" do
     before(:all) do
       @sobj = Basic.new
-      @sobj.save.should be_true
+      expect(@sobj.save).to be_truthy
     end
     
     it "should save the doc" do
       doc = Basic.get(@sobj.id)
-      doc['_id'].should == @sobj.id
+      expect(doc['_id']).to eq(@sobj.id)
     end
     
     it "should be set for resaving" do
       rev = @obj.rev
       @sobj['another-key'] = "some value"
       @sobj.save
-      @sobj.rev.should_not == rev
+      expect(@sobj.rev).not_to eq(rev)
     end
     
     it "should set the id" do
-      @sobj.id.should be_an_instance_of(String)
+      expect(@sobj.id).to be_an_instance_of(String)
     end
     
     it "should set the type" do
-      @sobj[@sobj.model_type_key].should == 'Basic'
+      expect(@sobj[@sobj.model_type_key]).to eq('Basic')
     end
 
     it "should accept true or false on save for validation" do
-      @sobj.should_receive(:valid?)
+      expect(@sobj).to receive(:valid?)
       @sobj.save(true)
     end
 
     it "should accept hash with validation option" do
-      @sobj.should_receive(:valid?)
+      expect(@sobj).to receive(:valid?)
       @sobj.save(:validate => true)
     end
 
     it "should not call validation when option is false" do
-      @sobj.should_not_receive(:valid?)
+      expect(@sobj).not_to receive(:valid?)
       @sobj.save(false)
     end
 
     it "should not call validation when option :validate is false" do
-      @sobj.should_not_receive(:valid?)
+      expect(@sobj).not_to receive(:valid?)
       @sobj.save(:validate => false)
     end
 
@@ -152,12 +152,12 @@ describe CouchRest::Model::Persistence do
       end
       
       it "should return true if save the document" do
-        @sobj.save!.should be_true
+        expect(@sobj.save!).to be_truthy
       end
       
       it "should raise error if don't save the document" do
         @sobj.first_name = nil
-        lambda { @sobj.save! }.should raise_error(CouchRest::Model::Errors::Validations)
+        expect { @sobj.save! }.to raise_error(CouchRest::Model::Errors::Validations)
       end
 
     end
@@ -171,41 +171,41 @@ describe CouchRest::Model::Persistence do
     end
     
     it "should be a new document" do
-      @art.should be_new
-      @art.title.should be_nil
+      expect(@art).to be_new
+      expect(@art.title).to be_nil
     end
     
     it "should require the title" do
-      lambda{@art.save}.should raise_error
+      expect{@art.save}.to raise_error(/unique_id cannot be nil/)
       @art.title = 'This is the title'
-      @art.save.should be_true
+      expect(@art.save).to be_truthy
     end
     
     it "should not change the slug on update" do
       @art.title = 'This is the title'
-      @art.save.should be_true
+      expect(@art.save).to be_truthy
       @art.title = 'new title'
-      @art.save.should be_true
-      @art.slug.should == 'this-is-the-title'
+      expect(@art.save).to be_truthy
+      expect(@art.slug).to eq('this-is-the-title')
     end
     
     it "should raise an error when the slug is taken" do
       @art.title = 'This is the title'
-      @art.save.should be_true
+      expect(@art.save).to be_truthy
       @art2 = Article.new(:title => 'This is the title!')
-      lambda{@art2.save}.should raise_error
+      expect{@art2.save}.to raise_error(/409 Conflict/)
     end
     
     it "should set the slug" do
       @art.title = 'This is the title'
-      @art.save.should be_true
-      @art.slug.should == 'this-is-the-title'
+      expect(@art.save).to be_truthy
+      expect(@art.slug).to eq('this-is-the-title')
     end
     
     it "should set the id" do
       @art.title = 'This is the title'
-      @art.save.should be_true
-      @art.id.should == 'this-is-the-title'
+      expect(@art.save).to be_truthy
+      expect(@art.id).to eq('this-is-the-title')
     end
   end
 
@@ -217,48 +217,48 @@ describe CouchRest::Model::Persistence do
     end
     
     it "should require the field" do
-      lambda{@templated.save}.should raise_error
+      expect{@templated.save}.to raise_error(/unique_id cannot be nil/)
       @templated['slug'] = 'very-important'
-      @templated.save.should be_true
+      expect(@templated.save).to be_truthy
     end
     
     it "should save with the id" do
       @templated['slug'] = 'very-important'
-      @templated.save.should be_true
+      expect(@templated.save).to be_truthy
       t = WithTemplateAndUniqueID.get('very-important')
-      t.should == @templated
+      expect(t).to eq(@templated)
     end
     
     it "should not change the id on update" do
       @templated['slug'] = 'very-important'
-      @templated.save.should be_true
+      expect(@templated.save).to be_truthy
       @templated['slug'] = 'not-important'
-      @templated.save.should be_true
+      expect(@templated.save).to be_truthy
       t = WithTemplateAndUniqueID.get('very-important')
-      t.id.should == @templated.id
+      expect(t.id).to eq(@templated.id)
     end
     
     it "should raise an error when the id is taken" do
       @templated['slug'] = 'very-important'
-      @templated.save.should be_true
-      lambda{WithTemplateAndUniqueID.new('slug' => 'very-important').save}.should raise_error
+      expect(@templated.save).to be_truthy
+      expect{WithTemplateAndUniqueID.new('slug' => 'very-important').save}.to raise_error(/409 Conflict/)
     end
     
     it "should set the id" do
       @templated['slug'] = 'very-important'
-      @templated.save.should be_true
-      @templated.id.should == 'very-important'
+      expect(@templated.save).to be_truthy
+      expect(@templated.id).to eq('very-important')
     end
   end
 
   describe "destroying an instance" do
     before(:each) do
       @dobj = Event.new
-      @dobj.save.should be_true
+      expect(@dobj.save).to be_truthy
     end
     it "should return true" do
       result = @dobj.destroy
-      result.should be_true
+      expect(result).to be_truthy
     end
     it "should make it go away" do
       @dobj.destroy
@@ -267,17 +267,17 @@ describe CouchRest::Model::Persistence do
     it "should freeze the object" do
       @dobj.destroy
       # In Ruby 1.9.2 this raises RuntimeError, in 1.8.7 TypeError, D'OH!
-      lambda { @dobj.subject = "Test" }.should raise_error(StandardError)
+      expect { @dobj.subject = "Test" }.to raise_error(StandardError)
     end
     it "trying to save after should fail" do
       @dobj.destroy
-      lambda { @dobj.save }.should raise_error(StandardError)
+      expect { @dobj.save }.to raise_error(StandardError)
       expect(Basic.get(@dobj.id)).to be_nil
     end
     it "should make destroyed? true" do
-      @dobj.destroyed?.should be_false
+      expect(@dobj.destroyed?).to be_falsey
       @dobj.destroy
-      @dobj.destroyed?.should be_true
+      expect(@dobj.destroyed?).to be_truthy
     end
   end
 
@@ -289,18 +289,18 @@ describe CouchRest::Model::Persistence do
     end
     it "should load and instantiate it" do
       foundart = Article.get @art.id
-      foundart.title.should == "All About Getting"
+      expect(foundart.title).to eq("All About Getting")
     end
     it "should load and instantiate with find" do
       foundart = Article.find @art.id
-      foundart.title.should == "All About Getting"
+      expect(foundart.title).to eq("All About Getting")
     end
     it "should return nil if `get` is used and the document doesn't exist" do
       foundart = Article.get 'matt aimonetti'
-      foundart.should be_nil
+      expect(foundart).to be_nil
     end                     
     it "should return nil if a blank id is requested" do
-      Article.get("").should be_nil
+      expect(Article.get("")).to be_nil
     end
     it "should raise an error if `get!` is used and the document doesn't exist" do
       expect{ Article.get!('matt aimonetti') }.to raise_error(CouchRest::Model::DocumentNotFound)
@@ -313,7 +313,7 @@ describe CouchRest::Model::Persistence do
     end
     context "without a database" do
       it "should cause #get to raise an error" do
-        Article.stub(:database).and_return(nil)
+        allow(Article).to receive(:database).and_return(nil)
         expect{ Article.get('foo') }.to raise_error(CouchRest::Model::DatabaseNotDefined)
         expect{ Article.get!('foo') }.to raise_error(CouchRest::Model::DatabaseNotDefined)
       end
@@ -339,10 +339,10 @@ describe CouchRest::Model::Persistence do
       @course = Course.get r['id']
     end
     it "should load the course" do
-      @course.title.should == "Metaphysics 200"
+      expect(@course.title).to eq("Metaphysics 200")
     end
     it "should instantiate them as such" do
-      @course["questions"][0].a[0].should == "beast"
+      expect(@course["questions"][0].a[0]).to eq("beast")
     end
   end
 
@@ -354,83 +354,83 @@ describe CouchRest::Model::Persistence do
     
     describe "validation" do
       it "should run before_validation before validating" do
-        @doc.run_before_validation.should be_nil
-        @doc.should be_valid
-        @doc.run_before_validation.should be_true
+        expect(@doc.run_before_validation).to be_nil
+        expect(@doc).to be_valid
+        expect(@doc.run_before_validation).to be_truthy
       end
       it "should run after_validation after validating" do
-        @doc.run_after_validation.should be_nil
-        @doc.should be_valid
-        @doc.run_after_validation.should be_true
+        expect(@doc.run_after_validation).to be_nil
+        expect(@doc).to be_valid
+        expect(@doc.run_after_validation).to be_truthy
       end
     end
 
     describe "with contextual validation on ”create”" do
       it "should validate only within ”create” context" do
         doc = WithContextualValidationOnCreate.new
-        doc.save.should be_false
+        expect(doc.save).to be_falsey
         doc.name = "Alice"
-        doc.save.should be_true
+        expect(doc.save).to be_truthy
 
-        doc.update_attributes(:name => nil).should be_true
+        expect(doc.update_attributes(:name => nil)).to be_truthy
       end
     end
 
     describe "with contextual validation on ”update”" do
       it "should validate only within ”update” context" do
         doc = WithContextualValidationOnUpdate.new
-        doc.save.should be_true
+        expect(doc.save).to be_truthy
 
-        doc.update_attributes(:name => nil).should be_false
-        doc.update_attributes(:name => "Bob").should be_true
+        expect(doc.update_attributes(:name => nil)).to be_falsey
+        expect(doc.update_attributes(:name => "Bob")).to be_truthy
       end
     end
 
     describe "save" do
       it "should run the after filter after saving" do
-        @doc.run_after_save.should be_nil
-        @doc.save.should be_true
-        @doc.run_after_save.should be_true
+        expect(@doc.run_after_save).to be_nil
+        expect(@doc.save).to be_truthy
+        expect(@doc.run_after_save).to be_truthy
       end
       it "should run the grouped callbacks before saving" do
-        @doc.run_one.should be_nil
-        @doc.run_two.should be_nil
-        @doc.run_three.should be_nil
-        @doc.save.should be_true
-        @doc.run_one.should be_true
-        @doc.run_two.should be_true
-        @doc.run_three.should be_true
+        expect(@doc.run_one).to be_nil
+        expect(@doc.run_two).to be_nil
+        expect(@doc.run_three).to be_nil
+        expect(@doc.save).to be_truthy
+        expect(@doc.run_one).to be_truthy
+        expect(@doc.run_two).to be_truthy
+        expect(@doc.run_three).to be_truthy
       end
       it "should not run conditional callbacks" do
         @doc.run_it = false
-        @doc.save.should be_true
-        @doc.conditional_one.should be_nil
-        @doc.conditional_two.should be_nil
+        expect(@doc.save).to be_truthy
+        expect(@doc.conditional_one).to be_nil
+        expect(@doc.conditional_two).to be_nil
       end
       it "should run conditional callbacks" do
         @doc.run_it = true
-        @doc.save.should be_true
-        @doc.conditional_one.should be_true
-        @doc.conditional_two.should be_true
+        expect(@doc.save).to be_truthy
+        expect(@doc.conditional_one).to be_truthy
+        expect(@doc.conditional_two).to be_truthy
       end
     end
     describe "create" do
       it "should run the before save filter when creating" do
-        @doc.run_before_save.should be_nil
-        @doc.create.should_not be_nil
-        @doc.run_before_save.should be_true
+        expect(@doc.run_before_save).to be_nil
+        expect(@doc.create).not_to be_nil
+        expect(@doc.run_before_save).to be_truthy
       end
       it "should run the before create filter" do
-        @doc.run_before_create.should be_nil
-        @doc.create.should_not be_nil
+        expect(@doc.run_before_create).to be_nil
+        expect(@doc.create).not_to be_nil
         @doc.create
-        @doc.run_before_create.should be_true
+        expect(@doc.run_before_create).to be_truthy
       end
       it "should run the after create filter" do
-        @doc.run_after_create.should be_nil
-        @doc.create.should_not be_nil
+        expect(@doc.run_after_create).to be_nil
+        expect(@doc.create).not_to be_nil
         @doc.create
-        @doc.run_after_create.should be_true
+        expect(@doc.run_after_create).to be_truthy
       end
     end
     describe "update" do
@@ -439,19 +439,19 @@ describe CouchRest::Model::Persistence do
         @doc.save
       end      
       it "should run the before update filter when updating an existing document" do
-        @doc.run_before_update.should be_nil
+        expect(@doc.run_before_update).to be_nil
         @doc.update
-        @doc.run_before_update.should be_true
+        expect(@doc.run_before_update).to be_truthy
       end
       it "should run the after update filter when updating an existing document" do
-        @doc.run_after_update.should be_nil
+        expect(@doc.run_after_update).to be_nil
         @doc.update
-        @doc.run_after_update.should be_true
+        expect(@doc.run_after_update).to be_truthy
       end
       it "should run the before update filter when saving an existing document" do
-        @doc.run_before_update.should be_nil
+        expect(@doc.run_before_update).to be_nil
         @doc.save
-        @doc.run_before_update.should be_true
+        expect(@doc.run_before_update).to be_truthy
       end
       
     end
@@ -461,35 +461,35 @@ describe CouchRest::Model::Persistence do
   describe "#reload" do
     it "reloads defined attributes" do
       i = Article.create!(:title => "Reload when changed")
-      i.title.should == "Reload when changed"
+      expect(i.title).to eq("Reload when changed")
 
       i.title = "..."
-      i.title.should == "..."
+      expect(i.title).to eq("...")
 
       i.reload
-      i.title.should == "Reload when changed"
+      expect(i.title).to eq("Reload when changed")
     end
 
     it "reloads defined attributes set to nil" do
       i = Article.create!(:title => "Reload when nil")
-      i.title.should == "Reload when nil"
+      expect(i.title).to eq("Reload when nil")
 
       i.title = nil
-      i.title.should be_nil
+      expect(i.title).to be_nil
 
       i.reload
-      i.title.should == "Reload when nil"
+      expect(i.title).to eq("Reload when nil")
     end
 
     it "returns self" do
       i = Article.create!(:title => "Reload return self")
-      i.reload.should be(i)
+      expect(i.reload).to be(i)
     end
   end
 
   describe ".model_type_value" do
     it "should always return string value of class" do
-      Article.model_type_value.should eql('Article')
+      expect(Article.model_type_value).to eql('Article')
     end
 
     describe "usage" do
@@ -505,8 +505,8 @@ describe CouchRest::Model::Persistence do
         obj = klass.build_from_database(
           '_id' => '1234', 'type' => 'something_else', 'name' => 'Test'
         )
-        obj['type'].should eql('something_else')
-        obj.name.should eql('Test')
+        expect(obj['type']).to eql('something_else')
+        expect(obj.name).to eql('Test')
       end
       it "should fail if different model type value provided" do
         expect {