koala 2.4.0 → 3.5.0

data/spec/cases/http_service_spec.rb

@@ -16,32 +16,31 @@ describe Koala::HTTPService do
   end
 
   describe "DEFAULT_MIDDLEWARE" do
-    before :each do
-      @builder = double("Faraday connection builder")
-      allow(@builder).to receive(:request)
-      allow(@builder).to receive(:adapter)
-      allow(@builder).to receive(:use)
-    end
+    class FakeBuilder
+      attr_reader :requests, :uses, :adapters
 
-    it "is defined" do
-      expect(Koala::HTTPService.const_defined?("DEFAULT_MIDDLEWARE")).to be_truthy
-    end
+      def use(arg)
+        @uses ||= []
+        @uses << arg
+      end
 
-    it "adds multipart" do
-      expect(@builder).to receive(:use).with(Koala::HTTPService::MultipartRequest)
-      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
-    end
+      def request(arg)
+        @requests ||= []
+        @requests << arg
+      end
 
-    it "adds url_encoded" do
-      expect(@builder).to receive(:request).with(:url_encoded)
-      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+      def adapter(arg)
+        @adapters ||= []
+        @adapters << arg
+      end
     end
 
-    it "uses the default adapter" do
-      adapter = :testing_now
-      allow(Faraday).to receive(:default_adapter).and_return(adapter)
-      expect(@builder).to receive(:adapter).with(adapter)
-      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    let(:builder) { FakeBuilder.new }
+
+    it "adds the right default middleware" do
+      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(builder)
+      expect(builder.requests).to eq([:multipart, :url_encoded])
+      expect(builder.adapters).to eq([Faraday.default_adapter])
     end
   end
 
@@ -52,10 +51,6 @@ describe Koala::HTTPService do
       expect(defaults[:graph_server]).to eq("graph.facebook.com")
     end
 
-    it "defines the rest server" do
-      expect(defaults[:rest_server]).to eq("api.facebook.com")
-    end
-
     it "defines the dialog host" do
       expect(defaults[:dialog_host]).to eq("www.facebook.com")
     end
@@ -73,86 +68,21 @@ describe Koala::HTTPService do
     end
   end
 
-  describe "server" do
-    describe "with no options" do
-      it "returns the REST server if options[:rest_api]" do
-        expect(Koala::HTTPService.server(:rest_api => true)).to eq(
-         "http://#{Koala.config.rest_server}"
-        )
-      end
-
-      it "returns the graph server if !options[:rest_api]" do
-        expect(Koala::HTTPService.server(:rest_api => false)).to eq(
-          "http://#{Koala.config.graph_server}"
-        )
-        expect(Koala::HTTPService.server({})).to eq(
-          "http://#{Koala.config.graph_server}"
-        )
-      end
-
-      context "with use_ssl" do
-        it "includes https" do
-          expect(Koala::HTTPService.server(use_ssl: true)).to eq(
-            "https://#{Koala.config.graph_server}"
-          )
-        end
-      end
-    end
-
-    describe "with options[:beta]" do
-      before :each do
-        @options = {:beta => true}
-      end
-
-      it "returns the beta REST server if options[:rest_api]" do
-        server = Koala::HTTPService.server(@options.merge(:rest_api => true))
-        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)
-        expect(server).to match(Regexp.new(Koala.config.graph_server.gsub(/\.facebook/, ".beta.facebook")))
-      end
-    end
-
-    describe "with options[:video]" do
-      before :each do
-        @options = {:video => true}
-      end
-
-      it "returns the REST video server if options[:rest_api]" do
-        server = Koala::HTTPService.server(@options.merge(:rest_api => true))
-        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)
-        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
       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'
-      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"
+      not_a_string = {not_a_string: 2}
 
       args = {
-        not_a_string => not_a_string,
-        string => string
+        :arg => not_a_string,
       }
 
       result = Koala::HTTPService.encode_params(args)
       expect(result.split('&').find do |key_and_val|
-        key_and_val.match("#{not_a_string}=#{val}")
+        key_and_val.match("arg=#{CGI.escape not_a_string.to_json}")
       end).to be_truthy
     end
 
@@ -185,244 +115,154 @@ describe Koala::HTTPService do
   end
 
   describe ".make_request" 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 "creating the Faraday connection" do
-      it "creates a Faraday connection using the server" do
-        server = "foo"
-        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
-        expect(Faraday).to receive(:new).with(anything, hash_including(http_options)).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get")
-      end
+    let(:mock_body) { "a body" }
+    let(:mock_headers_hash) { double(value: "headers hash") }
+    let(:mock_http_response) { double("Faraday Response", status: 200, headers: mock_headers_hash, body: mock_body) }
 
