couchrest_model 2.1.0.rc1 → 2.2.0.beta1

data/spec/unit/casted_array_spec.rb

@@ -17,9 +17,9 @@ describe CouchRest::Model::CastedArray do
       prop   = double('Property')
       parent = double('Parent')
       obj = klass.new([], prop, parent)
-      obj.casted_by_property.should eql(prop)
-      obj.casted_by.should eql(parent)
-      obj.should be_empty
+      expect(obj.casted_by_property).to eql(prop)
+      expect(obj.casted_by).to eql(parent)
+      expect(obj).to be_empty
     end
   end
 
@@ -34,16 +34,16 @@ describe CouchRest::Model::CastedArray do
       ], property)
     end
     it "should return an array" do
-      obj.as_couch_json.should be_a(Array)
+      expect(obj.as_couch_json).to be_a(Array)
     end
     it "should call as_couch_json on each value" do
-      obj.first.should_receive(:as_couch_json)
+      expect(obj.first).to receive(:as_couch_json)
       obj.as_couch_json
     end
     it "should return value if no as_couch_json method" do
       obj = klass.new(['Felix', 'Garfield'], CouchRest::Model::Property.new(:title, :type => String))
-      obj.first.should_not respond_to(:as_couch_json)
-      obj.as_couch_json.first.should eql('Felix')
+      expect(obj.first).not_to respond_to(:as_couch_json)
+      expect(obj.as_couch_json.first).to eql('Felix')
     end
 
   end

data/spec/unit/casted_spec.rb

@@ -23,11 +23,11 @@ describe "casting an extended document" do
   end
 
   it "should retain all properties of the casted attribute" do
-    @car.driver.should == @driver
+    expect(@car.driver).to eq(@driver)
   end
   
   it "should let the casted document know who casted it" do
-    @car.driver.casted_by.should == @car
+    expect(@car.driver.casted_by).to eq(@car)
   end
 end
 
@@ -39,17 +39,17 @@ describe "assigning a value to casted attribute after initializing an object" do
   end
   
   it "should not create an empty casted object" do
-    @car.driver.should be_nil
+    expect(@car.driver).to be_nil
   end
   
   it "should let you assign the value" do
     @car.driver = @driver
-    @car.driver.name.should == 'Matt'
+    expect(@car.driver.name).to eq('Matt')
   end
   
   it "should cast attribute" do
     @car.driver = JSON.parse(@driver.to_json)
-    @car.driver.should be_instance_of(Driver)
+    expect(@car.driver).to be_instance_of(Driver)
   end
 
 end
@@ -63,10 +63,10 @@ describe "casting a model from parsed JSON" do
   end
 
   it "should cast casted attribute" do
-    @new_car.driver.should be_instance_of(Driver)
+    expect(@new_car.driver).to be_instance_of(Driver)
   end
   
   it "should retain all properties of the casted attribute" do
-    @new_car.driver.should == @driver
+    expect(@new_car.driver).to eq(@driver)
   end
 end

data/spec/unit/configuration_spec.rb

@@ -13,7 +13,7 @@ describe CouchRest::Model::Configuration do
       @class.configure do |config|
         config.foo_bar = 'monkey'
       end
-      @class.foo_bar.should == 'monkey'
+      expect(@class.foo_bar).to eq('monkey')
     end
   end
 
@@ -22,7 +22,7 @@ describe CouchRest::Model::Configuration do
     it "should add a class level accessor" do
       @class.add_config :foo_bar
       @class.foo_bar = 'foo'
-      @class.foo_bar.should == 'foo'
+      expect(@class.foo_bar).to eq('foo')
     end
     
     ['foo', :foo, 45, ['foo', :bar]].each do |val|
@@ -31,13 +31,13 @@ describe CouchRest::Model::Configuration do
         @child_class = Class.new(@class)
 
         @class.foo_bar = val
-        @class.foo_bar.should == val
-        @child_class.foo_bar.should == val
+        expect(@class.foo_bar).to eq(val)
+        expect(@child_class.foo_bar).to eq(val)
 
         @child_class.foo_bar = "bar"
-        @child_class.foo_bar.should == "bar"
+        expect(@child_class.foo_bar).to eq("bar")
 
-        @class.foo_bar.should == val
+        expect(@class.foo_bar).to eq(val)
       end
     end
     
@@ -45,13 +45,13 @@ describe CouchRest::Model::Configuration do
     it "should add an instance level accessor" do
       @class.add_config :foo_bar
       @class.foo_bar = 'foo'
