koala 1.8.0 → 1.9.0rc1

data/spec/cases/koala_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe Koala do
   it "has an http_service accessor" do
-    Koala.should respond_to(:http_service)
-    Koala.should respond_to(:http_service=)
+    expect(Koala).to respond_to(:http_service)
+    expect(Koala).to respond_to(:http_service=)
   end
 
   describe "constants" do
     it "has a version" do
-      Koala.const_defined?("VERSION").should be_true
+      expect(Koala.const_defined?("VERSION")).to be_truthy
     end
   end
 
@@ -23,21 +23,21 @@ describe Koala do
 
     it "invokes deprecated_interface if present" do
       mock_service = double("http service")
-      mock_service.should_receive(:deprecated_interface)
+      expect(mock_service).to receive(:deprecated_interface)
       Koala.http_service = mock_service
     end
 
     it "does not set the service if it's deprecated" do
       mock_service = double("http service")
-      mock_service.stub(:deprecated_interface)
+      allow(mock_service).to receive(:deprecated_interface)
       Koala.http_service = mock_service
-      Koala.http_service.should == @service
+      expect(Koala.http_service).to eq(@service)
     end
 
     it "sets the service if it's not deprecated" do
       mock_service = double("http service")
       Koala.http_service = mock_service
-      Koala.http_service.should == mock_service
+      expect(Koala.http_service).to eq(mock_service)
     end
   end
 
@@ -48,7 +48,7 @@ describe Koala do
       verb = "get"
       options = {:c => :d}
 
-      Koala.http_service.should_receive(:make_request).with(path, args, verb, options)
+      expect(Koala.http_service).to receive(:make_request).with(path, args, verb, options)
       Koala.make_request(path, args, verb, options)
     end
   end
@@ -77,7 +77,7 @@ describe Koala do
       Koala.configure do |config|
         config.graph_server = "some-new.graph_server.com"
       end
-      Koala.config.graph_server.should == "some-new.graph_server.com"
+      expect(Koala.config.graph_server).to eq("some-new.graph_server.com")
     end
   end
 

data/spec/cases/legacy_spec.rb

@@ -5,27 +5,27 @@ describe "legacy APIs" do
 
   it "deprecates the REST API" do
     api = Koala::Facebook::API.new
-    api.stub(:api)
-    Koala::Utils.should_receive(:deprecate)
+    allow(api).to receive(:api)
+    expect(Koala::Utils).to receive(:deprecate)
     api.rest_call("stuff")
   end
 
   describe Koala::Facebook::GraphAPI do
     describe "class consolidation" do
       before :each do
-        Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
+        allow(Koala::Utils).to receive(:deprecate) # avoid actual messages to stderr
       end
 
       it "still allows you to instantiate a GraphAndRestAPI object" do
-        api = Koala::Facebook::GraphAPI.new("token").should be_a(Koala::Facebook::GraphAPI)
+        api = expect(Koala::Facebook::GraphAPI.new("token")).to be_a(Koala::Facebook::GraphAPI)
       end
 
       it "ultimately creates an API object" do
-        api = Koala::Facebook::GraphAPI.new("token").should be_a(Koala::Facebook::API)
+        api = expect(Koala::Facebook::GraphAPI.new("token")).to be_a(Koala::Facebook::API)
       end
 
       it "fires a depreciation warning" do
-        Koala::Utils.should_receive(:deprecate)
+        expect(Koala::Utils).to receive(:deprecate)
         api = Koala::Facebook::GraphAPI.new("token")
       end
     end
@@ -34,19 +34,19 @@ describe "legacy APIs" do
   describe Koala::Facebook::RestAPI do
     describe "class consolidation" do
       before :each do
-        Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
+        allow(Koala::Utils).to receive(:deprecate) # avoid actual messages to stderr
       end
 
       it "still allows you to instantiate a GraphAndRestAPI object" do
-        api = Koala::Facebook::RestAPI.new("token").should be_a(Koala::Facebook::RestAPI)
+        api = expect(Koala::Facebook::RestAPI.new("token")).to be_a(Koala::Facebook::RestAPI)
       end
 
       it "ultimately creates an API object" do
-        api = Koala::Facebook::RestAPI.new("token").should be_a(Koala::Facebook::API)
+        api = expect(Koala::Facebook::RestAPI.new("token")).to be_a(Koala::Facebook::API)
       end
 
       it "fires a depreciation warning" do
-        Koala::Utils.should_receive(:deprecate)
+        expect(Koala::Utils).to receive(:deprecate)
         api = Koala::Facebook::RestAPI.new("token")
       end
     end
@@ -55,19 +55,19 @@ describe "legacy APIs" do
   describe Koala::Facebook::GraphAndRestAPI do
     describe "class consolidation" do
       before :each do
-        Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
+        allow(Koala::Utils).to receive(:deprecate) # avoid actual messages to stderr
       end
 
       it "still allows you to instantiate a GraphAndRestAPI object" do
-        api = Koala::Facebook::GraphAndRestAPI.new("token").should be_a(Koala::Facebook::GraphAndRestAPI)
+        api = expect(Koala::Facebook::GraphAndRestAPI.new("token")).to be_a(Koala::Facebook::GraphAndRestAPI)
       end
 
       it "ultimately creates an API object" do
-        api = Koala::Facebook::GraphAndRestAPI.new("token").should be_a(Koala::Facebook::API)
+        api = expect(Koala::Facebook::GraphAndRestAPI.new("token")).to be_a(Koala::Facebook::API)
       end
 
       it "fires a depreciation warning" do
-        Koala::Utils.should_receive(:deprecate)
+        expect(Koala::Utils).to receive(:deprecate)
         api = Koala::Facebook::GraphAndRestAPI.new("token")
       end
     end
