koala 1.0.0 → 1.2.0

data/spec/cases/graph_collection_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Koala::Facebook::GraphCollection do
+  before(:each) do
+    @result = {
+      "data" => [1, 2, :three],
+      "paging" => {:paging => true}
+    }
+    @api = Koala::Facebook::API.new("123")
+    @collection = Koala::Facebook::GraphCollection.new(@result, @api)
+  end
+
+  it "subclasses Array" do
+    Koala::Facebook::GraphCollection.ancestors.should include(Array)
+  end
+  
+  it "creates an array-like object" do
+    Koala::Facebook::GraphCollection.new(@result, @api).should be_an(Array)
+  end
+  
+  it "contains the result data" do
+    @result["data"].each_with_index {|r, i| @collection[i].should == r}
+  end
+
+  it "has a read-only paging attribute" do
+    @collection.methods.map(&:to_sym).should include(:paging)
+    @collection.methods.map(&:to_sym).should_not include(:paging=)
+  end
+  
+  it "sets paging to results['paging']" do
+    @collection.paging.should == @result["paging"]
+  end
+  
+  it "sets raw_response to the original results" do
+    @collection.raw_response.should == @result
+  end
+  
+  it "sets the API to the provided API" do
+    @collection.api.should == @api
+  end
+    
+  describe "when getting a whole page" do
+    before(:each) do
+      @second_page = {
+        "data" => [:second, :page, :data],
+        "paging" => {}
+      }
+      @base = stub("base")
+      @args = stub("args")
+      @page_of_results = stub("page of results")
+    end
+
+    it "should return the previous page of results" do
+      @collection.should_receive(:previous_page_params).and_return([@base, @args])
+      @api.should_receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
+      Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      @collection.previous_page.should == @page_of_results
+    end
+
+    it "should return the next page of results" do
+      @collection.should_receive(:next_page_params).and_return([@base, @args])
+      @api.should_receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
+      Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
+
+      @collection.next_page.should == @page_of_results
+    end
+
+    it "should return nil it there are no other pages" do
+      %w{next previous}.each do |this|
+        @collection.should_receive("#{this}_page_params".to_sym).and_return(nil)
+        @collection.send("#{this}_page").should == nil
+      end
+    end
+  end
+
+  describe "when parsing page paramters" do
+    it "should return the base as the first array entry" do
+      base = "url_path"
+      @collection.parse_page_url("anything.com/#{base}?anything").first.should == base
+    end
+
+    it "should return the arguments as a hash as the last array entry" do
+      args_hash = {"one" => "val_one", "two" => "val_two"}
+      @collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+    end
+  end
+
+  describe "#evaluate" do
+    it "returns the original result if it's provided a non-hash result" do
+      result = []
+      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+    end
+    
+    it "returns the original result if it's provided a nil result" do
+      result = nil
+      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+    end
+    
+    it "returns the original result if the result doesn't have a data key" do
+      result = {"paging" => {}}
+      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+    end
+    
+    it "returns the original result if the result's data key isn't an array" do
+      result = {"data" => {}, "paging" => {}}
+      Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
+    end
+        
+    it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
+      result = {"data" => [], "paging" => {}}
+      expected = :foo
+      Koala::Facebook::GraphCollection.should_receive(:new).with(result, @api).and_return(expected)
+      Koala::Facebook::GraphCollection.evaluate(result, @api).should == expected
+    end
+  end
+end

data/spec/cases/http_service_spec.rb

