koala 1.5.0 → 1.6.0.rc1

data/spec/cases/graph_api_batch_spec.rb

@@ -381,58 +381,56 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             }.to raise_exception(Koala::Facebook::APIError)
           end
 
-          it "raises an APIError if the body is empty" do
+          it "raises a BadFacebookResponse if the body is empty" do
             Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, "", {}))
             expect {
               Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
-            }.to raise_exception(Koala::Facebook::APIError)
+            }.to raise_exception(Koala::Facebook::BadFacebookResponse)
           end
 
           context "with the old style" do
             before :each do
-              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":190,"error_description":"Error validating access token."}', {}))
+              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(400, '{"error_code":190,"error_description":"Error validating access token."}', {}))
             end
 
-            it "throws an error if the response is an old Batch API-style error" do
+            it "throws an error" do
               expect {
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               }.to raise_exception(Koala::Facebook::APIError)
             end
 
-            it "provides a type for the error if the response is an old Batch API-style error" do
+            it "passes all the error details" do
               begin
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               rescue Koala::Facebook::APIError => err
+                err.fb_error_code.should == 190
+                err.fb_error_message.should == "Error validating access token."
+                err.http_status == 400
+                err.response_body == '{"error_code":190,"error_description":"Error validating access token."}'
               end
-              err.fb_error_type.should
-            end
-
-            it "passes all the error details if an old Batch API-style error is raised" do
-              begin
-                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
-              rescue Koala::Facebook::APIError => err
-              end
-              err.raw_response["error"].should == 190
             end
           end
 
           context "with the new style" do
             before :each do
-              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}', {}))
+              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(400, '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}', {}))
             end
 
-            it "throws an error if the response is a new Graph API-style error" do
+            it "throws an error" do
               expect {
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               }.to raise_exception(Koala::Facebook::APIError)
             end
 
-            it "passes all the error details if an old Batch API-style error is raised" do
+            it "passes all the error details" do
               begin
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               rescue Koala::Facebook::APIError => err
+                err.fb_error_type.should == "GraphBatchException"
+                err.fb_error_message.should == "Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests"
+                err.http_status == 400
+                err.response_body == '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}'
               end
-              err.raw_response["message"].should
             end
           end
         end
@@ -509,7 +507,8 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       pictures = @api.batch do |batch_api|
         batch_api.get_picture('me')
       end
-      pictures.first.should_not be_empty
+      puts pictures.inspect
+      pictures.first.should =~ /http\:\/\// # works both live & stubbed
     end
 
     it "handles requests for two different tokens" do
@@ -526,7 +525,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         batch_api.get_connection("2", "invalidconnection")
         batch_api.get_object(KoalaTest.user1, {}, {"access_token" => @app_api.access_token})
       end
-      failed_call.should be_a(Koala::Facebook::APIError)
+      failed_call.should be_a(Koala::Facebook::ClientError)
       koppel["id"].should_not be_nil
     end
 
@@ -550,6 +549,42 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       fql_result[0]["first_name"].should == "Alex"
     end
 
+    describe 'with post-processing callback' do
+      let(:me_result) { stub("me result") }
+      let(:friends_result) { stub("friends result") }
+
+      let(:me_callback) { lambda {|data| me_result } }
+      let(:friends_callback) { lambda {|data| friends_result } }
+
+      it 'calls the callback with the appropriate data' do
+        me_callback.should_receive(:call).with(hash_including(
+          'id' => KoalaTest.user1
+        ))
+        friends_callback.should_receive(:call).with([
+          hash_including('id' => KoalaTest.user2)
+        ])
+        @api.batch do |batch_api|
+          batch_api.get_object('me', &me_callback)
+          batch_api.get_connections('me', 'friends', &friends_callback)
+        end
+      end
+
+      it 'passes GraphCollections, not raw data' do
+        friends_callback.should_receive(:call).with(kind_of(Koala::Facebook::API::GraphCollection))
+        @api.batch do |batch_api|
+          batch_api.get_object('me')
+          batch_api.get_connections('me', 'friends', &friends_callback)
+        end
+      end
+
+      it "returns the result of the callback" do
+        @api.batch do |batch_api|
+          batch_api.get_object('me', &me_callback)
+          batch_api.get_connections('me', 'friends', &friends_callback)
+        end.should == [me_result, friends_result]
+      end
+    end
+
     describe "binary files" do
       it "posts binary files" do
         file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
