koala 1.1.0 → 1.2.0beta1

data/lib/koala/uploadable_io.rb

@@ -1,36 +1,30 @@
-require 'koala'
+require "net/http/post/multipart"
 
 module Koala
   class UploadableIO
-    attr_reader :io_or_path, :content_type, :requires_base_http_service
+    attr_reader :io_or_path, :content_type, :filename
 
     def initialize(io_or_path_or_mixed, content_type = nil, filename = 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
-      
-      # Probably a StringIO or similar object, which won't work with Typhoeus
-      @requires_base_http_service = @io_or_path.respond_to?(:read) && !@io_or_path.kind_of?(File)
+      parse_init_mixed_param io_or_path_or_mixed, content_type
 
       # filename is used in the Ads API
-      @filename = filename || "koala-io-file.dum"
+      # if it's provided, take precedence over the detected filename
+      # otherwise, fall back to a dummy name
+      @filename = filename || @filename || "koala-io-file.dum"
 
       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?
+      raise KoalaError.new("Unable to determine MIME type for UploadableIO") if !@content_type
     end
-    
+
     def to_upload_io
       UploadIO.new(@io_or_path, @content_type, @filename)
     end
-    
+
     def to_file
       @io_or_path.is_a?(String) ? File.open(@io_or_path) : @io_or_path
     end
-    
+
     def self.binary_content?(content)
       content.is_a?(UploadableIO) || DETECTION_STRATEGIES.detect {|method| send(method, content)}
     end
@@ -41,69 +35,80 @@ module Koala
       :rails_3_param?,
       :file_param?
     ]
-  
+
     PARSE_STRATEGIES = [
       :parse_rails_3_param,
       :parse_sinatra_param,
       :parse_file_object,
       :parse_string_path
     ]
-    
-    def parse_init_mixed_param(mixed)
+
+    def parse_init_mixed_param(mixed, content_type = nil)
       PARSE_STRATEGIES.each do |method|
-        send(method, mixed)
+        send(method, mixed, content_type)
         return if @io_or_path && @content_type
       end
     end
-    
+
     # Expects a parameter of type ActionDispatch::Http::UploadedFile
     def self.rails_3_param?(uploaded_file)
       uploaded_file.respond_to?(:content_type) and uploaded_file.respond_to?(:tempfile) and uploaded_file.tempfile.respond_to?(:path)
     end
-    
-    def parse_rails_3_param(uploaded_file)
-      if UploadableIO.rails_3_param?(uploaded_file) 
+
+    def parse_rails_3_param(uploaded_file, content_type = nil)
+      if UploadableIO.rails_3_param?(uploaded_file)
         @io_or_path = uploaded_file.tempfile.path
-        @content_type = uploaded_file.content_type
+        @content_type = content_type || uploaded_file.content_type
+        @filename = uploaded_file.original_filename
       end
     end
-    
+
     # Expects a Sinatra hash of file info
     def self.sinatra_param?(file_hash)
       file_hash.kind_of?(Hash) and file_hash.has_key?(:type) and file_hash.has_key?(:tempfile)
     end
-    
-    def parse_sinatra_param(file_hash)
+
+    def parse_sinatra_param(file_hash, content_type = nil)
       if UploadableIO.sinatra_param?(file_hash)
         @io_or_path = file_hash[:tempfile]
-        @content_type = file_hash[:type] || detect_mime_type(tempfile)
+        @content_type = content_type || file_hash[:type] || detect_mime_type(tempfile)
+        @filename = file_hash[:filename]
       end
     end
-    
+
     # takes a file object
     def self.file_param?(file)
       file.kind_of?(File)
     end
-    
-    def parse_file_object(file)
+
+    def parse_file_object(file, content_type = nil)
       if UploadableIO.file_param?(file)
         @io_or_path = file
-        @content_type = detect_mime_type(file.path)
+        @content_type = content_type || detect_mime_type(file.path)
+        @filename = File.basename(file.path)
       end
     end
-    
-    def parse_string_path(path)
+
+    def parse_string_path(path, content_type = nil)
       if path.kind_of?(String)
         @io_or_path = path
