koala 2.5.0 → 3.0.0

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

@@ -54,6 +54,12 @@ 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 "adds error data from the body" do
             error_data = {
               "type" => "FB error type",
@@ -113,4 +119,3 @@ module Koala
     end
   end
 end
-

data/spec/cases/http_service/request_spec.rb

@@ -0,0 +1,242 @@
+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 "does nothing 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).not_to include(:ssl, :use_ssl)
+          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 = {verify: :dunno}
+              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
+          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 options[:use_ssl] is false (e.g. no access token)" do
+              let(:args) { {"a" => "b"} }
+
+              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