koala 1.0.0.beta → 1.0.0

data/lib/koala/http_services.rb

@@ -15,26 +15,19 @@ module Koala
         class << self
           attr_accessor :always_use_ssl
         end
-        
+               
+        def self.server(options = {})
+          "#{options[:beta] ? "beta." : ""}#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"          
+        end
+                                      
         protected
+        
         def self.params_require_multipart?(param_hash)
-          param_hash.any? { |key, value| is_valid_file_hash?(value) }
+          param_hash.any? { |key, value| value.kind_of?(Koala::UploadableIO) }
         end
-        
-        # A file hash can take two forms:
-        # - A hash with "content_type" and "path" keys where "path" is the local path
-        #   to the file to be uploaded.
-        # - A hash with the "file" key containing an already-opened IO that responds to "read"
-        #   as well as "content_type" and the "path" key to the original file
-        #   ("path"" is required by multipart-post even for opened files)
-        #
-        # Valid inputs for a file to be posted via multipart/form-data
-        # are based on the criteria for an UploadIO to be created 
-        # See : https://github.com/nicksieger/multipart-post/blob/master/lib/composite_io.rb       
-        def self.is_valid_file_hash?(value)
-          value.kind_of?(Hash) and value.key?("content_type") and value.key?("path") and (
-            !value.key?("file") or value["file"].respond_to?(:read)
-          )
+    
+        def self.multipart_requires_content_type?
+          true
         end
       end
     end
@@ -61,16 +54,9 @@ module Koala
           # 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"
 
-          server = options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER
-          http = Net::HTTP.new(server, private_request ? 443 : nil)
+          http = create_http(server(options), private_request, options)
           http.use_ssl = true if private_request
 
-          # 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 do |http|
             response, body = if verb == "post"
               if params_require_multipart? args
@@ -98,17 +84,25 @@ module Koala
         
         def self.encode_multipart_params(param_hash)
           Hash[*param_hash.collect do |key, value| 
-            if is_valid_file_hash?(value)
-              if value.key?("file")
-                value = UploadIO.new(value["file"], value["content_type"], value["path"])
-              else
-                value = UploadIO.new(value["path"], value['content_type'])
-              end
-            end
-            
-            [key, value]
+            [key, value.kind_of?(Koala::UploadableIO) ? value.to_upload_io : value]
           end.flatten]
         end
+
+        def self.create_http(server, private_request, options)
+          if options[:proxy]
+            proxy = URI.parse(options[:proxy])
+            http  = Net::HTTP.new(server, private_request ? 443 : nil,
+                                  proxy.host, proxy.port, proxy.user, proxy.password)
+          else
+            http = Net::HTTP.new(server, private_request ? 443 : nil)
+          end
+          if options[:timeout]
+            http.open_timeout = options[:timeout]
+            http.read_timeout = options[:timeout]
+          end
+          http
+        end
+
       end
     end
   end
@@ -116,11 +110,6 @@ module Koala
   module TyphoeusService
     # this service uses Typhoeus to send requests to the graph
 
-    # used for multipart file uploads (see below)
-    class NetHTTPInterface
-      include NetHTTPService
-    end
-
     def self.included(base)
       base.class_eval do
         require "typhoeus" unless defined?(Typhoeus)
@@ -129,25 +118,27 @@ module Koala
         include Koala::HTTPService
 
         def self.make_request(path, args, verb, options = {})
-          unless params_require_multipart?(args)
-            # 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"
-            server = options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER
+          # 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"
 
-            # you can pass arguments directly to Typhoeus using the :typhoeus_options key
-            typhoeus_options = {:params => args}.merge(options[:typhoeus_options] || {})
+          # switch any UploadableIOs to the files Typhoeus expects 
+          args.each_pair {|key, value| args[key] = value.to_file if value.is_a?(UploadableIO)}
 
-            # by default, we use SSL only for private requests (e.g. with access token)
-            # this makes public requests faster
-            prefix = (args["access_token"] || @always_use_ssl || options[:use_ssl]) ? "https" : "http"
+          # you can pass arguments directly to Typhoeus using the :typhoeus_options key
+          typhoeus_options = {:params => args}.merge(options[:typhoeus_options] || {})
 