-        @content_type = detect_mime_type(path)
+        @content_type = content_type || detect_mime_type(path)
+        @filename = File.basename(path)
+      end
+    end
+
+    def parse_io(io, content_type = nil)
+      if io.respond_to?(:read)
+        @io_or_path = io
+        @content_type = content_type
       end
     end
-    
+
     MIME_TYPE_STRATEGIES = [
       :use_mime_module,
       :use_simple_detection
     ]
-    
+
     def detect_mime_type(filename)
       if filename
         MIME_TYPE_STRATEGIES.each do |method|
@@ -113,7 +118,7 @@ module Koala
       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
@@ -124,12 +129,12 @@ module Koala
         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
-      case extension 
+      case extension
         when ""
           nil
         # images
@@ -169,7 +174,7 @@ module Koala
         	"video/ogg"
         when "wmv"
         	"video/x-ms-wmv"
-      end    
+      end
     end
   end
 end

data/lib/koala/utils.rb

@@ -0,0 +1,11 @@
+module Koala
+  module Utils
+    def self.deprecate(message)
+      begin
+        send(:warn, "KOALA: Deprecation warning: #{message}")
+      rescue Exception => err
+        puts "Unable to issue Koala deprecation warning!  #{err.message}"
+      end
+    end
+  end
+end

data/readme.md

