koala 0.4 → 3.7.0

data/spec/cases/graph_api_spec.rb

@@ -0,0 +1,76 @@
+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
+
+  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} } }
+
+    # 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
+        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(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
+        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(
+          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)
+      end
+    end
+  end
+
+  context '#graph_call' do
+    describe "the appsecret_proof option" do
+      let(:path) { '/path' }
+
+      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).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)).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', {}).and_return(dummy_response)
+        @api.graph_call(path)
+      end
+    end
+  end
+end

data/spec/cases/graph_collection_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Koala::Facebook::API::GraphCollection do
+  let(:paging){ {"paging" => true} }
+
+  before(:each) do
+    @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::API::GraphCollection.new(@result, @api)
+  end
+
+  it "subclasses Array" do
+    expect(Koala::Facebook::API::GraphCollection.ancestors).to include(Array)
+  end
+
+  it "creates an array-like object" do
+    expect(Koala::Facebook::API::GraphCollection.new(@result, @api)).to be_an(Array)
+  end
+
+  it "contains the result data" do
+    @data["data"].each_with_index {|r, i| expect(@collection[i]).to eq(r)}
+  end
+
+  it "has a read-only paging attribute" do
+    expect(@collection.methods.map(&:to_sym)).to include(:paging)
+    expect(@collection.methods.map(&:to_sym)).not_to include(:paging=)
+  end
+
+  it "sets paging to results['paging']" do
+    expect(@collection.paging).to eq(@data["paging"])
+  end
+
+  it "sets summary to results['summary']" do
+    expect(@collection.summary).to eq(@data["summary"])
+  end
+
+  it "sets raw_response to the original results" do
+    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"],
+        "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(@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(@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
+
+    it "should return nil it there are no other pages" do
+      %w{next previous}.each do |this|
+        expect(@collection).to receive("#{this}_page_params".to_sym).and_return(nil)
+        expect(@collection.send("#{this}_page")).to eq(nil)
+      end
+    end
+  end
+
+  describe "when parsing page paramters" do
+    describe "#parse_page_url" do
+      it "should pass the url to the class method" do
+        url = double("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::API::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
+        expect(@collection.parse_page_url(double("url"))).to eq(parsed_content)
+      end
+    end
+
+    describe ".parse_page_url" do
+      it "should return the base as the first array entry" do
+        base = "url_path"
+        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::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::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::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 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::API::GraphCollection.evaluate(result, @api)).to eq(result)
+    end
+
+    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
+      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
+      body = {"data" => [], "paging" => {}}
+      result = Koala::HTTPService::Response.new(200, body.to_json, {})
+      expected = :foo
+      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
+
+  describe "#next_page" do
+    let(:paging){ {"next" => "http://example.com/abc?a=2&b=3"} }
+
+    it "should get next page" do
+      expect(@api).to receive(:get_page).with(["abc", {"a" => "2", "b" => "3"}])
+      @collection.next_page
+    end
+
+    it "should get next page with extra parameters" do
+      expect(@api).to receive(:get_page).with(["abc", {"a" => "2", "b" => "3", "c" => "4"}])
+      @collection.next_page("c" => "4")
+    end
+  end
+
+  describe "#previous_page" do
+    let(:paging){ {"previous" => "http://example.com/?a=2&b=3"} }
+
+    it "should get previous page" do
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3"}])
+      @collection.previous_page
+    end
+
+    it "should get previous page with extra parameters" do
+      expect(@api).to receive(:get_page).with(["", {"a" => "2", "b" => "3", "c" => "4"}])
+      @collection.previous_page("c" => "4")
+    end
+  end
+end

