koala 1.3.0rc1 → 1.3.0rc2

data/spec/cases/oauth_spec.rb

@@ -350,17 +350,17 @@ describe "Koala::Facebook::OAuth" do
     describe "#get_access_token_info" do
       it "uses options[:redirect_uri] if provided" do
         uri = "foo"
-        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => uri), anything, anything).and_return(Koala::Response.new(200, "", {}))
+        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => uri), anything, anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token_info(@code, :redirect_uri => uri)
       end
       
       it "uses the redirect_uri used to create the @oauth if no :redirect_uri option is provided" do
-        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => @callback_url), anything, anything).and_return(Koala::Response.new(200, "", {}))
+        Koala.should_receive(:make_request).with(anything, hash_including(:redirect_uri => @callback_url), anything, anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token_info(@code)        
       end
       
       it "makes a GET request" do
-        Koala.should_receive(:make_request).with(anything, anything, "get", anything).and_return(Koala::Response.new(200, "", {}))
+        Koala.should_receive(:make_request).with(anything, anything, "get", anything).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token_info(@code)                
       end
 
@@ -385,7 +385,7 @@ describe "Koala::Facebook::OAuth" do
       # TODO refactor these to be proper tests with stubs and tests against real data
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_access_token(@code, options)
       end
 
@@ -424,7 +424,7 @@ describe "Koala::Facebook::OAuth" do
 
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_app_access_token_info(options)
       end
     end
@@ -443,7 +443,7 @@ describe "Koala::Facebook::OAuth" do
 
       it "passes on any options provided to make_request" do
         options = {:a => 2}
-        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "", {}))
+        Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "", {}))
         @oauth.get_app_access_token(options)
       end
     end
@@ -524,7 +524,7 @@ describe "Koala::Facebook::OAuth" do
 
         it "passes on any options provided to make_request" do
           options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "[{}]", {}))
+          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
           @oauth.get_token_info_from_session_keys([], options)
         end
       end
@@ -556,7 +556,7 @@ describe "Koala::Facebook::OAuth" do
 
         it "passes on any options provided to make_request" do
           options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "[{}]", {}))
+          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
           @oauth.get_tokens_from_session_keys([], options)
         end
       end
@@ -586,7 +586,7 @@ describe "Koala::Facebook::OAuth" do
 
         it "passes on any options provided to make_request" do
           options = {:a => 2}
-          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::Response.new(200, "[{}]", {}))
+          Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(options)).and_return(Koala::HTTPService::Response.new(200, "[{}]", {}))
           @oauth.get_token_from_session_key("", options)
         end
       end

data/spec/cases/realtime_updates_spec.rb

@@ -24,33 +24,37 @@ describe "Koala::Facebook::RealtimeUpdates" do
     end
   end
 
-  describe "when initializing" do
+  before :each do 
+    @updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+  end
+
+  describe ".new" do
     # basic initialization
-    it "should initialize properly with an app_id and an app_access_token" do
+    it "initializes properly with an app_id and an app_access_token" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       updates.should be_a(Koala::Facebook::RealtimeUpdates)
     end
     
     # attributes
-    it "should allow read access to app_id" do
+    it "allows read access to app_id" do
       # in Ruby 1.9, .method returns symbols 
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:app_id)
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:app_id=)
     end
 
-    it "should allow read access to app_access_token" do
+    it "allows read access to app_access_token" do
       # in Ruby 1.9, .method returns symbols 
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:app_access_token)
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
     end
 
-    it "should allow read access to secret" do
+    it "allows read access to secret" do
       # in Ruby 1.9, .method returns symbols 
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:secret)
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:secret=)
     end
 
-    it "should allow read access to api" do
+    it "allows read access to api" do
       # in Ruby 1.9, .method returns symbols 
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should include(:api)
       Koala::Facebook::RealtimeUpdates.instance_methods.map(&:to_sym).should_not include(:api=)
