koala 1.8.0 → 1.9.0rc1

data/spec/cases/graph_api_spec.rb

@@ -17,21 +17,21 @@ describe 'Koala::Facebook::GraphAPIMethods' do
     # and the other methods which do some post-processing locally
     context '#get_object' do
       it 'returns result of block' do
-        @api.stub(:api).and_return(double("other results"))
-        @api.get_object('koppel', &post_processing)["result"].should == result
+        allow(@api).to receive(:api).and_return(double("other results"))
+        expect(@api.get_object('koppel', &post_processing)["result"]).to eq(result)
       end
     end
 
     context '#get_picture' do
       it 'returns result of block' do
-        @api.stub(:api).and_return("Location" => double("other result"))
-        @api.get_picture('lukeshepard', &post_processing)["result"].should == result
+        allow(@api).to receive(:api).and_return("Location" => double("other result"))
+        expect(@api.get_picture('lukeshepard', &post_processing)["result"]).to eq(result)
       end
     end
 
     context '#fql_multiquery' do
       before do
-        @api.should_receive(:get_object).and_return([
+        expect(@api).to receive(:get_object).and_return([
           {"name" => "query1", "fql_result_set" => [{"id" => 123}]},
           {"name" => "query2", "fql_result_set" => ["id" => 456]}
         ])
@@ -43,18 +43,41 @@ describe 'Koala::Facebook::GraphAPIMethods' do
           'query2' => [{'id' => 456}]
         }
         response = @api.fql_multiquery({}, &post_processing)
-        response["args"].should == resolved_result
-        response["result"].should == result
+        expect(response["args"]).to eq(resolved_result)
+        expect(response["result"]).to eq(result)
       end
     end
 
     context '#get_page_access_token' do
       it 'returns result of block' do
         token = Koala::MockHTTPService::APP_ACCESS_TOKEN
-        @api.stub(:api).and_return("access_token" => token)
+        allow(@api).to receive(:api).and_return("access_token" => token)
         response = @api.get_page_access_token('facebook', &post_processing)
-        response["args"].should == token
-        response["result"].should == result
+        expect(response["args"]).to eq(token)
+        expect(response["result"]).to eq(result)
+      end
+    end
+  end
+
+  context '#graph_call' do
+    describe "the appsecret_proof option" do
+      let(:path) { '/path' }
+
+      it "is enabled by default if an app secret is present" do
+        api = Koala::Facebook::API.new(@token, "mysecret")
+        expect(api).to receive(:api).with(path, {}, 'get', :appsecret_proof => true)
+        api.graph_call(path)
+      end
+
+      it "can be disabled manually" do
+        api = Koala::Facebook::API.new(@token, "mysecret")
+        expect(api).to receive(:api).with(path, {}, 'get', hash_not_including(appsecret_proof: true))
+        api.graph_call(path, {}, "get", appsecret_proof: false)
+      end
+
+      it "isn't included if no app secret is present" do
+        expect(@api).to receive(:api).with(path, {}, 'get', {})
+        @api.graph_call(path)
       end
     end
   end

data/spec/cases/graph_collection_spec.rb

@@ -13,32 +13,32 @@ describe Koala::Facebook::GraphCollection do
   end
 
   it "subclasses Array" do
-    Koala::Facebook::GraphCollection.ancestors.should include(Array)
+    expect(Koala::Facebook::GraphCollection.ancestors).to include(Array)
   end
 
   it "creates an array-like object" do
-    Koala::Facebook::GraphCollection.new(@result, @api).should be_an(Array)
+    expect(Koala::Facebook::GraphCollection.new(@result, @api)).to be_an(Array)
   end
 
   it "contains the result data" do
-    @result["data"].each_with_index {|r, i| @collection[i].should == r}
+    @result["data"].each_with_index {|r, i| expect(@collection[i]).to eq(r)}
   end
 
   it "has a read-only paging attribute" do
-    @collection.methods.map(&:to_sym).should include(:paging)
-    @collection.methods.map(&:to_sym).should_not include(:paging=)
+    expect(@collection.methods.map(&:to_sym)).to include(:paging)
+    expect(@collection.methods.map(&:to_sym)).not_to include(:paging=)
   end
 
   it "sets paging to results['paging']" do
-    @collection.paging.should == @result["paging"]
+    expect(@collection.paging).to eq(@result["paging"])
   end
 
   it "sets raw_response to the original results" do
-    @collection.raw_response.should == @result
+    expect(@collection.raw_response).to eq(@result)
   end
 
   it "sets the API to the provided API" do
-    @collection.api.should == @api
+    expect(@collection.api).to eq(@api)
   end
 
   describe "when getting a whole page" do
@@ -53,24 +53,24 @@ describe Koala::Facebook::GraphCollection do
     end
 
     it "should return the previous page of results" do
-      @collection.should_receive(:previous_page_params).and_return([@base, @args])
-      @api.should_receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-      @collection.previous_page.should == @page_of_results
+      expect(@collection).to receive(:previous_page_params).and_return([@base, @args])
+      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
+      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(@collection.previous_page).to eq(@page_of_results)
     end
 
     it "should return the next page of results" do
-      @collection.should_receive(:next_page_params).and_return([@base, @args])
-      @api.should_receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(@collection).to receive(:next_page_params).and_return([@base, @args])
+      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
+      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
 
-      @collection.next_page.should == @page_of_results
+      expect(@collection.next_page).to eq(@page_of_results)
     end
 
     it "should return nil it there are no other pages" do
       %w{next previous}.each do |this|
-        @collection.should_receive("#{this}_page_params".to_sym).and_return(nil)
-        @collection.send("#{this}_page").should == nil
+        expect(@collection).to receive("#{this}_page_params".to_sym).and_return(nil)
+        expect(@collection.send("#{this}_page")).to eq(nil)
       end
     end
   end
@@ -79,38 +79,38 @@ describe Koala::Facebook::GraphCollection do
     describe "#parse_page_url" do
       it "should pass the url to the class method" do
         url = double("url")
-        Koala::Facebook::GraphCollection.should_receive(:parse_page_url).with(url)
+        expect(Koala::Facebook::GraphCollection).to receive(:parse_page_url).with(url)
         @collection.parse_page_url(url)
       end
 
       it "should return the result of the class method" do
         parsed_content = double("parsed_content")
-        Koala::Facebook::GraphCollection.stub(:parse_page_url).and_return(parsed_content)
-        @collection.parse_page_url(double("url")).should == parsed_content
+        allow(Koala::Facebook::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
+        expect(@collection.parse_page_url(double("url"))).to eq(parsed_content)
       end
     end
 
     describe ".parse_page_url" do
       it "should return the base as the first array entry" do
         base = "url_path"
-        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first.should == base
+        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first).to eq(base)
       end
 
       it "should return the arguments as a hash as the last array entry" do
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last).to eq(args_hash)
       end
 
       it "works with non-.com addresses" do
         base = "url_path"
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").should == [base, args_hash]
+        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}")).to eq([base, args_hash])
       end
 
       it "works with addresses with irregular characters" do
         access_token = "appid123a|fdcba"
         base, args_hash = Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