data/spec/cases/graph_error_checker_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+module Koala
+  module Facebook
+    RSpec.describe GraphErrorChecker do
+      it "defines a set of AUTHENTICATION_ERROR_CODES" do
+        expect(GraphErrorChecker::AUTHENTICATION_ERROR_CODES).to match_array([102, 190, 450, 452, 2500])
+      end
+
+      it "defines a set of DEBUG_HEADERS" do
+        expect(GraphErrorChecker::DEBUG_HEADERS).to match_array([
+          "x-fb-rev",
+          "x-fb-debug",
+          "x-fb-trace-id",
+          "x-business-use-case-usage",
+          "x-ad-account-usage",
+          "x-app-usage"
+        ])
+      end
+
+      describe "#error_if_appropriate" do
+        shared_examples_for :returning_no_error do |status|
+          it "returns no error" do
+            expect(GraphErrorChecker.new(status, "{}", {}).error_if_appropriate).to be_nil
+          end
+
+          it "ignores error data even if present" do
+            checker = GraphErrorChecker.new(
+              status,
+              {"error" => {"some" => "error"}},
+              {"x-fb-rev" => "data"}
+            )
+            expect(checker.error_if_appropriate).to be_nil
+          end
+        end
+
+        context "if the status is 2xx" do
+          it_should_behave_like :returning_no_error, 202
+        end
+
+        context "if the status is 3xx" do
+          it_should_behave_like :returning_no_error, 302
+        end
+
+        shared_examples_for :returns_an_error do |status|
+          let(:body) { "{}" }
+          let(:headers) { {} }
+          let(:error) { GraphErrorChecker.new(status, body, headers).error_if_appropriate }
+          it "returns a ClientError for a generic error" do
+            expect(error).to be_a(ClientError)
+            expect(error.response_body).to eq(body)
+          end
+
+          it "returns a ClientError even if the body can't be parsed as JSON" do
+            body.replace("hello from Chicago")
+            expect(error).to be_a(ClientError)
+            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",
+              "code" => "FB error code",
+              "error_subcode" => "FB error subcode",
+              "message" => "An error occurred!",
+              "error_user_msg" => "A user msg",
+              "error_user_title" => "usr title",
+              "fbtrace_id" => "fbtrace_id"
+            }
+            body.replace({"error" => error_data}.to_json)
+
+            expect(error.fb_error_trace_id).to eq(error_data["fbtrace_id"])
+            expect(error.fb_error_type).to eq(error_data["type"])
+            expect(error.fb_error_code).to eq(error_data["code"])
+            expect(error.fb_error_subcode).to eq(error_data["error_subcode"])
+            expect(error.fb_error_message).to eq(error_data["message"])
+            expect(error.fb_error_user_msg).to eq(error_data["error_user_msg"])
+            expect(error.fb_error_user_title).to eq(error_data["error_user_title"])
+          end
+
+          it "adds the FB debug headers to the errors" do
+            headers.merge!(
+              "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_debug_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: expected object key, got 'invalid:json}' at line 1 column 2 while parsing x-app-usage = {invalid:json}")
+            expect(error.fb_app_usage).to eq(nil)
+          end
+
+          context "it returns an AuthenticationError" do
+            it "if FB says it's an OAuthException and it has no code" do
+              body.replace({"error" => {"type" => "OAuthException"}}.to_json)
+              expect(error).to be_an(AuthenticationError)
+            end
+
+            GraphErrorChecker::AUTHENTICATION_ERROR_CODES.each do |error_code|
+              it "if FB says it's an OAuthException and it has code #{error_code}" do
+                body.replace({"error" => {"type" => "OAuthException", "code" => error_code}}.to_json)
+                expect(error).to be_an(AuthenticationError)
+              end
+            end
+          end
+
+          # Note: I'm not sure why this behavior was implemented, it may be incorrect. To
+          # investigate.
+          it "doesn't return an AuthenticationError if FB says it's an OAuthException but the code doesn't match" do
+            body.replace({"error" => {"type" => "OAuthException", "code" => 2499}}.to_json)
+            expect(error).to be_an(ClientError)
+          end
+        end
+
+        context "if the status is 4xx" do
+          it_should_behave_like :returns_an_error, 400
+        end
+      end
+    end
+  end
+end

data/spec/cases/http_service/request_spec.rb