@@ -69,72 +73,178 @@ describe "Koala::Facebook::RealtimeUpdates" do
     end
     
     # init with secret / fetching the token
-    it "should initialize properly with an app_id and a secret" do 
+    it "initializes properly with an app_id and a secret" do 
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
       updates.should be_a(Koala::Facebook::RealtimeUpdates)      
     end
 
-    it "should fetch an app_token from Facebook when provided an app_id and a secret" do 
+    it "fetches an app_token from Facebook when provided an app_id and a secret" do 
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
       updates.app_access_token.should_not be_nil
     end
-    
-    it "should use the OAuth class to fetch a token when provided an app_id and a secret" do
+        
+    it "uses the OAuth class to fetch a token when provided an app_id and a secret" do
       oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
       token = oauth.get_app_access_token
       oauth.should_receive(:get_app_access_token).and_return(token)
       Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth) 
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
     end
+    
+    it "sets up the with the app acces token" do 
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      updates.api.should be_a(Koala::Facebook::API)
+      updates.api.access_token.should == @app_access_token
+    end    
+    
   end
 
-  describe "when used" do
-    before :each do 
-      @updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+  describe "#subscribe" do   
+    it "makes a POST to the subscription path" do
+      @updates.api.should_receive(:graph_call).with(@updates.subscription_path, anything, "post", anything)
+      @updates.subscribe("user", "name", @subscription_path, @verify_token)
+    end
+
+    it "properly formats the subscription request" do
+      obj = "user"
+      fields = "name"
+      @updates.api.should_receive(:graph_call).with(anything, hash_including(
+        :object => obj,
+        :fields => fields,
+        :callback_url => @subscription_path,
+        :verify_token => @verify_token 
+      ), anything, anything)
+      @updates.subscribe("user", "name", @subscription_path, @verify_token)
+    end
+    
+    pending "doesn't require a verify_token" do
+      # see https://github.com/arsduo/koala/issues/150
+      obj = "user"
+      fields = "name"
+      @updates.api.should_not_receive(:graph_call).with(anything, hash_including(:verify_token => anything), anything, anything)
+      @updates.subscribe("user", "name", @subscription_path)
+    end
+    
+    it "requires verify_token" do
+      expect { @updates.subscribe("user", "name", @subscription_path) }.to raise_exception
     end
     
-    it "should send a subscription request to a valid server" do
-      result = @updates.subscribe("user", "name", @subscription_path, @verify_token)
-      result.should be_true
+    it "requests the status component" do
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(:http_component => :status))
+      @updates.subscribe("user", "name", @subscription_path, @verify_token)
     end
     
-    it "should send a subscription request to a valid server" do
-      result = @updates.subscribe("user", "name", @subscription_path, @verify_token)
-      result.should be_true
+    it "accepts an options hash" do
+      options = {:a => 2, :b => "c"}
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
+      @updates.subscribe("user", "name", @subscription_path, @verify_token, options)
     end
     
-    it "should send a subscription request to an invalid path on a valid server" do
-      lambda { result = @updates.subscribe("user", "name", @subscription_path + "foo", @verify_token) }.should raise_exception(Koala::Facebook::APIError)
+    it "overrides any provided http_component" do
+      # since we test against status, we need to ensure that we get that
+      options = {:http_component => :body}
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(:http_component => :status))
+      @updates.subscribe("user", "name", @subscription_path, @verify_token, options)
     end
+
+    describe "in practice" do
+      it "sends a subscription request" do
+        result = @updates.subscribe("user", "name", @subscription_path, @verify_token)
+        result.should be_true
+      end
     