-        args_hash["token"].should == access_token
+        expect(args_hash["token"]).to eq(access_token)
       end
     end
   end
@@ -118,29 +118,29 @@ describe Koala::Facebook::GraphCollection do
   describe ".evaluate" do
     it "returns the original result if it's provided a non-hash result" do
       result = []
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if it's provided a nil result" do
       result = nil
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if the result doesn't have a data key" do
       result = {"paging" => {}}
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if the result's data key isn't an array" do
       result = {"data" => {}, "paging" => {}}
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
       result = {"data" => [], "paging" => {}}
       expected = :foo
-      Koala::Facebook::GraphCollection.should_receive(:new).with(result, @api).and_return(expected)
-      Koala::Facebook::GraphCollection.evaluate(result, @api).should == expected
+      expect(Koala::Facebook::GraphCollection).to receive(:new).with(result, @api).and_return(expected)
+      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(expected)
     end
   end
 
@@ -148,12 +148,12 @@ describe Koala::Facebook::GraphCollection do
     let(:paging){ {"next" => "http://example.com/?a=2&b=3"} }
 
     it "should get next page" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
       @collection.next_page
     end
 
     it "should get next page with extra parameters" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
       @collection.next_page("c" => "4")
     end
   end
@@ -162,12 +162,12 @@ describe Koala::Facebook::GraphCollection do
     let(:paging){ {"previous" => "http://example.com/?a=2&b=3"} }
 
     it "should get previous page" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
       @collection.previous_page
     end
 
     it "should get previous page with extra parameters" do
