koala 2.4.0 → 3.5.0

data/spec/cases/graph_api_batch_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'json' unless Hash.respond_to?(:to_json)
 
 describe "Koala::Facebook::GraphAPI in batch mode" do
 
@@ -58,11 +59,11 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           @batch_queue = []
           allow(Koala::Facebook::API).to receive(:batch_calls).and_return(@batch_queue)
 
-          allow(Koala::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
-          allow(Koala::UploadableIO).to receive(:binary_content?).and_return(false)
-          allow(Koala::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
-          allow(Koala::UploadableIO).to receive(:binary_content?).with(@uploadable_io).and_return(true)
-          allow(@uploadable_io).to receive(:is_a?).with(Koala::UploadableIO).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).and_return(false)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).with(@uploadable_io).and_return(true)
+          allow(@uploadable_io).to receive(:is_a?).with(Koala::HTTPService::UploadableIO).and_return(true)
 
           @args[:method] = "post" # files are always post
         end
@@ -243,11 +244,11 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       describe "with binary files" do
         before :each do
           @binary = double("Binary file")
-          allow(Koala::UploadableIO).to receive(:binary_content?).and_return(false)
-          allow(Koala::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).and_return(false)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
           @uploadable_io = double("UploadableIO")
-          allow(Koala::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
-          allow(@uploadable_io).to receive(:is_a?).with(Koala::UploadableIO).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
+          allow(@uploadable_io).to receive(:is_a?).with(Koala::HTTPService::UploadableIO).and_return(true)
 
           @batch_queue = []
           allow(Koala::Facebook::API).to receive(:batch_calls).and_return(@batch_queue)
@@ -322,7 +323,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           allow(Koala::Facebook::GraphBatchAPI::BatchOperation).to receive(:new).and_return(op)
 
           # two requests should generate two batch operations
-          expected = MultiJson.dump([op.to_batch_params(access_token, nil), op.to_batch_params(access_token, nil)])
+          expected = JSON.dump([op.to_batch_params(access_token, nil), op.to_batch_params(access_token, nil)])
           expect(Koala).to 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')
@@ -468,17 +469,57 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         expect(thread_one_count).to eq(first_count)
         expect(thread_two_count).to eq(second_count)
       end
+
+    end
+  end
+
+  describe '#big_batches' do
+    before :each do
+      payload = [{code: 200, headers: [{name: "Content-Type", value: "text/javascript; charset=UTF-8"}], body: "{\"id\":\"1234\"}"}]
+      allow(Koala).to receive(:make_request) do |_request, args, _verb, _options|
+        request_count = JSON.parse(args['batch']).length
+        expect(request_count).to be <= 50   # check FB's limit
+        Koala::HTTPService::Response.new(200, (payload * request_count).to_json, {})
+      end
+    end
+
+    it 'stays within fb limits' do
+      count_calls = 0
+      expected_calls = 100
+      @api.batch do |batch_api|
+        expected_calls.times { |_i| batch_api.get_object('me') { |_ret| count_calls += 1 } }
+      end
+
+      expect(count_calls).to eq(expected_calls)
+    end
+
+    it 'is recursive safe' do
+      # ensure batch operations whose callbacks call batch operations don't resubmit
+      call_count = 0
+      iterations = 60
+      @api.batch do |batch_api|
+        # must do enough calls to provoke a batch submission
+        iterations.times { |_i|
+          batch_api.get_object('me') { |_ret|
+            call_count += 1
+            batch_api.get_object('me') { |_ret|
+              call_count += 1
+            }
+          }
+        }
+      end
+      expect(call_count).to eq(2 * iterations)
     end
   end
 
   describe "usage tests" do
     it "gets two results at once" do
-      me, koppel = @api.batch do |batch_api|
+      me, barackobama = @api.batch do |batch_api|
         batch_api.get_object('me')
         batch_api.get_object(KoalaTest.user1)
       end
       expect(me['id']).not_to be_nil
-      expect(koppel['id']).not_to be_nil
+      expect(barackobama['id']).not_to be_nil
     end
 
     it 'makes mixed calls inside of a batch' do
@@ -486,7 +527,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         batch_api.get_object('me')
         batch_api.get_connections('me', 'friends')
       end
-      expect(friends).to be_a(Koala::Facebook::GraphCollection)
+      expect(friends).to be_a(Koala::Facebook::API::GraphCollection)
     end
 
     it 'turns pageable results into GraphCollections' do
@@ -502,7 +543,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       pictures = @api.batch do |batch_api|
         batch_api.get_picture('me')
       end
-      expect(pictures.first).to match(/http\:\/\//) # works both live & stubbed
+      expect(pictures.first).to match(/https\:\/\//) # works both live & stubbed
     end
 
     it 'takes an after processing block for a get_picture call inside of a batch' do
@@ -510,40 +551,40 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       @api.batch do |batch_api|
         batch_api.get_picture('me') { |pic| picture = pic }
       end
-      expect(picture).to match(/http\:\/\//) # works both live & stubbed
+      expect(picture).to match(/https\:\/\//) # works both live & stubbed
     end
 
     it "handles requests for two different tokens" do
-      me, insights = @api.batch do |batch_api|
+      me, app_event_types = @api.batch do |batch_api|
         batch_api.get_object('me')
-        batch_api.get_connections(@app_id, 'insights', {}, {"access_token" => @app_api.access_token})
+        batch_api.get_connections(@app_id, 'app_event_types', {}, {"access_token" => @app_api.access_token})
       end
       expect(me['id']).not_to be_nil
-      expect(insights).to be_an(Koala::Facebook::GraphCollection)
+      expect(app_event_types).to be_an(Koala::Facebook::API::GraphCollection)
     end
 
     it "handles requests passing the access token option as a symbol instead of a string" do
-      me, insights = @api.batch do |batch_api|
+      me, app_event_types = @api.batch do |batch_api|
         batch_api.get_object('me')
-        batch_api.get_connections(@app_id, 'insights', {}, {:access_token => @app_api.access_token})
+        batch_api.get_connections(@app_id, 'app_event_types', {}, {:access_token => @app_api.access_token})
       end
       expect(me['id']).not_to be_nil
-      expect(insights).to be_an(Koala::Facebook::GraphCollection)
+      expect(app_event_types).to be_an(Koala::Facebook::API::GraphCollection)
     end
 
     it "preserves batch-op specific access tokens in GraphCollection returned from batch" do
       # Provide an alternate token for a batch operation
       @other_access_token_args = { 'access_token' => @app_api.access_token }
 
-      # make a batch call for insights using another token
-      me, insights = @api.batch do |batch_api|
+      # make a batch call for app_event_types using another token
+      me, app_event_types = @api.batch do |batch_api|
         batch_api.get_object('me')
-        batch_api.get_connections(@app_id, 'insights', {}, @other_access_token_args)
+        batch_api.get_connections(@app_id, 'app_event_types', {}, @other_access_token_args)
       end
 
       # The alternate token is returned with the next page parameters
       # The GraphCollection should receive a request for the next_page_params during paging
-      expect(insights).to receive(:next_page_params).and_return([double("base"), @other_access_token_args.dup])
+      expect(app_event_types).to receive(:next_page_params).and_return([double("base"), @other_access_token_args.dup])
 
       # The alternate access token should pass through to making the request
       # Koala should receive a request during paging using the alternate token
@@ -552,41 +593,31 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           hash_including(@other_access_token_args.dup),
           anything,
           anything
-      ).and_return(Koala::HTTPService::Response.new(200, "", ""))
+      ).and_return(Koala::HTTPService::Response.new(200, "", {}))
 
       # Page the collection
-      insights.next_page
+      app_event_types.next_page
     end
 
     it "inserts errors in the appropriate place, without breaking other results" do
-      failed_call, koppel = @api.batch do |batch_api|
+      failed_call, barackobama = @api.batch do |batch_api|
         batch_api.get_connection("2", "invalidconnection")
         batch_api.get_object(KoalaTest.user1, {}, {"access_token" => @app_api.access_token})
       end
       expect(failed_call).to be_a(Koala::Facebook::ClientError)
-      expect(koppel["id"]).not_to be_nil
+      expect(barackobama["id"]).not_to be_nil
     end
 
     it "handles different request methods" do
       result = @api.put_wall_post("Hello, world, from the test suite batch API!")
       wall_post = result["id"]
 
-      wall_post, koppel = @api.batch do |batch_api|
+      wall_post, barackobama = @api.batch do |batch_api|
         batch_api.put_like(wall_post)
         batch_api.delete_object(wall_post)
       end
     end
 
-    it "allows FQL" do
-      result = @api.batch do |batch_api|
-        batch_api.graph_call("method/fql.query", {:query=>"select first_name from user where uid=#{KoalaTest.user1_id}"}, "post")
-      end
-
-      fql_result = result[0]
-      expect(fql_result[0]).to be_a(Hash)
-      expect(fql_result[0]["first_name"]).to eq("Alex")
-    end
-
     describe 'with post-processing callback' do
       let(:me_result) { double("me result") }
       let(:friends_result) { [double("friends result")] }
@@ -668,23 +699,23 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       end
 
       it "allows you to create dependencies" do
-        me, koppel = @api.batch do |batch_api|
+        me, barackobama = @api.batch do |batch_api|
           batch_api.get_object("me", {}, :batch_args => {:name => "getme"})
           batch_api.get_object(KoalaTest.user1, {}, :batch_args => {:depends_on => "getme"})
         end
 
         expect(me).to be_nil # gotcha!  it's omitted because it's a successfully-executed dependency
-        expect(koppel["id"]).not_to be_nil
+        expect(barackobama["id"]).not_to be_nil
       end
 
       it "properly handles dependencies that fail" do
-        failed_call, koppel = @api.batch do |batch_api|
+        failed_call, barackobama = @api.batch do |batch_api|
           batch_api.get_connections("2", "invalidconnection", {}, :batch_args => {:name => "getdata"})
           batch_api.get_object(KoalaTest.user1, {}, :batch_args => {:depends_on => "getdata"})
         end
 
         expect(failed_call).to be_a(Koala::Facebook::ClientError)
-        expect(koppel).to be_nil
+        expect(barackobama).to be_nil
       end
 
       it "throws an error for badly-constructed request relationships" do

data/spec/cases/graph_api_spec.rb

@@ -9,6 +9,8 @@ describe 'Koala::Facebook::GraphAPIMethods' do
     @app_api = Koala::Facebook::API.new(@app_access_token)
   end
 
+  let(:dummy_response) { double("fake response", data: {}, status: 200, body: "", headers: {}) }
+
   describe 'post-processing for' do
     let(:result) { double("result") }
     let(:post_processing) { lambda {|arg| {"result" => result, "args" => arg} } }
@@ -17,47 +19,31 @@ describe 'Koala::Facebook::GraphAPIMethods' do
     # and the other methods which do some post-processing locally
     context '#get_object' do
       it 'returns result of block' do
-        allow(@api).to receive(:api).and_return(double("other results"))
-        expect(@api.get_object('koppel', &post_processing)["result"]).to eq(result)
+        allow(@api).to receive(:api).and_return(dummy_response)
+        expect(@api.get_object('barackobama', &post_processing)["result"]).to eq(result)
       end
 
       it "doesn't add token to received arguments" do
         args = {}.freeze
-        expect(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, "", ""))
-        expect(@api.get_object('koppel', args, &post_processing)["result"]).to eq(result)
+        expect(Koala).to receive(:make_request).and_return(dummy_response)
+        expect(@api.get_object('barackobama', args, &post_processing)["result"]).to eq(result)
       end
     end
 
     context '#get_picture' do
       it 'returns result of block' do
-        allow(@api).to receive(:api).and_return({"data" => {"is_silhouette" => false, "url" => result}})
-        expect(@api.get_picture('lukeshepard', &post_processing)["result"]).to eq(result)
-      end
-    end
-
-    context '#fql_multiquery' do
-      before do
-        expect(@api).to 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}]
-        }
-        response = @api.fql_multiquery({}, &post_processing)
-        expect(response["args"]).to eq(resolved_result)
-        expect(response["result"]).to eq(result)
+        result_url = "a url"
+        allow(@api).to receive(:api).and_return(Koala::HTTPService::Response.new(200, {"data" => {"is_silhouette" => false, "url" => result_url}}.to_json, {}))
+        expect(@api.get_picture('koppel', &post_processing)["result"]).to eq(result)
       end
     end
 
     context '#get_page_access_token' do
       it 'returns result of block' do
         token = Koala::MockHTTPService::APP_ACCESS_TOKEN
