koala 1.0.0.beta → 1.1.0

data/spec/cases/http_services/typhoeus_service_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+
+Deer = Koala::TyphoeusService
+
+describe "TyphoeusService" do
+
+  describe "TyphoeusService module holder class Deer" do
+    before :each do
+      # reset global settings
+      Deer.always_use_ssl = Deer.proxy = Deer.timeout = nil
+    end
+
+    it "should define a make_request static module method" do
+      Deer.respond_to?(:make_request).should be_true
+    end
+
+    it "should include the Koala::HTTPService module defining common features" do
+      Deer.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 Deer itself
+        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
+        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
+        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
+          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
+          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
+          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
+          Typhoeus::Request.should_receive(:post).with(/http\:/, anything)
+
+          Deer.make_request('anything', {}, 'anything')
+        end
+
+        it "should use the graph server by default" do
+          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
+          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
+
+          Deer.make_request('anything', {}, 'anything', :rest_api => true)
+        end
+      end
+
+      it "should pass the arguments to Typhoeus under the :params key" do
+        args = {:a => 2}
+        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"
+        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}
+        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")}
+        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"
+        Typhoeus::Request.should_receive(:post).with(Regexp.new(path), anything)
+
+        Deer.make_request(path, {}, "post")
+      end
+
+      describe "the returned value" do
+        before(:each) do
+          @response = Deer.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 Typhoeus headers as headers" do
+          @response.headers.should == @mock_headers_hash
+        end
+      end # describe return value
+    end
+  end
+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/oauth_spec.rb

