active_rest_client 0.9.58

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe ActiveRestClient::Configuration do
+  before :each do
+    Object.send(:remove_const, :ConfigurationExample) if defined?(ConfigurationExample)
+    ActiveRestClient::Base._reset_configuration!
+
+    class ConfigurationExample
+      include ActiveRestClient::Configuration
+      base_url "http://www.example.com"
+    end
+
+    class ConfigurationExampleBare
+      include ActiveRestClient::Configuration
+    end
+  end
+
+  it "should default to non-whiny missing methods" do
+    class UnusuedConfigurationExample1
+      include ActiveRestClient::Configuration
+    end
+    expect(UnusuedConfigurationExample1.whiny_missing).to be_false
+  end
+
+  it "should allow whiny missing methods to be enabled" do
+    ConfigurationExample.whiny_missing true
+    expect(ConfigurationExample.whiny_missing).to be_true
+  end
+
+  it "should remember the set base_url" do
+    expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+  end
+
+  it "should remember the set base_url on a class, overriding a general one" do
+    ActiveRestClient::Base.base_url = "http://general.example.com"
+    expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+  end
+
+  it "should remove a trailing slash from a globally configured base_url" do
+    ActiveRestClient::Base.base_url = "http://general.example.com/"
+    expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+  end
+
+  it "should remember the set base_url on the base class if a more specific one hasn't been set" do
+    ActiveRestClient::Base.base_url = "http://general.example.com"
+    expect(ConfigurationExampleBare.base_url).to eq("http://general.example.com")
+  end
+
+  it "should remove a trailing slash from a specific class configured base_url" do
+    class ConfigurationExample2
+      include ActiveRestClient::Configuration
+      base_url "http://specific.example.com/"
+    end
+    expect(ConfigurationExample2.base_url).to eq("http://specific.example.com")
+  end
+
+  it "should default to non-lazy loading" do
+    class LazyLoadingConfigurationExample1
+      include ActiveRestClient::Configuration
+    end
+    expect(LazyLoadingConfigurationExample1.lazy_load?).to be_false
+  end
+
+  it "should be able to switch on lazy loading" do
+    class LazyLoadingConfigurationExample2
+      include ActiveRestClient::Configuration
+      lazy_load!
+    end
+    expect(LazyLoadingConfigurationExample2.lazy_load?).to be_true
+  end
+
+  it "should default to non-verbose loggingg" do
+    class VerboseConfigurationExample1
+      include ActiveRestClient::Configuration
+    end
+    expect(VerboseConfigurationExample1.verbose).to be_false
+  end
+
+  it "should be able to switch on verbose logging" do
+    class VerboseConfigurationExample2
+      include ActiveRestClient::Configuration
+      verbose!
+    end
+    class VerboseConfigurationExample3
+      include ActiveRestClient::Configuration
+      verbose true
+    end
+    expect(VerboseConfigurationExample2.verbose).to be_true
+    expect(VerboseConfigurationExample3.verbose).to be_true
+  end
+
+  it "should store a translator given" do
+    expect{ ConfigurationExample.send(:translator) }.to_not raise_error
+    ConfigurationExample.send(:translator, String)
+    expect{ ConfigurationExample.translator.respond_to?(:length) }.to be_true
+  end
+
+  it "should store a proxy given" do
+    expect{ ConfigurationExample.send(:proxy) }.to_not raise_error
+    ConfigurationExample.send(:proxy, String)
+    expect{ ConfigurationExample.proxy.respond_to?(:length) }.to be_true
+  end
+
+
+end