-        allow(@api).to receive(:api).and_return("access_token" => token)
+        allow(@api).to receive(:api).and_return(
+          Koala::HTTPService::Response.new(200, {"access_token" => token}.to_json, {})
+        )
         response = @api.get_page_access_token('facebook', &post_processing)
         expect(response["args"]).to eq(token)
         expect(response["result"]).to eq(result)
@@ -71,18 +57,18 @@ describe 'Koala::Facebook::GraphAPIMethods' do
 
       it "is enabled by default if an app secret is present" do
         api = Koala::Facebook::API.new(@token, "mysecret")
-        expect(api).to receive(:api).with(path, {}, 'get', :appsecret_proof => true)
+        expect(api).to receive(:api).with(path, {}, 'get', :appsecret_proof => true).and_return(dummy_response)
         api.graph_call(path)
       end
 
       it "can be disabled manually" do
         api = Koala::Facebook::API.new(@token, "mysecret")
-        expect(api).to receive(:api).with(path, {}, 'get', hash_not_including(appsecret_proof: true))
+        expect(api).to receive(:api).with(path, {}, 'get', hash_not_including(appsecret_proof: true)).and_return(dummy_response)
         api.graph_call(path, {}, "get", appsecret_proof: false)
       end
 
       it "isn't included if no app secret is present" do
