couchrest_model 2.1.0.rc1 → 2.2.0.beta1

data/spec/unit/base_spec.rb

@@ -9,7 +9,7 @@ describe "Model Base" do
   
   describe "instance database connection" do
     it "should use the default database" do
-      @obj.database.name.should == 'couchrest-model-test'
+      expect(@obj.database.name).to eq('couchrest-model-test')
     end
     
     it "should override the default db" do
@@ -22,52 +22,52 @@ describe "Model Base" do
   describe "a new model" do
     it "should be a new document" do
       @obj = Basic.new
-      @obj.rev.should be_nil
-      @obj.should be_new
-      @obj.should be_new_document
-      @obj.should be_new_record
+      expect(@obj.rev).to be_nil
+      expect(@obj).to be_new
+      expect(@obj).to be_new_document
+      expect(@obj).to be_new_record
     end
 
     it "should not fail with nil argument" do
       @obj = Basic.new(nil)
-      @obj.should_not be_nil
+      expect(@obj).not_to be_nil
     end
 
     it "should allow the database to be set" do
       @obj = Basic.new(nil, :database => 'database')
-      @obj.database.should eql('database')
+      expect(@obj.database).to eql('database')
     end
 
     it "should support initialization block" do 
       @obj = Basic.new {|b| b.database = 'database'}
-      @obj.database.should eql('database')
+      expect(@obj.database).to eql('database')
     end
 
     it "should only set defined properties" do
       @doc = WithDefaultValues.new(:name => 'test', :foo => 'bar')
-      @doc['name'].should eql('test')
-      @doc['foo'].should be_nil
+      expect(@doc['name']).to eql('test')
+      expect(@doc['foo']).to be_nil
     end
 
-    it "should set all properties with :directly_set_attributes option" do
-      @doc = WithDefaultValues.new({:name => 'test', :foo => 'bar'}, :directly_set_attributes => true)
-      @doc['name'].should eql('test')
-      @doc['foo'].should eql('bar')
+    it "should set all properties with :write_all_attributes option" do
+      @doc = WithDefaultValues.new({:name => 'test', :foo => 'bar'}, :write_all_attributes => true)
+      expect(@doc['name']).to eql('test')
+      expect(@doc['foo']).to eql('bar')
     end
 
     it "should set the model type" do
       @doc = WithDefaultValues.new()
-      @doc[WithDefaultValues.model_type_key].should eql('WithDefaultValues')
+      expect(@doc[WithDefaultValues.model_type_key]).to eql('WithDefaultValues')
     end
 
     it "should call after_initialize method if available" do
       @doc = WithAfterInitializeMethod.new
-      @doc['some_value'].should eql('value')
+      expect(@doc['some_value']).to eql('value')
     end
 
     it "should call after_initialize after block" do
       @doc = WithAfterInitializeMethod.new {|d| d.some_value = "foo"}
-      @doc['some_value'].should eql('foo')
+      expect(@doc['some_value']).to eql('foo')
     end
 
     it "should call after_initialize callback if available" do
@@ -78,7 +78,7 @@ describe "Model Base" do
         def set_name; self.name = "foobar"; end
       end
       @doc = klass.new
-      @doc.name.should eql("foobar")
+      expect(@doc.name).to eql("foobar")
     end
   end
 
@@ -91,14 +91,14 @@ describe "Model Base" do
     describe "#to_key" do
       context "when the document is new" do
         it "returns nil" do
-          @obj.to_key.should be_nil
+          expect(@obj.to_key).to be_nil
         end
       end
 
       context "when the document is not new" do
         it "returns id in an array" do
           @obj.save
-          @obj.to_key.should eql([@obj['_id']])
+          expect(@obj.to_key).to eql([@obj['_id']])
         end
       end
     end
@@ -106,14 +106,14 @@ describe "Model Base" do
     describe "#to_param" do
       context "when the document is new" do
         it "returns nil" do
-          @obj.to_param.should be_nil
+          expect(@obj.to_param).to be_nil
         end
       end
 
       context "when the document is not new" do
         it "returns id" do
           @obj.save
-          @obj.to_param.should eql(@obj['_id'])
+          expect(@obj.to_param).to eql(@obj['_id'])
         end
       end
     end
@@ -121,14 +121,14 @@ describe "Model Base" do
     describe "#persisted?" do
       context "when the document is new" do
         it "returns false" do
-          @obj.persisted?.should be_false
+          expect(@obj.persisted?).to be_falsey
         end
       end
 
       context "when the document is not new" do
         it "returns id" do
           @obj.save
-          @obj.persisted?.should be_true 
+          expect(@obj.persisted?).to be_truthy 
         end
       end
       
@@ -136,29 +136,29 @@ describe "Model Base" do
         it "returns false" do
           @obj.save
           @obj.destroy