@@ -0,0 +1,446 @@
+require 'spec_helper'
+
+describe "Koala::HTTPService" do
+  it "has a faraday_middleware accessor" do
+    Koala::HTTPService.methods.map(&:to_sym).should include(:faraday_middleware)
+    Koala::HTTPService.methods.map(&:to_sym).should include(:faraday_middleware=)
+  end
+
+  it "has an http_options accessor" do
+    Koala::HTTPService.should respond_to(:http_options)
+    Koala::HTTPService.should respond_to(:http_options=)
+  end
+  
+  it "sets http_options to {} by default" do
+    Koala::HTTPService.http_options.should == {}
+  end
+
+  describe "DEFAULT_MIDDLEWARE" do
+    before :each do
+      @builder = stub("Faraday connection builder")
+      @builder.stub(:request)
+      @builder.stub(:adapter)
+    end
+
+    it "is defined" do
+      Koala::HTTPService.const_defined?("DEFAULT_MIDDLEWARE").should be_true
+    end
+
+    it "adds multipart" do
+      @builder.should_receive(:request).with(:multipart)
+      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+
+    it "adds url_encoded" do
+      @builder.should_receive(:request).with(:url_encoded)
+      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+
+    it "uses the default adapter" do
+      adapter = :testing_now
+      Faraday.stub(:default_adapter).and_return(adapter)
+      @builder.should_receive(:adapter).with(adapter)
+      Koala::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+  end
+
+  describe "server" do
+    describe "with no options" do
+      it "returns the REST server if options[:rest_api]" do
+        Koala::HTTPService.server(:rest_api => true).should =~ Regexp.new(Koala::Facebook::REST_SERVER)
+      end
+
+      it "returns the graph server if !options[:rest_api]" do
+        Koala::HTTPService.server(:rest_api => false).should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER)
+        Koala::HTTPService.server({}).should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER)
+      end
+    end
+
+    describe "with options[:beta]" do
+      before :each do
+        @options = {:beta => true}
+      end
+
+      it "returns the beta REST server if options[:rest_api]" do
+        server = Koala::HTTPService.server(@options.merge(:rest_api => true))
+        server.should =~ Regexp.new("beta.#{Koala::Facebook::REST_SERVER}")
+      end
+
+      it "returns the beta rest server if !options[:rest_api]" do
+        server = Koala::HTTPService.server(@options)
+        server.should =~ Regexp.new("beta.#{Koala::Facebook::GRAPH_SERVER}")
+      end
+    end
+
+    describe "with options[:video]" do
+      before :each do
+        @options = {:video => true}
+      end
+
+      it "should return the REST video server if options[:rest_api]" do
+        server = Koala::HTTPService.server(@options.merge(:rest_api => true))
+        server.should =~ Regexp.new(Koala::Facebook::REST_SERVER.gsub(/\.facebook/, "-video.facebook"))
+      end
+
+      it "should return the graph video server if !options[:rest_api]" do
+        server = Koala::HTTPService.server(@options)
+        server.should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER.gsub(/\.facebook/, "-video.facebook"))
+      end
+    end
+  end
+
+  describe "#encode_params" do
+    it "should return an empty string if param_hash evaluates to false" do
+      Koala::HTTPService.encode_params(nil).should == ''
+    end
+
+    it "should convert values to JSON if the value is not a String" do
+      val = 'json_value'
+      not_a_string = 'not_a_string'
+      not_a_string.stub(:is_a?).and_return(false)
+      MultiJson.should_receive(:encode).with(not_a_string).and_return(val)
+
+      string = "hi"
+
+      args = {
+        not_a_string => not_a_string,
+        string => string
+      }
+
+      result = Koala::HTTPService.encode_params(args)
+      result.split('&').find do |key_and_val|
+        key_and_val.match("#{not_a_string}=#{val}")
+      end.should be_true
+    end
+
+    it "should escape all values" do
+      args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
+
+      result = Koala::HTTPService.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        val.should == CGI.escape(args[key])
+      end
+    end
+
+    it "should convert all keys to Strings" do
+      args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
+
+      result = Koala::HTTPService.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
+      end
+    end
+  end
+
+  describe "#make_request" do
+    before :each do
+      # Setup stubs for make_request to execute without exceptions
+      @mock_body = stub('Typhoeus response body')
+      @mock_headers_hash = stub({:value => "headers hash"})
+      @mock_http_response = stub("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
+
+      @mock_connection = stub("Faraday connection")
+      @mock_connection.stub(:get).and_return(@mock_http_response)
+      @mock_connection.stub(:post).and_return(@mock_http_response)
+      Faraday.stub(:new).and_return(@mock_connection)
+    end
+
+    describe "creating the Faraday connection" do
+      it "creates a Faraday connection using the server" do
+        server = "foo"
+        Koala::HTTPService.stub(:server).and_return(server)
+        Faraday.should_receive(:new).with(server, anything).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {}, "anything")
+      end
+
+      it "merges Koala::HTTPService.http_options into the request params" do
+        http_options = {:a => 2, :c => "3"}
+        Koala::HTTPService.http_options = http_options
+        Faraday.should_receive(:new).with(anything, hash_including(http_options)).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {}, "get")
+      end
+
+      it "merges any provided options into the request params" do
+        options = {:a => 2, :c => "3"}
+        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {}, "get", options)
+      end
+
+      it "overrides Koala::HTTPService.http_options with any provided options for the request params" do
+        options = {:a => 2, :c => "3"}
+        http_options = {:a => :a}
+        Koala::HTTPService.stub(:http_options).and_return(http_options)
+
+        Faraday.should_receive(:new).with(anything, hash_including(http_options.merge(options))).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {}, "get", options)
+      end
+      
+      it "forces use_ssl to true if an access token is present" do
+        options = {:use_ssl => false}
+        Koala::HTTPService.stub(:http_options).and_return(:use_ssl => false)
+        Faraday.should_receive(:new).with(anything, hash_including(:use_ssl => true)).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
+      end
+      
+      it "calls server with the composite options" do
+        options = {:a => 2, :c => "3"}
+        http_options = {:a => :a}
+        Koala::HTTPService.stub(:http_options).and_return(http_options)
+        Koala::HTTPService.should_receive(:server).with(hash_including(http_options.merge(options))).and_return("foo")
+        Koala::HTTPService.make_request("anything", {}, "get", options)        
+      end
+
+      it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
+        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)        
+        Faraday.should_receive(:new).with(anything, anything, &Koala::HTTPService::DEFAULT_MIDDLEWARE).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {}, "get")        
+      end
+      
+      it "uses the defined HTTPService.faraday_middleware block if defined" do
+        block = Proc.new { }
+        Koala::HTTPService.should_receive(:faraday_middleware).and_return(block)
+        Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {}, "get")        
+      end
+    end
+
+    it "makes a POST request if the verb isn't get" do
+      @mock_connection.should_receive(:post).and_return(@mock_http_response)
+      Koala::HTTPService.make_request("anything", {}, "anything")
+    end
+
+    it "includes the verb in the body if the verb isn't get" do
+      verb = "eat"
+      @mock_connection.should_receive(:post).with(anything, hash_including("method" => verb)).and_return(@mock_http_response)
+      Koala::HTTPService.make_request("anything", {}, verb)
+    end
+
+    it "makes a GET request if the verb is get" do
+      @mock_connection.should_receive(:get).and_return(@mock_http_response)
+      Koala::HTTPService.make_request("anything", {}, "get")
+    end
+
+    describe "for GETs" do
+      it "submits the arguments in the body" do
+        # technically this is done for all requests, but you don't send GET requests with files
+        args = {"a" => :b, "c" => 3}
+        Faraday.should_receive(:new).with(anything, hash_including(:params => args)).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", args, "get")
+      end
+
+      it "submits nothing to the body" do
+        # technically this is done for all requests, but you don't send GET requests with files
+        args = {"a" => :b, "c" => 3}
+        @mock_connection.should_receive(:get).with(anything, {}).and_return(@mock_http_response)
+        Koala::HTTPService.make_request("anything", args, "get")
+      end
+    end
+
+    describe "for POSTs" do
+      it "submits the arguments in the body" do
+        # technically this is done for all requests, but you don't send GET requests with files
+        args = {"a" => :b, "c" => 3}
+        @mock_connection.should_receive(:post).with(anything, hash_including(args)).and_return(@mock_http_response)
+        Koala::HTTPService.make_request("anything", args, "post")
+      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 = stub("UploadIO")
+        u = Koala::UploadableIO.new("/path/to/stuff", "img/jpg")
+        u.stub(:to_upload_io).and_return(upload_io)
+        @mock_connection.should_receive(:post).with(anything, hash_including("source" => upload_io)).and_return(@mock_http_response)
+        Koala::HTTPService.make_request("anything", {:source => u}, "post")
+      end
+    end
+  end
+
+  describe "deprecated options" do
+    before :each do
+      Koala::HTTPService.stub(:http_options).and_return({})
+      @service = Koala.http_service
+    end
+
+    after :each do
+      Koala.http_service = @service
+    end
+    
+    {
+      :timeout => :timeout,
+      :always_use_ssl => :use_ssl,
+      :proxy => :proxy 
+    }.each_pair do |deprecated_method, parameter|
+      describe "##{deprecated_method}" do
+        context "read" do
+          it "reads http_options[:#{parameter}]" do
+            value = "foo"
+            Koala::HTTPService.http_options[parameter] = value
+            Koala::HTTPService.send(deprecated_method).should == value
+          end
+      
+          it "generates a deprecation warning" do
+            Koala::Utils.should_receive(:deprecate)
+            Koala::HTTPService.send(deprecated_method)
+          end
+        end
+      
+        context "write" do
+          it "writes to http_options[:#{parameter}]" do
+            Koala::HTTPService.http_options[parameter] = nil
+            value = "foo"
+            Koala::HTTPService.send(:"#{deprecated_method}=", value)
+            Koala::HTTPService.http_options[parameter].should == value
+          end
+      
+          it "generates a deprecation warning" do
+            Koala::Utils.should_receive(:deprecate)
+            Koala::HTTPService.send(:"#{deprecated_method}=", 2)
+          end
+        end
+      end
+    end
+    
+    # ssl options
+    [:ca_path, :ca_file, :verify_mode].each do |deprecated_method|
+      describe "##{deprecated_method}" do
+        context "read" do
+          it "reads http_options[:ssl][:#{deprecated_method}] if http_options[:ssl]" do
+            value = "foo"
+            Koala::HTTPService.http_options[:ssl] = {deprecated_method => value}
+            Koala::HTTPService.send(deprecated_method).should == value
+          end
+      
+          it "returns nil if http_options[:ssl] is not defined" do
+            Koala::HTTPService.send(deprecated_method).should be_nil
+          end
+
+          it "generates a deprecation warning" do
+            Koala::Utils.should_receive(:deprecate)
+            Koala::HTTPService.send(deprecated_method)
+          end
+        end
+      
+        context "write" do      
+          it "defines http_options[:ssl] if not defined" do
+            Koala::HTTPService.http_options[:ssl] = nil
+            value = "foo"
+            Koala::HTTPService.send(:"#{deprecated_method}=", value)
+            Koala::HTTPService.http_options[:ssl].should
+          end
+
+          it "writes to http_options[:ssl][:#{deprecated_method}]" do
+            value = "foo"
+            Koala::HTTPService.send(:"#{deprecated_method}=", value)
+            Koala::HTTPService.http_options[:ssl].should
+            Koala::HTTPService.http_options[:ssl][deprecated_method].should == value
+          end
+          
+          it "does not redefine http_options[:ssl] if already defined" do
+            hash = {:a => 2}
+            Koala::HTTPService.http_options[:ssl] = hash
+            Koala::HTTPService.send(:"#{deprecated_method}=", 3)
+            Koala::HTTPService.http_options[:ssl].should include(hash)
+          end
+                
+          it "generates a deprecation warning" do
+            Koala::Utils.should_receive(:deprecate)
+            Koala::HTTPService.send(:"#{deprecated_method}=", 2)
+          end
+        end
+      end
+    end
+    
+    describe "per-request options" do
+      before :each do
+        # Setup stubs for make_request to execute without exceptions
+        @mock_body = stub('Typhoeus response body')
+        @mock_headers_hash = stub({:value => "headers hash"})
+        @mock_http_response = stub("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
+
+        @mock_connection = stub("Faraday connection")
+        @mock_connection.stub(:get).and_return(@mock_http_response)
+        @mock_connection.stub(:post).and_return(@mock_http_response)
+        Faraday.stub(:new).and_return(@mock_connection)
+      end
+      
+      describe ":typhoeus_options" do
+        it "merges any typhoeus_options into options" do
+          typhoeus_options = {:a => 2}
+          Faraday.should_receive(:new).with(anything, hash_including(typhoeus_options)).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)          
+        end
+        
+        it "deletes the typhoeus_options key" do
+          typhoeus_options = {:a => 2}
+          Faraday.should_receive(:new).with(anything, hash_not_including(:typhoeus_options => typhoeus_options)).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)          
+        end
+      end
+
+      describe ":ca_path" do
+        it "sets any ca_path into options[:ssl]" do
+          ca_path = :foo
+          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_path => ca_path))).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
+        end
+
+        it "deletes the ca_path key" do
+          ca_path = :foo
+          Faraday.should_receive(:new).with(anything, hash_not_including(:ca_path => ca_path)).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
+        end
+      end
+      
+      describe ":ca_file" do
+        it "sets any ca_file into options[:ssl]" do
+          ca_file = :foo
+          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_file => ca_file))).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
+        end
+
+        it "deletes the ca_file key" do
+          ca_file = :foo
+          Faraday.should_receive(:new).with(anything, hash_not_including(:ca_file => ca_file)).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
+        end
+      end
+      
+      describe ":verify_mode" do
+        it "sets any verify_mode into options[:ssl]" do
+          verify_mode = :foo
+          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:verify_mode => verify_mode))).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
+        end
+
+        it "deletes the verify_mode key" do
+          verify_mode = :foo
+          Faraday.should_receive(:new).with(anything, hash_not_including(:verify_mode => verify_mode)).and_return(@mock_connection)
+          Koala::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
+        end
+      end
+    end
+
+    {
+      :typhoeus => Koala::TyphoeusService, 
+      :net_http => Koala::NetHTTPService
+    }.each_pair do |adapter, module_class|
+      describe module_class.to_s do
+        it "should respond to deprecated_interface" do
+           module_class.should respond_to(:deprecated_interface)
+        end
+      
+        it "should issue a deprecation warning" do
+          Koala::Utils.should_receive(:deprecate)
+          module_class.deprecated_interface
+        end
+      
+        it "should set the default adapter to #{adapter}" do
+          module_class.deprecated_interface
+          Faraday.default_adapter.should == adapter
+        end
+      end
+    end
+  end
+end