-        expect(@api).to receive(:api).with(path, {}, 'get', {})
+        expect(@api).to receive(:api).with(path, {}, 'get', {}).and_return(dummy_response)
         @api.graph_call(path)
       end
     end

data/spec/cases/graph_collection_spec.rb

@@ -1,28 +1,30 @@
 require 'spec_helper'
 
-describe Koala::Facebook::GraphCollection do
-  let(:paging){ {:paging => true} }
+describe Koala::Facebook::API::GraphCollection do
+  let(:paging){ {"paging" => true} }
 
   before(:each) do
-    @result = {
-      "data" => [1, 2, :three],
+    @headers = {'Content-Type' => 'application/json'}
+    @data = {
+      "data" => [1, 2, 'three'],
       "paging" => paging,
       "summary" => [3]
     }
+    @result = Koala::HTTPService::Response.new(200, @data.to_json, @headers)
     @api = Koala::Facebook::API.new("123")
-    @collection = Koala::Facebook::GraphCollection.new(@result, @api)
+    @collection = Koala::Facebook::API::GraphCollection.new(@result, @api)
   end
 
   it "subclasses Array" do
-    expect(Koala::Facebook::GraphCollection.ancestors).to include(Array)
+    expect(Koala::Facebook::API::GraphCollection.ancestors).to include(Array)
   end
 
   it "creates an array-like object" do
-    expect(Koala::Facebook::GraphCollection.new(@result, @api)).to be_an(Array)
+    expect(Koala::Facebook::API::GraphCollection.new(@result, @api)).to be_an(Array)
   end
 
   it "contains the result data" do
-    @result["data"].each_with_index {|r, i| expect(@collection[i]).to eq(r)}
+    @data["data"].each_with_index {|r, i| expect(@collection[i]).to eq(r)}
   end
 
   it "has a read-only paging attribute" do
@@ -31,43 +33,49 @@ describe Koala::Facebook::GraphCollection do
   end
 
   it "sets paging to results['paging']" do
-    expect(@collection.paging).to eq(@result["paging"])
+    expect(@collection.paging).to eq(@data["paging"])
   end
 
   it "sets summary to results['summary']" do
-    expect(@collection.summary).to eq(@result["summary"])
+    expect(@collection.summary).to eq(@data["summary"])
   end
 
   it "sets raw_response to the original results" do
-    expect(@collection.raw_response).to eq(@result)
+    expect(@collection.raw_response).to eq(@result.data)
   end
 
   it "sets the API to the provided API" do
     expect(@collection.api).to eq(@api)
   end
 
+  it "sets the headers correctly" do
+    expect(@collection.headers).to eq(@headers)
+  end
+
   describe "when getting a whole page" do
     before(:each) do
       @second_page = {
-        "data" => [:second, :page, :data],
+        "data" => ["second", "page", "data"],
         "paging" => {}
       }
       @base = double("base")
       @args = {"a" => 1}
       @page_of_results = double("page of results")
+      @result = Koala::HTTPService::Response.new(200, @second_page.to_json, {})
+      @result.data
     end
 
     it "should return the previous page of results" do
       expect(@collection).to receive(:previous_page_params).and_return([@base, @args])
-      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@result)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(@result, @api).and_return(@page_of_results)
       expect(@collection.previous_page).to eq(@page_of_results)
     end
 
     it "should return the next page of results" do
       expect(@collection).to receive(:next_page_params).and_return([@base, @args])