data/spec/lib/connection_manager_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe ActiveRestClient::ConnectionManager do
+  before(:each) do
+    ActiveRestClient::ConnectionManager.reset!
+  end
+
+  it "should have a get_connection method" do
+    expect(ActiveRestClient::ConnectionManager).to respond_to("get_connection")
+  end
+
+  it "should return a connection for a given base url" do
+    connection = ActiveRestClient::ConnectionManager.get_connection("http://www.example.com")
+    expect(connection).to be_kind_of(ActiveRestClient::Connection)
+  end
+
+  it "should return the same connection for each base url when re-requested" do
+    connection = ActiveRestClient::ConnectionManager.get_connection("http://www.example.com")
+    expect(ActiveRestClient::ConnectionManager.get_connection("http://www.example.com")).to eq(connection)
+  end
+
+  it "should return different connections for each base url when requested" do
+    base_url = "http://www.example.com"
+    other_base_url = "http://other.example.com"
+    expect(ActiveRestClient::ConnectionManager.get_connection(base_url).base_url).to eq(base_url)
+    expect(ActiveRestClient::ConnectionManager.get_connection(other_base_url).base_url).to eq(other_base_url)
+    expect(ActiveRestClient::ConnectionManager.instance_variable_get(:@_connections).size).to eq(2)
+  end
+
+  it "should find a connection if you pass in URLs containing an existing connection's base_url" do
+    base_url         = "http://www.example.com"
+    connection       = ActiveRestClient::ConnectionManager.get_connection(base_url)
+    found_connection = ActiveRestClient::ConnectionManager.find_connection_for_url("#{base_url}:8080/people/test")
+    expect(found_connection).to eq(connection)
+  end
+end

data/spec/lib/connection_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe ActiveRestClient::Connection do
+  before(:each) do
+    @connection = ActiveRestClient::Connection.new("http://www.example.com")
+  end
+
+  it "should contain a patron session" do
+    expect(@connection.session).to be_a_kind_of(Patron::Session)
+  end
+
+  it "should set the Base URL for Patron to be the one passed in" do
+    expect(@connection.session.base_url).to eq("http://www.example.com")
+  end
+
+  it "should set a user agent for the Patron session" do
+    expect(@connection.headers["User-Agent"]).to match(/^ActiveRestClient\/[0-9.]+$/)
+  end
+
+  it "should try to Keep-Alive Patron session connections" do
+    expect(@connection.headers["Connection"]).to match(/Keep-Alive/)
+  end
+
+  it "should pass a GET request through to Patron" do
+    @connection.session = double(Patron::Session)
+    @connection.session.stub(:get).with("/foo", {}).and_return(OpenStruct.new(body:"{result:true}"))
+    result = @connection.get("/foo")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should pass a PUT request through to Patron" do
+    @connection.session = double(Patron::Session)
+    @connection.session.stub(:put).with("/foo", "body", {}).and_return(OpenStruct.new(body:"{result:true}"))
+    result = @connection.put("/foo", "body")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should pass a POST request through to Patron" do
+    @connection.session = double(Patron::Session)
+    @connection.session.stub(:post).with("/foo", "body", {}).and_return(OpenStruct.new(body:"{result:true}"))
+    result = @connection.post("/foo", "body")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should pass a DELETE request through to Patron" do
+    @connection.session = double(Patron::Session)
+    @connection.session.stub(:delete).with("/foo", {}).and_return(OpenStruct.new(body:"{result:true}"))
+    result = @connection.delete("/foo")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should retry once in the event of a connection failed" do
+    @times_called = 0
+    Patron::Session.any_instance.stub(:get).and_return do
+      raise Patron::ConnectionFailed.new("Foo") if (@times_called += 1) == 1
+    end
+    expect { @connection.get("/foo") }.to_not raise_error
+  end
+
+  it "should not retry more than once in the event of a connection failed" do
+    @times_called = 0
+    Patron::Session.any_instance.stub(:get).and_return do
+      raise Patron::ConnectionFailed.new("Foo")
+    end
+    expect { @connection.get("/foo") }.to raise_error(ActiveRestClient::ConnectionFailedException)
+  end
+
+  it "should raise an exception on timeout" do
+    Patron::Session.any_instance.stub(:get).and_raise Patron::TimeoutError.new("Foo")
+    expect { @connection.get("/foo") }.to raise_error(ActiveRestClient::TimeoutException)
+  end
+
+end