-      @api.should_receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
       @collection.previous_page("c" => "4")
     end
   end

data/spec/cases/http_service_spec.rb

@@ -2,45 +2,45 @@ require 'spec_helper'
 
 describe Koala::HTTPService do
   it "has a faraday_middleware accessor" do
-    Koala::HTTPService.methods.map(&:to_sym).should include(:faraday_middleware)
-    Koala::HTTPService.methods.map(&:to_sym).should include(:faraday_middleware=)
+    expect(Koala::HTTPService.methods.map(&:to_sym)).to include(:faraday_middleware)
+    expect(Koala::HTTPService.methods.map(&:to_sym)).to include(:faraday_middleware=)
   end
 
   it "has an http_options accessor" do
-    Koala::HTTPService.should respond_to(:http_options)
-    Koala::HTTPService.should respond_to(:http_options=)
+    expect(Koala::HTTPService).to respond_to(:http_options)
+    expect(Koala::HTTPService).to respond_to(:http_options=)
   end
 
   it "sets http_options to {} by default" do
-    Koala::HTTPService.http_options.should == {}
+    expect(Koala::HTTPService.http_options).to eq({})
   end
 
   describe "DEFAULT_MIDDLEWARE" do
     before :each do
       @builder = double("Faraday connection builder")
-      @builder.stub(:request)
-      @builder.stub(:adapter)
-      @builder.stub(:use)
+      allow(@builder).to receive(:request)
+      allow(@builder).to receive(:adapter)
+      allow(@builder).to receive(:use)
     end
 
     it "is defined" do
-      Koala::HTTPService.const_defined?("DEFAULT_MIDDLEWARE").should be_true
+      expect(Koala::HTTPService.const_defined?("DEFAULT_MIDDLEWARE")).to be_truthy
     end
 
     it "adds multipart" do
-      @builder.should_receive(:use).with(Koala::HTTPService::MultipartRequest)
+      expect(@builder).to receive(:use).with(Koala::HTTPService::MultipartRequest)
       Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
     end
 
     it "adds url_encoded" do
-      @builder.should_receive(:request).with(:url_encoded)
+      expect(@builder).to receive(:request).with(:url_encoded)
       Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
     end
 
     it "uses the default adapter" do
       adapter = :testing_now
-      Faraday.stub(:default_adapter).and_return(adapter)
-      @builder.should_receive(:adapter).with(adapter)
+      allow(Faraday).to receive(:default_adapter).and_return(adapter)
+      expect(@builder).to receive(:adapter).with(adapter)
       Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
     end
   end
@@ -49,39 +49,39 @@ describe Koala::HTTPService do
     let(:defaults) { Koala::HTTPService::DEFAULT_SERVERS }
 
     it "defines the graph server" do
-      defaults[:graph_server].should == "graph.facebook.com"
+      expect(defaults[:graph_server]).to eq("graph.facebook.com")
     end
 
     it "defines the rest server" do
-      defaults[:rest_server].should == "api.facebook.com"
+      expect(defaults[:rest_server]).to eq("api.facebook.com")
     end
 
     it "defines the dialog host" do
-      defaults[:dialog_host].should == "www.facebook.com"
+      expect(defaults[:dialog_host]).to eq("www.facebook.com")
     end
 
     it "defines the path replacement regular expression" do
-      defaults[:host_path_matcher].should == /\.facebook/
+      expect(defaults[:host_path_matcher]).to eq(/\.facebook/)
     end
 
     it "defines the video server replacement for uploads" do
-      defaults[:video_replace].should == "-video.facebook"
+      expect(defaults[:video_replace]).to eq("-video.facebook")
     end
 
     it "defines the beta tier replacement" do
