koala 1.11.1 → 2.0.0rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44887034b965ebbac49df6389117a3482918a215
-  data.tar.gz: 0e49cb623168d97da705aed316df81eb7a1dfebf
+  metadata.gz: 01598f2db0d23da8cbd84470160a9cba1084716f
+  data.tar.gz: a6f806ca786838e52ed397491302183e9d9baf49
 SHA512:
-  metadata.gz: 27f94913be28e196b58ff0934611007025f9374b0f08c3925dc6ce66670493f6dc06c7c6907c22b437765215435fd177b7f858c288466dfa1aa424eae3107344
-  data.tar.gz: f58743aef73431532ca4a8e206ede00abaf43522b5c1e6638f4cd8e4d2a74277661ca1a20f2911fb3aac57309879c10be66561e5b5d30dbbdd5c07664da564f9
+  metadata.gz: b37d3eeff4c01d7258cbbe100d2a782c21b2e67a9f0e15d8d42beb896a5b20480757b8a8aab7527255180a635099ac84f7a96057f687d989c0f1103c1bfcb7f3
+  data.tar.gz: 57a67e64453cfb7b5778e5b87d1dfeebbcdb4f9dcad369e0c1a5d6e83915531feaa26e72a6eb3671becca3dbdd516cc94b0eec29d4b30455134098073d9e0e0a

data/changelog.md

@@ -1,5 +1,24 @@
+v2.0.0
+======
+
+Koala 2.0 is not a major refactor, but rather a set of small, mostly internal
+refactors:
+
+* BatchAPI now reads both access token and app secret from the original API
+  instance (thanks, lukeasrodgers!)
+* Remove legacy interfaces (deprecated since 1.2)
+  * API#search (which Facebook doesn't support anymore)
+  * TestUser#graph\_api and RealtimeUpdates#graph\_api (use #api instead)
+  * Various HTTP options (see diff for deprecation warnings/upgrade
+    instructions for each method)
+  * NetHTTPService and TyphoeusHTTPService (see diff for deprecation
+    warnings/upgrade instructions)
+  * OAuth methods for dealing with session tokens (which Facebook stopped
+    providing)
+  * OAuth#get\_user\_from\_cookies (use get\_user\_info\_from\_cookies instead)
+
 v.1.11.1
-=======
+========
 
 Bug fixes:
 * Properly import Facebook error attributes (thanks, isra17!)
@@ -14,7 +33,7 @@ Updated features:
 
 Bug fixes:
 * Fixed bug in GraphCollection URL versioning (thanks, deviousdodo and jankowy!)
-* TestUsers#create_network now properly handles options (thanks, crx!)
+* TestUsers#create\_network now properly handles options (thanks, crx!)
 
 Documentation improvements:
 * Updated gem version (thanks, thomasklemm!)

data/lib/koala.rb

@@ -53,18 +53,10 @@ module Koala
   end
 
   # @private
-  # For current HTTPServices, switch the service as expected.
-  # For deprecated services (Typhoeus and Net::HTTP), print a warning and set the default Faraday adapter appropriately.
+  # Switch the HTTP service -- mostly used for testing.
   def self.http_service=(service)
-    if service.respond_to?(:deprecated_interface)
-      # if this is a deprecated module, support the old interface
-      # by changing the default adapter so the right library is used
-      # we continue to use the single HTTPService module for everything
-      service.deprecated_interface
-    else
-      # if it's a real http_service, use it
-      @http_service = service
-    end
+    # if it's a real http_service, use it
+    @http_service = service
   end
 
   # An convenenient alias to Koala.http_service.make_request.

data/lib/koala/api.rb

@@ -109,6 +109,4 @@ module Koala
   end
 end
 
-require 'koala/api/graph_batch_api'
-# legacy support for old pre-1.2 API interfaces
-require 'koala/api/legacy'
+require 'koala/api/graph_batch_api'

data/lib/koala/api/graph_api.rb

@@ -300,20 +300,6 @@ module Koala
         graph_call("#{id}/likes", {}, "delete", options, &block)
       end
 