@@ -0,0 +1,409 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::OAuth" do
+  before :each do
+    # make the relevant test data easily accessible
+    @oauth_data = $testing_data["oauth_test_data"]
+    @app_id = @oauth_data["app_id"]
+    @secret = @oauth_data["secret"]
+    @code = @oauth_data["code"]
+    @callback_url = @oauth_data["callback_url"]
+    @raw_token_string = @oauth_data["raw_token_string"]
+    @raw_offline_access_token_string = @oauth_data["raw_offline_access_token_string"]
+    
+    # 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 && 
+                                                                              @code && @raw_token_string && 
+                                                                              @raw_offline_access_token_string
+
+    @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)
+  end
+  
+  # initialization
+  it "should properly initialize" do
+    @oauth.should
+  end
+
+  it "should properly set attributes" do
+    (@oauth.app_id == @app_id && 
+      @oauth.app_secret == @secret && 
+      @oauth.oauth_callback_url == @callback_url).should be_true
+  end
+
+  it "should properly initialize without a callback_url" do
+    @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+  end
+
+  it "should properly set attributes without a callback URL" do
+    @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+    (@oauth.app_id == @app_id && 
+      @oauth.app_secret == @secret && 
+      @oauth.oauth_callback_url == nil).should be_true
+  end
+  
+  describe "for cookie parsing" do
+    describe "get_user_info_from_cookies" do
+      it "should properly parse valid cookies" do
+        result = @oauth.get_user_info_from_cookies(@oauth_data["valid_cookies"])
+        result.should be_a(Hash)
+      end
+  
+      it "should return all the cookie components from valid cookie string" do
+        cookie_data = @oauth_data["valid_cookies"]
+        parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
+        number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
+        parsing_results.length.should == number_of_components
+      end
+
+      it "should properly parse valid offline access cookies (e.g. no expiration)" do 
+        result = @oauth.get_user_info_from_cookies(@oauth_data["offline_access_cookies"])
+        result["uid"].should      
+      end
+
+      it "should return all the cookie components from offline access cookies" do
+        cookie_data = @oauth_data["offline_access_cookies"]
+        parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
+        number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
+        parsing_results.length.should == number_of_components
+      end
+
+      it "shouldn't parse expired cookies" do
+        result = @oauth.get_user_info_from_cookies(@oauth_data["expired_cookies"])
+        result.should be_nil
+      end
+  
+      it "shouldn't parse invalid cookies" do
+        # make an invalid string by replacing some values
+        bad_cookie_hash = @oauth_data["valid_cookies"].inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
+        result = @oauth.get_user_info_from_cookies(bad_cookie_hash)
+        result.should be_nil
+      end
+    end
+    
+    describe "get_user_from_cookies" do
+      it "should use get_user_info_from_cookies to parse the cookies" do
+        data = @oauth_data["valid_cookies"]
+        @oauth.should_receive(:get_user_info_from_cookies).with(data).and_return({})
+        @oauth.get_user_from_cookies(data)
+      end
+
+      it "should use return a string if the cookies are valid" do
+        result = @oauth.get_user_from_cookies(@oauth_data["valid_cookies"])
+        result.should be_a(String)
+      end
+      
+      it "should return nil if the cookies are invalid" do
+        # make an invalid string by replacing some values
+        bad_cookie_hash = @oauth_data["valid_cookies"].inject({}) { |hash, value| hash[value[0]] = value[1].gsub(/[0-9]/, "3") }
+        result = @oauth.get_user_from_cookies(bad_cookie_hash)
+        result.should be_nil
+      end        
+    end
+  end
+  
+  # OAuth URLs
+  
+  describe "for URL generation" do
+
+    describe "for OAuth codes" do 
+      # url_for_oauth_code
+      it "should generate a properly formatted OAuth code URL with the default values" do 
+        url = @oauth.url_for_oauth_code
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}"
+      end
+
+      it "should generate a properly formatted OAuth code URL when a callback is given" do 
+        callback = "foo.com"
+        url = @oauth.url_for_oauth_code(:callback => callback)
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}"
+      end
+
+      it "should generate a properly formatted OAuth code URL when permissions are requested as a string" do 
+        permissions = "publish_stream,read_stream"
+        url = @oauth.url_for_oauth_code(:permissions => permissions)
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}&scope=#{permissions}"
+      end
+
+      it "should generate a properly formatted OAuth code URL when permissions are requested as a string" do 
+        permissions = ["publish_stream", "read_stream"]
+        url = @oauth.url_for_oauth_code(:permissions => permissions)
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}&scope=#{permissions.join(",")}"
+      end
+
+      it "should generate a properly formatted OAuth code URL when both permissions and callback are provided" do 
+        permissions = "publish_stream,read_stream"
+        callback = "foo.com"
+        url = @oauth.url_for_oauth_code(:callback => callback, :permissions => permissions)
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}&scope=#{permissions}"
+      end
+
+      it "should generate a properly formatted OAuth code URL when a display is given as a string" do 
+        url = @oauth.url_for_oauth_code(:display => "page")
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}&display=page"
+      end
+
+      it "should raise an exception if no callback is given in initialization or the call" do 
+        oauth2 = Koala::Facebook::OAuth.new(@app_id, @secret)
+        lambda { oauth2.url_for_oauth_code }.should raise_error(ArgumentError)
+      end
+    end
+  
+    describe "for access token URLs" do
+      # url_for_access_token
+      it "should generate a properly formatted OAuth token URL when provided a code" do 
+        url = @oauth.url_for_access_token(@code)
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{@callback_url}&client_secret=#{@secret}&code=#{@code}"
+      end
+
+      it "should generate a properly formatted OAuth token URL when provided a callback" do 
+        callback = "foo.com"
+        url = @oauth.url_for_access_token(@code, :callback => callback)
+        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@secret}&code=#{@code}"
+      end
+    end
+  end
+
+  describe "for fetching access tokens" do 
+    describe "get_access_token_info" do
+      it "should properly get and parse an access token token results into a hash" do
+        result = @oauth.get_access_token_info(@code)
+        result.should be_a(Hash)
+      end
+
+      it "should properly include the access token results" do
+        result = @oauth.get_access_token_info(@code)
+        result["access_token"].should
+      end
+
+      it "should raise an error when get_access_token is called with a bad code" do
+        lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::APIError) 
+      end
+    end
+
+    describe "get_access_token" do
+      it "should use get_access_token_info to get and parse an access token token results" do
+        result = @oauth.get_access_token(@code)
+        result.should be_a(String)
+      end
+
+      it "should return the access token as a string" do
+        result = @oauth.get_access_token(@code)
+        original = @oauth.get_access_token_info(@code)
+        result.should == original["access_token"]
+      end
+
+      it "should raise an error when get_access_token is called with a bad code" do
+        lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::APIError) 
+      end
+
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_access_token(@code, options)
+      end
+    end
+
+    describe "get_app_access_token_info" do
+      it "should properly get and parse an app's access token as a hash" do
+        result = @oauth.get_app_access_token_info
+        result.should be_a(Hash)
+      end
+        
+      it "should include the access token" do
+        result = @oauth.get_app_access_token_info
+        result["access_token"].should
+      end
+      
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_app_access_token_info(options)
+      end
+    end
+  
+    describe "get_app_acess_token" do
+      it "should use get_access_token_info to get and parse an access token token results" do
+        result = @oauth.get_app_access_token
+        result.should be_a(String)
+      end
+
+      it "should return the access token as a string" do
+        result = @oauth.get_app_access_token
+        original = @oauth.get_app_access_token_info
+        result.should == original["access_token"]
+      end
+      
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        @oauth.get_app_access_token(options)
+      end
+    end
+    
+    describe "protected methods" do
+    
+      # protected methods
+      # since these are pretty fundamental and pretty testable, we want to test them
+
+      # parse_access_token
+      it "should properly parse access token results" do
+        result = @oauth.send(:parse_access_token, @raw_token_string)
+        has_both_parts = result["access_token"] && result["expires"]
+        has_both_parts.should
+      end
+
+      it "should properly parse offline access token results" do
+        result = @oauth.send(:parse_access_token, @raw_offline_access_token_string)
+        has_both_parts = result["access_token"] && !result["expires"]
+        has_both_parts.should
+      end
+
+      # fetch_token_string
+      # somewhat duplicative with the tests for get_access_token and get_app_access_token
+      # but no harm in thoroughness
+      it "should fetch a proper token string from Facebook when given a code" do
+        result = @oauth.send(:fetch_token_string, :code => @code, :redirect_uri => @callback_url)
+        result.should =~ /^access_token/
+      end
+
+      it "should fetch a proper token string from Facebook when asked for the app token" do
+        result = @oauth.send(:fetch_token_string, {:type => 'client_cred'}, true)
+        result.should =~ /^access_token/
+      end
+    end
+  end
+
+  describe "for exchanging session keys" do
+    describe "with get_token_info_from_session_keys" do
+      it "should get an array of session keys from Facebook when passed a single key" do
+        result = @oauth.get_tokens_from_session_keys([@oauth_data["session_key"]])
+        result.should be_an(Array)
+        result.length.should == 1
+      end
+
+      it "should get an array of session keys from Facebook when passed multiple keys" do
+        result = @oauth.get_tokens_from_session_keys(@oauth_data["multiple_session_keys"])
+        result.should be_an(Array)
+        result.length.should == 2
+      end
+      
+      it "should return the original hashes" do
+        result = @oauth.get_token_info_from_session_keys(@oauth_data["multiple_session_keys"])
+        result[0].should be_a(Hash)
+      end
+      
+      it "should properly handle invalid session keys" do
+        result = @oauth.get_token_info_from_session_keys(["foo", "bar"])
+        #it should return nil for each of the invalid ones
+        result.each {|r| r.should be_nil}
+      end
+      
+      it "should properly handle a mix of valid and invalid session keys" do
+        result = @oauth.get_token_info_from_session_keys(["foo"].concat(@oauth_data["multiple_session_keys"]))
+        # it should return nil for each of the invalid ones
+        result.each_with_index {|r, index| index > 0 ? r.should(be_a(Hash)) : r.should(be_nil)}
+      end
+      
+      it "should throw an APIError if Facebook returns an empty body (as happens for instance when the API breaks)" do
+        @oauth.should_receive(:fetch_token_string).and_return("")
+        lambda { @oauth.get_token_info_from_session_keys(@oauth_data["multiple_session_keys"]) }.should raise_error(Koala::Facebook::APIError)
+      end
+      
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "[{}]", {}))
+        @oauth.get_token_info_from_session_keys([], options)
+      end
+    end
+    
+    describe "with get_tokens_from_session_keys" do
+      it "should call get_token_info_from_session_keys" do
+        args = @oauth_data["multiple_session_keys"]
+        @oauth.should_receive(:get_token_info_from_session_keys).with(args, anything).and_return([])
+        @oauth.get_tokens_from_session_keys(args)
+      end
+      
+      it "should return an array of strings" do
+        args = @oauth_data["multiple_session_keys"]
+        result = @oauth.get_tokens_from_session_keys(args)
+        result.each {|r| r.should be_a(String) }
+      end
+      
+      it "should properly handle invalid session keys" do
+        result = @oauth.get_tokens_from_session_keys(["foo", "bar"])
+        # it should return nil for each of the invalid ones
+        result.each {|r| r.should be_nil}
+      end
+      
+      it "should properly handle a mix of valid and invalid session keys" do
+        result = @oauth.get_tokens_from_session_keys(["foo"].concat(@oauth_data["multiple_session_keys"]))
+        # it should return nil for each of the invalid ones
+        result.each_with_index {|r, index| index > 0 ? r.should(be_a(String)) : r.should(be_nil)}
+      end
+      
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "[{}]", {}))
+        @oauth.get_tokens_from_session_keys([], options)
+      end
+    end
+
+    describe "get_token_from_session_key" do
+      it "should call get_tokens_from_session_keys when the get_token_from_session_key is called" do
+        key = @oauth_data["session_key"]
+        @oauth.should_receive(:get_tokens_from_session_keys).with([key], anything).and_return([])
+        @oauth.get_token_from_session_key(key)
+      end
+
+      it "should get back the access token string from get_token_from_session_key" do
+        result = @oauth.get_token_from_session_key(@oauth_data["session_key"])
+        result.should be_a(String)
+      end
+
+      it "should be the first value in the array" do
+        result = @oauth.get_token_from_session_key(@oauth_data["session_key"])
+        array = @oauth.get_tokens_from_session_keys([@oauth_data["session_key"]])
+        result.should == array[0]
+      end
+      
+      it "should properly handle an invalid session key" do
+        result = @oauth.get_token_from_session_key("foo")
+        result.should be_nil
+      end
+      
+      it "should pass on any options provided to make_request" do
+        options = {:a => 2}
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "[{}]", {}))
+        @oauth.get_token_from_session_key("", options)
+      end
+    end    
+  end
+  
+  describe "for parsing signed requests" do
+    # the signed request code is ported directly from Facebook
+    # so we only need to test at a high level that it works      
+    it "should throw an error if the algorithm is unsupported" do
+      MultiJson.stub(:decode).and_return("algorithm" => "my fun algorithm")
+      lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
+    end
+    
+    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 "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
+
+end # describe