right_cloud_api_base 0.1.0

data/spec/routines/test_connection_proxy_spec.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright (c) 2013 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.dirname(__FILE__)) + "/../spec_helper"
+
+describe "RightScale::CloudApi::ConnectionProxy" do
+  before(:each) do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @connectionproxy = RightScale::CloudApi::ConnectionProxy.new
+    @test_data = {}
+    @test_data[:options] = {:cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new({:logger => logger})}
+    @test_data[:callbacks] = {}
+    @test_data[:response] = {}
+    allow(@connectionproxy).to receive(:log)
+  end
+
+  it "creates a close connection callback" do
+    proxy = double(:request => nil)
+    expect(RightScale::CloudApi::ConnectionProxy::NetHttpPersistentProxy).to receive(:new).and_return(proxy)
+    @connectionproxy.execute(@test_data)
+    expect(@test_data[:callbacks][:close_current_connection]).to be_a(Proc)
+  end
+end

data/spec/routines/test_request_analyzer_spec.rb

@@ -0,0 +1,106 @@
+#--
+# Copyright (c) 2013 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.dirname(__FILE__)) + "/../spec_helper"
+
+describe "RightScale::CloudApi::RequestAnalyzer" do
+  before(:each) do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @api_manager = RightScale::CloudApi::ApiManager.new({'x' => 'y'},'endpoint', {:logger => logger})
+    @api_manager.class.set_routine RightScale::CloudApi::RequestAnalyzer
+    @api_manager.class.options[:error_patterns] = []
+  end
+
+  context "request keys" do
+    before(:each) do
+      @valid_request_keys    = RightScale::CloudApi::RequestAnalyzer::REQUEST_KEYS.inject({}) { |result, k| result.merge(k  => k.to_s)}
+      @valid_request_actions = RightScale::CloudApi::RequestAnalyzer::REQUEST_ACTIONS
+    end
+    it "creates a pattern for expected keys" do
+      expected_result = []
+      @valid_request_actions.each do |action|
+        expected_result << @valid_request_keys.merge(:action => action)
+        expect(@api_manager.class.error_pattern(action, @valid_request_keys)).to eq expected_result
+      end
+    end
+  end
+
+  context "response keys" do
+    before(:each) do
+      @valid_response_keys    = RightScale::CloudApi::RequestAnalyzer::RESPONSE_KEYS.inject({}) { |result, k| result.merge(k  => k.to_s)}
+      @valid_response_actions = RightScale::CloudApi::RequestAnalyzer::RESPONSE_ACTIONS
+    end
+    it "creates a pattern for expected keys" do
+      expected_result = []
+      @valid_response_actions.each do |action|
+        expected_result << @valid_response_keys.merge(:action => action)
+        expect(@api_manager.class.error_pattern(action, @valid_response_keys)).to eq expected_result
+      end
+    end
+  end
+
+  context "with unexpected keys" do
+    it "fails to create a pattern" do
+      valid_request_action = :abort_on_timeout
+      expect { @api_manager.class.error_pattern(valid_request_action, {:bad_key => "BadKey"}) }.to raise_error(RightScale::CloudApi::RequestAnalyzer::Error)
+      expect { @api_manager.class.error_pattern(:bad_action, {:verb => /verb/}) }.to raise_error(RightScale::CloudApi::RequestAnalyzer::Error)
+      expect { @api_manager.class.error_pattern(valid_request_action, {:response => /verb/}) }.to raise_error(RightScale::CloudApi::RequestAnalyzer::Error)
+    end
+  end
+
+  context "process" do
+    before(:each) do
+      logger         = Logger.new(STDOUT)
+      logger.level   = Logger::INFO
+      error_patterns = [{:path   =>/Action=(Run|Create)/,
+                         :action =>:abort_on_timeout},
+                        {:response => /InternalError|Internal Server Error|internal service error/i,
+                         :action   => :retry}]
+      @data = {:request => {:instance    => 'some_instance',
+                            :verb        => 'some_verb',
+                            :orig_params => {}},
+               :options => {:error_patterns   => error_patterns,
+                            :cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new({:logger => logger,
+                                                                                           :log_filters => [:request_generator] })}}
+      @requestanalyzer = RightScale::CloudApi::RequestAnalyzer.new
+      allow(@requestanalyzer).to receive(:log)
+    end
+
+    context "when patern does not match" do
+      it "does not set :abort_on_timeout flag" do
+        expect(RightScale::CloudApi::Utils).to receive(:pattern_matches?).and_return(false)
+        @requestanalyzer.execute(@data)
+        expect(@data[:options].has_key?(:abort_on_timeout)).to be(false)
+      end
+    end
+
+    context "when patern matches" do
+      it "sets :abort_on_timeout flag" do
+        expect(RightScale::CloudApi::Utils).to receive(:pattern_matches?).and_return(true)
+        @requestanalyzer.execute(@data)
+        expect(@data[:options][:abort_on_timeout]).to be(true)
+      end
+    end
+  end
+end