@@ -1,77 +1,77 @@
+[![Build Status](https://secure.travis-ci.org/arsduo/koala.png)](http://travis-ci.org/arsduo/koala)
+
 Koala
 ====
-[Koala](http://github.com/arsduo/koala) is a new Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), the REST API, realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
+[Koala](http://github.com/arsduo/koala) is a Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), the REST API, realtime updates, test users, 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, at 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.  (In addition to vanilla Ruby, we support JRuby, Rubinius, and REE, and provide  built-in mechanism for using whichever HTTP library you prefer.)
-* 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.)
+* Lightweight: Koala should be as light and simple as Facebook’s own libraries, providing API accessors and returning simple JSON.
+* Fast: Koala should, out of the box, be quick. Out of the box, we use Facebook's faster read-only servers when possible and if available, the Typhoeus gem to make snappy Facebook requests.  Of course, that brings us to our next topic:
+* Flexible: Koala should be useful to everyone, regardless of their current configuration.  (We support JRuby, Rubinius, and REE as well as vanilla Ruby, and use the Faraday library to provide complete flexibility over how HTTP requests are made.)
+* Tested: Koala should have complete test coverage, so you can rely on it.  (Our test coverage is complete and can be run against either mocked responses or the live Facebook servers.)
 
 Installation
 ---
 
 Easy:
-    
-    [sudo|rvm] gem install koala
-    
+
+    [sudo|rvm] gem install koala --pre # for 1.2 beta
+    [sudo|rvm] gem install koala # for 1.1
+
 Or in Bundler:
-  
-    gem "koala"
-  
+
+    gem "koala", "~> 1.2.0beta" 
+    gem "koala" # for 1.1 
+
 Graph API
 ----
 The Graph API is the simple, slick new interface to Facebook's data.  Using it with Koala is quite straightforward:
 
-    @graph = Koala::Facebook::GraphAPI.new(oauth_access_token)
+    @graph = Koala::Facebook::API.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!")
 
 The response of most requests is the JSON data returned from the Facebook servers as a Hash.
 
-When retrieving data that returns an array of results (for example, when calling GraphAPI#get_connections or GraphAPI#search) a GraphCollection object (a sub-class of Array) will be returned, which contains added methods for getting the next and previous page of results:
+When retrieving data that returns an array of results (for example, when calling API#get_connections or API#search) a GraphCollection object will be returned, which makes it easy to page through the results:
 
     # Returns the feed items for the currently logged-in user as a GraphCollection
     feed = @graph.get_connections("me", "feed")
-
-    # GraphCollection is a sub-class of Array, so you can use it as a usual Array
-    first_entry = feed[0]
-    last_entry = feed.last
-
-    # Returns the next page of results (also as a GraphCollection)
+    feed.each {|f| do_something_with_item(f) } # it's a subclass of Array
     next_feed = feed.next_page
 
-    # Returns an array describing the URL for the next page: [path, arguments]
-    # This is useful for paging across multiple requests
-    next_path, next_args = feed.next_page_params
-
-    # You can use those params to easily get the next (or previous) page
-    page = @graph.get_page(feed.next_page_params)
+    # You can also get an array describing the URL for the next page: [path, arguments]
+    # This is useful for storing page state across multiple browser requests
+    next_page_params = feed.next_page_params
+    page = @graph.get_page(next_page_params)
 
-You can make multiple calls at once using Facebook's batch API:
+You can also make multiple calls at once using Facebook's batch API:
 
     # Returns an array of results as if they were called non-batch
     @graph.batch do |batch_api|
       batch_api.get_object('me')
-      batch_api.get_object('koppel')
+      batch_api.put_wall_post('Making a post in a batch.')
     end
 
-Check out the wiki for more examples.
+Check out the wiki for more details and examples.
 
 The REST API
 -----
 Where the Graph API and the old REST API overlap, you should choose the Graph API.  Unfortunately, that overlap is far from complete, and there are many important API calls that can't yet be done via the Graph.
 
-Koala now supports the old-school REST API using OAuth access tokens; to use this, instantiate your class using the RestAPI class:
+Fortunately, Koala supports the REST API using the very same interface; to use this, instantiate an API:
 
-  	@rest = Koala::Facebook::RestAPI.new(oauth_access_token)
+  	@rest = Koala::Facebook::API.new(oauth_access_token)
   	@rest.fql_query(my_fql_query) # convenience method
   	@rest.fql_multiquery(fql_query_hash) # convenience method
   	@rest.rest_call("stream.publish", arguments_hash) # generic version
 
-We reserve the right to expand the built-in REST API coverage to additional convenience methods in the future, depending on how fast Facebook moves to fill in the gaps.
+Of course, you can use the Graph API methods on the same object -- the power of two APIs right in the palm of your hand.
 
-(If you want the power of both APIs in the palm of your hand, try out the GraphAndRestAPI class.)
+    @api = Koala::Facebook::API.new(oauth_access_token)
+    fql = @api.fql_query(my_fql_query)
+    @api.put_wall_post(process_result(fql))
+    
 
 OAuth
 -----
@@ -130,10 +130,10 @@ Test Users
 -----
 
 We also support the test users API, allowing you to conjure up fake users and command them to do your bidding using the Graph or REST API:
-    
+
     @test_users = Koala::Facebook::TestUsers.new(:app_id => id, :secret => secret)
     user = @test_users.create(is_app_installed, desired_permissions)
-    user_graph_api = Koala::Facebook::GraphAPI.new(user["access_token"])
+    user_graph_api = Koala::Facebook::API.new(user["access_token"])
     # or, if you want to make a whole community:
     @test_users.create_network(network_size, is_app_installed, common_permissions)
 
@@ -149,14 +149,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 anywhere in the project directory:
     bundle exec rake spec
-    
+
 
 You can also run live tests against Facebook's servers:
-    
+
     # Again from anywhere in the project directory:
     LIVE=true bundle exec rake spec
 
-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 this 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.)
+By default, the live tests are run against test users, so you can run them as frequently as you want.  If you want to run them against a real user, however, you can fill in the OAuth token, code, and access\_token values in spec/fixtures/facebook_data.yml.  See the wiki for more details.

data/spec/cases/api_base_spec.rb

@@ -44,7 +44,7 @@ describe "Koala::Facebook::API" do
 
     Koala.stub(:make_request).and_return(response)
 
-    @service.api('anything', 'get', {}, :http_component => http_component)
+    @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
@@ -98,4 +98,4 @@ describe "Koala::Facebook::API" do
     end
   end
 
-end
+end

data/spec/cases/error_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Koala::Facebook::APIError do
+  it "is a StandardError" do
+    Koala::Facebook::APIError.new.should be_a(StandardError)
+  end
+
+  it "has an accessor for fb_error_type" do
+    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type)
+    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type=)
+  end
+
+  it "sets fb_error_type to details['type']" do
+    type = "foo"
+    Koala::Facebook::APIError.new("type" => type).fb_error_type.should == type
+  end
+
+  it "sets the error message details['type']: details['message']" do
+    type = "foo"
+    message = "bar"
+    error = Koala::Facebook::APIError.new("type" => type, "message" => message)
+    error.message.should =~ /#{type}/
+    error.message.should =~ /#{message}/
+  end
+end
+
+describe Koala::KoalaError do
+  it "is a StandardError" do
+     Koala::KoalaError.new.should be_a(StandardError)
+  end
+end
+

data/spec/cases/graph_and_rest_api_spec.rb

@@ -1,11 +1,28 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::GraphAndRestAPI" do
-  include LiveTestingDataHelper
+  describe "class consolidation" do
+    before :each do
+      Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
+    end
+
+    it "still allows you to instantiate a GraphAndRestAPI object" do
+      api = Koala::Facebook::GraphAndRestAPI.new("token").should be_a(Koala::Facebook::GraphAndRestAPI)
+    end
+
+    it "ultimately creates an API object" do
+      api = Koala::Facebook::GraphAndRestAPI.new("token").should be_a(Koala::Facebook::API)
+    end
+
+    it "fires a depreciation warning" do
+      Koala::Utils.should_receive(:deprecate)
+      api = Koala::Facebook::GraphAndRestAPI.new("token")
+    end
+  end
 
   describe "with an access token" do
     before(:each) do
-      @api = Koala::Facebook::GraphAndRestAPI.new(@token)
+      @api = Koala::Facebook::API.new(@token)
     end
 
     it_should_behave_like "Koala RestAPI"
@@ -18,7 +35,7 @@ describe "Koala::Facebook::GraphAndRestAPI" do
 
   describe "without an access token" do
     before(:each) do
-      @api = Koala::Facebook::GraphAndRestAPI.new
+      @api = Koala::Facebook::API.new
     end
 
     it_should_behave_like "Koala RestAPI"

data/spec/cases/graph_api_batch_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::GraphAPI in batch mode" do
-  include LiveTestingDataHelper
+
   before :each do
-    @api = Koala::Facebook::GraphAPI.new(@token)
+    @api = Koala::Facebook::API.new(@token)
     # app API
-    @oauth_data = $testing_data["oauth_test_data"]
-    @app_id = @oauth_data["app_id"]
-    @app_access_token = @oauth_data["app_access_token"]
-    @app_api = Koala::Facebook::GraphAPI.new(@app_access_token)
-  end 
-  
+    @app_id = KoalaTest.app_id
+    @app_access_token = KoalaTest.app_access_token
+    @app_api = Koala::Facebook::API.new(@app_access_token)
+  end
+
   describe "BatchOperations" do
     before :each do
       @args = {
@@ -22,43 +21,43 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         :post_processing => lambda { }
       }
     end
-    
+
     describe "#new" do
       it "makes http_options accessible" do
         Koala::Facebook::BatchOperation.new(@args).http_options.should == @args[:http_options]
       end
-      
+
       it "makes post_processing accessible" do
         Koala::Facebook::BatchOperation.new(@args).post_processing.should == @args[:post_processing]
       end
-      
+
       it "makes access_token accessible" do
         Koala::Facebook::BatchOperation.new(@args).access_token.should == @args[:access_token]
       end
-            
+
       it "doesn't change the original http_options" do
         @args[:http_options][:name] = "baz2"
         expected = @args[:http_options].dup
         Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)
         @args[:http_options].should == expected
       end
-      
+
       it "leaves the file array nil by default" do
-        Koala::Facebook::BatchOperation.new(@args).files.should be_nil        
+        Koala::Facebook::BatchOperation.new(@args).files.should be_nil
       end
-      
+
       it "raises a KoalaError if no access token supplied" do
         expect { Koala::Facebook::BatchOperation.new(@args.merge(:access_token => nil)) }.to raise_exception(Koala::KoalaError)
       end
-      
+
       describe "when supplied binary files" do
         before :each do
           @binary = stub("Binary file")
           @uploadable_io = stub("UploadableIO 1")
-          
+
           @batch_queue = []
           Koala::Facebook::GraphAPI.stub(:batch_calls).and_return(@batch_queue)
-          
+
           Koala::UploadableIO.stub(:new).with(@binary).and_return(@uploadable_io)
           Koala::UploadableIO.stub(:binary_content?).and_return(false)
           Koala::UploadableIO.stub(:binary_content?).with(@binary).and_return(true)
@@ -67,14 +66,14 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
           @args[:method] = "post" # files are always post
         end
-        
+
         it "adds binary files to the files attribute as UploadableIOs" do
           @args[:args].merge!("source" => @binary)
           batch_op = Koala::Facebook::BatchOperation.new(@args)
           batch_op.files.should_not be_nil
           batch_op.files.find {|k, v| v == @uploadable_io}.should_not be_nil
         end
-        
+
         it "works if supplied an UploadableIO as an argument" do
           # as happens with put_picture at the moment
           @args[:args].merge!("source" => @uploadable_io)
@@ -82,14 +81,14 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           batch_op.files.should_not be_nil
           batch_op.files.find {|k, v| v == @uploadable_io}.should_not be_nil
         end
-                
+
         it "assigns each binary parameter unique name" do
           @args[:args].merge!("source" => @binary, "source2" => @binary)
           batch_op = Koala::Facebook::BatchOperation.new(@args)
           # if the name wasn't unique, there'd just be one item
           batch_op.files.should have(2).items
         end
-        
+
         it "assigns each binary parameter unique name across batch requests" do
           @args[:args].merge!("source" => @binary, "source2" => @binary)
           batch_op = Koala::Facebook::BatchOperation.new(@args)
@@ -100,59 +99,59 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           # if the name wasn't unique, we should have < 4 items since keys would be the same
           batch_op.files.merge(batch_op2.files).should have(4).items
         end
-        
+
         it "removes the value from the arguments" do
           @args[:args].merge!("source" => @binary)
           Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should_not =~ /source=/
         end
-      end   
-      
+      end
+
     end
-    
-    describe ".to_batch_params" do    
+
+    describe ".to_batch_params" do
       describe "handling arguments and URLs" do
         shared_examples_for "request with no body" do
           it "adds the args to the URL string, with ? if no args previously present" do
             test_args = "foo"
             @args[:url] = url = "/"
             Koala.http_service.stub(:encode_params).and_return(test_args)
-          
+
             Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == "#{url}?#{test_args}"
           end
-        
+
           it "adds the args to the URL string, with & if args previously present" do
             test_args = "foo"
             @args[:url] = url = "/?a=2"
             Koala.http_service.stub(:encode_params).and_return(test_args)
-          
+
             Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == "#{url}&#{test_args}"
           end
-          
+
           it "adds nothing to the URL string if there are no args to be added" do
             @args[:args] = {}
-            Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])[:relative_url].should == @args[:url]            
+            Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])[:relative_url].should == @args[:url]
           end
