koala 1.0.0 → 1.2.0beta1

data/spec/support/graph_api_shared_examples.rb

@@ -16,7 +16,7 @@ shared_examples_for "Koala GraphAPI" do
   # GRAPH CALL
   describe "graph_call" do
     it "should pass all arguments to the api method" do
-      args = ["koppel", {}, "get", {:a => :b}]
+      args = [KoalaTest.user1, {}, "get", {:a => :b}]
 
       @api.should_receive(:api).with(*args)
 
@@ -25,7 +25,7 @@ shared_examples_for "Koala GraphAPI" do
 
     it "should throw an APIError if the result hash has an error key" do
       Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error" => "An error occurred!"}, {}))
-      lambda { @api.graph_call("koppel", {}) }.should raise_exception(Koala::Facebook::APIError)
+      lambda { @api.graph_call(KoalaTest.user1, {}) }.should raise_exception(Koala::Facebook::APIError)
     end
   end
 
@@ -40,20 +40,30 @@ shared_examples_for "Koala GraphAPI" do
 
   # get_object
   it "should get public data about a user" do
-    result = @api.get_object("koppel")
+    result = @api.get_object(KoalaTest.user1)
     # the results should have an ID and a name, among other things
     (result["id"] && result["name"]).should_not be_nil
   end
 
   it "should get public data about a Page" do
-    result = @api.get_object("contextoptional")
+    result = @api.get_object(KoalaTest.page)
     # the results should have an ID and a name, among other things
     (result["id"] && result["name"]).should
   end
 
+  it "should return [] from get_objects if passed an empty array" do
+    results = @api.get_objects([])
+    results.should == []
+  end
+
   it "should be able to get multiple objects" do
-    results = @api.get_objects(["contextoptional", "naitik"])
-    results.length.should == 2
+    results = @api.get_objects([KoalaTest.page, KoalaTest.user1])
+    results.should have(2).items
+  end
+
+  it "should be able to get multiple objects if they're a string" do
+    results = @api.get_objects("contextoptional,#{KoalaTest.user1}")
+    results.should have(2).items
   end
 
   it "should be able to access a user's picture" do
@@ -61,14 +71,24 @@ shared_examples_for "Koala GraphAPI" do
   end
 
   it "should be able to access a user's picture, given a picture type"  do
-    @api.get_picture("lukeshepard", {:type => 'large'}).should =~ /^http[s]*\:\/\//
+    @api.get_picture(KoalaTest.user2, {:type => 'large'}).should =~ /^http[s]*\:\/\//
   end
 
   it "should be able to access connections from public Pages" do
-    result = @api.get_connections("contextoptional", "photos")
+    result = @api.get_connections(KoalaTest.page, "photos")
     result.should be_a(Array)
   end
 
+  it "should be able to access comments for a URL" do
+    result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/472"])
+    (result["http://developers.facebook.com/blog/post/472"]).should
+  end
+
+  it "should be able to access comments for 2 URLs" do
+    result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/490", "http://developers.facebook.com/blog/post/472"])
+    (result["http://developers.facebook.com/blog/post/490"] && result["http://developers.facebook.com/blog/post/472"]).should
+  end
+
   # SEARCH
   it "should be able to search" do
     result = @api.search("facebook")
@@ -86,9 +106,8 @@ end
 
 
 shared_examples_for "Koala GraphAPI with an access token" do
-
   it "should get private data about a user" do
-    result = @api.get_object("koppel")
+    result = @api.get_object(KoalaTest.user1)
     # updated_time should be a pretty fixed test case
     result["updated_time"].should_not be_nil
   end
@@ -99,11 +118,11 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   it "should be able to get multiple objects" do
-    result = @api.get_objects(["contextoptional", "naitik"])
+    result = @api.get_objects([KoalaTest.page, KoalaTest.user1])
     result.length.should == 2
   end
   it "should be able to access connections from users" do
-    result = @api.get_connections("lukeshepard", "likes")
+    result = @api.get_connections(KoalaTest.user2, "friends")
     result.length.should > 0
   end
 
@@ -147,36 +166,91 @@ shared_examples_for "Koala GraphAPI with an access token" do
     @temporary_object_id.should_not be_nil
   end
 
