koala 1.1.0 → 1.2.0beta1

data/spec/cases/graph_api_spec.rb

@@ -1,11 +1,28 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::GraphAPI" do
-  include LiveTestingDataHelper
-  
+  describe "class consolidation" do
+    before :each do
+      Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
+    end
+
+    it "still allows you to instantiate a GraphAndRestAPI object" do
+      api = Koala::Facebook::GraphAPI.new("token").should be_a(Koala::Facebook::GraphAPI)
+    end
+
+    it "ultimately creates an API object" do
+      api = Koala::Facebook::GraphAPI.new("token").should be_a(Koala::Facebook::API)
+    end
+
+    it "fires a depreciation warning" do
+      Koala::Utils.should_receive(:deprecate)
+      api = Koala::Facebook::GraphAPI.new("token")
+    end
+  end
+
   context "with an access token" do
     before :each do
-      @api = Koala::Facebook::GraphAPI.new(@token)
+      @api = Koala::Facebook::API.new(@token)
     end
 
     it_should_behave_like "Koala GraphAPI"
@@ -15,7 +32,7 @@ describe "Koala::Facebook::GraphAPI" do
 
   context "without an access token" do
     before :each do
-      @api = Koala::Facebook::GraphAPI.new
+      @api = Koala::Facebook::API.new
     end
 
     it_should_behave_like "Koala GraphAPI"

data/spec/cases/http_service_spec.rb

