right_agent 2.0.8-x86-mingw32 → 2.1.0-x86-mingw32

data/spec/clients/base_retry_client_spec.rb

@@ -103,7 +103,7 @@ describe RightScale::BaseRetryClient do
 
     it "sets up for reconnect if not connected" do
       flexmock(RightScale::BalancedHttpClient).should_receive(:new).and_return(@http_client).once
-      e = RightScale::BalancedHttpClient::NotResponding.new(nil, RestExceptionMock.new(503))
+      e = RightScale::BalancedHttpClient::NotResponding.new(nil, RightScale::HttpExceptions.create(503))
       @http_client.should_receive(:check_health).and_raise(e)
       @log.should_receive(:error)
       flexmock(@client).should_receive(:enable_use).never
@@ -291,9 +291,9 @@ describe RightScale::BaseRetryClient do
     end
 
     it "sets state to :disconnected and logs if server not responding" do
-      e = RightScale::BalancedHttpClient::NotResponding.new("not responding", RestExceptionMock.new(503))
+      e = RightScale::BalancedHttpClient::NotResponding.new("not responding", RightScale::HttpExceptions.create(503))
       @http_client.should_receive(:check_health).and_raise(e).once
-      @log.should_receive(:error).with("Failed test health check", RestExceptionMock).once
+      @log.should_receive(:error).with("Failed test health check", RightScale::HttpException).once
       @client.send(:check_health).should == :disconnected
       @client.state.should == :disconnected
     end
@@ -490,7 +490,7 @@ describe RightScale::BaseRetryClient do
       context "when redirect" do
         [301, 302].each do |http_code|
           it "handles #{http_code} redirect" do
-            e = RestExceptionMock.new(http_code, "redirect")
+            e = RightScale::HttpExceptions.create(http_code, "redirect")
             flexmock(@client).should_receive(:handle_redirect).with(e, @type, @request_uuid).once
             @client.send(:handle_exception, e, @type, @request_uuid, @now, 1)
           end
@@ -498,27 +498,27 @@ describe RightScale::BaseRetryClient do
       end
 
       it "raises if unauthorized" do
-        e = RestExceptionMock.new(401, "unauthorized")
+        e = RightScale::HttpExceptions.create(401, "unauthorized")
         lambda { @client.send(:handle_exception, e, @type, @request_uuid, @now, 1) }.should \
             raise_error(RightScale::Exceptions::Unauthorized, "unauthorized")
       end
 
       it "notifies auth client and raises retryable if session expired" do
-        e = RestExceptionMock.new(403, "forbidden")
+        e = RightScale::HttpExceptions.create(403, "forbidden")
         lambda { @client.send(:handle_exception, e, @type, @request_uuid, @now, 1) }.should \
             raise_error(RightScale::Exceptions::RetryableError, "Authorization expired")
         @auth_client.expired_called.should be_true
       end
 
       it "handles retry with and updates request_uuid to distinguish for retry" do
-        e = RestExceptionMock.new(449, "retry with")
+        e = RightScale::HttpExceptions.create(449, "retry with")
         flexmock(@client).should_receive(:handle_retry_with).with(e, @type, @request_uuid, @now, 1).
             and_return("modified uuid").once
         @client.send(:handle_exception, e, @type, @request_uuid, @now, 1).should == "modified uuid"
       end
 
       it "handles internal server error" do
-        e = RestExceptionMock.new(500, "test internal error")
+        e = RightScale::HttpExceptions.create(500, "test internal error")
         lambda { @client.send(:handle_exception, e, @type, @request_uuid, @now, 1) }.should \
             raise_error(RightScale::Exceptions::InternalServerError, "test internal error")
       end
@@ -530,7 +530,7 @@ describe RightScale::BaseRetryClient do
       end
 
       it "causes other HTTP exceptions to be re-raised by returning nil" do
-        e = RestExceptionMock.new(400, "bad request")
+        e = RightScale::HttpExceptions.create(400, "bad request")
         @client.send(:handle_exception, e, @type, @request_uuid, @now, 1).should be_nil
       end
 