@@ -76,40 +76,40 @@ describe "legacy APIs" do
   {:typhoeus => Koala::TyphoeusService, :net_http => Koala::NetHTTPService}.each_pair do |adapter, module_class|
     describe module_class.to_s do
       it "responds to deprecated_interface" do
-        module_class.should respond_to(:deprecated_interface)
+        expect(module_class).to respond_to(:deprecated_interface)
       end
 
       it "issues a deprecation warning" do
-        Koala::Utils.should_receive(:deprecate)
+        expect(Koala::Utils).to receive(:deprecate)
         module_class.deprecated_interface
       end
 
       it "sets the default adapter to #{adapter}" do
         module_class.deprecated_interface
-        Faraday.default_adapter.should == adapter
+        expect(Faraday.default_adapter).to eq(adapter)
       end
     end
   end
 
   describe "moved classes" do
     it "allows you to access Koala::HTTPService::MultipartRequest through the Koala module" do
-      Koala::MultipartRequest.should == Koala::HTTPService::MultipartRequest
+      expect(Koala::MultipartRequest).to eq(Koala::HTTPService::MultipartRequest)
     end
     
     it "allows you to access Koala::Response through the Koala module" do
-      Koala::Response.should == Koala::HTTPService::Response
+      expect(Koala::Response).to eq(Koala::HTTPService::Response)
     end
     
     it "allows you to access Koala::Response through the Koala module" do
-      Koala::UploadableIO.should == Koala::HTTPService::UploadableIO
+      expect(Koala::UploadableIO).to eq(Koala::HTTPService::UploadableIO)
     end
     
     it "allows you to access Koala::Facebook::GraphBatchAPI::BatchOperation through the Koala::Facebook module" do
-      Koala::Facebook::BatchOperation.should == Koala::Facebook::GraphBatchAPI::BatchOperation
+      expect(Koala::Facebook::BatchOperation).to eq(Koala::Facebook::GraphBatchAPI::BatchOperation)
     end 
     
     it "allows you to access Koala::Facebook::API::GraphCollection through the Koala::Facebook module" do
-      Koala::Facebook::GraphCollection.should == Koala::Facebook::API::GraphCollection
+      expect(Koala::Facebook::GraphCollection).to eq(Koala::Facebook::API::GraphCollection)
     end   
   end
 end

data/spec/cases/multipart_request_spec.rb

@@ -2,65 +2,64 @@ require 'spec_helper'
 
 describe Koala::HTTPService::MultipartRequest do
   it "is a subclass of Faraday::Request::Multipart" do
-    Koala::HTTPService::MultipartRequest.superclass.should == Faraday::Request::Multipart
+    expect(Koala::HTTPService::MultipartRequest.superclass).to eq(Faraday::Request::Multipart)
   end
-  
+
   it "defines mime_type as multipart/form-data" do
-    Koala::HTTPService::MultipartRequest.mime_type.should == 'multipart/form-data'
+    expect(Koala::HTTPService::MultipartRequest.mime_type).to eq('multipart/form-data')
   end
-  
+
   describe "#process_request?" do
     before :each do
-      @env = {}
+      @env = Faraday::Env.new
       @multipart = Koala::HTTPService::MultipartRequest.new
-      @multipart.stub(:request_type).and_return("")
+      allow(@multipart).to receive(:request_type).and_return("")
     end
-    
+
     # no way to test the call to super, unfortunately
     it "returns true if env[:body] is a hash with at least one hash in its values" do
       @env[:body] = {:a => {:c => 2}}
-      @multipart.process_request?(@env).should be_true
+      expect(@multipart.process_request?(@env)).to be_truthy
     end
 
     it "returns true if env[:body] is a hash with at least one array in its values" do
       @env[:body] = {:a => [:c, 2]}
-      @multipart.process_request?(@env).should be_true
+      expect(@multipart.process_request?(@env)).to be_truthy
     end
 
     it "returns true if env[:body] is a hash with mixed objects in its values" do
       @env[:body] = {:a => [:c, 2], :b => {:e => :f}}
-      @multipart.process_request?(@env).should be_true
+      expect(@multipart.process_request?(@env)).to be_truthy
     end
 
     it "returns false if env[:body] is a string" do
       @env[:body] = "my body"
-      @multipart.process_request?(@env).should be_false
+      expect(@multipart.process_request?(@env)).to be_falsey
     end
 
     it "returns false if env[:body] is a hash without an array or hash value" do
       @env[:body] = {:a => 3}
-      @multipart.process_request?(@env).should be_false
-    end    
+      expect(@multipart.process_request?(@env)).to be_falsey
+    end
   end
-  
+
   describe "#process_params" do
     before :each do
       @parent = Faraday::Request::Multipart.new
-      @multipart = Koala::HTTPService::MultipartRequest.new 
-      @block = lambda {|k, v| "#{k}=#{v}"}     
+      @multipart = Koala::HTTPService::MultipartRequest.new
+      @block = lambda {|k, v| "#{k}=#{v}"}
     end
-    
+
     it "is identical to the parent for requests without a prefix" do
       hash = {:a => 2, :c => "3"}
-      @multipart.process_params(hash, &@block).should == @parent.process_params(hash, &@block)
+      expect(@multipart.process_params(hash, &@block)).to eq(@parent.process_params(hash, &@block))
     end
-    
+
     it "replaces encodes [ and ] if the request has a prefix" do
       hash = {:a => 2, :c => "3"}
       prefix = "foo"
       # process_params returns an array
-      @multipart.process_params(hash, prefix, &@block).join("&").should == @parent.process_params(hash, prefix, &@block).join("&").gsub(/\[/, "%5B").gsub(/\]/, "%5D")
+      expect(@multipart.process_params(hash, prefix, &@block).join("&")).to eq(@parent.process_params(hash, prefix, &@block).join("&").gsub(/\[/, "%5B").gsub(/\]/, "%5D"))
     end
   end
-  
 end

data/spec/cases/oauth_spec.rb

