koala 1.4.0 → 1.5.0

data/spec/cases/api_spec.rb

@@ -59,7 +59,7 @@ describe "Koala::Facebook::API" do
     Koala.stub(:make_request).and_return(response)
 
     json_body = mock('JSON body')
-    MultiJson.stub(:decode).and_return([json_body])
+    MultiJson.stub(:load).and_return([json_body])
 
     @service.api('anything').should == json_body
   end
@@ -73,7 +73,7 @@ describe "Koala::Facebook::API" do
 
     @service.api('anything', {}, "get") do |arg|
       yield_test.pass
-      arg.should == MultiJson.decode(body)
+      arg.should == MultiJson.load(body)
     end
   end
 

data/spec/cases/error_spec.rb

@@ -5,24 +5,27 @@ describe Koala::Facebook::APIError do
     Koala::Facebook::APIError.new.should be_a(StandardError)
   end
 
-  it "has an accessor for fb_error_type" do
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type)
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type=)
-  end
-
-  it "has an accessor for raw_response" do
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:raw_response)
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:raw_response=)
+  [:fb_error_type, :fb_error_code, :fb_error_message, :raw_response].each do |accessor|
+    it "has an accessor for #{accessor}" do
+      Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(accessor)
+      Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:"#{accessor}=")
+    end
   end
 
   it "sets raw_response to the provided error details" do
     error_response = {"type" => "foo", "other_details" => "bar"}
     Koala::Facebook::APIError.new(error_response).raw_response.should == error_response
   end
-  
-  it "sets fb_error_type to details['type']" do
-    type = "foo"
-    Koala::Facebook::APIError.new("type" => type).fb_error_type.should == type
+
+  {
+    :fb_error_type => 'type',
+    :fb_error_message => 'message',
+    :fb_error_code => 'code'
+  }.each_pair do |accessor, key|
+    it "sets #{accessor} to details['#{key}']" do
+      value = "foo"
+      Koala::Facebook::APIError.new(key => value).send(accessor).should == value
+    end
   end
 
   it "sets the error message details['type']: details['message']" do

data/spec/cases/graph_api_batch_spec.rb

@@ -304,7 +304,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           Koala::Facebook::GraphBatchAPI::BatchOperation.stub(:new).and_return(op)
 
           # two requests should generate two batch operations
-          expected = MultiJson.encode([op.to_batch_params(access_token), op.to_batch_params(access_token)])
+          expected = MultiJson.dump([op.to_batch_params(access_token), op.to_batch_params(access_token)])
           Koala.should_receive(:make_request).with(anything, hash_including("batch" => expected), anything, anything).and_return(@fake_response)
           Koala::Facebook::API.new(access_token).batch do |batch_api|
             batch_api.get_object('me')
@@ -381,6 +381,13 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             }.to raise_exception(Koala::Facebook::APIError)
           end
 
+          it "raises an APIError if the body is empty" do
+            Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, "", {}))
+            expect {
+              Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+            }.to raise_exception(Koala::Facebook::APIError)
+          end
+
           context "with the old style" do
             before :each do
               Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":190,"error_description":"Error validating access token."}', {}))

data/spec/cases/graph_collection_spec.rb

@@ -13,11 +13,11 @@ describe Koala::Facebook::GraphCollection do
   it "subclasses Array" do
     Koala::Facebook::GraphCollection.ancestors.should include(Array)
   end
-  
+
   it "creates an array-like object" do
     Koala::Facebook::GraphCollection.new(@result, @api).should be_an(Array)
   end
-  
+
   it "contains the result data" do
     @result["data"].each_with_index {|r, i| @collection[i].should == r}
   end
@@ -26,19 +26,19 @@ describe Koala::Facebook::GraphCollection do
     @collection.methods.map(&:to_sym).should include(:paging)
     @collection.methods.map(&:to_sym).should_not include(:paging=)
   end
-  
+
   it "sets paging to results['paging']" do
     @collection.paging.should == @result["paging"]
   end
-  
+
   it "sets raw_response to the original results" do
     @collection.raw_response.should == @result
   end
