spark_api 1.4.34 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d372159752425b341adabf6fe1bf0361d28e4c1674f09f553b9e911f6294ac24
-  data.tar.gz: cad48a5f4871cb19982be6ba6fd01163957aaf4b552156066e7ed5ebe5581538
+  metadata.gz: 17eaaa74af21a3a858941c286e4731ae9d67d1b315f06f5a3409d78d7d4fa89e
+  data.tar.gz: 51373eaa638eefed5245d88d78cc0e1374d75cdfe385c3c358d4d40348059514
 SHA512:
-  metadata.gz: ea1807cfe81a706d50eb70a59a9e831720d69c46318a414dbf1e2c0bc0e75d31f289d6686a21644224efde694993bccff0d0659d0ac8bd873754c6ccf1802963
-  data.tar.gz: 8a6a226f3883d1f2bc9cb60bdaddf328e2e027f7d26452c0a60299ddd2ac99045cb19d8b1e55c00a35b15d418361d28f2aecadd750508ab68612f3c0e435fb73
+  metadata.gz: 7d81cd63e089a1182557cdeb95ab1e52d526904879294f66e22026c68d3dd4dd5ec8408763fd9d62ac72a9fcf23964ee9eec3d5e6e104a214e33c5a46ece21f7
+  data.tar.gz: c44265855abe3384dea240410e96230b68fca9f9ac3cef702feb1ff0e05d026d571833591d5fa4865c21f04dc9f48d7f2987ffc9895088ac5c4431d73fa9b3c0

data/README.md

@@ -1,6 +1,6 @@
 Spark API
 =====================
