koala 1.0.0 → 1.1.0rc2

data/spec/cases/http_services/http_service_spec.rb

@@ -17,6 +17,38 @@ describe "Koala::HTTPService" do
       end
     end
     
+    describe "proxy accessor" do
+      it "should be added" do
+        # in Ruby 1.8, .methods returns strings
+        # in Ruby 1.9, .method returns symbols 
+        Bear.methods.collect {|m| m.to_sym}.should include(:proxy)
+        Bear.methods.collect {|m| m.to_sym}.should include(:proxy=)
+      end
+    end
+    
+    describe "timeout accessor" do
+      it "should be added" do
+        # in Ruby 1.8, .methods returns strings
+        # in Ruby 1.9, .method returns symbols 
+        Bear.methods.collect {|m| m.to_sym}.should include(:timeout)
+        Bear.methods.collect {|m| m.to_sym}.should include(:timeout=)
+      end
+    end
+    
+    describe "ca_file accessor" do
+      it "should be added" do
+        Bear.methods.collect {|m| m.to_sym}.should include(:ca_file)
+        Bear.methods.collect {|m| m.to_sym}.should include(:ca_file=)
+      end
+    end
+    
+    describe "ca_path accessor" do
+      it "should be added" do
+        Bear.methods.collect {|m| m.to_sym}.should include(:ca_path)
+        Bear.methods.collect {|m| m.to_sym}.should include(:ca_path=)
+      end
+    end        
+    
     describe "server" do
       describe "without options[:beta]" do
         it "should return the rest server if options[:rest_api]" do
@@ -46,9 +78,52 @@ describe "Koala::HTTPService" do
           server.should =~ /beta\./
         end
       end
-      
     end
 
+    describe "#encode_params" do
+      it "should return an empty string if param_hash evaluates to false" do
+        Bear.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)
+        not_a_string.should_receive(:to_json).and_return(val)
+
+        string = "hi"
+
+        args = {
+          not_a_string => not_a_string,
+          string => string
+        }
+
+        result = Bear.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 = Bear.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 = Bear.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
   end
 
 end

data/spec/cases/http_services/net_http_service_spec.rb

@@ -1,14 +1,12 @@
 require 'spec_helper'
 
 
-module Horse
-  include Koala::NetHTTPService
-end
+Horse = Koala::NetHTTPService
 
 describe "NetHTTPService module holder class Horse" do
   before :each do
-    # reset the always_use_ssl parameter
-    Horse.always_use_ssl = nil
+    # reset global settings
+    Horse.always_use_ssl = Horse.proxy = Horse.timeout = nil
   end
 
   it "should define a make_request static module method" do
@@ -37,6 +35,8 @@ describe "NetHTTPService module holder class Horse" do
 
       @http_mock = stub('Net::HTTP object', 'use_ssl=' => true, 'verify_mode=' => true)
       @http_mock.stub(:start).and_yield(@http_yield_mock)
+      @http_mock.stub(:ca_path=)
+      @http_mock.stub(:ca_file=)      
 
       Net::HTTP.stub(:new).and_return(@http_mock)
     end
@@ -128,7 +128,168 @@ describe "NetHTTPService module holder class Horse" do
         Horse.make_request('anything', {}, 'anything')
       end
     end
