spark_api 1.4.29 → 1.5.1

data/spec/unit/spark_api/configuration_spec.rb

@@ -3,18 +3,18 @@ require './spec/spec_helper'
 describe SparkApi::Client, "Client config"  do
   describe "default settings" do
     it "should return the proper defaults when called with no arguments" do
-      SparkApi.api_key.should be_nil
-      SparkApi.api_secret.should be_nil
-      SparkApi.version.should match("v1")
-      SparkApi.ssl_verify.should be_true
-      SparkApi.auth_endpoint.should match("sparkplatform.com/openid")
-      SparkApi.endpoint.should match("api.sparkapi.com")
-      SparkApi.user_agent.should match(/Spark API Ruby Gem .*/)
+      expect(SparkApi.api_key).to be_nil
+      expect(SparkApi.api_secret).to be_nil
+      expect(SparkApi.version).to match("v1")
+      expect(SparkApi.ssl_verify).to be true
+      expect(SparkApi.auth_endpoint).to match("sparkplatform.com/openid")
+      expect(SparkApi.endpoint).to match("api.sparkapi.com")
+      expect(SparkApi.user_agent).to match(/Spark API Ruby Gem .*/)
       SparkApi.api_key = "my_api_key"
-      SparkApi.api_key.should match("my_api_key")
-      SparkApi.timeout.should eq(5)
-      SparkApi.request_id_chain.should be_nil
-      SparkApi.middleware.should eq('spark_api')
+      expect(SparkApi.api_key).to match("my_api_key")
+      expect(SparkApi.timeout).to eq(5)
+      expect(SparkApi.request_id_chain).to be_nil
+      expect(SparkApi.middleware).to eq('spark_api')
     end
   end
 
@@ -28,30 +28,30 @@ describe SparkApi::Client, "Client config"  do
                                     :timeout => 15,
                                     :request_id_chain => 'foobar')
  
-      client.api_key.should match("key_of_wade")
-      client.api_secret.should match("TopSecret")
-      client.api_user.should match("1234")
-      client.auth_endpoint.should match("https://login.wade.dev.fbsdata.com")
-      client.endpoint.should match("http://api.wade.dev.fbsdata.com")
-      client.version.should match("v1")
-      client.timeout.should eq(15)
-      client.request_id_chain.should eq('foobar')
+      expect(client.api_key).to match("key_of_wade")
+      expect(client.api_secret).to match("TopSecret")
+      expect(client.api_user).to match("1234")
+      expect(client.auth_endpoint).to match("https://login.wade.dev.fbsdata.com")
+      expect(client.endpoint).to match("http://api.wade.dev.fbsdata.com")
+      expect(client.version).to match("v1")
+      expect(client.timeout).to eq(15)
+      expect(client.request_id_chain).to eq('foobar')
     end
     
     it "should allow unverified ssl certificates when verification is off" do
       client = SparkApi::Client.new(:auth_endpoint => "https://login.wade.dev.fbsdata.com",
                                     :endpoint => "https://api.wade.dev.fbsdata.com",
                                     :ssl_verify => false)
-      client.ssl_verify.should be_false
-      client.connection.ssl.verify.should be_false
+      expect(client.ssl_verify).to be false
+      expect(client.connection.ssl.verify).to be false
     end
 
     it "should allow restrict ssl certificates when verification is on" do
       client = SparkApi::Client.new(:auth_endpoint => "https://login.wade.dev.fbsdata.com",
                                     :endpoint => "https://api.wade.dev.fbsdata.com",
                                     :ssl_verify => true)
-      client.ssl_verify.should be_true
-      client.connection.ssl.should be_empty
+      expect(client.ssl_verify).to be true
+      expect(client.connection.ssl).to be_empty
     end
   end
 
@@ -67,11 +67,11 @@ describe SparkApi::Client, "Client config"  do
     
     it "should convert the configuration to oauth2 when specified" do
       oauth2_client.oauthify!
