spark_api 1.4.34 → 1.5.3

data/spec/unit/spark_api/authentication/base_auth_spec.rb

@@ -3,8 +3,8 @@ require './spec/spec_helper'
 describe SparkApi::Authentication::BaseAuth  do
   subject {SparkApi::Authentication::BaseAuth.new(nil) }
   it "should raise an error" do
-    expect {subject.authenticate()}.to raise_error(){ |e| e.message.should == "Implement me!"}
-    expect {subject.logout()}.to raise_error(){ |e| e.message.should == "Implement me!"}
-    expect {subject.request(nil, nil, nil, nil)}.to raise_error(){ |e| e.message.should == "Implement me!"}
+    expect {subject.authenticate()}.to raise_error(){ |e| expect(e.message).to eq("Implement me!")}
+    expect {subject.logout()}.to raise_error(){ |e| expect(e.message).to eq("Implement me!")}
+    expect {subject.request(nil, nil, nil, nil)}.to raise_error(){ |e| expect(e.message).to eq("Implement me!")}
   end
 end

data/spec/unit/spark_api/authentication/oauth2_impl/faraday_middleware_spec.rb

@@ -10,7 +10,7 @@ describe SparkApi::Authentication::OAuth2Impl::SparkbarFaradayMiddleware do
       :status => 201
     }
     subject.on_complete env
-    env[:body]["token"].should eq("sp4rkb4rt0k3n")
+    expect(env[:body]["token"]).to eq("sp4rkb4rt0k3n")
   end
   
   it "should raise error on unsuccessful response" do

data/spec/unit/spark_api/authentication/oauth2_impl/grant_type_base_spec.rb

@@ -4,6 +4,6 @@ describe SparkApi::Authentication::OAuth2Impl::GrantTypeBase do
   subject { SparkApi::Authentication::OAuth2Impl::GrantTypeBase }
   # Make sure the client boostraps the right plugin based on configuration.
   it "create should " do
-    expect {subject.create(nil, InvalidAuth2Provider.new())}.to  raise_error(SparkApi::ClientError){ |e| e.message.should == "Unsupported grant type [not_a_real_type]" }
+    expect {subject.create(nil, InvalidAuth2Provider.new())}.to  raise_error(SparkApi::ClientError){ |e| expect(e.message).to eq("Unsupported grant type [not_a_real_type]") }
   end
 end

data/spec/unit/spark_api/authentication/oauth2_impl/single_session_provider_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe SparkApi::Authentication::SingleSessionProvider do
   subject { SparkApi::Authentication::SingleSessionProvider.new({ :access_token => "the_token" }) }
   it "should initialize a new session with access_token" do
-    subject.load_session.should respond_to(:access_token)
-    subject.load_session.access_token.should eq("the_token")
+    expect(subject.load_session).to respond_to(:access_token)
+    expect(subject.load_session.access_token).to eq("the_token")
   end
 end

data/spec/unit/spark_api/authentication/oauth2_spec.rb

@@ -11,7 +11,7 @@ describe SparkApi::Authentication::OAuth2  do
   # Make sure the client boostraps the right plugin based on configuration.
   describe "plugin" do
     it "should load the oauth2 authenticator" do
-      client.authenticator.class.should eq(SparkApi::Authentication::OAuth2)
+      expect(client.authenticator.class).to eq(SparkApi::Authentication::OAuth2)
     end
   end
   describe "authenticate" do
@@ -21,8 +21,8 @@ describe SparkApi::Authentication::OAuth2  do
           '{"client_id":"example-id","client_secret":"example-password","code":"my_code","grant_type":"authorization_code","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback"}' 
         ).
         to_return(:body => fixture("oauth2/access.json"), :status=>200)
-      subject.authenticate.access_token.should eq("04u7h-4cc355-70k3n")
-      subject.authenticate.expires_in.should eq(57600)
+      expect(subject.authenticate.access_token).to eq("04u7h-4cc355-70k3n")
+      expect(subject.authenticate.expires_in).to eq(57600)
     end
     
     it "should raise an error when api credentials are invalid" do
@@ -31,7 +31,7 @@ describe SparkApi::Authentication::OAuth2  do
           '{"client_id":"example-id","client_secret":"example-password","code":"my_code","grant_type":"authorization_code","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback"}'
         ).
         to_return(:body => fixture("oauth2/error.json"), :status=>400)
-      expect {subject.authenticate()}.to raise_error(SparkApi::ClientError){ |e| e.status.should == 400 }
+      expect {subject.authenticate()}.to raise_error(SparkApi::ClientError){ |e| expect(e.status).to eq(400) }
     end
     
   end