-      defaults[:beta_replace].should == ".beta.facebook"
+      expect(defaults[:beta_replace]).to eq(".beta.facebook")
     end
   end
 
   describe "server" do
     describe "with no options" do
       it "returns the REST server if options[:rest_api]" do
-        Koala::HTTPService.server(:rest_api => true).should =~ Regexp.new(Koala.config.rest_server)
+        expect(Koala::HTTPService.server(:rest_api => true)).to match(Regexp.new(Koala.config.rest_server))
       end
 
       it "returns the graph server if !options[:rest_api]" do
-        Koala::HTTPService.server(:rest_api => false).should =~ Regexp.new(Koala.config.graph_server)
-        Koala::HTTPService.server({}).should =~ Regexp.new(Koala.config.graph_server)
+        expect(Koala::HTTPService.server(:rest_api => false)).to match(Regexp.new(Koala.config.graph_server))
+        expect(Koala::HTTPService.server({})).to match(Regexp.new(Koala.config.graph_server))
       end
     end
 
@@ -92,12 +92,12 @@ describe Koala::HTTPService do
 
       it "returns the beta REST server if options[:rest_api]" do
         server = Koala::HTTPService.server(@options.merge(:rest_api => true))
-        server.should =~ Regexp.new(Koala.config.rest_server.gsub(/\.facebook/, ".beta.facebook"))
+        expect(server).to match(Regexp.new(Koala.config.rest_server.gsub(/\.facebook/, ".beta.facebook")))
       end
 
       it "returns the beta rest server if !options[:rest_api]" do
         server = Koala::HTTPService.server(@options)
-        server.should =~ Regexp.new(Koala.config.graph_server.gsub(/\.facebook/, ".beta.facebook"))
+        expect(server).to match(Regexp.new(Koala.config.graph_server.gsub(/\.facebook/, ".beta.facebook")))
       end
     end
 
@@ -108,26 +108,26 @@ describe Koala::HTTPService do
 
       it "returns the REST video server if options[:rest_api]" do
         server = Koala::HTTPService.server(@options.merge(:rest_api => true))
-        server.should =~ Regexp.new(Koala.config.rest_server.gsub(/\.facebook/, "-video.facebook"))
+        expect(server).to match(Regexp.new(Koala.config.rest_server.gsub(/\.facebook/, "-video.facebook")))
       end
 
       it "returns the graph video server if !options[:rest_api]" do
         server = Koala::HTTPService.server(@options)
-        server.should =~ Regexp.new(Koala.config.graph_server.gsub(/\.facebook/, "-video.facebook"))
+        expect(server).to match(Regexp.new(Koala.config.graph_server.gsub(/\.facebook/, "-video.facebook")))
       end
     end
   end
 
   describe ".encode_params" do
     it "returns an empty string if param_hash evaluates to false" do
-      Koala::HTTPService.encode_params(nil).should == ''
+      expect(Koala::HTTPService.encode_params(nil)).to eq('')
     end
 
     it "converts values to JSON if the value is not a String" do
       val = 'json_value'
       not_a_string = 'not_a_string'
-      not_a_string.stub(:is_a?).and_return(false)
-      MultiJson.should_receive(:dump).with(not_a_string).and_return(val)
+      allow(not_a_string).to receive(:is_a?).and_return(false)
+      expect(MultiJson).to receive(:dump).with(not_a_string).and_return(val)
 
       string = "hi"
 
@@ -137,9 +137,9 @@ describe Koala::HTTPService do
       }
 
       result = Koala::HTTPService.encode_params(args)
-      result.split('&').find do |key_and_val|
+      expect(result.split('&').find do |key_and_val|
         key_and_val.match("#{not_a_string}=#{val}")
-      end.should be_true
+      end).to be_truthy
     end
 
     it "escapes all values" do
@@ -148,7 +148,7 @@ describe Koala::HTTPService do
       result = Koala::HTTPService.encode_params(args)
       result.split('&').each do |key_val|
         key, val = key_val.split('=')
-        val.should == CGI.escape(args[key])
+        expect(val).to eq(CGI.escape(args[key]))
       end
     end
 
