koala 0.10.0 → 1.0.0.beta2.1

data/spec/koala/http_services/net_http_service_tests.rb

@@ -0,0 +1,339 @@
+require 'koala/http_services'
+class NetHTTPServiceTests < Test::Unit::TestCase
+  module Bear
+    include Koala::NetHTTPService
+  end
+
+  describe "NetHTTPService module holder class Bear" do
+    before :each do
+      # reset the always_use_ssl parameter
+      Bear.always_use_ssl = nil
+    end
+
+    it "should define a make_request static module method" do
+      Bear.respond_to?(:make_request).should be_true
+    end
+
+    it "should include the Koala::HTTPService module defining common features" do
+      Bear.included_modules.include?(Koala::HTTPService).should be_true
+    end
+
+    describe "when making a request" do
+      before(:each) do
+        # Setup stubs for make_request to execute without exceptions
+        @mock_http_response = stub('Net::HTTPResponse', :code => 1)
+        @mock_body = stub('Net::HTTPResponse body')
+        @http_request_result = [@mock_http_response, @mock_body]
+
+        # to_ary is called in Ruby 1.9 to provide backwards compatibility
+        # with the response, body = http.get() syntax we use
+        @mock_http_response.stub!(:to_ary).and_return(@http_request_result)
+
+        @http_yield_mock = mock('Net::HTTP start yielded object')
+
+        @http_yield_mock.stub(:post).and_return(@http_request_result)
+        @http_yield_mock.stub(:get).and_return(@http_request_result)
+
+        @http_mock = stub('Net::HTTP object', 'use_ssl=' => true, 'verify_mode=' => true)
+        @http_mock.stub(:start).and_yield(@http_yield_mock)
+
+        Net::HTTP.stub(:new).and_return(@http_mock)
+      end
+
+      describe "the connection" do
+        it "should use POST if verb is not GET" do
+          @http_yield_mock.should_receive(:post).and_return(@mock_http_response)
+          @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+
+          Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should use GET if that verb is specified" do
+          @http_yield_mock.should_receive(:get).and_return(@mock_http_response)
+          @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+
+          Bear.make_request('anything', {}, 'get')
+        end
+
+        it "should add the method to the arguments if it's not get or post" do
+          args = {}
+          method = "telekenesis"
+          # since the arguments get encoded later, we'll test for merge!
+          # even though that's somewhat testing internal implementation
+          args.should_receive(:merge!).with(:method => method)
+
+          Bear.make_request('anything', args, method)
+        end
+      end
+
+      describe "if the request has an access token" do
+        before :each do
+          @args = {"access_token" => "123"}
+        end
+
+        it "should use SSL" do
+          @http_mock.should_receive('use_ssl=').with(true)
+
+          Bear.make_request('anything', @args, 'anything')
+        end
+
+        it "should set the port to 443" do
+          Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+          Bear.make_request('anything', @args, 'anything')
+        end
+      end
+
+      describe "if always_use_ssl is true" do
+        before :each do
+          Bear.always_use_ssl = true
+        end
+
+        it "should use SSL" do
+          @http_mock.should_receive('use_ssl=').with(true)
+
+          Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should set the port to 443" do
+          Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+          Bear.make_request('anything', {}, 'anything')
+        end
+      end
+
+      describe "if the use_ssl option is provided" do
+        it "should use SSL" do
+          @http_mock.should_receive('use_ssl=').with(true)
+
+          Bear.make_request('anything', {}, 'anything', :use_ssl => true)
+        end
+
+        it "should set the port to 443" do
+          Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+
+          Bear.make_request('anything', {}, 'anything', :use_ssl => true)
+        end
+      end
+
+      describe "if there's no token and always_use_ssl isn't true" do
+        it "should not use SSL" do
+          @http_mock.should_not_receive('use_ssl=')
+          Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should not set the port" do
+          Net::HTTP.should_receive(:new).with(anything, nil).and_return(@http_mock)
+          Bear.make_request('anything', {}, 'anything')
+        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)
+        Bear.make_request('anything', {}, 'anything')
+      end
+
+      it "should use the REST server if the :rest_api option is true" do
+        Net::HTTP.should_receive(:new).with(Koala::Facebook::REST_SERVER, anything).and_return(@http_mock)
+        Bear.make_request('anything', {}, 'anything', :rest_api => true)
+      end
+
+      it "no longer turns off vertificate validaiton warnings" do
+        @http_mock.should_not_receive('verify_mode=')
+
+        Bear.make_request('anything', {}, 'anything')
+      end
+
+      it "should start an HTTP connection" do
+        @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+        Bear.make_request('anything', {}, 'anything')
+      end
+
+      describe "via POST" do
+        it "should use Net::HTTP to make a POST request" do
+          @http_yield_mock.should_receive(:post).and_return(@http_request_result)
+
+          Bear.make_request('anything', {}, 'post')
+        end
+
+        it "should go to the specified path adding a / if it doesn't exist" do
+          path = mock('Path')
+          @http_yield_mock.should_receive(:post).with(path, anything).and_return(@http_request_result)
+
+          Bear.make_request(path, {}, 'post')
+        end
+
+        it "should use encoded parameters" do
+          args = {}
+          params = mock('Encoded parameters')
+          Bear.should_receive(:encode_params).with(args).and_return(params)
+
+          @http_yield_mock.should_receive(:post).with(anything, params).and_return(@http_request_result)
+
+          Bear.make_request('anything', args, 'post')
+        end
+
+        describe "with multipart/form-data" do
+          before(:each) do
+            Bear.stub(:encode_multipart_params)
+            Bear.stub("params_require_multipart?").and_return(true)
+
+            @multipart_request_stub = stub('Stub Multipart Request')
+            Net::HTTP::Post::Multipart.stub(:new).and_return(@multipart_request_stub)
+
+            @file_stub = stub('fake File', "kind_of?" => true, "path" => 'anypath.jpg')
+
+            @http_yield_mock.stub(:request).with(@multipart_request_stub).and_return(@http_request_result)
+          end
+
+          it "should use multipart/form-data if any parameter is a valid file hash" do
+            @http_yield_mock.should_receive(:request).with(@multipart_request_stub).and_return(@http_request_result)
+
+            Bear.make_request('anything', {}, 'post')
+          end
+
+          it "should use the given request path for the request" do
+            args = {"file" => @file_stub}
+            expected_path = 'expected/path'
+
+            Net::HTTP::Post::Multipart.should_receive(:new).with(expected_path, anything).and_return(@multipart_request_stub)
+
+            Bear.make_request(expected_path, {}, 'post')
+          end
+
+          it "should use multipart encoded arguments for the request" do
+            args = {"file" => @file_stub}
+            expected_params = stub('Stub Multipart Params')
+
+            Bear.should_receive(:encode_multipart_params).with(args).and_return(expected_params)
+            Net::HTTP::Post::Multipart.should_receive(:new).with(anything, expected_params).and_return(@multipart_request_stub)
+
+            Bear.make_request('anything', args, 'post')
+          end
+        end
+      end
+
+      describe "via GET" do
+        it "should use Net::HTTP to make a GET request" do
+          @http_yield_mock.should_receive(:get).and_return(@http_request_result)
+
+          Bear.make_request('anything', {}, 'get')
+        end
+
+        it "should use the correct path, including arguments" do
+          path = mock('Path')
+          params = mock('Encoded parameters')
+          args = {}
+
+          Bear.should_receive(:encode_params).with(args).and_return(params)
+          @http_yield_mock.should_receive(:get).with("#{path}?#{params}").and_return(@http_request_result)
+
+          Bear.make_request(path, args, 'get')
+        end
+      end
+
+      describe "the returned value" do
+        before(:each) do
+          @response = Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should return a Koala::Response object" do
+          @response.class.should == Koala::Response
+        end
+
+        it "should return a Koala::Response with the right status" do
+          @response.status.should == @mock_http_response.code
+        end
+
+        it "should reutrn a Koala::Response with the right body" do
+          @response.body.should == @mock_body
+        end
+
+        it "should return a Koala::Response with the Net::HTTPResponse object as headers" do
+          @response.headers.should == @mock_http_response
+        end
+      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
+        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(: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 = 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
+
+    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")
+        koala_io.should_receive(:kind_of?).with(Koala::UploadableIO).and_return(true)
+
+        args = {
+          "key1" => "val",
+          "key2" => "val",
+          "key3" => koala_io,
+          "key4" => "val"
+        }
+
+        Bear.params_require_multipart?(args).should be_true
+      end
+      
+      describe "when encoding multipart/form-data params" do
+        it "should replace Koala::UploadableIO values with UploadIO values" do
+          upload_io = UploadIO.new(__FILE__, "fake type")
+          
+          uploadable_io = stub('Koala::UploadableIO')
+          uploadable_io.should_receive(:kind_of?).with(Koala::UploadableIO).and_return(true)
+          uploadable_io.should_receive(:to_upload_io).and_return(upload_io)
+          args = {
+            "not_a_file" => "not a file",
+            "file" => uploadable_io
+          }
+          
+          result = Bear.encode_multipart_params(args)
+
+          result["not_a_file"] == args["not_a_file"]
+          result["file"] == upload_io
+        end
+      end
+      
+    end
+  end
+end

data/spec/koala/http_services/typhoeus_service_tests.rb

@@ -0,0 +1,162 @@
+require 'koala/http_services'
+class TyphoeusServiceTests < Test::Unit::TestCase
+  module Bear
+    include Koala::TyphoeusService
+  end
+
+  describe "TyphoeusService module holder class Bear" do
+    before :each do
+      # reset the always_use_ssl parameter
+      Bear.always_use_ssl = nil
+    end
+
+    it "should define a make_request static module method" do
+      Bear.respond_to?(:make_request).should be_true
+    end
+
+    it "should include the Koala::HTTPService module defining common features" do
+      Bear.included_modules.include?(Koala::HTTPService).should be_true
+    end
+
+    describe "when making a 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(Typhoeus::Response, :code => 1, :headers_hash => @mock_headers_hash, :body => @mock_body)
+
+        # Typhoeus is an included module, so we stub methods on Bear itself
+        Bear.stub(:post).and_return(@mock_http_response)
+        Bear.stub(:get).and_return(@mock_http_response)
+      end
+
+      it "should use POST if verb is not GET" do
+        Bear.should_receive(:post).and_return(@mock_http_response)
+        Bear.make_request('anything', {}, 'anything')
+      end
+
+      it "should use GET if that verb is specified" do
+        Bear.should_receive(:get).and_return(@mock_http_response)
+        Bear.make_request('anything', {}, 'get')
+      end
+
+      describe "the connection" do
+        it "should use SSL if the request has an access token" do
+          Bear.should_receive(:post).with(/https\:/, anything)
+
+          Bear.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
+          Bear.should_receive(:post).with(/https\:/, anything)
+
+          Bear.always_use_ssl = true
+          Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should use SSL if the :use_ssl option is provided, even if there's no token" do
+          Bear.should_receive(:post).with(/https\:/, anything)
+
+          Bear.always_use_ssl = true
+          Bear.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
+          Bear.should_receive(:post).with(/http\:/, anything)
+
+          Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should use the graph server by default" do
+          Bear.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
+
+          Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should use the REST server if the :rest_api option is true" do
+          Bear.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
+
+          Bear.make_request('anything', {}, 'anything', :rest_api => true)
+        end
+      end
+
+      it "should pass the arguments to Typhoeus under the :params key" do
+        args = {:a => 2}
+        Bear.should_receive(:post).with(anything, hash_including(:params => args))
+
+        Bear.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"
+        Bear.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
+
+        Bear.make_request('anything', {}, method)
+      end
+
+      it "should pass :typhoeus_options to Typhoeus if provided" do
+        t_options = {:a => :b}
+        Bear.should_receive(:post).with(anything, hash_including(t_options))
+
+        Bear.make_request("anything", {}, "post", :typhoeus_options => t_options)
+      end
+
+      it "should include the path in the request" do
+        path = "/a/b/c/1"
+        Bear.should_receive(:post).with(Regexp.new(path), anything)
+
+        Bear.make_request(path, {}, "post")
+      end
+
+      describe "the returned value" do
+        before(:each) do
+          @response = Bear.make_request('anything', {}, 'anything')
+        end
+
+        it "should return a Koala::Response object" do
+          @response.class.should == Koala::Response
+        end
+
+        it "should return a Koala::Response with the right status" do
+          @response.status.should == @mock_http_response.code
+        end
+
+        it "should reutrn a Koala::Response with the right body" do
+          @response.body.should == @mock_body
+        end
+
+        it "should return a Koala::Response with the Net::HTTPResponse object as headers" do
+          @response.headers.should == @mock_headers_hash
+        end
+      end # describe return value
+    end
+    
+    describe "with file upload" do
+      it "should include an interface to NetHTTPService called NetHTTPInterface" do
+        # we should be able to access it
+        lambda { Koala::TyphoeusService::NetHTTPInterface }.should_not raise_exception(Exception)
+        Koala::TyphoeusService::NetHTTPInterface.included_modules.include?(Koala::NetHTTPService).should be_true
+      end
+      
+      it "should call the NetHTTPInterface if multipart is required" do
+        method = "any_method"
+        args = {}
+        verb = "get"
+        options = {}
+
+        Bear.stub(:params_require_multipart?).and_return(true)
+        Koala::TyphoeusService::NetHTTPInterface.should_receive(:make_request).with(method, args, verb, options)
+
+        Bear.make_request(method, args, verb, options)
+      end
+      
+      # Typhoeus file uploads currently don't work
+      # 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")}
+      #  Bear.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
+      #  Bear.make_request("anything", args, :post)
+      # end
+    end
+  end
+end

data/spec/koala/live_testing_data_helper.rb

@@ -19,7 +19,7 @@ module LiveTestingDataHelper
         errors = []
         
         if count > 0
-          print "\nCleaning up #{count} temporary #{count > 1 ? "objects" : "object"}..."
+          print "\nCleaning up #{count} temporary #{count > 1 ? "objects" : "object (#{@temporary_object_ids.first})"}..."
           @temporary_object_ids.each do |id|
             # get our API
             api = @api || (@test_users ? @test_users.graph_api : nil)

data/spec/koala/oauth/oauth_tests.rb

@@ -10,12 +10,9 @@ class FacebookOAuthTests < Test::Unit::TestCase
       @raw_token_string = @oauth_data["raw_token_string"]
       @raw_offline_access_token_string = @oauth_data["raw_offline_access_token_string"]
       
-      # per Facebook's example:
-      # http://developers.facebook.com/docs/authentication/canvas
-      # this allows us to use Facebook's example data while running the other live data
-      @request_secret = @oauth_data["request_secret"] || @secret 
-      @signed_request = @oauth_data["signed_request"]
-      @signed_request_result = @oauth_data["signed_request_result"]
+      # for signed requests (http://developers.facebook.com/docs/authentication/canvas/encryption_proposal)
+      @signed_params = @oauth_data["signed_params"]
+      @signed_params_result = @oauth_data["signed_params_result"]
       
       # this should expanded to cover all variables
       raise Exception, "Must supply app data to run FacebookOAuthTests!" unless @app_id && @secret && @callback_url && 
@@ -24,9 +21,9 @@ class FacebookOAuthTests < Test::Unit::TestCase
 
       @oauth = Koala::Facebook::OAuth.new(@app_id, @secret, @callback_url)
 
-      time = Time.now
-      Time.stub!(:now).and_return(time)
-      time.stub!(:to_i).and_return(1273363199)
+      @time = Time.now
+      Time.stub!(:now).and_return(@time)
+      @time.stub!(:to_i).and_return(1273363199)
     end
     
     # initialization
@@ -350,86 +347,23 @@ class FacebookOAuthTests < Test::Unit::TestCase
     end
     
     describe "for parsing signed requests" do
-      before :each do 
-        # you can test against live data by updating the YML, or you can use the default data
-        # which tests against Facebook's example on http://developers.facebook.com/docs/authentication/canvas
-        @oauth = Koala::Facebook::OAuth.new(@app_id, @request_secret || @app_secret)
-      end
-
-      it "should break the request into the encoded signature and the payload" do
-        @signed_request.should_receive(:split).with(".").and_return(["", ""])
-        @oauth.parse_signed_request(@signed_request)
+      # the signed request code comes directly from Facebook
+      # so we only need to test at a high level that it works      
+      # signed params refers to http://developers.facebook.com/docs/authentication/canvas
+      # signed request refers to http://developers.facebook.com/docs/authentication/canvas/encryption_proposal
+      it "should throw an error if the algorithm is unsupported" do
+        JSON.stub!(:parse).and_return("algorithm" => "my fun algorithm")
+        lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
       end
       
-      it "should base64 URL decode the signed request" do
-        sig = ""
-        @signed_request.should_receive(:split).with(".").and_return([sig, "1"])
-        @oauth.should_receive(:base64_url_decode).with(sig).and_return("4")
-        @oauth.parse_signed_request(@signed_request)
+      it "should throw an error if the signature is invalid" do
+        OpenSSL::HMAC.stub!(:hexdigest).and_return("i'm an invalid signature")
+        lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
       end
 
-      it "should base64 URL decode the signed request" do
-        sig = @signed_request.split(".")[0]
-        @oauth.should_receive(:base64_url_decode).with(sig).and_return(nil)
-        @oauth.parse_signed_request(@signed_request)        
-      end
-      
-      it "should get the sha64 encoded payload using proper arguments from OpenSSL::HMAC" do
-        payload = ""
-        @signed_request.should_receive(:split).with(".").and_return(["1", payload])
-        OpenSSL::HMAC.should_receive(:digest).with("sha256", @request_secret, payload)
-        @oauth.parse_signed_request(@signed_request)        
-      end
-      
-      it "should compare the encoded payload with the signature" do
-        sig = "2"
-        @oauth.should_receive(:base64_url_decode).and_return(sig)
-        encoded_payload = "1"
-        OpenSSL::HMAC.should_receive(:digest).with(anything, anything, anything).and_return(encoded_payload)
-        encoded_payload.should_receive(:==).with(sig)
-        @oauth.parse_signed_request(@signed_request)                
-      end
-        
-      describe "if the encoded payload matches the signature" do
-        before :each do
-          # set it up so the sig will match the encoded payload
-          raw_sig = ""
-          @sig = "2"
-          @payload = "1"
-          @signed_request.should_receive(:split).and_return([raw_sig, @payload])
-          @oauth.should_receive(:base64_url_decode).with(raw_sig).and_return(@sig)
-          OpenSSL::HMAC.should_receive(:digest).with(anything, anything, anything).and_return(@sig.dup)
-        end
-        
-        it "should base64_url_decode the payload" do
-          @oauth.should_receive(:base64_url_decode).with(@payload).ordered.and_return("{}")
-          @oauth.parse_signed_request(@signed_request)        
-        end
-        
-        it "should JSON decode the payload" do
-          result = "{}"
-          @oauth.should_receive(:base64_url_decode).with(@payload).and_return(result)
-          JSON.should_receive(:parse).with(result)
-          @oauth.parse_signed_request(@signed_request)        
-        end
-      end
-
-      describe "if the encoded payload does not match the signature" do
-        before :each do
-          sig = ""
-          @signed_request.should_receive(:split).and_return([sig, ""])
-          OpenSSL::HMAC.should_receive(:digest).with(anything, anything, anything).and_return("hi")
-        end
-        
-        it "should return nil" do
-          @oauth.parse_signed_request(@signed_request).should be_nil
-        end
-      end
-      
-      describe "run against data" do
-        it "should work" do
-          @oauth.parse_signed_request(@signed_request).should == @signed_request_result
-        end
+      it "properly parses requests" do
+        @oauth = Koala::Facebook::OAuth.new(@app_id, @secret || @app_secret)
+        @oauth.parse_signed_request(@signed_params).should == @signed_params_result
       end
     end