-      oauth2_client.oauth2_provider.should be_a(SparkApi::Authentication::SimpleProvider)
+      expect(oauth2_client.oauth2_provider).to be_a(SparkApi::Authentication::SimpleProvider)
     end
 
     it "should say oauth2_enabled? when it is" do
-      oauth2_client.oauth2_enabled?().should be_true
+      expect(oauth2_client.oauth2_enabled?()).to be true
     end
 
     it "should say oauth2_enabled? is false" do
@@ -80,11 +80,11 @@ describe SparkApi::Client, "Client config"  do
                                     :callback => "http://wade.dev.fbsdata.com/callback",
                                     :auth_endpoint => "https://login.wade.dev.fbsdata.com",
                                     :endpoint => "http://api.wade.dev.fbsdata.com")
-      client.oauth2_enabled?().should be_false
+      expect(client.oauth2_enabled?()).to be false
     end
 
     it "should properly build a grant_uri from the endpoint" do
-      oauth2_client.grant_uri.should eq("http://api.wade.dev.fbsdata.com/v1/oauth2/grant")
+      expect(oauth2_client.grant_uri).to eq("http://api.wade.dev.fbsdata.com/v1/oauth2/grant")
     end
   end
 
@@ -100,14 +100,14 @@ describe SparkApi::Client, "Client config"  do
         config.timeout = 15
       end
 
-      SparkApi.api_key.should match("my_key")
-      SparkApi.api_secret.should match("my_secret")
-      SparkApi.api_user.should match("1234")
-      SparkApi.version.should match("veleventy")
-      SparkApi.endpoint.should match("test.api.sparkapi.com")
-      SparkApi.user_agent.should match("my useragent")
-      SparkApi.oauth2_enabled?().should be_false
-      SparkApi.timeout.should eq(15)
+      expect(SparkApi.api_key).to match("my_key")
+      expect(SparkApi.api_secret).to match("my_secret")
+      expect(SparkApi.api_user).to match("1234")
+      expect(SparkApi.version).to match("veleventy")
+      expect(SparkApi.endpoint).to match("test.api.sparkapi.com")
+      expect(SparkApi.user_agent).to match("my useragent")
+      expect(SparkApi.oauth2_enabled?()).to be false
+      expect(SparkApi.timeout).to eq(15)
     end
 
     it "should correctly set up the client for oauth2" do
@@ -120,7 +120,7 @@ describe SparkApi::Client, "Client config"  do
         config.user_agent = "my useragent"
         config.authentication_mode = SparkApi::Authentication::OAuth2
       end
-      SparkApi.oauth2_enabled?().should be_true
+      expect(SparkApi.oauth2_enabled?()).to be true
     end
     
     it "should reset" do
@@ -133,12 +133,11 @@ describe SparkApi::Client, "Client config"  do
         config.request_id_chain = 'foobar'
       end
       
-      SparkApi.api_key.should match("my_key")
-      SparkApi.request_id_chain.should eq("foobar")
+      expect(SparkApi.api_key).to match("my_key")
+      expect(SparkApi.request_id_chain).to eq("foobar")
       SparkApi.reset
-      SparkApi.api_key.should == SparkApi::Configuration::DEFAULT_API_KEY
-      SparkApi.request_id_chain.should SparkApi::Configuration::DEFAULT_REQUEST_ID_CHAIN
-    
+      expect(SparkApi.api_key).to eq(SparkApi::Configuration::DEFAULT_API_KEY)
+      expect(SparkApi.request_id_chain).to eq(SparkApi::Configuration::DEFAULT_REQUEST_ID_CHAIN)
     end
   end
 
@@ -152,7 +151,7 @@ describe SparkApi::Client, "Client config"  do
           }).
           to_return(:body => '{"D":{"Success": true,"Results": [{"SSL":false}]}}')
           
