koala 1.5.0 → 1.6.0

data/spec/cases/error_spec.rb

@@ -1,40 +1,76 @@
 require 'spec_helper'
 
 describe Koala::Facebook::APIError do
-  it "is a StandardError" do
-    Koala::Facebook::APIError.new.should be_a(StandardError)
+  it "is a Koala::KoalaError" do
+    Koala::Facebook::APIError.new(nil, nil).should be_a(Koala::KoalaError)
   end
 
-  [:fb_error_type, :fb_error_code, :fb_error_message, :raw_response].each do |accessor|
+  [:fb_error_type, :fb_error_code, :fb_error_subcode, :fb_error_message, :http_status, :response_body].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
+  it "sets http_status to the provided status" do
+    error_response = '{ "error": {"type": "foo", "other_details": "bar"} }'
+    Koala::Facebook::APIError.new(400, error_response).response_body.should == error_response
+  end
+
+  it "sets response_body to the provided response body" do
+    Koala::Facebook::APIError.new(400, '').http_status.should == 400
+  end
+
+  context "with an error_info hash" do
+    let(:error) { 
+      error_info = {
+        'type' => 'type',
+        'message' => 'message',
+        'code' => 1,
+        'error_subcode' => 'subcode'
+      }
+      Koala::Facebook::APIError.new(400, '', error_info)
+    }
+
+    {
+      :fb_error_type => 'type',
+      :fb_error_message => 'message',
+      :fb_error_code => 1,
+      :fb_error_subcode => 'subcode'
+    }.each_pair do |accessor, value|
+      it "sets #{accessor} to #{value}" do
+        error.send(accessor).should == value
+      end
+    end
+
+    it "sets the error message \"type: error_info['type'], code: error_info['code'], error_subcode: error_info['error_subcode'], message: error_info['message'] [HTTP http_status]\"" do
+      error.message.should == "type: type, code: 1, error_subcode: subcode, message: message [HTTP 400]"
+    end
   end
 
-  {
-    :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
+  context "with an error_info string" do
+    it "sets the error message \"error_info [HTTP http_status]\"" do
+      error_info = "Facebook is down."
+      error = Koala::Facebook::APIError.new(400, '', error_info)
+      error.message.should == "Facebook is down. [HTTP 400]"
     end
   end
 
-  it "sets the error message details['type']: details['message']" do
-    type = "foo"
-    message = "bar"
-    error = Koala::Facebook::APIError.new("type" => type, "message" => message)
-    error.message.should =~ /#{type}/
-    error.message.should =~ /#{message}/
+  context "with no error_info and a response_body containing error JSON" do
+    it "should extract the error info from the response body" do
+      response_body = '{ "error": { "type": "type", "message": "message", "code": 1, "error_subcode": "subcode" } }'
+      error = Koala::Facebook::APIError.new(400, response_body)
+      {
+        :fb_error_type => 'type',
+        :fb_error_message => 'message',
+        :fb_error_code => 1,
+        :fb_error_subcode => 'subcode'
+      }.each_pair do |accessor, value|
+        error.send(accessor).should == value
+      end
+    end
   end
+
 end
 
 describe Koala::KoalaError do
@@ -43,3 +79,38 @@ describe Koala::KoalaError do
   end
 end
 
+describe Koala::Facebook::OAuthSignatureError do
+  it "is a Koala::KoalaError" do
+     Koala::KoalaError.new.should be_a(Koala::KoalaError)
+  end
+end
+
+describe Koala::Facebook::BadFacebookResponse do
+  it "is a Koala::Facebook::APIError" do
+     Koala::Facebook::BadFacebookResponse.new(nil, nil).should be_a(Koala::Facebook::APIError)
+  end
+end
+
+describe Koala::Facebook::OAuthTokenRequestError do
+  it "is a Koala::Facebook::APIError" do
+     Koala::Facebook::OAuthTokenRequestError.new(nil, nil).should be_a(Koala::Facebook::APIError)
+  end
+end
+
+describe Koala::Facebook::ServerError do
+  it "is a Koala::Facebook::APIError" do
+     Koala::Facebook::ServerError.new(nil, nil).should be_a(Koala::Facebook::APIError)
+  end
+end
+
+describe Koala::Facebook::ClientError do
+  it "is a Koala::Facebook::APIError" do
+     Koala::Facebook::ClientError.new(nil, nil).should be_a(Koala::Facebook::APIError)
+  end
+end
+
+describe Koala::Facebook::AuthenticationError do
+  it "is a Koala::Facebook::ClientError" do
+     Koala::Facebook::AuthenticationError.new(nil, nil).should be_a(Koala::Facebook::ClientError)
+  end
+end

data/spec/cases/graph_api_batch_spec.rb

@@ -381,58 +381,56 @@ 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
+          it "raises a BadFacebookResponse 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)
+            }.to raise_exception(Koala::Facebook::BadFacebookResponse)
           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."}', {}))