-      # Search for a given query among visible Facebook objects.
-      # See {http://developers.facebook.com/docs/reference/api/#searching Facebook documentation} for more information.
-      #
-      # @param search_terms the query to search for
-      # @param args additional arguments, such as type, fields, etc.
-      # @param options (see #get_object)
-      # @param block (see Koala::Facebook::API#api)
-      #
-      # @return [Koala::Facebook::API::GraphCollection] an array of search results
-      def search(search_terms, args = {}, options = {}, &block)
-        args.merge!({:q => search_terms}) unless search_terms.nil?
-        graph_call("search", args, "get", options, &block)
-      end
-
       # Convenience Methods
       # In general, we're trying to avoid adding convenience methods to Koala
       # except to support cases where the Facebook API requires non-standard input
@@ -469,7 +455,7 @@ module Koala
       # @return an array of results from your batch calls (as if you'd made them individually),
       #         arranged in the same order they're made.
       def batch(http_options = {}, &block)
-        batch_client = GraphBatchAPI.new(access_token, self)
+        batch_client = GraphBatchAPI.new(self)
         if block
           yield batch_client
           batch_client.execute(http_options)

data/lib/koala/api/graph_batch_api.rb

@@ -9,8 +9,8 @@ module Koala
       include GraphAPIMethods
 
       attr_reader :original_api
-      def initialize(access_token, api)
-        super(access_token)
+      def initialize(api)
+        super(api.access_token, api.app_secret)
         @original_api = api
       end
 

data/lib/koala/http_service.rb

@@ -81,7 +81,7 @@ module Koala
       params = args.inject({}) {|hash, kv| hash[kv.first.to_s] = kv.last.is_a?(UploadableIO) ? kv.last.to_upload_io : kv.last; hash}
 
       # figure out our options for this request
-      request_options = {:params => (verb == "get" ? params : {})}.merge(http_options || {}).merge(process_options(options))
+      request_options = {:params => (verb == "get" ? params : {})}.merge(http_options || {}).merge(options)
       request_options[:use_ssl] = true if args["access_token"] # require https if there's a token
       if request_options[:use_ssl]
         ssl = (request_options[:ssl] ||= {})
@@ -135,128 +135,11 @@ module Koala
       !!(match && match[1])
     end
 
-    # deprecations
-    # not elegant or compact code, but temporary
-
-    # @private
-    def self.always_use_ssl
-      Koala::Utils.deprecate("HTTPService.always_use_ssl is now HTTPService.http_options[:use_ssl]; always_use_ssl will be removed in a future version.")
-      http_options[:use_ssl]
-    end
-
-    # @private
-    def self.always_use_ssl=(value)
-      Koala::Utils.deprecate("HTTPService.always_use_ssl is now HTTPService.http_options[:use_ssl]; always_use_ssl will be removed in a future version.")
-      http_options[:use_ssl] = value
-    end
-
-    # @private
-    def self.timeout
-      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
-      http_options[:timeout]
-    end
-
-    # @private
-    def self.timeout=(value)
-      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
-      http_options[:timeout] = value
-    end
-
-    # @private
-    def self.proxy
-      Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
-      http_options[:proxy]
-    end
-
-    # @private
-    def self.proxy=(value)
-      Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
-      http_options[:proxy] = value
-    end
-
-    # @private
-    def self.ca_path
-      Koala::Utils.deprecate("HTTPService.ca_path is now (HTTPService.http_options[:ssl] ||= {})[:ca_path]; .ca_path will be removed in a future version.")
-      (http_options[:ssl] || {})[:ca_path]
-    end
-
-    # @private
-    def self.ca_path=(value)
-      Koala::Utils.deprecate("HTTPService.ca_path is now (HTTPService.http_options[:ssl] ||= {})[:ca_path]; .ca_path will be removed in a future version.")
-      (http_options[:ssl] ||= {})[:ca_path] = value
-    end
-
-    # @private
-    def self.ca_file
-      Koala::Utils.deprecate("HTTPService.ca_file is now (HTTPService.http_options[:ssl] ||= {})[:ca_file]; .ca_file will be removed in a future version.")
-      (http_options[:ssl] || {})[:ca_file]
-    end
-
-    # @private
-    def self.ca_file=(value)
-      Koala::Utils.deprecate("HTTPService.ca_file is now (HTTPService.http_options[:ssl] ||= {})[:ca_file]; .ca_file will be removed in a future version.")
-      (http_options[:ssl] ||= {})[:ca_file] = value
-    end
-
-    # @private
-    def self.verify_mode
-      Koala::Utils.deprecate("HTTPService.verify_mode is now (HTTPService.http_options[:ssl] ||= {})[:verify_mode]; .verify_mode will be removed in a future version.")
-      (http_options[:ssl] || {})[:verify_mode]
-    end
-
-    # @private
-    def self.verify_mode=(value)
-      Koala::Utils.deprecate("HTTPService.verify_mode is now (HTTPService.http_options[:ssl] ||= {})[:verify_mode]; .verify_mode will be removed in a future version.")
-      (http_options[:ssl] ||= {})[:verify_mode] = value
-    end
-
     private
 