-      SparkApi.client.get('/connections')[0]["SSL"].should eq(false)
+      expect(SparkApi.client.get('/connections')[0]["SSL"]).to eq(false)
     end
 
     it "should use https when ssl is enabled" do
@@ -165,7 +164,7 @@ describe SparkApi::Client, "Client config"  do
           to_return(:body => '{"D":{"Success": true,"Results": [{"SSL":true}]}}')
           
       c = SparkApi::Client.new(:endpoint => "https://api.sparkapi.com", :ssl => true)
-      c.get('/connections')[0]["SSL"].should eq(true)
+      expect(c.get('/connections')[0]["SSL"]).to eq(true)
     end
     
     it "should have correct headers based on configuration" do
@@ -182,7 +181,7 @@ describe SparkApi::Client, "Client config"  do
         config.user_agent = "my useragent"
       end
       SparkApi.client.get '/headers'
-      WebMock.should have_requested(:get, "#{SparkApi.endpoint}/#{SparkApi.version}/headers?ApiUser=foobar&ApiSig=717a066c4f4302c5ca9507e484db4812&AuthToken=c401736bf3d3f754f07c04e460e09573").
+      expect(WebMock).to have_requested(:get, "#{SparkApi.endpoint}/#{SparkApi.version}/headers?ApiUser=foobar&ApiSig=717a066c4f4302c5ca9507e484db4812&AuthToken=c401736bf3d3f754f07c04e460e09573").
         with(:headers => {
           'User-Agent' => SparkApi::Configuration::DEFAULT_USER_AGENT,
           SparkApi::Configuration::X_SPARK_API_USER_AGENT => "my useragent",
@@ -206,7 +205,7 @@ describe SparkApi::Client, "Client config"  do
         config.request_id_chain = 'foobar'
       end
       SparkApi.client.get '/headers'
-      WebMock.should have_requested(:get, "#{SparkApi.endpoint}/#{SparkApi.version}/headers?ApiUser=foobar&ApiSig=717a066c4f4302c5ca9507e484db4812&AuthToken=c401736bf3d3f754f07c04e460e09573").
+      expect(WebMock).to have_requested(:get, "#{SparkApi.endpoint}/#{SparkApi.version}/headers?ApiUser=foobar&ApiSig=717a066c4f4302c5ca9507e484db4812&AuthToken=c401736bf3d3f754f07c04e460e09573").
         with(:headers => {
           'User-Agent' => SparkApi::Configuration::DEFAULT_USER_AGENT,
           SparkApi::Configuration::X_SPARK_API_USER_AGENT => "my useragent",
@@ -218,24 +217,24 @@ describe SparkApi::Client, "Client config"  do
 
     it "should not set gzip header by default" do
       c = SparkApi::Client.new(:endpoint => "https://sparkapi.com")
-      c.connection.headers["Accept-Encoding"].should be_nil
+      expect(c.connection.headers["Accept-Encoding"]).to be_nil
     end
 
     it "should set gzip header if compress option is set" do
       c = SparkApi::Client.new(:endpoint => "https://api.sparkapi.com",
         :compress => true) 
-      c.connection.headers["Accept-Encoding"].should eq("gzip, deflate")
+      expect(c.connection.headers["Accept-Encoding"]).to eq("gzip, deflate")
     end
 
     it "should set default timeout of 5 seconds" do
       c = SparkApi::Client.new(:endpoint => "https://sparkapi.com")
-      c.connection.options[:timeout].should eq(5)
+      expect(c.connection.options[:timeout]).to eq(5)
     end
 
     it "should set alternate timeout if specified" do
       c = SparkApi::Client.new(:endpoint => "https://sparkapi.com",
         :timeout => 15)
-      c.connection.options[:timeout].should eq(15)
+      expect(c.connection.options[:timeout]).to eq(15)
     end
   end
 
@@ -250,14 +249,14 @@ describe SparkApi::Client, "Client config"  do
                                     :middleware => 'reso_api',
                                     :dictionary_version => '1.6')
  
-      client.api_key.should match("key_of_cody")
-      client.api_secret.should match("TopSecret")
-      client.api_user.should match("1234")
-      client.endpoint.should match("http://api.coolio.dev.fbsdata.com")
-      client.timeout.should eq(15)
-      client.request_id_chain.should eq('foobar')
-      client.middleware.should eq('reso_api')
-      client.dictionary_version.should eq('1.6')
+      expect(client.api_key).to match("key_of_cody")
+      expect(client.api_secret).to match("TopSecret")
+      expect(client.api_user).to match("1234")
+      expect(client.endpoint).to match("http://api.coolio.dev.fbsdata.com")
+      expect(client.timeout).to eq(15)
+      expect(client.request_id_chain).to eq('foobar')
+      expect(client.middleware).to eq('reso_api')
+      expect(client.dictionary_version).to eq('1.6')
     end
   end
 end

data/spec/unit/spark_api/faraday_middleware_spec.rb

@@ -64,13 +64,13 @@ describe SparkApi do
     end
     
     it "should raised exception when token is expired" do
-      expect { @connection.get('/expired')}.to raise_error(SparkApi::PermissionDenied){ |e| e.code.should == SparkApi::ResponseCodes::SESSION_TOKEN_EXPIRED }
+      expect { @connection.get('/expired')}.to raise_error(SparkApi::PermissionDenied){ |e| expect(e.code).to eq(SparkApi::ResponseCodes::SESSION_TOKEN_EXPIRED) }
     end
 
     it "should raised exception on error" do
-      expect { @connection.get('/methodnotallowed')}.to raise_error(SparkApi::NotAllowed){ |e| e.message.should == "Method Not Allowed" }
-      expect { @connection.get('/epicfail')}.to raise_error(SparkApi::ClientError){ |e| e.status.should be(500) }
-      expect { @connection.get('/unknownerror')}.to raise_error(SparkApi::ClientError){ |e| e.status.should be(499) }
+      expect { @connection.get('/methodnotallowed')}.to raise_error(SparkApi::NotAllowed){ |e| expect(e.message).to eq("Method Not Allowed") }
+      expect { @connection.get('/epicfail')}.to raise_error(SparkApi::ClientError){ |e| expect(e.status).to be(500) }
+      expect { @connection.get('/unknownerror')}.to raise_error(SparkApi::ClientError){ |e| expect(e.status).to be(499) }
     end
 
     it "should raised exception on invalid responses" do
@@ -81,20 +81,20 @@ describe SparkApi do
 
     it "should give me a session response" do
       response = @connection.post('/session').body
-      response.success.should eq(true)
+      expect(response.success).to eq(true)
       session = SparkApi::Authentication::Session.new(response.results[0])
-      session.auth_token.should eq("xxxxx")
+      expect(session.auth_token).to eq("xxxxx")
     end
     
     it "should give me an api response" do
       response = @connection.get('/system').body
-      response.success.should eq(true)
-      response.results.length.should be > 0 
+      expect(response.success).to eq(true)
+      expect(response.results.length).to be > 0 
     end
 
     it "should include the errors in the response" do
       expect { @connection.get('/badresourcerequest')}.to raise_error(SparkApi::BadResourceRequest){ |e| 
-        e.errors.should == "Some errors and stuff."
+        expect(e.errors).to eq("Some errors and stuff.")
       }
     end
 
@@ -111,7 +111,7 @@ describe SparkApi do
         :response_headers => {}
       }
 
-      middleware.decompress_body(env).should eq("UNCOMPRESSED")
+      expect(middleware.decompress_body(env)).to eq("UNCOMPRESSED")
     end
 
     it "should unzip gzipped data" do
@@ -129,7 +129,7 @@ describe SparkApi do
         }
       }
 