-      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
-        expect(Faraday).to receive(:new).with(anything, hash_not_including(http_options)).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get")
-      end
+    let(:verb) { "get" }
+    let(:options) { {} }
+    let(:args) { {"an" => :arg } }
+    let(:request) { Koala::HTTPService::Request.new(path: "/foo", verb: verb, args: args, options: options) }
 
-      it "merges any provided options into the request params" do
-        options = {:proxy => "http://user:password@example.org/", :request => { :timeout => 3 }}
-        expect(Faraday).to receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get", options)
+    shared_examples_for :making_a_request do
+      before :each do
+        allow_any_instance_of(Faraday::Connection).to receive(:get).and_return(mock_http_response)
+        allow_any_instance_of(Faraday::Connection).to receive(:post).and_return(mock_http_response)
       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 }}
-        allow(Koala::HTTPService).to receive(:http_options).and_return(http_options)
+      it "makes a Faraday request appropriately" do
+        expect_any_instance_of(Faraday::Connection).to receive(verb) do |instance, path, post_params|
+          expect(path).to eq(request.path)
+          expect(post_params).to eq(request.post_args)
+          expect(instance.params).to eq(request.options[:params])
+          expect(instance.url_prefix).to eq(URI.parse(request.server))
 
-        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
+          mock_http_response
+        end
 
-      it "forces use_ssl to true if an access token is present" do
-        options = {:use_ssl => false}
-        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)
+        Koala::HTTPService.make_request(request)
       end
 
-      it "defaults verify to true if use_ssl is true" do
-        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 "returns the right response" do
+        response = Koala::HTTPService.make_request(request)
+        expect(response.status).to eq(mock_http_response.status)
+        expect(response.headers).to eq(mock_http_response.headers)
+        expect(response.body).to eq(mock_http_response.body)
 
-      it "allows you to set other verify modes if you really want" do
-        options = {:ssl => {:verify => :foo}}
-        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 a json object when provided a format option for post requests" do
-        # Unstub the now somewhat regrettable stubbing above
-        allow(Faraday).to receive(:new).and_call_original
+      it "logs verb, url and params to debug" do
+        log_message = "#{verb.upcase}: #{request.path} params: #{request.raw_args.inspect}"
+        expect(Koala::Utils.logger).to receive(:debug).with("STARTED => #{log_message}")
+        expect(Koala::Utils.logger).to receive(:debug).with("FINISHED => #{log_message}")
 
-        mock_request_klass = Class.new do
-          attr_accessor :path, :body, :headers, :status
-          def initialize
-            @headers = {}
-          end
-        end
+        Koala::HTTPService.make_request(request)
+      end
+    end
 
-        mock_request = mock_request_klass.new
-        allow_any_instance_of(Faraday::Connection).to receive(:post).and_yield(mock_request)
+    context "for gets" do
+      it_should_behave_like :making_a_request
+    end
 
-        path = "California"
-        args = {:a => 2, :c => "3"}
+    # we don't need to test delete and put since those are translated into posts
+    context "for posts" do
+      let(:verb) { "post" }
 
-        Koala::HTTPService.make_request(path, args, "post", format: :json)
+      it_should_behave_like :making_a_request
+    end
 
-        expect(mock_request.path).to eq(path)
-        expect(mock_request.headers).to eq("Content-Type" => "application/json")
-        expect(mock_request.body).to eq(args.to_json)
-      end
+    context "for JSON requests" do
+      let(:verb) { "post" }
+      let(:options) { {format: :json} }
 
-      it "calls server with the composite options" do
-        options = {:a => 2, :c => "3"}
-        http_options = {:a => :a}
-        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 "makes a Faraday request appropriately" do
+        expect_any_instance_of(Faraday::Connection).to receive(verb) do |instance, path, &block|
+          faraday_request = Faraday::Request.new
+          faraday_request.headers = {}
+          block.call(faraday_request)
+          expect(faraday_request.path).to eq(request.path)
+          expect(faraday_request.body).to eq(request.post_args.to_json)
+          expect(faraday_request.headers).to include("Content-Type" => "application/json")
 
-      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)
-        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
+          mock_http_response
+        end
 
-      it "uses the defined HTTPService.faraday_middleware block if defined" do
-        block = Proc.new { }
-        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")
+        Koala::HTTPService.make_request(request)
       end
     end
 
+    it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
+      block = Proc.new { |builder|
+        builder.request :multipart
+        builder.request :url_encoded
+      }
+      stub_const("Koala::HTTPService::DEFAULT_MIDDLEWARE", block)
+      allow(Koala::HTTPService).to receive(:faraday_middleware).and_return(nil)
 