-    def self.process_options(options)
-      if typhoeus_options = options.delete(:typhoeus_options)
-        Koala::Utils.deprecate("typhoeus_options should now be included directly in the http_options hash.  Support for this key will be removed in a future version.")
-        options = options.merge(typhoeus_options)
-      end
-
-      if ca_file = options.delete(:ca_file)
-        Koala::Utils.deprecate("http_options[:ca_file] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:ca_file].  Support for this key will be removed in a future version.")
-        (options[:ssl] ||= {})[:ca_file] = ca_file
-      end
-
-      if ca_path = options.delete(:ca_path)
-        Koala::Utils.deprecate("http_options[:ca_path] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:ca_path].  Support for this key will be removed in a future version.")
-        (options[:ssl] ||= {})[:ca_path] = ca_path
-      end
-
-      if verify_mode = options.delete(:verify_mode)
-        Koala::Utils.deprecate("http_options[:verify_mode] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:verify_mode].  Support for this key will be removed in a future version.")
-        (options[:ssl] ||= {})[:verify_mode] = verify_mode
-      end
-
-      options
-    end
-
     def self.faraday_options(options)
       valid_options = [:request, :proxy, :ssl, :builder, :url, :parallel_manager, :params, :headers, :builder_class]
       Hash[ options.select { |key,value| valid_options.include?(key) } ]
     end
   end
-
-  # @private
-  module TyphoeusService
-    def self.deprecated_interface
-      # support old-style interface with a warning
-      Koala::Utils.deprecate("the TyphoeusService module is deprecated; to use Typhoeus, set Faraday.default_adapter = :typhoeus.  Enabling Typhoeus for all Faraday connections.")
-      Faraday.default_adapter = :typhoeus
-    end
-  end
-
-  # @private
-  module NetHTTPService
-    def self.deprecated_interface
-      # support old-style interface with a warning
-      Koala::Utils.deprecate("the NetHTTPService module is deprecated; to use Net::HTTP, set Faraday.default_adapter = :net_http.  Enabling Net::HTTP for all Faraday connections.")
-      Faraday.default_adapter = :net_http
-    end
-  end
 end

data/lib/koala/oauth.rb

@@ -40,26 +40,6 @@ module Koala
       end
       alias_method :get_user_info_from_cookie, :get_user_info_from_cookies
 
-      # Parses the cookie set Facebook's JavaScript SDK and returns only the user ID.
-      #
-      # @note (see #get_user_info_from_cookie)
-      #
-      # @param (see #get_user_info_from_cookie)
-      #
-      # @return the authenticated user's Facebook ID, or nil.
-      def get_user_from_cookies(cookies)
-        Koala::Utils.deprecate("Due to Facebook changes, you can only redeem an OAuth code once; it is therefore recommended not to use this method, as it will consume the code without providing you the access token. See https://developers.facebook.com/roadmap/completed-changes/#december-2012.")
-        if signed_cookie = cookies["fbsr_#{@app_id}"]
-          if components = parse_signed_request(signed_cookie)
-            components["user_id"]
-          end
-        elsif info = get_user_info_from_cookies(cookies)
-          # Parsing unsigned cookie
-          info["uid"]
-        end
-      end
-      alias_method :get_user_from_cookie, :get_user_from_cookies
-
       # URLs
 
       # Builds an OAuth URL, where users will be prompted to log in and for any desired permissions.
@@ -180,7 +160,6 @@ module Koala
         get_token_from_server({:code => code, :redirect_uri => options[:redirect_uri] || @oauth_callback_url}, false, options)
       end
 
-
       # Fetches the access token (ignoring expiration and other info) from Facebook.
       # Useful when you've received an OAuth code using the server-side authentication process.
       # @see get_access_token_info
@@ -272,41 +251,6 @@ module Koala
         envelope
       end
 