-            response = self.send(verb, "#{prefix}://#{server}#{path}", typhoeus_options)
-            Koala::Response.new(response.code, response.body, response.headers_hash)
-          else
-            # we have to use NetHTTPService for multipart for file uploads
-            # until Typhoeus integrates support
-            Koala::TyphoeusService::NetHTTPInterface.make_request(path, args, verb, options)
-          end
+          # by default, we use SSL only for private requests (e.g. with access token)
+          # this makes public requests faster
+          prefix = (args["access_token"] || @always_use_ssl || options[:use_ssl]) ? "https" : "http"
+
+          response = self.send(verb, "#{prefix}://#{server(options)}#{path}", typhoeus_options)
+          Koala::Response.new(response.code, response.body, response.headers_hash)
+        end
+        
+        private
+        
+        def self.multipart_requires_content_type?
+          false # Typhoeus handles multipart file types, we don't have to require it
         end
       end # class_eval
     end

data/lib/koala/test_users.rb

@@ -20,11 +20,11 @@ module Koala
         @graph_api = GraphAPI.new(@app_access_token)
       end
 
-      def create(installed, permissions = nil)
+      def create(installed, permissions = nil, args = {}, options = {})
         # Creates and returns a test user
-        args = {'installed' => installed}
+        args['installed'] = installed
         args['permissions'] = (permissions.is_a?(Array) ? permissions.join(",") : permissions) if installed
-        result = @graph_api.graph_call(accounts_path, args, "post")
+        result = @graph_api.graph_call(accounts_path, args, "post", options)
       end
       
       def list
@@ -40,12 +40,25 @@ module Koala
         list.each {|u| delete u }
       end
       
-      def befriend(user1, user2)
-        user1 = user1["id"] if user1.is_a?(Hash)
-        user2 = user2["id"] if user2.is_a?(Hash)
-        @graph_api.graph_call("/#{user1}/friends/#{user2}") && @graph_api.graph_call("/#{user2}/friends/#{user1}")
+      def befriend(user1_hash, user2_hash)
+        user1_id = user1_hash["id"] || user1_hash[:id]
+        user2_id = user2_hash["id"] || user2_hash[:id]
+        user1_token = user1_hash["access_token"] || user1_hash[:access_token]
+        user2_token = user2_hash["access_token"] || user2_hash[:access_token]
+        unless user1_id && user2_id && user1_token && user2_token
+          # we explicitly raise an error here to minimize the risk of confusing output
+          # if you pass in a string (as was previously supported) no local exception would be raised
+          # but the Facebook call would fail
+          raise ArgumentError, "TestUsers#befriend requires hash arguments for both users with id and access_token"
+        end
+        
+        u1_graph_api = GraphAPI.new(user1_token)
+        u2_graph_api = GraphAPI.new(user2_token)
+
+        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post") && 
+          u2_graph_api.graph_call("#{user2_id}/friends/#{user1_id}", {}, "post")
       end
-      
+
       def create_network(network_size, installed = true, permissions = '')
         network_size = 50 if network_size > 50 # FB's max is 50
         users = (0...network_size).collect { create(installed, permissions) }

data/lib/koala/uploadable_io.rb