-          @obj.persisted?.should be_false
+          expect(@obj.persisted?).to be_falsey
         end
       end
     end
 
     describe "#model_name" do
       it "returns the name of the model" do
-        @obj.class.model_name.should eql('Basic')
-        WithDefaultValues.model_name.human.should eql("With default values")
+        expect(@obj.class.model_name).to eql('Basic')
+        expect(WithDefaultValues.model_name.human).to eql("With default values")
       end
     end
 
     describe "#destroyed?" do
       it "should be present" do
-        @obj.should respond_to(:destroyed?)
+        expect(@obj).to respond_to(:destroyed?)
       end
       it "should return false with new object" do
-        @obj.destroyed?.should be_false
+        expect(@obj.destroyed?).to be_falsey
       end
       it "should return true after destroy" do
         @obj.save
         @obj.destroy
-        @obj.destroyed?.should be_true
+        expect(@obj.destroyed?).to be_truthy
       end
     end
   end
@@ -168,34 +168,34 @@ describe "Model Base" do
       context "on saved document" do
         it "should be true on same document" do
           p = Project.create
-          p.should eql(p)
+          expect(p).to eql(p)
         end
         it "should be true after loading" do
           p = Project.create
-          p.should eql(Project.get(p.id))
+          expect(p).to eql(Project.get(p.id))
         end
         it "should not be true if databases do not match" do
           p = Project.create
           p2 = p.dup
-          p2.stub(:database).and_return('other')
-          p.should_not eql(p2)
+          allow(p2).to receive(:database).and_return('other')
+          expect(p).not_to eql(p2)
         end
         it "should always be false if one document not saved" do
           p = Project.create(:name => 'test')
           o = Project.new(:name => 'test')
-          p.should_not eql(o)
+          expect(p).not_to eql(o)
         end
       end
       context "with new documents" do
         it "should be true when attributes match" do
           p = Project.new(:name => 'test')
           o = Project.new(:name => 'test')
-          p.should eql(o)
+          expect(p).to eql(o)
         end
         it "should not be true when attributes don't match" do
           p = Project.new(:name => 'test')
           o = Project.new(:name => 'testing')
-          p.should_not eql(o)
+          expect(p).not_to eql(o)
         end
       end
     end
@@ -209,37 +209,37 @@ describe "Model Base" do
       @art.save
     end
     it "should work for attribute= methods" do
-      @art['title'].should == "big bad danger"
-      @art.update_attributes_without_saving('date' => Time.now, :title => "super danger")
-      @art['title'].should == "super danger"
+      expect(@art['title']).to eql("big bad danger")
+      @art.write_attributes('date' => Time.now, :title => "super danger")
+      expect(@art['title']).to eql("super danger")
     end
     it "should silently ignore _id" do
-      @art.update_attributes_without_saving('_id' => 'foobar')
-      @art['_id'].should_not == 'foobar'
+      @art.write_attributes('_id' => 'foobar')
+      expect(@art['_id']).to_not eql('foobar')
     end
     it "should silently ignore _rev" do
-      @art.update_attributes_without_saving('_rev' => 'foobar')
-      @art['_rev'].should_not == 'foobar'
+      @art.write_attributes('_rev' => 'foobar')
+      expect(@art['_rev']).to_not eql('foobar')
     end
     it "should silently ignore created_at" do
-      @art.update_attributes_without_saving('created_at' => 'foobar')
+      @art.write_attributes('created_at' => 'foobar')
       expect(@art['created_at'].to_s).to_not eql('foobar')
     end
     it "should silently ignore updated_at" do
-      @art.update_attributes_without_saving('updated_at' => 'foobar')
+      @art.write_attributes('updated_at' => 'foobar')
       expect(@art['updated_at']).to_not eql('foobar')
     end
     it "should also work using attributes= alias" do
-      @art.respond_to?(:attributes=).should be_true
+      expect(@art.respond_to?(:attributes=)).to be_truthy
       @art.attributes = {'date' => Time.now, :title => "something else"}
-      @art['title'].should == "something else"
+      expect(@art['title']).to eql("something else")
     end
     
     it "should not flip out if an attribute= method is missing and ignore it" do
-      lambda {
-        @art.update_attributes_without_saving('slug' => "new-slug", :title => "super danger")
-      }.should_not raise_error
-      @art.slug.should == "big-bad-danger"
+      expect {
+        @art.attributes = {'slug' => "new-slug", :title => "super danger"}
+      }.not_to raise_error
+      expect(@art.slug).to eq("big-bad-danger")
     end
 
     #it "should not change other attributes if there is an error" do
@@ -258,25 +258,25 @@ describe "Model Base" do
       @art.save
     end
     it "should save" do
-      @art['title'].should == "big bad danger"
+      expect(@art['title']).to eq("big bad danger")
       @art.update_attributes('date' => Time.now, :title => "super danger")
       loaded = Article.get(@art.id)