-      @class.new.foo_bar.should == 'foo'
+      expect(@class.new.foo_bar).to eq('foo')
     end
     
     it "should add a convenient in-class setter" do
       @class.add_config :foo_bar
       @class.foo_bar "monkey"
-      @class.foo_bar.should == "monkey"
+      expect(@class.foo_bar).to eq("monkey")
     end
   end
 
@@ -67,10 +67,10 @@ describe CouchRest::Model::Configuration do
       Cat.instance_eval do
         model_type_key 'cat-type'
       end
-      CouchRest::Model::Base.model_type_key.should eql(default_model_key)
-      Cat.model_type_key.should eql('cat-type')
+      expect(CouchRest::Model::Base.model_type_key).to eql(default_model_key)
+      expect(Cat.model_type_key).to eql('cat-type')
       cat = Cat.new
-      cat.model_type_key.should eql('cat-type')
+      expect(cat.model_type_key).to eql('cat-type')
     end
   end
 

data/spec/unit/connection_spec.rb

@@ -14,20 +14,20 @@ describe CouchRest::Model::Connection do
 
     describe "#database" do
       it "should respond to" do
-        @obj.should respond_to(:database)
+        expect(@obj).to respond_to(:database)
       end
       it "should provided class's database" do
-        @obj.class.should_receive :database
+        expect(@obj.class).to receive :database
         @obj.database
       end
     end
 
     describe "#server" do
       it "should respond to method" do
-        @obj.should respond_to(:server)
+        expect(@obj).to respond_to(:server)
       end
       it "should return class's server" do
-        @obj.class.should_receive :server
+        expect(@obj.class).to receive :server
         @obj.server
       end
     end
@@ -36,13 +36,13 @@ describe CouchRest::Model::Connection do
   describe "default configuration" do
 
     it "should provide environment" do
-      @class.environment.should eql(:development)
+      expect(@class.environment).to eql(:development)
     end
     it "should provide connection config file" do
-      @class.connection_config_file.should eql(File.join(Dir.pwd, 'config', 'couchdb.yml'))
+      expect(@class.connection_config_file).to eql(File.join(Dir.pwd, 'config', 'couchdb.yml'))
     end
     it "should provided simple connection details" do
-      @class.connection[:prefix].should eql('couchrest')
+      expect(@class.connection[:prefix]).to eql('couchrest')
     end
 
   end
@@ -51,46 +51,46 @@ describe CouchRest::Model::Connection do
 
     describe ".use_database" do
       it "should respond to" do
-        @class.should respond_to(:use_database)
+        expect(@class).to respond_to(:use_database)
       end
       it "should set the database if object provided" do
         db = @class.server.database('test')
         @class.use_database(db)
-        @class.database.should eql(db)
+        expect(@class.database).to eql(db)
       end
       it "should never prepare the database before it is needed" do
         db = @class.server.database('test')
-        @class.should_not_receive(:prepare_database)
+        expect(@class).not_to receive(:prepare_database)
         @class.use_database('test')
         @class.use_database(db)
       end
       it "should use the database specified" do
         @class.use_database(:test)
-        @class.database.name.should eql('couchrest_test')
+        expect(@class.database.name).to eql('couchrest_test')
       end
     end
 
     describe ".database" do
       it "should respond to" do
-        @class.should respond_to(:database)
+        expect(@class).to respond_to(:database)
       end
       it "should provide a database object" do
-        @class.database.should be_a(CouchRest::Database)
+        expect(@class.database).to be_a(CouchRest::Database)
       end
       it "should provide a database with default name" do
-        @class.database.name.should eql('couchrest')
+        expect(@class.database.name).to eql('couchrest')
       end
     end
 
     describe ".server" do
       it "should respond to" do
-        @class.should respond_to(:server)
+        expect(@class).to respond_to(:server)
       end
       it "should provide a server object" do
-        @class.server.should be_a(CouchRest::Server)
+        expect(@class.server).to be_a(CouchRest::Server)
       end
       it "should provide a server with default config" do
-        @class.server.uri.to_s.should eql("http://localhost:5984")
+        expect(@class.server.uri.to_s).to eql("http://localhost:5984")
       end
       it "should allow the configuration to be overwritten" do
         @class.connection = {
@@ -102,37 +102,37 @@ describe CouchRest::Model::Connection do
             :username => 'foo',
             :password => 'bar'
           }
-        @class.server.uri.to_s.should eql("https://foo:bar@127.0.0.1:5985")
+        expect(@class.server.uri.to_s).to eql("https://foo:bar@127.0.0.1:5985")
       end
 
       it "should pass through the persistent connection option" do
         @class.connection[:persistent] = false
