koala 1.1.0rc2 → 1.1.0

data/spec/support/graph_api_shared_examples.rb

@@ -166,44 +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 "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
+      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")
   
-  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_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
@@ -267,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
@@ -343,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

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

@@ -5,6 +5,9 @@ module Koala
   module MockHTTPService
     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 = '*'

data/spec/support/rest_api_shared_examples.rb

@@ -154,13 +154,13 @@ shared_examples_for "Koala RestAPI" do
           "fql.multiquery", anything, anything
         ).and_return({})
 
-        @api.fql_multiquery stub('query string')
+        @api.fql_multiquery 'query string'
       end
 
       it "should pass a queries argument" do
         queries = stub('query string')
         queries_json = "some JSON"
-        queries.stub(:to_json).and_return(queries_json)
+        MultiJson.stub(:encode).with(queries).and_return(queries_json)
         
         @api.should_receive(:rest_call).with(
           anything,

data/spec/support/setup_mocks_or_live.rb

@@ -4,8 +4,7 @@ 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, read_insights 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|
       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

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: koala
 version: !ruby/object:Gem::Version 
-  prerelease: 5
-  version: 1.1.0rc2
+  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors: 
 - Alex Koppel, Chris Baclig, Rafi Jacoby, Context Optional
@@ -10,11 +10,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-06 00:00:00 +02:00
+date: 2011-07-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: multi_json
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -80,6 +80,7 @@ extra_rdoc_files:
 files: 
 - .autotest
 - .gitignore
+- .travis.yml
 - CHANGELOG
 - Gemfile
 - LICENSE
@@ -88,8 +89,10 @@ files:
 - autotest/discover.rb
 - koala.gemspec
 - lib/koala.rb
+- lib/koala/batch_operation.rb
 - lib/koala/graph_api.rb
-- lib/koala/graph_api_batch.rb
+- lib/koala/graph_batch_api.rb
+- lib/koala/graph_collection.rb
 - lib/koala/http_services.rb
 - lib/koala/http_services/net_http_service.rb
 - lib/koala/http_services/typhoeus_service.rb
@@ -113,10 +116,12 @@ files:
 - spec/cases/test_users_spec.rb
 - spec/cases/uploadable_io_spec.rb
 - spec/fixtures/beach.jpg
+- spec/fixtures/cat.m4v
 - spec/fixtures/facebook_data.yml
 - spec/fixtures/mock_facebook_responses.yml
 - spec/spec_helper.rb
 - spec/support/graph_api_shared_examples.rb
+- spec/support/json_testing_fix.rb
 - spec/support/live_testing_data_helper.rb
 - spec/support/mock_http_service.rb
 - spec/support/rest_api_shared_examples.rb
@@ -139,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4094332028190876979
+      hash: -702788258280667645
       segments: 
       - 0
       version: "0"
@@ -171,10 +176,12 @@ test_files:
 - spec/cases/test_users_spec.rb
 - spec/cases/uploadable_io_spec.rb
 - spec/fixtures/beach.jpg
+- spec/fixtures/cat.m4v
 - spec/fixtures/facebook_data.yml
 - spec/fixtures/mock_facebook_responses.yml
 - spec/spec_helper.rb
 - spec/support/graph_api_shared_examples.rb
+- spec/support/json_testing_fix.rb
 - spec/support/live_testing_data_helper.rb
 - spec/support/mock_http_service.rb
 - spec/support/rest_api_shared_examples.rb

data/lib/koala/graph_api_batch.rb

@@ -1,151 +0,0 @@
-module Koala
-  module Facebook
-    class BatchOperation
-      attr_reader :access_token, :http_options, :post_processing, :files
-       
-      def initialize(options = {})
-        @args = (options[:args] || {}).dup # because we modify it below
-        @access_token = options[:access_token]
-        @http_options = (options[:http_options] || {}).dup # dup because we modify it below
-        @batch_args = @http_options.delete(:batch_args) || {}
-        @url = options[:url]
-        @method = options[:method].to_sym
-        @post_processing = options[:post_processing]
-        
-        process_binary_args
-        
-        raise Koala::KoalaError, "Batch operations require an access token, none provided." unless @access_token
-      end
-      
-      def to_batch_params(main_access_token)
-        # set up the arguments
-        args_string = Koala.http_service.encode_params(@access_token == main_access_token ? @args : @args.merge(:access_token => @access_token))
-        
-        response = {
-          :method => @method, 
-          :relative_url => @url,
-        }
-         
-        # handle batch-level arguments, such as name, depends_on, and attached_files
-        @batch_args[:attached_files] = @files.keys.join(",") if @files
-        response.merge!(@batch_args) if @batch_args
-        
-        # for get and delete, we append args to the URL string
-        # otherwise, they go in the body
-        if args_string.length > 0
-          if args_in_url?
-            response[:relative_url] += (@url =~ /\?/ ? "&" : "?") + args_string if args_string.length > 0
-          else
-            response[:body] = args_string if args_string.length > 0
-          end
-        end
-        
-        response
-      end
-  
-      protected
-      
-      def process_binary_args
-        # collect binary files
-        @args.each_pair do |key, value| 
-          if UploadableIO.binary_content?(value)
-            @files ||= {}
-            # we use object_id to ensure unique file identifiers across multiple batch operations
-            # remove it from the original hash and add it to the file store
-            id = "file#{GraphAPI.batch_calls.length}_#{@files.keys.length}"
-            @files[id] = @args.delete(key).is_a?(UploadableIO) ? value : UploadableIO.new(value)
-          end
-        end          
-      end
-      
-      def args_in_url?
-        @method == :get || @method == :delete 
-      end   
-    end
-    
-    module GraphAPIBatchMethods
-      def self.included(base)
-        base.class_eval do
-          # batch mode flags
-          def self.batch_mode?
-            !!@batch_mode
-          end
-
-          def self.batch_calls
-            raise KoalaError, "GraphAPI.batch_calls accessed when not in batch block!" unless batch_mode?
-            @batch_calls
-          end
-
-          def self.batch(http_options = {}, &block)
-            @batch_mode = true
-            @batch_http_options = http_options
-            @batch_calls = []
-            yield
-            begin
-              results = batch_api(@batch_calls)
-            ensure
-              @batch_mode = false
-            end
-            results
-          end
-
-          def self.batch_api(batch_calls)
-            return [] unless batch_calls.length > 0
-            # Facebook requires a top-level access token
-
-            # Get the access token for the user and start building a hash to store params
-            # Turn the call args collected into what facebook expects
-            args = {}
-            access_token = args["access_token"] = batch_calls.first.access_token
-            args['batch'] = batch_calls.map { |batch_op| 
-              args.merge!(batch_op.files) if batch_op.files
-              batch_op.to_batch_params(access_token)
-            }.to_json
-            
-            # Make the POST request for the batch call
-            # batch operations have to go over SSL, but since there's an access token, that secures that
-            result = Koala.make_request('/', args, 'post', @batch_http_options) 
-            # Raise an error if we get a 500
-            raise APIError.new("type" => "HTTP #{result.status.to_s}", "message" => "Response body: #{result.body}") if result.status >= 500
-
-            response = JSON.parse(result.body.to_s)
-            # raise an error if we get a Batch API error message
-            raise APIError.new("type" => "Error #{response["error"]}", "message" => response["error_description"]) if response.is_a?(Hash) && response["error"]
-
-            # otherwise, map the results with post-processing included            
-            index = 0 # keep compat with ruby 1.8 - no with_index for map
-            response.map do |call_result|
-              # Get the options hash
-              batch_op = batch_calls[index]
-              index += 1
-
-              if call_result
-                # (see note in regular api method about JSON parsing)
-                body = JSON.parse("[#{call_result['body'].to_s}]")[0]
-                unless call_result["code"].to_i >= 500 || error = GraphAPI.check_response(body)
-                  # Get the HTTP component they want
-                  data = case batch_op.http_options[:http_component] 
-                  when :status
-                    call_result["code"].to_i
-                  when :headers
-                    # facebook returns the headers as an array of k/v pairs, but we want a regular hash
-                    call_result['headers'].inject({}) { |headers, h| headers[h['name']] = h['value']; headers}
-                  else
-                    body
-                  end
-                
-                  # process it if we are given a block to process with
-                  batch_op.post_processing ? batch_op.post_processing.call(data) : data
-                else
-                  error || APIError.new({"type" => "HTTP #{call_result["code"].to_s}", "message" => "Response body: #{body}"})
-                end
-              else
-                nil
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end