koala 1.2.1 → 1.3.0rc2

data/spec/cases/oauth_spec.rb

@@ -29,26 +29,27 @@ describe "Koala::Facebook::OAuth" do
     @time.stub!(:to_i).and_return(1273363199)
   end
 
-  # initialization
-  it "properly initializes" do
-    @oauth.should
-  end
+  describe ".new" do
+    it "properly initializes" do
+      @oauth.should
+    end
 
-  it "properly sets attributes" do
-    (@oauth.app_id == @app_id &&
-      @oauth.app_secret == @secret &&
-      @oauth.oauth_callback_url == @callback_url).should be_true
-  end
+    it "properly sets attributes" do
+      (@oauth.app_id == @app_id &&
+        @oauth.app_secret == @secret &&
+        @oauth.oauth_callback_url == @callback_url).should be_true
+    end
 
-  it "properly initializes without a callback_url" do
-    @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
-  end
+    it "properly initializes without a callback_url" do
+      @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+    end
 
-  it "properly sets attributes without a callback URL" do
-    @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
-    (@oauth.app_id == @app_id &&
-      @oauth.app_secret == @secret &&
-      @oauth.oauth_callback_url == nil).should be_true
+    it "properly sets attributes without a callback URL" do
+      @oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+      (@oauth.app_id == @app_id &&
+        @oauth.app_secret == @secret &&
+        @oauth.oauth_callback_url == nil).should be_true
+    end
   end
 
   describe "for cookie parsing" do
@@ -209,88 +210,157 @@ describe "Koala::Facebook::OAuth" do
     end
   end
 
-  # OAuth URLs
-
   describe "for URL generation" do
-
-    describe "for OAuth codes" do
-      # url_for_oauth_code
+    describe "#url_for_oauth_code" do
       it "generates a properly formatted OAuth code URL with the default values" do
         url = @oauth.url_for_oauth_code
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth code URL when a callback is given" do
         callback = "foo.com"
         url = @oauth.url_for_oauth_code(:callback => callback)
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}")
       end
 
       it "generates a properly formatted OAuth code URL when permissions are requested as a string" do
         permissions = "publish_stream,read_stream"
         url = @oauth.url_for_oauth_code(:permissions => permissions)
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}&scope=#{permissions}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&scope=#{CGI.escape permissions}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth code URL when permissions are requested as a string" do
         permissions = ["publish_stream", "read_stream"]
         url = @oauth.url_for_oauth_code(:permissions => permissions)
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}&scope=#{permissions.join(",")}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&scope=#{CGI.escape permissions.join(",")}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth code URL when both permissions and callback are provided" do
         permissions = "publish_stream,read_stream"
         callback = "foo.com"
         url = @oauth.url_for_oauth_code(:callback => callback, :permissions => permissions)
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{callback}&scope=#{permissions}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&scope=#{CGI.escape permissions}&redirect_uri=#{CGI.escape callback}")
       end
 
       it "generates a properly formatted OAuth code URL when a display is given as a string" do
         url = @oauth.url_for_oauth_code(:display => "page")
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&redirect_uri=#{@callback_url}&display=page"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/authorize?client_id=#{@app_id}&display=page&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "raises an exception if no callback is given in initialization or the call" do
         oauth2 = Koala::Facebook::OAuth.new(@app_id, @secret)
         lambda { oauth2.url_for_oauth_code }.should raise_error(ArgumentError)
       end
+      
+      it "includes any additional options as URL parameters, appropriately escaped" do
+        params = {
+          :url => "http://foo.bar?c=2",
+          :email => "cdc@b.com"
+        }
+        url = @oauth.url_for_oauth_code(params)
+        params.each_pair do |key, value| 
+          url.should =~ /[\&\?]#{key}=#{CGI.escape value}/
+        end
+      end
     end
 
-    describe "for access token URLs" do
+    describe "#url_for_access_token" do
       before :each do
         # since we're just composing a URL here, we don't need to have a real code
         @code ||= "test_code"
       end
-
-      # url_for_access_token
+      
       it "generates a properly formatted OAuth token URL when provided a code" do
         url = @oauth.url_for_access_token(@code)
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{@callback_url}&client_secret=#{@secret}&code=#{@code}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape @callback_url}").should be_true
       end
 
       it "generates a properly formatted OAuth token URL when provided a callback" do
         callback = "foo.com"
         url = @oauth.url_for_access_token(@code, :callback => callback)