+    
+    describe "proxy options" do
+      before :each do
+        Horse.proxy = "http://defaultproxy"
+      end
+      after :all do
+        Horse.proxy = nil
+      end
+
+      it "should use passed proxy option if provided" do
+        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything, "passedproxy", 80, nil, nil).and_return(@http_mock)
+        Horse.make_request('anything', {} , 'anything', {:proxy => "http://passedproxy"})
+      end
+      
+      it "should use default proxy if default is provided and NO proxy option passed" do
+        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything, "defaultproxy", 80, nil, nil).and_return(@http_mock)
+        Horse.make_request('anything', {} , 'anything', {})
+      end
+      
+      it "should NOT use a proxy if default is NOT provided and NO proxy option passed" do
+        Horse.proxy = nil
+        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
+        Horse.make_request('anything', {} , 'anything', {})
+      end
+    end
+    
+    describe "timeout options" do
+      before :each do
+        Horse.timeout = 20 # seconds
+      end
+      after :all do
+        Horse.timeout = nil # seconds
+      end
+
+      it "should use passed timeout option if provided" do
+        @http_mock.should_receive('open_timeout=').with(10)
+        @http_mock.should_receive('read_timeout=').with(10)
+        Horse.make_request('anything', {} , 'anything', {:timeout => 10})
+      end
+      
+      it "should use default timout if default is provided and NO timeout option passed" do
+        @http_mock.should_receive('open_timeout=').with(20)
+        @http_mock.should_receive('read_timeout=').with(20)
+        Horse.make_request('anything', {} , 'anything', {})
+      end
+      
+      it "should NOT use a timeout if default is NOT provided and NO timeout option passed" do
+        Horse.timeout = nil # seconds
+        @http_mock.should_not_receive('open_timeout=')
+        @http_mock.should_not_receive('read_timeout=')
+        Horse.make_request('anything', {} , 'anything', {})
+      end
+    end
+    
+    describe "ca_file options" do
+      after :each do
+        Horse.always_use_ssl = nil
+        Horse.ca_file = nil
+      end
+      
+      it "should not use a ca_file if the request is not via SSL" do
+        Horse.always_use_ssl = false  
+        @http_mock.should_not_receive(:ca_file=)
+        Horse.make_request('anything', {} , 'anything', {:ca_file => '/no/file'})
+      end
+      
+      describe "when via SSL" do
+        before :each do
+          Horse.always_use_ssl = true
+          
+          @global_ca_file_path = '/global/ca/file/path'
+          File.stub(:exists?).and_return(true)
+        end
 
+        it "should not use a default ca_file if the default ca_file does not exist" do
+          Horse.ca_file = @global_ca_file_path
+          
+          File.should_receive(:exists?).with(@global_ca_file_path).and_return(false)
+          Horse.should_not_receive(:ca_file=).with(@global_ca_file_path)
+          
+          Horse.make_request('anything', {} , 'anything', {})
+        end
+        
+        it "should use passed ca_file options if provided" do
+          given_ca_file = '/ca/file'
+          
+          Horse.ca_file = @global_ca_file_path
+          @http_mock.should_not_receive(:ca_file=).with(@global_ca_file_path)
+          @http_mock.should_receive(:ca_file=).with(given_ca_file)
+          
+          Horse.make_request('anything', {} , 'anything', {:ca_file => given_ca_file})
+        end
+        
+        it "should use default ca_file if default is provided and NO ca_file option is passed" do
+          Horse.ca_file = @global_ca_file_path
+          @http_mock.should_receive(:ca_file=).with(@global_ca_file_path)
+          
+          Horse.make_request('anything', {} , 'anything', {})
+        end
+        
+        it "should NOT use a ca_file if default is NOT provided and NO ca_file option is passed" do
+          @http_mock.should_not_receive(:ca_file=)
+          
+          Horse.make_request('anything', {} , 'anything', {})          
+        end
+      end
+    end
+    
+    describe "ca_path options" do
+      after :each do
+        Horse.always_use_ssl = nil
+        Horse.ca_path = nil
+      end
+      
+      it "should not use a ca_path if the request is not via SSL" do
+        Horse.always_use_ssl = false  
+        @http_mock.should_not_receive('ca_path=')
+        Horse.make_request('anything', {} , 'anything', {:ca_file => '/no/file'})
+      end
+      
+      describe "when via SSL" do
+        before :each do
+          Horse.always_use_ssl = true
+          
+          @global_ca_path = '/global/ca/path'
+          Dir.stub(:exists?).and_return(true)
+        end
+
+        it "should not use a default ca_path if the default ca_path does not exist" do
+          Horse.ca_path = @global_ca_path
+          
+          Dir.should_receive(:exists?).with(@global_ca_path).and_return(false)
+          Horse.should_not_receive(:ca_path=).with(@global_ca_path)
+          
+          Horse.make_request('anything', {} , 'anything', {})
+        end
+        
+        it "should use passed ca_path options if provided" do
+          given_ca_path = '/ca/path'
+          
+          Horse.ca_path = @global_ca_path
+          @http_mock.should_not_receive(:ca_ath=).with(@global_ca_path)
+          @http_mock.should_receive(:ca_path=).with(given_ca_path)
+          
+          Horse.make_request('anything', {} , 'anything', {:ca_path => given_ca_path})
+        end
+        
+        it "should use default ca_path if default is provided and NO ca_path option is passed" do
+          Horse.ca_path = @global_ca_path
+          @http_mock.should_receive(:ca_path=).with(@global_ca_path)
+          
+          Horse.make_request('anything', {} , 'anything', {})
+        end
+        
+        it "should NOT use a ca_path if default is NOT provided and NO ca_path option is passed" do
+          @http_mock.should_not_receive(:ca_path=)
+          
+          Horse.make_request('anything', {} , 'anything', {})          
+        end
+      end
+    end    
+    
     it "should use the graph server by default" do
       Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
       Horse.make_request('anything', {}, 'anything')
