koala 1.0.0 → 1.2.0

data/spec/support/graph_api_shared_examples.rb

@@ -16,17 +16,36 @@ 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)
-
       @api.graph_call(*args)
     end
 
     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
+    
+    it "passes the results through GraphCollection.evaluate" do
+      result = {}
+      @api.stub(:api).and_return(result)
+      Koala::Facebook::GraphCollection.should_receive(:evaluate).with(result, @api)
+      @api.graph_call("/me")
+    end
+    
+    it "returns the results of GraphCollection.evaluate" do
+      expected = {}
+      @api.stub(:api).and_return([])
+      Koala::Facebook::GraphCollection.should_receive(:evaluate).and_return(expected)
+      @api.graph_call("/me").should == expected
     end
+    
+    it "returns the post_processing block's results if one is supplied" do
+      other_result = [:a, 2, :three]
+      block = Proc.new {|r| other_result}
+      @api.stub(:api).and_return({})
+      @api.graph_call("/me", {}, "get", {}, &block).should == other_result
+    end 
   end
 
   # SEARCH
@@ -40,20 +59,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 +90,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 +125,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 +137,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 +185,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 +313,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 +339,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
@@ -268,23 +368,17 @@ end
 
 # GraphCollection
 shared_examples_for "Koala GraphAPI with GraphCollection" do
-
-  it "should create an array-like object" do
-    call = @api.graph_call("contextoptional/photos")
-    Koala::Facebook::GraphCollection.new(call, @api).should be_an(Array)
-  end
-
   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
@@ -299,74 +393,14 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
     end
 
     it "should get a GraphCollection when paging through results" do
-      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}])
+      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])
       @results.should be_a(Koala::Facebook::GraphCollection)
     end
 
     it "should return nil if the page call fails with nil" do
       # this happens sometimes
       @api.should_receive(:graph_call).and_return(nil)
-      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}]).should be_nil
-    end
-
-    # GraphCollection attributes
-    describe "the GraphCollection" do
-      before(:each) do
-        @result = @api.get_connections("contextoptional", "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)
-      end
-
-      describe "when getting a whole page" do
-        before(:each) do
-          @second_page = stub("page of Fb graph results")
-          @base = stub("base")
-          @args = stub("args")
-          @page_of_results = stub("page of results")
-        end
-
-        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)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@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)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-
-          @result.next_page.should == @page_of_results
-        end
-
-        it "should return nil it there are no other pages" do
-          %w{next previous}.each do |this|
-            @result.should_receive("#{this}_page_params".to_sym).and_return(nil)
-            @result.send("#{this}_page").should == nil
-          end
-        end
-      end
-
-      describe "when parsing page paramters" do
-        before(:each) do
-          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::GraphAPI.new)
-        end
-
-        it "should return the base as the first array entry" do
-          base = "url_path"
-          @graph_collection.parse_page_url("anything.com/#{base}?anything").first.should == base
-        end
-
-        it "should return the arguments as a hash as the last array entry" do
-          args_hash = {"one" => "val_one", "two" => "val_two"}
-          @graph_collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
-        end
-      end
+      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}]).should be_nil
     end
   end
 end
@@ -385,12 +419,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 +432,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 +452,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,187 @@
+# 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, :search_time
+  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
+      
+      Koala.http_service.http_options[:beta] = true if ENV["beta"] || ENV["BETA"]
+
+      # 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"]
+    
+    # fix the search time so it can be used in the mock responses
+    self.search_time = data["search_time"] || (Time.now - 3600).to_s
+  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)
+
+    RSpec.configure do |config|
+      config.before :all do
+        # before each test module, create two test users with specific names and befriend them
+        KoalaTest.create_test_users
+      end
+      
+      config.after :all do
+        # after each test module, delete the test users to avoid cluttering up the application
+        KoalaTest.destroy_test_users
+      end
+    end
+
+    puts "done."
+  end
+
+  def self.create_test_users
+    @live_testing_user = @test_user_api.create(true, KoalaTest.testing_permissions, :name => KoalaTest.user1_name)
+    @live_testing_friend = @test_user_api.create(true, KoalaTest.testing_permissions, :name => KoalaTest.user2_name)
+    @test_user_api.befriend(@live_testing_user, @live_testing_friend)
+    self.oauth_token = @live_testing_user["access_token"]
+  end
+  
+  def self.destroy_test_users
+    [@live_testing_user, @live_testing_friend].each do |u|
+      puts "Unable to delete test user #{u.inspect}" if u && !(@test_user_api.delete(u) rescue false)
+    end
+  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