koala 0.7.1 → 0.8.0

data/CHANGELOG

@@ -1,3 +1,29 @@
+v0.8.0
+-- Breaking interface changes
+  -- Removed string overloading for the methods, per 0.7.3, which caused Marshaling issues
+  -- Removed ability to provide a string as the second argument to url_for_access_token, per 0.5.0
+
+v0.7.4 
+-- Fixed bug with get_user_from_cookies
+
+v0.7.3
+-- Added support for picture sizes -- thanks thhermansen for the patch!
+-- Adjusted the return values for several methods (get_access_token, get_app_access_token, get_token_from_session_key, get_tokens_from_session_keys, get_user_from_cookies)
+  -- These methods now return strings, rather than hashes, which makes more sense
+  -- The strings are overloaded with an [] method for backwards compatibility (Ruby is truly amazing)
+    -- Using those methods triggers a deprecation warning
+    -- This will be removed by 1.0
+  -- There are new info methods (get_access_token_info, get_app_access_token_info, get_token_info_from_session_keys, and get_user_info_from_cookies) that natively return hashes, for when you want the expiration date
+-- Responses with HTTP status 500+ now properly throw errors under Net::HTTP 
+-- Updated changelog
+-- Added license
+
+v0.7.2
+-- Added support for exchanging session keys for OAuth access tokens (get_token_from_session_key for single keys, get_tokens_from_session_keys for multiple)
+-- Moved Koala files into a koala/ subdirectory to minimize risk of name collisions
+-- Added OAuth Playground git submodule as an example 
+-- Updated tests, readme, and changelog
+
 v0.7.1
 -- Updated RealtimeUpdates#list_subscriptions and GraphAPI#get_connections to now return an 
 array of results directly (rather than a hash with one key)

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Alex Koppel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -1,12 +1,14 @@
 CHANGELOG
+LICENSE
 Manifest
 Rakefile
 init.rb
-lib/graph_api.rb
-lib/http_services.rb
+koala.gemspec
 lib/koala.rb
-lib/realtime_updates.rb
-lib/rest_api.rb
+lib/koala/graph_api.rb
+lib/koala/http_services.rb
+lib/koala/realtime_updates.rb
+lib/koala/rest_api.rb
 readme.md
 spec/facebook_data.yml
 spec/koala/api_base_tests.rb

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake'
 require 'echoe'
 
 # gem management
-Echoe.new('koala', '0.7.1') do |p|
+Echoe.new('koala', '0.8.0') do |p|
   p.summary    = "A lightweight, flexible library for Facebook with support for the Graph API, the old REST API, realtime updates, and OAuth validation."
   p.description = "Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write access to the social graph via the Graph API and the older REST API, as well as support for realtime updates and OAuth and Facebook Connect authentication.  Koala is fully tested and supports Net::HTTP and Typhoeus connections out of the box and can accept custom modules for other services."
   p.url            = "http://github.com/arsduo/koala"
@@ -12,4 +12,5 @@ Echoe.new('koala', '0.7.1') do |p|
   p.email          = "alex@alexkoppel.com"
   p.ignore_pattern = ["tmp/*", "script/*", "pkg/*"]
   p.development_dependencies = []
+  p.retain_gemspec = true
 end

data/koala.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{koala}
-  s.version = "0.7.1"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Koppel, Chris Baclig, Rafi Jacoby, Context Optional"]
-  s.date = %q{2010-05-27}
+  s.date = %q{2010-06-27}
   s.description = %q{Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write access to the social graph via the Graph API and the older REST API, as well as support for realtime updates and OAuth and Facebook Connect authentication.  Koala is fully tested and supports Net::HTTP and Typhoeus connections out of the box and can accept custom modules for other services.}
   s.email = %q{alex@alexkoppel.com}
