koala 0.6.0 → 0.7.0

data/spec/koala/graph_and_rest_api/graph_and_rest_api_with_token_tests.rb

@@ -0,0 +1,11 @@
+class GraphAndRestAPIWithTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAndRestAPI without an access token" do
+    it_should_behave_like "live testing examples"
+    it_should_behave_like "Koala RestAPI with an access token"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    
+    before(:each) do
+      @api = Koala::Facebook::GraphAndRestAPI.new(@token)
+    end
+  end
+end

data/spec/koala/graph_api/graph_api_no_access_token_tests.rb

@@ -0,0 +1,101 @@
+shared_examples_for "Koala GraphAPI without an access token" do
+  it "should get public data about a user" do
+    result = @api.get_object("koppel")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should
+  end
+
+  it "should not get private data about a user" do
+    result = @api.get_object("koppel")
+    # updated_time should be a pretty fixed test case
+    result["updated_time"].should be_nil
+  end
+
+  it "should get public data about a Page" do
+    result = @api.get_object("contextoptional")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should
+  end
+
+  it "should not be able to get data about 'me'" do
+    lambda { @api.get_object("me") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "should be able to get multiple objects" do
+    results = @api.get_objects(["contextoptional", "naitik"])
+    results.length.should == 2
+  end
+
+  it "shouldn't be able to access connections from users" do
+    lambda { @api.get_connections("lukeshepard", "likes") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "should be able to access a user's picture" do
+    @api.get_picture("chris.baclig").should =~ /http\:\/\//
+  end
+
+  it "should be able to access connections from public Pages" do
+    result = @api.get_connections("contextoptional", "likes")
+    result["data"].should be_a(Array)
+  end
+
+  it "should not be able to put an object" do
+    lambda { @result = @api.put_object("lukeshepard", "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow put onto Luke Shepard's wall!" if @result
+  end
+
+  # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
+  it "should not be able to post to a feed" do
+    (lambda do
+      attachment = {:name => "Context Optional", :link => "http://www.contextoptional.com/"}
+      @result = @api.put_wall_post("Hello, world", attachment, "contextoptional") 
+    end).should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow put onto Context Optional's wall!" if @result
+  end
+
+  it "should not be able to comment on an object" do
+    # random public post on the ContextOptional wall
+    lambda { @result = @api.put_comment("7204941866_119776748033392", "The hackathon was great!") }.should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow commented on post 7204941866_119776748033392!" if @result    
+  end
+
+  it "should not be able to like an object" do
+    lambda { @api.put_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+
+  # DELETE
+  it "should not be able to delete posts" do 
+    # test post on the Ruby SDK Test application
+    lambda { @result = @api.delete_object("115349521819193_113815981982767") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  # SEARCH
+  it "should be able to search" do
+    result = @api.search("facebook")
+    result["data"].should be_an(Array)
+  end
+
+  # API
+  it "should never use the rest api server" do
+    Koala.should_receive(:make_request).with(
+      anything,
+      anything,
+      anything,
+      hash_not_including(:rest_api => true)
+    ).and_return(Koala::Response.new(200, "", {}))      
+    
+    @api.api("anything")
+  end
+end
+
+class FacebookNoAccessTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAPI without an access token" do
+    before :each do
+      @api = Koala::Facebook::GraphAPI.new
+    end  
+    
+    it_should_behave_like "Koala GraphAPI without an access token"
+  end
+end
+  

data/spec/koala/{facebook_with_access_token_tests.rb → graph_api/graph_api_with_access_token_tests.rb}

@@ -1,95 +1,83 @@
-class FacebookWithAccessTokenTests < Test::Unit::TestCase
-  describe "Koala GraphAPI with an access token" do
-    before :each do
-      token = $testing_data["oauth_token"]
-      raise Exception, "Must supply access token to run FacebookWithAccessTokenTests!" unless token
-      @graph = Koala::Facebook::GraphAPI.new(token)
-    end
-    
-    after :each do 
-      # clean up any temporary objects
-      if @temporary_object_id
-        puts "\nCleaning up temporary object #{@temporary_object_id.to_s}"
-        result = @graph.delete_object(@temporary_object_id)
-        raise "Unable to clean up temporary Graph object #{@temporary_object_id}!" unless result
-      end
-    end
-
-    it "should get public data about a user" do
-      result = @graph.get_object("koppel")
+shared_examples_for "Koala GraphAPI with an access token" do
+it "should get public data about a user" do
+      result = @api.get_object("koppel")
       # the results should have an ID and a name, among other things
       (result["id"] && result["name"]).should_not be_nil
     end
 
     it "should get private data about a user" do
-      result = @graph.get_object("koppel")
+      result = @api.get_object("koppel")
       # updated_time should be a pretty fixed test case
       result["updated_time"].should_not be_nil
     end
 
     it "should get public data about a Page" do
-      result = @graph.get_object("contextoptional")
+      result = @api.get_object("contextoptional")
       # the results should have an ID and a name, among other things
       (result["id"] && result["name"]).should
     end
   
     it "should get data about 'me'" do
-      result = @graph.get_object("me")
+      result = @api.get_object("me")
       result["updated_time"].should
     end
   
     it "should be able to get multiple objects" do
-      result = @graph.get_objects(["contextoptional", "naitik"])
+      result = @api.get_objects(["contextoptional", "naitik"])
       result.length.should == 2
     end
   
+    it "should be able to access a user's picture" do
+      @api.get_picture("chris.baclig").should =~ /http\:\/\//
+    end
+  
     it "should be able to access connections from users" do
-      result = @graph.get_connections("lukeshepard", "likes")
+      result = @api.get_connections("lukeshepard", "likes")
       result["data"].length.should > 0
     end
 
     it "should be able to access connections from public Pages" do
-      result = @graph.get_connections("contextoptional", "likes")
+      result = @api.get_connections("contextoptional", "likes")
       result["data"].should be_a(Array)
     end
     
     # PUT
     it "should be able to write an object to the graph" do
-      result = @graph.put_wall_post("Hello, world, from the test suite!")
+      result = @api.put_wall_post("Hello, world, from the test suite!")
       @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
     # DELETE
     it "should be able to delete posts" do 
-      result = @graph.put_wall_post("Hello, world, from the test suite delete method!")
+      result = @api.put_wall_post("Hello, world, from the test suite delete method!")
       object_id_to_delete = result["id"]
-      delete_result = @graph.delete_object(object_id_to_delete)
+      delete_result = @api.delete_object(object_id_to_delete)
       delete_result.should == true
     end
 
     # additional put tests
     it "should be able to verify messages posted to a wall" do
       message = "the cats are asleep"
-      put_result = @graph.put_wall_post(message)
+      put_result = @api.put_wall_post(message)
       @temporary_object_id = put_result["id"]
-      get_result = @graph.get_object(@temporary_object_id)
+      get_result = @api.get_object(@temporary_object_id)
       
       # make sure the message we sent is the message that got posted
       get_result["message"].should == message
     end
 
     it "should be able to post a message with an attachment to a feed" do
-      result = @graph.put_wall_post("Hello, world, from the test suite again!", {:name => "Context Optional", :link => "http://www.contextoptional.com/"})
+      result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "Context Optional", :link => "http://www.contextoptional.com/"})
       @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
     end
     
     it "should be able to verify a message with an attachment posted to a feed" do
       attachment = {"name" => "Context Optional", "link" => "http://www.contextoptional.com/"}
-      result = @graph.put_wall_post("Hello, world, from the test suite again!", attachment)
+      result = @api.put_wall_post("Hello, world, from the test suite again!", attachment)
       @temporary_object_id = result["id"]
-      get_result = @graph.get_object(@temporary_object_id)
+      get_result = @api.get_object(@temporary_object_id)
 
       # make sure the result we fetch includes all the parameters we sent
       it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
@@ -97,43 +85,51 @@ class FacebookWithAccessTokenTests < Test::Unit::TestCase
     end
 
     it "should be able to comment on an object" do
-      result = @graph.put_wall_post("Hello, world, from the test suite, testing comments!")
+      result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
       @temporary_object_id = result["id"]
       
       # this will be deleted when the post gets deleted 
-      comment_result = @graph.put_comment(@temporary_object_id, "it's my comment!")
+      comment_result = @api.put_comment(@temporary_object_id, "it's my comment!")
       comment_result.should_not be_nil
     end
     
     it "should be able to verify a comment posted about an object" do
       message_text = "Hello, world, from the test suite, testing comments!"
-      result = @graph.put_wall_post(message_text)
+      result = @api.put_wall_post(message_text)
       @temporary_object_id = result["id"]
       
       # this will be deleted when the post gets deleted 
       comment_text = "it's my comment!"
-      comment_result = @graph.put_comment(@temporary_object_id, comment_text)
-      get_result = @graph.get_object(comment_result["id"])
+      comment_result = @api.put_comment(@temporary_object_id, comment_text)
+      get_result = @api.get_object(comment_result["id"])
 
       # make sure the text of the comment matches what we sent
       get_result["message"].should == comment_text
     end
 
     it "should be able to like an object" do
-      result = @graph.put_wall_post("Hello, world, from the test suite, testing comments!")
+      result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
       @temporary_object_id = result["id"]
-      like_result = @graph.put_like(@temporary_object_id)
+      like_result = @api.put_like(@temporary_object_id)
     end
 
     # SEARCH
     it "should be able to search" do
-      result = @graph.search("facebook")
+      result = @api.search("facebook")
       result["data"].should be_an(Array)
     end
 
     # API
     # the above tests test this already, but we should consider additional api tests
-    
-  end # describe
+end
 
-end #class
+class FacebookWithAccessTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAPI with an access token" do
+    it_should_behave_like "live testing examples"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    
+    before :each do
+      @api = Koala::Facebook::GraphAPI.new(@token)
+    end
+  end
+end

data/spec/koala/live_testing_data_helper.rb

@@ -0,0 +1,15 @@
+shared_examples_for "live testing examples" do
+    before :each do
+      @token = $testing_data["oauth_token"]
+      raise Exception, "Must supply access token to run FacebookWithAccessTokenTests!" unless @token
+    end
+    
+    after :each do 
+      # clean up any temporary objects
+      if @temporary_object_id
+        puts "\nCleaning up temporary object #{@temporary_object_id.to_s}"
+        result = @api.delete_object(@temporary_object_id)
+        raise "Unable to clean up temporary Graph object #{@temporary_object_id}!" unless result
+      end
+    end
+end

data/spec/koala/net_http_service_tests.rb

@@ -0,0 +1,15 @@
+require 'http_services'
+  
+class NetHTTPServiceTests < Test::Unit::TestCase
+  module Bear
+    include Koala::NetHTTPService
+  end
+  
+  it "should define a make_request static module method" do
+    Bear.respond_to?(:make_request).should be_true
+  end
+  
+  it "should use POST if verb is not GET"
+  
+  it "should return a Koala::Response object"
+end

data/spec/koala/{facebook_oauth_tests.rb → oauth/oauth_tests.rb}

@@ -156,36 +156,54 @@ class FacebookOAuthTests < Test::Unit::TestCase
       url.should == "https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&redirect_uri=#{callback}&client_secret=#{@secret}&code=#{@code}"
       out.should_not be_nil
     end
+
+    # START CODE THAT NEEDS MOCKING
+
+    # get_access_token
+    it "should properly get and parse an access token token results" do
+      result = @oauth.get_access_token(@code)
+      result["access_token"].should
+    end
+
+    it "should raise 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) 
+    end
+    
+    it "should properly get and parse an app's access token token results" do
+      result = @oauth.get_app_access_token
+      result["access_token"].should
+    end
+    
+    # protected methods
+    # since these are pretty fundamental and pretty testable, we want to test them
     
     # parse_access_token
     it "should properly parse access token results" do
-      result = @oauth.parse_access_token(@raw_token_string)
+      result = @oauth.send(:parse_access_token, @raw_token_string)
       has_both_parts = result["access_token"] && result["expires"]
       has_both_parts.should
     end
     
     it "should properly parse offline access token results" do
-      result = @oauth.parse_access_token(@raw_offline_access_token_string)
+      result = @oauth.send(:parse_access_token, @raw_offline_access_token_string)
       has_both_parts = result["access_token"] && !result["expires"]
       has_both_parts.should
     end
-
+    
     # fetch_token_string
-    # note -- we just test that this looks right, since get_access_token tests the parsing too
+    # somewhat duplicative with the tests for get_access_token and get_app_access_token
+    # but no harm in thoroughness
     it "should fetch a proper token string from Facebook when given a code" do
-      result = @oauth.fetch_token_string(@code)
+      result = @oauth.send(:fetch_token_string, :code => @code, :redirect_uri => @callback_url)
       result.should =~ /^access_token/
     end
-    
-    # get_access_token
-    it "should properly get and parse an access token token results" do
-      result = @oauth.get_access_token(@code)
-      result["access_token"].should
-    end
 
-    it "should raise 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) 
+    it "should fetch a proper token string from Facebook when asked for the app token" do
+      result = @oauth.send(:fetch_token_string, {:type => 'client_cred'}, true)
+      result.should =~ /^access_token/
     end
+    
+    # END CODE THAT NEEDS MOCKING
   end # describe
 
 end #class

data/spec/koala/realtime_updates/realtime_updates_tests.rb

@@ -0,0 +1,187 @@
+class FacebookRealtimeUpdatesTests < Test::Unit::TestCase
+  include Koala
+  
+  describe "Koala RealtimeUpdates" do
+    before :all do
+      # get oauth data
+      @oauth_data = $testing_data["oauth_test_data"]
+      @app_id = @oauth_data["app_id"]
+      @secret = @oauth_data["secret"]
+      @callback_url = @oauth_data["callback_url"]
+      @app_access_token = @oauth_data["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!" 
+      end
+      
+      # get subscription data
+      @subscription_data = $testing_data["subscription_test_data"]
+      @verify_token = @subscription_data["verify_token"]
+      @challenge_data = @subscription_data["challenge_data"]
+      @subscription_path = @subscription_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 live subscription tests!" 
+      end
+    end
+
+    describe "when initializing" do
+      # basic initialization
+      it "should initialize properly with an app_id and an app_access_token" do
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        updates.should be_a(Facebook::RealtimeUpdates)
+      end
+      
+      # attributes
+      it "should allow read access to app_id, app_access_token, and secret" do
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        # this should not throw errors
+        updates.app_id && updates.app_access_token && updates.secret
+      end
+      
+      it "should not allow write access to app_id" do
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        # this should not throw errors
+        lambda { updates.app_id = 2 }.should raise_error(NoMethodError)
+      end
+
+      it "should not allow write access to app_access_token" do
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        # this should not throw errors
+        lambda { updates.app_access_token = 2 }.should raise_error(NoMethodError)
+      end
+    
+      it "should not allow write access to secret" do
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        # this should not throw errors
+        lambda { updates.secret = 2 }.should raise_error(NoMethodError)
+      end
+      
+      # init with secret / fetching the token
+      it "should initialize properly with an app_id and a secret" do 
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+        updates.should be_a(Facebook::RealtimeUpdates)      
+      end
+
+      it "should fetch an app_token from Facebook when provided an app_id and a secret" do 
+        updates = 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
+        oauth = Facebook::OAuth.new(@app_id, @secret)
+        token = oauth.get_app_access_token
+        oauth.should_receive(:get_app_access_token).and_return(token)
+        Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth) 
+        updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+      end
+    end
+  
+    describe "when used" do
+      before :each do 
+        @updates = Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+      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
+      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
+      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)
+      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)
+      end
+    
+      it "should unsubscribe a valid individual object successfully" do 
+        @updates.unsubscribe("user").should be_true
+      end
+
+      it "should unsubscribe 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)
+      end
+      
+      it "should is subscriptions properly" do
+        @updates.list_subscriptions["data"].should be_a(Array)
+      end
+    end # describe "when used"
+    
+    describe "when meeting challenge" do
+      it "should return false if hub.mode isn't subscribe" do
+        params = {'hub.mode' => 'not subscribe'}
+        Facebook::RealtimeUpdates.meet_challenge(params).should be_false
+      end
+      
+      it "should return false if not given a verify_token or block" do
+        params = {'hub.mode' => 'subscribe'}
+        Facebook::RealtimeUpdates.meet_challenge(params).should be_false
+      end
+      
+      describe "and mode is 'subscribe'" 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 "should return false if the given verify token doesn't match" do
+            Facebook::RealtimeUpdates.meet_challenge(@params, @token + '1').should be_false
+          end
+          
+          it "should return the challenge if the given verify token matches" do
+            @params['hub.challenge'] = 'challenge val'
+            Facebook::RealtimeUpdates.meet_challenge(@params, @token).should == @params['hub.challenge']
+          end
+        end
+        
+        describe "and a block is given" do
+          it "should give the block the token as a parameter" do
+            Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+              token.should == @token
+            end
+          end
+          
+          it "should return false if the given block return false" do
+            Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+              false
+            end.should be_false
+          end
+          
+          it "should return false if the given block returns nil" do
+            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
+            @params['hub.challenge'] = 'challenge val'
+            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 #class

data/spec/koala/rest_api/rest_api_no_access_token_tests.rb

@@ -0,0 +1,94 @@
+shared_examples_for "Koala RestAPI without an access token" do
+  # REST_CALL
+  describe "when making a rest request" do
+    it "should use the proper path" do
+      method = stub('methodName')
+      @api.should_receive(:api).with(
+        "method/#{method}",
+        anything,
+        anything,
+        anything
+      )
+      
+      @api.rest_call(method)  
+    end
+    
+    it "should always use the rest api" do
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        :rest_api => true
+      )  
+      
+      @api.rest_call('anything')
+    end
+    
+    it "should take an optional hash of arguments" do
+      args = {:arg1 => 'arg1'}
+      
+      @api.should_receive(:api).with(
+        anything,
+        hash_including(args),
+        anything,
+        anything
+      )
+      
+      @api.rest_call('anything', args)
+    end
+    
+    it "should always ask for JSON" do
+      @api.should_receive(:api).with(
+        anything,
+        hash_including('format' => 'json'),
+        anything,
+        anything
+      )
+      
+      @api.rest_call('anything')
+    end
+  end 
+
+  # FQL_QUERY
+  describe "when making a FQL request" do
+    it "should call fql.query method" do
+      @api.should_receive(:rest_call).with(
+        "fql.query", 
+        anything
+      ).and_return(Koala::Response.new(200, "2", {}))
+      
+      @api.fql_query stub('query string')
+    end
+    
+    it "should pass a query argument" do
+      query = stub('query string')
+      
+      @api.should_receive(:rest_call).with(
+        anything,
+        hash_including("query" => query)
+      )
+      
+      @api.fql_query(query)
+    end
+  
+    it "should be able to access public information via FQL" do
+      @result = @api.fql_query("select first_name from user where uid = 216743")
+      @result.size.should == 1
+      @result.first["first_name"].should == "Chris"
+    end
+    
+    it "should not be able to access protected information via FQL" do
+      lambda { @api.fql_query("select read_stream from permissions where uid = 216743") }.should raise_error(Koala::Facebook::APIError)
+    end
+  end
+end
+
+class FacebookRestAPINoAccessTokenTest < Test::Unit::TestCase
+  before :each do
+    @api = Koala::Facebook::RestAPI.new
+  end
+  
+  describe "Koala RestAPI without an access token" do
+    it_should_behave_like "Koala RestAPI without an access token" 
+  end
+end