-      loaded['title'].should == "super danger"
+      expect(loaded['title']).to eq("super danger")
     end
   end
 
   describe "with default" do
     it "should have the default value set at initalization" do
-      @obj.preset.should == {:right => 10, :top_align => false}
+      expect(@obj.preset).to eq({:right => 10, :top_align => false})
     end
 
     it "should have the default false value explicitly assigned" do
-      @obj.default_false.should == false
+      expect(@obj.default_false).to eq(false)
     end
     
     it "should automatically call a proc default at initialization" do
-      @obj.set_by_proc.should be_an_instance_of(Time)
-      @obj.set_by_proc.should == @obj.set_by_proc
+      expect(@obj.set_by_proc).to be_an_instance_of(Time)
+      expect(@obj.set_by_proc).to eq(@obj.set_by_proc)
       expect(@obj.set_by_proc.utc).to be < Time.now.utc
     end
     
@@ -288,31 +288,31 @@ describe "Model Base" do
     it "should keep default values for new instances" do
       obj = WithDefaultValues.new
       obj.preset[:alpha] = 123
-      obj.preset.should == {:right => 10, :top_align => false, :alpha => 123}
+      expect(obj.preset).to eq({:right => 10, :top_align => false, :alpha => 123})
       another = WithDefaultValues.new
-      another.preset.should == {:right => 10, :top_align => false}
+      expect(another.preset).to eq({:right => 10, :top_align => false})
     end
     
     it "should work with a default empty array" do
       obj = WithDefaultValues.new(:tags => ['spec'])
-      obj.tags.should == ['spec']
+      expect(obj.tags).to eq(['spec'])
     end
     
     it "should set default value of read-only property" do
       obj = WithDefaultValues.new
-      obj.read_only_with_default.should == 'generic'
+      expect(obj.read_only_with_default).to eq('generic')
     end
   end
 
   describe "simplified way of setting property types" do
     it "should set defaults" do
       obj = WithSimplePropertyType.new
-      obj.preset.should eql('none')
+      expect(obj.preset).to eql('none')
     end
 
     it "should handle arrays" do
       obj = WithSimplePropertyType.new(:tags => ['spec'])
-      obj.tags.should == ['spec']
+      expect(obj.tags).to eq(['spec'])
     end
   end
   
@@ -324,16 +324,16 @@ describe "Model Base" do
       @tmpl2 = WithTemplateAndUniqueID.new(:preset => 'not_value', 'slug' => '1')
     end
     it "should have fields set when new" do
-      @tmpl.preset.should == 'value'
+      expect(@tmpl.preset).to eq('value')
     end
     it "shouldn't override explicitly set values" do
-      @tmpl2.preset.should == 'not_value'
+      expect(@tmpl2.preset).to eq('not_value')
     end
     it "shouldn't override existing documents" do
       @tmpl2.save
       tmpl2_reloaded = WithTemplateAndUniqueID.get(@tmpl2.id)
-      @tmpl2.preset.should == 'not_value'
-      tmpl2_reloaded.preset.should == 'not_value'
+      expect(@tmpl2.preset).to eq('not_value')
+      expect(tmpl2_reloaded.preset).to eq('not_value')
     end
   end
   
@@ -349,7 +349,7 @@ describe "Model Base" do
     end
     it "should find all" do
       rs = WithTemplateAndUniqueID.all 
-      rs.length.should == 4
+      expect(rs.length).to eq(4)
     end
   end
   
@@ -359,14 +359,14 @@ describe "Model Base" do
     end
 
     it ".count should return 0 if there are no docuemtns" do
-      WithTemplateAndUniqueID.count.should == 0
+      expect(WithTemplateAndUniqueID.count).to eq(0)
     end
 
     it ".count should return the number of documents" do
       WithTemplateAndUniqueID.new('slug' => '1').save
       WithTemplateAndUniqueID.new('slug' => '2').save
       WithTemplateAndUniqueID.new('slug' => '3').save
-      WithTemplateAndUniqueID.count.should == 3
+      expect(WithTemplateAndUniqueID.count).to eq(3)
     end
   end
   
@@ -380,11 +380,11 @@ describe "Model Base" do
     end
     it "should find first" do
       rs = WithTemplateAndUniqueID.first
-      rs['slug'].should == "1"
+      expect(rs['slug']).to eq("1")
     end
     it "should return nil if no instances are found" do
       WithTemplateAndUniqueID.all.each {|obj| obj.destroy }
-      WithTemplateAndUniqueID.first.should be_nil
+      expect(WithTemplateAndUniqueID.first).to be_nil
     end
   end
 
@@ -402,13 +402,13 @@ describe "Model Base" do
       @course = Course.get r['id']
     end
     it "should load the course" do