-          
+
           it "adds nothing to the body" do
             Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should be_nil
           end
         end
-        
+
         shared_examples_for "requests with a body param" do
           it "sets the body to the encoded args string, if there are args" do
             test_args = "foo"
             Koala.http_service.stub(:encode_params).and_return(test_args)
-          
+
             Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should == test_args
           end
-          
+
           it "does not set the body if there are no args" do
             test_args = ""
             Koala.http_service.stub(:encode_params).and_return(test_args)
             Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:body].should be_nil
           end
-          
-        
+
+
           it "doesn't change the url" do
             test_args = "foo"
             Koala.http_service.stub(:encode_params).and_return(test_args)
@@ -160,40 +159,40 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)[:relative_url].should == @args[:url]
           end
         end
-            
+
         context "for get operations" do
           before :each do
             @args[:method] = :get
           end
-        
-          it_should_behave_like "request with no body"        
+
+          it_should_behave_like "request with no body"
         end
-      
+
         context "for delete operations" do
           before :each do
             @args[:method] = :delete
           end
-        
-          it_should_behave_like "request with no body"        
+
+          it_should_behave_like "request with no body"
         end
-      
+
         context "for get operations" do
           before :each do
             @args[:method] = :put
           end
-        
-          it_should_behave_like "requests with a body param"  
+
+          it_should_behave_like "requests with a body param"
         end