-      middleware.decompress_body(env).should eq(bod)
+      expect(middleware.decompress_body(env)).to eq(bod)
     end
 
     it "should inflate deflated data" do
@@ -143,7 +143,7 @@ describe SparkApi do
         }
       }
 
-      middleware.decompress_body(env).should eq(bod)
+      expect(middleware.decompress_body(env)).to eq(bod)
     end
   end
   

data/spec/unit/spark_api/models/account_spec.rb

@@ -101,20 +101,20 @@ describe Account do
 
     it "should respond to attributes" do
       ['Name','Id','Mls','MlsId','Office'].each do |k|
-        (@account.send k.to_sym).should be_a(String)
+        expect(@account.send k.to_sym).to be_a(String)
       end
     end
 
     it "should have primary subresources" do
-      @account.emails.primary.Address.should eq("work@test.com")
-      @account.phones.primary.Number.should eq("701-555-1212")
-      @account.addresses.primary.Address.should eq("101 Main Ave, Phoenix, AZ 12345")
-      @account.websites.primary.Uri.should eq("http://iamthebestagent.com")
+      expect(@account.emails.primary.Address).to eq("work@test.com")
+      expect(@account.phones.primary.Number).to eq("701-555-1212")
+      expect(@account.addresses.primary.Address).to eq("101 Main Ave, Phoenix, AZ 12345")
+      expect(@account.websites.primary.Uri).to eq("http://iamthebestagent.com")
     end
 
     it "should be able to provide a primary image" do
