koala 2.5.0 → 3.0.0

data/spec/cases/api_spec.rb

@@ -1,9 +1,30 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::API" do
-  before(:each) do
+  before :each do
     @service = Koala::Facebook::API.new
   end
+  let(:dummy_response) { double("fake response", data: {}, status: 200, body: "", headers: {}) }
+
+  it "defaults to the globally configured token if one's provided" do
+    token = "Foo"
+
+    Koala.configure do |config|
+      config.access_token = token
+    end
+
+    expect(Koala::Facebook::API.new.access_token).to eq(token)
+  end
+
+  it "defaults to the globally configured app_secret if one's provided" do
+    app_secret = "Foo"
+
+    Koala.configure do |config|
+      config.app_secret = app_secret
+    end
+
+    expect(Koala::Facebook::API.new.app_secret).to eq(app_secret)
+  end
 
   it "doesn't include an access token if none was given" do
     expect(Koala).to receive(:make_request).with(
@@ -45,36 +66,6 @@ describe "Koala::Facebook::API" do
     service.api('anything', args)
   end
 
-  it "has an attr_reader for access token" do
-    token = 'adfadf'
-    service = Koala::Facebook::API.new token
-    expect(service.access_token).to eq(token)
-  end
-
-  it "has an attr_reader for app_secret" do
-    secret = double
-    service = Koala::Facebook::API.new(@token, secret)
-    expect(service.app_secret).to eq(secret)
-  end
-
-  it "gets the attribute of a Koala::HTTPService::Response given by the http_component parameter" do
-    http_component = :method_name
-
-    response = double('Mock KoalaResponse', :body => '', :status => 200)
-    result = double("result")
-    allow(response).to receive(http_component).and_return(result)
-    allow(Koala).to receive(:make_request).and_return(response)
-
-    expect(@service.api('anything', {}, 'get', :http_component => http_component)).to eq(result)
-  end
-
-  it "returns the entire response if http_component => :response" do
-    http_component = :response
-    response = double('Mock KoalaResponse', :body => '', :status => 200)
-    allow(Koala).to receive(:make_request).and_return(response)
-    expect(@service.api('anything', {}, 'get', :http_component => http_component)).to eq(response)
-  end
-
   it "turns arrays of non-enumerables into comma-separated arguments by default" do
     args = [12345, {:foo => [1, 2, "3", :four]}]
     expected = ["/12345", {:foo => "1,2,3,four"}, "get", {}]
@@ -123,43 +114,12 @@ describe "Koala::Facebook::API" do
     @service.api(*args)
   end
 
-  it "returns the body of the request as JSON if no http_component is given" do
-    response = double('response', :body => 'body', :status => 200)
-    allow(Koala).to receive(:make_request).and_return(response)
-
-    json_body = double('JSON body')
-    allow(JSON).to receive(:load).and_return([json_body])
-
-    expect(@service.api('anything')).to eq(json_body)
-  end
-
-  it "executes an error checking block if provided" do
-    response = Koala::HTTPService::Response.new(200, '{}', {})
-    allow(Koala).to receive(:make_request).and_return(response)
-
-    yield_test = double('Yield Tester')
-    expect(yield_test).to receive(:pass)
-
-    @service.api('anything', {}, "get") do |arg|
-      yield_test.pass
-      expect(arg).to eq(response)
-    end
-  end
-
   it "raises an API error if the HTTP response code is greater than or equal to 500" do
     allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, 'response body', {}))
 
     expect { @service.api('anything') }.to raise_exception(Koala::Facebook::APIError)
   end
 
-  it "handles rogue true/false as responses" do
-    expect(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, 'true', {}))
-    expect(@service.api('anything')).to be_truthy
-
-    expect(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, 'false', {}))
-    expect(@service.api('anything')).to be_falsey
-  end
-
   describe "path manipulation" do
     context "leading /" do
       it "adds a leading / to the path if not present" do
@@ -179,11 +139,9 @@ describe "Koala::Facebook::API" do
   describe "with an access token" do
     before(:each) do
       @api = Koala::Facebook::API.new(@token)