@@ -156,7 +156,7 @@ describe Koala::HTTPService do
       args = {:b => '2', 'a' => '1'}
 
       result = Koala::HTTPService.encode_params(args)
-      result.split('&').map{|key_val| key_val.split('=')[0]}.should == ['a', 'b']
+      expect(result.split('&').map{|key_val| key_val.split('=')[0]}).to eq(['a', 'b'])
     end
 
     it "converts all keys to Strings" do
@@ -165,7 +165,7 @@ describe Koala::HTTPService do
       result = Koala::HTTPService.encode_params(args)
       result.split('&').each do |key_val|
         key, val = key_val.split('=')
-        key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
+        expect(key).to eq(args.find{|key_val_arr| key_val_arr.last == val}.first.to_s)
       end
     end
   end
@@ -178,103 +178,103 @@ describe Koala::HTTPService do
       @mock_http_response = double("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
 
       @mock_connection = double("Faraday connection")
-      @mock_connection.stub(:get).and_return(@mock_http_response)
-      @mock_connection.stub(:post).and_return(@mock_http_response)
-      Faraday.stub(:new).and_return(@mock_connection)
+      allow(@mock_connection).to receive(:get).and_return(@mock_http_response)
+      allow(@mock_connection).to receive(:post).and_return(@mock_http_response)
+      allow(Faraday).to receive(:new).and_return(@mock_connection)
     end
 
     describe "creating the Faraday connection" do
       it "creates a Faraday connection using the server" do
         server = "foo"
-        Koala::HTTPService.stub(:server).and_return(server)
-        Faraday.should_receive(:new).with(server, anything).and_return(@mock_connection)
+        allow(Koala::HTTPService).to receive(:server).and_return(server)
+        expect(Faraday).to receive(:new).with(server, anything).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "anything")
       end
 
       it "merges Koala::HTTPService.http_options into the request params" do
         http_options = {:proxy => "http://user:password@example.org/", :request => { :timeout => 3 }}
         Koala::HTTPService.http_options = http_options
-        Faraday.should_receive(:new).with(anything, hash_including(http_options)).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_including(http_options)).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get")
       end
 
       it "does not merge invalid Faraday options from Koala::HTTPService.http_options into the request params" do
         http_options = {:invalid => "fake param"}
         Koala::HTTPService.http_options = http_options
-        Faraday.should_receive(:new).with(anything, hash_not_including(http_options)).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_not_including(http_options)).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get")
       end
 
       it "merges any provided options into the request params" do
         options = {:proxy => "http://user:password@example.org/", :request => { :timeout => 3 }}
-        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get", options)
       end
 
       it "overrides Koala::HTTPService.http_options with any provided options for the request params" do
         options = {:proxy => "http://user:password@proxy.org/", :request => { :timeout => 10 }}
         http_options = {:proxy => "http://user:password@example.org/", :request => { :timeout => 3 }}
-        Koala::HTTPService.stub(:http_options).and_return(http_options)
+        allow(Koala::HTTPService).to receive(:http_options).and_return(http_options)
 
-        Faraday.should_receive(:new).with(anything, hash_including(http_options.merge(options))).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_including(http_options.merge(options))).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get", options)
       end
 
       it "forces use_ssl to true if an access token is present" do
         options = {:use_ssl => false}
-        Koala::HTTPService.stub(:http_options).and_return(:use_ssl => false)
-        Faraday.should_receive(:new).with(anything, hash_including(:ssl => {:verify => true})).and_return(@mock_connection)
+        allow(Koala::HTTPService).to receive(:http_options).and_return(:use_ssl => false)
+        expect(Faraday).to receive(:new).with(anything, hash_including(:ssl => {:verify => true})).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
       end
 
       it "defaults verify to true if use_ssl is true" do
-        Faraday.should_receive(:new).with(anything, hash_including(:ssl => {:verify => true})).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_including(:ssl => {:verify => true})).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get")
       end
 
       it "allows you to set other verify modes if you really want" do
         options = {:ssl => {:verify => :foo}}
-        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
       end
 
       it "calls server with the composite options" do
         options = {:a => 2, :c => "3"}
         http_options = {:a => :a}