data/spec/routines/test_response_analyzer_spec.rb

@@ -0,0 +1,132 @@
+#--
+# Copyright (c) 2013 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.dirname(__FILE__)) + "/../spec_helper"
+
+describe "RightScale::CloudApi::ResponseAnalyzer" do
+  before(:each) do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @responseanalyzer = RightScale::CloudApi::ResponseAnalyzer.new
+    @test_data = {}
+    @test_data[:request] = { :verb => 'some_verb', :orig_params => {}, :instance => 'some_request'}
+    @test_data[:vars]    = { :retry => {} }
+    @test_data[:options] = {:error_patterns => [], :cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new(
+        {:logger => logger, :log_filters => [:response_analyzer, :response_analyzer_body_error]})
+    }
+    @close_current_connection_callback = double
+    @test_data[:callbacks] = {:close_current_connection => @close_current_connection_callback}
+    @test_data[:connection] = {}
+    allow(@responseanalyzer).to receive(:log)
+  end
+
+  context "with no error patterns" do
+    it "fails on 5xx, 4xx errors" do
+      [500, 400].each do |http_error|
+        @test_data[:response] = {:instance => generate_http_response(http_error)}
+        expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::HttpError)
+      end
+    end
+    it "fails on redirect when there is no location tin the response" do
+      @test_data[:response] = {:instance => generate_http_response(300)}
+      expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::HttpError)
+    end
+    it "works for 2xx codes" do
+      @test_data[:response] = {:instance => generate_http_response(200)}
+      expect { @responseanalyzer.execute(@test_data) }.to_not raise_error
+    end
+  end
+
+  context "when retry is requested" do
+    before(:each) do
+      error_patterns = [{:action => :retry}]
+      @test_data[:options][:error_patterns] = error_patterns
+      allow(RightScale::CloudApi::Utils).to receive(:pattern_matches?).and_return(true)
+    end
+    it "raises a retry attempt exception for 4xx and 5xx errors" do
+      [500, 400].each do |http_error|
+        @test_data[:response] = {:instance => generate_http_response(http_error)}
+        expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::RetryAttempt)
+      end
+    end
+    it "fails when there is no location for 3xx redirect" do
+      response = generate_http_response(301, 'body', {'location' => ''})
+      @test_data[:response] = {:instance => response}
+      expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::HttpError)
+    end
+    it "raises a retry attempt exception when there is a location (in headers) for 3xx redirect" do
+      response = generate_http_response(301, 'body', {'location' => 'www.some-new-location.com'})
+      @test_data[:response] = {:instance => response}
+      expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::RetryAttempt)
+    end
+    it "raises a retry attempt exception when there is a location (in body) for 3xx redirect" do
+      response = generate_http_response(301, '<Endpoint> www.some-new-location.com </Endpoint>', {'location' => ''})
+      @test_data[:response] = {:instance => response}
+      uri_object = double(:host= => 'www.some-new-location.com', :to_s => 'www.some-new-location.com')
+      @test_data[:connection][:uri] = uri_object
+      expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::RetryAttempt)
+    end
+  end
+
+  context "when reconnect_and_retry is requested" do
+    before(:each) do
+      @test_data[:options][:error_patterns] = [{:action => :reconnect_and_retry}]
+      expect(RightScale::CloudApi::Utils).to receive(:pattern_matches?).at_least(1).and_return(true)
+      expect(@close_current_connection_callback).to receive(:call).twice.with(/Error code/)
+    end
+    it "raises a retry attempt exception for 4xx and 5xx errors" do
+      [500, 400].each do |http_error|
+        @test_data[:response] = {:instance => generate_http_response(http_error)}
+        expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::RetryAttempt)
+      end
+    end
+  end
+
+  context "when disconnect_and_abort is requested" do
+    before(:each) do
+      @test_data[:options][:error_patterns] = [{:action => :disconnect_and_abort}]
+      expect(RightScale::CloudApi::Utils).to receive(:pattern_matches?).at_least(1).and_return(true)
+      expect(@close_current_connection_callback).to receive(:call).twice.with(/Error code/)
+    end
+    it "failse for 4xx and 5xx errors" do
+      [500, 400].each do |http_error|
+        @test_data[:response] = {:instance => generate_http_response(http_error)}
+        expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::HttpError)
+      end
+    end
+  end
+
+  context "when abort is requested" do
+    before(:each) do
+      @test_data[:options][:error_patterns] = [{:action => :abort}]
+      expect(RightScale::CloudApi::Utils).to receive(:pattern_matches?).at_least(1).and_return(true)
+      expect(@close_current_connection_callback).to receive(:call).never
+    end
+    it "failse for 4xx and 5xx errors" do
+      [500, 400].each do |http_error|
+        @test_data[:response] = {:instance => generate_http_response(http_error)}
+        expect { @responseanalyzer.execute(@test_data) }.to raise_error(RightScale::CloudApi::HttpError)
+      end
+    end
+  end
+end