-[![Build Status](https://travis-ci.org/sparkapi/spark_api.png?branch=master)](http://travis-ci.org/sparkapi/spark_api) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/sparkapi/spark_api)
+![CI](https://github.com/sparkapi/spark_api/workflows/CI/badge.svg) ![Code Climate](https://codeclimate.com/badge.png)
 
 A Ruby wrapper for the Spark REST API. Loosely based on ActiveResource to provide models to interact with remote services.
 

data/VERSION

@@ -1 +1 @@
-1.4.34
+1.5.0

data/lib/spark_api/authentication/api_auth.rb

@@ -62,7 +62,7 @@ module SparkApi
       
       # Perform an HTTP request (no data)
       def request(method, path, body, options)
-        escaped_path = URI.escape(path)
+        escaped_path = Addressable::URI.escape(path)
         request_opts = {
           :AuthToken => @session.auth_token
         }

data/lib/spark_api/authentication/oauth2.rb

@@ -40,7 +40,7 @@ module SparkApi
       
       # Perform an HTTP request (no data)
       def request(method, path, body, options={})
-        escaped_path = URI.escape(path)
+        escaped_path = Addressable::URI.escape(path)
         connection = @client.connection(true)  # SSL Only!
         connection.headers.merge!(self.auth_header)
 

data/lib/spark_api/authentication/oauth2_impl/grant_type_base.rb

@@ -45,7 +45,7 @@ module SparkApi
           response.expires_in = provider.session_timeout if response.expires_in.nil?
           SparkApi.logger.debug { "[oauth2] New session created #{response}" }
           response
-        rescue Faraday::Error::ConnectionFailed => e
+        rescue Faraday::ConnectionFailed => e
           if @client.ssl_verify && e.message =~ /certificate verify failed/
             SparkApi.logger.error { SparkApi::Errors.ssl_verification_error }
           end

data/lib/spark_api/client.rb

@@ -2,7 +2,7 @@ module SparkApi
   # =API Client
   # Main class to setup and run requests on the API.  A default client is accessible globally as 
   # SparkApi::client if the global configuration has been set as well.  Otherwise, this class may 
-  # be instanciated separately with the configuration information.
+  # be instantiated separately with the configuration information.
   class Client
     include Connection
     include Authentication
@@ -21,7 +21,7 @@ module SparkApi
       Configuration::VALID_OPTION_KEYS.each do |key|
         send("#{key}=", options[key])
       end
-      # Instanciate the authenication class passed in.
+      # Instantiate the authentication class passed in.
       @authenticator = authentication_mode.send("new", self)
     end
     

data/lib/spark_api/request.rb

@@ -99,7 +99,7 @@ module SparkApi
       else
         return response.body
       end
-    rescue Faraday::Error::ConnectionFailed => e
+    rescue Faraday::ConnectionFailed => e
       if self.ssl_verify && e.message =~ /certificate verify failed/
         SparkApi.logger.error { SparkApi::Errors.ssl_verification_error }
       end

data/spec/spec_helper.rb

@@ -11,7 +11,6 @@ end
 
 require "rubygems"
 require "rspec"
-require 'rspec/autorun'
 require 'webmock/rspec'
 require "json"
 require 'multi_json'
@@ -22,6 +21,13 @@ require path + '/spark_api'
 
 require 'spark_api'
 
+if ENV['COVERAGE'] == "on"
+  require 'simplecov'
+  require 'simplecov-rcov'
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  SimpleCov.start { add_filter %w(/vendor /spec /test) }
+end
+
 FileUtils.mkdir 'log' unless File.exists? 'log'
 
 module SparkApi
@@ -48,17 +54,16 @@ end
 Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
 
 RSpec.configure do |config|
-  
+
   config.include WebMock::API
   config.include StubApiRequests
 
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.alias_example_to :on_get_it, :method => 'GET'
   config.alias_example_to :on_put_it, :method => 'PUT'
   config.alias_example_to :on_post_it, :method => 'POST'
   config.alias_example_to :on_delete_it, :method => 'DELETE'
   config.before(:all) { reset_config }
-  config.color_enabled = true
+  config.color = true
 end
 
 def jruby? 

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

@@ -4,15 +4,14 @@ describe SparkApi::Authentication::ApiAuth  do
   subject {SparkApi::Authentication::ApiAuth.new(nil) }
   describe "build_param_hash" do
     it "should return a blank string when passed nil" do
-      subject.build_param_string(nil).should be_empty
+      expect(subject.build_param_string(nil)).to be_empty
     end
     it "should return a correct param string for one item" do
-      subject.build_param_string({:foo => "bar"}).should match("foobar")
+      expect(subject.build_param_string({:foo => "bar"})).to match("foobar")
     end
     it "should alphabatize the param names by key first, then by value" do
-      subject.build_param_string({:zoo => "zar", :ooo => "car"}).should match("ooocarzoozar")
-      subject.build_param_string({:Akey => "aValue", :aNotherkey => "AnotherValue"}).should 
-           match "AkeyaValueaNotherkeyAnotherValue"
+      expect(subject.build_param_string({:zoo => "zar", :ooo => "car"})).to match("ooocarzoozar")
+      expect(subject.build_param_string({:Akey => "aValue", :aNotherkey => "AnotherValue"})).to match("AkeyaValueaNotherkeyAnotherValue")
     end
   end
   
@@ -33,7 +32,7 @@ describe SparkApi::Authentication::ApiAuth  do
       stub_request(:post, "https://api.sparkapi.com/#{SparkApi.version}/session").
                   with(:query => {:ApiKey => "my_key", :ApiSig => "c731cf2455fbc7a4ef937b2301108d7a"}).
                   to_return(:body => fixture("authentication_failure.json"), :status=>401)
-      expect {subject.authenticate()}.to raise_error(SparkApi::ClientError){ |e| e.status.should == 401 }
+      expect {subject.authenticate()}.to raise_error(SparkApi::ClientError){ |e| expect(e.status).to eq(401) }
     end
   end
 
@@ -41,16 +40,16 @@ describe SparkApi::Authentication::ApiAuth  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
 
@@ -61,14 +60,14 @@ describe SparkApi::Authentication::ApiAuth  do
     it "should logout when there is an active session" do
       logged_out = false
       subject.session = session
-      client.stub(:delete).with("/session/1234") { logged_out = true }
+      allow(client).to receive(:delete).with("/session/1234") { logged_out = true }
       subject.logout
-      subject.session.should eq(nil)
-      logged_out.should eq(true)
+      expect(subject.session).to eq(nil)
+      expect(logged_out).to eq(true)
     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
   
@@ -98,7 +97,7 @@ describe SparkApi::Authentication::ApiAuth  do
           :AuthToken => "1234"}.merge(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
       stub_auth_request
@@ -118,14 +117,14 @@ describe SparkApi::Authentication::ApiAuth  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
   end
   
   describe "sign" do
     it "should sign the auth parameters correctly" do
       sign_token = "my_secretApiKeymy_key"
-      subject.sign(sign_token).should eq("c731cf2455fbc7a4ef937b2301108d7a")
+      expect(subject.sign(sign_token)).to eq("c731cf2455fbc7a4ef937b2301108d7a")
     end
   end
   
@@ -134,7 +133,7 @@ describe SparkApi::Authentication::ApiAuth  do
     subject {SparkApi::Authentication::ApiAuth.new(client) }
     it "should fully sign the token" do
       parms = {:AuthToken => "1234", :ApiUser => "CoolAsIce"}
-      subject.sign_token("/test", parms).should eq("7bbe3384a8b64368357f8551cab271e3")
+      expect(subject.sign_token("/test", parms)).to eq("7bbe3384a8b64368357f8551cab271e3")
     end
   end
   
@@ -160,8 +159,8 @@ describe SparkApi::Authentication::ApiAuth  do
           to_return(:body => fixture('listings/with_documents.json'))
       l = Listing.find('1234', :_expand => "Documents")
       
-      count.should eq(2)
-      SparkApi.client.session.expired?.should eq(false)
+      expect(count).to eq(2)
+      expect(SparkApi.client.session.expired?).to eq(false)
     end
   end
   

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,7 @@ 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
   end
   
@@ -106,7 +106,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 +142,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 +164,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 +186,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 +215,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 +240,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 +260,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 +286,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 +299,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