koala 2.5.0 → 3.0.0.beta1

data/spec/cases/http_service_spec.rb

@@ -16,32 +16,32 @@ 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([:url_encoded])
+      expect(builder.uses).to eq([Koala::HTTPService::MultipartRequest])
+      expect(builder.adapters).to eq([Faraday.default_adapter])
     end
   end
 
@@ -52,10 +52,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 +69,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(JSON).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 +116,119 @@ 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
+    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) }
 
-    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
-
-      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(:request) { Koala::HTTPService::Request.new(path: "/foo", verb: verb, args: {"an" => :arg}, 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)
-      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)
-
-        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}
-        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
-        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}}
-        expect(Faraday).to receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "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 "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 "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))
 
-        mock_request_klass = Class.new do
-          attr_accessor :path, :body, :headers, :status
-          def initialize
-            @headers = {}
-          end
+          mock_http_response
         end
 
-        mock_request = mock_request_klass.new
-        allow_any_instance_of(Faraday::Connection).to receive(:post).and_yield(mock_request)
-
-        path = "California"
-        args = {:a => 2, :c => "3"}
-
-        Koala::HTTPService.make_request(path, args, "post", format: :json)
-
-        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
-
-      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)
+        Koala::HTTPService.make_request(request)
       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)
-        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 { }
-        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 "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)
 
-    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")
       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
-
-      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 "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(log_message)
 
-      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")
+        Koala::HTTPService.make_request(request)
       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")
+    context "for gets" do
+      it_should_behave_like :making_a_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
+    # we don't need to test delete and put since those are translated into posts
+    context "for posts" do
+      let(:verb) { "post" }
 
-    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")
+      it_should_behave_like :making_a_request
     end
 
-    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")
-      end
+    context "for JSON requests" do
+      let(:verb) { "post" }
+      let(:options) { {format: :json} }
 
-      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 "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 "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
+          mock_http_response
         end
 
-        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 "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
+    it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
+      block = Proc.new { |builder|
+        builder.use Koala::HTTPService::MultipartRequest
+        builder.request :url_encoded
+        builder.use Koala::HTTPService::MultipartRequest
+      }
+      stub_const("Koala::HTTPService::DEFAULT_MIDDLEWARE", block)
+      allow(Koala::HTTPService).to receive(:faraday_middleware).and_return(nil)
 
-      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")
+      expect_any_instance_of(Faraday::Connection).to receive(:get) do |instance|
+        expect(instance.builder.handlers).to eq([
+          Koala::HTTPService::MultipartRequest,
+          Faraday::Request::UrlEncoded,
+          Koala::HTTPService::MultipartRequest
+        ])
+        mock_http_response
       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
+      Koala::HTTPService.make_request(request)
     end
 
-    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
+    it "uses the defined HTTPService.faraday_middleware block if defined" do
+      block = Proc.new { |builder|
+        builder.use Koala::HTTPService::MultipartRequest
+        builder.request :url_encoded
+        builder.use Koala::HTTPService::MultipartRequest
+      }
+      expect(Koala::HTTPService).to receive(:faraday_middleware).and_return(block)
 
-    it "works with versions without a ." do
-      expect(Koala::HTTPService.path_contains_api_version?('v21/anything')).to be true
-    end
+      expect_any_instance_of(Faraday::Connection).to receive(:get) do |instance|
+        expect(instance.builder.handlers).to eq([
+          Koala::HTTPService::MultipartRequest,
+          Faraday::Request::UrlEncoded,
+          Koala::HTTPService::MultipartRequest
+        ])
+        mock_http_response
+      end
 
-    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

data/spec/cases/koala_spec.rb

@@ -19,7 +19,12 @@ 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

data/spec/cases/oauth_spec.rb

@@ -584,7 +584,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(JSON).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
 

data/spec/cases/test_users_spec.rb

@@ -265,7 +265,10 @@ describe "Koala::Facebook::TestUsers" do
         options = {:some_http_option => true}
         # should come twice, once for each user
         @stubbed = true
-        expect(Koala.http_service).to receive(:make_request).with(anything, anything, anything, options).twice.and_return(Koala::HTTPService::Response.new(200, "{}", {}))
+        expect(Koala.http_service).to receive(:make_request).twice do |request|
+          expect(request.raw_options).to eq(options)
+          Koala::HTTPService::Response.new(200, "{}", {})
+        end
         @test_users.befriend(@user1, @user2, options)
       end
     end