-  s.extra_rdoc_files = ["CHANGELOG", "lib/graph_api.rb", "lib/http_services.rb", "lib/koala.rb", "lib/realtime_updates.rb", "lib/rest_api.rb"]
-  s.files = ["CHANGELOG", "Manifest", "Rakefile", "init.rb", "lib/graph_api.rb", "lib/http_services.rb", "lib/koala.rb", "lib/realtime_updates.rb", "lib/rest_api.rb", "readme.md", "spec/facebook_data.yml", "spec/koala/api_base_tests.rb", "spec/koala/graph_and_rest_api/graph_and_rest_api_no_token_tests.rb", "spec/koala/graph_and_rest_api/graph_and_rest_api_with_token_tests.rb", "spec/koala/graph_api/graph_api_no_access_token_tests.rb", "spec/koala/graph_api/graph_api_with_access_token_tests.rb", "spec/koala/live_testing_data_helper.rb", "spec/koala/net_http_service_tests.rb", "spec/koala/oauth/oauth_tests.rb", "spec/koala/realtime_updates/realtime_updates_tests.rb", "spec/koala/rest_api/rest_api_no_access_token_tests.rb", "spec/koala/rest_api/rest_api_with_access_token_tests.rb", "spec/koala_spec.rb", "spec/koala_spec_helper.rb", "spec/koala_spec_without_mocks.rb", "spec/mock_facebook_responses.yml", "spec/mock_http_service.rb", "koala.gemspec"]
+  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "lib/koala.rb", "lib/koala/graph_api.rb", "lib/koala/http_services.rb", "lib/koala/realtime_updates.rb", "lib/koala/rest_api.rb"]
+  s.files = ["CHANGELOG", "LICENSE", "Manifest", "Rakefile", "init.rb", "koala.gemspec", "lib/koala.rb", "lib/koala/graph_api.rb", "lib/koala/http_services.rb", "lib/koala/realtime_updates.rb", "lib/koala/rest_api.rb", "readme.md", "spec/facebook_data.yml", "spec/koala/api_base_tests.rb", "spec/koala/graph_and_rest_api/graph_and_rest_api_no_token_tests.rb", "spec/koala/graph_and_rest_api/graph_and_rest_api_with_token_tests.rb", "spec/koala/graph_api/graph_api_no_access_token_tests.rb", "spec/koala/graph_api/graph_api_with_access_token_tests.rb", "spec/koala/live_testing_data_helper.rb", "spec/koala/net_http_service_tests.rb", "spec/koala/oauth/oauth_tests.rb", "spec/koala/realtime_updates/realtime_updates_tests.rb", "spec/koala/rest_api/rest_api_no_access_token_tests.rb", "spec/koala/rest_api/rest_api_with_access_token_tests.rb", "spec/koala_spec.rb", "spec/koala_spec_helper.rb", "spec/koala_spec_without_mocks.rb", "spec/mock_facebook_responses.yml", "spec/mock_http_service.rb"]
   s.homepage = %q{http://github.com/arsduo/koala}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Koala", "--main", "readme.md"]
   s.require_paths = ["lib"]

data/lib/{graph_api.rb → koala/graph_api.rb}

@@ -47,11 +47,11 @@ module Koala
         graph_call("#{id}/#{connection_name}", args)["data"]
       end
     
-      def get_picture(object)
-        result = graph_call("#{object}/picture", {}, "get", :http_component => :headers)
+      def get_picture(object, args = {})
+        result = graph_call("#{object}/picture", args, "get", :http_component => :headers)
         result["Location"]
-      end
-    
+      end    
+      
       def put_object(parent_object, connection_name, args = {})
         # Writes the given object to the graph, connected to the given parent.
         # 

data/lib/{realtime_updates.rb → koala/realtime_updates.rb}

@@ -44,7 +44,7 @@ module Koala
         # fetch the access token if we're provided a secret
         if @secret && !@app_access_token
           oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
-          @app_access_token = oauth.get_app_access_token["access_token"]
+          @app_access_token = oauth.get_app_access_token
         end
       end
       

data/lib/koala.rb

@@ -6,15 +6,15 @@ require 'rubygems'
 require 'json'
 
 # include default http services
-require 'http_services'
+require 'koala/http_services'
 
 # add Graph API methods
-require 'graph_api'
+require 'koala/graph_api'
 
 # add REST API methods
-require 'rest_api'
+require 'koala/rest_api'
 
-require 'realtime_updates'
+require 'koala/realtime_updates'
 
 module Koala
     
@@ -52,6 +52,11 @@ module Koala
         # make the request via the provided service
         result = Koala.make_request(path, args, verb, options)
 
+        # Check for any 500 errors before parsing the body
+        # since we're not guaranteed that the body is valid JSON
+        # in the case of a server error
+        raise APIError.new({"type" => "HTTP #{result.status.to_s}", "message" => "Response body: #{result.body}"}) if result.status >= 500
+        
         # Parse the body as JSON and check for errors if provided a mechanism to do so 
         # Note: Facebook sometimes sends results like "true" and "false", which aren't strictly objects
         # and cause JSON.parse to fail -- so we account for that by wrapping the result in []
@@ -102,12 +107,11 @@ module Koala
         @app_secret = app_secret
         @oauth_callback_url = oauth_callback_url 
       end
-    
-      def get_user_from_cookie(cookie_hash)
+
+      def get_user_info_from_cookie(cookie_hash)
         # Parses the cookie set by the official Facebook JavaScript SDK.
         # 
-        # cookies should be a dictionary-like object mapping cookie names to
-        # cookie values.
+        # cookies should be a Hash, like the one Rails provides
         # 
         # If the user is logged in via Facebook, we return a dictionary with the
         # keys "uid" and "access_token". The former is the user's Facebook ID,
@@ -132,8 +136,17 @@ module Koala
           sig == components["sig"] && (components["expires"] == "0" || Time.now.to_i < components["expires"].to_i) ? components : nil
         end
       end
+      alias_method :get_user_info_from_cookies, :get_user_info_from_cookie
+    
+      def get_user_from_cookie(cookies)
+        if info = get_user_info_from_cookies(cookies)
+          string = info["uid"]
+        end
+      end
       alias_method :get_user_from_cookies, :get_user_from_cookie
     
+      # URLs
+    
       def url_for_oauth_code(options = {})
         # for permissions, see http://developers.facebook.com/docs/authentication/permissions
         permissions = options[:permissions]
@@ -148,26 +161,65 @@ module Koala
         
       def url_for_access_token(code, options = {})
         # Creates the URL for the token corresponding to a given code generated by Facebook
-        if options.is_a?(String) # changing the arguments
-          puts "Deprecation warning: url_for_access_token now takes an options hash as the second argument; pass the callback as :callback."
-          options = {:callback => options}
-        end
         callback = options[:callback] || @oauth_callback_url
         raise ArgumentError, "url_for_access_token must get a callback either from the OAuth object or in the parameters!" unless callback
         "https://#{GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@app_secret}&code=#{code}"
       end
-      
-      def get_access_token(code)
+            
+      def get_access_token_info(code)
         # convenience method to get a parsed token from Facebook for a given code
         # should this require an OAuth callback URL?
         get_token_from_server(:code => code, :redirect_uri => @oauth_callback_url)
       end
       
-      def get_app_access_token
+      def get_access_token(code)
+        # upstream methods will throw errors if needed
+        if info = get_access_token_info(code) 
+          string = info["access_token"]        
+        end
+      end
+      
+      def get_app_access_token_info
         # convenience method to get a the application's sessionless access token 
         get_token_from_server({:type => 'client_cred'}, true)
       end
       
+      def get_app_access_token
+        if info = get_app_access_token_info
+          string = info["access_token"] 
+        end
+      end
+
+      # from session keys
+      def get_token_info_from_session_keys(sessions)
+        # fetch the OAuth tokens from Facebook
+        response = fetch_token_string({
+          :type => 'client_cred',
+          :sessions => sessions.join(",")
+        }, true, "exchange_sessions")
+        
+        # get_token_from_session_key should return an empty body if an empty string or nil is provided
+        # if invalid tokens are provided, it returns an array of nulls, which is a valid result
+        if response == ""
+          raise APIError.new("ArgumentError", "get_token_from_session_key received an error (empty response body) for sessions #{sessions.inspect}!")
+        end
+        
+        JSON.parse(response)
+      end
+  
+      def get_tokens_from_session_keys(sessions)
+        # get the original hash results
+        results = get_token_info_from_session_keys(sessions)
+        # now recollect them as just the access tokens
+        results.collect { |r| string = r["access_token"] }
+      end
+      
+      def get_token_from_session_key(session)
+        # convenience method for a single key
+        # gets the overlaoded strings automatically
+        get_tokens_from_session_keys([session])[0]
+      end
+      
       protected
       
       def get_token_from_server(args, post = false)
@@ -189,8 +241,8 @@ module Koala
         components 
       end
 
-      def fetch_token_string(args, post = false)
-        Koala.make_request("oauth/access_token", {
+      def fetch_token_string(args, post = false, endpoint = "access_token")
+        Koala.make_request("oauth/#{endpoint}", {
           :client_id => @app_id, 
           :client_secret => @app_secret
         }.merge!(args), post ? "post" : "get").body

data/readme.md

@@ -34,7 +34,7 @@ We reserve the right to expand the built-in REST API coverage to additional conv
 OAuth
 -----
 You can use the Graph and REST APIs without an OAuth access token, but the real magic happens when you provide Facebook an OAuth token to prove you're authenticated.  Koala provides an OAuth class to make that process easy:
-     @oauth = Koala::Facebook::OAuth.new(app_id, code, callback_url)
+    @oauth = Koala::Facebook::OAuth.new(app_id, code, callback_url)
 
 If your application uses Koala and the Facebook [JavaScript SDK](http://github.com/facebook/connect-js) (formerly Facebook Connect), you can use the OAuth class to parse the cookies:
     @oauth.get_user_from_cookie(cookies)
@@ -50,6 +50,9 @@ You can also get your application's own access token, which can be used without
 
 That's it!  It's pretty simple once you get the hang of it.  If you're new to OAuth, though, check out the wiki and the OAuth Playground example site (see below).
 
+*Exchanging session keys:* Stuck building tab applications on Facebook?  Wishing you had an OAuth token so you could use the Graph API?  You're in luck! Koala now allows you to exchange session keys for OAuth access tokens:
+    @oauth.get_token_from_session_key(session_key)
+    @oauth.get_tokens_from_session_keys(array_of_session_keys)
 
 Real-time Updates
 -----

data/spec/facebook_data.yml

@@ -5,14 +5,19 @@
  
 # You must supply this value yourself to test the GraphAPI class.
 # Your OAuth token should have publish_stream and read_stream permissions.
-oauth_token: 119908831367602|2.6WkxQTbQPGFCyLblPYdsMg__.3600.1274979600-2905623|8YPVs-jBmpWC6y10pMCWzMRFrdk. 
+oauth_token: 
 
 # for testing the OAuth class    
 # baseline app
 oauth_test_data: 
   # You must supply this value yourself, since they will expire.
-  code:  2.6WkxQTbQPGFCyLblPYdsMg__.3600.1274979600-2905623|zHzbqwoONeqNxOXX7z9LZlpEGdc.
-    
+  code: 
+  # easiest way to get session keys: use multiple test accounts with the Javascript login at http://oauth.twoalex.com
+  session_key: 
+  multiple_session_keys:
+    - 
+    - 
+  
   # These values will work out of the box
   app_id: 119908831367602
   secret: e45e55a333eec232d4206d2703de1307

data/spec/koala/api_base_tests.rb

@@ -29,9 +29,45 @@ class ApiBaseTests < Test::Unit::TestCase
       service.api('anything')
     end
     
-    it "should properly handle the http_component parameter"
+    it "should get the attribute of a Koala::Response given by the http_component parameter" do
+      http_component = :method_name
+      
+      response = mock('Mock KoalaResponse', :body => '', :status => 200)
+      response.should_receive(http_component).and_return('')
+      
+      Koala.stub(:make_request).and_return(response)
+      
+      @service.api('anything', 'get', {}, :http_component => http_component)
+    end
+    
+    it "should return the body of the request as JSON if no http_component is given" do
+      response = stub('response', :body => 'body', :status => 200)
+      Koala.stub(:make_request).and_return(response)
+      
+      json_body = mock('JSON body')
+      JSON.stub(:parse).and_return([json_body])
+      
+      @service.api('anything').should == json_body
+    end
     
-    it "should execute a block to test for errors if passed one"
+    it "should execute a block with the response body if passed one" do
+      body = '{}'
+      Koala.stub(:make_request).and_return(Koala::Response.new(200, body, {}))
+      
+      yield_test = mock('Yield Tester')
+      yield_test.should_receive(:pass)
+      
+      @service.api('anything') do |arg| 
+        yield_test.pass
+        arg.should == JSON.parse(body)
+      end
+    end
+    
+    it "should raise an API error if the HTTP response code is greater than or equal to 500" do
+      Koala.stub(:make_request).and_return(Koala::Response.new(500, 'response body', {}))
+      
+      lambda { @service.api('anything') }.should raise_exception(Koala::Facebook::APIError)
+    end
     
     it "should handle rogue true/false as responses" do
       Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'true', {}))

data/spec/koala/graph_api/graph_api_no_access_token_tests.rb

@@ -34,6 +34,10 @@ shared_examples_for "Koala GraphAPI without an access token" do
     @api.get_picture("chris.baclig").should =~ /http\:\/\//
   end
 
+  it "should be able to access a user's picture, given a picture type"  do
+    @api.get_picture("chris.baclig", {:type => 'large'}).should =~ /^http\:\/\//
+  end
+
   it "should be able to access connections from public Pages" do
     result = @api.get_connections("contextoptional", "likes")
     result.should be_a(Array)

data/spec/koala/graph_api/graph_api_with_access_token_tests.rb

@@ -31,6 +31,10 @@ it "should get public data about a user" do
       @api.get_picture("chris.baclig").should =~ /http\:\/\//
     end
   
+    it "should be able to access a user's picture, given a picture type"  do
+      @api.get_picture("chris.baclig", {:type => 'large'}).should =~ /^http\:\/\//
+    end
+  
     it "should be able to access connections from users" do
       result = @api.get_connections("lukeshepard", "likes")
       result.length.should > 0

data/spec/koala/net_http_service_tests.rb

@@ -1,4 +1,4 @@
-require 'http_services'
+require 'koala/http_services'
   
 class NetHTTPServiceTests < Test::Unit::TestCase
   module Bear
@@ -8,10 +8,174 @@ class NetHTTPServiceTests < Test::Unit::TestCase
   it "should define a make_request static module method" do
     Bear.respond_to?(:make_request).should be_true
   end
-  
-  it "should return a string for location header"
 
-  it "should use POST if verb is not GET"
+  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]
+      
+      @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
+  
+    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 port 443" do
+      Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+      
+      Bear.make_request('anything', {}, 'anything')  
+    end
+    
+    it "should use SSL" do
+      @http_mock.should_receive('use_ssl=').with(true)
+      
+      Bear.make_request('anything', {}, 'anything')  
+    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 "should turn off vertificate validaiton warnings" do
+      @http_mock.should_receive('verify_mode=').with(OpenSSL::SSL::VERIFY_NONE)
+      
+      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" 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
+    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
   
-  it "should return a Koala::Response object"
+  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
 end

data/spec/koala/oauth/oauth_tests.rb

@@ -51,41 +51,64 @@ class FacebookOAuthTests < Test::Unit::TestCase
         @oauth.oauth_callback_url == nil).should be_true
     end
     