-    it "should fail to send a subscription request to an invalid server" do
-      lambda { @updates.subscribe("user", "name", "foo", @verify_token) }.should raise_exception(Koala::Facebook::APIError)
+      pending "sends a subscription request without a verify token" do
+        result = @updates.subscribe("user", "name", @subscription_path)
+        result.should be_true
+      end
+  
+      it "fails if you try to hit an invalid path on your valid server" do
+        expect { result = @updates.subscribe("user", "name", @subscription_path + "foo", @verify_token) }.to raise_exception(Koala::Facebook::APIError)
+      end
+  
+      it "fails to send a subscription request to an invalid server" do
+        expect { @updates.subscribe("user", "name", "foo", @verify_token) }.to raise_exception(Koala::Facebook::APIError)
+      end
     end
+  end
   
-    it "should unsubscribe a valid individual object successfully" do 
-      @updates.unsubscribe("user").should be_true
+  describe "#unsubscribe" do
+    it "makes a DELETE to the subscription path" do
+      @updates.api.should_receive(:graph_call).with(@updates.subscription_path, anything, "delete", anything)
+      @updates.unsubscribe("user")
     end
 
-    it "should unsubscribe all subscriptions successfully" do 
-      @updates.unsubscribe.should be_true
+    it "includes the object if provided" do
+      obj = "user"
+      @updates.api.should_receive(:graph_call).with(anything, hash_including(:object => obj), anything, anything)
+      @updates.unsubscribe(obj)
     end
+    
+    it "requests the status component" do
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(:http_component => :status))
+      @updates.unsubscribe("user")
+    end
+        
+    it "accepts an options hash" do
+      options = {:a => 2, :b => "C"}
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
+      @updates.unsubscribe("user", options)
+    end
+    
+    it "overrides any provided http_component" do
+      # since we test against status, we need to ensure that we get that
+      options = {:http_component => :body}
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(:http_component => :status))
+      @updates.unsubscribe("user", options)
+    end
+    
+    describe "in practice" do
+      it "unsubscribes a valid individual object successfully" do 
+        @updates.unsubscribe("user").should be_true
+      end
+
+      it "unsubscribes all subscriptions successfully" do 
+        @updates.unsubscribe.should be_true
+      end
 
-    it "should fail when an invalid object is provided to unsubscribe" do 
-      lambda { @updates.unsubscribe("kittens") }.should raise_error(Koala::Facebook::APIError)
+      it "fails when an invalid object is provided to unsubscribe" do 
+        expect { @updates.unsubscribe("kittens") }.to raise_error(Koala::Facebook::APIError)
+      end
+    end
+  end
+  
+  describe "#list_subscriptions" do
+    it "GETs the subscription path" do
+      @updates.api.should_receive(:graph_call).with(@updates.subscription_path, anything, "get", anything)
+      @updates.list_subscriptions
     end
     
-    it "should is subscriptions properly" do
-      @updates.list_subscriptions.should be_a(Array)
+    it "accepts options" do
+      options = {:a => 3, :b => "D"}      
+      @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
+      @updates.list_subscriptions(options)
     end
-  end # describe "when used"
+    
+    describe "in practice" do
+      it "lists subscriptions properly" do
+        @updates.list_subscriptions.should be_a(Array)
+      end
+    end
+  end
+  
+  describe "#subscription_path" do
+    it "returns the app_id/subscriptions" do
+      @updates.subscription_path.should == "#{@app_id}/subscriptions"
+    end
+  end
   
-  describe "when meeting challenge" do
-    it "should return false if hub.mode isn't subscribe" do
+  describe ".meet_challenge" do
+    it "returns false if hub.mode isn't subscribe" do
       params = {'hub.mode' => 'not subscribe'}
       Koala::Facebook::RealtimeUpdates.meet_challenge(params).should be_false
     end
     
-    it "should return false if not given a verify_token or block" do
+    it "returns false if not given a verify_token or block" do
       params = {'hub.mode' => 'subscribe'}
       Koala::Facebook::RealtimeUpdates.meet_challenge(params).should be_false
     end
@@ -150,11 +260,11 @@ describe "Koala::Facebook::RealtimeUpdates" do
           @params['hub.verify_token'] = @token
         end
         