data/spec/cases/koala_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe "Koala" do
+  it "has a version" do
+    Koala.const_defined?("VERSION").should be_true
+  end
+  
+  it "has an http_service accessor" do
+    Koala.should respond_to(:http_service)
+    Koala.should respond_to(:http_service=)
+  end
+  
+  context "for deprecated services" do
+    before :each do
+      @service = Koala.http_service
+    end
+    
+    after :each do
+      Koala.http_service = @service
+    end
+
+    it "invokes deprecated_interface if present" do
+      mock_service = stub("http service")
+      mock_service.should_receive(:deprecated_interface)
+      Koala.http_service = mock_service
+    end
+    
+    it "does not set the service if it's deprecated" do
+      mock_service = stub("http service")
+      mock_service.stub(:deprecated_interface)
+      Koala.http_service = mock_service
+      Koala.http_service.should == @service
+    end
+
+    it "sets the service if it's not deprecated" do
+      mock_service = stub("http service")
+      Koala.http_service = mock_service
+      Koala.http_service.should == mock_service
+    end
+  end
+
+  describe "make_request" do
+    it "passes all its arguments to the http_service" do
+      path = "foo"
+      args = {:a => 2}
+      verb = "get"
+      options = {:c => :d}
+      
+      Koala.http_service.should_receive(:make_request).with(path, args, verb, options)
+      Koala.make_request(path, args, verb, options)
+    end
+  end
+
+end