+              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(400, '{"error_code":190,"error_description":"Error validating access token."}', {}))
             end
 
-            it "throws an error if the response is an old Batch API-style error" do
+            it "throws an error" do
               expect {
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               }.to raise_exception(Koala::Facebook::APIError)
             end
 
-            it "provides a type for the error if the response is an old Batch API-style error" do
+            it "passes all the error details" do
               begin
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               rescue Koala::Facebook::APIError => err
+                err.fb_error_code.should == 190
+                err.fb_error_message.should == "Error validating access token."
+                err.http_status == 400
+                err.response_body == '{"error_code":190,"error_description":"Error validating access token."}'
               end
-              err.fb_error_type.should
-            end
-
-            it "passes all the error details if an old Batch API-style error is raised" do
-              begin
-                Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
-              rescue Koala::Facebook::APIError => err
-              end
-              err.raw_response["error"].should == 190
             end
           end
 
           context "with the new style" do
             before :each do
-              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}', {}))
+              Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(400, '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}', {}))
             end
 
-            it "throws an error if the response is a new Graph API-style error" do
+            it "throws an error" do
               expect {
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               }.to raise_exception(Koala::Facebook::APIError)
             end
 
-            it "passes all the error details if an old Batch API-style error is raised" do
+            it "passes all the error details" do
               begin
                 Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
               rescue Koala::Facebook::APIError => err
+                err.fb_error_type.should == "GraphBatchException"
+                err.fb_error_message.should == "Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests"
+                err.http_status == 400
+                err.response_body == '{"error":{"message":"Request 0 cannot depend on an  unresolved request with  name f. Requests can only depend on preceding requests","type":"GraphBatchException"}}'
               end
-              err.raw_response["message"].should
             end
           end
         end
@@ -509,7 +507,8 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       pictures = @api.batch do |batch_api|
         batch_api.get_picture('me')
       end
-      pictures.first.should_not be_empty
+      puts pictures.inspect
+      pictures.first.should =~ /http\:\/\// # works both live & stubbed
     end
 
     it "handles requests for two different tokens" do
@@ -526,7 +525,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         batch_api.get_connection("2", "invalidconnection")
         batch_api.get_object(KoalaTest.user1, {}, {"access_token" => @app_api.access_token})
       end
-      failed_call.should be_a(Koala::Facebook::APIError)
+      failed_call.should be_a(Koala::Facebook::ClientError)
       koppel["id"].should_not be_nil
     end
 
@@ -550,6 +549,42 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       fql_result[0]["first_name"].should == "Alex"
     end
 
+    describe 'with post-processing callback' do
+      let(:me_result) { stub("me result") }
+      let(:friends_result) { stub("friends result") }
+
+      let(:me_callback) { lambda {|data| me_result } }
+      let(:friends_callback) { lambda {|data| friends_result } }
+
+      it 'calls the callback with the appropriate data' do
+        me_callback.should_receive(:call).with(hash_including(
+          'id' => KoalaTest.user1
+        ))
+        friends_callback.should_receive(:call).with([
+          hash_including('id' => KoalaTest.user2)
+        ])
+        @api.batch do |batch_api|
+          batch_api.get_object('me', &me_callback)
+          batch_api.get_connections('me', 'friends', &friends_callback)
+        end
+      end
+
+      it 'passes GraphCollections, not raw data' do
+        friends_callback.should_receive(:call).with(kind_of(Koala::Facebook::API::GraphCollection))
+        @api.batch do |batch_api|
+          batch_api.get_object('me')
+          batch_api.get_connections('me', 'friends', &friends_callback)
+        end
+      end
+
+      it "returns the result of the callback" do
+        @api.batch do |batch_api|
+          batch_api.get_object('me', &me_callback)
+          batch_api.get_connections('me', 'friends', &friends_callback)
+        end.should == [me_result, friends_result]
+      end
+    end
+
     describe "binary files" do
       it "posts binary files" do
         file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