@@ -0,0 +1,446 @@
+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=)
+  end
+
+  it "has an http_options accessor" do
+    Koala::HTTPService.should respond_to(:http_options)
+    Koala::HTTPService.should respond_to(:http_options=)
+  end
+  
+  it "sets http_options to {} by default" do
+    Koala::HTTPService.http_options.should == {}
+  end
+
+  describe "DEFAULT_MIDDLEWARE" do
+    before :each do
+      @builder = stub("Faraday connection builder")
+      @builder.stub(:request)
+      @builder.stub(:adapter)
+    end
+
+    it "is defined" do
+      Koala::HTTPService.const_defined?("DEFAULT_MIDDLEWARE").should be_true
+    end
+
+    it "adds multipart" do
+      @builder.should_receive(:request).with(:multipart)
+      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+
+    it "adds url_encoded" do
+      @builder.should_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)
+      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    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::Facebook::REST_SERVER)
+      end
+
+      it "returns the graph server if !options[:rest_api]" do
+        Koala::HTTPService.server(:rest_api => false).should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER)
+        Koala::HTTPService.server({}).should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER)
+      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))
+        server.should =~ Regexp.new("beta.#{Koala::Facebook::REST_SERVER}")
+      end
+
+      it "returns the beta rest server if !options[:rest_api]" do
+        server = Koala::HTTPService.server(@options)
+        server.should =~ Regexp.new("beta.#{Koala::Facebook::GRAPH_SERVER}")
+      end
+    end
+
+    describe "with options[:video]" do
+      before :each do
+        @options = {:video => true}
+      end
+
+      it "should return the REST video server if options[:rest_api]" do
+        server = Koala::HTTPService.server(@options.merge(:rest_api => true))
+        server.should =~ Regexp.new(Koala::Facebook::REST_SERVER.gsub(/\.facebook/, "-video.facebook"))
+      end
+
+      it "should return the graph video server if !options[:rest_api]" do
+        server = Koala::HTTPService.server(@options)
+        server.should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER.gsub(/\.facebook/, "-video.facebook"))
+      end
+    end
+  end
+
+  describe "#encode_params" do
+    it "should return an empty string if param_hash evaluates to false" do
+      Koala::HTTPService.encode_params(nil).should == ''
+    end
+
+    it "should convert 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(:encode).with(not_a_string).and_return(val)
+
+      string = "hi"
+
+      args = {
+        not_a_string => not_a_string,
+        string => string
+      }
+
+      result = Koala::HTTPService.encode_params(args)
+      result.split('&').find do |key_and_val|
+        key_and_val.match("#{not_a_string}=#{val}")
+      end.should be_true
+    end
+
+    it "should escape all values" do
+      args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
+
+      result = Koala::HTTPService.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        val.should == CGI.escape(args[key])
+      end
+    end
+
+    it "should convert all keys to Strings" do
+      args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
+
+      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
+      end
+    end
+  end
+
+  describe "#make_request" do
+    before :each do
+      # Setup stubs for make_request to execute without exceptions
+      @mock_body = stub('Typhoeus response body')
+      @mock_headers_hash = stub({:value => "headers hash"})
+      @mock_http_response = stub("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
+
+      @mock_connection = stub("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)
+    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)
+        Koala::HTTPService.make_request("anything", {}, "anything")
+      end
+
+      it "merges Koala::HTTPService.http_options into the request params" do
+        http_options = {:a => 2, :c => "3"}
+        Koala::HTTPService.http_options = http_options
+        Faraday.should_receive(:new).with(anything, hash_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 = {:a => 2, :c => "3"}
+        Faraday.should_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 = {:a => 2, :c => "3"}
+        http_options = {:a => :a}
+        Koala::HTTPService.stub(:http_options).and_return(http_options)
+
+        Faraday.should_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(:use_ssl => true)).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")
+        Koala::HTTPService.make_request("anything", {}, "get", options)        
+      end
+
+      it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
+        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)        
+        Faraday.should_receive(:new).with(anything, anything, &Koala::HTTPService::DEFAULT_MIDDLEWARE).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)
+        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)
+      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)
+      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)
+      Koala::HTTPService.make_request("anything", {}, "get")
+    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}
+        Faraday.should_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)
+        Koala::HTTPService.make_request("anything", args, "get")
+      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}
+        @mock_connection.should_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 = stub("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)
+        Koala::HTTPService.make_request("anything", {:source => u}, "post")
+      end
+    end
+  end
+
+  describe "deprecated options" do
+    before :each do
+      Koala::HTTPService.stub(: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
+            Koala::HTTPService.send(deprecated_method).should == value
+          end
+      
+          it "generates a deprecation warning" do
+            Koala::Utils.should_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)
+            Koala::HTTPService.http_options[parameter].should == value
+          end
+      
+          it "generates a deprecation warning" do
+            Koala::Utils.should_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}
+            Koala::HTTPService.send(deprecated_method).should == value
+          end
+      
+          it "returns nil if http_options[:ssl] is not defined" do
+            Koala::HTTPService.send(deprecated_method).should be_nil
+          end
+
+          it "generates a deprecation warning" do
+            Koala::Utils.should_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)
+            Koala::HTTPService.http_options[:ssl].should
+          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
+          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)
+          end
+                
+          it "generates a deprecation warning" do
+            Koala::Utils.should_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 = stub('Typhoeus response body')
+        @mock_headers_hash = stub({:value => "headers hash"})
+        @mock_http_response = stub("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
+
+        @mock_connection = stub("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)
+      end
+      
+      describe ":typhoeus_options" do
+        it "merges any typhoeus_options into options" do
+          typhoeus_options = {:a => 2}
+          Faraday.should_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 = {:a => 2}
+          Faraday.should_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
+          Faraday.should_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)
+          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
+          Faraday.should_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)
+          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
+          Faraday.should_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)
+          Koala::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
+        end
+      end
+    end
+
+    {
+      :typhoeus => Koala::TyphoeusService, 
+      :net_http => Koala::NetHTTPService
+    }.each_pair do |adapter, module_class|
+      describe module_class.to_s do
+        it "should respond to deprecated_interface" do
+           module_class.should respond_to(:deprecated_interface)
+        end
+      
+        it "should issue a deprecation warning" do
+          Koala::Utils.should_receive(:deprecate)
+          module_class.deprecated_interface
+        end
+      
+        it "should set the default adapter to #{adapter}" do
+          module_class.deprecated_interface
+          Faraday.default_adapter.should == adapter
+        end
+      end
+    end
+  end
+end