koala 1.1.0 → 1.2.0beta1

data/spec/spec_helper.rb

@@ -4,16 +4,40 @@ rescue LoadError
   puts 'Although not required, bundler is recommended for running the tests.'
 end
 
-# load the libraries
+# In Ruby 1.9.2 versions before patchlevel 290, the default Psych
+# parser has an issue with YAML merge keys, which 
+# fixtures/mock_facebook_responses.yml relies heavily on.
+# 
+# Anyone using an earlier version will see missing mock response
+# errors when running the test suite similar to this:
+# 
+# RuntimeError:
+#   Missing a mock response for graph_api: /me/videos: source=[FILE]: post: with_token
+#   API PATH: /me/videos?source=[FILE]&format=json&access_token=*
+# 
+# For now, it seems the best fix is to just downgrade to the old syck YAML parser
+# for these troubled versions.
+#
+# See https://github.com/tenderlove/psych/issues/8 for more details
+YAML::ENGINE.yamler = 'syck' if RUBY_VERSION == '1.9.2' && RUBY_PATCHLEVEL < 290
+
+# load the library
 require 'koala'
 
-# load testing data libraries
-require 'support/live_testing_data_helper'
-require 'support/json_testing_fix' # ensure consistent to_json behavior
+# ensure consistent to_json behavior
+# this must be required first so mock_http_service loads the YAML as expected
+require 'support/ordered_hash' 
+require 'support/json_testing_fix' 
+
+# set up our testing environment
 require 'support/mock_http_service'
+require 'support/koala_test'
+# load testing data and (if needed) create test users or validate real users
+KoalaTest.setup_test_environment!
+
+# load supporting files for our tests
 require 'support/rest_api_shared_examples'
 require 'support/graph_api_shared_examples'
 require 'support/uploadable_io_shared_examples'
-require 'support/setup_mocks_or_live'
 
 BEACH_BALL_PATH = File.join(File.dirname(__FILE__), "fixtures", "beach.jpg")

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,13 +40,13 @@ 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
@@ -55,14 +55,14 @@ shared_examples_for "Koala GraphAPI" do
     results = @api.get_objects([])
     results.should == []
   end
-  
+
   it "should be able to get multiple objects" do
-    results = @api.get_objects(["contextoptional", "naitik"])
+    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,naitik")
+    results = @api.get_objects("contextoptional,#{KoalaTest.user1}")
     results.should have(2).items
   end
 
@@ -71,11 +71,11 @@ 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
 
@@ -107,7 +107,7 @@ 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
@@ -118,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
 
@@ -168,52 +168,63 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
   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"      
+      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 = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
-    it "uses the base HTTP service if the upload is a StringIO or similar" do
-      source = stub("UploadIO")
-      Koala::UploadableIO.stub(:new).and_return(source)
-      source.stub(:requires_base_http_service).and_return(true)
-      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
-      @api.put_picture(StringIO.new)
-    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 = 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 = 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
-  
+
   describe ".put_video" do
     before :each do
-      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")      
-      @content_type = "video/mpeg4"      
+      @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)
@@ -221,26 +232,19 @@ shared_examples_for "Koala GraphAPI with an access token" do
       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 = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
-    it "uses the base HTTP service if the upload is a StringIO or similar" do
-      source = stub("UploadIO")
-      Koala::UploadableIO.stub(:new).and_return(source)
-      source.stub(:requires_base_http_service).and_return(true)
-      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
-      @api.put_video(StringIO.new)
-    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 = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
@@ -290,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)
@@ -348,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
@@ -383,7 +393,7 @@ 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
@@ -425,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
@@ -456,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
@@ -470,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

data/spec/support/json_testing_fix.rb

@@ -1,18 +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 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 1.8.7 fails if we don't assign the ternary result as a local variable 
-    # separate from calling encode_original)
-    new_object = object.is_a?(Hash) ? object.keys.sort.inject({}) {|hash, k| hash[k] = object[k]; hash} : object
-    encode_original(new_object)
-  end
+    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
   
-  alias_method :encode_original, :encode
-  alias_method :encode, :encode_with_ordering
-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