@@ -614,7 +649,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           batch_api.get_object(KoalaTest.user1, {}, :batch_args => {:depends_on => "getdata"})
         end
 
-        failed_call.should be_a(Koala::Facebook::APIError)
+        failed_call.should be_a(Koala::Facebook::ClientError)
         koppel.should be_nil
       end
 
@@ -624,7 +659,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             batch_api.get_connections("me", "friends", {:limit => 5})
             batch_api.get_objects("{result=i-dont-exist:$.data.*.id}")
           end
-        }.to raise_exception(Koala::Facebook::APIError)
+        }.to raise_exception(Koala::Facebook::ClientError)
       end
     end
   end

data/spec/cases/graph_api_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'Koala::Facebook::GraphAPIMethods' do
+  before do
+    @api = Koala::Facebook::API.new(@token)
+    # app API
+    @app_id = KoalaTest.app_id
+    @app_access_token = KoalaTest.app_access_token
+    @app_api = Koala::Facebook::API.new(@app_access_token)
+  end
+
+  describe 'post-processing for' do
+    let(:post_processing) { lambda {} }
+
+    # Most API methods have the same signature, we test get_object representatively
+    # and the other methods which do some post-processing locally
+    context '#get_object' do
+      it 'returns result of block' do
+        result = {"id" => 1, "name" => 1, "updated_time" => 1}
+        @api.stub(:api).and_return(result)
+        post_processing.should_receive(:call).
+          with(result).and_return('new result')
+        @api.get_object('koppel', &post_processing).should == 'new result'
+      end
+    end
+
+    context '#get_picture' do
+      it 'returns result of block' do
+        result = "http://facebook.com/"
+        @api.stub(:api).and_return("Location" => result)
+        post_processing.should_receive(:call).
+          with(result).and_return('new result')
+        @api.get_picture('lukeshepard', &post_processing).should == 'new result'
+      end
+    end
+
+    context '#fql_multiquery' do
+      before do
+        @api.should_receive(:get_object).and_return([
+          {"name" => "query1", "fql_result_set" => [{"id" => 123}]},
+          {"name" => "query2", "fql_result_set" => ["id" => 456]}
+        ])
+      end
+
+      it 'is called with resolved response' do
+        resolved_result = {
+          'query1' => [{'id' => 123}],
+          'query2' => [{'id'=>456}]
+        }
+        post_processing.should_receive(:call).
+          with(resolved_result).and_return('id'=>'123', 'id'=>'456')
+        @api.fql_multiquery({}, &post_processing).should ==
+          {'id'=>'123', 'id'=>'456'}
+      end
+    end
+
+    context '#get_page_access_token' do
+      it 'returns result of block' do
+        token = Koala::MockHTTPService::APP_ACCESS_TOKEN
+        @api.stub(:api).and_return("access_token" => token)
+        post_processing.should_receive(:call).
+          with(token).and_return('base64-encoded access token')
+        @api.get_page_access_token('facebook', &post_processing).should ==
+          'base64-encoded access token'
+      end
+    end
+  end
+end

data/spec/cases/graph_collection_spec.rb

@@ -104,6 +104,12 @@ describe Koala::Facebook::GraphCollection do
         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
+
+      it "works with addresses with irregular characters" do
+        access_token = "appid123a|fdcba"
+        base, args_hash = Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
+        args_hash["token"].should == access_token
+      end
     end
   end
 

data/spec/cases/oauth_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::OAuth" do
-  before :each do
+  before :all do
     # make the relevant test data easily accessible
     @app_id = KoalaTest.app_id
     @secret = KoalaTest.secret
@@ -24,7 +24,9 @@ describe "Koala::Facebook::OAuth" do
     @multiple_session_keys = [KoalaTest.session_key, KoalaTest.session_key] if KoalaTest.session_key
 
     @oauth = Koala::Facebook::OAuth.new(@app_id, @secret, @callback_url)
+  end
 
+  before :each do
     @time = Time.now
     Time.stub!(:now).and_return(@time)
     @time.stub!(:to_i).and_return(1273363199)