-        Koala::HTTPService.stub(:http_options).and_return(http_options)
-        Koala::HTTPService.should_receive(:server).with(hash_including(http_options.merge(options))).and_return("foo")
+        allow(Koala::HTTPService).to receive(:http_options).and_return(http_options)
+        expect(Koala::HTTPService).to receive(:server).with(hash_including(http_options.merge(options))).and_return("foo")
         Koala::HTTPService.make_request("anything", {}, "get", options)
       end
 
       it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
         block = Proc.new {}
         stub_const("Koala::HTTPService::DEFAULT_MIDDLEWARE", block)
-        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)
-        Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
+        allow(Koala::HTTPService).to receive(:faraday_middleware).and_return(nil)
+        expect(Faraday).to receive(:new).with(anything, anything, &block).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get")
       end
 
       it "uses the defined HTTPService.faraday_middleware block if defined" do
         block = Proc.new { }
-        Koala::HTTPService.should_receive(:faraday_middleware).and_return(block)
-        Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
+        expect(Koala::HTTPService).to receive(:faraday_middleware).and_return(block)
+        expect(Faraday).to receive(:new).with(anything, anything, &block).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get")
       end
     end
 
     it "makes a POST request if the verb isn't get" do
-      @mock_connection.should_receive(:post).and_return(@mock_http_response)
+      expect(@mock_connection).to receive(:post).and_return(@mock_http_response)
       Koala::HTTPService.make_request("anything", {}, "anything")
     end
 
     it "includes the verb in the body if the verb isn't get" do
       verb = "eat"
-      @mock_connection.should_receive(:post).with(anything, hash_including("method" => verb)).and_return(@mock_http_response)
+      expect(@mock_connection).to receive(:post).with(anything, hash_including("method" => verb)).and_return(@mock_http_response)
       Koala::HTTPService.make_request("anything", {}, verb)
     end
 
     it "makes a GET request if the verb is get" do
-      @mock_connection.should_receive(:get).and_return(@mock_http_response)
+      expect(@mock_connection).to receive(:get).and_return(@mock_http_response)
       Koala::HTTPService.make_request("anything", {}, "get")
     end
 
@@ -282,27 +282,27 @@ describe Koala::HTTPService do
       it "submits the arguments in the body" do
         # technically this is done for all requests, but you don't send GET requests with files
         args = {"a" => :b, "c" => 3}
-        Faraday.should_receive(:new).with(anything, hash_including(:params => args)).and_return(@mock_connection)
+        expect(Faraday).to receive(:new).with(anything, hash_including(:params => args)).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", args, "get")
       end
 
       it "submits nothing to the body" do
         # technically this is done for all requests, but you don't send GET requests with files
         args = {"a" => :b, "c" => 3}
-        @mock_connection.should_receive(:get).with(anything, {}).and_return(@mock_http_response)
+        expect(@mock_connection).to receive(:get).with(anything, {}).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", args, "get")
       end
 
       it "logs verb, url and params to debug" do
         args = {"a" => :b, "c" => 3}
         log_message_stem = "GET: anything params: "
-        Koala::Utils.logger.should_receive(:debug) do |log_message|
+        expect(Koala::Utils.logger).to receive(:debug) do |log_message|
           # unordered hashes are a bane
           # Ruby in 1.8 modes tends to return different hash orderings,
           # which makes checking the content of the stringified hash hard
           # it's enough just to ensure that there's hash content in the string, I think
-          log_message.should include(log_message_stem)
-          log_message.match(/\{.*\}/).should_not be_nil
+          expect(log_message).to include(log_message_stem)
+          expect(log_message.match(/\{.*\}/)).not_to be_nil
         end
 
         Koala::HTTPService.make_request("anything", args, "get")
@@ -313,7 +313,7 @@ describe Koala::HTTPService do
       it "submits the arguments in the body" do
         # technically this is done for all requests, but you don't send GET requests with files
         args = {"a" => :b, "c" => 3}
-        @mock_connection.should_receive(:post).with(anything, hash_including(args)).and_return(@mock_http_response)
+        expect(@mock_connection).to receive(:post).with(anything, hash_including(args)).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", args, "post")
       end
 