-      
+
         context "for delete operations" do
           before :each do
             @args[:method] = :post
           end
-        
-          it_should_behave_like "requests with a body param"       
+
+          it_should_behave_like "requests with a body param"
         end
       end
-    
+
       it "includes the access token if the token is not the main one for the request" do
          params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(nil)
          params[:relative_url].should =~ /access_token=#{@args[:access_token]}/
@@ -209,13 +208,13 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
          params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])
          params[:relative_url].should_not =~ /access_token=#{@args[:access_token]}/
       end
-      
+
       it "includes the other arguments if the token is the main one for the request" do
         @args[:args] = {:a => 2}
         params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])
         params[:relative_url].should =~ /a=2/
       end
-      
+
       it "includes any arguments passed as http_options[:batch_args]" do
         batch_args = {:name => "baz", :headers => {:some_param => true}}
         @args[:http_options][:batch_args] = batch_args
@@ -227,22 +226,22 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         params = Koala::Facebook::BatchOperation.new(@args).to_batch_params(@args[:access_token])
         params[:method].should == @args[:method].to_s
       end
-      
+
       it "works with nil http_options" do
         expect { Koala::Facebook::BatchOperation.new(@args.merge(:http_options => nil)).to_batch_params(nil) }.not_to raise_exception
       end