@@ -614,7 +649,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           batch_api.get_object(KoalaTest.user1, {}, :batch_args => {:depends_on => "getdata"})
         end
 
-        failed_call.should be_a(Koala::Facebook::APIError)
+        failed_call.should be_a(Koala::Facebook::ClientError)
         koppel.should be_nil
       end
 
@@ -624,7 +659,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             batch_api.get_connections("me", "friends", {:limit => 5})
             batch_api.get_objects("{result=i-dont-exist:$.data.*.id}")
           end
-        }.to raise_exception(Koala::Facebook::APIError)
+        }.to raise_exception(Koala::Facebook::ClientError)
       end
     end
   end

data/spec/cases/graph_api_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'Koala::Facebook::GraphAPIMethods' do
+  before do
+    @api = Koala::Facebook::API.new(@token)
+    # app API
+    @app_id = KoalaTest.app_id
+    @app_access_token = KoalaTest.app_access_token
+    @app_api = Koala::Facebook::API.new(@app_access_token)
+  end
+
+  describe 'post-processing for' do
+    let(:post_processing) { lambda {} }
+
+    # Most API methods have the same signature, we test get_object representatively
+    # and the other methods which do some post-processing locally
+    context '#get_object' do
+      it 'returns result of block' do
+        result = {"id" => 1, "name" => 1, "updated_time" => 1}
+        @api.stub(:api).and_return(result)
+        post_processing.should_receive(:call).
+          with(result).and_return('new result')
+        @api.get_object('koppel', &post_processing).should == 'new result'
+      end
+    end
+
+    context '#get_picture' do
+      it 'returns result of block' do
+        result = "http://facebook.com/"
+        @api.stub(:api).and_return("Location" => result)
+        post_processing.should_receive(:call).
+          with(result).and_return('new result')
+        @api.get_picture('lukeshepard', &post_processing).should == 'new result'
+      end
+    end
+
+    context '#fql_multiquery' do
+      before do
+        @api.should_receive(:get_object).and_return([
+          {"name" => "query1", "fql_result_set" => [{"id" => 123}]},
+          {"name" => "query2", "fql_result_set" => ["id" => 456]}
+        ])
+      end
+
+      it 'is called with resolved response' do
+        resolved_result = {
+          'query1' => [{'id' => 123}],
+          'query2' => [{'id'=>456}]
+        }
+        post_processing.should_receive(:call).
+          with(resolved_result).and_return('id'=>'123', 'id'=>'456')
+        @api.fql_multiquery({}, &post_processing).should ==
+          {'id'=>'123', 'id'=>'456'}
+      end
+    end
+
+    context '#get_page_access_token' do
+      it 'returns result of block' do
+        token = Koala::MockHTTPService::APP_ACCESS_TOKEN
+        @api.stub(:api).and_return("access_token" => token)
+        post_processing.should_receive(:call).
+          with(token).and_return('base64-encoded access token')
+        @api.get_page_access_token('facebook', &post_processing).should ==
+          'base64-encoded access token'
+      end
+    end
+  end
+end

data/spec/cases/graph_collection_spec.rb

@@ -104,6 +104,12 @@ describe Koala::Facebook::GraphCollection do
         args_hash = {"one" => "val_one", "two" => "val_two"}
         Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").should == [base, args_hash]
       end
+
+      it "works with addresses with irregular characters" do
+        access_token = "appid123a|fdcba"
+        base, args_hash = Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
+        args_hash["token"].should == access_token
+      end
     end
   end
 

data/spec/cases/oauth_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::OAuth" do
-  before :each do
+  before :all do
     # make the relevant test data easily accessible
     @app_id = KoalaTest.app_id
     @secret = KoalaTest.secret
@@ -24,7 +24,9 @@ describe "Koala::Facebook::OAuth" do
     @multiple_session_keys = [KoalaTest.session_key, KoalaTest.session_key] if KoalaTest.session_key
 
     @oauth = Koala::Facebook::OAuth.new(@app_id, @secret, @callback_url)
+  end
 
+  before :each do
     @time = Time.now
     Time.stub!(:now).and_return(@time)
     @time.stub!(:to_i).and_return(1273363199)
@@ -117,19 +119,16 @@ describe "Koala::Facebook::OAuth" do
           end
 
           it "returns nil if the call to FB returns an expired code error" do