@@ -267,51 +428,6 @@ describe "NetHTTPService module holder class Horse" do
     end # describe return value
   end # describe when making a request
 
-  describe "when encoding parameters" do
-    it "should return an empty string if param_hash evaluates to false" do
-      Horse.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(:class).and_return('NotAString')
-      not_a_string.should_receive(:to_json).and_return(val)
-
-      string = "hi"
-
-      args = {
-        not_a_string => not_a_string,
-        string => string
-      }
-
-      result = Horse.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 = Horse.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 = Horse.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 "when detecting if multipart posting is needed" do
     it "should be true if any parameter value requires multipart post" do
       koala_io = mock("Koala::IO")

data/spec/cases/http_services/typhoeus_service_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
 
-module Deer
-  include Koala::TyphoeusService
-end
+Deer = Koala::TyphoeusService
 
 describe "TyphoeusService" do
 
   describe "TyphoeusService module holder class Deer" do
     before :each do
-      # reset the always_use_ssl parameter
-      Deer.always_use_ssl = nil
+      # reset global settings
+      Deer.always_use_ssl = Deer.proxy = Deer.timeout = nil
     end
 
     it "should define a make_request static module method" do
@@ -29,55 +27,55 @@ describe "TyphoeusService" do
         @mock_http_response = stub(Typhoeus::Response, :code => 1, :headers_hash => @mock_headers_hash, :body => @mock_body)
 
         # Typhoeus is an included module, so we stub methods on Deer itself
-        Deer.stub(:post).and_return(@mock_http_response)
-        Deer.stub(:get).and_return(@mock_http_response)
+        Typhoeus::Request.stub(:post).and_return(@mock_http_response)
+        Typhoeus::Request.stub(:get).and_return(@mock_http_response)
       end
 
       it "should use POST if verb is not GET" do
-        Deer.should_receive(:post).and_return(@mock_http_response)
+        Typhoeus::Request.should_receive(:post).and_return(@mock_http_response)
         Deer.make_request('anything', {}, 'anything')
       end
 
       it "should use GET if that verb is specified" do
-        Deer.should_receive(:get).and_return(@mock_http_response)
+        Typhoeus::Request.should_receive(:get).and_return(@mock_http_response)
         Deer.make_request('anything', {}, 'get')
       end
 
       describe "the connection" do
         it "should use SSL if the request has an access token" do