@@ -0,0 +1,115 @@
+require 'koala'
+
+module Koala
+  class UploadableIO
+    attr_reader :io_or_path, :content_type
+
+    def initialize(io_or_path_or_mixed, content_type = nil)
+      # see if we got the right inputs
+      if content_type.nil?
+        parse_init_mixed_param io_or_path_or_mixed
+      elsif !content_type.nil? && (io_or_path_or_mixed.respond_to?(:read) or io_or_path_or_mixed.kind_of?(String))
+        @io_or_path = io_or_path_or_mixed
+        @content_type = content_type
+      end
+      
+      raise KoalaError.new("Invalid arguments to initialize an UploadableIO") unless @io_or_path
+      raise KoalaError.new("Unable to determine MIME type for UploadableIO") if !@content_type && Koala.multipart_requires_content_type?
+    end
+    
+    def to_upload_io
+      UploadIO.new(@io_or_path, @content_type, "koala-io-file.dum")
+    end
+    
+    def to_file
+      @io_or_path.is_a?(String) ? File.open(@io_or_path) : @io_or_path
+    end
+
+    private
+      PARSE_STRATEGIES = [
+        :parse_rails_3_param,
+        :parse_sinatra_param,
+        :parse_file_object,
+        :parse_string_path
+      ]
+      
+      def parse_init_mixed_param(mixed)
+        PARSE_STRATEGIES.each do |method|
+          send(method, mixed)
+          return if @io_or_path && @content_type
+        end
+      end
+      
+      # Expects a parameter of type ActionDispatch::Http::UploadedFile
+      def parse_rails_3_param(uploaded_file)
+        if uploaded_file.respond_to?(:content_type) and uploaded_file.respond_to?(:tempfile) and uploaded_file.tempfile.respond_to?(:path)
+          @io_or_path = uploaded_file.tempfile.path
+          @content_type = uploaded_file.content_type
+        end
+      end
+      
+      # Expects a Sinatra hash of file info
+      def parse_sinatra_param(file_hash)
+        if file_hash.kind_of?(Hash) and file_hash.has_key?(:type) and file_hash.has_key?(:tempfile)
+          @io_or_path = file_hash[:tempfile]
+          @content_type = file_hash[:type] || detect_mime_type(tempfile)
+        end
+      end
+      
+      # takes a file object
+      def parse_file_object(file)
+        if file.kind_of?(File)
+          @io_or_path = file
+          @content_type = detect_mime_type(file.path)
+        end
+      end
+      
+      def parse_string_path(path)
+        if path.kind_of?(String)
+          @io_or_path = path
+          @content_type = detect_mime_type(path)
+        end
+      end
+      
+      MIME_TYPE_STRATEGIES = [
+        :use_mime_module,
+        :use_simple_detection
+      ]
+      
+      def detect_mime_type(filename)
+        if filename
+          MIME_TYPE_STRATEGIES.each do |method|
+            result = send(method, filename)
+            return result if result
+          end
+        end
+        nil # if we can't find anything
+      end
+      
+      def use_mime_module(filename)
+        # if the user has installed mime/types, we can use that
+        # if not, rescue and return nil
+        begin
+          type = MIME::Types.type_for(filename).first
+          type ? type.to_s : nil
+        rescue
+          nil
+        end
+      end
+      
+      def use_simple_detection(filename)
+        # very rudimentary extension analysis for images
+        # first, get the downcased extension, or an empty string if it doesn't exist
+        extension = ((filename.match(/\.([a-zA-Z0-9]+)$/) || [])[1] || "").downcase
+        if extension == ""
+          nil
+        elsif extension == "jpg" || extension == "jpeg"
+          "image/jpeg"
+        elsif extension == "png"
+          "image/png"
+        elsif extension == "gif"
+          "image/gif"
+        end
+      end
+  end
+end

data/lib/koala.rb

@@ -1,55 +1,32 @@
 require 'cgi'
 require 'digest/md5'
 
-# rubygems is required to support json, how facebook returns data
-require 'rubygems'
 require 'json'
 
 # OpenSSL and Base64 are required to support signed_request
 require 'openssl'
 require 'base64'
 
-# include default http services
+# include koala modules
 require 'koala/http_services'
-
-# add Graph API methods
 require 'koala/graph_api'
-
-# add REST API methods
 require 'koala/rest_api'
-
-# add realtime update methods
 require 'koala/realtime_updates'
-
-# add test user methods
 require 'koala/test_users'
 
+# add KoalaIO class
+require 'koala/uploadable_io'
+
 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/.
+    # Copyright 2010-2011 Alex Koppel
+    # Contributors: Alex Koppel, Chris Baclig, Rafi Jacoby, and the team at Context Optional
+    # http://github.com/arsduo/koala
 
     class API
-      # initialize with an access token 
+      # initialize with an access token
       def initialize(access_token = nil)
         @access_token = access_token
       end
@@ -58,7 +35,7 @@ module Koala
       def api(path, args = {}, verb = "get", options = {}, &error_checking_block)
         # Fetches the given path in the Graph API.
         args["access_token"] = @access_token || @app_access_token if @access_token || @app_access_token
-
+        
         # add a leading /
         path = "/#{path}" unless path =~ /^\//
 
@@ -110,7 +87,7 @@ module Koala
       attr_reader :graph_api
     end
 
-    class APIError < Exception
+    class APIError < StandardError
       attr_accessor :fb_error_type
       def initialize(details = {})
         self.fb_error_type = details["type"]
@@ -170,12 +147,13 @@ module Koala
         # for permissions, see http://developers.facebook.com/docs/authentication/permissions
         permissions = options[:permissions]
         scope = permissions ? "&scope=#{permissions.is_a?(Array) ? permissions.join(",") : permissions}" : ""