-  
+
   it "sets the API to the provided API" do
     @collection.api.should == @api
   end
-    
+
   describe "when getting a whole page" do
     before(:each) do
       @second_page = {
@@ -87,16 +87,22 @@ describe Koala::Facebook::GraphCollection do
         @collection.parse_page_url(stub("url")).should == parsed_content
       end
     end
-    
-    describe ".parse_page_url" do    
+
+    describe ".parse_page_url" do
       it "should return the base as the first array entry" do
         base = "url_path"
-        Koala::Facebook::GraphCollection.parse_page_url("anything.com/#{base}?anything").first.should == base
+        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.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"}
-        Koala::Facebook::GraphCollection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+      end
+
+      it "works with non-.com addresses" do
+        base = "url_path"
+        args_hash = {"one" => "val_one", "two" => "val_two"}
+        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").should == [base, args_hash]
       end
     end
   end
@@ -106,22 +112,22 @@ describe Koala::Facebook::GraphCollection do
       result = []
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-    
+
     it "returns the original result if it's provided a nil result" do
       result = nil
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-    
+
     it "returns the original result if the result doesn't have a data key" do
       result = {"paging" => {}}
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-    
+
     it "returns the original result if the result's data key isn't an array" do
       result = {"data" => {}, "paging" => {}}
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-        
+
     it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
       result = {"data" => [], "paging" => {}}
       expected = :foo

data/spec/cases/http_service_spec.rb

@@ -10,7 +10,7 @@ describe "Koala::HTTPService" do
     Koala::HTTPService.should respond_to(:http_options)
     Koala::HTTPService.should respond_to(:http_options=)
   end
-  
+
   it "sets http_options to {} by default" do
     Koala::HTTPService.http_options.should == {}
   end
@@ -99,7 +99,7 @@ describe "Koala::HTTPService" do
       val = 'json_value'
       not_a_string = 'not_a_string'
       not_a_string.stub(:is_a?).and_return(false)
-      MultiJson.should_receive(:encode).with(not_a_string).and_return(val)
+      MultiJson.should_receive(:dump).with(not_a_string).and_return(val)
 
       string = "hi"
 
@@ -123,10 +123,10 @@ describe "Koala::HTTPService" do
         val.should == CGI.escape(args[key])
       end
     end
-    
+
     it "encodes parameters in alphabetical order" do
       args = {:b => '2', 'a' => '1'}
-      
+
       result = Koala::HTTPService.encode_params(args)
       result.split('&').map{|key_val| key_val.split('=')[0]}.should == ['a', 'b']
     end
@@ -184,33 +184,44 @@ describe "Koala::HTTPService" do
         Faraday.should_receive(:new).with(anything, hash_including(http_options.merge(options))).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get", options)
       end
-      
+
       it "forces use_ssl to true if an access token is present" do
         options = {:use_ssl => false}
         Koala::HTTPService.stub(:http_options).and_return(:use_ssl => false)
-        Faraday.should_receive(:new).with(anything, hash_including(:use_ssl => true)).and_return(@mock_connection)
+        Faraday.should_receive(:new).with(anything, hash_including(:use_ssl => true, :ssl => {:verify => true})).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
       end
-      
+
+      it "defaults verify to true if use_ssl is true" do
+        Faraday.should_receive(:new).with(anything, hash_including(:ssl => {:verify => true})).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get")
+      end
+
+      it "allows you to set other verify modes if you really want" do
+        options = {:ssl => {:verify => :foo}}
+        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
+      end
+
       it "calls server with the composite options" do
         options = {:a => 2, :c => "3"}
         http_options = {:a => :a}
         Koala::HTTPService.stub(:http_options).and_return(http_options)
         Koala::HTTPService.should_receive(:server).with(hash_including(http_options.merge(options))).and_return("foo")
-        Koala::HTTPService.make_request("anything", {}, "get", options)        
+        Koala::HTTPService.make_request("anything", {}, "get", options)
       end
 
       it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
-        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)        
+        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)
         Faraday.should_receive(:new).with(anything, anything, &Koala::HTTPService::DEFAULT_MIDDLEWARE).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get")        