@@ -40,16 +40,16 @@ describe SparkApi::Authentication::OAuth2  do
     let(:session) { Object.new }
     it "should return true when session is active" do
       subject.session = session
-      session.stub(:expired?) { false }
-      subject.authenticated?.should eq(true)
+      allow(session).to receive(:expired?) { false }
+      expect(subject.authenticated?).to eq(true)
     end
     it "should return false when session is expired" do
       subject.session = session
-      session.stub(:expired?) { true }
-      subject.authenticated?.should eq(false)
+      allow(session).to receive(:expired?) { true }
+      expect(subject.authenticated?).to eq(false)
     end
     it "should return false when session is uninitialized" do
-      subject.authenticated?.should eq(false)
+      expect(subject.authenticated?).to eq(false)
     end
   end
 
@@ -58,11 +58,11 @@ describe SparkApi::Authentication::OAuth2  do
     it "should logout when there is an active session" do
       subject.session = session
       subject.logout
-      subject.session.should eq(nil)
+      expect(subject.session).to eq(nil)
     end
     it "should skip logging out when there is no active session information" do 
-      client.stub(:delete) { raise "Should not be called" }
-      subject.logout.should eq(nil)
+      allow(client).to receive(:delete) { raise "Should not be called" }
+      expect(subject.logout).to eq(nil)
     end
   end
   
@@ -79,7 +79,7 @@ describe SparkApi::Authentication::OAuth2  do
         with(:query => args).
         to_return(:body => fixture("listings/no_subresources.json"))
       subject.session = session
-      subject.request(:get, "/#{SparkApi.version}/listings", nil, args).status.should eq(200)
+      expect(subject.request(:get, "/#{SparkApi.version}/listings", nil, args).status).to eq(200)
     end
     it "should handle a post request" do
       subject.session = session
@@ -95,7 +95,25 @@ describe SparkApi::Authentication::OAuth2  do
             }]}
           }', 
           :status=>201)
-      subject.request(:post, "/#{SparkApi.version}/contacts", contact, args).status.should eq(201)
+      expect(subject.request(:post, "/#{SparkApi.version}/contacts", contact, args).status).to eq(201)
+    end
+    it "should incorporate any override_headers it is given while excluding them from the resulting request" do
+      subject.session = session
+      args = {
+        override_headers: {
+          "Some-Header" => "Some-Value"
+        },
+        some_other_param: "some_other_value"
+      }
+      body = "somerequestbodytext"
+      stub_request(:post, "https://api.sparkapi.com/#{SparkApi.version}/someservice?some_other_param=some_other_value").
+        with(body: body, headers: args[:override_headers]).
+        to_return(body: '{"D": {
+          "Success": true,
+          "Results": []
+        }',
+        status: 200)
+        expect(subject.request(:post, "/#{SparkApi.version}/someservice", body, args).status).to eq(200)
     end
   end
   
@@ -106,7 +124,7 @@ describe SparkApi::Authentication::OAuth2  do
         with(:body => "access_token=#{session.access_token}").
         to_return(:body => '{"token":"sp4rkb4rt0k3n"}')
       subject.session = session
-      subject.sparkbar_token.should eq("sp4rkb4rt0k3n")
+      expect(subject.sparkbar_token).to eq("sp4rkb4rt0k3n")
     end
     it "should raise an error on missing sparkbar token" do
       c = stub_request(:post, "https://test.sparkplatform.com/appbar/authorize").
@@ -142,9 +160,9 @@ describe SparkApi::Authentication::OAuth2  do
           to_return(:body => fixture('errors/expired.json'), :status => 401).times(1).then.
           to_return(:body => fixture('listings/with_documents.json'))
         client.get("/listings/1234")
-        count.should eq(1)
-        refresh_count.should eq(1)
-        client.session.expired?.should eq(false)
+        expect(count).to eq(1)
+        expect(refresh_count).to eq(1)
+        expect(client.session.expired?).to eq(false)
       end
     end
     context "and an invalid refresh token" do
@@ -164,8 +182,8 @@ describe SparkApi::Authentication::OAuth2  do
           to_return(:body => fixture('listings/with_documents.json'))
               
         client.get("/listings/1234")
-        count.should eq(2)
-        client.session.expired?.should eq(false)
+        expect(count).to eq(2)
+        expect(client.session.expired?).to eq(false)
       end
     end
   end
@@ -186,16 +204,16 @@ describe SparkApi::Authentication::OpenIdOAuth2Hybrid do
   end
   describe "plugin" do
     it "should load the hybrid authenticator" do