-    context "with API versions" do
-      it "adds a version if specified by Koala.config" do
-        expect(Koala.config).to receive(:api_version).and_return("v11")
-        expect(@mock_connection).to receive(:get).with("/v11/anything", anything)
-        Koala::HTTPService.make_request("anything", {}, "get")
+      expect_any_instance_of(Faraday::Connection).to receive(:get) do |instance|
+        expect(instance.builder.handlers).to eq([
+          Faraday::Multipart::Middleware,
+          Faraday::Request::UrlEncoded,
+        ])
+        mock_http_response
       end
 
-      it "prefers a version set in http_options" do
-        allow(Koala.config).to receive(:api_version).and_return("v11")
-        allow(Koala::HTTPService).to receive(:http_options).and_return({ api_version: 'v12' })
-        expect(@mock_connection).to receive(:get).with("/v12/anything", anything)
-        Koala::HTTPService.make_request("anything", {}, "get")
-      end
+      Koala::HTTPService.make_request(request)
+    end
 
-      it "doesn't add double slashes to the path" do
-        allow(Koala::HTTPService).to receive(:http_options).and_return({ api_version: 'v12' })
-        expect(@mock_connection).to receive(:get).with("/v12/anything", anything)
-        Koala::HTTPService.make_request("/anything", {}, "get")
-      end
+    it "uses the defined HTTPService.faraday_middleware block if defined" do
+      block = Proc.new { |builder|
+        builder.request :multipart
+        builder.request :url_encoded
+      }
+      expect(Koala::HTTPService).to receive(:faraday_middleware).and_return(block)
 
-      it "doesn't add a version if the path already contains one" do
-        expect(Koala.config).to receive(:api_version).and_return("v11")
-        expect(@mock_connection).to receive(:get).with("/v12/anything", anything)
-        Koala::HTTPService.make_request("/v12/anything", {}, "get")
+      expect_any_instance_of(Faraday::Connection).to receive(:get) do |instance|
+        expect(instance.builder.handlers).to eq([
+          Faraday::Multipart::Middleware,
+          Faraday::Request::UrlEncoded,
+        ])
+        mock_http_response
       end
-    end
 
-    it "makes a POST request if the verb isn't get" do
-      expect(@mock_connection).to receive(:post).and_return(@mock_http_response)
-      Koala::HTTPService.make_request("anything", {}, "anything")
+      Koala::HTTPService.make_request(request)
     end
 
-    it "includes the verb in the body if the verb isn't get" do
-      verb = "eat"
-      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
-      expect(@mock_connection).to receive(:get).and_return(@mock_http_response)
-      Koala::HTTPService.make_request("anything", {}, "get")
-    end
+    context 'log_tokens configuration' do
+      let(:args) { { "an" => :arg, "access_token" => "myvisbleaccesstoken" } }
 
-    describe "for GETs" 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}
-        expect(Faraday).to receive(:new).with(anything, hash_including(:params => args)).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", args, "get")
+      before(:each) do
+        allow_any_instance_of(Faraday::Connection).to receive(:get) { double(status: '200', body: 'ok', headers: {}) }
       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}
-        expect(@mock_connection).to receive(:get).with(anything, {}).and_return(@mock_http_response)
-        Koala::HTTPService.make_request("anything", args, "get")
-      end
+      it 'logs tokens' do
+        allow(Koala.config).to receive(:mask_tokens) { false }
 
-      it "logs verb, url and params to debug" do
-        args = {"a" => :b, "c" => 3}
-        log_message_stem = "GET: anything params: "
-        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
-          expect(log_message).to include(log_message_stem)
-          expect(log_message.match(/\{.*\}/)).not_to be_nil
-        end
+        expect(Koala::Utils).to receive(:debug).with('STARTED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleaccesstoken"}')
+        expect(Koala::Utils).to receive(:debug).with('FINISHED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleaccesstoken"}')
 
-        Koala::HTTPService.make_request("anything", args, "get")
+        Koala::HTTPService.make_request(request)
       end
-    end
 
-    describe "for POSTs" 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}
-        expect(@mock_connection).to receive(:post).with(anything, hash_including(args)).and_return(@mock_http_response)
-        Koala::HTTPService.make_request("anything", args, "post")
-      end
+      it 'doesnt log tokens' do
+        allow(Koala.config).to receive(:mask_tokens) { true }
 
-      it "turns any UploadableIOs to UploadIOs" 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")
-        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
+        expect(Koala::Utils).to receive(:debug).with('STARTED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleac*****token"}')
+        expect(Koala::Utils).to receive(:debug).with('FINISHED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleac*****token"}')
 
-      it "logs verb, url and params to debug" do
-        args = {"a" => :b, "c" => 3}
-        log_message_stem = "POST: anything params: "
-        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
-          expect(log_message).to include(log_message_stem)
-          expect(log_message.match(/\{.*\}/)).not_to be_nil
-        end
-        Koala::HTTPService.make_request("anything", args, "post")
+        Koala::HTTPService.make_request(request)
       end
-    end
-  end
 