@@ -28,19 +28,19 @@ describe "Koala::Facebook::OAuth" do
 
   before :each do
     @time = Time.now
-    Time.stub(:now).and_return(@time)
-    @time.stub(:to_i).and_return(1273363199)
+    allow(Time).to receive(:now).and_return(@time)
+    allow(@time).to receive(:to_i).and_return(1273363199)
   end
 
   describe ".new" do
     it "properly initializes" do
-      @oauth.should
+      expect(@oauth).to be_truthy
     end
 
     it "properly sets attributes" do
-      (@oauth.app_id == @app_id &&
+      expect(@oauth.app_id == @app_id &&
         @oauth.app_secret == @secret &&
-        @oauth.oauth_callback_url == @callback_url).should be_true
+        @oauth.oauth_callback_url == @callback_url).to be_truthy
     end
 
     it "properly initializes without a callback_url" do
@@ -49,9 +49,9 @@ describe "Koala::Facebook::OAuth" do
 
     it "properly sets attributes without a callback URL" do
       @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
-      (@oauth.app_id == @app_id &&
+      expect(@oauth.app_id == @app_id &&
         @oauth.app_secret == @secret &&
-        @oauth.oauth_callback_url == nil).should be_true
+        @oauth.oauth_callback_url == nil).to be_truthy
     end
   end
 
@@ -62,71 +62,71 @@ describe "Koala::Facebook::OAuth" do
           # we don't actually want to make requests to Facebook to redeem the code
           @cookie = KoalaTest.oauth_test_data["valid_signed_cookies"]
           @token = "my token"
-          @oauth.stub(:get_access_token_info).and_return("access_token" => @token)
+          allow(@oauth).to receive(:get_access_token_info).and_return("access_token" => @token)
         end
 
         it "parses valid cookies" do
           result = @oauth.get_user_info_from_cookies(@cookie)
-          result.should be_a(Hash)
+          expect(result).to be_a(Hash)
         end
 
         it "returns all the components in the signed request" do
           result = @oauth.get_user_info_from_cookies(@cookie)
           @oauth.parse_signed_request(@cookie.values.first).each_pair do |k, v|
-            result[k].should == v
+            expect(result[k]).to eq(v)
           end
         end
 
         it "makes a request to Facebook to redeem the code if present" do
           code = "foo"
-          @oauth.stub(:parse_signed_request).and_return({"code" => code})
-          @oauth.should_receive(:get_access_token_info).with(code, anything)
+          allow(@oauth).to receive(:parse_signed_request).and_return({"code" => code})
+          expect(@oauth).to receive(:get_access_token_info).with(code, anything)
           @oauth.get_user_info_from_cookies(@cookie)
         end
 
         it "sets the code redemption redirect_uri to ''" do
-          @oauth.should_receive(:get_access_token_info).with(anything, :redirect_uri => '')
+          expect(@oauth).to receive(:get_access_token_info).with(anything, :redirect_uri => '')
           @oauth.get_user_info_from_cookies(@cookie)
         end
 
         context "if the code is missing" do
           it "doesn't make a request to Facebook" do
-            @oauth.stub(:parse_signed_request).and_return({})
-            @oauth.should_receive(:get_access_token_info).never
+            allow(@oauth).to receive(:parse_signed_request).and_return({})
+            expect(@oauth).to receive(:get_access_token_info).never
             @oauth.get_user_info_from_cookies(@cookie)
           end
 
           it "returns nil" do
-            @oauth.stub(:parse_signed_request).and_return({})
-            @oauth.get_user_info_from_cookies(@cookie).should be_nil
+            allow(@oauth).to receive(:parse_signed_request).and_return({})
+            expect(@oauth.get_user_info_from_cookies(@cookie)).to be_nil
           end
 
           it "logs a warning" do
-            @oauth.stub(:parse_signed_request).and_return({})
-            Koala::Utils.logger.should_receive(:warn)
+            allow(@oauth).to receive(:parse_signed_request).and_return({})
+            expect(Koala::Utils.logger).to receive(:warn)
             @oauth.get_user_info_from_cookies(@cookie)
           end
         end
 
         context "if the code is present" do
           it "adds the access_token into the hash" do
-            @oauth.get_user_info_from_cookies(@cookie)["access_token"].should == @token
+            expect(@oauth.get_user_info_from_cookies(@cookie)["access_token"]).to eq(@token)
           end
 
           it "returns nil if the call to FB returns no data" do
-            @oauth.stub(:get_access_token_info).and_return(nil)
-            @oauth.get_user_info_from_cookies(@cookie).should be_nil
+            allow(@oauth).to receive(:get_access_token_info).and_return(nil)
+            expect(@oauth.get_user_info_from_cookies(@cookie)).to be_nil
           end
 
           it "returns nil if the call to FB returns an expired code error" do
-            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
+            allow(@oauth).to receive(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
               '{ "error": { "type": "OAuthException", "message": "Code was invalid or expired. Session has expired at unix time 1324044000. The current unix time is 1324300957." } }'
             ))
-            @oauth.get_user_info_from_cookies(@cookie).should be_nil
+            expect(@oauth.get_user_info_from_cookies(@cookie)).to be_nil
           end
 
           it "raises the error if the call to FB returns a different error" do
-            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
+            allow(@oauth).to receive(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
               '{ "error": { "type": "OtherError", "message": "A Facebook Error" } }'))
             expect { @oauth.get_user_info_from_cookies(@cookie) }.to raise_exception(Koala::Facebook::OAuthTokenRequestError)
           end
@@ -136,46 +136,46 @@ describe "Koala::Facebook::OAuth" do
           # make an invalid string by replacing some values
           bad_cookie_hash = @cookie.inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
           result = @oauth.get_user_info_from_cookies(bad_cookie_hash)