-      client.authenticator.class.should eq(SparkApi::Authentication::OpenIdOAuth2Hybrid)
+      expect(client.authenticator.class).to eq(SparkApi::Authentication::OpenIdOAuth2Hybrid)
     end
   end
 
   describe "#authorization_url" do
     it "should include combined flow parameter" do
-      client.authenticator.authorization_url.should match("openid.spark.combined_flow=true")
+      expect(client.authenticator.authorization_url).to match("openid.spark.combined_flow=true")
     end
     it "should allow custom parameters" do
-      client.authenticator.authorization_url({"joshua" => "iscool"}).should match("joshua=iscool")
+      expect(client.authenticator.authorization_url({"joshua" => "iscool"})).to match("joshua=iscool")
     end
   end
 end
@@ -215,24 +233,24 @@ describe SparkApi::Authentication::OpenId do
 
   describe "plugin" do
     it "should not include combined flow parameter" do
-      client.authenticator.authorization_url.should_not match("openid.spark.combined_flow=true")
+      expect(client.authenticator.authorization_url).not_to match("openid.spark.combined_flow=true")
     end
     it "should load the oauth2 authenticator" do
-      client.authenticator.class.should eq(SparkApi::Authentication::OpenId)
+      expect(client.authenticator.class).to eq(SparkApi::Authentication::OpenId)
     end
   end
 
   describe "#authorization_url" do
     it "should allow custom parameters" do
-      client.authenticator.authorization_url({"joshua" => "iscool"}).should match("joshua=iscool")
+      expect(client.authenticator.authorization_url({"joshua" => "iscool"})).to match("joshua=iscool")
     end
   end
 
   describe "forbidden methods" do
     it "should not allow authentication" do
-      lambda {
+      expect {
         client.authenticate
-      }.should raise_error(RuntimeError)
+      }.to raise_error(RuntimeError)
     end
   end
 end
@@ -240,12 +258,12 @@ end
 describe SparkApi::Authentication::BaseOAuth2Provider  do
   context "session_timeout" do
     it "should provide a default" do
-      subject.session_timeout.should eq(86400)
+      expect(subject.session_timeout).to eq(86400)
     end
     describe TestOAuth2Provider do
       subject { TestOAuth2Provider.new }
       it "should be able to override the session timeout" do
-        subject.session_timeout.should eq(57600)
+        expect(subject.session_timeout).to eq(57600)
       end
     end
   end
@@ -260,18 +278,18 @@ describe "password authentication" do
       with(:body =>
         '{"client_id":"example-id","client_secret":"example-secret","grant_type":"password","password":"example-password","username":"example-user"}' 
       ).to_return(:body => fixture("oauth2/access.json"), :status=>200)
-    subject.authenticate.access_token.should eq("04u7h-4cc355-70k3n")
-    subject.authenticate.expires_in.should eq(60)
+    expect(subject.authenticate.access_token).to eq("04u7h-4cc355-70k3n")
+    expect(subject.authenticate.expires_in).to eq(60)
   end
 end
 describe SparkApi::Authentication::OAuth2Impl  do
   it "should load a provider" do
     example = "SparkApi::Authentication::OAuth2Impl::CLIProvider"
-    SparkApi::Authentication::OAuth2Impl.load_provider(example,{}).class.to_s.should eq(example)
+    expect(SparkApi::Authentication::OAuth2Impl.load_provider(example,{}).class.to_s).to eq(example)
     prefix = "::#{example}"
-    SparkApi::Authentication::OAuth2Impl.load_provider(prefix,{}).class.to_s.should eq(example)
+    expect(SparkApi::Authentication::OAuth2Impl.load_provider(prefix,{}).class.to_s).to eq(example)
     bad_example = "Derp::Derp::Derp::DerpProvider"
-    expect{SparkApi::Authentication::OAuth2Impl.load_provider(bad_example,{}).class.to_s.should eq(bad_example)}.to raise_error(ArgumentError)
+    expect{expect(SparkApi::Authentication::OAuth2Impl.load_provider(bad_example,{}).class.to_s).to eq(bad_example)}.to raise_error(ArgumentError)
   end
 
 end
@@ -286,8 +304,8 @@ describe SparkApi::Authentication::OAuthSession do
       "start_time" => "2012-01-01T00:00:00+00:00"
     }
     session = SparkApi::Authentication::OAuthSession.new(args)