-  it "should be able to post photos to the user's wall with an open file object" do
-    content_type = "image/jpg"      
-    file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
-    
-    result = @api.put_picture(file, content_type)
-    @temporary_object_id = result["id"] 
-    @temporary_object_id.should_not be_nil
-  end
-  
-  it "should be able to post photos to the user's wall without an open file object" do
-    content_type = "image/jpg",
-    file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
-    
-    result = @api.put_picture(file_path, content_type)
-    @temporary_object_id = result["id"] 
-    @temporary_object_id.should_not be_nil
+  describe ".put_picture" do
+    it "should be able to post photos to the user's wall with an open file object" do
+      content_type = "image/jpg"
+      file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
+
+      result = @api.put_picture(file, content_type)
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+
+    it "should be able to post photos to the user's wall without an open file object" do
+      content_type = "image/jpg",
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+
+      result = @api.put_picture(file_path, content_type)
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+
+    it "should be able to verify a photo posted to a user's wall" do
+      content_type = "image/jpg",
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+
+      expected_message = "This is the test message"
+
+      result = @api.put_picture(file_path, content_type, :message => expected_message)
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+
+      get_result = @api.get_object(@temporary_object_id)
+      get_result["name"].should == expected_message
+    end
+
+
+    describe "using a URL instead of a file" do
+      before :each do
+        @url = "http://img.slate.com/images/redesign2008/slate_logo.gif"
+      end
+
+      it "should be able to post photo to the user's wall using a URL" do
+        result = @api.put_picture(@url)
+        @temporary_object_id = result["id"]
+        @temporary_object_id.should_not be_nil
+      end
+
+      it "should be able to post photo to the user's wall using a URL and an additional param" do
+        result = @api.put_picture(@url, :message => "my message")
+        @temporary_object_id = result["id"]
+        @temporary_object_id.should_not be_nil
+      end
+    end
   end
-    
-  it "should be able to verify a photo posted to a user's wall" do
-    content_type = "image/jpg",
-    file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
-    
-    expected_message = "This is the test message"
-    
-    result = @api.put_picture(file_path, content_type, :message => expected_message)
-    @temporary_object_id = result["id"] 
-    @temporary_object_id.should_not be_nil
-    
-    get_result = @api.get_object(@temporary_object_id)
-    get_result["name"].should == expected_message
+
+  describe ".put_video" do
+    before :each do
+      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")
+      @content_type = "video/mpeg4"
+    end
+
+    it "should set options[:video] to true" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(false)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_video("foo")
+    end
+
+    it "should be able to post videos to the user's wall with an open file object" do
+      file = File.open(@cat_movie)
+
+      result = @api.put_video(file, @content_type)
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+
+
+    it "should be able to post videos to the user's wall without an open file object" do
+      result = @api.put_video(@cat_movie, @content_type)
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+
+    # note: Facebook doesn't post videos immediately to the wall, due to processing time
+    # during which get_object(video_id) will return false
+    # hence we can't do the same verify test we do for photos
   end
 
   it "should be able to verify a message with an attachment posted to a feed" do
@@ -220,6 +294,12 @@ shared_examples_for "Koala GraphAPI with an access token" do
     like_result.should be_true
   end
 
+  # Page Access Token Support
+  it "gets a page's access token" do
+    # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
+    @api.should_receive(:api).with("my_page", {:fields => "access_token"}, "get", anything)
+    @api.get_page_access_token("my_page")
+  end
 
   # test all methods to make sure they pass data through to the API
   # we run the tests here (rather than in the common shared example group)
@@ -240,6 +320,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
       :search => 3,
       # methods that have special arguments
       :put_picture => ["x.jpg", "image/jpg", {}, "me"],
+      :put_video => ["x.mp4", "video/mpeg4", {}, "me"],
       :get_objects => [["x"], {}]
     }.each_pair do |method_name, params|
       it "should pass http options through for #{method_name}" do
@@ -277,14 +358,14 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
   describe "when getting a collection" do
     # GraphCollection methods
     it "should get a GraphCollection when getting connections" do
-      @result = @api.get_connections("contextoptional", "photos")
+      @result = @api.get_connections(KoalaTest.page, "photos")
       @result.should be_a(Koala::Facebook::GraphCollection)
     end
 
     it "should return nil if the get_collections call fails with nil" do
       # this happens sometimes
       @api.should_receive(:graph_call).and_return(nil)
-      @api.get_connections("contextoptional", "photos").should be_nil
+      @api.get_connections(KoalaTest.page, "photos").should be_nil
     end
 
     it "should get a GraphCollection when searching" do
@@ -312,12 +393,12 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
     # GraphCollection attributes
     describe "the GraphCollection" do
       before(:each) do
-        @result = @api.get_connections("contextoptional", "photos")
+        @result = @api.get_connections(KoalaTest.page, "photos")
       end
 
       it "should have a read-only paging attribute" do