@@ -321,21 +321,21 @@ describe Koala::HTTPService do
         # technically this is done for all requests, but you don't send GET requests with files
         upload_io = double("UploadIO")
         u = Koala::UploadableIO.new("/path/to/stuff", "img/jpg")
-        u.stub(:to_upload_io).and_return(upload_io)
-        @mock_connection.should_receive(:post).with(anything, hash_including("source" => upload_io)).and_return(@mock_http_response)
+        allow(u).to receive(:to_upload_io).and_return(upload_io)
+        expect(@mock_connection).to receive(:post).with(anything, hash_including("source" => upload_io)).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", {:source => u}, "post")
       end
 
       it "logs verb, url and params to debug" do
         args = {"a" => :b, "c" => 3}
         log_message_stem = "POST: anything params: "
-        Koala::Utils.logger.should_receive(:debug) do |log_message|
+        expect(Koala::Utils.logger).to receive(:debug) do |log_message|
           # unordered hashes are a bane
           # Ruby in 1.8 modes tends to return different hash orderings,
           # which makes checking the content of the stringified hash hard
           # it's enough just to ensure that there's hash content in the string, I think
-          log_message.should include(log_message_stem)
-          log_message.match(/\{.*\}/).should_not be_nil
+          expect(log_message).to include(log_message_stem)
+          expect(log_message.match(/\{.*\}/)).not_to be_nil
         end
         Koala::HTTPService.make_request("anything", args, "post")
       end
@@ -344,7 +344,7 @@ describe Koala::HTTPService do
 
   describe "deprecated options" do
     before :each do
-      Koala::HTTPService.stub(:http_options).and_return({})
+      allow(Koala::HTTPService).to receive(:http_options).and_return({})
       @service = Koala.http_service
     end
 
@@ -362,11 +362,11 @@ describe Koala::HTTPService do
           it "reads http_options[:#{parameter}]" do
             value = "foo"
             Koala::HTTPService.http_options[parameter] = value
-            Koala::HTTPService.send(deprecated_method).should == value
+            expect(Koala::HTTPService.send(deprecated_method)).to eq(value)
           end
 
           it "generates a deprecation warning" do
-            Koala::Utils.should_receive(:deprecate)
+            expect(Koala::Utils).to receive(:deprecate)
             Koala::HTTPService.send(deprecated_method)
           end
         end
@@ -376,11 +376,11 @@ describe Koala::HTTPService do
             Koala::HTTPService.http_options[parameter] = nil
             value = "foo"
             Koala::HTTPService.send(:"#{deprecated_method}=", value)
-            Koala::HTTPService.http_options[parameter].should == value
+            expect(Koala::HTTPService.http_options[parameter]).to eq(value)
           end
 
           it "generates a deprecation warning" do
-            Koala::Utils.should_receive(:deprecate)
+            expect(Koala::Utils).to receive(:deprecate)
             Koala::HTTPService.send(:"#{deprecated_method}=", 2)
           end
         end
@@ -394,15 +394,15 @@ describe Koala::HTTPService do
           it "reads http_options[:ssl][:#{deprecated_method}] if http_options[:ssl]" do
             value = "foo"
             Koala::HTTPService.http_options[:ssl] = {deprecated_method => value}
-            Koala::HTTPService.send(deprecated_method).should == value
+            expect(Koala::HTTPService.send(deprecated_method)).to eq(value)
           end
 
           it "returns nil if http_options[:ssl] is not defined" do
-            Koala::HTTPService.send(deprecated_method).should be_nil
+            expect(Koala::HTTPService.send(deprecated_method)).to be_nil
           end
 
           it "generates a deprecation warning" do
-            Koala::Utils.should_receive(:deprecate)
+            expect(Koala::Utils).to receive(:deprecate)
             Koala::HTTPService.send(deprecated_method)
           end
         end
@@ -412,25 +412,25 @@ describe Koala::HTTPService do
             Koala::HTTPService.http_options[:ssl] = nil
             value = "foo"
             Koala::HTTPService.send(:"#{deprecated_method}=", value)
