koala 3.0.0.beta1 → 3.0.0.beta2

data/lib/koala/http_service/request.rb

@@ -14,11 +14,7 @@ module Koala
       # @option options :beta use the beta tier
       # @option options :use_ssl force https, even if not needed
       # @option options :json whether or not to send JSON to Facebook
-      def initialize(path: nil, args: {}, verb: nil, options: {})
-        # we still support Ruby 2.0 so we can't use required keyword arguments
-        raise ArgumentError, "Missing required argument verb" unless verb
-        raise ArgumentError, "Missing required argument path" unless path
-
+      def initialize(path:, verb:, args: {}, options: {})
         @raw_path = path
         @raw_args = args
         @raw_verb = verb

data/lib/koala/http_service/response.rb

@@ -9,6 +9,12 @@ module Koala
         @body = body
         @headers = headers
       end
+
+      def data
+        # quirks_mode is needed because Facebook sometimes returns a raw true or false value --
+        # in Ruby 2.4 we can drop that.
+        @data ||= JSON.parse(body, quirks_mode: true) unless body.empty?
+      end
     end
   end
 end

data/lib/koala/test_users.rb

@@ -146,11 +146,12 @@ module Koala
           raise ArgumentError, "TestUsers#befriend requires hash arguments for both users with id and access_token"
         end
 
-        u1_graph_api = API.new(user1_token)
-        u2_graph_api = API.new(user2_token)
+        u1_graph_api = API.new(user1_token, secret)
+        u2_graph_api = API.new(user2_token, secret)
 
-        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post", options) &&
-          u2_graph_api.graph_call("#{user2_id}/friends/#{user1_id}", {}, "post", options)
+        # if we have a secret token, flag that we want the appsecret_proof to be generated
+        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post", options.merge(appsecret_proof: !!secret)) &&
+          u2_graph_api.graph_call("#{user2_id}/friends/#{user1_id}", {}, "post", options.merge(appsecret_proof: !!secret))
       end
 
       # Create a network of test users, all of whom are friends and have the same permissions.

data/lib/koala/version.rb

@@ -1,3 +1,3 @@
 module Koala
-  VERSION = "3.0.0.beta1"
+  VERSION = "3.0.0.beta2"
 end

data/spec/cases/api_spec.rb

@@ -1,9 +1,10 @@
 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 "doesn't include an access token if none was given" do
     expect(Koala).to receive(:make_request).with(
@@ -57,24 +58,6 @@ describe "Koala::Facebook::API" do
     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 +106,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(:parse).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,6 +131,7 @@ 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 GraphAPI"
@@ -191,9 +144,10 @@ describe "Koala::Facebook::API" do
       @api = Koala::Facebook::API.new
     end
 
+    # 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
@@ -246,4 +200,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.data, @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/graph_api_batch_spec.rb

@@ -473,12 +473,12 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
 
   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
@@ -502,7 +502,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 +510,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::API::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::API::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,23 +555,23 @@ 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
@@ -658,23 +658,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,28 +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)
+        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)
@@ -52,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

@@ -49,7 +49,7 @@ describe Koala::Facebook::API::GraphCollection do
   describe "when getting a whole page" do
     before(:each) do
       @second_page = {
-        "data" => [:second, :page, :data],
+        "data" => ["second", "page", "data"],
         "paging" => {}
       }
       @base = double("base")
@@ -59,14 +59,14 @@ describe Koala::Facebook::API::GraphCollection do
 
     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(@api).to receive(:api).with(@base, @args, anything, anything).and_return(Koala::HTTPService::Response.new(200, @second_page.to_json, {}))
       expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(@second_page, @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(@api).to receive(:api).with(@base, @args, anything, anything).and_return(Koala::HTTPService::Response.new(200, @second_page.to_json, {}))
       expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
 
       expect(@collection.next_page).to eq(@page_of_results)