-        url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@secret}&code=#{@code}"
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape callback}").should be_true
+      end
+
+      it "includes any additional options as URL parameters, appropriately escaped" do
+        params = {
+          :url => "http://foo.bar?c=2",
+          :email => "cdc@b.com"
+        }
+        url = @oauth.url_for_access_token(@code, params)
+        params.each_pair do |key, value| 
+          url.should =~ /[\&\?]#{key}=#{CGI.escape value}/
+        end
+      end
+    end
+    
+    describe "#url_for_dialog" do
+      it "builds the base properly" do
+        dialog_type = "my_dialog_type"
+        @oauth.url_for_dialog(dialog_type).should =~ /^http:\/\/#{Koala::Facebook::DIALOG_HOST}\/dialog\/#{dialog_type}/
+      end
+      
+      it "adds the app_id/client_id to the url" do
+        automatic_params = {:app_id => @app_id, :client_id => @client_id}
+        url = @oauth.url_for_dialog("foo", automatic_params)
+        automatic_params.each_pair do |key, value|
+          # we're slightly simplifying how encode_params works, but for strings/ints, it's okay
+          url.should =~ /[\&\?]#{key}=#{CGI.escape value.to_s}/
+        end
+      end
+            
+      it "includes any additional options as URL parameters, appropriately escaped" do
+        params = {
+          :url => "http://foo.bar?c=2",
+          :email => "cdc@b.com"
+        }
+        url = @oauth.url_for_dialog("friends", params)
+        params.each_pair do |key, value| 
+          # we're slightly simplifying how encode_params works, but strings/ints, it's okay
+          url.should =~ /[\&\?]#{key}=#{CGI.escape value.to_s}/
+        end
+      end
+      
+      describe "real examples from FB documentation" do
+        # see http://developers.facebook.com/docs/reference/dialogs/
+        # slightly brittle (e.g. if parameter order changes), but still useful
+        it "can generate a send dialog" do
+          url = @oauth.url_for_dialog("send", :name => "People Argue Just to Win", :link => "http://www.nytimes.com/2011/06/15/arts/people-argue-just-to-win-scholars-assert.html")
+          url.should match_url("http://www.facebook.com/dialog/send?app_id=#{@app_id}&client_id=#{@app_id}&link=http%3A%2F%2Fwww.nytimes.com%2F2011%2F06%2F15%2Farts%2Fpeople-argue-just-to-win-scholars-assert.html&name=People+Argue+Just+to+Win&redirect_uri=#{CGI.escape @callback_url}")
+        end
+      
+        it "can generate a feed dialog" do
+          url = @oauth.url_for_dialog("feed", :name => "People Argue Just to Win", :link => "http://www.nytimes.com/2011/06/15/arts/people-argue-just-to-win-scholars-assert.html")
+          url.should match_url("http://www.facebook.com/dialog/feed?app_id=#{@app_id}&client_id=#{@app_id}&link=http%3A%2F%2Fwww.nytimes.com%2F2011%2F06%2F15%2Farts%2Fpeople-argue-just-to-win-scholars-assert.html&name=People+Argue+Just+to+Win&redirect_uri=#{CGI.escape @callback_url}")
+        end
+      
+        it "can generate a oauth dialog" do
+          url = @oauth.url_for_dialog("oauth", :scope => "email", :response_type => "token")
+          url.should match_url("http://www.facebook.com/dialog/oauth?app_id=#{@app_id}&client_id=#{@app_id}&redirect_uri=#{CGI.escape @callback_url}&response_type=token&scope=email")
+        end
+      
+        it "can generate a pay dialog" do
+          url = @oauth.url_for_dialog("pay", :order_id => "foo", :credits_purchase => false)
+          url.should match_url("http://www.facebook.com/dialog/pay?app_id=#{@app_id}&client_id=#{@app_id}&order_id=foo&credits_purchase=false&redirect_uri=#{CGI.escape @callback_url}")
+        end
       end
     end
   end
 
   describe "for fetching access tokens" do
-    describe ".get_access_token_info" 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
 
@@ -311,11 +381,11 @@ describe "Koala::Facebook::OAuth" do
       end
     end
     
-    describe ".get_access_token" do
+    describe "#get_access_token" 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
 
@@ -354,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
@@ -373,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
@@ -454,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
@@ -486,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
@@ -516,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