@@ -542,7 +542,7 @@ describe RightScale::BaseRetryClient do
     context :handle_redirect do
       it "initiates redirect by notifying auth client and raising retryable error" do
         location = "http://somewhere.com"
-        e = RestExceptionMock.new(301, "moved permanently", {:location => location})
+        e = RightScale::HttpExceptions.create(301, "moved permanently", {:location => location})
         @log.should_receive(:info).with(/Received REDIRECT/).once.ordered
         @log.should_receive(:info).with("Requesting auth client to handle redirect to #{location.inspect}").once.ordered
         lambda { @client.send(:handle_redirect, e, @type, @request_uuid) }.should \
@@ -551,7 +551,7 @@ describe RightScale::BaseRetryClient do
       end
 
       it "raises internal error if no redirect location is provided" do
-        e = RestExceptionMock.new(301, "moved permanently")
+        e = RightScale::HttpExceptions.create(301, "moved permanently")
         @log.should_receive(:info).with(/Received REDIRECT/).once
         lambda { @client.send(:handle_redirect, e, @type, @request_uuid) }.should \
             raise_error(RightScale::Exceptions::InternalServerError, "No redirect location provided")
@@ -560,10 +560,10 @@ describe RightScale::BaseRetryClient do
 
     context :handle_retry_with do
       before(:each) do
-        @exception = RestExceptionMock.new(449, "retry with")
+        @exception = RightScale::HttpExceptions.create(449, "retry with")
       end
 
-      it "sleeps for configured interval and does not raise if retry still viable" do
+      it "waits for configured interval and does not raise if retry still viable" do
         @log.should_receive(:error).with(/Retrying type request/).once
         flexmock(@client).should_receive(:sleep).with(4).once
         @client.send(:handle_retry_with, @exception, @type, @request_uuid, @now, 1)
@@ -598,13 +598,13 @@ describe RightScale::BaseRetryClient do
         @exception = RightScale::BalancedHttpClient::NotResponding.new("Server not responding")
       end
 
-      it "sleeps for configured interval and does not raise if retry still viable" do
+      it "waits for configured interval and does not raise if retry still viable" do
         @log.should_receive(:error).with(/Retrying type request/).once
         flexmock(@client).should_receive(:sleep).with(4).once
         @client.send(:handle_not_responding, @exception, @type, @request_uuid, @now, 1)
       end
 
-      it "changes sleep interval for successive retries" do
+      it "changes wait interval for successive retries" do
         @log.should_receive(:error).with(/Retrying type request/).once
         flexmock(@client).should_receive(:sleep).with(12).once
         @client.send(:handle_not_responding, @exception, @type, @request_uuid, @now, 2)
@@ -636,4 +636,20 @@ describe RightScale::BaseRetryClient do
       end
     end
   end
+
+  context :wait do
+    it "waits using timer if non-blocking enabled" do
+      @fiber = flexmock("fiber", :resume => true).by_default
+      flexmock(Fiber).should_receive(:current).and_return(@fiber)
+      flexmock(Fiber).should_receive(:yield).once
+      flexmock(EM).should_receive(:add_timer).with(1, Proc).and_yield.once
+      @client.init(:test, @auth_client, @options.merge(:non_blocking => true))
+      @client.send(:wait, 1).should be true
+    end
+
+    it " waits using sleep if non-blocking disabled" do
+      flexmock(@client).should_receive(:sleep).with(1).once
+      @client.send(:wait, 1).should be true
+    end
+  end
 end

data/spec/clients/blocking_client_spec.rb