@@ -0,0 +1,250 @@
+require "spec_helper"
+
+module Koala
+  module HTTPService
+    RSpec.describe Request do
+      let(:path) { "/foo" }
+      let(:args) { {"a" => 2, "b" => 3, "access_token" => "a_token"} }
+      let(:verb) { "get" }
+      let(:options) { {an: :option} }
+      let(:request) { Request.new(path: path, args: args, verb: verb, options: options) }
+
+      shared_context post: true do
+        let(:verb) { "post" }
+      end
+
+      shared_context delete: true do
+        let(:verb) { "delete" }
+      end
+
+      shared_context put: true do
+        let(:verb) { "put" }
+      end
+
+      it "raises an ArgumentError if no verb is supplied" do
+        expect { Request.new(path: path) }.to raise_exception(ArgumentError)
+      end
+
+      it "raises an ArgumentError if no path is supplied" do
+        expect { Request.new(verb: verb) }.to raise_exception(ArgumentError)
+      end
+
+      describe "#verb" do
+        it "returns get for get" do
+          expect(Request.new(path: path, verb: "get").verb).to eq("get")
+        end
+
+        it "returns post for post" do
+          expect(Request.new(path: path, verb: "post").verb).to eq("post")
+        end
+
+        it "returns post for put" do
+          expect(Request.new(path: path, verb: "put").verb).to eq("post")
+        end
+
+        it "returns post for delete" do
+          expect(Request.new(path: path, verb: "delete").verb).to eq("post")
+        end
+      end
+
+      describe "#path" do
+        context "if there's no API version" do
+          it "returns the path" do
+            expect(request.path).to eq(path)
+          end
+        end
+
+        context "if there's an API version" do
+          shared_examples_for :including_the_version do
+            it "prefixes the version appropriately when the path starts with /" do
+              expect(Request.new(path: "/foo", verb: "get", options: options).path).to eq("/#{version}/foo")
+            end
+
+            it "prefixes the version appropriately when the path doesn't start with /" do
+              expect(Request.new(path: "foo", verb: "get", options: options).path).to eq("/#{version}/foo")
+            end
+          end
+
+          context "set by Koala.config" do
+            let(:version) { "v2.7" }
+
+            before :each do
+              Koala.configure do |config|
+                config.api_version = version
+              end
+            end
+
+            it_should_behave_like :including_the_version
+          end
+
+          context "set in options" do
+            let(:version) { "v2.8" }
+
+            let(:options) { {api_version: version} }
+
+            it_should_behave_like :including_the_version
+          end
+
+          context "for versions without a ." do
+            let(:version) { "v21" }
+
+            let(:options) { {api_version: version} }
+
+            it_should_behave_like :including_the_version
+          end
+        end
+      end
+
+      describe "#post_args" do
+        it "returns {} for get" do
+          expect(request.post_args).to eq({})
+        end
+
+        it "returns args for post", :post do
+          expect(request.post_args).to eq(args)
+        end
+
+        it "returns args + method: delete for delete", :delete do
+          expect(request.post_args).to eq(args.merge(method: "delete"))
+        end
+
+        it "returns args + method: put for put", :put do
+          expect(request.post_args).to eq(args.merge(method: "put"))
+        end
+
+        it "turns any UploadableIOs to UploadIOs" do
+          # technically this is done for all requests, but you don't send GET requests with files
+          upload_io = double("UploadIO")
+          u = Koala::HTTPService::UploadableIO.new("/path/to/stuff", "img/jpg")
+          allow(u).to receive(:to_upload_io).and_return(upload_io)
+          request = Request.new(path: path, verb: "post", args: {an_upload: u})
+          expect(request.post_args[:an_upload]).to eq(upload_io)
+        end
+      end
+
+      describe "#json?" do
+        it "returns false if the option for JSON isn't set" do
+          expect(request).not_to be_json
+        end
+
+        context "if JSON is set" do
+          let(:options) { {format: :json} }
+
+          it "returns true if it is" do
+            expect(request).to be_json
+          end
+        end
+      end
+
+      describe "#options" do
+        it "returns the options provided" do
+          expect(request.options).to include(options)
+        end
+
+        it "merges in any global options" do
+          global_options = {some: :opts}
+          HTTPService.http_options = global_options
+          results = request.options
+          HTTPService.http_options = {}
+          expect(results).to include(global_options)
+        end
+
+        it "overwrites any global options with equivalent ones" do
+          options = {foo: :bar}
+          HTTPService.http_options = {foo: 2}
+          results = Request.new(path: path, args: args, verb: verb, options: options).options
+          HTTPService.http_options = {}
+          expect(results).to include(options)
+        end
+
+        describe "get parameters" do
+          it "includes the parameters for a get " do
+            expect(request.options[:params]).to eq(args)
+          end
+
+          it "returns {} for post", :post do
+            expect(request.options[:params]).to eq({})
+          end
+
+          it "returns {} for delete", :delete do
+            expect(request.options[:params]).to eq({})
+          end
+
+          it "returns {} for put", :put do
+            expect(request.options[:params]).to eq({})
+          end
+        end
+
+        describe "ssl options" do
+          it "includes the default SSL options even if there's no access token" do
+            request_options = Request.new(path: path, args: args.delete_if {|k, _v| k == "access_token"}, verb: verb, options: options).options
+            expect(request_options).to include(use_ssl: true, ssl: {verify: true})
+          end
+
+          context "if there is an access_token" do
+            it "includes the default SSL options" do
+              expect(request.options).to include(use_ssl: true, ssl: {verify: true})
+            end
+
+            it "incorporates any provided SSL options" do
+              new_ssl_options = {an: :option2}
+              request_options = Request.new(path: path, args: args, verb: verb, options: options.merge(ssl: new_ssl_options)).options
+              expect(request_options[:ssl]).to include(new_ssl_options)
+            end
+
+            it "overrides default SSL options with what's provided" do
+              new_ssl_options = {use_ssl: false, ssl:{verify: :dunno}}
+              request_options = Request.new(path: path, args: args, verb: verb, options: options.merge(new_ssl_options)).options
+              expect(request_options).to include(new_ssl_options)
+            end
+          end
+        end
+
+        describe "server" do
+          describe "with no options" do
+            it "returns the graph server by default" do
+              expect(request.server).to eq("https://graph.facebook.com")
+            end
+
+            it "uses another base server if specified" do
+              Koala.config.graph_server = "foo"
+              expect(request.server).to eq("https://foo")
+            end
+
+            context "if there is no access token" do
+              let(:args) { {"a" => "b"} }
+
+              it "uses https" do
+                expect(request.server).to eq("https://graph.facebook.com")
+              end
+            end
+
+            context "if options[:use_ssl] is false" do
+              let(:options) { {use_ssl: false} }
+
+              it "uses http" do
+                expect(request.server).to eq("http://graph.facebook.com")
+              end
+            end
+
+            context "if options[:beta]" do
+              let(:options) { {beta: true} }
+
+              it "returns https if options[:beta]" do
+                expect(request.server).to eq("https://graph.beta.facebook.com")
+              end
+            end
+
+            context "if options[:video]" do
+              let(:options) { {video: true} }
+
+              it "returns https if options[:video]" do
+                expect(request.server).to eq("https://graph-video.facebook.com")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cases/http_service/response_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+module Koala::HTTPService
+  RSpec.describe Response do
+    describe "#data" do
+      it "returns nothing if the body is empty" do
+        expect(Response.new(200, "", {}).data).to be_nil
+      end
+
+      it "parses the JSON if there's a body" do
+        result = {"foo" => "bar"}
+        expect(Response.new(200, result.to_json, {}).data).to eq(result)
+      end
+
+      it "allows raw values" do
+        expect(Response.new(200, "true", {}).data).to be true
+      end
+
+      it "raises a ParserError if it's invalid JSON" do
+        expect { Response.new(200, "{", {}).data }.to raise_exception(JSON::ParserError)
+      end
+    end
+  end
+end