-      # Old session key code
-
-      # @deprecated Facebook no longer provides session keys.
-      def get_token_info_from_session_keys(sessions, options = {})
-        Koala::Utils.deprecate("Facebook no longer provides session keys. The relevant OAuth methods will be removed in the next release.")
-
-        # fetch the OAuth tokens from Facebook
-        response = fetch_token_string({
-          :type => 'client_cred',
-          :sessions => sessions.join(",")
-        }, true, "exchange_sessions", options)
-
-        # Facebook returns an empty body in certain error conditions
-        if response == ""
-          raise BadFacebookResponse.new(200, '', "get_token_from_session_key received an error (empty response body) for sessions #{sessions.inspect}!")
-        end
-
-        MultiJson.load(response)
-      end
-
-      # @deprecated (see #get_token_info_from_session_keys)
-      def get_tokens_from_session_keys(sessions, options = {})
-        # get the original hash results
-        results = get_token_info_from_session_keys(sessions, options)
-        # now recollect them as just the access tokens
-        results.collect { |r| r ? r["access_token"] : nil }
-      end
-
-      # @deprecated (see #get_token_info_from_session_keys)
-      def get_token_from_session_key(session, options = {})
-        # convenience method for a single key
-        # gets the overlaoded strings automatically
-        get_tokens_from_session_keys([session], options)[0]
-      end
-
       protected
 
       def get_token_from_server(args, post = false, options = {})

data/lib/koala/realtime_updates.rb

@@ -141,12 +141,6 @@ module Koala
       def subscription_path
         @subscription_path ||= "#{@app_id}/subscriptions"
       end
-
-      # @private
-      def graph_api
-        Koala::Utils.deprecate("the TestUsers.graph_api accessor is deprecated and will be removed in a future version; please use .api instead.")
-        @api
-      end
     end
   end
 end

data/lib/koala/test_users.rb

@@ -183,13 +183,6 @@ module Koala
       def test_user_accounts_path
         @test_user_accounts_path ||= "/#{@app_id}/accounts/test-users"
       end
-
-      # @private
-      # Legacy accessor for before GraphAPI was unified into API
-      def graph_api
-        Koala::Utils.deprecate("the TestUsers.graph_api accessor is deprecated and will be removed in a future version; please use .api instead.")
-        @api
-      end
     end # TestUserMethods
   end # Facebook
 end # Koala

data/lib/koala/version.rb

@@ -1,3 +1,3 @@
 module Koala
-  VERSION = "1.11.1"
+  VERSION = "2.0.0rc1"
 end

data/readme.md

@@ -65,7 +65,7 @@ Koala.config.api_version = "v2.0"
 
 The response of most requests is the JSON data returned from the Facebook servers as a Hash.
 