-    session.start_time.should eq(DateTime.parse(args["start_time"]))
-    JSON.parse(session.to_json).should eq(args)
+    expect(session.start_time).to eq(DateTime.parse(args["start_time"]))
+    expect(JSON.parse(session.to_json)).to eq(args)
   end
 
   it "should accept symbolized parameters" do
@@ -299,12 +317,12 @@ describe SparkApi::Authentication::OAuthSession do
       :start_time => "2012-01-01T00:00:00+00:00"
     }
     session = SparkApi::Authentication::OAuthSession.new(args)
-    session.start_time.should eq(DateTime.parse(args[:start_time]))
-    JSON.parse(session.to_json).should eq(JSON.parse(args.to_json))
+    expect(session.start_time).to eq(DateTime.parse(args[:start_time]))
+    expect(JSON.parse(session.to_json)).to eq(JSON.parse(args.to_json))
   end
 
   it "should not expire if expires_in is nil" do
     session = SparkApi::Authentication::OAuthSession.new
-    session.expired?.should eq(false)
+    expect(session.expired?).to eq(false)
   end
 end

data/spec/unit/spark_api/authentication_spec.rb

@@ -13,7 +13,7 @@ describe SparkApi::Authentication do
     client = SparkApi.client
     stub_auth_request
     session = client.get "/session/c401736bf3d3f754f07c04e460e09573"
-    session[0]["AuthToken"].should eq("c401736bf3d3f754f07c04e460e09573")
+    expect(session[0]["AuthToken"]).to eq("c401736bf3d3f754f07c04e460e09573")
   end
   it "should delete a session" do
     stub_auth_request
@@ -26,7 +26,7 @@ describe SparkApi::Authentication do
       to_return(:body => fixture("success.json"))
     client = SparkApi.client
     client.logout
-    client.session.should eq(nil)
+    expect(client.session).to eq(nil)
   end
 
 end

data/spec/unit/spark_api/configuration/yaml_spec.rb

@@ -4,70 +4,70 @@ describe SparkApi::Configuration::YamlConfig, "Yaml Config"  do
   describe "api auth" do
     let(:api_file){ "spec/config/spark_api/test_key.yml" }
     it "should load a configured api key for development" do
-      subject.stub(:env){ {} }
-      subject.api_env.should eq("development")
+      allow(subject).to receive(:env){ {} }
+      expect(subject.api_env).to eq("development")
       subject.load_file(api_file)
-      subject.oauth2?.should eq(false)
-      subject.ssl_verify?.should eq(false)
-      subject.api_key.should eq("demo_key")
-      subject.api_secret.should eq("t3sts3cr3t")
-      subject.endpoint.should eq("https://developers.sparkapi.com")
-      subject.name.should eq("test_key")
-      subject.client_keys.keys.should =~ [:api_key, :api_secret, :endpoint, :ssl_verify]
-      subject.oauth2_keys.keys.should eq([])
+      expect(subject.oauth2?).to eq(false)
+      expect(subject.ssl_verify?).to eq(false)
+      expect(subject.api_key).to eq("demo_key")
+      expect(subject.api_secret).to eq("t3sts3cr3t")
+      expect(subject.endpoint).to eq("https://developers.sparkapi.com")
+      expect(subject.name).to eq("test_key")
+      expect(subject.client_keys.keys).to match_array([:api_key, :api_secret, :endpoint, :ssl_verify])
+      expect(subject.oauth2_keys.keys).to eq([])
     end
     it "should load a configured api key for production" do
-      subject.stub(:env){ {"SPARK_API_ENV" => "production"} }
-      subject.api_env.should eq("production")
+      allow(subject).to receive(:env){ {"SPARK_API_ENV" => "production"} }
+      expect(subject.api_env).to eq("production")
       subject.load_file(api_file)
-      subject.oauth2?.should eq(false)
-      subject.api_key.should eq("prod_demo_key")
-      subject.api_secret.should eq("prod_t3sts3cr3t")
-      subject.endpoint.should eq("https://api.sparkapi.com")
+      expect(subject.oauth2?).to eq(false)
+      expect(subject.api_key).to eq("prod_demo_key")
+      expect(subject.api_secret).to eq("prod_t3sts3cr3t")
+      expect(subject.endpoint).to eq("https://api.sparkapi.com")
     end
     it "should raise an error for a bad configuration" do
-      subject.stub(:env){ {} }
+      allow(subject).to receive(:env){ {} }
       expect { subject.load_file("spec/config/spark_api/some_random_key.yml")}.to raise_error
