koala 1.0.0 → 1.1.0

data/spec/support/graph_api_shared_examples.rb

@@ -51,9 +51,19 @@ shared_examples_for "Koala GraphAPI" do
     (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.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.should have(2).items
   end
 
   it "should be able to access a user's picture" do
@@ -69,6 +79,16 @@ shared_examples_for "Koala GraphAPI" do
     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,7 +106,6 @@ 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")
     # updated_time should be a pretty fixed test case
@@ -147,36 +166,87 @@ 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
+  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"))
   
-  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
+      result = @api.put_picture(file, content_type)
+      @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.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
   end
+  
+  describe ".put_video" do
+    before :each do
+      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")      
+      @content_type = "video/mpeg4"      
+    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
+    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
     
-    get_result = @api.get_object(@temporary_object_id)
-    get_result["name"].should == expected_message
+    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 "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.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
@@ -240,6 +310,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
@@ -316,8 +387,8 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
       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 +401,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
@@ -421,4 +492,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,18 @@
+# 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
+  
+  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
+  
+  alias_method :encode_original, :encode
+  alias_method :encode, :encode_with_ordering
+end

data/spec/support/mock_http_service.rb

@@ -3,11 +3,15 @@ require 'yaml'
 
 module Koala
   module MockHTTPService
-    # Mocks all HTTP requests for with koala_spec_with_mocks.rb
-    IS_MOCK = true # this lets our tests figure out if we want to stub methods
+    include Koala::HTTPService
+
+    # fix our specs to use ok_json, so we always get the same results from to_json
+    MultiJson.engine = :ok_json
 
+    # Mocks all HTTP requests for with koala_spec_with_mocks.rb
     # Mocked values to be included in TEST_DATA used in specs
     ACCESS_TOKEN = '*'
+    APP_ACCESS_TOKEN = "**"
     OAUTH_CODE = 'OAUTHCODE'
 
     # Loads testing data
@@ -18,7 +22,7 @@ module Koala
     # Useful in mock_facebook_responses.yml
     OAUTH_DATA = TEST_DATA['oauth_test_data']
     OAUTH_DATA.merge!({
-      'app_access_token' => Koala::MockHTTPService::ACCESS_TOKEN,
+      'app_access_token' => APP_ACCESS_TOKEN,
       'session_key' => "session_key",
       'multiple_session_keys' => ["session_key", "session_key_2"]
     })
@@ -30,66 +34,63 @@ module Koala
     mock_response_file_path = File.join(File.dirname(__FILE__), '..', 'fixtures', 'mock_facebook_responses.yml')
     RESPONSES = YAML.load(ERB.new(IO.read(mock_response_file_path)).result(binding))
 
-    def self.included(base)
-      base.class_eval do
-
-        include Koala::HTTPService
-
-        def self.make_request(path, args, verb, options = {})
-          path = 'root' if path == '' || path == '/'
-          verb ||= 'get'
-          server = options[:rest_api] ? 'rest_api' : 'graph_api'
-          with_token = args.delete('access_token') == ACCESS_TOKEN ? 'with_token' : 'no_token'
-
-          # Assume format is always JSON
-          args.delete('format')
+    def self.make_request(path, args, verb, options = {})
+      path = 'root' if path == '' || path == '/'
+      verb ||= 'get'
+      server = options[:rest_api] ? 'rest_api' : 'graph_api'
+      token = args.delete('access_token') 
+      with_token = (token == ACCESS_TOKEN || token == APP_ACCESS_TOKEN) ? 'with_token' : 'no_token'
 
-          # Create a hash key for the arguments
-          args = create_params_key(args)
+      # Assume format is always JSON
+      args.delete('format')
 
-          begin
-            response = RESPONSES[server][path][args][verb][with_token]
+      # Create a hash key for the arguments
+      args = create_params_key(args)
 
-            # Raises an error of with_token/no_token key is missing
-            raise NoMethodError unless response
-
-            # create response class object
-            response_object = if response.is_a? String
-                Koala::Response.new(200, response, {})
-              else
-                Koala::Response.new(response["code"] || 200, response["body"] || "", response["headers"] || {})
-              end
-
-          rescue NoMethodError
-            # Raises an error message with the place in the data YML
-            # to place a mock as well as a URL to request from
-            # Facebook's servers for the actual data
-            # (Don't forget to replace ACCESS_TOKEN with a real access token)
-            data_trace = [server, path, args, verb, with_token] * ': '
-
-            args = args == 'no_args' ? '' : "#{args}&"
-            args += 'format=json'
-            args += "&access_token=#{ACCESS_TOKEN}" if with_token
-
-            raise "Missing a mock response for #{data_trace}\nAPI PATH: #{[path, args].join('?')}"
-          end
+      begin
+        response = RESPONSES[server][path][args][verb][with_token]
 
-          response_object
-        end
+        # Raises an error of with_token/no_token key is missing
+        raise NoMethodError unless response
 
-        protected
-        def self.create_params_key(params_hash)
-          if params_hash.empty?
-            'no_args'
+        # create response class object
+        response_object = if response.is_a? String
+            Koala::Response.new(200, response, {})
           else
-            params_hash.sort{ |a,b| a[0].to_s <=> b[0].to_s}.map do |arr|
-              arr[1] = '[FILE]' if arr[1].kind_of?(Koala::UploadableIO)
-              arr.join('=')
-            end.join('&')
+            Koala::Response.new(response["code"] || 200, response["body"] || "", response["headers"] || {})
           end
-        end
 
-      end # class_eval
-    end # included
+      rescue NoMethodError
+        # Raises an error message with the place in the data YML
+        # to place a mock as well as a URL to request from
+        # Facebook's servers for the actual data
+        # (Don't forget to replace ACCESS_TOKEN with a real access token)
+        data_trace = [server, path, args, verb, with_token] * ': '
+
+        args = args == 'no_args' ? '' : "#{args}&"
+        args += 'format=json'
+        args += "&access_token=#{ACCESS_TOKEN}" if with_token
+
+        raise "Missing a mock response for #{data_trace}\nAPI PATH: #{[path, args].join('?')}"
+      end
+
+      response_object
+    end
+
+    def self.mock?
+      true
+    end
+
+    protected
+    def self.create_params_key(params_hash)
+      if params_hash.empty?
+        'no_args'
+      else
+        params_hash.sort{ |a,b| a[0].to_s <=> b[0].to_s}.map do |arr|
+          arr[1] = '[FILE]' if arr[1].kind_of?(Koala::UploadableIO)
+          arr.join('=')
+        end.join('&')
+      end
+    end
   end
 end

data/spec/support/rest_api_shared_examples.rb

@@ -87,6 +87,29 @@ shared_examples_for "Koala RestAPI" do
 
       @api.rest_call('anything', {}, options)
     end
+    
+    it "uses get by default" do
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        "get",
+        anything
+      )
+
+      @api.rest_call('anything')
+    end
+    
+    it "allows you to specify other http methods as the last argument" do
+      method = 'bar'
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        method,
+        anything
+      )
+
+      @api.rest_call('anything', {}, {}, method)
+    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_code" => "An error occurred!"}, {}))
@@ -96,8 +119,7 @@ shared_examples_for "Koala RestAPI" do
     describe "when making a FQL request" do
       it "should call fql.query method" do
         @api.should_receive(:rest_call).with(
-          "fql.query",
-          anything
+          "fql.query", anything, anything
         ).and_return(Koala::Response.new(200, "2", {}))
 
         @api.fql_query stub('query string')