-      @account.primary_img("Photo").Name.should == 'My Photo 1'
-      @account.primary_img("Logo").Name.should == '1 My Logo'
+      expect(@account.primary_img("Photo").Name).to eq('My Photo 1')
+      expect(@account.primary_img("Logo").Name).to eq('1 My Logo')
     end
 
     after(:each) do
@@ -131,19 +131,19 @@ describe Account do
       on_get_it "should get my account" do
         stub_api_get("/my/account", 'accounts/my.json')
         account = Account.my
-        account.Id.should eq("20000426173054342350000000")
-        account.websites.first.Name.should == 'My Work Website'
+        expect(account.Id).to eq("20000426173054342350000000")
+        expect(account.websites.first.Name).to eq('My Work Website')
       end
 
       on_put_it "should save my portal account" do
         stub_api_get("/my/account", 'accounts/my_portal.json')
         stub_api_put("/my/account", 'accounts/my_save.json', 'accounts/my_put.json')
         account = Account.my
-        account.Id.should eq("20110426173054342350000000")
-        account.GetEmailUpdates.should eq(false)
+        expect(account.Id).to eq("20110426173054342350000000")
+        expect(account.GetEmailUpdates).to eq(false)
         account.GetEmailUpdates = true
         account.save!
-        account.GetEmailUpdates.should eq(true)
+        expect(account.GetEmailUpdates).to eq(true)
       end
     end
 
@@ -151,10 +151,10 @@ describe Account do
       on_get_it "should get all accounts" do
         stub_api_get("/accounts", 'accounts/all.json')
         accounts = Account.get
-        accounts.should be_an(Array)
-        accounts.length.should eq(3)
-        accounts.first.Id.should eq("20000426173054342350000000")
-        accounts.last.Id.should eq("20110126173054382350000000")
+        expect(accounts).to be_an(Array)
+        expect(accounts.length).to eq(3)
+        expect(accounts.first.Id).to eq("20000426173054342350000000")
+        expect(accounts.last.Id).to eq("20110126173054382350000000")
       end
       on_put_it "should save password" do
         stub_api_get("/my/account", 'accounts/my.json')
@@ -162,7 +162,7 @@ describe Account do
         stub_api_put("/accounts/#{account.Id}", 'accounts/password_save.json', 'accounts/my.json')
         account.Password = "1"
         account.PasswordValidation = "1"
-        account.save.should be(true)
+        expect(account.save).to be(true)
       end   
     end
 