+        Koala::HTTPService.make_request("anything", {}, "get")
       end
-      
+
       it "uses the defined HTTPService.faraday_middleware block if defined" do
         block = Proc.new { }
         Koala::HTTPService.should_receive(:faraday_middleware).and_return(block)
         Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get")        
+        Koala::HTTPService.make_request("anything", {}, "get")
       end
     end
 
@@ -244,6 +255,21 @@ describe "Koala::HTTPService" do
         @mock_connection.should_receive(:get).with(anything, {}).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", args, "get")
       end
+
+      it "logs verb, url and params to debug" do
+        args = {"a" => :b, "c" => 3}
+        log_message_stem = "GET: anything params: "
+        Koala::Utils.logger.should_receive(:debug) do |log_message|
+          # unordered hashes are a bane
+          # Ruby in 1.8 modes tends to return different hash orderings,
+          # which makes checking the content of the stringified hash hard
+          # it's enough just to ensure that there's hash content in the string, I think
+          log_message.should include(log_message_stem)
+          log_message.match(/\{.*\}/).should_not be_nil
+        end
+
+        Koala::HTTPService.make_request("anything", args, "get")
+      end
     end
 
     describe "for POSTs" do
@@ -262,6 +288,20 @@ describe "Koala::HTTPService" do
         @mock_connection.should_receive(:post).with(anything, hash_including("source" => upload_io)).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", {:source => u}, "post")
       end
+
+      it "logs verb, url and params to debug" do
+        args = {"a" => :b, "c" => 3}
+        log_message_stem = "POST: anything params: "
+        Koala::Utils.logger.should_receive(:debug) do |log_message|
+          # unordered hashes are a bane
+          # Ruby in 1.8 modes tends to return different hash orderings,
+          # which makes checking the content of the stringified hash hard
+          # it's enough just to ensure that there's hash content in the string, I think
+          log_message.should include(log_message_stem)
+          log_message.match(/\{.*\}/).should_not be_nil
+        end
+        Koala::HTTPService.make_request("anything", args, "post")
+      end
     end
   end
 
@@ -274,11 +314,11 @@ describe "Koala::HTTPService" do
     after :each do
       Koala.http_service = @service
     end
-    
+
     {
       :timeout => :timeout,
       :always_use_ssl => :use_ssl,
-      :proxy => :proxy 
+      :proxy => :proxy
     }.each_pair do |deprecated_method, parameter|
       describe ".#{deprecated_method}" do
         context "read" do
@@ -287,13 +327,13 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.http_options[parameter] = value
             Koala::HTTPService.send(deprecated_method).should == value
           end
-      
+
           it "generates a deprecation warning" do
             Koala::Utils.should_receive(:deprecate)
             Koala::HTTPService.send(deprecated_method)
           end
         end
-      
+
         context "write" do
           it "writes to http_options[:#{parameter}]" do
             Koala::HTTPService.http_options[parameter] = nil
@@ -301,7 +341,7 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.send(:"#{deprecated_method}=", value)
             Koala::HTTPService.http_options[parameter].should == value
           end
-      
+
           it "generates a deprecation warning" do
             Koala::Utils.should_receive(:deprecate)
             Koala::HTTPService.send(:"#{deprecated_method}=", 2)
@@ -309,7 +349,7 @@ describe "Koala::HTTPService" do
         end
       end
     end
-    
+
     # ssl options
     [:ca_path, :ca_file, :verify_mode].each do |deprecated_method|
       describe ".#{deprecated_method}" do
@@ -319,7 +359,7 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.http_options[:ssl] = {deprecated_method => value}
             Koala::HTTPService.send(deprecated_method).should == value
           end
-      
+
           it "returns nil if http_options[:ssl] is not defined" do
             Koala::HTTPService.send(deprecated_method).should be_nil
           end
@@ -329,8 +369,8 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.send(deprecated_method)
           end
         end