-        expect(@class.server.connection_options[:persistent]).to be_false
+        expect(@class.server.connection_options[:persistent]).to be_falsey
       end
 
     end
 
     describe ".prepare_database" do
       it "should respond to" do
-        @class.should respond_to(:prepare_database)
+        expect(@class).to respond_to(:prepare_database)
       end
 
       it "should join the database name correctly" do
         @class.connection[:suffix] = 'db'
         db = @class.prepare_database('test')
-        db.name.should eql('couchrest_test_db')
+        expect(db.name).to eql('couchrest_test_db')
       end
 
       it "should ignore nil values in database name" do
         @class.connection[:suffix] = nil
         db = @class.prepare_database('test')
-        db.name.should eql('couchrest_test')
+        expect(db.name).to eql('couchrest_test')
       end
 
       it "should use the .use_database value" do
         @class.use_database('testing')
         db = @class.prepare_database
-        db.name.should eql('couchrest_testing')
+        expect(db.name).to eql('couchrest_testing')
       end
     end
 
@@ -140,26 +140,26 @@ describe CouchRest::Model::Connection do
 
       describe ".connection_configuration" do
         it "should provide main config by default" do
-          @class.send(:connection_configuration).should eql(@class.connection)
+          expect(@class.send(:connection_configuration)).to eql(@class.connection)
         end
         it "should load file if available" do
           @class.connection_config_file = File.join(FIXTURE_PATH, 'config', 'couchdb.yml')
           hash = @class.send(:connection_configuration)
-          hash[:protocol].should eql('https')
-          hash[:host].should eql('sample.cloudant.com')
-          hash[:join].should eql('_')
+          expect(hash[:protocol]).to eql('https')
+          expect(hash[:host]).to eql('sample.cloudant.com')
+          expect(hash[:join]).to eql('_')
         end
       end
 
       describe ".load_connection_config_file" do
         it "should provide an empty hash if config not found" do
-          @class.send(:load_connection_config_file).should eql({})
+          expect(@class.send(:load_connection_config_file)).to eql({})
         end
         it "should load file if available" do
           @class.connection_config_file = File.join(FIXTURE_PATH, 'config', 'couchdb.yml')
           hash = @class.send(:load_connection_config_file)
-          hash[:development].should_not be_nil
-          @class.server.uri.to_s.should eql("https://test:user@sample.cloudant.com")
+          expect(hash[:development]).not_to be_nil
+          expect(@class.server.uri.to_s).to eql("https://test:user@sample.cloudant.com")
         end
 
       end

data/spec/unit/core_extensions/{time_parsing.rb → time_parsing_spec.rb}

@@ -6,46 +6,46 @@ describe "Time Parsing core extension" do
   describe "Time" do
 
     it "should respond to .parse_iso8601" do
-      Time.respond_to?("parse_iso8601").should be_true
+      expect(Time.respond_to?("parse_iso8601")).to be_truthy
     end
 
     describe "#as_json" do
 
       it "should convert local time to JSON string" do
         time = Time.new(2011, 04, 01, 19, 05, 30, "+02:00")
-        time.as_json.should eql("2011-04-01T19:05:30.000+02:00")
+        expect(time.as_json).to eql("2011-04-01T19:05:30.000+02:00")
       end
 
       it "should convert utc time to JSON string" do
         time = Time.utc(2011, 04, 01, 19, 05, 30)
-        time.as_json.should eql("2011-04-01T19:05:30.000Z")
+        expect(time.as_json).to eql("2011-04-01T19:05:30.000Z")
       end
 
       it "should convert local time with fraction to JSON" do
         time = Time.new(2011, 04, 01, 19, 05, 30.123, "+02:00")
-        time.as_json.should eql("2011-04-01T19:05:30.123+02:00")
+        expect(time.as_json).to eql("2011-04-01T19:05:30.123+02:00")
       end
 
       it "should convert utc time with fraction to JSON" do
         time = Time.utc(2011, 04, 01, 19, 05, 30.123)
-        time.as_json.should eql("2011-04-01T19:05:30.123Z")
+        expect(time.as_json).to eql("2011-04-01T19:05:30.123Z")
       end
 
       it "should allow fraction digits" do
         time = Time.utc(2011, 04, 01, 19, 05, 30.123456)
-        time.as_json(:fraction_digits => 6).should eql("2011-04-01T19:05:30.123456Z")
+        expect(time.as_json(:fraction_digits => 6)).to eql("2011-04-01T19:05:30.123456Z")
       end
 
       it "should use CouchRest::Model::Base.time_fraction_digits config option" do
         CouchRest::Model::Base.time_fraction_digits = 6
         time = Time.utc(2011, 04, 01, 19, 05, 30.123456)