-    # cookie parsing
-    it "should properly parse valid cookies" do
-      result = @oauth.get_user_from_cookie(@oauth_data["valid_cookies"])
-      result["uid"].should
-    end
+    describe "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_from_cookie(cookie_data)
-      number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
-      parsing_results.length.should == number_of_components
-    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_from_cookie(@oauth_data["offline_access_cookies"])
-      result["uid"].should      
-    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_from_cookie(cookie_data)
-      number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
-      parsing_results.length.should == number_of_components
-    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_from_cookie(@oauth_data["expired_cookies"])
-      result.should be_nil
-    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_from_cookie(bad_cookie_hash)
-      result.should be_nil
+        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
@@ -138,40 +161,116 @@ class FacebookOAuthTests < Test::Unit::TestCase
       url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@secret}&code=#{@code}"
     end
     
-    it "should output a deprecation warning but generate a properly formatted OAuth token URL when provided a callback in the deprecated fashion" do 
-      callback = "foo.com"
-      url = out = nil
-      
-      begin
-        # we want to capture the deprecation warning as well as the output
-        # credit to http://thinkingdigitally.com/archive/capturing-output-from-puts-in-ruby/ for the technique
-        out = StringIO.new
-        $stdout = out
-        url = @oauth.url_for_access_token(@code, callback)
-      ensure
-        $stdout = STDOUT
+    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
-      
-      # two assertions may be bad test writing, but this is for a deprecated method
-      url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@secret}&code=#{@code}"
-      out.should_not be_nil
     end
 