-      
-        context "write" do      
+
+        context "write" do
           it "defines http_options[:ssl] if not defined" do
             Koala::HTTPService.http_options[:ssl] = nil
             value = "foo"
@@ -344,14 +384,14 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.http_options[:ssl].should
             Koala::HTTPService.http_options[:ssl][deprecated_method].should == value
           end
-          
+
           it "does not redefine http_options[:ssl] if already defined" do
             hash = {:a => 2}
             Koala::HTTPService.http_options[:ssl] = hash
             Koala::HTTPService.send(:"#{deprecated_method}=", 3)
             Koala::HTTPService.http_options[:ssl].should include(hash)
           end
-                
+
           it "generates a deprecation warning" do
             Koala::Utils.should_receive(:deprecate)
             Koala::HTTPService.send(:"#{deprecated_method}=", 2)
@@ -359,7 +399,7 @@ describe "Koala::HTTPService" do
         end
       end
     end
-    
+
     describe "per-request options" do
       before :each do
         # Setup stubs for make_request to execute without exceptions
@@ -372,18 +412,18 @@ describe "Koala::HTTPService" do
         @mock_connection.stub(:post).and_return(@mock_http_response)
         Faraday.stub(:new).and_return(@mock_connection)
       end
-      
+
       describe ":typhoeus_options" do
         it "merges any typhoeus_options into options" do
           typhoeus_options = {:a => 2}
           Faraday.should_receive(:new).with(anything, hash_including(typhoeus_options)).and_return(@mock_connection)
-          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)          
+          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
         end
-        
+
         it "deletes the typhoeus_options key" do
           typhoeus_options = {:a => 2}
           Faraday.should_receive(:new).with(anything, hash_not_including(:typhoeus_options => typhoeus_options)).and_return(@mock_connection)
-          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)          
+          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
         end
       end
 
@@ -400,7 +440,7 @@ describe "Koala::HTTPService" do
           Koala::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
         end
       end
-      
+
       describe ":ca_file" do
         it "sets any ca_file into options[:ssl]" do
           ca_file = :foo
@@ -414,7 +454,7 @@ describe "Koala::HTTPService" do
           Koala::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
         end
       end
-      
+
       describe ":verify_mode" do
         it "sets any verify_mode into options[:ssl]" do
           verify_mode = :foo

data/spec/cases/oauth_spec.rb

@@ -98,6 +98,12 @@ describe "Koala::Facebook::OAuth" do
             @oauth.stub(:parse_signed_request).and_return({})
             @oauth.get_user_info_from_cookies(@cookie).should be_nil
           end
+
+          it "logs a warning" do
+            @oauth.stub(:parse_signed_request).and_return({})
+            Koala::Utils.logger.should_receive(:warn)
+            @oauth.get_user_info_from_cookies(@cookie)
+          end
         end
 
         context "if the code is present" do
@@ -655,7 +661,7 @@ describe "Koala::Facebook::OAuth" do
     # the signed request code is ported directly from Facebook
     # so we only need to test at a high level that it works
     it "throws an error if the algorithm is unsupported" do
-      MultiJson.stub(:decode).and_return("algorithm" => "my fun algorithm")
+      MultiJson.stub(:load).and_return("algorithm" => "my fun algorithm")
       lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
     end
 

data/spec/cases/utils_spec.rb

@@ -31,4 +31,25 @@ describe Koala::Utils do
       Koala::Utils.deprecate(message)
     end
   end
+  
+  describe ".logger" do
+    it "has an accessor for logger" do
+      Koala::Utils.methods.map(&:to_sym).should include(:logger)
+      Koala::Utils.methods.map(&:to_sym).should include(:logger=)
+    end
+    
+    it "defaults to the standard ruby logger with level set to ERROR" do |variable|
+      Koala::Utils.logger.should be_kind_of(Logger)
+      Koala::Utils.logger.level.should == Logger::ERROR
+    end
+    
+    logger_methods = [:debug, :info, :warn, :error, :fatal]
+    
+    logger_methods.each do |logger_method|
+      it "should delegate #{logger_method} to the attached logger" do
+        Koala::Utils.logger.should_receive(logger_method)
+        Koala::Utils.send(logger_method, "Test #{logger_method} message")
+      end
+    end
+  end
 end