@@ -0,0 +1,265 @@
+#--
+# Copyright (c) 2013-2014 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'right_agent', 'clients', 'blocking_client'))
+
+describe RightScale::BlockingClient do
+
+  include FlexMock::ArgumentTypes
+
+  before(:each) do
+    @log = flexmock(RightScale::Log)
+    @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @url = "http://my.com"
+    @urls = [@url]
+    @host = @url
+    @path = "/foo/bar"
+    @balancer = flexmock("balancer")
+    flexmock(RightSupport::Net::RequestBalancer).should_receive(:new).and_return(@balancer).by_default
+    @later = (@now = Time.now)
+    flexmock(Time).should_receive(:now).and_return { @later += 1 }
+  end
+
+  context :initialize do
+    before(:each) do
+      @options = {}
+      @client = RightScale::BlockingClient.new(@options)
+    end
+
+    it "does not initialize use of proxy if not defined in environment" do
+      flexmock(RestClient).should_receive(:proxy=).never
+      RightScale::BlockingClient.new(@options)
+    end
+
+    ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY'].each do |proxy|
+      context "when #{proxy} defined in environment" do
+        after(:each) do
+          ENV.delete(proxy)
+        end
+
+        it "initializes use of proxy" do
+          ENV[proxy] = "https://my.proxy.com"
+          flexmock(RestClient).should_receive(:proxy=).with("https://my.proxy.com").once
+          RightScale::BlockingClient.new(@options)
+        end
+
+        it "infers http scheme for proxy address" do
+          ENV[proxy] = "1.2.3.4"
+          flexmock(RestClient).should_receive(:proxy=).with("http://1.2.3.4").once
+          RightScale::BlockingClient.new(@options)
+        end
+      end
+    end
+
+    it "constructs health check proc" do
+      @client.health_check_proc.should be_a Proc
+    end
+
+    context "health check proc" do
+      before(:each) do
+        @http_client = flexmock("http client")
+        flexmock(RightSupport::Net::HTTPClient).should_receive(:new).and_return(@http_client).by_default
+      end
+
+      it "removes user and password from URL when checking health" do
+        @url = "http://111:secret@me.com"
+        @client = RightScale::BlockingClient.new(@options.merge(:health_check_path => "/health-check-me"))
+        flexmock(@client).should_receive(:request).with(:get, "", "http://me.com/health-check-me", {}, Hash).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "uses default path if none specified" do
+        @client = RightScale::BlockingClient.new(@options)
+        flexmock(@client).should_receive(:request).with(:get, "", "http://my.com/health-check", {}, Hash).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "appends health check path to any existing path" do
+        @url = "http://my.com/foo"
+        @client = RightScale::BlockingClient.new(@options)
+        flexmock(@client).should_receive(:request).with(:get, "", "http://my.com/foo/health-check", {}, Hash).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "uses fixed timeout values" do
+        @client = RightScale::BlockingClient.new(:open_timeout => 5, :request_timeout => 30)
+        flexmock(@client).should_receive(:request).with(:get, "", String, {}, {:open_timeout => 2, :timeout => 5}).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "sets API version if specified" do
+        @client = RightScale::BlockingClient.new(:api_version => "2.0")
+        flexmock(@client).should_receive(:request).with(:get, "", String, {}, hsh(:headers => {"X-API-Version" => "2.0"})).once
+        @client.health_check_proc.call(@url)
+      end
+    end
+  end
+
+  context :options do
+    before(:each) do
+      @options = {}
+      @verb = :get
+      @params = {}
+      @headers = {}
+      @client = RightScale::BlockingClient.new(@options)
+    end
+
+    it "sets default open and request timeouts" do
+      connect_options, request_options = @client.options(@verb, @path, @params, @headers, @options)
+      connect_options.should == {}
+      request_options[:open_timeout].should == RightScale::BalancedHttpClient::DEFAULT_OPEN_TIMEOUT
+      request_options[:timeout].should == RightScale::BalancedHttpClient::DEFAULT_REQUEST_TIMEOUT
+    end
+
+    it "sets specified open and request timeouts" do
+      @options = {:open_timeout => 1, :request_timeout => 2}
+      _, request_options = @client.options(@verb, @path, @params, @headers, @options)
+      request_options[:open_timeout].should == 1
+      request_options[:timeout].should == 2
+    end
+
+    it "sets request headers" do
+      @headers = {:some => "header"}
+      _, request_options = @client.options(@verb, @path, @params, @headers, @options)
+      request_options[:headers].should == @headers
+    end
+
+    [:get, :delete].each do |verb|
+      context "with #{verb.inspect}" do
+        it "uses form-encoded query option for parameters" do
+          @params = {:some => "data", :more => ["a", "b"]}
+          _, request_options = @client.options(verb, @path, @params, @headers, @options)
+          request_options[:query].should == "?some=data&more[]=a&more[]=b"
+          request_options[:payload].should be nil
+        end
+
+        it "omits query option if there are no parameters" do
+          _, request_options = @client.options(verb, @path, @params, @headers, @options)
+          request_options.has_key?(:query).should be false
+        end
+      end
+    end
+
+    [:post, :put].each do |verb|
+      context "with #{verb.inspect}" do
+        it "uses JSON-encoded payload options for parameters" do
+          @params = {:some => "data"}
+          _, request_options = @client.options(verb, @path, @params, @headers, @options)
+          request_options[:query].should be_nil
+          request_options[:payload].should == JSON.dump(@params)
+          request_options[:headers][:content_type].should == "application/json"
+        end
+      end
+    end
+  end
+
+  context "requesting" do
+    before(:each) do
+      @options = {}
+      @query = "?some=data&more[]=a&more[]=b"
+      @connect_options = {}
+      @request_options = {:open_timeout => 2, :request_timeout => 5, :headers => {:accept => "application/json"}, :query => @query}
+      @result = {"out" => 123}
+      @body = JSON.dump({:out => 123})
+      @headers = {:status => "200 OK"}
+      @response = flexmock("response", :code => 200, :body => @body, :headers => @headers).by_default
+      @http_client = flexmock("http client")
+      flexmock(RightSupport::Net::HTTPClient).should_receive(:new).and_return(@http_client).by_default
+      @client = RightScale::BlockingClient.new(@options)
+    end
+
+    context :request do
+      it "makes request" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@response).once
+        @client.request(:get, @path, @host, @connect_options, @request_options)
+        @request_options[:query].should be nil
+      end
+
+      it "processes response and returns result plus response code, body, and headers" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@response).once
+        result = @client.request(:get, @path, @host, @connect_options, @request_options)
+        result.should == [@result, 200, @body, @headers]
+      end
+
+      it "returns nil if response is nil" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(nil).once
+        result = @client.request(:get, @path, @host, @connect_options, @request_options)
+        result.should == [nil, nil, nil, nil]
+      end
+    end
+
+    context :poll do
+      before(:each) do
+        @stop_at = @later + 10
+        @connection = {:host => @host, :path => @path, :expires_at => @later}
+        @nil_response = flexmock("nil response", :code => 200, :body => "null", :headers => @headers).by_default
+      end
+
+      it "uses existing connection info to form url" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@response).once
+        @client.poll(@connection, @request_options, @stop_at)
+      end
+
+      it "makes request" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@response).once
+        result = @client.poll(@connection, @request_options, @stop_at)
+        result.should == [@result, 200, @body, @headers]
+      end
+
+      it "makes at least one request regardless of stop time" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@nil_response).once
+        result = @client.poll(@connection, @request_options, @now - 10)
+        result.should == [nil, 200, "null", @headers]
+      end
+
+      it "stops polling if there is a non-nil result" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@nil_response).once.ordered
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@response).once.ordered
+        result = @client.poll(@connection, @request_options, @stop_at)
+        result.should == [@result, 200, @body, @headers]
+      end
+
+      it "stops polling if there is a nil result but it is time to stop" do
+        @http_client.should_receive(:get).with(@host + @path + @query, @request_options).and_return(@nil_response).twice
+        result = @client.poll(@connection, @request_options, @later + 2)
+        result.should == [nil, 200, "null", @headers]
+      end
+    end
+
+    context :request_once do
+      it "makes request and returns results" do
+        @http_client.should_receive(:get).with(@url, @request_options).and_return(@response).once
+        result = @client.send(:request_once, :get, @url, @request_options)
+        result.should == [@result, 200, @body, @headers]
+      end
+
+      it "returns nil if response is nil" do
+        @http_client.should_receive(:get).with(@url, @request_options).and_return(nil).once
+        result = @client.send(:request_once, :get, @url, @request_options)
+        result.should == [nil, nil, nil, nil]
+      end
+    end
+  end
+end