-      @course["professor"]["name"][1].should == "Hinchliff"
+      expect(@course["professor"]["name"][1]).to eq("Hinchliff")
     end
     it "should instantiate the professor as a person" do
-      @course['professor'].last_name.should == "Hinchliff"
+      expect(@course['professor'].last_name).to eq("Hinchliff")
     end
     it "should instantiate the ends_at as a Time" do
-      @course['ends_at'].should == Time.parse("2008/12/19 13:00:00 +0800")
+      expect(@course['ends_at']).to eq(Time.parse("2008/12/19 13:00:00 +0800"))
     end
   end
   
@@ -424,39 +424,39 @@ describe "Model Base" do
       @obj.save
       json = @obj.to_json
       obj = WithDefaultValues.get(@obj.id)
-      obj.should be_an_instance_of(WithDefaultValues)
-      obj.created_at.should be_an_instance_of(Time)
-      obj.updated_at.should be_an_instance_of(Time)
-      obj.created_at.to_s.should == @obj.updated_at.to_s
+      expect(obj).to be_an_instance_of(WithDefaultValues)
+      expect(obj.created_at).to be_an_instance_of(Time)
+      expect(obj.updated_at).to be_an_instance_of(Time)
+      expect(obj.created_at.to_s).to eq(@obj.updated_at.to_s)
     end
     
     it "should not change created_at on update" do
       2.times do 
-        lambda do
+        expect do
           @art.save
-        end.should_not change(@art, :created_at)
+        end.not_to change(@art, :created_at)
       end
     end
      
     it "should set the time on create" do
-      (Time.now - @art.created_at).should < 2
+      expect(Time.now - @art.created_at).to be < 2
       foundart = Article.get @art.id
       # Use string for comparison to cope with microsecond differences
-      foundart.created_at.to_s.should == foundart.updated_at.to_s
+      expect(foundart.created_at.to_s).to eq(foundart.updated_at.to_s)
     end
     it "should set the time on update" do
       @art.title = "new title"  # only saved if @art.changed? == true
       @art.save
-      @art.created_at.should < @art.updated_at
+      expect(@art.created_at).to be < @art.updated_at
     end
   end
   
   describe "getter and setter methods" do
     it "should try to call the arg= method before setting :arg in the hash" do
       @doc = WithGetterAndSetterMethods.new(:arg => "foo")
-      @doc['arg'].should be_nil
-      @doc[:arg].should be_nil
-      @doc.other_arg.should == "foo-foo"
+      expect(@doc['arg']).to be_nil
+      expect(@doc[:arg]).to be_nil
+      expect(@doc.other_arg).to eq("foo-foo")
     end
   end
 
@@ -468,30 +468,30 @@ describe "Model Base" do
     
     it "should not save if a nested casted model is invalid" do
       @cat.favorite_toy = CatToy.new
-      @cat.should_not be_valid
-      @cat.save.should be_false
-      lambda{@cat.save!}.should raise_error
+      expect(@cat).not_to be_valid
+      expect(@cat.save).to be_falsey
+      expect{@cat.save!}.to raise_error(/Validation Failed/)
     end
     
     it "should save when nested casted model is valid" do
       @cat.favorite_toy = CatToy.new(:name => 'Squeaky')
-      @cat.should be_valid
-      @cat.save.should be_true
-      lambda{@cat.save!}.should_not raise_error
+      expect(@cat).to be_valid
+      expect(@cat.save).to be_truthy
+      expect{@cat.save!}.not_to raise_error
     end
     
     it "should not save when nested collection contains an invalid casted model" do
       @cat.toys = [CatToy.new(:name => 'Feather'), CatToy.new]
-      @cat.should_not be_valid
-      @cat.save.should be_false
-      lambda{@cat.save!}.should raise_error
+      expect(@cat).not_to be_valid
+      expect(@cat.save).to be_falsey
+      expect{@cat.save!}.to raise_error(/Validation Failed/)
     end
     
     it "should save when nested collection contains valid casted models" do
       @cat.toys = [CatToy.new(:name => 'feather'), CatToy.new(:name => 'ball-o-twine')]
-      @cat.should be_valid
-      @cat.save.should be_true
-      lambda{@cat.save!}.should_not raise_error
+      expect(@cat).to be_valid
+      expect(@cat.save).to be_truthy
+      expect{@cat.save!}.not_to raise_error
     end
     
     it "should not fail if the nested casted model doesn't have validation" do
@@ -499,8 +499,8 @@ describe "Model Base" do
       Cat.validates_presence_of :name
       cat = Cat.new(:name => 'Mr Bigglesworth')
       cat.trainer = Person.new
-      cat.should be_valid
-      cat.save.should be_true
+      expect(cat).to be_valid
+      expect(cat.save).to be_truthy
     end
   end