@@ -170,10 +170,10 @@ describe Account do
       on_get_it "should all office accounts" do
         stub_api_get("/accounts/by/office/20030426173014239760000000", 'accounts/office.json')
         accounts = Account.by_office("20030426173014239760000000")
-        accounts.should be_an(Array)
-        accounts.length.should eq(2)
+        expect(accounts).to be_an(Array)
+        expect(accounts.length).to eq(2)
         accounts.each do |account|
-          accounts.first.OfficeId.should eq("20030426173014239760000000")
+          expect(accounts.first.OfficeId).to eq("20030426173014239760000000")
         end
       end
     end

data/spec/unit/spark_api/models/activity_spec.rb

@@ -10,9 +10,9 @@ describe Activity do
     it "gets a current user's activities" do
       s = stub_api_get("/activities", "activities/get.json")
       activities = Activity.get
-      activities.should be_an(Array)
-      activities.size.should eq(2)
-      s.should have_been_requested
+      expect(activities).to be_an(Array)
+      expect(activities.size).to eq(2)
+      expect(s).to have_been_requested
     end
   end
 
@@ -21,8 +21,8 @@ describe Activity do
     it "gets an individual activity" do
       s = stub_api_get("/activities/#{id}", "activities/get.json")
       activity = Activity.find(id)
-      activity.should be_an(Activity)
-      s.should have_been_requested
+      expect(activity).to be_an(Activity)
+      expect(s).to have_been_requested
     end
   end
 

data/spec/unit/spark_api/models/base_spec.rb

@@ -22,31 +22,31 @@ describe MyExampleModel, "Example model" do
   end
 
   it "should be persisted" do
-    @model.persisted?.should eq(true)
+    expect(@model.persisted?).to eq(true)
   end
 
   it "should not be persisted" do
     @new_model = MyExampleModel.new()
-    @new_model.persisted?.should eq(false)
+    expect(@new_model.persisted?).to eq(false)
   end
 
   it "should parse and return ResourceUri without v1" do
-    @model.resource_uri.should eq("/some/place/20101230223226074201000000")
+    expect(@model.resource_uri).to eq("/some/place/20101230223226074201000000")
   end
 
   it "should parse and return the correct path for a persisted resource" do
-    @model.path.should eq("/some/place")
+    expect(@model.path).to eq("/some/place")
   end
 
   it "should parse and return the correct path" do
     @model = MyExampleModel.new
-    @model.path.should eq("/test/example")
+    expect(@model.path).to eq("/test/example")
   end
 
   it "should parse and return the correct path for resource with a parent" do
     @model = MyExampleModel.new
     @model.parent = Contact.new({ :Id => "20101230223226074201000000" })
-    @model.path.should eq("/contacts/20101230223226074201000000/test/example")
+    expect(@model.path).to eq("/contacts/20101230223226074201000000/test/example")
   end
 
 end
@@ -55,16 +55,16 @@ describe Base, "Base model" do
 
   describe "class methods" do
     it "should set the element name" do
-      MyExampleModel.element_name.should eq("example")
-      MyDefaultModel.element_name.should eq("resource")
+      expect(MyExampleModel.element_name).to eq("example")
+      expect(MyDefaultModel.element_name).to eq("resource")
     end
     it "should set the prefix" do
-      MyExampleModel.prefix.should eq("/test/")
-      MyDefaultModel.prefix.should eq("/")
+      expect(MyExampleModel.prefix).to eq("/test/")
+      expect(MyDefaultModel.prefix).to eq("/")
     end
     it "should set the path" do
-      MyExampleModel.path.should eq("/test/example")
-      MyDefaultModel.path.should eq("/resource")
+      expect(MyExampleModel.path).to eq("/test/example")
+      expect(MyDefaultModel.path).to eq("/resource")
     end
     describe "finders" do
       before(:each) do
@@ -72,11 +72,11 @@ describe Base, "Base model" do
         stub_api_get("/test/example", 'base.json')
       end
       it "should get all results" do