data/spec/clients/non_blocking_client_spec.rb

@@ -0,0 +1,387 @@
+#--
+# Copyright (c) 2013-2014 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'right_agent', 'clients', 'non_blocking_client'))
+
+describe RightScale::NonBlockingClient do
+
+  include FlexMock::ArgumentTypes
+
+  before(:each) do
+    @log = flexmock(RightScale::Log)
+    @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @url = "http://my.com"
+    @urls = [@url]
+    @host = @url
+    @path = "/foo/bar"
+    @balancer = flexmock("balancer")
+    flexmock(RightSupport::Net::RequestBalancer).should_receive(:new).and_return(@balancer).by_default
+    @later = (@now = Time.now)
+    flexmock(Time).should_receive(:now).and_return { @later += 1 }
+  end
+
+  context :initialize do
+    before(:each) do
+      @options = {}
+      @client = RightScale::NonBlockingClient.new(@options)
+    end
+
+    it "does not initialize use of proxy if not defined in environment" do
+      @client.instance_variable_get(:@proxy).should be nil
+    end
+
+    ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY'].each do |proxy|
+      context "when #{proxy} defined in environment" do
+        after(:each) do
+          ENV.delete(proxy)
+        end
+
+        it "initializes use of proxy" do
+          ENV[proxy] = "https://my.proxy.com"
+          @client = RightScale::NonBlockingClient.new(@options)
+          @client.instance_variable_get(:@proxy).should == {:host => "my.proxy.com", :port => 443}
+        end
+
+        it "infers http scheme for proxy address" do
+          ENV[proxy] = "1.2.3.4"
+          @client = RightScale::NonBlockingClient.new(@options)
+          @client.instance_variable_get(:@proxy).should == {:host => "1.2.3.4", :port => 80}
+        end
+
+        it "applies user and password to proxy address if defined in proxy address" do
+          ENV[proxy] = "https://111:secret@my.proxy.com"
+          @client = RightScale::NonBlockingClient.new(@options)
+          @client.instance_variable_get(:@proxy).should == {:host => "my.proxy.com", :port => 443, :authorization => ["111", "secret"]}
+        end
+      end
+    end
+
+    it "constructs health check proc" do
+      @client.health_check_proc.should be_a Proc
+    end
+
+    context "health check proc" do
+      it "removes user and password from URL when checking health" do
+        @url = "http://111:secret@me.com"
+        @client = RightScale::NonBlockingClient.new(@options.merge(:health_check_path => "/health-check-me"))
+        flexmock(@client).should_receive(:request).with(:get, "", "http://me.com", Hash, {:path => "/health-check-me"}).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "uses default path if none specified" do
+        flexmock(@client).should_receive(:request).with(:get, "", @host, Hash, {:path => "/health-check"}).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "appends health check path to any existing path" do
+        @url = "http://my.com/foo"
+        flexmock(@client).should_receive(:request).with(:get, "", @host, Hash, {:path => "/foo/health-check"}).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "uses fixed timeout values" do
+        @client = RightScale::NonBlockingClient.new(@options.merge(:open_timeout => 5, :request_timeout => 30))
+        connect_options = {:connect_timeout => 2, :inactivity_timeout => 5}
+        flexmock(@client).should_receive(:request).with(:get, "", @host, connect_options, Hash).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "sets API version if specified" do
+        @client = RightScale::NonBlockingClient.new(@options.merge(:api_version => "2.0"))
+        request_options = {:path => "/health-check", :head => {"X-API-Version" => "2.0"}}
+        flexmock(@client).should_receive(:request).with(:get, "", @host, Hash, request_options).once
+        @client.health_check_proc.call(@url)
+      end
+
+      it "uses proxy if defined" do
+        ENV["HTTPS_PROXY"] = "https://my.proxy.com"
+        @client = RightScale::NonBlockingClient.new(@options)
+        connect_options = {:connect_timeout => 2, :inactivity_timeout => 5, :proxy => {:host => "my.proxy.com", :port => 443}}
+        flexmock(@client).should_receive(:request).with(:get, "", @host, connect_options, Hash).once
+        @client.health_check_proc.call(@url)
+        ENV.delete("HTTPS_PROXY")
+      end
+    end
+  end
+
+  context :options do
+    before(:each) do
+      @options = {}
+      @verb = :get
+      @params = {}
+      @headers = {}
+      @client = RightScale::NonBlockingClient.new(@options)
+    end
+
+    it "sets default open and request timeouts" do
+      connect_options, _ = @client.options(@verb, @path, @params, @headers, @options)
+      connect_options[:connect_timeout].should == RightScale::BalancedHttpClient::DEFAULT_OPEN_TIMEOUT
+      connect_options[:inactivity_timeout].should == RightScale::BalancedHttpClient::DEFAULT_REQUEST_TIMEOUT
+    end
+
+    it "sets specified open and request timeouts" do
+      @options = {:open_timeout => 1, :request_timeout => 2}
+      connect_options, _ = @client.options(@verb, @path, @params, @headers, @options)
+      connect_options[:connect_timeout].should == 1
+      connect_options[:inactivity_timeout].should == 2
+    end
+
+    it "uses poll timeout instead of request timeout if defined" do
+      @options = {:open_timeout => 1, :poll_timeout=> 2, :request_timeout => 3}
+      connect_options, _ = @client.options(:poll, @path, @params, @headers, @options)
+      connect_options[:connect_timeout].should == 1
+      connect_options[:inactivity_timeout].should == 2
+    end
+
+    it "does not uses poll timeout if defined but not polling" do
+      @options = {:open_timeout => 1, :poll_timeout=> 2, :request_timeout => 3}
+      connect_options, _ = @client.options(@verb, @path, @params, @headers, @options)
+      connect_options[:connect_timeout].should == 1
+      connect_options[:inactivity_timeout].should == 3
+    end
+
+    it "sets :keepalive if this is a poll request" do
+      _, request_options = @client.options(:poll, @path, @params, @headers, @options)
+      request_options[:keepalive].should be true
+    end
+
+    it "sets request headers" do
+      @headers = {:some => "header"}
+      _, request_options = @client.options(@verb, @path, @params, @headers, @options)
+      request_options[:head].should == @headers
+    end
+
+    it "sets :proxy if defined" do
+      ENV["HTTPS_PROXY"] = "https://my.proxy.com"
+      @client = RightScale::NonBlockingClient.new(@options)
+      connect_options, _ = @client.options(@verb, @path, @params, @headers, @options)
+      connect_options[:proxy].should == {:host => "my.proxy.com", :port => 443}
+      ENV.delete("HTTPS_PROXY")
+    end
+
+    [:get, :delete].each do |verb|
+      context "with #{verb.inspect}" do
+        it "appends form-encoded query option to path" do
+          @params = {:some => "data"}
+          _, request_options = @client.options(verb, @path, @params, @headers, @options)
+          request_options[:path].should == "/foo/bar?some=data"
+          request_options[:body].should be nil
+        end
+      end
+    end
+
+    [:post, :put].each do |verb|
+      context "with #{verb.inspect}" do
+        it "stores JSON-encoded parameters in body" do
+          @params = {:some => "data"}
+          _, request_options = @client.options(verb, @path, @params, @headers, @options)
+          request_options[:path].should == @path
+          request_options[:body].should == JSON.dump(@params)
+          request_options[:head][:content_type].should == "application/json"
+        end
+      end
+    end
+  end
+
+  context "requesting" do
+    before(:each) do
+      @options = {}
+      @connect_options = {:connect_timeout => 2, :inactivity_timeout => 5}
+      @request_options = {:path => @path, :head => {:accept => "application/json"}}
+      @result = {"out" => 123}
+      @body = JSON.dump({:out => 123})
+      @headers = EventMachine::HttpResponseHeader.new
+      @headers.http_status = 200
+      @headers["STATUS"] = "200 OK"
+      @beautified_headers = {:status => "200 OK"}
+      @response = flexmock("em http response", :response_header => @headers, :response => @body,
+                           :error => nil, :errback => true, :callback => true).by_default
+      @request = flexmock("em http request", :get => @response).by_default
+      flexmock(EM::HttpRequest).should_receive(:new).and_return(@request).by_default
+      @fiber = flexmock("fiber", :resume => true).by_default
+      flexmock(Fiber).should_receive(:current).and_return(@fiber)
+      flexmock(Fiber).should_receive(:yield).and_return([200, @body, @headers]).by_default
+      @client = RightScale::NonBlockingClient.new(@options)
+    end
+
+    context :request do
+      it "makes request" do
+        @response.should_receive(:callback).and_yield.once
+        @fiber.should_receive(:resume).with(200, @body, @headers).once
+        flexmock(EM::HttpRequest).should_receive(:new).with(@host, @connect_options).and_return(@request).once
+        @request.should_receive(:get).with(@request_options).and_return(@response).once
+        @client.request(:get, @path, @host, @connect_options, @request_options)
+        @client.connections[@path].should be nil
+      end
+
+      it "processes response and returns result plus response code, body, and headers" do
+        @response.should_receive(:callback).and_yield.once
+        @fiber.should_receive(:resume).with(200, @body, @headers).once
+        flexmock(EM::HttpRequest).should_receive(:new).with(@host, @connect_options).and_return(@request).once
+        result = @client.request(:get, @path, @host, @connect_options, @request_options)
+        result.should == [@result, 200, @body, @beautified_headers]
+      end
+
+      it "handles host value that has path" do
+        @response.should_receive(:callback).and_yield.once
+        @fiber.should_receive(:resume).with(200, @body, @headers).once
+        flexmock(EM::HttpRequest).should_receive(:new).with(@host, @connect_options).and_return(@request).once
+        @request.should_receive(:get).with(on { |a| a[:path] == "/api" + @path }).and_return(@response).once
+        @client.request(:get, @path, @host + "/api", @connect_options, @request_options)
+        @request_options[:path].should == "/api/foo/bar"
+      end
+
+      it "converts Errno::ETIMEDOUT error to 504" do
+        @headers.http_status = 504
+        @response.should_receive(:errback).and_yield.once
+        @response.should_receive(:error).and_return("Errno::ETIMEDOUT")
+        @fiber.should_receive(:resume).with(504, "Errno::ETIMEDOUT").once
+        flexmock(Fiber).should_receive(:yield).and_return([504, "Errno::ETIMEDOUT"]).once
+        flexmock(EM::HttpRequest).should_receive(:new).with(@host, @connect_options).and_return(@request).once
+        lambda { @client.request(:get, @path, @host, @connect_options, @request_options) }.
+            should raise_error(RightScale::HttpExceptions::GatewayTimeout)
+      end
+
+      it "stores the connection if keepalive enabled" do
+        @request_options.merge!(:keepalive => true)
+        flexmock(EM::HttpRequest).should_receive(:new).and_return(@request).once
+        @client.request(:get, @path, @host, @connect_options, @request_options)
+        @client.connections[@path].should == {:host => @host, :connection => @request, :expires_at => @later + 5}
+      end
+    end
+
+    context "polling" do
+      before(:each) do
+        @stop_at = @later + 10
+        @request_options.merge!(:keepalive => true)
+        @connection = {:host => @host, :connection => @request, :expires_at => @later}
+      end
+
+      context :poll do
+        before(:each) do
+          flexmock(Fiber).should_receive(:yield).and_return([200, @body, @headers]).once
+        end
+
+        it "polls using specified connection and returns result data" do
+          @request.should_receive(:get).with(@request_options).and_return(@response).once
+          result = @client.poll(@connection, @request_options, @stop_at)
+          result.should be_a Array
+          result[1].should == 200
+        end
+
+        it "handles host value that has path" do
+          @connection[:host] += "/api"
+          @request.should_receive(:get).with(on { |a| a[:path] == "/api" + @path }).and_return(@response).once
+          @client.poll(@connection, @request_options, @stop_at)
+        end
+
+        it "beautifies response headers" do
+          _, _, _, headers = @client.poll(@connection, @request_options, @stop_at)
+          headers.should == @beautified_headers
+        end
+
+        it "processes the response to get the result" do
+          result, _, _, _ = @client.poll(@connection, @request_options, @stop_at)
+          result.should == @result
+        end
+
+        it "updates the timeout in the connection" do
+          @client.poll(@connection, @request_options, @stop_at)
+          @connection[:expires_at].should == @later + 5
+        end
+      end
+
+      context :poll_again do
+        it "makes HTTP get request using specified connection" do
+          @client.send(:poll_again, @fiber, @request, @request_options, @stop_at).should be true
+        end
+
+        it "stops polling if there is a non-nil result" do
+          @response.should_receive(:callback).and_yield.once
+          @fiber.should_receive(:resume).with(200, @body, @headers).once
+          @client.send(:poll_again, @fiber, @request, @request_options, @stop_at).should be true
+        end
+
+        it "stops polling if the status code is not 200" do
+          @headers.http_status = 204
+          @response.should_receive(:callback).and_yield.once
+          @response.should_receive(:response).and_return(nil).once
+          @fiber.should_receive(:resume).with(204, nil, @headers).once
+          @client.send(:poll_again, @fiber, @request, @request_options, @stop_at).should be true
+        end
+
+        it "stops polling if it is time to" do
+          @response.should_receive(:callback).and_yield.once
+          @response.should_receive(:response).and_return(nil).once
+          @fiber.should_receive(:resume).with(200, nil, @headers).once
+          @client.send(:poll_again, @fiber, @request, @request_options, @later + 1).should be true
+        end
+
+        it "stops polling if there is an error" do
+          @response.should_receive(:error).and_return("some error").twice
+          @response.should_receive(:errback).and_yield.once
+          @fiber.should_receive(:resume).with(500, "some error").once
+          @client.send(:poll_again, @fiber, @request, @request_options, @stop_at).should be true
+        end
+
+        it "otherwise polls again" do
+          @response.should_receive(:callback).and_yield.twice
+          @response.should_receive(:response).and_return(nil).once.ordered
+          @response.should_receive(:response).and_return(@body).once.ordered
+          @fiber.should_receive(:resume).once
+          @client.send(:poll_again, @fiber, @request, @request_options, @later + 2).should be true
+        end
+
+        it "polls again for JSON-encoded nil result" do
+          @response.should_receive(:callback).and_yield.twice
+          @response.should_receive(:response).and_return("null").once.ordered
+          @response.should_receive(:response).and_return(@body).once.ordered
+          @fiber.should_receive(:resume).once
+          @client.send(:poll_again, @fiber, @request, @request_options, @later + 2).should be true
+        end
+      end
+    end
+  end
+
+  context :beautify_headers do
+    before(:each) do
+      @client = RightScale::NonBlockingClient.new(@options)
+    end
+
+    it "beautifies header keys" do
+      headers = {"SERVER" => "nginx/1.4.2", "DATE" => "Tue, 25 Mar 2014 22:19:52 GMT",
+                 "CONTENT_TYPE" => "application/json; charset=utf-8", "CONTENT_LENGTH" => "4", "CONNECTION" => "close",
+                 "STATUS" => "200 OK", "CACHE_CONTROL" => "private, max-age=0, must-revalidate", "X_RUNTIME" => "1", "SET_COOKIE" => ""}
+      result = @client.send(:beautify_headers, headers)
+      result.should == {:server => "nginx/1.4.2", :date => "Tue, 25 Mar 2014 22:19:52 GMT",
+                 :content_type => "application/json; charset=utf-8", :content_length => "4", :connection => "close",
+                 :status => "200 OK", :cache_control => "private, max-age=0, must-revalidate", :x_runtime => "1", :set_cookie => ""}
+    end
+
+    it "converts hyphenations to underscores" do
+      @client.send(:beautify_headers, {"NON-BLOCKING" => "yes"}).should == {:non_blocking => "yes"}
+    end
+  end
+end