-          result.should be_nil
+          expect(result).to be_nil
         end
       end
 
       context "for unsigned cookies" do
         it "properly parses valid cookies" do
           result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["valid_cookies"])
-          result.should be_a(Hash)
+          expect(result).to be_a(Hash)
         end
 
         it "returns all the cookie components from valid cookie string" do
           cookie_data = KoalaTest.oauth_test_data["valid_cookies"]
           parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
           number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
-          parsing_results.length.should == number_of_components
+          expect(parsing_results.length).to eq(number_of_components)
         end
 
         it "properly parses valid offline access cookies (e.g. no expiration)" do
           result = @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["offline_access_cookies"])
-          result["uid"].should
+          expect(result["uid"]).to be_truthy
         end
 
         it "returns all the cookie components from offline access cookies" do
           cookie_data = KoalaTest.oauth_test_data["offline_access_cookies"]
           parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
           number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
-          parsing_results.length.should == number_of_components
+          expect(parsing_results.length).to eq(number_of_components)
         end
 
         it "doesn't parse expired cookies" do
           new_time = @time.to_i * 2
-          @time.stub(:to_i).and_return(new_time)
-          @oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["valid_cookies"]).should be_nil
+          allow(@time).to receive(:to_i).and_return(new_time)
+          expect(@oauth.get_user_info_from_cookies(KoalaTest.oauth_test_data["valid_cookies"])).to be_nil
         end
 
         it "doesn't parse invalid cookies" do
           # make an invalid string by replacing some values
           bad_cookie_hash = KoalaTest.oauth_test_data["valid_cookies"].inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
           result = @oauth.get_user_info_from_cookies(bad_cookie_hash)
-          result.should be_nil
+          expect(result).to be_nil
         end
       end
     end
@@ -185,28 +185,28 @@ describe "Koala::Facebook::OAuth" do
         before :each do
           # we don't actually want to make requests to Facebook to redeem the code
           @cookie = KoalaTest.oauth_test_data["valid_signed_cookies"]
-          @oauth.stub(:get_access_token_info).and_return("access_token" => "my token")
+          allow(@oauth).to receive(:get_access_token_info).and_return("access_token" => "my token")
         end
 
         it "does not uses get_user_info_from_cookies to parse the cookies" do
-          @oauth.should_not_receive(:get_user_info_from_cookies).with(@cookie)
+          expect(@oauth).not_to receive(:get_user_info_from_cookies).with(@cookie)
           @oauth.get_user_from_cookies(@cookie)
         end
 
         it "uses return the facebook user id string if the cookies are valid" do
           result = @oauth.get_user_from_cookies(@cookie)
-          result.should == "2905623" # the user who generated the original test cookie
+          expect(result).to eq("2905623") # the user who generated the original test cookie
         end
 
         it "returns nil if the cookies are invalid" do
           # make an invalid string by replacing some values
           bad_cookie_hash = @cookie.inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
           result = @oauth.get_user_from_cookies(bad_cookie_hash)
-          result.should be_nil
+          expect(result).to be_nil
         end
 
         it "is deprecated" do
-          Koala::Utils.should_receive(:deprecate)
+          expect(Koala::Utils).to receive(:deprecate)
           @oauth.get_user_from_cookies({})
         end
       end
@@ -218,20 +218,20 @@ describe "Koala::Facebook::OAuth" do
         end
 
         it "uses get_user_info_from_cookies to parse the cookies" do
-          @oauth.should_receive(:get_user_info_from_cookies).with(@cookie).and_return({})
+          expect(@oauth).to receive(:get_user_info_from_cookies).with(@cookie).and_return({})
           @oauth.get_user_from_cookies(@cookie)
         end
 
         it "uses return a string if the cookies are valid" do
           result = @oauth.get_user_from_cookies(@cookie)
-          result.should == "2905623" # the user who generated the original test cookie
+          expect(result).to eq("2905623") # the user who generated the original test cookie
         end
 
         it "returns nil if the cookies are invalid" do
           # make an invalid string by replacing some values
           bad_cookie_hash = @cookie.inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
           result = @oauth.get_user_from_cookies(bad_cookie_hash)
-          result.should be_nil
+          expect(result).to be_nil
         end
       end
     end
@@ -241,42 +241,42 @@ describe "Koala::Facebook::OAuth" do
     describe "#url_for_oauth_code" do
       it "generates a properly formatted OAuth code URL with the default values" do
         url = @oauth.url_for_oauth_code
-        url.should match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&redirect_uri=#{CGI.escape @callback_url}")
+        expect(url).to match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth code URL when a callback is given" do
         callback = "foo.com"
         url = @oauth.url_for_oauth_code(:callback => callback)
-        url.should match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&redirect_uri=#{callback}")
+        expect(url).to match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&redirect_uri=#{callback}")
       end
 
       it "generates a properly formatted OAuth code URL when permissions are requested as a string" do
         permissions = "publish_stream,read_stream"
         url = @oauth.url_for_oauth_code(:permissions => permissions)
-        url.should match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&scope=#{CGI.escape permissions}&redirect_uri=#{CGI.escape @callback_url}")
+        expect(url).to match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&scope=#{CGI.escape permissions}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth code URL when permissions are requested as a string" do
         permissions = ["publish_stream", "read_stream"]
         url = @oauth.url_for_oauth_code(:permissions => permissions)
-        url.should match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&scope=#{CGI.escape permissions.join(",")}&redirect_uri=#{CGI.escape @callback_url}")
+        expect(url).to match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&scope=#{CGI.escape permissions.join(",")}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth code URL when both permissions and callback are provided" do
         permissions = "publish_stream,read_stream"
         callback = "foo.com"
         url = @oauth.url_for_oauth_code(:callback => callback, :permissions => permissions)