-        it "should return false if the given verify token doesn't match" do
+        it "returns false if the given verify token doesn't match" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token + '1').should be_false
         end
         
-        it "should return the challenge if the given verify token matches" do
+        it "returns the challenge if the given verify token matches" do
           @params['hub.challenge'] = 'challenge val'
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token).should == @params['hub.challenge']
         end
@@ -165,34 +275,31 @@ describe "Koala::Facebook::RealtimeUpdates" do
           @params['hub.verify_token'] = @token
         end
           
-        it "should give the block the token as a parameter" do
+        it "gives the block the token as a parameter" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             token.should == @token
           end
         end
         
-        it "should return false if the given block return false" do
+        it "returns false if the given block return false" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             false
           end.should be_false
         end
         
-        it "should return false if the given block returns nil" do
+        it "returns false if the given block returns nil" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             nil
           end.should be_false
         end
         
-        it "should return the challenge if the given block returns true" do
+        it "returns the challenge if the given block returns true" do
           @params['hub.challenge'] = 'challenge val'
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             true
           end.should be_true
         end
       end
-    
-    end # describe "and mode is subscribe"
-    
-  end # describe "when meeting challenge"
-  
-end # describe
+    end
+  end
+end

data/spec/cases/test_users_spec.rb

@@ -1,271 +1,320 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::TestUsers" do
-  context "with access token" do
-    before :all do
-      # get oauth data
-      @app_id = KoalaTest.app_id
-      @secret = KoalaTest.secret
-      @app_access_token = KoalaTest.app_access_token
-
-      # check OAuth data
-      unless @app_id && @secret && @app_access_token
-        raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
-      end
+  before :all do
+    # get oauth data
+    @app_id = KoalaTest.app_id
+    @secret = KoalaTest.secret
+    @app_access_token = KoalaTest.app_access_token
+
+    @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+
+    # check OAuth data
+    unless @app_id && @secret && @app_access_token
+      raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
     end
-    
-    after :each do
-      # clean up any test users
-      ((@network || []) + [@user1, @user2]).each do |u|
-        puts "Unable to delete test user #{u.inspect}" if u && !(@test_users.delete(u) rescue false)
-      end
+  end
+  
+  after :each do
+    # clean up any test users
+    ((@network || []) + [@user1, @user2]).each do |u|
+      puts "Unable to delete test user #{u.inspect}" if u && !(@test_users.delete(u) rescue false)
     end
+  end
 
-    describe "when initializing" do
-      # basic initialization
-      it "should initialize properly with an app_id and an app_access_token" do
-        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :app_access_token => @app_access_token)
-        test_users.should be_a(Koala::Facebook::TestUsers)
-      end
+  describe "when initializing" do
+    # basic initialization
+    it "initializes properly with an app_id and an app_access_token" do
+      test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      test_users.should be_a(Koala::Facebook::TestUsers)
+    end
 
-      # init with secret / fetching the token
-      it "should initialize properly with an app_id and a secret" do
-        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
-        test_users.should be_a(Koala::Facebook::TestUsers)
-      end
+    # init with secret / fetching the token
+    it "initializes properly with an app_id and a secret" do
+      test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+      test_users.should be_a(Koala::Facebook::TestUsers)
+    end
+
+    it "uses the OAuth class to fetch a token when provided an app_id and a secret" do
+      oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+      token = oauth.get_app_access_token
+      oauth.should_receive(:get_app_access_token).and_return(token)
+      Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
+      test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+    end
+
+    # attributes
+    it "allows read access to app_id, app_access_token, and secret" do
+      # in Ruby 1.9, .method returns symbols
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_id)
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_id=)
+    end
+
+    it "allows read access to app_access_token" do
+      # in Ruby 1.9, .method returns symbols
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_access_token)
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
+    end
+
+    it "allows read access to secret" do
+      # in Ruby 1.9, .method returns symbols
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:secret)
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:secret=)
+    end
+
+    it "allows read access to api" do
+      # in Ruby 1.9, .method returns symbols
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:api)
+      Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:api=)
+    end
+
+    # old graph_api accessor
+    it "returns the api object when graph_api is called" do
+      test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+      test_users.graph_api.should == test_users.api
+    end
 