-      
+
       it "works with nil args" do
         expect { Koala::Facebook::BatchOperation.new(@args.merge(:args => nil)).to_batch_params(nil) }.not_to raise_exception
-      end 
-      
+      end
+
       describe "with binary files" do
         before :each do
           @binary = stub("Binary file")
           Koala::UploadableIO.stub(:binary_content?).and_return(false)
           Koala::UploadableIO.stub(:binary_content?).with(@binary).and_return(true)
           @uploadable_io = stub("UploadableIO")
-          Koala::UploadableIO.stub(:new).with(@binary).and_return(@uploadable_io)          
+          Koala::UploadableIO.stub(:new).with(@binary).and_return(@uploadable_io)
           @uploadable_io.stub(:is_a?).with(Koala::UploadableIO).and_return(true)
 
           @batch_queue = []
@@ -250,7 +249,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
           @args[:method] = "post" # files are always post
         end
-        
+
         it "adds file identifiers as attached_files in a comma-separated list" do
           @args[:args].merge!("source" => @binary, "source2" => @binary)
           batch_op = Koala::Facebook::BatchOperation.new(@args)
@@ -293,7 +292,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         it "includes the first operation's access token as the main one in the args" do
           access_token = "foo"
           Koala.should_receive(:make_request).with(anything, hash_including("access_token" => access_token), anything, anything).and_return(@fake_response)
-          Koala::Facebook::GraphAPI.new(access_token).batch do |batch_api|
+          Koala::Facebook::API.new(access_token).batch do |batch_api|
             batch_api.get_object('me')
             batch_api.get_object('me', {}, {'access_token' => 'bar'})
           end
@@ -308,7 +307,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           # two requests should generate two batch operations
           expected = MultiJson.encode([op.to_batch_params(access_token), op.to_batch_params(access_token)])
           Koala.should_receive(:make_request).with(anything, hash_including("batch" => expected), anything, anything).and_return(@fake_response)
-          Koala::Facebook::GraphAPI.new(access_token).batch do |batch_api|
+          Koala::Facebook::API.new(access_token).batch do |batch_api|
             batch_api.get_object('me')
             batch_api.get_object('me')
           end
@@ -324,7 +323,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           Koala::Facebook::BatchOperation.stub(:new).and_return(batch_op)
 
           Koala.should_receive(:make_request).with(anything, hash_including(@key => @uploadable_io), anything, anything).and_return(@fake_response)
-          Koala::Facebook::GraphAPI.new("bar").batch do |batch_api|
+          Koala::Facebook::API.new("bar").batch do |batch_api|
             batch_api.put_picture("path/to/file", "image/jpeg")
           end
         end