-            Koala::HTTPService.http_options[:ssl].should
+            expect(Koala::HTTPService.http_options[:ssl]).to be_a(Hash)
           end
 
           it "writes to http_options[:ssl][:#{deprecated_method}]" do
             value = "foo"
             Koala::HTTPService.send(:"#{deprecated_method}=", value)
-            Koala::HTTPService.http_options[:ssl].should
-            Koala::HTTPService.http_options[:ssl][deprecated_method].should == value
+            expect(Koala::HTTPService.http_options[:ssl]).to be_a(Hash)
+            expect(Koala::HTTPService.http_options[:ssl][deprecated_method]).to eq(value)
           end
 
           it "does not redefine http_options[:ssl] if already defined" do
             hash = {:a => 2}
             Koala::HTTPService.http_options[:ssl] = hash
             Koala::HTTPService.send(:"#{deprecated_method}=", 3)
-            Koala::HTTPService.http_options[:ssl].should include(hash)
+            expect(Koala::HTTPService.http_options[:ssl]).to include(hash)
           end
 
           it "generates a deprecation warning" do
-            Koala::Utils.should_receive(:deprecate)
+            expect(Koala::Utils).to receive(:deprecate)
             Koala::HTTPService.send(:"#{deprecated_method}=", 2)
           end
         end
@@ -445,21 +445,21 @@ describe Koala::HTTPService do
         @mock_http_response = double("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
 
         @mock_connection = double("Faraday connection")
-        @mock_connection.stub(:get).and_return(@mock_http_response)
-        @mock_connection.stub(:post).and_return(@mock_http_response)
-        Faraday.stub(:new).and_return(@mock_connection)
+        allow(@mock_connection).to receive(:get).and_return(@mock_http_response)
+        allow(@mock_connection).to receive(:post).and_return(@mock_http_response)
+        allow(Faraday).to receive(:new).and_return(@mock_connection)
       end
 
       describe ":typhoeus_options" do
         it "merges any typhoeus_options into options" do
           typhoeus_options = {:proxy => "http://user:password@example.org/" }
-          Faraday.should_receive(:new).with(anything, hash_including(typhoeus_options)).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_including(typhoeus_options)).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
         end
 
         it "deletes the typhoeus_options key" do
           typhoeus_options = {:proxy => "http://user:password@example.org/" }
-          Faraday.should_receive(:new).with(anything, hash_not_including(:typhoeus_options => typhoeus_options)).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_not_including(:typhoeus_options => typhoeus_options)).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
         end
       end
@@ -467,13 +467,13 @@ describe Koala::HTTPService do
       describe ":ca_path" do
         it "sets any ca_path into options[:ssl]" do
           ca_path = :foo
-          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_path => ca_path))).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_path => ca_path))).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
         end
 
         it "deletes the ca_path key" do
           ca_path = :foo
-          Faraday.should_receive(:new).with(anything, hash_not_including(:ca_path => ca_path)).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_not_including(:ca_path => ca_path)).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
         end
       end
@@ -481,13 +481,13 @@ describe Koala::HTTPService do
       describe ":ca_file" do
         it "sets any ca_file into options[:ssl]" do
           ca_file = :foo
-          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_file => ca_file))).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_file => ca_file))).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
         end
 
         it "deletes the ca_file key" do
           ca_file = :foo
-          Faraday.should_receive(:new).with(anything, hash_not_including(:ca_file => ca_file)).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_not_including(:ca_file => ca_file)).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
         end
       end
@@ -495,13 +495,13 @@ describe Koala::HTTPService do
       describe ":verify_mode" do
         it "sets any verify_mode into options[:ssl]" do
           verify_mode = :foo
-          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:verify_mode => verify_mode))).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_including(:ssl => hash_including(:verify_mode => verify_mode))).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
         end
 
         it "deletes the verify_mode key" do
           verify_mode = :foo
-          Faraday.should_receive(:new).with(anything, hash_not_including(:verify_mode => verify_mode)).and_return(@mock_connection)
+          expect(Faraday).to receive(:new).with(anything, hash_not_including(:verify_mode => verify_mode)).and_return(@mock_connection)
           Koala::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
         end
       end