-        lambda { @result.paging }.should_not raise_error
-        lambda { @result.paging = "paging" }.should raise_error(NoMethodError)
+        @result.methods.map(&:to_sym).should include(:paging)
+        @result.methods.map(&:to_sym).should_not include(:paging=)
       end
 
       describe "when getting a whole page" do
@@ -330,18 +411,18 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
 
         it "should return the previous page of results" do
           @result.should_receive(:previous_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_return(@second_page)
+          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
           Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
 
-          @result.previous_page.should == @page_of_results
+          @result.previous_page#.should == @page_of_results
         end
 
         it "should return the next page of results" do
           @result.should_receive(:next_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_return(@second_page)
+          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
           Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
 
-          @result.next_page.should == @page_of_results
+          @result.next_page#.should == @page_of_results
         end
 
         it "should return nil it there are no other pages" do
@@ -354,7 +435,7 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
 
       describe "when parsing page paramters" do
         before(:each) do
-          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::GraphAPI.new)
+          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::API.new)
         end
 
         it "should return the base as the first array entry" do
@@ -385,12 +466,11 @@ shared_examples_for "Koala GraphAPI without an access token" do
   end
 
   it "shouldn't be able to access connections from users" do
-    lambda { @api.get_connections("lukeshepard", "likes") }.should raise_error(Koala::Facebook::APIError)
+    lambda { @api.get_connections("lukeshepard", "friends") }.should raise_error(Koala::Facebook::APIError)
   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
@@ -399,13 +479,11 @@ shared_examples_for "Koala GraphAPI without an access token" do
       attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.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
@@ -421,4 +499,4 @@ shared_examples_for "Koala GraphAPI without an access token" do
   it "should not be able to delete a like" do
     lambda { @api.delete_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::APIError)
   end
-end
+end

data/spec/support/json_testing_fix.rb

@@ -0,0 +1,42 @@
+# when testing across Ruby versions, we found that JSON string creation inconsistently ordered keys
+# which is a problem because our mock testing service ultimately matches strings to see if requests are mocked
+# this fix solves that problem by ensuring all hashes are created with a consistent key order every time
+module MultiJson
+  self.engine = :ok_json
+
+  class << self
+    def encode_with_ordering(object)
+      # if it's a hash, recreate it with k/v pairs inserted in sorted-by-key order
+      # (for some reason, REE fails if we don't assign the ternary result as a local variable
+      # separately from calling encode_original)
+      encode_original(sort_object(object))
+    end
+
+    alias_method :encode_original, :encode
+    alias_method :encode, :encode_with_ordering
+  
+    def decode_with_ordering(string)
+      sort_object(decode_original(string))
+    end
+
+    alias_method :decode_original, :decode
+    alias_method :decode, :decode_with_ordering
+    
+    private 
+  
+    def sort_object(object)
+      if object.is_a?(Hash)
+        sort_hash(object)
+      elsif object.is_a?(Array)
+        object.collect {|item| item.is_a?(Hash) ? sort_hash(item) : item}
+      else
+        object
+      end
+    end
+  
+    def sort_hash(unsorted_hash)
+      sorted_hash = KoalaTest::OrderedHash.new(sorted_hash)
+      unsorted_hash.keys.sort {|a, b| a.to_s <=> b.to_s}.inject(sorted_hash) {|hash, k| hash[k] = unsorted_hash[k]; hash}
+    end
+  end
+end

data/spec/support/koala_test.rb