-When retrieving data that returns an array of results (for example, when calling `API#get_connections` or `API#search`)
+When retrieving data that returns an array of results (for example, when calling `API#get_connections`)
 a GraphCollection object will be returned, which makes it easy to page through the results:
 
 ```ruby

data/spec/cases/graph_api_batch_spec.rb

@@ -56,7 +56,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           @uploadable_io = double("UploadableIO 1")
 
           @batch_queue = []
-          allow(Koala::Facebook::GraphAPI).to receive(:batch_calls).and_return(@batch_queue)
+          allow(Koala::Facebook::API).to receive(:batch_calls).and_return(@batch_queue)
 
           allow(Koala::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
           allow(Koala::UploadableIO).to receive(:binary_content?).and_return(false)
@@ -245,7 +245,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           allow(@uploadable_io).to receive(:is_a?).with(Koala::UploadableIO).and_return(true)
 
           @batch_queue = []
-          allow(Koala::Facebook::GraphAPI).to receive(:batch_calls).and_return(@batch_queue)
+          allow(Koala::Facebook::API).to receive(:batch_calls).and_return(@batch_queue)
 
           @args[:method] = "post" # files are always post
         end
@@ -297,6 +297,19 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           end
         end
 
+        context 'with appsecret_proof and app_secret' do
+          it "includes the app_secret in the API call" do
+            access_token = "foo"
+            app_secret = "baz"
+            app_secret_digest = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), app_secret, access_token)
+            expect(Koala).to receive(:make_request).with(anything, hash_including("access_token" => access_token, "appsecret_proof" => app_secret_digest), anything, anything).and_return(@fake_response)
+            Koala::Facebook::API.new(access_token, app_secret).batch do |batch_api|
+              batch_api.get_object('me')
+              batch_api.get_object('me', {}, {'access_token' => 'bar'})
+            end
+          end
+        end
+
         it "sets args['batch'] to a json'd map of all the batch params" do
           access_token = "bar"
           op = Koala::Facebook::GraphBatchAPI::BatchOperation.new(:access_token => access_token, :method => :get, :url => "/")

data/spec/cases/http_service_spec.rb

@@ -401,170 +401,4 @@ describe Koala::HTTPService do
       expect(Koala::HTTPService.path_contains_api_version?('/anything')).to be false
     end
   end
-
-  describe "deprecated options" do
-    before :each do
-      allow(Koala::HTTPService).to receive(:http_options).and_return({})
-      @service = Koala.http_service
-    end
-
-    after :each do
-      Koala.http_service = @service
-    end
-
-    {
-      :timeout => :timeout,
-      :always_use_ssl => :use_ssl,
-      :proxy => :proxy
-    }.each_pair do |deprecated_method, parameter|
-      describe ".#{deprecated_method}" do
-        context "read" do
-          it "reads http_options[:#{parameter}]" do
-            value = "foo"
-            Koala::HTTPService.http_options[parameter] = value
-            expect(Koala::HTTPService.send(deprecated_method)).to eq(value)
-          end
-
-          it "generates a deprecation warning" do
-            expect(Koala::Utils).to receive(:deprecate)
-            Koala::HTTPService.send(deprecated_method)
-          end
-        end
-
-        context "write" do
-          it "writes to http_options[:#{parameter}]" do
-            Koala::HTTPService.http_options[parameter] = nil
-            value = "foo"
-            Koala::HTTPService.send(:"#{deprecated_method}=", value)
-            expect(Koala::HTTPService.http_options[parameter]).to eq(value)
-          end
-
-          it "generates a deprecation warning" do
-            expect(Koala::Utils).to receive(:deprecate)
-            Koala::HTTPService.send(:"#{deprecated_method}=", 2)
-          end
-        end
-      end
-    end
-
-    # ssl options
-    [:ca_path, :ca_file, :verify_mode].each do |deprecated_method|
-      describe ".#{deprecated_method}" do
-        context "read" do
-          it "reads http_options[:ssl][:#{deprecated_method}] if http_options[:ssl]" do
-            value = "foo"
-            Koala::HTTPService.http_options[:ssl] = {deprecated_method => value}
-            expect(Koala::HTTPService.send(deprecated_method)).to eq(value)
-          end
-
-          it "returns nil if http_options[:ssl] is not defined" do
-            expect(Koala::HTTPService.send(deprecated_method)).to be_nil
-          end
-
-          it "generates a deprecation warning" do
-            expect(Koala::Utils).to receive(:deprecate)
-            Koala::HTTPService.send(deprecated_method)
-          end
-        end
-
-        context "write" do
-          it "defines http_options[:ssl] if not defined" do
-            Koala::HTTPService.http_options[:ssl] = nil
-            value = "foo"
-            Koala::HTTPService.send(:"#{deprecated_method}=", value)
-            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)
-            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)
-            expect(Koala::HTTPService.http_options[:ssl]).to include(hash)
-          end
-
-          it "generates a deprecation warning" do
-            expect(Koala::Utils).to receive(:deprecate)
-            Koala::HTTPService.send(:"#{deprecated_method}=", 2)
-          end
-        end
-      end
-    end
-
-    describe "per-request options" do
-      before :each do
-        # Setup stubs for make_request to execute without exceptions
-        @mock_body = double('Typhoeus response body')
-        @mock_headers_hash = double({:value => "headers hash"})
-        @mock_http_response = double("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
-
-        @mock_connection = double("Faraday 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/" }
-          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/" }
-          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
-
-      describe ":ca_path" do
-        it "sets any ca_path into options[:ssl]" do
-          ca_path = :foo
-          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
-          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
-
-      describe ":ca_file" do
-        it "sets any ca_file into options[:ssl]" do
-          ca_file = :foo
-          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
-          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
-
-      describe ":verify_mode" do
-        it "sets any verify_mode into options[:ssl]" do
-          verify_mode = :foo
-          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
-          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
-    end
-  end
 end