-        url.should match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&scope=#{CGI.escape permissions}&redirect_uri=#{CGI.escape callback}")
+        expect(url).to match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&scope=#{CGI.escape permissions}&redirect_uri=#{CGI.escape callback}")
       end
 
       it "generates a properly formatted OAuth code URL when a display is given as a string" do
         url = @oauth.url_for_oauth_code(:display => "page")
-        url.should match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&display=page&redirect_uri=#{CGI.escape @callback_url}")
+        expect(url).to match_url("https://#{Koala.config.dialog_host}/dialog/oauth?client_id=#{@app_id}&display=page&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "raises an exception if no callback is given in initialization or the call" do
         oauth2 = Koala::Facebook::OAuth.new(@app_id, @secret)
-        lambda { oauth2.url_for_oauth_code }.should raise_error(ArgumentError)
+        expect { oauth2.url_for_oauth_code }.to raise_error(ArgumentError)
       end
 
       it "includes any additional options as URL parameters, appropriately escaped" do
@@ -286,7 +286,7 @@ describe "Koala::Facebook::OAuth" do
         }
         url = @oauth.url_for_oauth_code(params)
         params.each_pair do |key, value|
-          url.should =~ /[\&\?]#{key}=#{CGI.escape value}/
+          expect(url).to match(/[\&\?]#{key}=#{CGI.escape value}/)
         end
       end
     end
@@ -299,13 +299,13 @@ describe "Koala::Facebook::OAuth" do
 
       it "generates a properly formatted OAuth token URL when provided a code" do
         url = @oauth.url_for_access_token(@code)
-        url.should match_url("https://#{Koala.config.graph_server}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape @callback_url}")
+        expect(url).to match_url("https://#{Koala.config.graph_server}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth token URL when provided a callback" do
         callback = "foo.com"
         url = @oauth.url_for_access_token(@code, :callback => callback)
-        url.should match_url("https://#{Koala.config.graph_server}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape callback}")
+        expect(url).to match_url("https://#{Koala.config.graph_server}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape callback}")
       end
 
       it "includes any additional options as URL parameters, appropriately escaped" do
@@ -315,7 +315,7 @@ describe "Koala::Facebook::OAuth" do
         }
         url = @oauth.url_for_access_token(@code, params)
         params.each_pair do |key, value|
-          url.should =~ /[\&\?]#{key}=#{CGI.escape value}/
+          expect(url).to match(/[\&\?]#{key}=#{CGI.escape value}/)
         end
       end
     end
@@ -323,7 +323,7 @@ describe "Koala::Facebook::OAuth" do
     describe "#url_for_dialog" do
       it "builds the base properly" do
         dialog_type = "my_dialog_type"
-        @oauth.url_for_dialog(dialog_type).should =~ /^http:\/\/#{Koala.config.dialog_host}\/dialog\/#{dialog_type}/
+        expect(@oauth.url_for_dialog(dialog_type)).to match(/^http:\/\/#{Koala.config.dialog_host}\/dialog\/#{dialog_type}/)
       end
 
       it "adds the app_id/client_id to the url" do
@@ -331,7 +331,7 @@ describe "Koala::Facebook::OAuth" do
         url = @oauth.url_for_dialog("foo", automatic_params)
         automatic_params.each_pair do |key, value|
           # we're slightly simplifying how encode_params works, but for strings/ints, it's okay
-          url.should =~ /[\&\?]#{key}=#{CGI.escape value.to_s}/
+          expect(url).to match(/[\&\?]#{key}=#{CGI.escape value.to_s}/)
         end
       end
 
@@ -343,7 +343,7 @@ describe "Koala::Facebook::OAuth" do
         url = @oauth.url_for_dialog("friends", params)
         params.each_pair do |key, value|
           # we're slightly simplifying how encode_params works, but strings/ints, it's okay
-          url.should =~ /[\&\?]#{key}=#{CGI.escape value.to_s}/
+          expect(url).to match(/[\&\?]#{key}=#{CGI.escape value.to_s}/)
         end
       end
 
@@ -352,22 +352,22 @@ describe "Koala::Facebook::OAuth" do
         # slightly brittle (e.g. if parameter order changes), but still useful
         it "can generate a send dialog" do
           url = @oauth.url_for_dialog("send", :name => "People Argue Just to Win", :link => "http://www.nytimes.com/2011/06/15/arts/people-argue-just-to-win-scholars-assert.html")
-          url.should match_url("http://www.facebook.com/dialog/send?app_id=#{@app_id}&client_id=#{@app_id}&link=http%3A%2F%2Fwww.nytimes.com%2F2011%2F06%2F15%2Farts%2Fpeople-argue-just-to-win-scholars-assert.html&name=People+Argue+Just+to+Win&redirect_uri=#{CGI.escape @callback_url}")
+          expect(url).to match_url("http://www.facebook.com/dialog/send?app_id=#{@app_id}&client_id=#{@app_id}&link=http%3A%2F%2Fwww.nytimes.com%2F2011%2F06%2F15%2Farts%2Fpeople-argue-just-to-win-scholars-assert.html&name=People+Argue+Just+to+Win&redirect_uri=#{CGI.escape @callback_url}")
         end
 
         it "can generate a feed dialog" do
           url = @oauth.url_for_dialog("feed", :name => "People Argue Just to Win", :link => "http://www.nytimes.com/2011/06/15/arts/people-argue-just-to-win-scholars-assert.html")
-          url.should match_url("http://www.facebook.com/dialog/feed?app_id=#{@app_id}&client_id=#{@app_id}&link=http%3A%2F%2Fwww.nytimes.com%2F2011%2F06%2F15%2Farts%2Fpeople-argue-just-to-win-scholars-assert.html&name=People+Argue+Just+to+Win&redirect_uri=#{CGI.escape @callback_url}")
+          expect(url).to match_url("http://www.facebook.com/dialog/feed?app_id=#{@app_id}&client_id=#{@app_id}&link=http%3A%2F%2Fwww.nytimes.com%2F2011%2F06%2F15%2Farts%2Fpeople-argue-just-to-win-scholars-assert.html&name=People+Argue+Just+to+Win&redirect_uri=#{CGI.escape @callback_url}")
         end
 
         it "can generate a oauth dialog" do
           url = @oauth.url_for_dialog("oauth", :scope => "email", :response_type => "token")
-          url.should match_url("http://www.facebook.com/dialog/oauth?app_id=#{@app_id}&client_id=#{@app_id}&redirect_uri=#{CGI.escape @callback_url}&response_type=token&scope=email")
+          expect(url).to match_url("http://www.facebook.com/dialog/oauth?app_id=#{@app_id}&client_id=#{@app_id}&redirect_uri=#{CGI.escape @callback_url}&response_type=token&scope=email")
         end
 
         it "can generate a pay dialog" do
           url = @oauth.url_for_dialog("pay", :order_id => "foo", :credits_purchase => false)
-          url.should match_url("http://www.facebook.com/dialog/pay?app_id=#{@app_id}&client_id=#{@app_id}&order_id=foo&credits_purchase=false&redirect_uri=#{CGI.escape @callback_url}")
+          expect(url).to match_url("http://www.facebook.com/dialog/pay?app_id=#{@app_id}&client_id=#{@app_id}&order_id=foo&credits_purchase=false&redirect_uri=#{CGI.escape @callback_url}")
         end
       end
     end
@@ -377,35 +377,35 @@ describe "Koala::Facebook::OAuth" do
     describe '#generate_client_code' do
       if KoalaTest.mock_interface? || KoalaTest.oauth_token
         it 'makes a request using the correct endpoint' do
-          Koala.should_receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '{"code": "fake_client_code"}', {}))
+          expect(Koala).to receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '{"code": "fake_client_code"}', {}))
           @oauth.generate_client_code(KoalaTest.oauth_token)
         end
 
         it 'gets a valid client code returned' do
-          Koala.should_receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '{"code": "fake_client_code"}', {}))
+          expect(Koala).to receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '{"code": "fake_client_code"}', {}))
           result = @oauth.generate_client_code(KoalaTest.oauth_token)
