cbaclig-koala 0.5.0.1

data/CHANGELOG

@@ -0,0 +1,42 @@
+v0.5.0.1 
+-- Added #fql method to allow easy FQL queries
+-- Added fql tests
+
+v0.5.0
+-- Added several new OAuth methods for making and parsing access token requests
+-- Added test suite for the OAuth class
+-- Made second argument to url_for_access_token a hash (strings still work but trigger a deprecation warning)
+-- Added fields to facebook_data.yml
+-- Updated readme
+
+v0.4.1
+-- Encapsulated GraphAPI and OAuth classes in the Koala::Facebook module for clarity (and to avoid claiming the global Facebook class)
+-- Moved make_request method to Koala class from GraphAPI instance (for use by future OAuth class functionality)
+-- Renamed request method to api for consistancy with Javascript library
+-- Updated tests and readme
+
+v0.4.0
+-- Adopted the Koala name
+-- Updated readme and tests
+-- Fixed cookie verification bug for non-expiring OAuth tokens
+
+v0.3.1
+-- Bug fixes.
+
+v0.3
+-- Renamed Graph API class from Facebook::GraphAPI to FacebookGraph::API
+-- Created FacebookGraph::OAuth class for tokens and OAuth URLs
+-- Updated method for including HTTP service (think we've got it this time) 
+-- Updated tests
+-- Added CHANGELOG and gemspec
+
+v0.2
+-- Gemified the project
+-- Split out HTTP services into their own file, and adjusted inclusion method
+
+v0.1
+-- Added modular support for Typhoeus
+-- Added tests
+
+v0.0
+-- Hi from F8!  Basic read/write from the graph is working

data/Manifest

@@ -0,0 +1,12 @@
+CHANGELOG
+Manifest
+Rakefile
+init.rb
+lib/http_services.rb
+lib/koala.rb
+readme.md
+test/facebook_data.yml
+test/koala/facebook_no_access_token_tests.rb
+test/koala/facebook_oauth_tests.rb
+test/koala/facebook_with_access_token_tests.rb
+test/koala_tests.rb

data/Rakefile

@@ -0,0 +1,15 @@
+# Rakefile
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+# gem management
+Echoe.new('cbaclig-koala') do |p|
+  p.summary    = "A lightweight, flexible library for Facebook's new Graph API"
+  p.description = "Koala is a lightweight, flexible Ruby SDK for Facebook's new Graph API.  It allows read/write access to the Facebook Graph and provides OAuth URLs and cookie validation for Facebook Connect sites.  Koala 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"
+  p.author         = ["Alex Koppel", "Rafi Jacoby", "Context Optional"]
+  p.email          = "alex@alexkoppel.com"
+  p.ignore_pattern = ["tmp/*", "script/*", "pkg/*"]
+  p.development_dependencies = []
+end

data/cbaclig-koala.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cbaclig-koala}
+  s.version = "0.5.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Koppel, Rafi Jacoby, Context Optional"]
+  s.date = %q{2010-05-11}
+  s.description = %q{Koala is a lightweight, flexible Ruby SDK for Facebook's new Graph API.  It allows read/write access to the Facebook Graph and provides OAuth URLs and cookie validation for Facebook Connect sites.  Koala 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/http_services.rb", "lib/koala.rb"]
+  s.files = ["CHANGELOG", "Manifest", "Rakefile", "init.rb", "lib/http_services.rb", "lib/koala.rb", "readme.md", "test/facebook_data.yml", "test/koala/facebook_no_access_token_tests.rb", "test/koala/facebook_oauth_tests.rb", "test/koala/facebook_with_access_token_tests.rb", "test/koala_tests.rb", "cbaclig-koala.gemspec"]
+  s.homepage = %q{http://github.com/arsduo/koala}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Cbaclig-koala", "--main", "readme.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{cbaclig-koala}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A lightweight, flexible library for Facebook's new Graph API}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1,2 @@
+# init.rb
+require 'koala'

data/lib/http_services.rb

@@ -0,0 +1,58 @@
+module Koala
+  module NetHTTPService
+    # this service uses Net::HTTP to send requests to the graph
+    def self.included(base)
+      base.class_eval do
+        require 'net/http' unless defined?(Net::HTTP)
+        require 'net/https'
+      
+        def self.make_request(path, args, verb, graph = true)
+          # We translate args to a valid query string. If post is specified,
+          # we send a POST request to the given path with the given arguments.
+
+          # if the verb isn't get or post, send it as a post argument
+          args.merge!({:method => verb}) && verb = "post" if verb != "get" && verb != "post"
+
+          http = Net::HTTP.new(graph ? Facebook::GRAPH_SERVER : Facebook::REST_SERVER, 443)
+          http.use_ssl = true
+          # we turn off certificate validation to avoid the 
+          # "warning: peer certificate won't be verified in this SSL session" warning
+          # not sure if this is the right way to handle it
+          # see http://redcorundum.blogspot.com/2008/03/ssl-certificates-and-nethttps.html
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+          result = http.start { |http|
+            response, body = (verb == "post" ? http.post(path, encode_params(args)) : http.get("#{path}?#{encode_params(args)}")) 
+            body
+          }
+        end
+
+        protected
+        def self.encode_params(param_hash)
+          # TODO investigating whether a built-in method handles this
+          # if no hash (e.g. no auth token) return empty string
+          ((param_hash || {}).collect do |key_and_value| 
+            key_and_value[1] = key_and_value[1].to_json if key_and_value[1].class != String
+            "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
+          end).join("&")
+        end
+      end
+    end
+  end
+
+  module TyphoeusService
+    # this service uses Typhoeus to send requests to the graph
+    def self.included(base)
+      base.class_eval do
+        require 'typhoeus' unless defined?(Typhoeus)
+        include Typhoeus
+
+        def self.make_request(path, args, verb, graph = true)
+          # if the verb isn't get or post, send it as a post argument
+          args.merge!({:method => verb}) && verb = "post" if verb != "get" && verb != "post"
+          self.send(verb, "https://#{graph ? Facebook::GRAPH_SERVER : Facebook::REST_SERVER}/#{path}", :params => args).body
+        end
+      end      
+    end
+  end
+end

data/lib/koala.rb

@@ -0,0 +1,317 @@
+require 'cgi'
+require 'digest/md5'
+
+# rubygems is required to support json, how facebook returns data
+require 'rubygems'
+require 'json'
+
+# include default http services
+require 'http_services'
+
+module Koala
+    
+  module Facebook
+    # Ruby client library for the Facebook Platform.
+    # Copyright 2010 Facebook
+    # Adapted from the Python library by Alex Koppel, Rafi Jacoby, and the team at Context Optional
+    #
+    # Licensed under the Apache License, Version 2.0 (the "License"); you may
+    # not use this file except in compliance with the License. You may obtain
+    # a copy of the License at
+    #     http://www.apache.org/licenses/LICENSE-2.0
+    #
+    # Unless required by applicable law or agreed to in writing, software
+    # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+    # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+    # License for the specific language governing permissions and limitations
+    # under the License.
+    # 
+    # This client library is designed to support the Graph API and the official
+    # Facebook JavaScript SDK, which is the canonical way to implement
+    # Facebook authentication. Read more about the Graph API at
+    # http://developers.facebook.com/docs/api. You can download the Facebook
+    # JavaScript SDK at http://github.com/facebook/connect-js/.
+
+    GRAPH_SERVER = "graph.facebook.com"
+    REST_SERVER = "api.facebook.com"
+
+    class GraphAPI
+      # A client for the Facebook Graph API.
+      # 
+      # See http://developers.facebook.com/docs/api for complete documentation
+      # for the API.
+      # 
+      # The Graph API is made up of the objects in Facebook (e.g., people, pages,
+      # events, photos) and the connections between them (e.g., friends,
+      # photo tags, and event RSVPs). This client provides access to those
+      # primitive types in a generic way. For example, given an OAuth access
+      # token, this will fetch the profile of the active user and the list
+      # of the user's friends:
+      # 
+      #    graph = Koala::Facebook::GraphAPI.new(access_token)
+      #    user = graph.get_object("me")
+      #    friends = graph.get_connections(user["id"], "friends")
+      # 
+      # You can see a list of all of the objects and connections supported
+      # by the API at http://developers.facebook.com/docs/reference/api/.
+      # 
+      # You can obtain an access token via OAuth or by using the Facebook
+      # JavaScript SDK. See http://developers.facebook.com/docs/authentication/
+      # for details.
+      # 
+      # If you are using the JavaScript SDK, you can use the
+      # Koala::Facebook::OAuth.get_user_from_cookie() method below to get the OAuth access token
+      # for the active user from the cookie saved by the SDK.
+            
+      # initialize with an access token 
+      def initialize(access_token = nil)
+        @access_token = access_token
+      end
+    
+      def get_object(id, args = {})
+        # Fetchs the given object from the graph.
+        api(id, args)
+      end
+    
+      def get_objects(ids, args = {})
+        # Fetchs all of the given object from the graph.
+        # We return a map from ID to object. If any of the IDs are invalid,
+        # we raise an exception.
+        api("", args.merge("ids" => ids.join(",")))
+      end
+    
+      def get_connections(id, connection_name, args = {})
+        # Fetchs the connections for given object.
+        api("#{id}/#{connection_name}", args)
+      end
+    
+      def put_object(parent_object, connection_name, args = {})
+        # Writes the given object to the graph, connected to the given parent.
+        # 
+        # For example,
+        # 
+        #     graph.put_object("me", "feed", :message => "Hello, world")
+        # 
+        # writes "Hello, world" to the active user's wall. Likewise, this
+        # will comment on a the first post of the active user's feed:
+        # 
+        #     feed = graph.get_connections("me", "feed")
+        #     post = feed["data"][0]
+        #     graph.put_object(post["id"], "comments", :message => "First!")
+        # 
+        # See http://developers.facebook.com/docs/api#publishing for all of
+        # the supported writeable objects.
+        # 
+        # Most write operations require extended permissions. For example,
+        # publishing wall posts requires the "publish_stream" permission. See
+        # http://developers.facebook.com/docs/authentication/ for details about
+        # extended permissions.
+
+        raise GraphAPIError.new({"type" => "KoalaMissingAccessToken", "message" => "Write operations require an access token"}) unless @access_token
+        api("#{parent_object}/#{connection_name}", args, "post")
+      end
+    
+      def put_wall_post(message, attachment = {}, profile_id = "me")
+        # Writes a wall post to the given profile's wall.
+        # 
+        # We default to writing to the authenticated user's wall if no
+        # profile_id is specified.
+        # 
+        # attachment adds a structured attachment to the status message being
+        # posted to the Wall. It should be a dictionary of the form:
+        # 
+        #     {"name": "Link name"
+        #      "link": "http://www.example.com/",
+        #      "caption": "{*actor*} posted a new review",
+        #      "description": "This is a longer description of the attachment",
+        #      "picture": "http://www.example.com/thumbnail.jpg"}
+
+        self.put_object(profile_id, "feed", attachment.merge({:message => message}))
+      end
+    
+      def put_comment(object_id, message)
+        # Writes the given comment on the given post.
+        self.put_object(object_id, "comments", {:message => message})
+      end
+    
+      def put_like(object_id)
+        # Likes the given post.
+        self.put_object(object_id, "likes")
+      end
+    
+      def delete_object(id)
+        # Deletes the object with the given ID from the graph.
+        api(id, {}, "delete")
+      end
+    
+      def search(search_terms, args = {})
+        # Searches for a given term
+        api("search", args.merge({:q => search_terms}))
+      end
+    
+      def api(path, args = {}, verb = "get")
+        # Fetches the given path in the Graph API.
+        args["access_token"] = @access_token if @access_token
+        
+        # make the request via the provided service
+        result = Koala.make_request(path, args, verb)
+      
+        # Facebook sometimes sends results like "true" and "false", which aren't strictly object
+        # and cause JSON.parse to fail
+        # so we account for that
+        response = JSON.parse("[#{result}]")[0]
+
+        # check for errors
+        if response.is_a?(Hash) && error_details = response["error"]
+          raise GraphAPIError.new(error_details)
+        end
+      
+        response
+      end
+      
+      def fql(query)
+        args = {
+          "query" => query,
+          "format" => "json",
+        }
+        
+        # Adds access_token if available
+        args["access_token"] = @access_token if @access_token
+        
+        response = Koala.make_request('method/fql.query', args, 'get', false)
+        
+        # Facebook sometimes sends results like "true" and "false", which aren't strictly object
+        # and cause JSON.parse to fail
+        # so we account for that
+        response = JSON.parse("[#{response}]")[0]
+        
+        # check for errors
+        if response.is_a?(Hash) && response["error_code"]
+          raise RestAPIError.new(response)
+        end
+        
+        response
+      end
+    end
+  
+    class GraphAPIError < Exception
+      attr_accessor :fb_error_type
+      def initialize(details = {})
+        self.fb_error_type = details["type"]  
+        super("#{fb_error_type}: #{details["message"]}")
+      end
+    end
+    
+    class RestAPIError < Exception
+      attr_accessor :fb_error_code
+      def initialize(details = {})
+        self.fb_error_code = details["error_code"]  
+        super("#{fb_error_code}: #{details["error_msg"]} [#{details["request_args"].map{|h| "#{h['key']}=#{h['value']}" }.join('&')}]")
+      end
+    end
+    
+    
+    class OAuth
+      attr_accessor :app_id, :app_secret, :oauth_callback_url
+      def initialize(app_id, app_secret, oauth_callback_url = nil)
+        @app_id = app_id
+        @app_secret = app_secret
+        @oauth_callback_url = oauth_callback_url 
+      end
+    
+      def get_user_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.
+        # 
+        # 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,
+        # and the latter can be used to make authenticated requests to the Graph API.
+        # If the user is not logged in, we return None.
+        # 
+        # Download the official Facebook JavaScript SDK at
+        # http://github.com/facebook/connect-js/. Read more about Facebook
+        # authentication at http://developers.facebook.com/docs/authentication/.
+
+        if fb_cookie = cookie_hash["fbs_" + @app_id.to_s]
+          # remove the opening/closing quote
+          fb_cookie = fb_cookie.gsub(/\"/, "")
+
+          # since we no longer get individual cookies, we have to separate out the components ourselves
+          components = {}
+          fb_cookie.split("&").map {|param| param = param.split("="); components[param[0]] = param[1]}
+
+          # generate the signature and make sure it matches what we expect
+          auth_string = components.keys.sort.collect {|a| a == "sig" ? nil : "#{a}=#{components[a]}"}.reject {|a| a.nil?}.join("")
+          sig = Digest::MD5.hexdigest(auth_string + @app_secret)          
+          sig == components["sig"] && (components["expires"] == "0" || Time.now.to_i < components["expires"].to_i) ? components : nil
+        end
+      end
+      alias_method :get_user_from_cookies, :get_user_from_cookie
+    
+      def url_for_oauth_code(options = {})
+        # for permissions, see http://developers.facebook.com/docs/authentication/permissions
+        permissions = options[:permissions]
+        scope = permissions ? "&scope=#{permissions.is_a?(Array) ? permissions.join(",") : permissions}" : ""
+
+        callback = options[:callback] || @oauth_callback_url
+        raise ArgumentError, "url_for_oauth_code must get a callback either from the OAuth object or in the options!" unless callback
+
+        # Creates the URL for oauth authorization for a given callback and optional set of permissions
+        "https://#{GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}#{scope}"    
+      end
+        
+      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 parse_access_token(response_text)
+        components = response_text.split("&").inject({}) do |hash, bit|
+          key, value = bit.split("=")
+          hash.merge!(key => value)
+        end
+        components 
+      end
+
+      def fetch_token_string(code)
+        Koala.make_request("oauth/access_token", {
+          :client_id => @app_id, 
+          :redirect_uri => @oauth_callback_url, 
+          :client_secret => @app_secret, 
+          :code => code
+        }, "get")
+      end
+      
+      def get_access_token(code)
+        result = fetch_token_string(code)
+        
+        # if we have an error, parse the error JSON and raise an error
+        raise GraphAPIError.new((JSON.parse(result)["error"] rescue nil) || {}) if result =~ /error/
+        # otherwise, parse the access token
+        parse_access_token(result)
+      end
+    end
+  end
+  
+  # finally, set up the http service Koala methods used to make requests
+  # you can use your own (for HTTParty, etc.) by calling Koala.http_service = YourModule
+  def self.http_service=(service)
+    self.send(:include, service)
+  end
+
+  # by default, try requiring Typhoeus -- if that works, use it
+  begin
+    require 'typhoeus'
+    Koala.http_service = TyphoeusService
+  rescue LoadError
+    Koala.http_service = NetHTTPService
+  end
+end

data/readme.md

@@ -0,0 +1,39 @@
+Koala
+====
+Koala (<a href="http://github.com/arsduo/koala" target="_blank">http://github.com/arsduo/koala</a>) is a new Facebook Graph library for Ruby.  We wrote Koala with four goals: 
+
+* Lightweight: Koala should be as light and simple as Facebook’s own new libraries, providing API accessors and returning simple JSON.  (We clock in, with comments, just over 300 lines of code.)
+* Fast: Koala should, out of the box, be quick. In addition to supporting the vanilla Ruby networking libraries, it natively supports Typhoeus, our preferred gem for making fast HTTP requests. Of course, That brings us to our next topic:
+* Flexible: Koala should be useful to everyone, regardless of their current configuration.  (We have no dependencies beyond the JSON gem.  Koala also has a built-in mechanism for using whichever HTTP library you prefer to make requests against the graph.)
+* Tested: Koala should have complete test coverage, so you can rely on it.  (By the time you read this the final tests are being written.)
+
+Basic usage:
+
+    graph = Koala::Facebook::GraphAPI.new(oauth_access_token)
+    profile = graph.get_object("me")
+    friends = graph.get_connections("me", "friends")
+    graph.put_object("me", "feed", :message => "I am writing on my wall!")
+
+If you're using Koala within a web application with the Facebook
+[JavaScript SDK](http://github.com/facebook/connect-js), you can use the Koala::Facebook::OAuth class 
+to parse the cookies set by the JavaScript SDK for logged in users.
+
+Examples and More Details 
+-----
+There's a very detailed description and walkthrough of Koala at <a href="http://blog.twoalex.com/2010/05/03/introducing-koala-a-new-gem-for-facebooks-new-graph-api/">http://blog.twoalex.com/2010/05/03/introducing-koala-a-new-gem-for-facebooks-new-graph-api/</a>.
+
+You can easily generate OAuth access tokens and any other data needed to play with the Graph API or OAuth at the Koala-powered <a href="http://oauth.twoalex.com" target="_blank">OAuth Playground</a>.
+
+
+Testing
+-----
+
+Unit tests are provided for all of Koala's methods; however, because the OAuth access tokens and cookies expire, you have to provide some of your own data: a valid OAuth access token with publish_stream and read_stream permissions and an OAuth code that can be used to generate an access token.  (The file also provides valid values for other tests, which you're welcome to sub out for data specific to your own application.)
+
+Insert the required values into the file test/facebook_data.yml, then run the test as follows:
+    spec koala_tests.rb
+    
+
+Known Issues
+-----
+1. gem install koala produces "Could not find main page readme.md" message

data/test/facebook_data.yml

@@ -0,0 +1,31 @@
+# Check out http://oauth.twoalex.com/ to easily generate tokens, cookies, etc.
+# Those values will work with the default settings in this yaml.
+# Of course, you can change this to work with your own app.
+# Just remember to update all fields!
+
+# You must supply this value yourself to test the GraphAPI class.
+# Your OAuth token should have publish_stream and read_stream permissions
+oauth_token:  
+
+
+# for testing the OAuth class    
+# baseline app
+oauth_test_data:
+  # You must supply this value yourself, since they will expire.
+  code: 
+    
+  # These values will work out of the box
+  app_id: 119908831367602
+  secret: e45e55a333eec232d4206d2703de1307
+  callback_url: http://oauth.twoalex.com/
+  raw_token_string: "access_token=119908831367602|2.6GneoQbnEqtSiPppZzDU4Q__.3600.1273366800-2905623|3OLa3w0x1K4C1S5cOgbs07TytAk.&expires=6621"
+  raw_offline_access_token_string: access_token=119908831367602|2.6GneoQbnEqtSiPppZzDU4Q__.3600.1273366800-2905623|3OLa3w0x1K4C1S5cOgbs07TytAk.
+  valid_cookies: 
+    # note: the tests stub the time class so these default cookies are always valid (if you're using the default app)
+    # if not you may want to remove the stubbing to test expiration
+    fbs_119908831367602: '"access_token=119908831367602|2.LKE7ksSPOx0V_8mHPr2NHQ__.3600.1273363200-2905623|CMpi0AYbn03Oukzv94AUha2qbO4.&expires=1273363200&secret=lT_9zm5r5IbJ6Aa5O54nFw__&session_key=2.LKE7ksSPOx0V_8mHPr2NHQ__.3600.1273363200-2905623&sig=9515e93113921f9476a4efbdd4a3c746&uid=2905623"'
+  expired_cookies:
+    fbs_119908831367602: '"access_token=119908831367602|2.xv9mi6QSOpr474s4n2X_pw__.3600.1273287600-2905623|yVt5WH_S6J5p3gFa5_5lBzckhws.&expires=1273287600&secret=V_E79ovQnXqxGctFuC_n5A__&session_key=2.xv9mi6QSOpr474s4n2X_pw__.3600.1273287600-2905623&sig=eeef60838c0c800258d89b7e6ddddddb&uid=2905623"'
+  offline_access_cookies: 
+    # note: I've revoked the offline access for security reasons, so you can't make calls against this :)
+    fbs_119908831367602: '"access_token=119908831367602|08170230801eb225068e7a70-2905623|Q3LDCYYF8CX9cstxnZLsxiR0nwg.&expires=0&secret=78abaee300b392e275072a9f2727d436&session_key=08170230801eb225068e7a70-2905623&sig=423b8aa4b6fa1f9a571955f8e929d567&uid=2905623"'

data/test/koala/facebook_no_access_token_tests.rb

@@ -0,0 +1,128 @@
+class FacebookNoAccessTokenTests < Test::Unit::TestCase
+  
+  describe "Koala GraphAPI without an access token" do
+    before :each do
+      @graph = Koala::Facebook::GraphAPI.new
+    end
+  
+    it "should get public data about a user" do
+      result = @graph.get_object("koppel")
+      # the results should have an ID and a name, among other things
+      (result["id"] && result["name"]).should
+    end
+
+    it "should not get private data about a user" do
+      result = @graph.get_object("koppel")
+      # updated_time should be a pretty fixed test case
+      result["updated_time"].should be_nil
+    end
+
+  
+    it "should get public data about a Page" do
+      result = @graph.get_object("contextoptional")
+      # the results should have an ID and a name, among other things
+      (result["id"] && result["name"]).should
+    end
+  
+    it "should not be able to get data about 'me'" do
+      begin
+        @graph.get_object("me")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+  
+    it "should be able to get multiple objects" do
+      results = @graph.get_objects(["contextoptional", "naitik"])
+      results.length.should == 2
+    end
+  
+    it "shouldn't be able to access connections from users" do
+      begin
+        @graph.get_connections("lukeshepard", "likes")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+
+    it "should be able to access connections from public Pages" do
+      result = @graph.get_connections("contextoptional", "likes")
+      result["data"].should be_a(Array)
+    end
+  
+    it "should not be able to put an object" do
+      begin
+        @result = @graph.put_object("lukeshepard", "feed", :message => "Hello, world")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+
+    # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
+    it "should not be able to post to a feed" do
+      begin
+        @result = @graph.put_wall_post("Hello, world", {:name => "Context Optional", :link => "http://www.contextoptional.com/"}, "contextoptional")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+
+    it "should not be able to comment on an object" do
+      begin
+        # random public post on the ContextOptional wall
+        @result = @graph.put_comment("7204941866_119776748033392", "The hackathon was great!")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+
+    it "should not be able to like an object" do
+      begin
+        @result = @graph.put_like("7204941866_119776748033392")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+
+
+    # DELETE
+    it "should not be able to delete posts" do 
+      begin
+        # test post on the Ruby SDK Test application
+        @result = @graph.delete_object("115349521819193_113815981982767")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue Exception => wrong_err
+      end
+      @right_err.should_not be_nil
+    end
+
+    # SEARCH
+    it "should be able to search" do
+      result = @graph.search("facebook")
+      result["data"].should be_an(Array)
+    end
+    
+    # FQL
+    it "should be able to access public information via FQL" do
+      @result = @graph.fql('select first_name from user where uid = 216743')
+      @result.size.should  == 1
+      @result.first['first_name'].should == 'Chris'
+    end
+    
+    it "should not be able to access protected information via FQL" do
+      lambda { @graph.fql("select read_stream from permissions where uid = 216743") }.should raise_error(Koala::Facebook::RestAPIError)
+    end
+    
+    # API
+    # the above tests test this already, but we should consider additional api tests
+    
+  end # describe
+
+end #class
+  

data/test/koala/facebook_oauth_tests.rb

@@ -0,0 +1,202 @@
+# stub the Time class to always return a time for which the valid cookie is still valid
+class Time
+  def self.now
+    self
+  end
+  
+  def self.to_i
+    1273363199
+  end
+end
+
+class FacebookOAuthTests < Test::Unit::TestCase
+  describe "Koala GraphAPI without an access token" 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"]
+      
+      # 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)
+    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
+    
+    # cookie parsing
+    it "should properly parse valid cookies" do
+      result = @oauth.get_user_from_cookie(@oauth_data["valid_cookies"])
+      result["uid"].should
+    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 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 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 "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 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
+    end
+    
+    # OAuth URLs
+    
+    # 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 raise an exception if no callback is given in initialization or the call" do 
+      oauth2 = Koala::Facebook::OAuth.new(@app_id, @secret)
+      begin
+        url = oauth2.url_for_oauth_code
+      rescue ArgumentError => @right_err
+      rescue
+      end
+      
+      @right_err.should
+    end
+
+    # 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
+    
+    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
+      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
+    
+    # parse_access_token
+    it "should properly parse access token results" do
+      result = @oauth.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.parse_access_token(@raw_offline_access_token_string)
+      has_both_parts = result["access_token"] && !result["expires"]
+      has_both_parts.should
+    end
+
+    # fetch_token_string
+    # note -- we just test that this looks right, since get_access_token tests the parsing too
+    it "should fetch a proper token string from Facebook when given a code" do
+      result = @oauth.fetch_token_string(@code)
+      result.should =~ /^access_token/
+    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
+    end
+
+    it "should raise an error when get_access_token is called with a bad code" do
+      begin
+        result = @oauth.get_access_token("foo")
+      rescue Koala::Facebook::GraphAPIError => @right_err
+      rescue
+      end
+      @right_err.should
+    end
+  end # describe
+
+end #class

data/test/koala/facebook_with_access_token_tests.rb

@@ -0,0 +1,155 @@
+class FacebookWithAccessTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAPI with an access token" do
+    before :each do
+      token = $testing_data["oauth_token"]
+      raise Exception, "Must supply access token to run FacebookWithAccessTokenTests!" unless token
+      @graph = Koala::Facebook::GraphAPI.new(token)
+    end
+    
+    after :each do 
+      # clean up any temporary objects
+      if @temporary_object_id
+        puts "\nCleaning up temporary object #{@temporary_object_id.to_s}"
+        result = @graph.delete_object(@temporary_object_id)
+        raise "Unable to clean up temporary Graph object #{@temporary_object_id}!" unless result
+      end
+    end
+
+    it "should get public data about a user" do
+      result = @graph.get_object("koppel")
+      # the results should have an ID and a name, among other things
+      (result["id"] && result["name"]).should_not be_nil
+    end
+
+    it "should get private data about a user" do
+      result = @graph.get_object("koppel")
+      # updated_time should be a pretty fixed test case
+      result["updated_time"].should_not be_nil
+    end
+
+    it "should get public data about a Page" do
+      result = @graph.get_object("contextoptional")
+      # the results should have an ID and a name, among other things
+      (result["id"] && result["name"]).should
+    end
+  
+    it "should get data about 'me'" do
+      result = @graph.get_object("me")
+      result["updated_time"].should
+    end
+  
+    it "should be able to get multiple objects" do
+      result = @graph.get_objects(["contextoptional", "naitik"])
+      result.length.should == 2
+    end
+  
+    it "should be able to access connections from users" do
+      result = @graph.get_connections("lukeshepard", "likes")
+      result["data"].length.should > 0
+    end
+
+    it "should be able to access connections from public Pages" do
+      result = @graph.get_connections("contextoptional", "likes")
+      result["data"].should be_a(Array)
+    end
+    
+    # PUT
+    it "should be able to write an object to the graph" do
+      result = @graph.put_wall_post("Hello, world, from the test suite!")
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+
+    # DELETE
+    it "should be able to delete posts" do 
+      result = @graph.put_wall_post("Hello, world, from the test suite delete method!")
+      object_id_to_delete = result["id"]
+      delete_result = @graph.delete_object(object_id_to_delete)
+      delete_result.should == true
+    end
+
+    # additional put tests
+    it "should be able to verify messages posted to a wall" do
+      message = "the cats are asleep"
+      put_result = @graph.put_wall_post(message)
+      @temporary_object_id = put_result["id"]
+      get_result = @graph.get_object(@temporary_object_id)
+      
+      # make sure the message we sent is the message that got posted
+      get_result["message"].should == message
+    end
+
+    it "should be able to post a message with an attachment to a feed" do
+      result = @graph.put_wall_post("Hello, world, from the test suite again!", {:name => "Context Optional", :link => "http://www.contextoptional.com/"})
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+    
+    it "should be able to verify a message with an attachment posted to a feed" do
+      attachment = {"name" => "Context Optional", "link" => "http://www.contextoptional.com/"}
+      result = @graph.put_wall_post("Hello, world, from the test suite again!", attachment)
+      @temporary_object_id = result["id"]
+      get_result = @graph.get_object(@temporary_object_id)
+
+      # make sure the result we fetch includes all the parameters we sent
+      it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
+      it_matches.should == true 
+    end
+
+    it "should be able to comment on an object" do
+      result = @graph.put_wall_post("Hello, world, from the test suite, testing comments!")
+      @temporary_object_id = result["id"]
+      
+      # this will be deleted when the post gets deleted 
+      comment_result = @graph.put_comment(@temporary_object_id, "it's my comment!")
+      comment_result.should_not be_nil
+    end
+    
+    it "should be able to verify a comment posted about an object" do
+      message_text = "Hello, world, from the test suite, testing comments!"
+      result = @graph.put_wall_post(message_text)
+      @temporary_object_id = result["id"]
+      
+      # this will be deleted when the post gets deleted 
+      comment_text = "it's my comment!"
+      comment_result = @graph.put_comment(@temporary_object_id, comment_text)
+      get_result = @graph.get_object(comment_result["id"])
+
+      # make sure the text of the comment matches what we sent
+      get_result["message"].should == comment_text
+    end
+
+    it "should be able to like an object" do
+      result = @graph.put_wall_post("Hello, world, from the test suite, testing comments!")
+      @temporary_object_id = result["id"]
+      like_result = @graph.put_like(@temporary_object_id)
+    end
+
+    # SEARCH
+    it "should be able to search" do
+      result = @graph.search("facebook")
+      result["data"].should be_an(Array)
+    end
+    
+    # FQL
+    it "should be able to access public information via FQL" do
+      result = @graph.fql('select first_name from user where uid = 216743')
+      result.size.should  == 1
+      result.first['first_name'].should == 'Chris'
+    end
+    
+    it "should be able to access protected information via FQL" do
+      # Tests agains read_stream since these tests assume we have that permission
+      YOUR_ID = 216743
+      result = @graph.fql("select read_stream from permissions where uid = #{YOUR_ID}")
+      
+      result.size.should == 1
+      result.first['read_stream'].should == 1
+    end
+ 
+    # API
+    # the above tests test this already, but we should consider additional api tests
+    
+  end # describe
+
+end #class

data/test/koala_tests.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'rubygems'
+require 'spec/test/unit'
+
+# load the libraries
+require 'koala' 
+
+# load the tests
+require 'koala/facebook_no_access_token_tests'
+require 'koala/facebook_with_access_token_tests'
+require 'koala/facebook_oauth_tests'
+
+class FacebookTestSuite
+  def self.suite
+    suite = Test::Unit::TestSuite.new
+    suite << FacebookNoAccessTokenTests.suite
+    suite << FacebookWithAccessTokenTests.suite
+    suite << FacebookOAuthTests.suite
+    suite
+  end
+end
+
+# load testing data (see note in readme.md)
+# I'm seeing a bug with spec and gets where the facebook_test_suite.rb file gets read in when gets is called
+# until that's solved, we'll need to store/update tokens in the access_token file
+$testing_data = YAML.load_file("facebook_data.yml") rescue {}
+
+unless $testing_data["oauth_token"]
+  puts "Access token tests will fail until you store a valid token in facebook_data.yml"
+end
+
+# TODO finish tests for OAuth class
+# unless $testing_data["cookie_hash"] && $testing_data["app_id"] && $testing_data["secret"]
+#   puts "Cookie tests will fail until you store valid data for the cookie hash, app_id, and app secret in facebook_data.yml"
+# end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: cbaclig-koala
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  - 1
+  version: 0.5.0.1
+platform: ruby
+authors: 
+- Alex Koppel, Rafi Jacoby, Context Optional
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-11 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Koala is a lightweight, flexible Ruby SDK for Facebook's new Graph API.  It allows read/write access to the Facebook Graph and provides OAuth URLs and cookie validation for Facebook Connect sites.  Koala supports Net::HTTP and Typhoeus connections out of the box and can accept custom modules for other services.
+email: alex@alexkoppel.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- lib/http_services.rb
+- lib/koala.rb
+files: 
+- CHANGELOG
+- Manifest
+- Rakefile
+- init.rb
+- lib/http_services.rb
+- lib/koala.rb
+- readme.md
+- test/facebook_data.yml
+- test/koala/facebook_no_access_token_tests.rb
+- test/koala/facebook_oauth_tests.rb
+- test/koala/facebook_with_access_token_tests.rb
+- test/koala_tests.rb
+- cbaclig-koala.gemspec
+has_rdoc: true
+homepage: http://github.com/arsduo/koala
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Cbaclig-koala
+- --main
+- readme.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: cbaclig-koala
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A lightweight, flexible library for Facebook's new Graph API
+test_files: []
+