-      it "should use the OAuth class to fetch a token when provided an app_id and a secret" do
-        oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
-        token = oauth.get_app_access_token
-        oauth.should_receive(:get_app_access_token).and_return(token)
-        Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
-        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+    it "fire a deprecation warning when graph_api is called" do
+      test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+      Koala::Utils.should_receive(:deprecate)
+      test_users.graph_api
+    end
+  end
+
+  describe "when used without network" do
+    # TEST USER MANAGEMENT
+
+    describe "#create" do
+      it "creates a test user when not given installed" do
+        result = @test_users.create(false)
+        @user1 = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
       end
 
-      # attributes
-      it "should allow read access to app_id, app_access_token, and secret" do
-        # in Ruby 1.9, .method returns symbols
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_id)
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_id=)
+      it "creates a test user when not given installed, ignoring permissions" do
+        result = @test_users.create(false, "read_stream")
+        @user1 = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
       end
 
-      it "should allow read access to app_access_token" do
-        # in Ruby 1.9, .method returns symbols
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:app_access_token)
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:app_access_token=)
+      it "accepts permissions as a string" do
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
+        result = @test_users.create(true, "read_stream,publish_stream")
       end
 
-      it "should allow read access to secret" do
-        # in Ruby 1.9, .method returns symbols
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:secret)
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:secret=)
+      it "accepts permissions as an array" do
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
+        result = @test_users.create(true, ["read_stream", "publish_stream"])
       end
 
-      it "should allow read access to api" do
-        # in Ruby 1.9, .method returns symbols
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should include(:api)
-        Koala::Facebook::TestUsers.instance_methods.map(&:to_sym).should_not include(:api=)
+      it "creates a test user when given installed and a permission" do
+        result = @test_users.create(true, "read_stream")
+        @user1 = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
       end
 
-      # old graph_api accessor
-      it "returns the api object when graph_api is called" do
-        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
-        test_users.graph_api.should == test_users.api
+      it "lets you specify other graph arguments, like uid and access token" do
+        args = {:uid => "some test user ID", :owner_access_token => "some owner access token"}
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
+        @test_users.create(true, nil, args)
       end
 
-      it "fire a deprecation warning when graph_api is called" do
-        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
-        Koala::Utils.should_receive(:deprecate)
-        test_users.graph_api
+      it "lets you specify http options that get passed through to the graph call" do
+        options = {:some_http_option => true}
+        @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        @test_users.create(true, nil, {}, options)
       end
     end
-
-    describe "when used without network" do
+    
+    describe "#list" do
       before :each do
-        @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+        @user1 = @test_users.create(true, "read_stream")
+        @user2 = @test_users.create(true, "read_stream,user_interests")
       end
 