-          Deer.should_receive(:post).with(/https\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
 
           Deer.make_request('anything', {"access_token" => "123"}, 'anything')
         end
 
         it "should use SSL if always_use_ssl is true, even if there's no token" do
-          Deer.should_receive(:post).with(/https\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
 
           Deer.always_use_ssl = true
           Deer.make_request('anything', {}, 'anything')
         end
 
         it "should use SSL if the :use_ssl option is provided, even if there's no token" do
-          Deer.should_receive(:post).with(/https\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
 
           Deer.always_use_ssl = true
           Deer.make_request('anything', {}, 'anything', :use_ssl => true)
         end
 
         it "should not use SSL if always_use_ssl is false and there's no token" do
-          Deer.should_receive(:post).with(/http\:/, anything)
+          Typhoeus::Request.should_receive(:post).with(/http\:/, anything)
 
           Deer.make_request('anything', {}, 'anything')
         end
 
         it "should use the graph server by default" do
-          Deer.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
+          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
 
           Deer.make_request('anything', {}, 'anything')
         end
 
         it "should use the REST server if the :rest_api option is true" do
-          Deer.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
+          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
 
           Deer.make_request('anything', {}, 'anything', :rest_api => true)
         end
@@ -85,35 +83,45 @@ describe "TyphoeusService" do
 
       it "should pass the arguments to Typhoeus under the :params key" do
         args = {:a => 2}
-        Deer.should_receive(:post).with(anything, hash_including(:params => args))
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => args))
 
         Deer.make_request('anything', args, "post")
       end
 
       it "should add the method to the arguments if the method isn't get or post" do
         method = "telekenesis"
-        Deer.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
 
         Deer.make_request('anything', {}, method)
       end
 
       it "should pass :typhoeus_options to Typhoeus if provided" do
         t_options = {:a => :b}
-        Deer.should_receive(:post).with(anything, hash_including(t_options))
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(t_options))
 
         Deer.make_request("anything", {}, "post", :typhoeus_options => t_options)
       end
-      
+
+      it "should pass proxy and timeout :typhoeus_options to Typhoeus if set globally" do
+        Deer.proxy = "http://defaultproxy"
+        Deer.timeout = 20
+
+        t_options = {:proxy => "http://defaultproxy", :timeout => 20}
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(t_options))
+
+        Deer.make_request("anything", {}, "post")
+      end
+
       # for live tests, run the Graph API tests with Typhoues, which will run file uploads
       it "should pass any files directly on to Typhoues" do
         args = {:file => File.new(__FILE__, "r")}
-        Deer.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
+        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
         Deer.make_request("anything", args, :post)
       end
 
       it "should include the path in the request" do
         path = "/a/b/c/1"
-        Deer.should_receive(:post).with(Regexp.new(path), anything)
+        Typhoeus::Request.should_receive(:post).with(Regexp.new(path), anything)
 
         Deer.make_request(path, {}, "post")
       end

data/spec/cases/koala_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "Koala" do
+  it "has an http_service accessor" do
+    Koala.respond_to?(:http_service)
+  end
+
+  it "should let an http service be set" do
+    current_service = Koala.http_service
+    Koala.http_service = Koala::MockHTTPService
+    Koala.http_service.should == Koala::MockHTTPService
+    # reset the service back to the original one (important for live tests)
+    Koala.http_service = current_service
+  end
+
+  it "sets Net::HTTP as the base service" do
+    Koala.base_http_service.should == Koala::NetHTTPService
+  end
+
+  describe ".always_use_ssl" do
+    it "should be added" do
+      # in Ruby 1.8, .methods returns strings
+      # in Ruby 1.9, .method returns symbols 
+      Koala.methods.collect {|m| m.to_sym}.should include(:always_use_ssl)
+      Koala.methods.collect {|m| m.to_sym}.should include(:always_use_ssl=)
+    end
+  end
+
+  describe ".make_request" do
+    
+    before :each do
+      @old_service = Koala.http_service
+      Koala.http_service = Koala::MockHTTPService
+    end
+    
+    after :each do
+      Koala.http_service = @old_service
+    end
+
+    it "should use SSL if Koala.always_use_ssl is set to true, even if there's no token" do
+      Koala.http_service.should_receive(:make_request).with(anything, anything, anything, hash_including(:use_ssl => true))
+
+      Koala.always_use_ssl = true
+      Koala.make_request('anything', {}, 'anything')
+    end
+
+    it "should allow the caller to override the http_service" do
+      http_service = stub
+      http_service.should_receive(:make_request)
+      
+      Koala.make_request(anything, anything, anything, :http_service => http_service)
+    end
+
+  end
+end

data/spec/cases/test_users_spec.rb