-        time.as_json.should eql("2011-04-01T19:05:30.123456Z")
+        expect(time.as_json).to eql("2011-04-01T19:05:30.123456Z")
         CouchRest::Model::Base.time_fraction_digits = 3 # Back to normal
       end
 
       it "should cope with a nil options parameter" do
         time = Time.utc(2011, 04, 01, 19, 05, 30.123456)
-        lambda { time.as_json(nil) }.should_not raise_error
+        expect { time.as_json(nil) }.not_to raise_error
       end
 
     end
@@ -56,69 +56,69 @@ describe "Time Parsing core extension" do
 
         before :each do
           # Time.parse should not be called for these tests!
-          Time.stub!(:parse).and_return(nil)
+          allow(Time).to receive(:parse).and_return(nil)
         end
 
         it "should parse JSON time" do
           txt = "2011-04-01T19:05:30Z"
-          Time.parse_iso8601(txt).should eql(Time.utc(2011, 04, 01, 19, 05, 30))
+          expect(Time.parse_iso8601(txt)).to eql(Time.utc(2011, 04, 01, 19, 05, 30))
         end
 
         it "should parse JSON time as UTC without Z" do
           txt = "2011-04-01T19:05:30"
-          Time.parse_iso8601(txt).should eql(Time.utc(2011, 04, 01, 19, 05, 30))
+          expect(Time.parse_iso8601(txt)).to eql(Time.utc(2011, 04, 01, 19, 05, 30))
         end
 
         it "should parse basic time as UTC" do
           txt = "2011-04-01 19:05:30"
-          Time.parse_iso8601(txt).should eql(Time.utc(2011, 04, 01, 19, 05, 30))
+          expect(Time.parse_iso8601(txt)).to eql(Time.utc(2011, 04, 01, 19, 05, 30))
         end
 
         it "should parse JSON time with zone" do
           txt = "2011-04-01T19:05:30 +02:00"
-          Time.parse_iso8601(txt).should eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:00"))
+          expect(Time.parse_iso8601(txt)).to eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:00"))
         end
 
         it "should parse JSON time with zone 2" do
           txt = "2011-04-01T19:05:30-0200"
-          Time.parse_iso8601(txt).should eql(Time.new(2011, 04, 01, 19, 05, 30, "-02:00"))
+          expect(Time.parse_iso8601(txt)).to eql(Time.new(2011, 04, 01, 19, 05, 30, "-02:00"))
         end
 
         it "should parse dodgy time with zone" do
           txt = "2011-04-01 19:05:30 +0200"
-          Time.parse_iso8601(txt).should eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:00"))
+          expect(Time.parse_iso8601(txt)).to eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:00"))
         end
 
         it "should parse dodgy time with zone 2" do
           txt = "2011-04-01 19:05:30+0230"
-          Time.parse_iso8601(txt).should eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:30"))
+          expect(Time.parse_iso8601(txt)).to eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:30"))
         end
 
         it "should parse dodgy time with zone 3" do
           txt = "2011-04-01 19:05:30 0230"
-          Time.parse_iso8601(txt).should eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:30"))
+          expect(Time.parse_iso8601(txt)).to eql(Time.new(2011, 04, 01, 19, 05, 30, "+02:30"))
         end
 
         it "should parse JSON time with second fractions" do
           txt = "2014-12-11T16:53:54.000Z"
-          Time.parse_iso8601(txt).should eql(Time.utc(2014, 12, 11, 16, 53, Rational(54000, 1000)))
+          expect(Time.parse_iso8601(txt)).to eql(Time.utc(2014, 12, 11, 16, 53, Rational(54000, 1000)))
         end
 
         it "should avoid rounding errors parsing JSON time with second fractions" do
           txt = "2014-12-11T16:53:54.548Z"
-          Time.parse_iso8601(txt).should eql(Time.utc(2014, 12, 11, 16, 53, Rational(54548,1000)))
+          expect(Time.parse_iso8601(txt)).to eql(Time.utc(2014, 12, 11, 16, 53, Rational(54548,1000)))
         end
 
       end
 
       it "avoids seconds rounding error" do
         time_string = "2014-12-11T16:54:54.549Z"
-        Time.parse_iso8601(time_string).as_json.should eql(time_string)
+        expect(Time.parse_iso8601(time_string).as_json).to eql(time_string)
       end
 
       describe "resorting back to normal parse" do
         before :each do
-          Time.should_receive(:parse)
+          expect(Time).to receive(:parse)
         end
         it "should work with weird time" do
           txt = "16/07/1981 05:04:00"