-      # TEST USER MANAGEMENT
-
-      describe "#create" do
-        it "should create a test user when not given installed" do
-          result = @test_users.create(false)
-          @user1 = result["id"]
-          result.should be_a(Hash)
-          (result["id"] && result["access_token"] && result["login_url"]).should
-        end
-
-        it "should create a test user when not given installed, ignoring permissions" do
-          result = @test_users.create(false, "read_stream")
-          @user1 = result["id"]
-          result.should be_a(Hash)
-          (result["id"] && result["access_token"] && result["login_url"]).should
-        end
-
-        it "should accept permissions as a string" do
-          @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
-          result = @test_users.create(true, "read_stream,publish_stream")
-        end
-
-        it "should accept permissions as an array" do
-          @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
-          result = @test_users.create(true, ["read_stream", "publish_stream"])
-        end
-
-        it "should create a test user when given installed and a permission" do
-          result = @test_users.create(true, "read_stream")
-          @user1 = result["id"]
-          result.should be_a(Hash)
-          (result["id"] && result["access_token"] && result["login_url"]).should
-        end
-
-        it "lets you specify other graph arguments, like uid and access token" do
-          args = {:uid => "some test user ID", :owner_access_token => "some owner access token"}
-          @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
-          @test_users.create(true, nil, args)
-        end
-
-        it "lets you specify http options that get passed through to the graph call" do
-          options = {:some_http_option => true}
-          @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
-          @test_users.create(true, nil, {}, options)
-        end
+      it "lists test users" do
+        result = @test_users.list
+        result.should be_an(Array)
+        first_user, second_user = result[0], result[1]
+        (first_user["id"] && first_user["access_token"] && first_user["login_url"]).should
+        (second_user["id"] && second_user["access_token"] && second_user["login_url"]).should
       end
+      
+      it "accepts http options" do
+        options = {:some_http_option => true}          
+        @test_users.api.should_receive(:graph_call).with(anything, anything, anything, options)
+        @test_users.list(options)
+      end
+    end
 
-      describe "#delete" do
-        before :each do
-          @user1 = @test_users.create(true, "read_stream")
-          @user2 = @test_users.create(true, "read_stream,user_interests")
-        end
-
-        it "should delete a user by id" do
-          @test_users.delete(@user1['id']).should be_true
-          @user1 = nil
-        end
-
-        it "should delete a user by hash" do
-          @test_users.delete(@user2).should be_true
-          @user2 = nil
-        end
+    describe "#delete" do
+      before :each do
+        @user1 = @test_users.create(true, "read_stream")
+        @user2 = @test_users.create(true, "read_stream,user_interests")
+      end
 
-        it "should not delete users when provided a false ID" do
-          lambda { @test_users.delete("#{@user1['id']}1") }.should raise_exception(Koala::Facebook::APIError)
-        end
+      it "deletes a user by id" do
+        @test_users.delete(@user1['id']).should be_true
+        @user1 = nil
       end
 
-      describe "#delete_all" do
-        it "should delete all users found by the list commnand" do
-          array = [1, 2, 3]
-          @test_users.should_receive(:list).and_return(array)
-          array.each {|i| @test_users.should_receive(:delete).with(i) }
-          @test_users.delete_all
-        end
+      it "deletes a user by hash" do
+        @test_users.delete(@user2).should be_true
+        @user2 = nil
       end
 
-      describe "#update" do
-        before :each do
-          @updates = {:name => "Foo Baz"}
-          # we stub out :graph_call, but still need to be able to delete the users
-          @test_users2 = Koala::Facebook::TestUsers.new(:app_id => @test_users.app_id, :app_access_token => @test_users.app_access_token)
-        end
+      it "does not delete users when provided a false ID" do
+        lambda { @test_users.delete("#{@user1['id']}1") }.should raise_exception(Koala::Facebook::APIError)
+      end
+      
+      it "lets you specify http options that get passed through to the graph call" do
+        options = {:some_http_option => true}
+        # technically this goes through delete_object, but this makes it less brittle
+        @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        @test_users.delete("user", options)
+      end        
+    end
 
-        it "makes a POST with the test user Graph API " do
-          @user1 = @test_users2.create(true)
-          @test_users2.graph_api.should_receive(:graph_call).with(anything, anything, "post", anything)
-          @test_users2.update(@user1, @updates)
-        end
+    describe "#delete_all" do
+      it "deletes all users found by the list commnand" do
+        array = [1, 2, 3]
+        @test_users.should_receive(:list).and_return(array)
+        array.each {|i| @test_users.should_receive(:delete).with(i, anything) }
+        @test_users.delete_all
+      end
+      
+      it "accepts http options that get passed to both list and delete" do
+        array = [1, 2, 3]
+        options = {:some_http_option => true}
+        @test_users.should_receive(:list).with(options).and_return(array)
+        array.each {|i| @test_users.should_receive(:delete).with(anything, options) }
+        @test_users.delete_all(options)
+      end        
+    end
 