-
+        display = options.has_key?(:display) ? "&display=#{options[:display]}" : ""
+        
         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}"
+        "https://#{GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}#{scope}#{display}"
       end
 
       def url_for_access_token(code, options = {})
@@ -185,70 +163,56 @@ module Koala
         "https://#{GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@app_secret}&code=#{code}"
       end
 
-      def get_access_token_info(code)
+      def get_access_token_info(code, options = {})
         # 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)
+        get_token_from_server({:code => code, :redirect_uri => @oauth_callback_url}, false, options)
       end
 
-      def get_access_token(code)
+      def get_access_token(code, options = {})
         # upstream methods will throw errors if needed
-        if info = get_access_token_info(code)
+        if info = get_access_token_info(code, options)
           string = info["access_token"]
         end
       end
 
-      def get_app_access_token_info
+      def get_app_access_token_info(options = {})
         # convenience method to get a the application's sessionless access token
-        get_token_from_server({:type => 'client_cred'}, true)
+        get_token_from_server({:type => 'client_cred'}, true, options)
       end
 
-      def get_app_access_token
-        if info = get_app_access_token_info
+      def get_app_access_token(options = {})
+        if info = get_app_access_token_info(options)
           string = info["access_token"]
         end
       end
-    
-      # provided directly by Facebook
-      # see https://github.com/facebook/crypto-request-examples/blob/master/sample.rb
-      # and http://developers.facebook.com/docs/authentication/canvas/encryption_proposal
-      def parse_signed_request(input, max_age = 3600)
+
+      # Originally provided directly by Facebook, however this has changed
+      # as their concept of crypto changed. For historic purposes, this is their proposal:
+      # https://developers.facebook.com/docs/authentication/canvas/encryption_proposal/
+      # Currently see https://github.com/facebook/php-sdk/blob/master/src/facebook.php#L758
+      # for a more accurate reference implementation strategy.
+      def parse_signed_request(input)
         encoded_sig, encoded_envelope = input.split('.', 2)
+        signature = base64_url_decode(encoded_sig).unpack("H*").first
         envelope = JSON.parse(base64_url_decode(encoded_envelope))
-        algorithm = envelope['algorithm']
-
-        raise 'Invalid request. (Unsupported algorithm.)' \
-          if algorithm != 'AES-256-CBC HMAC-SHA256' && algorithm != 'HMAC-SHA256'
-
-        raise 'Invalid request. (Too old.)' \
-          if algorithm == "AES-256-CBC HMAC-SHA256" && envelope['issued_at'].to_i < Time.now.to_i - max_age
-
-        raise 'Invalid request. (Invalid signature.)' \
-          if base64_url_decode(encoded_sig) !=
-              OpenSSL::HMAC.hexdigest(
-                'sha256', @app_secret, encoded_envelope).split.pack('H*')
-
-        # for requests that are signed, but not encrypted, we're done
-        return envelope if algorithm == 'HMAC-SHA256'
-
-        # otherwise, decrypt the payload
-        cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
-        cipher.decrypt
-        cipher.key = @app_secret
-        cipher.iv = base64_url_decode(envelope['iv'])
-        cipher.padding = 0
-        decrypted_data = cipher.update(base64_url_decode(envelope['payload']))
-        decrypted_data << cipher.final
-        return JSON.parse(decrypted_data.strip)
+
+        raise "SignedRequest: Unsupported algorithm #{envelope['algorithm']}" if envelope['algorithm'] != 'HMAC-SHA256'
+
+        # now see if the signature is valid (digest, key, data)
+        hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, @app_secret, encoded_envelope.tr("-_", "+/"))
+        raise 'SignedRequest: Invalid signature' if (signature != hmac)
+
+        return envelope
       end
 
       # from session keys
-      def get_token_info_from_session_keys(sessions)
+      def get_token_info_from_session_keys(sessions, options = {})
         # fetch the OAuth tokens from Facebook
         response = fetch_token_string({
           :type => 'client_cred',
           :sessions => sessions.join(",")
-        }, true, "exchange_sessions")
+        }, true, "exchange_sessions", options)
 
         # Facebook returns an empty body in certain error conditions
         if response == ""
@@ -261,24 +225,24 @@ module Koala
         JSON.parse(response)
       end
 
-      def get_tokens_from_session_keys(sessions)
+      def get_tokens_from_session_keys(sessions, options = {})
         # get the original hash results