data/spec/lib/headers_list_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ActiveRestClient::HeadersList do
+  let(:headers_list) { ActiveRestClient::HeadersList.new }
+
+  it "should remember stored headers" do
+    url = "http://www.google.com"
+    headers_list["X-My-Header"] = url
+    expect(headers_list["X-My-Header"]).to eq(url)
+  end
+
+  it "should remember overwrite normal headers" do
+    url = "http://www.google.com"
+    headers_list["X-My-Header"] = "SHOULD NEVER BE SEEN"
+    headers_list["X-My-Header"] = url
+    expect(headers_list["X-My-Header"]).to eq(url)
+  end
+
+  it "should append to specific headers, such as Set-cookie" do
+    headers_list["Set-Cookie"] = "first_value"
+    headers_list["Set-Cookie"] = "second_value"
+    expect(headers_list["Set-Cookie"]).to eq(%w{first_value second_value})
+  end
+
+  it "should not be case sensitive on header names when setting headers" do
+    url = "http://www.google.com"
+    headers_list["X-My-Header"] = "SHOULD NEVER BE SEEN"
+    headers_list["X-MY-HEADER"] = url
+    expect(headers_list["X-My-Header"]).to eq(url)
+  end
+
+  it "should not be case sensitive on header names when getting headers" do
+    url = "http://www.google.com"
+    headers_list["X-My-Header"] = url
+    expect(headers_list["X-MY-HEADER"]).to eq(url)
+  end
+
+  it "should allow iterating over headers set, by default with array items returned whole" do
+    headers_list["X-My-Header"] = "http://www.google.com"
+    headers_list["Set-Cookie"] = "first_value"
+    headers_list["SET-COOKIE"] = "second_value"
+    values = []
+    headers_list.each do |name, value|
+      values << "#{name}=#{value.to_s}"
+    end
+    expect(values.size).to eq(2)
+    expect(values).to eq(["X-My-Header=http://www.google.com", "Set-Cookie=[\"first_value\", \"second_value\"]"])
+  end
+
+  it "should allow iterating over headers set splitting array headers in to individual ones" do
+    headers_list["X-My-Header"] = "http://www.google.com"
+    headers_list["Set-Cookie"] = "first_value"
+    headers_list["SET-COOKIE"] = "second_value"
+    values = []
+    headers_list.each(true) do |name, value|
+      values << "#{name}=#{value.to_s}"
+    end
+    expect(values.size).to eq(3)
+    expect(values).to eq(["X-My-Header=http://www.google.com", "Set-Cookie=first_value", "Set-Cookie=second_value"])
+  end
+end

data/spec/lib/instrumentation_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class InstrumentationExampleClient < ActiveRestClient::Base
+  base_url "http://www.example.com"
+  get :fake, "/fake", fake:"{\"result\":true, \"list\":[1,2,3,{\"test\":true}], \"child\":{\"grandchild\":{\"test\":true}}}"
+  get :real, "/real"
+end
+
+describe ActiveRestClient::Instrumentation do
+  it "should save a load hook to include the instrumentation" do
+    hook_tester = double("HookTester")
+    hook_tester.should_receive(:include).with(ActiveRestClient::ControllerInstrumentation)
+    ActiveSupport.run_load_hooks(:action_controller, hook_tester)
+  end
+
+  it "should call ActiveSupport::Notifications.instrument when making any request" do
+    ActiveSupport::Notifications.should_receive(:instrument).with("request_call.active_rest_client", {:name=>"InstrumentationExampleClient#fake"})
+    InstrumentationExampleClient.fake
+  end
+
+  it "should call ActiveSupport::Notifications#request_call when making any request" do
+    ActiveRestClient::Instrumentation.any_instance.should_receive(:request_call).with(an_instance_of(ActiveSupport::Notifications::Event))
+    InstrumentationExampleClient.fake
+  end
+
+
+  it "should log time spent in each API call" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:get).
+      with("/real", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
+    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first[/ActiveRestClient.*ms\)/]}
+    ActiveRestClient::Logger.should_receive(:debug).at_least(:once).with(any_args)
+    InstrumentationExampleClient.real
+  end
+
+
+  it "should report the total time spent" do
+    # Create a couple of classes to fake being part of ActionController (that would normally call this method)
+    class InstrumentationTimeSpentExampleClientParent
+      def append_info_to_payload(payload) ; {} ; end
+      def self.log_process_action(payload) ; [] ; end
+    end
+
+    class InstrumentationTimeSpentExampleClient < InstrumentationTimeSpentExampleClientParent
+      include ActiveRestClient::ControllerInstrumentation
+
+      def test
+        payload = {}
+        append_info_to_payload(payload)
+        self.class.log_process_action(payload)
+      end
+    end
+
+    messages = InstrumentationTimeSpentExampleClient.new.test
+    expect(messages.first).to match(/ActiveRestClient.*ms.*call/)
+  end
+end