-        it "makes a request to the test user with the update params " do
-          @user1 = @test_users2.create(true)
-          @test_users2.graph_api.should_receive(:graph_call).with(@user1["id"], @updates, anything, anything)
-          @test_users2.update(@user1, @updates)
-        end
+    describe "#update" do
+      before :each do
+        @updates = {:name => "Foo Baz"}
+        # we stub out :graph_call, but still need to be able to delete the users
+        @test_users2 = Koala::Facebook::TestUsers.new(:app_id => @test_users.app_id, :app_access_token => @test_users.app_access_token)
+      end
 
-        it "works" do
-          @user1 = @test_users.create(true)
-          @test_users.update(@user1, @updates)
-          user_info = Koala::Facebook::API.new(@user1["access_token"]).get_object(@user1["id"])
-          user_info["name"].should == @updates[:name]
-        end
+      it "makes a POST with the test user Graph API " do
+        @user1 = @test_users2.create(true)
+        @test_users2.graph_api.should_receive(:graph_call).with(anything, anything, "post", anything)
+        @test_users2.update(@user1, @updates)
       end
 
-      describe "with existing users" do
-        before :each do
-          @user1 = @test_users.create(true, "read_stream")
-          @user2 = @test_users.create(true, "read_stream,user_interests")
-        end
+      it "makes a request to the test user with the update params " do
+        @user1 = @test_users2.create(true)
+        @test_users2.graph_api.should_receive(:graph_call).with(@user1["id"], @updates, anything, anything)
+        @test_users2.update(@user1, @updates)
+      end
+      
+      it "accepts an options hash" do
+        options = {:some_http_option => true}          
+        @test_users2.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        @test_users2.update("foo", @updates, options)
+      end
 
-        it "should list test users" do
-          result = @test_users.list
-          result.should be_an(Array)
-          first_user, second_user = result[0], result[1]
-          (first_user["id"] && first_user["access_token"] && first_user["login_url"]).should
-          (second_user["id"] && second_user["access_token"] && second_user["login_url"]).should
-        end
+      it "works" do
+        @user1 = @test_users.create(true)
+        @test_users.update(@user1, @updates)
+        user_info = Koala::Facebook::API.new(@user1["access_token"]).get_object(@user1["id"])
+        user_info["name"].should == @updates[:name]
+      end
+    end
+    
+    describe "#befriend" do
+      before :each do
+        @user1 = @test_users.create(true, "read_stream")
+        @user2 = @test_users.create(true, "read_stream,user_interests")
+      end
+      
+      it "makes two users into friends with string hashes" do
+        result = @test_users.befriend(@user1, @user2)
+        result.should be_true
+      end
 
-        it "should make two users into friends with string hashes" do
-          result = @test_users.befriend(@user1, @user2)
-          result.should be_true
-        end
+      it "makes two users into friends with symbol hashes" do
+        new_user_1 = {}
+        @user1.each_pair {|k, v| new_user_1[k.to_sym] = v}
+        new_user_2 = {}
+        @user2.each_pair {|k, v| new_user_2[k.to_sym] = v}
 
-        it "should make two users into friends with symbol hashes" do
-          new_user_1 = {}
-          @user1.each_pair {|k, v| new_user_1[k.to_sym] = v}
-          new_user_2 = {}
-          @user2.each_pair {|k, v| new_user_2[k.to_sym] = v}
+        result = @test_users.befriend(new_user_1, new_user_2)
+        result.should be_true
+      end
 