@@ -117,19 +119,16 @@ describe "Koala::Facebook::OAuth" do
           end
 
           it "returns nil if the call to FB returns an expired code error" do
-            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::APIError.new(
-              "type" => "OAuthException",
-              "message" => "Code was invalid or expired. Session has expired at unix time 1324044000. The current unix time is 1324300957."
+            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
+              '{ "error": { "type": "OAuthException", "message": "Code was invalid or expired. Session has expired at unix time 1324044000. The current unix time is 1324300957." } }'
             ))
             @oauth.get_user_info_from_cookies(@cookie).should be_nil
           end
 
           it "raises the error if the call to FB returns a different error" do
-            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::APIError.new(
-              "type" => "OtherError",
-              "message" => "A Facebook Error"
-            ))
-            expect { @oauth.get_user_info_from_cookies(@cookie) }.to raise_exception(Koala::Facebook::APIError)
+            @oauth.stub(:get_access_token_info).and_raise(Koala::Facebook::OAuthTokenRequestError.new(400,
+              '{ "error": { "type": "OtherError", "message": "A Facebook Error" } }'))
+            expect { @oauth.get_user_info_from_cookies(@cookie) }.to raise_exception(Koala::Facebook::OAuthTokenRequestError)
           end
         end
 
@@ -149,6 +148,7 @@ describe "Koala::Facebook::OAuth" do
 
         it "returns all the cookie components from valid cookie string" do
           cookie_data = KoalaTest.oauth_test_data["valid_cookies"]
+          puts cookie_data.inspect
           parsing_results = @oauth.get_user_info_from_cookies(cookie_data)
           number_of_components = cookie_data["fbs_#{@app_id.to_s}"].scan(/\=/).length
           parsing_results.length.should == number_of_components
@@ -295,13 +295,13 @@ describe "Koala::Facebook::OAuth" do
 
       it "generates a properly formatted OAuth token URL when provided a code" do
         url = @oauth.url_for_access_token(@code)
-        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape @callback_url}").should be_true
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape @callback_url}")
       end
 
       it "generates a properly formatted OAuth token URL when provided a callback" do
         callback = "foo.com"
         url = @oauth.url_for_access_token(@code, :callback => callback)
-        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape callback}").should be_true
+        url.should match_url("https://#{Koala::Facebook::GRAPH_SERVER}/oauth/access_token?client_id=#{@app_id}&code=#{@code}&client_secret=#{@secret}&redirect_uri=#{CGI.escape callback}")
       end
 
       it "includes any additional options as URL parameters, appropriately escaped" do
@@ -399,7 +399,7 @@ describe "Koala::Facebook::OAuth" do
         end
 
         it "raises an error when get_access_token is called with a bad code" do
-          lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::APIError)
+          lambda { @oauth.get_access_token_info("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
       end
     end
@@ -425,7 +425,7 @@ describe "Koala::Facebook::OAuth" do
         end
 
         it "raises an error when get_access_token is called with a bad code" do
-          lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::APIError)
+          lambda { @oauth.get_access_token("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
         end
       end
     end
@@ -493,7 +493,7 @@ describe "Koala::Facebook::OAuth" do
       end
 
       it "raises an error when exchange_access_token_info is called with a bad code" do
-        lambda { @oauth.exchange_access_token_info("foo") }.should raise_error(Koala::Facebook::APIError)
+        lambda { @oauth.exchange_access_token_info("foo") }.should raise_error(Koala::Facebook::OAuthTokenRequestError)
       end
     end
 
@@ -579,9 +579,9 @@ describe "Koala::Facebook::OAuth" do
           result.each_with_index {|r, index| index > 0 ? r.should(be_a(Hash)) : r.should(be_nil)}
         end
 
-        it "throws an APIError if Facebook returns an empty body (as happens for instance when the API breaks)" do
+        it "throws a BadFacebookResponse if Facebook returns an empty body (as happens for instance when the API breaks)" do
           @oauth.should_receive(:fetch_token_string).and_return("")
-          lambda { @oauth.get_token_info_from_session_keys(@multiple_session_keys) }.should raise_error(Koala::Facebook::APIError)
+          lambda { @oauth.get_token_info_from_session_keys(@multiple_session_keys) }.should raise_error(Koala::Facebook::BadFacebookResponse)
         end
 
         it "passes on any options provided to make_request" do