@@ -107,17 +129,78 @@ shared_examples_for "Koala RestAPI" do
         query = stub('query string')
 
         @api.should_receive(:rest_call).with(
-          anything,
-          hash_including("query" => query)
+          anything, hash_including(:query => query), anything
         )
 
         @api.fql_query(query)
       end
+      
+      it "should pass on any other arguments provided" do
+        args = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
+        @api.fql_query("a query", args)
+      end
+      
+      it "should pass on any http options provided" do
+        opts = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
+        @api.fql_query("a query", {}, opts)
+      end
+    end
+    
+    describe "when making a FQL-multiquery request" do
+      it "should call fql.multiquery method" do
+        @api.should_receive(:rest_call).with(
+          "fql.multiquery", anything, anything
+        ).and_return({})
+
+        @api.fql_multiquery 'query string'
+      end
+
+      it "should pass a queries argument" do
+        queries = stub('query string')
+        queries_json = "some JSON"
+        MultiJson.stub(:encode).with(queries).and_return(queries_json)
+        
+        @api.should_receive(:rest_call).with(
+          anything,
+          hash_including(:queries => queries_json),
+          anything
+        )
+
+        @api.fql_multiquery(queries)
+      end
+      
+      it "simplifies the response format" do
+        raw_results = [
+          {"name" => "query1", "fql_result_set" => [1, 2, 3]},
+          {"name" => "query2", "fql_result_set" => [:a, :b, :c]}
+        ]
+        expected_results = {
+          "query1" => [1, 2, 3],
+          "query2" => [:a, :b, :c]
+        }
+        
+        @api.stub(:rest_call).and_return(raw_results)
+        results = @api.fql_multiquery({:query => true})
+        results.should == expected_results
+      end
+      
+      it "should pass on any other arguments provided" do
+        args = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
+        @api.fql_multiquery("a query", args)
+      end
+      
+      it "should pass on any http options provided" do
+        opts = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
+        @api.fql_multiquery("a query", {}, opts)
+      end
     end
   end
 end
 