data/spec/routines/test_response_parser_spec.rb

@@ -0,0 +1,228 @@
+#--
+# Copyright (c) 2013 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.dirname(__FILE__)) + "/../spec_helper"
+
+
+describe "RightScale::CloudApi::ResponseParser" do
+  before :each do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @response_parser = RightScale::CloudApi::ResponseParser.new
+    @test_data = {}
+    @test_data[:request] = { :verb => 'some_verb', :orig_params => {}, :instance => 'some_request'}
+    @test_data[:options] = {:error_patterns => [], :cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new(
+        {:logger => logger, :log_filters => [:response_parser]})
+    }
+    @callback = double
+    @test_data[:callbacks] = {:close_current_connection => @callback}
+    @test_data[:connection] = {}
+    allow(@response_parser).to receive(:log)
+  end
+
+
+  context "encoding" do
+    context "text/xml;charset=UTF-8" do
+      before :each do
+        response = double(
+          :code                => '200',
+          :body                => 'body',
+          :headers             => {"content-type" => ["text/xml;charset=UTF-8"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        expect(RightScale::CloudApi::Parser::Sax).to receive(:parse).\
+          once.with('body', {:encoding => 'UTF-8'})
+      end
+
+      it "works" do
+        @response_parser.execute(@test_data)
+      end
+    end
+
+
+    context "text/xml;charset=utf-8" do
+      before :each do
+        response = double(
+          :code                => '200',
+          :body                => 'body',
+          :headers             => {"content-type" => ["text/xml;charset=utf-8"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        expect(RightScale::CloudApi::Parser::Sax).to receive(:parse).\
+          once.with('body', {:encoding => 'UTF-8'})
+      end
+
+      it "works" do
+        @response_parser.execute(@test_data)
+      end
+    end
+
+
+    context "text/xml;charset=ISO" do
+      before :each do
+        response = double(
+          :code                => '200',
+          :body                => 'body',
+          :headers             => {"content-type" => ["text/xml;charset=ISO"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        expect(RightScale::CloudApi::Parser::Sax).to receive(:parse).\
+          once.with('body', {})
+      end
+
+      it "works" do
+        @response_parser.execute(@test_data)
+      end
+    end
+
+
+    context "text/xml" do
+      before :each do
+        response = double(
+          :code                => '200',
+          :body                => 'body',
+          :headers             => {"content-type" => ["text/xml"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        expect(RightScale::CloudApi::Parser::Sax).to receive(:parse).\
+          once.with('body', {})
+      end
+
+      it "works" do
+        @response_parser.execute(@test_data)
+      end
+    end
+
+
+    context "text/json;charset=ISO" do
+      before :each do
+        response = double(
+          :code                => '200',
+          :body                => 'body',
+          :headers             => {"content-type" => ["text/json;charset=ISO"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        expect(RightScale::CloudApi::Parser::Json).to receive(:parse).\
+          once.with('body', {})
+      end
+
+      it "works" do
+        @response_parser.execute(@test_data)
+      end
+    end
+
+
+    context "text/json;charset=utf-8" do
+      before :each do
+        response = double(
+          :code                => '200',
+          :body                => 'body',
+          :headers             => {"content-type" => ["text/json;charset=utf-8"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        expect(RightScale::CloudApi::Parser::Json).to receive(:parse).\
+          once.with('body', {:encoding => 'UTF-8'})
+      end
+
+      it "works" do
+        @response_parser.execute(@test_data)
+      end
+    end
+  end
+
+
+  context "parsing" do
+    context "XML, default" do
+      before :each do
+        @expectation = {'xml' => { 'a' => '1' }}
+        response = double(
+          :code                => '200',
+          :body                => @expectation._to_xml,
+          :headers             => {"content-type" => ["text/xml"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+      end
+
+      it "returns parsed response" do
+        @response_parser.execute(@test_data)
+        result = @test_data[:result]
+        expect(result).to be_a(Hash)
+        expect(result).to eq(@expectation)
+      end
+    end
+
+
+    context "XML, do not parse flag is set" do
+      before :each do
+        @expectation = {'xml' => { 'a' => '1' }}
+        response = double(
+          :code                => '200',
+          :body                => @expectation._to_xml,
+          :headers             => {"content-type" => ["text/xml"]},
+          :is_io?              => false,
+          :is_error?           => true,
+          :body_info_for_log   => 'body',
+          :header_info_for_log => ""
+        )
+        @test_data[:response] = {:instance => response}
+        @test_data[:options][:raw_response] = true
+      end
+
+      it "returns raw response" do
+        @response_parser.execute(@test_data)
+        result = @test_data[:result]
+        expect(result).to be_a(String)
+        expect(result).to eq(@expectation._to_xml)
+      end
+    end
+
+  end
+end

data/spec/routines/test_result_wrapper_spec.rb

@@ -0,0 +1,63 @@
+#--
+# Copyright (c) 2013 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.dirname(__FILE__)) + "/../spec_helper"
+
+describe "RightScale::CloudApi::ResultWrapper" do
+  before (:each)   do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @resultwrapper = RightScale::CloudApi::ResultWrapper.new
+    @test_data = {}
+    @test_data[:options] = { :user_agent       => 'user_agent_data',
+                             :cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new({:logger => logger})}
+    @test_data[:vars] = {}
+    @test_data[:callbacks] = {}
+
+    @parsed_response    = "parsed_response"
+    @test_data[:result] = @parsed_response
+
+    @headers = { 'header1' => ['1'], 'header2' => ['2'] }
+    @response= generate_http_response(201, 'body', @headers)
+    @test_data[:response] = {:instance => @response, :parsed => @parsed_response }
+    allow(@resultwrapper).to receive(:log)
+    @test_data[:vars][:current_cache_key] = "cache_key"
+    @test_data[:vars][:cache] = {'cache_key' => { :key => 'old_cache_record_key', :record => 'haha' }}
+    @result = @resultwrapper.execute(@test_data)
+  end
+
+  context "metadata" do
+    it "looks like a parsed body object but responds to metadata" do
+      expect(@result).to eq 'parsed_response'
+      expect(@result).to be_a(String)
+      expect { @result.metadata }.to_not raise_error
+    end
+    it "contains the last respose headers and code" do
+      expect(@result.metadata[:headers]).to eq @headers
+      expect(@result.metadata[:code]).to eq @response.code
+    end
+    it "may contain the cache key" do
+      expect(@result.metadata[:cache]).to eq @test_data[:vars][:cache]
+    end
+  end
+end

data/spec/routines/test_retry_manager_spec.rb

@@ -0,0 +1,84 @@
+#--
+# Copyright (c) 2013 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.dirname(__FILE__)) + "/../spec_helper"
+
+describe "" do
+  before(:each) do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @retrymanager = RightScale::CloudApi::RetryManager.new
+    allow(@retrymanager).to receive(:log)
+    @request = double(:verb => 'get', :path => 'some/path', :body => 'body', :is_io? => false, :is_error? => false, :is_redirect? => false, :headers => {'header1' => 'val1', 'header2' => 'val2'})
+    @test_data = {
+      :options     => { :user_agent => 'user_agent_data',
+                        :cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new({}),
+                        :retry => {
+                          :count            => 2,
+                          :reiteration_time => 10,
+                          :sleep_time       => 0.2
+                        },
+                      },
+      :vars        => { :system => {:block => 'block', :started_at => Time.now}},
+      :credentials => {},
+      :callbacks   => {},
+      :connection  => {:uri => double(:host => 'host.com', :port => '777', :scheme => 'scheme')},
+      :request     => {:instance => @request}
+    }
+    @response   = double(:code => '200', :body => 'body', :to_hash => {:code => '200', :body => 'body'})
+    @connection = double(:request => @response)
+  end
+
+  context "RightScale::CloudApi::RetryManager" do
+    it "works" do
+      # 1st run
+      @retrymanager.execute(@test_data)
+      expect(@test_data[:vars][:retry][:count]).to eq 0
+      expect(@test_data[:vars][:retry][:sleep_time]).to eq 0.2
+
+      # 2nd run, +1 count *2 sleep
+      @retrymanager.execute(@test_data)
+      expect(@test_data[:vars][:retry][:count]).to eq 1
+      expect(@test_data[:vars][:retry][:sleep_time]).to eq 0.4
+
+      # 3rd run, +1 count, *2 sleep
+      @retrymanager.execute(@test_data)
+      expect(@test_data[:vars][:retry][:count]).to eq 2
+      expect(@test_data[:vars][:retry][:sleep_time]).to eq 0.8
+
+      #4th run, case 1: default error
+      default_rm_error = "RetryManager: No more retries left."
+      expect do
+        @retrymanager.execute(@test_data)
+      end.to raise_error(RightScale::CloudApi::RetryManager::Error, default_rm_error)
+
+      #4th run, case 2: cloud_error + default error
+      http_error  = 'Banana.'
+      expectation = "#{http_error}\n#{default_rm_error}"
+      @test_data[:vars][:retry][:http] = { :code => 777, :message => http_error }
+      expect do
+        @retrymanager.execute(@test_data)
+      end.to raise_error(RightScale::CloudApi::RetryManager::Error, expectation)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'right_cloud_api_base'
+require 'rspec'
+
+# Generates a fake response object.
+#
+# @param [String] code HTTP response code
+# @param [String] body HTTP response body
+# @param [Hash]   headers HTTP response code
+# @param [HttpResponse] raw HTTP response object
+#
+# @return [RightScale::CloudApi::HTTPResponse]
+#
+def generate_http_response(code, body='body', headers={}, raw=nil)
+  RightScale::CloudApi::HTTPResponse.new(code.to_s, body, headers, raw)
+end