@@ -16,7 +16,7 @@ describe "Koala::Facebook::TestUsers" do
         raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
       end
 
-      @is_mock = defined?(Koala::IS_MOCK) && Koala::IS_MOCK
+      @is_mock = Koala.http_service.respond_to?(:mock?) && Koala.http_service.mock?
     end
 
     describe "when initializing" do

data/spec/cases/uploadable_io_spec.rb

@@ -9,6 +9,21 @@ module Koala::MIME
 end
 
 describe "Koala::UploadableIO" do
+  def rails_3_mocks
+    tempfile = stub('Tempfile', :path => "foo")
+    uploaded_file = stub('ActionDispatch::Http::UploadedFile',
+      :content_type => true,
+      :tempfile => tempfile
+    )
+    tempfile.stub!(:respond_to?).with(:path).and_return(true)
+
+    [tempfile, uploaded_file]
+  end
+  
+  def sinatra_mocks
+    {:type => "type", :tempfile => "Tempfile"}
+  end
+  
   describe "the constructor" do
     describe "when given a file path" do
       before(:each) do
@@ -29,6 +44,12 @@ describe "Koala::UploadableIO" do
           stub_type = @koala_io_params[1] = stub('Content Type')
           Koala::UploadableIO.new(*@koala_io_params).content_type.should == stub_type
         end
+
+        it "should detect that NetHTTPService must be used" do
+          @koala_io_params[0] = mock
+          @koala_io_params[0].stub!(:read)
+          Koala::UploadableIO.new(*@koala_io_params).requires_base_http_service.should be_true
+        end
       end
 
       describe "and no content type" do
@@ -63,13 +84,7 @@ describe "Koala::UploadableIO" do
 
     describe "when given a Rails 3 ActionDispatch::Http::UploadedFile" do
       before(:each) do
-        @tempfile = stub('Tempfile', :path => "foo")
-        @uploaded_file = stub('ActionDispatch::Http::UploadedFile',
-          :content_type => true,
-          :tempfile => @tempfile
-        )
-
-        @tempfile.stub!(:respond_to?).with(:path).and_return(true)
+        @tempfile, @uploaded_file = rails_3_mocks
       end
 
       it "should get the content type via the content_type method" do
@@ -87,10 +102,7 @@ describe "Koala::UploadableIO" do
 
     describe "when given a Sinatra file parameter hash" do
       before(:each) do
-        @file_hash = {
-          :type => "type",
-          :tempfile => "Tempfile"
-        }
+        @file_hash = sinatra_mocks
       end
 
       it "should get the content type from the :type key" do
@@ -130,9 +142,19 @@ describe "Koala::UploadableIO" do
       UploadIO.stub!(:new).with(anything, anything, anything).and_return(@upload_io)
     end
 
-    it "should call the constructor with the content type, file name, and a dummy file name" do
-      UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
-      Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io.should == @upload_io
+    context "if no filename was provided" do
+      it "should call the constructor with the content type, file name, and a dummy file name" do
+        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
+        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io.should == @upload_io
+      end
+    end
+    
+    context "if a filename was provided" do
+      it "should call the constructor with the content type, file name, and the filename" do
+        filename = "file"
+        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", filename).and_return(@upload_io)
+        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type", filename).to_upload_io
+      end
     end
   end
 
@@ -148,4 +170,24 @@ describe "Koala::UploadableIO" do
       Koala::UploadableIO.new(BEACH_BALL_PATH).to_file.should == result
     end
   end
+
+  describe "#binary_content?" do
+    it "returns true for Rails 3 file uploads" do
+      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+    end
+    
+    it "returns true for Sinatra file uploads" do
+      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+    end
+    
+    it "returns true for File objects" do
+      Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH)).should be_true
+    end
+    
+    it "returns false for everything else" do
+      Koala::UploadableIO.binary_content?(StringIO.new).should be_false
+      Koala::UploadableIO.binary_content?(BEACH_BALL_PATH).should be_false
+      Koala::UploadableIO.binary_content?(nil).should be_false
+    end
+  end
 end  # describe UploadableIO