+      @app_access_token = KoalaTest.app_access_token
     end
 
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI with an access token"
-
     it_should_behave_like "Koala GraphAPI"
     it_should_behave_like "Koala GraphAPI with an access token"
     it_should_behave_like "Koala GraphAPI with GraphCollection"
@@ -194,12 +152,10 @@ describe "Koala::Facebook::API" do
       @api = Koala::Facebook::API.new
     end
 
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI without an access token"
-
+    # In theory this should behave the same with a GraphCollection, but those tests currently hit
+    # an endpoint that now requires a token.
     it_should_behave_like "Koala GraphAPI"
     it_should_behave_like "Koala GraphAPI without an access token"
-    it_should_behave_like "Koala GraphAPI with GraphCollection"
   end
 
   context '#api' do
@@ -252,4 +208,78 @@ describe "Koala::Facebook::API" do
       end
     end
   end
+
+  describe "#graph_call" do
+    it "passes all arguments to the api method" do
+      user = KoalaTest.user1
+      args = {}
+      verb = 'get'
+      opts = {:a => :b}
+      expect(@service).to receive(:api).with(user, args, verb, opts).and_return(dummy_response)
+      @service.graph_call(user, args, verb, opts)
+    end
+
+    it "throws an APIError if the result hash has an error key" do
+      allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, '{"error": "An error occurred!"}', {}))
+      expect { @service.graph_call(KoalaTest.user1, {}) }.to raise_exception(Koala::Facebook::APIError)
+    end
+
+    it "passes the results through GraphCollection.evaluate" do
+      allow(@service).to receive(:api).and_return(dummy_response)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:evaluate).with(dummy_response, @service)
+      @service.graph_call("/me")
+    end
+
+    it "returns the results of GraphCollection.evaluate" do
+      expected = {}
+      allow(@service).to receive(:api).and_return(dummy_response)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:evaluate).and_return(expected)
+      expect(@service.graph_call("/me")).to eq(expected)
+    end
+
+    it "returns the post_processing block's results if one is supplied" do
+      other_result = [:a, 2, :three]
+      block = Proc.new {|r| other_result}
+      allow(@service).to receive(:api).and_return(dummy_response)
+      expect(@service.graph_call("/me", {}, "get", {}, &block)).to eq(other_result)
+    end
+
+    it "gets the status of a Koala::HTTPService::Response if requested" do
+      response = Koala::HTTPService::Response.new(200, '', {})
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      expect(@service.graph_call('anything', {}, 'get', http_component: :status)).to eq(200)
+    end
+
+    it "gets the headers of a Koala::HTTPService::Response if requested" do
+      headers = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, '', headers)
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      expect(@service.graph_call('anything', {}, 'get', :http_component => :headers)).to eq(headers)
+    end
+
+    it "returns the entire response if http_component => :response" do
+      http_component = :response
+      response = Koala::HTTPService::Response.new(200, '', {})
+      allow(Koala).to receive(:make_request).and_return(response)
+      expect(@service.graph_call('anything', {}, 'get', :http_component => http_component)).to eq(response)
+    end
+
+    it "returns the body of the request as JSON if no http_component is given" do
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, {})
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      expect(@service.graph_call('anything')).to eq(result)
+    end
+
+    it "handles rogue true/false as responses" do
+      expect(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, 'true', {}))
+      expect(@service.graph_call('anything')).to be_truthy
+
+      expect(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, 'false', {}))
+      expect(@service.graph_call('anything')).to be_falsey
+    end
+  end
 end

data/spec/cases/configuration_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+RSpec.describe Koala::Configuration do
+  let(:config) { Koala::Configuration.new }
+
+  it "defaults the HTTPService's DEFAULT_SERVERS" do
+    Koala::HTTPService::DEFAULT_SERVERS.each_pair do |key, value|
+      expect(config.public_send(key)).to eq(value)
+    end
+  end
+end

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)
@@ -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
@@ -555,38 +596,28 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       ).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