-      subject.stub(:env){ {"RAILS_ENV" => "fake_env"} }
+      allow(subject).to receive(:env){ {"RAILS_ENV" => "fake_env"} }
       expect { subject.load_file(api_file)}.to raise_error
     end
   end
   describe "oauth2" do
     let(:oauth2_file){ "spec/config/spark_api/test_oauth.yml" }
     it "should load a configured api key for development" do
-      subject.stub(:env){ {} }
-      subject.api_env.should eq("development")
+      allow(subject).to receive(:env){ {} }
+      expect(subject.api_env).to eq("development")
       subject.load_file(oauth2_file)
-      subject.oauth2?.should eq(true)
-      subject.authorization_uri.should eq("https://developers.sparkplatform.com/oauth2")
-      subject.access_uri.should eq("https://developers.sparkapi.com/v1/oauth2/grant")
-      subject.redirect_uri.should eq("http://localhost/oauth2/callback")
-      subject.client_id.should eq("developmentid124nj4qu3pua")
-      subject.client_secret.should eq("developmentsecret4orkp29f")
-      subject.endpoint.should eq("https://developers.sparkapi.com")
-      subject.oauth2_provider.should eq("SparkApi::TestOAuth2Provider")
-      subject.name.should eq("test_oauth")
-      subject.client_keys.keys.should =~ [:endpoint, :oauth2_provider]
-      subject.oauth2_keys.keys.should =~ [:authorization_uri, :client_id, :access_uri, :client_secret, :redirect_uri, :sparkbar_uri]
+      expect(subject.oauth2?).to eq(true)
+      expect(subject.authorization_uri).to eq("https://developers.sparkplatform.com/oauth2")
+      expect(subject.access_uri).to eq("https://developers.sparkapi.com/v1/oauth2/grant")
+      expect(subject.redirect_uri).to eq("http://localhost/oauth2/callback")
+      expect(subject.client_id).to eq("developmentid124nj4qu3pua")
+      expect(subject.client_secret).to eq("developmentsecret4orkp29f")
+      expect(subject.endpoint).to eq("https://developers.sparkapi.com")
+      expect(subject.oauth2_provider).to eq("SparkApi::TestOAuth2Provider")
+      expect(subject.name).to eq("test_oauth")
+      expect(subject.client_keys.keys).to match_array([:endpoint, :oauth2_provider])
+      expect(subject.oauth2_keys.keys).to match_array([:authorization_uri, :client_id, :access_uri, :client_secret, :redirect_uri, :sparkbar_uri])
     end
     it "should load a configured api key for production" do
-      subject.stub(:env){ {"SPARK_API_ENV" => "production"} }
-      subject.api_env.should eq("production")
+      allow(subject).to receive(:env){ {"SPARK_API_ENV" => "production"} }
+      expect(subject.api_env).to eq("production")
       subject.load_file(oauth2_file)
-      subject.oauth2?.should eq(true)
-      subject.authorization_uri.should eq("https://sparkplatform.com/oauth2")
-      subject.access_uri.should eq("https://api.sparkapi.com/v1/oauth2/grant")
-      subject.redirect_uri.should eq("http://localhost/oauth2/callback")
-      subject.client_id.should eq("production1id124nj4qu3pua")
-      subject.client_secret.should eq("productionsecret4orkp29fv")
-      subject.endpoint.should eq("https://api.sparkapi.com")
-      subject.oauth2_provider.should eq(subject.class::DEFAULT_OAUTH2_PROVIDER)
-      subject.name.should eq("test_oauth")
+      expect(subject.oauth2?).to eq(true)
+      expect(subject.authorization_uri).to eq("https://sparkplatform.com/oauth2")
+      expect(subject.access_uri).to eq("https://api.sparkapi.com/v1/oauth2/grant")
+      expect(subject.redirect_uri).to eq("http://localhost/oauth2/callback")
+      expect(subject.client_id).to eq("production1id124nj4qu3pua")
+      expect(subject.client_secret).to eq("productionsecret4orkp29fv")
+      expect(subject.endpoint).to eq("https://api.sparkapi.com")
+      expect(subject.oauth2_provider).to eq(subject.class::DEFAULT_OAUTH2_PROVIDER)
+      expect(subject.name).to eq("test_oauth")
     end
     
     it "should list available keys" do
-      SparkApi::Configuration::YamlConfig.stub(:config_path) { "spec/config/spark_api" }
-      subject.class.config_keys.should =~ ["test_key", "test_oauth", "test_single_session_oauth"]
+      allow(SparkApi::Configuration::YamlConfig).to receive(:config_path) { "spec/config/spark_api" }
+      expect(subject.class.config_keys).to match_array(["test_key", "test_oauth", "test_single_session_oauth"])
     end
   end
 end

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