flexirest 1.2.0

data/spec/lib/connection_manager_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Flexirest::ConnectionManager do
+  before(:each) do
+    Flexirest::ConnectionManager.reset!
+  end
+
+  it "should have a get_connection method" do
+    expect(Flexirest::ConnectionManager).to respond_to("get_connection")
+  end
+
+  it "should return a connection for a given base url" do
+    connection = Flexirest::ConnectionManager.get_connection("http://www.example.com")
+    expect(connection).to be_kind_of(Flexirest::Connection)
+  end
+
+  it "should return the same connection for each base url when re-requested" do
+    connection = Flexirest::ConnectionManager.get_connection("http://www.example.com")
+    expect(Flexirest::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(Flexirest::ConnectionManager.get_connection(base_url).base_url).to eq(base_url)
+    expect(Flexirest::ConnectionManager.get_connection(other_base_url).base_url).to eq(other_base_url)
+    expect(Thread.current[:_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       = Flexirest::ConnectionManager.get_connection(base_url)
+    found_connection = Flexirest::ConnectionManager.find_connection_for_url("#{base_url}:8080/people/test")
+    expect(found_connection).to eq(connection)
+  end
+
+  it "should call 'in_parllel' for a session and yield procedure inside that block" do
+    Flexirest::Base.adapter = :typhoeus
+    session = Flexirest::ConnectionManager.get_connection("http://www.example.com").session
+    expect { |b| Flexirest::ConnectionManager.in_parallel("http://www.example.com", &b)}.to yield_control
+    Flexirest::Base._reset_configuration!
+  end
+end

data/spec/lib/connection_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe Flexirest::Connection do
+  before do
+    @connection = Flexirest::Connection.new("http://www.example.com")
+  end
+
+  after do
+    Flexirest::Base._reset_configuration!
+    @connection.reconnect
+  end
+
+  it "should contain a Farday connection" do
+    expect(@connection.session).to be_a_kind_of(Faraday::Connection)
+  end
+
+  it "should set the Base URL to be the one passed in" do
+    expect(@connection.session.url_prefix.to_s).to eq("http://www.example.com/")
+  end
+
+  it "should set a user agent for the session" do
+    expect(@connection.headers["User-Agent"]).to match(/^Flexirest\/[0-9.]+$/)
+  end
+
+  it "should try to Keep-Alive session connections" do
+    expect(@connection.headers["Connection"]).to match(/Keep-Alive/)
+  end
+
+  it "should pass a GET request through to Faraday" do
+    stub_request(:get, "www.example.com/foo").to_return(body: "{result:true}")
+    result = @connection.get("/foo")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should pass a PUT request through to Faraday" do
+    stub_request(:put, "www.example.com/foo").with(body: "body").to_return(body: "{result:true}")
+    result = @connection.put("/foo", "body")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should pass a POST request through to Faraday" do
+    stub_request(:post, "www.example.com/foo").with(body: "body").to_return(body: "{result:true}")
+    result = @connection.post("/foo", "body")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  it "should pass a DELETE request through to Faraday" do
+    stub_request(:delete, "www.example.com/foo").to_return(body: "{result:true}")
+    result = @connection.delete("/foo")
+    expect(result.body).to eq("{result:true}")
+  end
+
+  describe "with default Faraday headers" do
+    before do
+      @default_headers = { "User-Agent" => "Custom" }
+
+      Flexirest::Base.faraday_config do |faraday|
+        faraday.adapter Flexirest::Base.adapter
+        faraday.headers.update(@default_headers)
+      end
+      @connection.reconnect
+    end
+
+    it "should pass a GET request through to Faraday preserving headers" do
+      stub_request(:get, "www.example.com/foo").
+        with(:headers => @default_headers).
+        to_return(body: "{result:true}")
+
+      result = @connection.get("/foo")
+      expect(result.body).to eq("{result:true}")
+    end
+
+    it "should pass a PUT request through to Faraday" do
+      stub_request(:put, "www.example.com/foo").
+        with(body: "body").
+        to_return(body: "{result:true}", :headers => @default_headers)
+
+      result = @connection.put("/foo", "body")
+      expect(result.body).to eq("{result:true}")
+    end
+
+    it "should pass a POST request through to Faraday" do
+      stub_request(:post, "www.example.com/foo").
+        with(body: "body", :headers => @default_headers).
+        to_return(body: "{result:true}")
+
+      result = @connection.post("/foo", "body")
+      expect(result.body).to eq("{result:true}")
+    end
+
+    it "should pass a DELETE request through to Faraday" do
+      stub_request(:delete, "www.example.com/foo").
+        with(:headers => @default_headers).
+        to_return(body: "{result:true}")
+
+      result = @connection.delete("/foo")
+      expect(result.body).to eq("{result:true}")
+    end
+  end
+
+  context 'with api auth signing requests' do
+    before(:each) do
+      # Need to still call this to load the api_auth library so tests work
+      Flexirest::Base.api_auth_credentials('id123', 'secret123')
+
+      @options = {
+        :api_auth => {
+          :api_auth_access_id => 'id123',
+          :api_auth_secret_key => 'secret123'
+        }
+      }
+
+      @default_headers = {'Date' => 'Sat, 14 Mar 2015 15:13:24 GMT'}
+
+      Flexirest::Base.faraday_config do |faraday|
+        faraday.adapter Flexirest::Base.adapter
+        faraday.headers.update(@default_headers)
+      end
+      @connection.reconnect
+    end
+
+    it 'should have an Authorization header' do
+      stub_request(:get, "www.example.com/foo")
+        .with(:headers => @default_headers)
+        .to_return(body: "{result:true}")
+      result = @connection.get("/foo", @options)
+      expect(result.env.request_headers['Authorization']).to eq("APIAuth id123:PMWBThkB8vKbvUccHvoqu9G3eVk=")
+    end
+
+    it 'should have an Content-MD5 header' do
+      stub_request(:put, "www.example.com/foo").
+        with(body: "body", :headers => @default_headers).
+        to_return(body: "{result:true}")
+
+      result = @connection.put("/foo", "body", @options)
+      expect(result.env.request_headers['Content-MD5']).to eq("hBotaJrYa9FhFEdFPCLG/A==")
+    end
+  end
+
+  it "should retry once in the event of a connection failed" do
+    stub_request(:get, "www.example.com/foo").to_raise(Faraday::Error::ConnectionFailed.new("Foo"))
+    expect { @connection.get("/foo") }.to raise_error(Flexirest::ConnectionFailedException)
+  end
+
+  it "should raise an exception on timeout" do
+    stub_request(:get, "www.example.com/foo").to_timeout
+    expect { @connection.get("/foo") }.to raise_error(Flexirest::TimeoutException)
+  end
+
+  it "should raise an exception on timeout" do
+    stub_request(:get, "www.example.com/foo").to_timeout
+    begin
+      @connection.get("foo")
+      fail
+    rescue Flexirest::TimeoutException => timeout
+      expect(timeout.message).to eq("Timed out getting http://www.example.com/foo")
+    end
+  end
+end

data/spec/lib/headers_list_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Flexirest::HeadersList do
+  let(:headers_list) { Flexirest::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,58 @@
+require 'spec_helper'
+
+class InstrumentationExampleClient < Flexirest::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 Flexirest::Instrumentation do
+  it "should save a load hook to include the instrumentation" do
+    hook_tester = double("HookTester")
+    expect(hook_tester).to receive(:include).with(Flexirest::ControllerInstrumentation)
+    ActiveSupport.run_load_hooks(:action_controller, hook_tester)
+  end
+
+  it "should call ActiveSupport::Notifications.instrument when making any request" do
+    expect(ActiveSupport::Notifications).to receive(:instrument).with("request_call.flexirest", {:name=>"InstrumentationExampleClient#fake"})
+    InstrumentationExampleClient.fake
+  end
+
+  it "should call ActiveSupport::Notifications#request_call when making any request" do
+    expect_any_instance_of(Flexirest::Instrumentation).to receive(:request_call).with(an_instance_of(ActiveSupport::Notifications::Event))
+    InstrumentationExampleClient.fake
+  end
+
+
+  it "should log time spent in each API call" do
+    expect_any_instance_of(Flexirest::Connection).
+      to receive(:get).
+      with("/real", an_instance_of(Hash)).
+      and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", response_headers:{}, status:200)))
+    expect(Flexirest::Logger).to receive(:debug).with(/Flexirest.*ms\)/)
+    expect(Flexirest::Logger).to 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 Flexirest::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(/Flexirest.*ms.*call/)
+  end
+end

data/spec/lib/lazy_association_loader_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+class MonthExample < Flexirest::Base
+  base_url "http://www.example.com"
+
+  get :find, "/month/:id", fake:"{\"name\":\"january\"}"
+end
+
+class YearExample < Flexirest::Base
+  base_url "http://www.example.com"
+
+  get :find, "/year/:id", lazy: { months: MonthExample }, fake: "{\"months\": [\"http://www.example.com/months/1\"] }"
+end
+
+describe Flexirest::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) { Flexirest::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
+      Flexirest::LazyAssociationLoader.new(:person, OpenStruct.new, nil)
+    end.to raise_error(Flexirest::InvalidLazyAssociationContentException)
+  end
+
+  it "should store a URL passed as a string to the new object during creation" do
+    loader = Flexirest::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 = Flexirest::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 = Flexirest::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 = Flexirest::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 = Flexirest::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 = Flexirest::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 = Flexirest::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 = Flexirest::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 = Flexirest::LazyAssociationLoader.new(:person, [url1, url2], nil)
+    output = []
+    loader.each do |o|
+      expect(o).to be_an_instance_of(Flexirest::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
+    allow(request).to receive(:method).and_return(method_data)
+    expect(request).to receive(:object).with(any_args).and_return(Array.new)
+    expect(request).to receive(:call).with(any_args).and_return("")
+    expect(Flexirest::Request).to receive(:new).with(any_args).and_return(request)
+    loader = Flexirest::LazyAssociationLoader.new(:person, url1, request)
+    loader.length
+  end
+
+  it "should proxy methods to the underlying object if the request has been made" do
+    loader = Flexirest::LazyAssociationLoader.new(:person, url1, request)
+    object = double("Object")
+    expect(object).to 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 = Flexirest::LazyAssociationLoader.new(:person, url1, request)
+    expect_any_instance_of(Flexirest::Request).to 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 = Flexirest::LazyAssociationLoader.new(:person, url1, request)
+    expect_any_instance_of(Flexirest::Request).to receive(:call).with(any_args).and_return([1,2,3])
+    expect(loader.size).to eq(3)
+  end
+
+  it "should use the class specified in the 'lazy' declaration to parse the response rather than the class of the object the lazy loader is attached to" do
+    association = YearExample.find(1)
+    expect(association.months.instance_variable_get('@request').instance_variable_get('@object').class).to eq(MonthExample)
+  end
+end