-          result = @test_users.befriend(new_user_1, new_user_2)
-          result.should be_true
-        end
+      it "does not accept user IDs anymore" do
+        lambda { @test_users.befriend(@user1["id"], @user2["id"]) }.should raise_exception
+      end
+      
+      it "accepts http options passed to both calls" do
+        options = {:some_http_option => true}  
+        # should come twice, once for each user
+        Koala.http_service.should_receive(:make_request).with(anything, anything, anything, options).twice.and_return(Koala::HTTPService::Response.new(200, "{}", {}))
+        @test_users.befriend(@user1, @user2, options)
+      end        
+    end
+  end # when used without network
 
-        it "should not accept user IDs anymore" do
-          lambda { @test_users.befriend(@user1["id"], @user2["id"]) }.should raise_exception
-        end
-      end # with existing users
+  describe "#test_user_accounts_path" do
+    it "returns the app_id/accounts/test-users" do
+      @test_users.test_user_accounts_path.should == "/#{@app_id}/accounts/test-users"
+    end
+  end
 
-    end # when used without network
+  describe "when creating a network of friends" do
+    before :each do
+      @network = []
 
-    describe "when creating a network of friends" do
-      before :each do
-        @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
-        @network = []
-
-        if KoalaTest.mock_interface?
-          id_counter = 999999900
-          @test_users.stub!(:create).and_return do
-            id_counter += 1
-            {"id" => id_counter, "access_token" => @token, "login_url" => "https://www.facebook.com/platform/test_account.."}
-          end
-          @test_users.stub!(:befriend).and_return(true)
-          @test_users.stub!(:delete).and_return(true)
+      if KoalaTest.mock_interface?
+        id_counter = 999999900
+        @test_users.stub!(:create).and_return do
+          id_counter += 1
+          {"id" => id_counter, "access_token" => @token, "login_url" => "https://www.facebook.com/platform/test_account.."}
         end
+        @test_users.stub!(:befriend).and_return(true)
+        @test_users.stub!(:delete).and_return(true)
       end
+    end
 
-      describe "tests that create users" do
-        it "should create a 5 person network" do
-          size = 5
-          @network = @test_users.create_network(size)
-          @network.should be_a(Array)
-          @network.size.should == size
-        end
+    describe "tests that create users" do
+      it "creates a 5 person network" do
+        size = 5
+        @network = @test_users.create_network(size)
+        @network.should be_a(Array)
+        @network.size.should == size
       end
+    end
 
-      it "has no built-in network size limit" do
-        times = 100
-        @test_users.should_receive(:create).exactly(times).times
-        @test_users.stub!(:befriend)
-        @network = @test_users.create_network(times)
-      end
+    it "has no built-in network size limit" do
+      times = 100
+      @test_users.should_receive(:create).exactly(times).times
+      @test_users.stub!(:befriend)
+      @test_users.create_network(times)
+    end
 
-      it "should pass on the installed and permissions parameters to create" do
-        perms = ["read_stream", "offline_access"]
-        installed = false
-        count = 25
-        @test_users.should_receive(:create).exactly(count).times.with(installed, perms)
-        @test_users.stub!(:befriend)
-        @network = @test_users.create_network(count, installed, perms)
-      end
+    it "passes on the installed and permissions parameters to create" do
+      perms = ["read_stream", "offline_access"]
+      installed = false
+      count = 25
+      @test_users.should_receive(:create).exactly(count).times.with(installed, perms, anything)
+      @test_users.stub!(:befriend)
+      @test_users.create_network(count, installed, perms)
+    end
 
-    end # when creating network
-  end
+    it "accepts http options that are passed to both the create and befriend calls" do
+      count = 25
+      options = {:some_http_option => true}  
+      @test_users.should_receive(:create).exactly(count).times.with(anything, anything, options).and_return({})
+      # there are more befriends than creates, but we don't need to do the extra work to calculate out the exact #
+      @test_users.should_receive(:befriend).at_least(count).times.with(anything, anything, options)
+      @test_users.create_network(count, true, "", options)
+    end
+  end # when creating network
 end  # describe Koala TestUsers