@@ -0,0 +1,163 @@
+# small helper method for live testing
+module KoalaTest
+
+  class << self
+    attr_accessor :oauth_token, :app_id, :secret, :app_access_token, :code, :session_key
+    attr_accessor :oauth_test_data, :subscription_test_data
+  end
+    
+  # Test setup
+  
+  def self.setup_test_environment!
+    setup_rspec
+    
+    unless ENV['LIVE']
+      # By default the Koala specs are run using stubs for HTTP requests,
+      # so they won't fail due to Facebook-imposed rate limits or server timeouts.
+      #
+      # However as a result they are more brittle since
+      # we are not testing the latest responses from the Facebook servers.
+      # To be certain all specs pass with the current Facebook services, 
+      # run LIVE=true bundle exec rake spec.
+      Koala.http_service = Koala::MockHTTPService
+      KoalaTest.setup_test_data(Koala::MockHTTPService::TEST_DATA)
+    else
+      # Runs Koala specs through the Facebook servers
+      # using data for a real app
+      live_data = YAML.load_file(File.join(File.dirname(__FILE__), '../fixtures/facebook_data.yml'))
+      KoalaTest.setup_test_data(live_data)
+
+      # allow live tests with different adapters
+      adapter = ENV['ADAPTER'] || "typhoeus"# use Typhoeus by default if available
+      begin
+        require adapter
+        Faraday.default_adapter = adapter.to_sym
+      rescue LoadError
+        puts "Unable to load adapter #{adapter}, using Net::HTTP."
+      end
+
+      # use a test user unless the developer wants to test against a real profile
+      unless token = KoalaTest.oauth_token
+        KoalaTest.setup_test_users
+      else
+        KoalaTest.validate_user_info(token)
+      end
+    end
+  end
+  
+  def self.setup_rspec
+    # set up a global before block to set the token for tests
+    # set the token up for
+    RSpec.configure do |config|
+      config.before :each do
+        @token = KoalaTest.oauth_token
+        Koala::Utils.stub(:deprecate) # never fire deprecation warnings
+      end
+
+      config.after :each do
+        # clean up any objects posted to Facebook
+        if @temporary_object_id && !KoalaTest.mock_interface?
+          api = @api || (@test_users ? @test_users.graph_api : nil)
+          raise "Unable to locate API when passed temporary object to delete!" unless api
+
+          # wait 10ms to allow Facebook to propagate data so we can delete it
+          sleep(0.01)
+
+          # clean up any objects we've posted
+          result = (api.delete_object(@temporary_object_id) rescue false)
+          # if we errored out or Facebook returned false, track that
+          puts "Unable to delete #{@temporary_object_id}: #{result} (probably a photo or video, which can't be deleted through the API)" unless result
+        end
+      end
+    end
+  end
+
+  def self.setup_test_data(data)
+    # make data accessible to all our tests
+    self.oauth_test_data = data["oauth_test_data"]
+    self.subscription_test_data = data["subscription_test_data"]
+    self.oauth_token = data["oauth_token"]
+    self.app_id = data["oauth_test_data"]["app_id"]
+    self.app_access_token = data["oauth_test_data"]["app_access_token"]
+    self.secret = data["oauth_test_data"]["secret"]
+    self.code = data["oauth_test_data"]["code"]
+    self.session_key = data["oauth_test_data"]["session_key"]
+  end
+
+  def self.testing_permissions
+    "read_stream, publish_stream, user_photos, user_videos, read_insights"
+  end
+  
+  def self.setup_test_users
+    # note: we don't have to delete the two test users explicitly, since the test user specs do that for us
+    # technically, this is a point of brittleness and would break if the tests were run out of order
+    # however, for now we can live with it since it would slow tests way too much to constantly recreate our test users
+    print "Setting up test users..."
+    @test_user_api = Koala::Facebook::TestUsers.new(:app_id => self.app_id, :secret => self.secret)
+
+    # create two test users with specific names and befriend them
+    @live_testing_user = @test_user_api.create(true, testing_permissions, :name => user1_name)
+    @live_testing_friend = @test_user_api.create(true, testing_permissions, :name => user2_name)
+    @test_user_api.befriend(@live_testing_user, @live_testing_friend)
+    self.oauth_token = @live_testing_user["access_token"]
+
+    puts "done."
+  end
+
+  def self.validate_user_info(token)
+    print "Validating permissions for live testing..."
+    # make sure we have the necessary permissions
+    api = Koala::Facebook::API.new(token)
+    perms = api.fql_query("select #{testing_permissions} from permissions where uid = me()")[0]
+    perms.each_pair do |perm, value|
+      if value == (perm == "read_insights" ? 1 : 0) # live testing depends on insights calls failing
+        puts "failed!\n" # put a new line after the print above
+        raise ArgumentError, "Your access token must have the read_stream, publish_stream, and user_photos permissions, and lack read_insights.  You have: #{perms.inspect}"
+      end
+    end
+    puts "done!"
+  end
+  
+  # Info about the testing environment
+  def self.real_user?
+    !(mock_interface? || @test_user)
+  end
+
+  def self.test_user?
+    !!@test_user_api
+  end
+
+  def self.mock_interface?
+    Koala.http_service == Koala::MockHTTPService
+  end
+
+  # Data for testing
+  def self.user1
+    test_user? ? @live_testing_user["id"] : "koppel"
+  end
+
+  def self.user1_id
+    test_user? ? @live_testing_user["id"] : 2905623
+  end
+
+  def self.user1_name
+    "Alex"
+  end
+
+  def self.user2
+    test_user? ? @live_testing_friend["id"] : "lukeshepard"
+  end
+
+  def self.user2_id
+    test_user? ? @live_testing_friend["id"] : 2901279
+  end
+
+  def self.user2_name
+    "Luke"
+  end
+
+  def self.page
+    "contextoptional"
+  end
+
+end