-  describe ".path_contains_api_version?" do
-    it "works when the path is prefixed by a slash" do
-      expect(Koala::HTTPService.path_contains_api_version?('/v2.1/anything')).to be true
-    end
+      it 'hides the token for the debug_token api endpoint' do
+        request = Koala::HTTPService::Request.new(path: "/debug_token", verb: verb, args: { input_token: 'myvisibleaccesstoken', 'access_token' => 'myvisibleaccesstoken' }, options: options)
 
-    it "works when the path is not prefixed by a slash" do
-      expect(Koala::HTTPService.path_contains_api_version?('v2.1/anything')).to be true
-    end
+        allow(Koala.config).to receive(:mask_tokens) { true }
 
-    it "works with versions without a ." do
-      expect(Koala::HTTPService.path_contains_api_version?('v21/anything')).to be true
-    end
+        expect(Koala::Utils).to receive(:debug).with('STARTED => GET: /debug_token params: {"input_token"=>"myvisiblea*****token", "access_token"=>"myvisiblea*****token"}')
+        expect(Koala::Utils).to receive(:debug).with('FINISHED => GET: /debug_token params: {"input_token"=>"myvisiblea*****token", "access_token"=>"myvisiblea*****token"}')
 
-    it "returns nil for paths without a version" do
-      expect(Koala::HTTPService.path_contains_api_version?('/anything')).to be false
+        Koala::HTTPService.make_request(request)
+      end
     end
   end
 end

data/spec/cases/koala_spec.rb

@@ -19,16 +19,19 @@ describe Koala do
       verb = "get"
       options = {:c => :d}
 
-      expect(Koala.http_service).to receive(:make_request).with(path, args, verb, options)
+      expect(Koala.http_service).to receive(:make_request) do |request|
+        expect(request.raw_path).to eq(path)
+        expect(request.raw_args).to eq(args)
+        expect(request.raw_verb).to eq(verb)
+        expect(request.raw_options).to eq(options)
+      end
       Koala.make_request(path, args, verb, options)
     end
   end
 
   describe ".configure" do
     it "yields a configurable object" do
-      expect {
-        Koala.configure {|c| c.foo = "bar"}
-      }.not_to raise_exception
+      Koala.configure {|c| expect(c).to be_a(Koala::Configuration)}
     end
 
     it "caches the config (singleton)" do
@@ -51,5 +54,4 @@ describe Koala do
       expect(Koala.config.graph_server).to eq("some-new.graph_server.com")
     end
   end
-
 end

data/spec/cases/oauth_spec.rb

@@ -53,6 +53,45 @@ describe "Koala::Facebook::OAuth" do
              @oauth.app_secret == @secret &&
              @oauth.oauth_callback_url == nil).to be_truthy
     end
+
+    context "with global defaults" do
+      let(:app_id) { :app_id }
+      let(:app_secret) { :app_secret }
+      let(:oauth_callback_url) { :oauth_callback_url }
+
+      before :each do
+        Koala.configure do |config|
+          config.app_id = app_id
+          config.app_secret = app_secret
+          config.oauth_callback_url = oauth_callback_url
+        end
+      end
+
+      it "defaults to the configured data if not otherwise provided" do
+        oauth = Koala::Facebook::OAuth.new
+        expect(oauth.app_id).to eq(app_id)
+        expect(oauth.app_secret).to eq(app_secret)
+        expect(oauth.oauth_callback_url).to eq(oauth_callback_url)
+      end
+
+      it "lets you override app_id" do
+        other_value = :another_id
+        oauth = Koala::Facebook::OAuth.new(other_value)
+        expect(oauth.app_id).to eq(other_value)
+      end
+
+      it "lets you override secret" do
+        other_value = :another_secret
+        oauth = Koala::Facebook::OAuth.new(nil, other_value)
+        expect(oauth.app_secret).to eq(other_value)
+      end
+
+      it "lets you override app_id" do
+        other_value = :another_token
+        oauth = Koala::Facebook::OAuth.new(nil, nil, other_value)
+        expect(oauth.oauth_callback_url).to eq(other_value)
+      end
+    end
   end
 
   describe "for cookie parsing" do
@@ -401,7 +440,7 @@ describe "Koala::Facebook::OAuth" do
           allow(Koala).to receive(:make_request).and_return(
             Koala::HTTPService::Response.new(
               200,
-              MultiJson.dump(result),
+              JSON.dump(result),
               {}
             )
           )
@@ -584,7 +623,7 @@ 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
-        allow(MultiJson).to receive(:load).and_return("algorithm" => "my fun algorithm")
+        allow(JSON).to receive(:parse).and_return("algorithm" => "my fun algorithm")
         expect { @oauth.parse_signed_request(@signed_params) }.to raise_error(Koala::Facebook::OAuthSignatureError)
       end