-      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@result)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(@result, @api).and_return(@page_of_results)
 
       expect(@collection.next_page).to eq(@page_of_results)
     end
@@ -84,13 +92,13 @@ describe Koala::Facebook::GraphCollection do
     describe "#parse_page_url" do
       it "should pass the url to the class method" do
         url = double("url")
-        expect(Koala::Facebook::GraphCollection).to receive(:parse_page_url).with(url)
+        expect(Koala::Facebook::API::GraphCollection).to receive(:parse_page_url).with(url)
         @collection.parse_page_url(url)
       end
 
       it "should return the result of the class method" do
         parsed_content = double("parsed_content")
-        allow(Koala::Facebook::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
+        allow(Koala::Facebook::API::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
         expect(@collection.parse_page_url(double("url"))).to eq(parsed_content)
       end
     end
@@ -98,54 +106,59 @@ describe Koala::Facebook::GraphCollection do
     describe ".parse_page_url" do
       it "should return the base as the first array entry" do
         base = "url_path"
-        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first).to eq(base)
+        expect(Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first).to eq(base)
       end
 
       it "should return the arguments as a hash as the last array entry" do
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last).to eq(args_hash)
+        expect(Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last).to eq(args_hash)
       end
 
       it "works with non-.com addresses" do
         base = "url_path"
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}")).to eq([base, args_hash])
+        expect(Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}")).to eq([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}")
+        base, args_hash = Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
         expect(args_hash["token"]).to eq(access_token)
       end
     end
   end
 
   describe ".evaluate" do