@@ -337,7 +336,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             (args ||= {})["batch"].should =~ /.*me\/farglebarg.*otheruser\/bababa/
             @fake_response
           end
-          Koala::Facebook::GraphAPI.new(access_token).batch do |batch_api|
+          Koala::Facebook::API.new(access_token).batch do |batch_api|
             batch_api.get_connections('me', "farglebarg")
             batch_api.get_connections('otheruser', "bababa")
           end
@@ -345,14 +344,14 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
         it "makes a POST request" do
           Koala.should_receive(:make_request).with(anything, anything, "post", anything).and_return(@fake_response)
-          Koala::Facebook::GraphAPI.new("foo").batch do |batch_api|
+          Koala::Facebook::API.new("foo").batch do |batch_api|
             batch_api.get_object('me')
           end
         end
 
         it "makes a request to /" do
           Koala.should_receive(:make_request).with("/", anything, anything, anything).and_return(@fake_response)
-          Koala::Facebook::GraphAPI.new("foo").batch do |batch_api|
+          Koala::Facebook::API.new("foo").batch do |batch_api|
             batch_api.get_object('me')
           end
         end
@@ -360,7 +359,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         it "includes any http options specified at the top level" do
           http_options = {"a" => "baz"}
           Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(http_options)).and_return(@fake_response)
-          Koala::Facebook::GraphAPI.new("foo").batch(http_options) do |batch_api|
+          Koala::Facebook::API.new("foo").batch(http_options) do |batch_api|
             batch_api.get_object('me')
           end
         end
@@ -369,14 +368,14 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       describe "processing the request" do
         it "throws an error if the response is not 200" do
           Koala.stub(:make_request).and_return(Koala::Response.new(500, "[]", {}))