-        results = get_token_info_from_session_keys(sessions)
+        results = get_token_info_from_session_keys(sessions, options)
         # now recollect them as just the access tokens
         results.collect { |r| r ? r["access_token"] : nil }
       end
 
-      def get_token_from_session_key(session)
+      def get_token_from_session_key(session, options = {})
         # convenience method for a single key
         # gets the overlaoded strings automatically
-        get_tokens_from_session_keys([session])[0]
+        get_tokens_from_session_keys([session], options)[0]
       end
 
       protected
 
-      def get_token_from_server(args, post = false)
+      def get_token_from_server(args, post = false, options = {})
         # fetch the result from Facebook's servers
-        result = fetch_token_string(args, post)
+        result = fetch_token_string(args, post, "access_token", options)
 
         # if we have an error, parse the error JSON and raise an error
         raise APIError.new((JSON.parse(result)["error"] rescue nil) || {}) if result =~ /error/
@@ -295,22 +259,24 @@ module Koala
         components
       end
 
-      def fetch_token_string(args, post = false, endpoint = "access_token")
+      def fetch_token_string(args, post = false, endpoint = "access_token", options = {})
         Koala.make_request("/oauth/#{endpoint}", {
           :client_id => @app_id,
           :client_secret => @app_secret
-        }.merge!(args), post ? "post" : "get", :use_ssl => true).body
+        }.merge!(args), post ? "post" : "get", {:use_ssl => true}.merge!(options)).body
       end
 
       # base 64
       # directly from https://github.com/facebook/crypto-request-examples/raw/master/sample.rb
       def base64_url_decode(str)
         str += '=' * (4 - str.length.modulo(4))
-        Base64.decode64(str.gsub('-', '+').gsub('_', '/'))
+        Base64.decode64(str.tr('-_', '+/'))
       end
     end
   end
 
+  class KoalaError< StandardError; 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)
@@ -318,6 +284,8 @@ module Koala
   end
 
   # by default, try requiring Typhoeus -- if that works, use it
+  # if you have Typheous and don't want to use it (or want another service),
+  # you can run Koala.http_service = NetHTTPService (or MyHTTPService)
   begin
     Koala.http_service = TyphoeusService
   rescue LoadError

data/readme.md

@@ -1,12 +1,22 @@
 Koala
 ====
-Koala (<a href="http://github.com/arsduo/koala" target="_blank">http://github.com/arsduo/koala</a>) is a new Facebook library for Ruby, supporting the Graph API, the old REST API, realtime updates, and OAuth validation.  We wrote Koala with four goals:
+Koala (<a href="http://github.com/arsduo/koala" target="_blank">http://github.com/arsduo/koala</a>) is a new Facebook library for Ruby, supporting the Graph API (including photo uploads), the old REST API, realtime updates, and OAuth validation.  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 750 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.  (Our complete test coverage can be run against either mocked responses or the live Facebook servers.)
 
+1.0 
+---
+Version 1.0 is due out on May 1st, 2011 with a ton of great features.  
+    
+    sudo gem install koala
+
+Until then, you can install the release candidate like so:
+  
+    sudo gem install koala --pre
+  
 Graph API
 ----
 The Graph API is the simple, slick new interface to Facebook's data.  Using it with Koala is quite straightforward:
@@ -120,11 +130,14 @@ Testing
 -----
 
 Unit tests are provided for all of Koala's methods.  By default, these tests run against mock responses and hence are ready out of the box:
-    # From the spec directory
-    spec koala_spec.rb
+    
+    # From anywhere in the project directory:
+    rake spec
+    
 
 You can also run live tests against Facebook's servers:
-    # Again from the spec directory
-    spec koala_spec_without_mocks.rb
+    
+    # Again from anywhere in the project directory:
+    LIVE=true rake spec
 
-Important Note: to run the live tests, 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.  You can get these data at the OAuth Playground; if you want to use your own app, remember to swap out the app ID, secret, and other values.  (The file also provides valid values for other tests, which you're welcome to swap out for data specific to your own application.)
+Important Note: to run the live tests, you have to provide some of your own data in spec/fixtures/facebook_data.yml: a valid OAuth access token with publish\_stream, read\_stream, and user\_photos permissions and an OAuth code that can be used to generate an access token.  You can get thisdata at the OAuth Playground; if you want to use your own app, remember to swap out the app ID, secret, and other values.  (The file also provides valid values for other tests, which you're welcome to swap out for data specific to your own application.)