data/spec/lib/lazy_association_loader_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe ActiveRestClient::LazyAssociationLoader do
+  let(:url1) { "http://www.example.com/some/url" }
+  let(:url2) { "http://www.example.com/some/other" }
+  let(:calling_object) { o = double("Object").as_null_object }
+  let(:request) { ActiveRestClient::Request.new({:method => :get, url:"http://api.example.com/v1/foo"}, calling_object) }
+
+  it "should raise an exception if you initialize it with a value that is not a string, hash or array" do
+    expect do
+      ActiveRestClient::LazyAssociationLoader.new(:person, OpenStruct.new, nil)
+    end.to raise_error(ActiveRestClient::InvalidLazyAssociationContentException)
+  end
+
+  it "should store a URL passed as a string to the new object during creation" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, nil)
+    expect(loader.instance_variable_get(:@url)).to eq(url1)
+  end
+
+  it "should store a URL from a hash passed to the new object during creation" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, {"url" => url1}, nil)
+    expect(loader.instance_variable_get(:@url)).to eq(url1)
+  end
+
+  it "should store a list of URLs from an array passed to the new object during creation" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, [url1, url2], nil)
+    array = loader.instance_variable_get(:@subloaders)
+    expect(array[0].instance_variable_get(:@url)).to eq(url1)
+    expect(array[1].instance_variable_get(:@url)).to eq(url2)
+    expect(array[2]).to be_nil
+  end
+
+  it "should store a hash of URLs from a hash passed to the new object during creation" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, {"main" => url1, "thumb" => url2}, request)
+    expect(loader.main.instance_variable_get(:@url)).to eq(url1)
+    expect(loader.thumb.instance_variable_get(:@url)).to eq(url2)
+    expect(loader.size).to eq(2)
+  end
+
+  it "should still be able to iterate over a hash of URLs from a hash passed to the new object during creation" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, {"main" => url1, "thumb" => url2}, request)
+    output = []
+    loader.each do |k, v|
+      output << v.instance_variable_get(:@url)
+    end
+    expect(output.size).to eq(2)
+    expect(output[0]).to eq(url1)
+    expect(output[1]).to eq(url2)
+    expect(output[2]).to be_nil
+  end
+
+  it "should be able to list the keys from a hash passed to the new object during creation" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, {"main" => url1, "thumb" => url2}, request)
+    expect(loader.keys[0]).to eq(:main)
+    expect(loader.keys[1]).to eq(:thumb)
+    expect(loader.keys.size).to eq(2)
+  end
+
+  it "should report the size of a list of stored URLs" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, [url1, url2], nil)
+    expect(loader.size).to eq(2)
+  end
+
+  it "should respond to each and iterate through the list of stored URLs" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, [url1, url2], nil)
+    output = []
+    loader.each do |o|
+      output << o.instance_variable_get(:@url)
+    end
+    expect(output.size).to eq(2)
+    expect(output[0]).to eq(url1)
+    expect(output[1]).to eq(url2)
+    expect(output[2]).to be_nil
+  end
+
+  it "should return a LazyAssociationLoader for each stored URL in a list" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, [url1, url2], nil)
+    output = []
+    loader.each do |o|
+      expect(o).to be_an_instance_of(ActiveRestClient::LazyAssociationLoader)
+    end
+  end
+
+  it "should make the request for a URL if it's accessed" do
+    method_data = {options:{url:"foo"}}
+    request = double("Request").as_null_object
+    request.stub(:method).and_return(method_data)
+    request.should_receive(:object).with(any_args).and_return(Array.new)
+    request.should_receive(:call).with(any_args).and_return("")
+    ActiveRestClient::Request.should_receive(:new).with(any_args).and_return(request)
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
+    loader.length
+  end
+
+  it "should proxy methods to the underlying object if the request has been made" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
+    object = double("Object")
+    object.should_receive(:length).and_return(1)
+    loader.instance_variable_set(:@object, object)
+    expect(loader.length).to eq(1)
+  end
+
+  it "should be able to iterate underlying object if it's an array" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
+    ActiveRestClient::Request.any_instance.should_receive(:call).with(any_args).and_return([1,2,3])
+    test = []
+    loader.each do |item|
+      test << item
+    end
+    expect(test).to eq([1,2,3])
+  end
+
+  it "should be able to return the size of the underlying object if it's an array" do
+    loader = ActiveRestClient::LazyAssociationLoader.new(:person, url1, request)
+    ActiveRestClient::Request.any_instance.should_receive(:call).with(any_args).and_return([1,2,3])
+    expect(loader.size).to eq(3)
+  end
+end