-          result.should be_a(String)
-          result.should eq('fake_client_code')
+          expect(result).to be_a(String)
+          expect(result).to eq('fake_client_code')
         end
 
         it 'raises a BadFacebookResponse error when empty response body is returned' do
-          Koala.should_receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '', {}))
-          lambda { @oauth.generate_client_code(KoalaTest.oauth_token) }.should raise_error(Koala::Facebook::BadFacebookResponse)
+          expect(Koala).to receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '', {}))
+          expect { @oauth.generate_client_code(KoalaTest.oauth_token) }.to raise_error(Koala::Facebook::BadFacebookResponse)
         end
 
         it 'raises an OAuthTokenRequestError when empty response body is returned' do
-          Koala.should_receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(400, '', {}))
-          lambda { @oauth.generate_client_code(KoalaTest.oauth_token) }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
+          expect(Koala).to receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(400, '', {}))
+          expect { @oauth.generate_client_code(KoalaTest.oauth_token) }.to raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
 
         it 'raises a ServerError when empty response body is returned' do
-          Koala.should_receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(500, '', {}))
-          lambda { @oauth.generate_client_code(KoalaTest.oauth_token) }.should raise_error(Koala::Facebook::ServerError)
+          expect(Koala).to receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(500, '', {}))
+          expect { @oauth.generate_client_code(KoalaTest.oauth_token) }.to raise_error(Koala::Facebook::ServerError)
         end
 
         it 'raises a KoalaError when empty response body is returned' do
-          Koala.should_receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '{"client_code":"should_not_be_returned"}', {}))
-          lambda { @oauth.generate_client_code(KoalaTest.oauth_token) }.should raise_error(Koala::KoalaError)
+          expect(Koala).to receive(:make_request).with('/oauth/client_code', anything, 'get', anything).and_return(Koala::HTTPService::Response.new(200, '{"client_code":"should_not_be_returned"}', {}))
+          expect { @oauth.generate_client_code(KoalaTest.oauth_token) }.to raise_error(Koala::KoalaError)
         end
       else
         pending "Some OAuth token exchange tests will not be run since the access token field in facebook_data.yml is blank."
@@ -417,33 +417,33 @@ describe "Koala::Facebook::OAuth" do
     describe "#get_access_token_info" do
       it "uses options[:redirect_uri] if provided" do
         uri = "foo"
-        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => uri), anything, anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, hash_including(:redirect_uri => uri), anything, anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token_info(@code, :redirect_uri => uri)
       end
 
       it "uses the redirect_uri used to create the @oauth if no :redirect_uri option is provided" do
-        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => @callback_url), anything, anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, hash_including(:redirect_uri => @callback_url), anything, anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token_info(@code)
       end
 
       it "makes a GET request" do