-    it "returns the original result if it's provided a non-hash result" do
-      result = []
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+    it "returns the body of the original response if it's provided a Response with a non-hash data key" do
+      result = double('fake response')
+      allow(result).to receive(:is_a?).with(Hash).and_return(false)
+      allow(result).to receive(:data).and_return([])
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq([])
     end
 
     it "returns the original result if it's provided a nil result" do
       result = nil
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
-    it "returns the original result if the result doesn't have a data key" do
-      result = {"paging" => {}}
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+    it "returns the original result body if the result doesn't have a data key" do
+      paging = {"paging" => {}}
+      result = Koala::HTTPService::Response.new(200, paging.to_json, {})
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(paging)
     end
 
     it "returns the original result if the result's data key isn't an array" do
-      result = {"data" => {}, "paging" => {}}
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+      body = {"data" => {}, "paging" => {}}
+      result = Koala::HTTPService::Response.new(200, body.to_json, {})
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(body)
     end
 
     it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
-      result = {"data" => [], "paging" => {}}
+      body = {"data" => [], "paging" => {}}
+      result = Koala::HTTPService::Response.new(200, body.to_json, {})
       expected = :foo
-      expect(Koala::Facebook::GraphCollection).to receive(:new).with(result, @api).and_return(expected)
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(expected)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(result, @api).and_return(expected)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(expected)
     end
   end
 

data/spec/cases/graph_error_checker_spec.rb

@@ -11,7 +11,10 @@ module Koala
         expect(GraphErrorChecker::DEBUG_HEADERS).to match_array([
           "x-fb-rev",
           "x-fb-debug",
-          "x-fb-trace-id"
+          "x-fb-trace-id",
+          "x-business-use-case-usage",
+          "x-ad-account-usage",
+          "x-app-usage"
         ])
       end
 
@@ -54,6 +57,18 @@ module Koala
             expect(error.response_body).to eq(body)
           end
 
+          it "returns a ClientError if the body is empty" do
+            body.replace("")
+            expect(error).to be_a(ClientError)
+            expect(error.response_body).to eq(body)
+          end
+
+          it "returns a ClientError if the body is null" do
+            body.replace("null")
+            expect(error).to be_a(ClientError)
+            expect(error.response_body).to eq(body)
+          end
+
           it "adds error data from the body" do
             error_data = {
               "type" => "FB error type",
@@ -78,10 +93,25 @@ module Koala
               "x-fb-debug" => double("fb debug"),
               "x-fb-rev" => double("fb rev"),
               "x-fb-trace-id" => double("fb trace id"),
+              "x-business-use-case-usage" => { 'a' => 1, 'b' => 2 }.to_json,
+              "x-ad-account-usage" => { 'c' => 3, 'd' => 4 }.to_json,
+              "x-app-usage" => { 'e' => 5, 'f' => 6 }.to_json
             )
             expect(error.fb_error_trace_id).to eq(headers["x-fb-trace-id"])
             expect(error.fb_error_debug).to eq(headers["x-fb-debug"])
             expect(error.fb_error_rev).to eq(headers["x-fb-rev"])
+            expect(error.fb_buc_usage).to eq({ 'a' => 1, 'b' => 2 })
+            expect(error.fb_ada_usage).to eq({ 'c' => 3, 'd' => 4 })
+            expect(error.fb_app_usage).to eq({ 'e' => 5, 'f' => 6 })
+          end
+
+          it "logs if one of the FB debug headers can't be parsed" do
+            headers.merge!(
+              "x-app-usage" => '{invalid:json}'
+            )
+
+            expect(Koala::Utils.logger).to receive(:error).with(/JSON::ParserError:.*unexpected token at '{invalid:json}' while parsing x-app-usage = {invalid:json}/)
+            expect(error.fb_app_usage).to eq(nil)
           end
 
           context "it returns an AuthenticationError" do
@@ -113,4 +143,3 @@ module Koala
     end
   end
 end
-