-            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::APIError.new(
-              "type" => "OAuthException",
-              "message" => "Code was invalid or expired. Session has expired at unix time 1324044000. The current unix time is 1324300957."
+            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
+              '{ "error": { "type": "OAuthException", "message": "Code was invalid or expired. Session has expired at unix time 1324044000. The current unix time is 1324300957." } }'
             ))
             @oauth.get_user_info_from_cookies(@cookie).should be_nil
           end
 
           it "raises the error if the call to FB returns a different error" do
-            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::APIError.new(
-              "type" => "OtherError",
-              "message" => "A Facebook Error"
-            ))
-            expect { @oauth.get_user_info_from_cookies(@cookie) }.to raise_exception(Koala::Facebook::APIError)
+            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
+              '{ "error": { "type": "OtherError", "message": "A Facebook Error" } }'))
+            expect { @oauth.get_user_info_from_cookies(@cookie) }.to raise_exception(Koala::Facebook::OAuthTokenRequestError)
           end
         end
 
@@ -149,6 +148,7 @@ describe "Koala::Facebook::OAuth" do
 
         it "returns all the cookie components from valid cookie string" do
           cookie_data = KoalaTest.oauth_test_data["valid_cookies"]
+          puts cookie_data.inspect
           parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
           number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
           parsing_results.length.should == number_of_components
@@ -295,13 +295,13 @@ describe "Koala::Facebook::OAuth" do
 
       it "generates a properly formatted OAuth token URL when provided a code" do
         url = @oauth.url_for_access_token(@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
+        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}")
       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 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
+        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}")
       end
 
       it "includes any additional options as URL parameters, appropriately escaped" do
@@ -399,7 +399,7 @@ describe "Koala::Facebook::OAuth" do
         end
 
         it "raises an error when get_access_token is called with a bad code" do
-          lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::APIError)
+          lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
       end
     end
@@ -425,7 +425,7 @@ describe "Koala::Facebook::OAuth" do
         end
 
         it "raises an error when get_access_token is called with a bad code" do
-          lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::APIError)
+          lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
       end
     end
@@ -493,7 +493,7 @@ describe "Koala::Facebook::OAuth" do
       end
 
       it "raises an error when exchange_access_token_info is called with a bad code" do
-        lambda { @oauth.exchange_access_token_info("foo") }.should raise_error(Koala::Facebook::APIError)
+        lambda { @oauth.exchange_access_token_info("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
       end
     end
 
@@ -579,9 +579,9 @@ describe "Koala::Facebook::OAuth" do
           result.each_with_index {|r, index| index > 0 ? r.should(be_a(Hash)) : r.should(be_nil)}
         end
 
-        it "throws an APIError if Facebook returns an empty body (as happens for instance when the API breaks)" do
+        it "throws a BadFacebookResponse if Facebook returns an empty body (as happens for instance when the API breaks)" do
           @oauth.should_receive(:fetch_token_string).and_return("")
-          lambda { @oauth.get_token_info_from_session_keys(@multiple_session_keys) }.should raise_error(Koala::Facebook::APIError)
+          lambda { @oauth.get_token_info_from_session_keys(@multiple_session_keys) }.should raise_error(Koala::Facebook::BadFacebookResponse)
         end
 
         it "passes on any options provided to make_request" do

data/spec/cases/realtime_updates_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'base64'
 
 describe "Koala::Facebook::RealtimeUpdates" do
   before :all do
@@ -7,24 +8,24 @@ describe "Koala::Facebook::RealtimeUpdates" do
     @secret = KoalaTest.secret
     @callback_url = KoalaTest.oauth_test_data["callback_url"]
     @app_access_token = KoalaTest.app_access_token
-    
+
     # check OAuth data
     unless @app_id && @secret && @callback_url && @app_access_token
-      raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!" 
+      raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
     end
-    
+
     # get subscription data
     @verify_token = KoalaTest.subscription_test_data["verify_token"]
     @challenge_data = KoalaTest.subscription_test_data["challenge_data"]
     @subscription_path = KoalaTest.subscription_test_data["subscription_path"]
-    
+
     # check subscription data
     unless @verify_token && @challenge_data && @subscription_path
-      raise Exception, "Must supply verify_token and equivalent challenge_data to run subscription tests!" 
+      raise Exception, "Must supply verify_token and equivalent challenge_data to run subscription tests!"
     end
   end
 
-  before :each do 
+  before :each do
     @updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
   end
 
@@ -34,28 +35,28 @@ describe "Koala::Facebook::RealtimeUpdates" 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 "allows read access to app_id" do
-      # in Ruby 1.9, .method returns symbols 
+      # 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 "allows read access to app_access_token" do
-      # in Ruby 1.9, .method returns symbols 
+      # 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 "allows read access to secret" do
-      # in Ruby 1.9, .method returns symbols 
+      # 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 "allows read access to api" do
-      # in Ruby 1.9, .method returns symbols 
+      # 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=)
     end
@@ -71,35 +72,35 @@ describe "Koala::Facebook::RealtimeUpdates" do
       Koala::Utils.should_receive(:deprecate)
       updates.graph_api
     end
-    
+
     # init with secret / fetching the token
-    it "initializes 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)      
+      updates.should be_a(Koala::Facebook::RealtimeUpdates)
     end
 
-    it "fetches 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 "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) 
+      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 
+
+    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
+
   end
 
-  describe "#subscribe" do   
+  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)
@@ -112,11 +113,11 @@ describe "Koala::Facebook::RealtimeUpdates" do
         :object => obj,
         :fields => fields,
         :callback_url => @subscription_path,