-          expect { Koala::Facebook::GraphAPI.new("foo").batch do |batch_api|
+          expect { Koala::Facebook::API.new("foo").batch do |batch_api|
             batch_api.get_object('me')
           end }.to raise_exception(Koala::Facebook::APIError)
         end
 
         it "throws an error if the response is a Batch API-style error" do
           Koala.stub(:make_request).and_return(Koala::Response.new(200, '{"error":190,"error_description":"Error validating access token."}', {}))
-          expect { Koala::Facebook::GraphAPI.new("foo").batch do |batch_api|
+          expect { Koala::Facebook::API.new("foo").batch do |batch_api|
             batch_api.get_object('me')
           end }.to raise_exception(Koala::Facebook::APIError)
         end
@@ -384,7 +383,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         it "returns the result status if http_component is status" do
           Koala.stub(:make_request).and_return(Koala::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
           result = @api.batch do |batch_api|
-            batch_api.get_object("koppel", {}, :http_component => :status)
+            batch_api.get_object(KoalaTest.user1, {}, :http_component => :status)
           end
           result[0].should == 203
         end
@@ -392,7 +391,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         it "returns the result headers as a hash if http_component is headers" do
           Koala.stub(:make_request).and_return(Koala::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
           result = @api.batch do |batch_api|
-            batch_api.get_object("koppel", {}, :http_component => :headers)
+            batch_api.get_object(KoalaTest.user1, {}, :http_component => :headers)
           end
           result[0].should == {"Content-Type" => "text/javascript; charset=UTF-8"}
         end
@@ -404,26 +403,26 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         thread_two_count = 0
         first_count = 20
         second_count = 10
-        
+
         Koala.stub(:make_request).and_return(@fake_response)
 
         thread1 = Thread.new do
-          @api.batch do |batch_api| 
+          @api.batch do |batch_api|
             first_count.times {|i| batch_api.get_object("me"); sleep(0.01) }
             thread_one_count = batch_api.batch_calls.count
           end
         end
-            
+
         thread2 = Thread.new do
-          @api.batch do |batch_api| 
+          @api.batch do |batch_api|
             second_count.times {|i| batch_api.get_object("me"); sleep(0.01) }
             thread_two_count = batch_api.batch_calls.count
           end
         end
-        
+
         thread1.join
         thread2.join
-        
+
         thread_one_count.should == first_count
         thread_two_count.should == second_count
       end
@@ -434,16 +433,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
     it "can get two results at once" do
       me, koppel = @api.batch do |batch_api|
         batch_api.get_object('me')
-        batch_api.get_object('koppel')
-      end
-      me['id'].should_not be_nil
-      koppel['id'].should_not be_nil
-    end
-
-    it "works with GraphAndRestAPI instances" do
-      me, koppel = Koala::Facebook::GraphAndRestAPI.new(@api.access_token).batch do |batch_api|
-        batch_api.get_object('me')
-        batch_api.get_object('koppel')
+        batch_api.get_object(KoalaTest.user1)
       end
       me['id'].should_not be_nil
       koppel['id'].should_not be_nil
@@ -477,7 +467,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
     it "inserts errors in the appropriate place, without breaking other results" do
       failed_insights, koppel = @api.batch do |batch_api|
         batch_api.get_connections(@app_id, 'insights')
-        batch_api.get_object("koppel", {}, {"access_token" => @app_api.access_token})
+        batch_api.get_object(KoalaTest.user1, {}, {"access_token" => @app_api.access_token})
       end
       failed_insights.should be_a(Koala::Facebook::APIError)
       koppel["id"].should_not be_nil
@@ -495,12 +485,12 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
     it "allows FQL" do
       result = @api.batch do |batch_api|
-        batch_api.graph_call("method/fql.query", {:query=>"select name from user where uid=4"}, "post")
+        batch_api.graph_call("method/fql.query", {:query=>"select first_name from user where uid=#{KoalaTest.user1_id}"}, "post")
       end
 
       fql_result = result[0]
       fql_result[0].should be_a(Hash)
-      fql_result[0]["name"].should == "Mark Zuckerberg"
+      fql_result[0]["first_name"].should == "Alex"
     end
 
     describe "binary files" do
@@ -518,11 +508,12 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
       it "posts binary files with multiple requests" do
         file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
+        file2 = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
 
         Koala::Facebook::BatchOperation.instance_variable_set(:@identifier, 0)
         results = @api.batch do |batch_api|
           batch_api.put_picture(file)
-          batch_api.put_picture(file, {}, "koppel")
+          batch_api.put_picture(file2, {}, KoalaTest.user1)
         end
         results[0]["id"].should_not be_nil
         results[1]["id"].should_not be_nil
@@ -553,7 +544,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       it "allows you to create dependencies" do
         me, koppel = @api.batch do |batch_api|
           batch_api.get_object("me", {}, :batch_args => {:name => "getme"})
-          batch_api.get_object("koppel", {}, :batch_args => {:depends_on => "getme"})
+          batch_api.get_object(KoalaTest.user1, {}, :batch_args => {:depends_on => "getme"})
         end
 
         me.should be_nil # gotcha!  it's omitted because it's a successfully-executed dependency
@@ -563,7 +554,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       it "properly handles dependencies that fail" do
         data, koppel = @api.batch do |batch_api|
           batch_api.get_connections(@app_id, 'insights', {}, :batch_args => {:name => "getdata"})
-          batch_api.get_object("koppel", {}, :batch_args => {:depends_on => "getdata"})
+          batch_api.get_object(KoalaTest.user1, {}, :batch_args => {:depends_on => "getdata"})
         end
 
         data.should be_a(Koala::Facebook::APIError)
@@ -583,24 +574,24 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
   describe "new interface" do
     it "includes a deprecation warning on GraphAPI" do
-      begin 
+      begin
         Koala::Facebook::GraphAPI.batch do
         end
       rescue NoMethodError => @err
       end
-      
+
       # verify the message points people to the wiki page
       @err.should
       @err.message.should =~ /https\:\/\/github.com\/arsduo\/koala\/wiki\/Batch-requests/
     end
-    
+
     it "includes a deprecation warning on GraphAndRESTAPI" do
-      begin 
+      begin
         Koala::Facebook::GraphAndRestAPI.batch do
         end
       rescue NoMethodError => @err
       end
-      
+
       # verify the message points people to the wiki page
       @err.should
       @err.message.should =~ /https\:\/\/github.com\/arsduo\/koala\/wiki\/Batch-requests/