data/spec/fixtures/mock_facebook_responses.yml

@@ -42,11 +42,11 @@ graph_api:
 
   # OAuth error response
   oauth_error: &oauth_error
-    no_token: '{"error": {"type": "OAuthException", "message": "Error validating verification code."}}'
+    no_token: '{"error": {"code"=>2500, "type": "OAuthException", "message": "Error validating verification code."}}'
 
   # Subscription error response
   verification_error: &verification_error
-    with_token: '{"error": {"type": "OAuthException", "message": "Error validating verification code."}}'
+    with_token: '{"error": {"code"=>2500, "type": "OAuthException", "message": "Error validating verification code."}}'
 
   test_user_uninstalled: &test_user_uninstalled
     post:
@@ -68,53 +68,53 @@ graph_api:
         no_token: '{"contextoptional":"{}","koppel":"{}"}'
 
     # Ruby 1.8.7 and 1.9.2 generate JSON with different key ordering, hence we have to dynamically generate it here
-    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "koppel"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "koppel"}]) %>:
       post:
         with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"id\":\"456\"}"}]'
-    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/picture"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "get", "relative_url" => "me/picture"}]) %>:
       post:
         with_token: '[{"headers":[{"name":"Location","value":"http://google.com"}]}]'
-    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "me/friends"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "me/friends"}]) %>:
       post:
         with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[],\"paging\":{}}"}]'
-    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me"}, {"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
+    batch=<%= MultiJson.dump([{"method"=>"get", "relative_url"=>"me"}, {"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
       post:
         with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[],\"paging\":{}}"}]'
-    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"2/invalidconnection"}, {"method"=>"get", "relative_url"=>"koppel?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
+    batch=<%= MultiJson.dump([{"method"=>"get", "relative_url"=>"2/invalidconnection"}, {"method"=>"get", "relative_url"=>"koppel?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},{"body":"{\"id\":\"123\"}"}]'
-    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"FEED_ITEM_BATCH/likes"}, {"method"=>"delete", "relative_url"=> "FEED_ITEM_BATCH"}]) %>:
+    batch=<%= MultiJson.dump([{"method"=>"post", "relative_url"=>"FEED_ITEM_BATCH/likes"}, {"method"=>"delete", "relative_url"=> "FEED_ITEM_BATCH"}]) %>:
       post:
         with_token: '[{"body": "{\"id\": \"MOCK_LIKE\"}"},{"body":true}]'
-    batch=<%= MultiJson.encode([{"method" => "post", "relative_url" => "method/fql.query", "body" => "query=select+first_name+from+user+where+uid%3D2905623"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "post", "relative_url" => "method/fql.query", "body" => "query=select+first_name+from+user+where+uid%3D2905623"}]) %>:
       post:
         with_token: '[{"body":"[{\"first_name\":\"Alex\"}]"}]'
 
     # dependencies
-    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me", "name" => "getme"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getme"}]) %>:
+    batch=<%= MultiJson.dump([{"method"=>"get", "relative_url"=>"me", "name" => "getme"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getme"}]) %>:
       post:
         with_token: '[null,{"body":"{\"id\":\"123\"}"}]'
-    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"2/invalidconnection", "name" => "getdata"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getdata"}]) %>:
+    batch=<%= MultiJson.dump([{"method"=>"get", "relative_url"=>"2/invalidconnection", "name" => "getdata"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getdata"}]) %>:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
-    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
       post:
         with_token: '[null,{"body":"{}"}]'
-    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends", "omit_response_on_success" => false}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends", "omit_response_on_success" => false}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
       post:
         with_token: '[{"body":"{\"data\":[],\"paging\":{}}"},{"body":"{}"}]'
-    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=i-dont-exist:$.data.*.id}"}"}]) %>:
+    batch=<%= MultiJson.dump([{"method" => "get", "relative_url" => "me/friends?limit=5"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=i-dont-exist:$.data.*.id}"}"}]) %>:
       post:
         with_token: '{"error":190,"error_description":"Error validating access token."}'
 
     # attached files tests