-    # START CODE THAT NEEDS MOCKING
+    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
 
-    # get_access_token
-    it "should properly get and parse an access token token results" do
-      result = @oauth.get_access_token(@code)
-      result["access_token"].should
+      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
     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) 
+    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
     end
     
-    it "should properly get and parse an app's access token token results" do
-      result = @oauth.get_app_access_token
-      result["access_token"].should
+    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
+    end
+
+    describe "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
+      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).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
+      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]).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
+      end    
     end
     
     # protected methods

data/spec/mock_facebook_responses.yml

@@ -114,6 +114,18 @@ graph_api:
           code: 302
           headers:
             Location: http://facebook.com/
+    type=large:
+      get:
+        no_token:
+          code: 302
+          headers:
+            Location: http://facebook.com/large
+        with_token:
+          code: 302
+          headers:
+            Location: http://facebook.com/large
+
+
   search:
     q=facebook:
       get: 
@@ -136,7 +148,15 @@ graph_api:
     client_id=<%= APP_ID %>&client_secret=<%= SECRET %>&type=client_cred:
       post:
         no_token: access_token=<%= ACCESS_TOKEN %>
-        
+  oauth/exchange_sessions:
+    client_id=<%= APP_ID %>&client_secret=<%= SECRET %>&sessions=<%= OAUTH_DATA["session_key"] %>&type=client_cred: 
+      post:
+        no_token: '[{"access_token":"<%= ACCESS_TOKEN %>","expires":4315}]'
+    client_id=<%= APP_ID %>&client_secret=<%= SECRET %>&sessions=<%= OAUTH_DATA["multiple_session_keys"].join(",") %>&type=client_cred: 
+      post:
+        no_token: '[{"access_token":"<%= ACCESS_TOKEN %>","expires":4315}, {"access_token":"<%= ACCESS_TOKEN %>","expires":4315}]'
+
+
 
 # -- Subscription Responses -- 
   <%= APP_ID %>/subscriptions:

data/spec/mock_http_service.rb

@@ -1,4 +1,5 @@
 require 'erb'
+require 'yaml'
 
 module Koala
   module MockHTTPService
@@ -15,7 +16,11 @@ module Koala
     
     # Useful in mock_facebook_responses.yml
     OAUTH_DATA = TEST_DATA['oauth_test_data']
-    OAUTH_DATA.merge!('app_access_token' => Koala::MockHTTPService::ACCESS_TOKEN)
+    OAUTH_DATA.merge!({
+      'app_access_token' => Koala::MockHTTPService::ACCESS_TOKEN,
+      'session_key' => "session_key",
+      'multiple_session_keys' => ["session_key", "session_key_2"]
+    })
     APP_ID = OAUTH_DATA['app_id']
     SECRET = OAUTH_DATA['secret']
     SUBSCRIPTION_DATA = TEST_DATA["subscription_test_data"]

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 7
-  - 1
-  version: 0.7.1
+  - 8
+  - 0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Alex Koppel, Chris Baclig, Rafi Jacoby, Context Optional
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-27 00:00:00 -07:00
+date: 2010-06-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -26,21 +26,24 @@ extensions: []
 
 extra_rdoc_files: 
 - CHANGELOG
-- lib/graph_api.rb
-- lib/http_services.rb
+- LICENSE
 - lib/koala.rb
-- lib/realtime_updates.rb
-- lib/rest_api.rb
+- lib/koala/graph_api.rb
+- lib/koala/http_services.rb
+- lib/koala/realtime_updates.rb
+- lib/koala/rest_api.rb
 files: 
 - CHANGELOG
+- LICENSE
 - Manifest
 - Rakefile
 - init.rb
-- lib/graph_api.rb
-- lib/http_services.rb
+- koala.gemspec
 - lib/koala.rb
-- lib/realtime_updates.rb
-- lib/rest_api.rb
+- lib/koala/graph_api.rb
+- lib/koala/http_services.rb
+- lib/koala/realtime_updates.rb
+- lib/koala/rest_api.rb
 - readme.md
 - spec/facebook_data.yml
 - spec/koala/api_base_tests.rb
@@ -59,7 +62,6 @@ files:
 - spec/koala_spec_without_mocks.rb
 - spec/mock_facebook_responses.yml
 - spec/mock_http_service.rb
-- koala.gemspec
 has_rdoc: true
 homepage: http://github.com/arsduo/koala
 licenses: []