-        MyExampleModel.get.length.should == 2
+        expect(MyExampleModel.get.length).to eq(2)
       end
       it "should get first result" do
-        MyExampleModel.first.Id.should == 1
-        MyExampleModel.first.Id.should eq(MyExampleModel.first.id)
+        expect(MyExampleModel.first.Id).to eq(1)
+        expect(MyExampleModel.first.Id).to eq(MyExampleModel.first.id)
       end
     end
   end
@@ -89,71 +89,71 @@ describe Base, "Base model" do
     end
 
     it "should access existing attributes" do
-      @model.Name.should == 'My Example'
+      expect(@model.Name).to eq('My Example')
     end
 
     it "should raise errors on access to non-existant attributes" do
-      lambda { @model.Nonsense }.should raise_error(NoMethodError)
+      expect { @model.Nonsense }.to raise_error(NoMethodError)
     end
 
     it "should set existing attributes" do
       new_name = 'John Jacob Jingleheimerschmidt'
       @model.Name = new_name
-      @model.Name.should == new_name
+      expect(@model.Name).to eq(new_name)
     end
 
     it "should set non-existant attributes" do
       nonsense = 'nonsense'
       @model.Nonsense = nonsense
-      @model.Nonsense.should == nonsense
+      expect(@model.Nonsense).to eq(nonsense)
     end
 
     it "should return a boolean for a predicate for an existing attribute" do
-      @model.Name?.should satisfy { |p| [true, false].include?(p) }
+      expect(@model.Name?).to satisfy { |p| [true, false].include?(p) }
     end
 
     it "should return a boolean for whether or not a model is persisted through the api" do
-      @model.persisted?.should satisfy { |p| [true, false].include?(p) }
+      expect(@model.persisted?).to satisfy { |p| [true, false].include?(p) }
     end
 
     it "should raise an Error for a predicate for a non-existant attribute" do
-      lambda { @model.Nonsense? }.should raise_error(NoMethodError)
+      expect { @model.Nonsense? }.to raise_error(NoMethodError)
     end
 
     it "should repond_to existing attributes" do
-      @model.should respond_to(:Name)
+      expect(@model).to respond_to(:Name)
     end
 
     it "should not respond_to non-existant attributes" do
-      @model.should_not respond_to(:Nonsense)
+      expect(@model).not_to respond_to(:Nonsense)
     end
 
     it "should respond_to a setter for an existing attribute" do
-      @model.should respond_to(:Name=)
+      expect(@model).to respond_to(:Name=)
     end
 
     it "should respond_to a setter for a non-existant attribute" do
-      @model.should respond_to(:Nonsense=)
+      expect(@model).to respond_to(:Nonsense=)
     end
 
     it "should respond_to a predicate for an existing attribute" do
-      @model.should respond_to(:Name?)
+      expect(@model).to respond_to(:Name?)
     end
 
     it "should not respond_to a predicate for a non-existant attribute" do
-      @model.should_not respond_to(:Nonsense?)
+      expect(@model).not_to respond_to(:Nonsense?)
     end
 
     it "should respond_to methods inherited from parent classes" do
-      @model.should respond_to(:freeze)
+      expect(@model).to respond_to(:freeze)
     end
 
     it "should respond_to a will_change! method for an existing attribute" do
-      @model.should respond_to(:Name_will_change!)
+      expect(@model).to respond_to(:Name_will_change!)
     end
 
     it "should not respond_to a will_change! method for a non-existant attribute" do
-      @model.should_not respond_to(:Nonsense_will_change!)
+      expect(@model).not_to respond_to(:Nonsense_will_change!)
     end
 
   end
@@ -161,7 +161,7 @@ describe Base, "Base model" do
   describe "to_partial_path" do
     it "should return the partial path" do
       model = MyExampleModel.new()
-      model.to_partial_path.should eq("my_example_models/my_example_model")
+      expect(model.to_partial_path).to eq("my_example_models/my_example_model")
     end
   end