-    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
+    batch=<%= MultiJson.dump([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
-    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
+    batch=<%= MultiJson.dump([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
       post:
         with_token: '[{"body":"{\"id\": \"MOCK_PHOTO\"}"}]'
-    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}, {"method"=>"post", "relative_url"=>"koppel/photos", "attached_files" => "op2_file0"}]) %>&op1_file0=[FILE]&op2_file0=[FILE]:
+    batch=<%= MultiJson.dump([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}, {"method"=>"post", "relative_url"=>"koppel/photos", "attached_files" => "op2_file0"}]) %>&op1_file0=[FILE]&op2_file0=[FILE]:
       post:
         with_token: '[{"body":"{\"id\": \"MOCK_PHOTO\"}"}, {"body":"{\"id\": \"MOCK_PHOTO\"}"}]'
 
@@ -273,11 +273,11 @@ graph_api:
       get:
         <<: *token_required
         with_token: '[{"read_stream":1}]'
-    'q=<%= MultiJson.encode({"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)"}) %>':
+    'q=<%= MultiJson.dump({"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)"}) %>':
       get:
         <<: *token_required
         with_token: '[{"name":"query1", "fql_result_set":[]},{"name":"query2", "fql_result_set":[]},{"name":"query3", "fql_result_set":[]}]'
-    'q=<%= MultiJson.encode({"query1" => "select uid, first_name from user where uid = 2901279", "query2" => "select uid, first_name from user where uid = 2905623"}) %>':
+    'q=<%= MultiJson.dump({"query1" => "select uid, first_name from user where uid = 2901279", "query2" => "select uid, first_name from user where uid = 2905623"}) %>':
       get:
         with_token: '[{"name":"query1", "fql_result_set":[{"uid":2901279,"first_name":"Luke"}]},{"name":"query2", "fql_result_set":[{"uid":"2905623","first_name":"Alex"}]}]'
         no_token: '[{"name":"query1", "fql_result_set":[{"uid":2901279,"first_name":"Luke"}]},{"name":"query2", "fql_result_set":[{"uid":"2905623","first_name":"Alex"}]}]'
@@ -296,7 +296,7 @@ graph_api:
 
 
   '/<%= APP_ID %>':
-    restrictions=<%= MultiJson.encode({"age_distr" => "13+"}) %>:
+    restrictions=<%= MultiJson.dump({"age_distr" => "13+"}) %>:
       post:
         with_token: "true"
 

data/spec/support/graph_api_shared_examples.rb

@@ -158,7 +158,7 @@ shared_examples_for "Koala GraphAPI" do
     it "passes a queries argument" do
       queries = stub('query string')
       queries_json = "some JSON"
-      MultiJson.stub(:encode).with(queries).and_return(queries_json)
+      MultiJson.stub(:dump).with(queries).and_return(queries_json)
 
       @api.should_receive(:get_object).with(anything, hash_including(:q => queries_json), anything)
       @api.fql_multiquery(queries)
@@ -426,7 +426,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     end
 
     it "JSON-encodes the restrictions" do
-      @app_api.should_receive(:graph_call).with(anything, hash_including(:restrictions => MultiJson.encode(@restrictions)), anything, anything)
+      @app_api.should_receive(:graph_call).with(anything, hash_including(:restrictions => MultiJson.dump(@restrictions)), anything, anything)
       @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)
     end
 
@@ -592,10 +592,13 @@ shared_examples_for "Koala GraphAPI without an access token" do
   end
 
   it "can't put an object" do
+    lambda { @result = @api.put_connections(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
+    # legacy put_object syntax
     lambda { @result = @api.put_object(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
   end
 
-  # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
+  # these are not strictly necessary as the other put methods resolve to put_connections,
+  # but are here for completeness
   it "can't post to a feed" do
     (lambda do
       attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"}