-
 shared_examples_for "Koala RestAPI with an access token" do
   # FQL
   it "should be able to access public information via FQL" do
@@ -126,6 +209,16 @@ shared_examples_for "Koala RestAPI with an access token" do
     result.first['first_name'].should == 'Chris'
   end
 
+  it "should be able to access public information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => 'select first_name from user where uid = 216743',
+      :query2 => 'select first_name from user where uid = 2905623'
+    )
+    result.size.should == 2
+    result["query1"].first['first_name'].should == 'Chris'
+    result["query2"].first['first_name'].should == 'Alex'
+  end
+
   it "should be able to access protected information via FQL" do
     # Tests agains the permissions fql table
 
@@ -138,10 +231,21 @@ shared_examples_for "Koala RestAPI with an access token" do
     result = @api.fql_query("select read_stream from permissions where uid = #{id}")
 
     result.size.should == 1
-    # we assume that you have read_stream permissions, so we can test against that
-    # (should we keep this?)
+    # we've verified that you have read_stream permissions, so we can test against that
     result.first["read_stream"].should == 1
   end
+  
+  
+  it "should be able to access protected information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => "select post_id from stream where source_id = me()", 
+      :query2 => "select fromid from comment where post_id in (select post_id from #query1)", 
+      :query3 => "select uid, name from user where uid in (select fromid from #query2)"
+    )
+    result.size.should == 3 
+    result.keys.should include("query1", "query2", "query3")
+  end
+
 end
 
 
@@ -153,9 +257,29 @@ shared_examples_for "Koala RestAPI without an access token" do
       @result.size.should == 1
       @result.first["first_name"].should == "Chris"
     end
+    
+    it "should be able to access public information via FQL.multiquery" do
+      result = @api.fql_multiquery(
+        :query1 => 'select first_name from user where uid = 216743',
+        :query2 => 'select first_name from user where uid = 2905623'
+      )
+      result.size.should == 2
+      result["query1"].first['first_name'].should == 'Chris'
+      result["query2"].first['first_name'].should == 'Alex'
+    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
+    
+    it "should not be able to access protected information via FQL.multiquery" do
+      lambda { 
+        @api.fql_multiquery(
+          :query1 => "select post_id from stream where source_id = me()", 
+          :query2 => "select fromid from comment where post_id in (select post_id from #query1)", 
+          :query3 => "select uid, name from user where uid in (select fromid from #query2)"
+        ) 
+      }.should raise_error(Koala::Facebook::APIError)
+    end
   end
 end

data/spec/support/setup_mocks_or_live.rb

@@ -4,12 +4,11 @@ module KoalaTest
     print "Validating permissions for live testing..."
     # make sure we have the necessary permissions
     api = Koala::Facebook::GraphAndRestAPI.new(token)
-    uid = api.get_object("me")["id"]
-    perms = api.fql_query("select read_stream, publish_stream, user_photos from permissions where uid = #{uid}")[0]
+    perms = api.fql_query("select read_stream, publish_stream, user_photos, user_videos, read_insights from permissions where uid = me()")[0]
     perms.each_pair do |perm, value|
-      unless value == 1
+      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.  You have: #{perms.inspect}"
+        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!"