-        :verify_token => @verify_token 
+        :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"
@@ -124,50 +125,36 @@ describe "Koala::Facebook::RealtimeUpdates" do
       @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 "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 "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 "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
+        expect { @updates.subscribe("user", "name", @subscription_path, @verify_token) }.to_not raise_error
       end
-    
+
       pending "sends a subscription request without a verify token" do
-        result = @updates.subscribe("user", "name", @subscription_path)
-        result.should be_true
+        expect { @updates.subscribe("user", "name", @subscription_path) }.to_not raise_error
       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
-  
+
   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)
@@ -179,65 +166,76 @@ describe "Koala::Facebook::RealtimeUpdates" do
       @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
+      it "unsubscribes a valid individual object successfully" do
+        expect { @updates.unsubscribe("user") }.to_not raise_error
       end
 
-      it "unsubscribes all subscriptions successfully" do 
-        @updates.unsubscribe.should be_true
+      it "unsubscribes all subscriptions successfully" do
+        expect { @updates.unsubscribe }.to_not raise_error
       end
 
-      it "fails when an invalid object is provided to unsubscribe" do 
+      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 "accepts options" do
-      options = {:a => 3, :b => "D"}      
+      options = {:a => 3, :b => "D"}
       @updates.api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options))
       @updates.list_subscriptions(options)
     end
-    
+
     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 ".validate_update" do
+    it "returns false if there is no X-Hub-Signature header" do
+      @updates.validate_update("", {}).should be_false
+    end
+
+    it "returns false if the signature doesn't match the body" do
+      @updates.validate_update("", {"X-Hub-Signature" => "sha1=badsha1"}).should be_false
+    end
+
+    it "results true if the signature matches the body with the secret" do
+      body = "BODY"
+      signature = OpenSSL::HMAC.hexdigest('sha1', @secret, body).chomp
+      @updates.validate_update(body, {"X-Hub-Signature" => "sha1=#{signature}"}).should be_true
+    end
+
+    it "results true with alternate HTTP_X_HUB_SIGNATURE header" do
+      body = "BODY"
+      signature = OpenSSL::HMAC.hexdigest('sha1', @secret, body).chomp
+      @updates.validate_update(body, {"HTTP_X_HUB_SIGNATURE" => "sha1=#{signature}"}).should be_true
+    end
+
+  end
+
   describe ".meet_challenge" do
     it "returns false if hub.mode isn't subscribe" do
       params = {'hub.mode' => 'not subscribe'}
@@ -250,56 +248,56 @@ describe "Koala::Facebook::RealtimeUpdates" do
       Koala::Facebook::RealtimeUpdates.meet_challenge(params){|token| block_evaluated = true}
       block_evaluated.should be_false
     end
-    
+
     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
-    
+
     describe "and mode is 'subscribe'" do
-      before(:each) do 
+      before(:each) do
         @params = {'hub.mode' => 'subscribe'}
       end
-      
+
       describe "and a token is given" do
         before(:each) do
           @token = 'token'
           @params['hub.verify_token'] = @token
         end
-        
+
         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 "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
       end
-      
+
       describe "and a block is given" do
         before :each do
           @params['hub.verify_token'] = @token
         end
-          
+
         it "gives the block the token as a parameter" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             token.should == @token
           end
         end
-        
+
         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 "returns false if the given block returns nil" do
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
             nil
           end.should be_false
         end
-        
+
         it "returns the challenge if the given block returns true" do
           @params['hub.challenge'] = 'challenge val'
           Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|