-        Koala.should_receive(:make_request).with(anything, anything, "get", anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, anything, "get", anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token_info(@code)
       end
 
       if KoalaTest.code
         it "properly gets and parses an access token token results into a hash" do
           result = @oauth.get_access_token_info(@code)
-          result.should be_a(Hash)
+          expect(result).to be_a(Hash)
         end
 
         it "properly includes the access token results" do
           result = @oauth.get_access_token_info(@code)
-          result["access_token"].should
+          expect(result["access_token"]).to be_truthy
         end
 
         it "raises an error when get_access_token is called with a bad code" do
-          lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
+          expect { @oauth.get_access_token_info("foo") }.to raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
       end
     end
@@ -452,24 +452,24 @@ describe "Koala::Facebook::OAuth" do
       # TODO refactor these to be proper tests with stubs and tests against real data
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token(@code, options)
       end
 
       if KoalaTest.code
         it "uses get_access_token_info to get and parse an access token token results" do
           result = @oauth.get_access_token(@code)
-          result.should be_a(String)
+          expect(result).to be_a(String)
         end
 
         it "returns the access token as a string" do
           result = @oauth.get_access_token(@code)
           original = @oauth.get_access_token_info(@code)
-          result.should == original["access_token"]
+          expect(result).to eq(original["access_token"])
         end
 
         it "raises an error when get_access_token is called with a bad code" do
-          lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
+          expect { @oauth.get_access_token("foo") }.to raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
       end
     end
@@ -481,17 +481,17 @@ describe "Koala::Facebook::OAuth" do
     describe "get_app_access_token_info" do
       it "properly gets and parses an app's access token as a hash" do
         result = @oauth.get_app_access_token_info
-        result.should be_a(Hash)
+        expect(result).to be_a(Hash)
       end
 
       it "includes the access token" do
         result = @oauth.get_app_access_token_info
-        result["access_token"].should
+        expect(result["access_token"]).to be_truthy
       end
 
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_app_access_token_info(options)
       end
     end
@@ -499,18 +499,18 @@ describe "Koala::Facebook::OAuth" do
     describe "get_app_access_token" do
       it "uses get_access_token_info to get and parse an access token token results" do
         result = @oauth.get_app_access_token
-        result.should be_a(String)
+        expect(result).to be_a(String)
       end
 
       it "returns the access token as a string" do
         result = @oauth.get_app_access_token
         original = @oauth.get_app_access_token_info
-        result.should == original["access_token"]
+        expect(result).to eq(original["access_token"])
       end
 
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_app_access_token(options)
       end
     end
@@ -519,12 +519,12 @@ describe "Koala::Facebook::OAuth" do
       if KoalaTest.mock_interface? || KoalaTest.oauth_token
         it "properly gets and parses an app's access token as a hash" do
           result = @oauth.exchange_access_token_info(KoalaTest.oauth_token)
-          result.should be_a(Hash)
+          expect(result).to be_a(Hash)
         end
 
         it "includes the access token" do
           result = @oauth.exchange_access_token_info(KoalaTest.oauth_token)
-          result["access_token"].should
+          expect(result["access_token"]).not_to be_nil
         end
       else
         pending "Some OAuth token exchange tests will not be run since the access token field in facebook_data.yml is blank."
@@ -532,25 +532,25 @@ describe "Koala::Facebook::OAuth" do
 
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.exchange_access_token_info(KoalaTest.oauth_token, options)
       end
 
       it "raises an error when exchange_access_token_info is called with a bad code" do
-        lambda { @oauth.exchange_access_token_info("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
+        expect { @oauth.exchange_access_token_info("foo") }.to raise_error(Koala::Facebook::OAuthTokenRequestError)
       end
     end
 
     describe "exchange_access_token" do
       it "uses get_access_token_info to get and parse an access token token results" do
         hash = {"access_token" => Time.now.to_i * rand}
-        @oauth.stub(:exchange_access_token_info).and_return(hash)
-        @oauth.exchange_access_token(KoalaTest.oauth_token).should == hash["access_token"]
+        allow(@oauth).to receive(:exchange_access_token_info).and_return(hash)
+        expect(@oauth.exchange_access_token(KoalaTest.oauth_token)).to eq(hash["access_token"])
       end
 
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
+        expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.exchange_access_token(KoalaTest.oauth_token, options)
       end
     end
@@ -563,13 +563,13 @@ describe "Koala::Facebook::OAuth" do
       it "properly parses access token results" do
         result = @oauth.send(:parse_access_token, @raw_token_string)
         has_both_parts = result["access_token"] && result["expires"]
-        has_both_parts.should
+        expect(has_both_parts).to be_truthy
       end
 
       it "properly parses offline access token results" do
         result = @oauth.send(:parse_access_token, @raw_offline_access_token_string)
         has_both_parts = result["access_token"] && !result["expires"]
-        has_both_parts.should
+        expect(has_both_parts).to be true
       end
 
       # fetch_token_string
@@ -578,7 +578,7 @@ describe "Koala::Facebook::OAuth" do
       if KoalaTest.code
         it "fetches a proper token string from Facebook when given a code" do
           result = @oauth.send(:fetch_token_string, :code => @code, :redirect_uri => @callback_url)
-          result.should =~ /^access_token/
+          expect(result).to match(/^access_token/)
         end
       else
         it "fetch_token_string code test will not be run since the code field in facebook_data.yml is blank."
@@ -586,7 +586,7 @@ describe "Koala::Facebook::OAuth" do
 
       it "fetches a proper token string from Facebook when asked for the app token" do
         result = @oauth.send(:fetch_token_string, {:grant_type => 'client_credentials'}, true)
-        result.should =~ /^access_token/
+        expect(result).to match(/^access_token/)
       end
     end
   end
@@ -596,41 +596,41 @@ describe "Koala::Facebook::OAuth" do
       describe "with get_token_info_from_session_keys" do
         it "gets an array of session keys from Facebook when passed a single key" do
           result = @oauth.get_tokens_from_session_keys([KoalaTest.session_key])
-          result.should be_an(Array)
-          result.length.should == 1
+          expect(result).to be_an(Array)
+          expect(result.length).to eq(1)
         end
 
         it "gets an array of session keys from Facebook when passed multiple keys" do
           result = @oauth.get_tokens_from_session_keys(@multiple_session_keys)
-          result.should be_an(Array)
-          result.length.should == 2
+          expect(result).to be_an(Array)
+          expect(result.length).to eq(2)
         end
 
         it "returns the original hashes" do
           result = @oauth.get_token_info_from_session_keys(@multiple_session_keys)
-          result[0].should be_a(Hash)
+          expect(result[0]).to be_a(Hash)
         end
 
         it "properly handles invalid session keys" do
           result = @oauth.get_token_info_from_session_keys(["foo", "bar"])
           #it should return nil for each of the invalid ones
-          result.each {|r| r.should be_nil}
+          result.each {|r| expect(r).to be_nil}
         end
 
         it "properly handles a mix of valid and invalid session keys" do
           result = @oauth.get_token_info_from_session_keys(["foo"].concat(@multiple_session_keys))
           # it should return nil for each of the invalid ones
-          result.each_with_index {|r, index| index > 0 ? r.should(be_a(Hash)) : r.should(be_nil)}
+          result.each_with_index {|r, index| index > 0 ? expect(r).to(be_a(Hash)) : expect(r).to(be_nil)}
         end
 
         it "throws a BadFacebookResponse if Facebook returns an empty body (as happens for instance when the API breaks)" do
-          @oauth.should_receive(:fetch_token_string).and_return("")
-          lambda { @oauth.get_token_info_from_session_keys(@multiple_session_keys) }.should raise_error(Koala::Facebook::BadFacebookResponse)
+          expect(@oauth).to receive(:fetch_token_string).and_return("")
+          expect { @oauth.get_token_info_from_session_keys(@multiple_session_keys) }.to raise_error(Koala::Facebook::BadFacebookResponse)
         end
 
         it "passes on any options provided to make_request" do
           options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
+          expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
           @oauth.get_token_info_from_session_keys([], options)
         end
       end
@@ -638,31 +638,31 @@ describe "Koala::Facebook::OAuth" do
       describe "with get_tokens_from_session_keys" do
         it "calls get_token_info_from_session_keys" do
           args = @multiple_session_keys
-          @oauth.should_receive(:get_token_info_from_session_keys).with(args, anything).and_return([])
+          expect(@oauth).to receive(:get_token_info_from_session_keys).with(args, anything).and_return([])
           @oauth.get_tokens_from_session_keys(args)
         end
 
         it "returns an array of strings" do
           args = @multiple_session_keys
           result = @oauth.get_tokens_from_session_keys(args)
-          result.each {|r| r.should be_a(String) }
+          result.each {|r| expect(r).to be_a(String) }
         end
 
         it "properly handles invalid session keys" do
           result = @oauth.get_tokens_from_session_keys(["foo", "bar"])
           # it should return nil for each of the invalid ones
-          result.each {|r| r.should be_nil}
+          result.each {|r| expect(r).to be_nil}
         end
 
         it "properly handles a mix of valid and invalid session keys" do
           result = @oauth.get_tokens_from_session_keys(["foo"].concat(@multiple_session_keys))
           # it should return nil for each of the invalid ones
-          result.each_with_index {|r, index| index > 0 ? r.should(be_a(String)) : r.should(be_nil)}
+          result.each_with_index {|r, index| index > 0 ? expect(r).to(be_a(String)) : expect(r).to(be_nil)}
         end
 
         it "passes on any options provided to make_request" do
           options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
+          expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
           @oauth.get_tokens_from_session_keys([], options)
         end
       end
@@ -670,29 +670,29 @@ describe "Koala::Facebook::OAuth" do
       describe "get_token_from_session_key" do
         it "calls get_tokens_from_session_keys when the get_token_from_session_key is called" do
           key = KoalaTest.session_key
-          @oauth.should_receive(:get_tokens_from_session_keys).with([key], anything).and_return([])
+          expect(@oauth).to receive(:get_tokens_from_session_keys).with([key], anything).and_return([])
           @oauth.get_token_from_session_key(key)
         end
 
         it "gets back the access token string from get_token_from_session_key" do
           result = @oauth.get_token_from_session_key(KoalaTest.session_key)
-          result.should be_a(String)
+          expect(result).to be_a(String)
         end
 
         it "returns the first value in the array" do
           result = @oauth.get_token_from_session_key(KoalaTest.session_key)
           array = @oauth.get_tokens_from_session_keys([KoalaTest.session_key])
-          result.should == array[0]
+          expect(result).to eq(array[0])
         end
 
         it "properly handles an invalid session key" do
           result = @oauth.get_token_from_session_key("foo")
-          result.should be_nil
+          expect(result).to be_nil
         end
 
         it "passes on any options provided to make_request" do
           options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
+          expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
           @oauth.get_token_from_session_key("", options)
         end
       end
@@ -705,24 +705,24 @@ describe "Koala::Facebook::OAuth" do
     # the signed request code is ported directly from Facebook
     # so we only need to test at a high level that it works
     it "throws an error if the algorithm is unsupported" do
-      MultiJson.stub(:load).and_return("algorithm" => "my fun algorithm")
-      lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
+      allow(MultiJson).to receive(:load).and_return("algorithm" => "my fun algorithm")
+      expect { @oauth.parse_signed_request(@signed_request) }.to raise_error
     end
 
     it "throws an error if the signature is invalid" do
-      OpenSSL::HMAC.stub(:hexdigest).and_return("i'm an invalid signature")
-      lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
+      allow(OpenSSL::HMAC).to receive(:hexdigest).and_return("i'm an invalid signature")
+      expect { @oauth.parse_signed_request(@signed_request) }.to raise_error
     end
 
     it "throws an error if the signature string is empty" do
       # this occasionally happens due to Facebook error
-      lambda { @oauth.parse_signed_request("") }.should raise_error
-      lambda { @oauth.parse_signed_request("abc-def") }.should raise_error
+      expect { @oauth.parse_signed_request("") }.to raise_error
+      expect { @oauth.parse_signed_request("abc-def") }.to raise_error
     end
 
     it "properly parses requests" do
       @oauth = Koala::Facebook::OAuth.new(@app_id, @secret || @app_secret)
-      @oauth.parse_signed_request(@signed_params).should == @signed_params_result
+      expect(@oauth.parse_signed_request(@signed_params)).to eq(@signed_params_result)
     end
   end