koala 1.5.0 → 1.6.0

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|

data/spec/cases/test_users_spec.rb

@@ -14,11 +14,16 @@ describe "Koala::Facebook::TestUsers" do
       raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
     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)
+    # Facebook only allows us 500 test users per app, so we have to clean up
+    # This would be a good place to clean up and accumulate all of them for
+    # later deletion.
+    unless KoalaTest.mock_interface?
+      ((@network || []) + [@user1, @user2]).each do |u|
+        puts "Unable to delete test user #{u.inspect}" if u && !(@test_users.delete(u) rescue false)
+      end
     end
   end
 
@@ -128,7 +133,7 @@ describe "Koala::Facebook::TestUsers" do
         @test_users.create(true, nil, {}, options)
       end
     end
-    
+
     describe "#list" do
       before :each do
         @user1 = @test_users.create(true, "read_stream")
@@ -142,9 +147,9 @@ describe "Koala::Facebook::TestUsers" do
         (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}          
+        options = {:some_http_option => true}
         @test_users.api.should_receive(:graph_call).with(anything, anything, anything, options)
         @test_users.list(options)
       end
@@ -169,13 +174,13 @@ describe "Koala::Facebook::TestUsers" do
       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
     end
 
     describe "#delete_all" do
@@ -187,20 +192,20 @@ describe "Koala::Facebook::TestUsers" do
         array.each {|item| batch_api.should_receive(:delete_object).with(item["id"]) }
         @test_users.delete_all
       end
-      
+
       it "accepts http options that get passed to both list and the batch call" do
         options = {:some_http_option => true}
         @test_users.should_receive(:list).with(options).and_return([{"id" => rand}], [])
         @test_users.api.should_receive(:batch).with(options)
         @test_users.delete_all(options)
-      end  
-      
+      end
+
       it "breaks if Facebook sends back the same list twice" do
         list = [{"id" => rand}]
         @test_users.should_receive(:list).any_number_of_times.and_return(list)
         @test_users.api.should_receive(:batch).once
         @test_users.delete_all
-      end        
+      end
     end
 
     describe "#update" do
@@ -221,9 +226,9 @@ describe "Koala::Facebook::TestUsers" do
         @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}          
+        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
@@ -235,13 +240,13 @@ describe "Koala::Facebook::TestUsers" do
         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
@@ -260,13 +265,13 @@ describe "Koala::Facebook::TestUsers" do
       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}  
+        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
   end # when used without network
 
@@ -318,7 +323,7 @@ describe "Koala::Facebook::TestUsers" do
 
     it "accepts http options that are passed to both the create and befriend calls" do
       count = 25
-      options = {:some_http_option => true}  
+      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)