right_cloud_api_base 0.1.0

data/spec/helpers/support_xml_spec.rb

@@ -0,0 +1,207 @@
+#--
+# 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 "support_xml.rb" do
+
+  # --- Object ---
+
+  context "Object#_xml_escale" do
+    it "escapes non-xml symbols" do
+      expect("Hello <'world'> & \"the Universe\""._xml_escape).to eq(
+        "Hello &lt;&apos;world&apos;&gt; &amp; &quot;the Universe&quot;"
+      )
+    end
+  end
+
+  context "Object#_xml_unescale" do
+    it "unescapes non-xml symbols" do
+      expect("Hello &lt;&apos;world&apos;&gt; &amp; &quot;the Universe&quot;"._xml_unescape).to eq(
+        "Hello <'world'> & \"the Universe\""
+      )
+    end
+  end
+
+  context "Object#_to_xml" do
+    it "returns a simple XML string" do
+      expect("hahaha"._to_xml).to eq 'hahaha'
+    end
+  end
+
+  # --- Array ---
+
+  context "Aray#_to_xml" do
+    it "builds a one-line XML by default" do
+      expect(['a', 2, [3, 4], 'string', :symbol, { 3 => 4 }, { 5 => { '@i:type' => '13', '@@text' => 555 }}].\
+        _to_xml).to eq(
+          "<item>a</item><item>2</item><item><item>3</item><item>4</item></item>" +
+          "<item>string</item><item>symbol</item><item><3>4</3></item><item><5 i:type=\"13\">555</5></item>"
+        )
+    end
+    it "builds a multi-line XML when :indent is set" do
+      expect(['a', 2, [3, 4], 'string', :symbol,
+       { 3 => 4 }, { 5 => { '@i:type' => '13', '@@text' => 555 }}]._to_xml(:tag => 'item', :indent => '  ')).to eq(
+        "<item>a</item>\n"      +
+        "<item>2</item>\n"      +
+        "<item>\n"              +
+        "  <item>3</item>\n"    +
+        "  <item>4</item>\n"    +
+        "</item>\n"             +
+        "<item>string</item>\n" +
+        "<item>symbol</item>\n" +
+        "<item>\n"              +
+        "  <3>4</3>\n"          +
+        "</item>\n"             +
+        "<item>\n"              +
+        "  <5 i:type=\"13\">555</5>\n" +
+        "</item>\n"
+      )
+    end
+  end
+
+  # --- Hash ---
+
+  context "Hash#_to_xml" do
+
+    it "builds a simple XML from a single key hash" do
+      expect(({ 'a' => [ 1, { :c => 'd' } ] })._to_xml).to eq "<a>1</a><a><c>d</c></a>"
+    end
+
+    it "understands attributes as keys starting with @ and text defined as @@text" do
+      expect({ 'screen' => { '@width' => 1080, '@@text' => 'HD' } }._to_xml).to eq(
+        "<screen width=\"1080\">HD</screen>"
+      )
+    end
+
+    # Ruby 1.8 keeps hash keys in unpredictable order and the order on the tags
+    # in the resulting XMl is also not easy to predict.
+    if RUBY_VERSION >= '1.9'
+
+      it "builds a one-line hash by default" do
+        expect({ 'a' => 2, :b => [1, 3, 4, { :c => { 'd' => 'something' } } ], 5 => { '@i:type' => '13', '@@text' => 555 } }._to_xml).to eq(
+          '<a>2</a><b>1</b><b>3</b><b>4</b><b><c><d>something</d></c></b><5 i:type="13">555</5>'
+        )
+      end
+      it "builds a multi-line hash when :indent is set" do
+        expect({ 'a' => 2, :b => [1, 3, 4, { :c => { 'd' => 'something' } } ] }._to_xml(:indent => '  ')).to eq(
+            "<a>2</a>"             + "\n" +
+            "<b>1</b>"             + "\n" +
+            "<b>3</b>"             + "\n" +
+            "<b>4</b>"             + "\n" +
+            "<b>"                  + "\n" +
+            "  <c>"                + "\n" +
+            "    <d>something</d>" + "\n" +
+            "  </c>"               + "\n" +
+            "</b>"                 + "\n"
+          )
+      end
+
+      it "understands attributes as keys starting with @ and text defined as @@text (more complex "+
+         "example for ruby 1.9)" do
+        expect({ 'screen' => {
+            '@width' => 1080,
+            '@hight' => 720,
+            '@@text' => 'HD',
+            'color'  => {
+              '@max-colors' => 65535,
+              '@dinamic-resolution' => '1:1000000',
+              '@@text' => '<"PAL">',
+                'brightness' => {
+                  'bright' => true
+                }
+              }
+            }
+          }._to_xml(:indent => '  ', :escape => true)).to eq(
+              "<screen width=\"1080\" hight=\"720\">"                           + "\n" +
+              "  HD"                                                            + "\n" +
+              "  <color max-colors=\"65535\" dinamic-resolution=\"1:1000000\">" + "\n" +
+              "    &lt;&quot;PAL&quot;&gt;"                                     + "\n" +
+              "    <brightness>"                                                + "\n" +
+              "      <bright>true</bright>"                                     + "\n" +
+              "    </brightness>"                                               + "\n" +
+              "  </color>"                                                      + "\n" +
+              "</screen>"                                                       + "\n"
+            )
+      end
+
+    end
+
+    it "can mix ordering ID into Strings" do
+      key1 = Hash::_order('my-item')
+      key2 = Hash::_order('my-item')
+
+      expect(!!key1[Hash::RIGHTXMLSUPPORT_SORTORDERREGEXP]).to be true
+      expect(!!key2[Hash::RIGHTXMLSUPPORT_SORTORDERREGEXP]).to be true
+
+      expect(key1).to be < key2
+    end
+
+    it "XML-text has all the keys sorted accordingly to the given order" do
+      Hash::instance_variable_set('@_next_ordered_key_id', 0)
+      hash = {
+        Hash::_order('foo') => 34,
+        Hash::_order('boo') => 45,
+        Hash::_order('zoo') => 53,
+        Hash::_order('poo') => 10,
+        Hash::_order('moo') => {
+          Hash::_order('noo') => 101,
+          Hash::_order('too') => 113,
+          Hash::_order('koo') => 102,
+        },
+        Hash::_order('woo') => 03,
+        Hash::_order('hoo') => 1
+       }
+
+       expect(hash).to eq(
+         "foo{#1}" => 34,
+         "boo{#2}" => 45,
+         "zoo{#3}" => 53,
+         "poo{#4}" => 10,
+         "moo{#5}" => {
+           "noo{#6}" => 101,
+           "too{#7}" => 113,
+           "koo{#8}" => 102,
+         },
+         "woo{#9}" => 3,
+         "hoo{#10}" => 1
+       )
+
+      expect(hash._to_xml(:indent => '  ')).to eq(
+          "<foo>34</foo>"    + "\n" +
+          "<boo>45</boo>"    + "\n" +
+          "<zoo>53</zoo>"    + "\n" +
+          "<poo>10</poo>"    + "\n" +
+          "<moo>"            + "\n" +
+          "  <noo>101</noo>" + "\n" +
+          "  <too>113</too>" + "\n" +
+          "  <koo>102</koo>" + "\n" +
+          "</moo>"           + "\n" +
+          "<woo>3</woo>"     + "\n" +
+          "<hoo>1</hoo>"     + "\n"
+        )
+    end
+
+  end
+
+end

data/spec/helpers/utils_spec.rb

@@ -0,0 +1,179 @@
+#--
+# 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.
+#++
+
+describe "Utils" do
+  context "RightScale::CloudApi::Utils" do
+
+    context "self.url_encode" do
+      it "uses CGI::escape to escape" do
+        str = 'hahaha'
+        expect(CGI).to receive(:escape).once.and_return(str)
+        RightScale::CloudApi::Utils.url_encode(str)
+      end
+      it "replaces spaces with '%20'" do
+        expect(RightScale::CloudApi::Utils.url_encode('ha ha ha')).to eq 'ha%20ha%20ha'
+      end
+    end
+
+    context "self.params_to_urn" do
+      it "converts a Hash into a string" do
+        expect(RightScale::CloudApi::Utils.params_to_urn('a' => 'b', 'c' => '', 'd' => nil)).to eq 'a=b&c=&d'
+      end
+      it "auto escapes values" do
+        expect(RightScale::CloudApi::Utils.params_to_urn('a' => 'ha  ha')).to eq 'a=ha%20%20ha'
+      end
+      it "uses a provided block to escape values" do
+        expect(RightScale::CloudApi::Utils.params_to_urn('a' => 'ha  ha'){|val| val.gsub(' ','-') }).to eq 'a=ha--ha'
+      end
+    end
+
+    context "self.join_urn" do
+      it "joins pathes" do
+        expect(RightScale::CloudApi::Utils.join_urn('/first', 'second', 'third')).to eq '/first/second/third'
+      end
+      it "knows how to deal with empty pathes or slashes" do
+        expect(RightScale::CloudApi::Utils.join_urn('/first', '', '1/', '1.1/', 'second', 'third')).to eq '/first/1/1.1/second/third'
+      end
+      it "drops strips left when it sees a path starting with forward slash (root sign)" do
+        expect(RightScale::CloudApi::Utils.join_urn('/first', '', '1/', '1.1/', '/second', 'third')).to eq '/second/third'
+      end
+      it "adds URL params" do
+        expect(RightScale::CloudApi::Utils.join_urn('/first','second', {'a' => 'b', 'c' => '', 'd' => nil})).to eq "/first/second?a=b&c=&d"
+      end
+
+      context "self.extract_url_params" do
+      end
+
+      context "self.pattern_matches?" do
+        it "returns a blank Hash when there are no any params in the provided URL" do
+          expect(RightScale::CloudApi::Utils.extract_url_params('https://ec2.amazonaws.com')).to eq({})
+        end
+        it "returns parsed URL params when they are in the provided URL" do
+          expect(RightScale::CloudApi::Utils.extract_url_params('https://ec2.amazonaws.com/?w=1&x=3&y&z')).to eq(
+            {"z"=>nil, "y"=>nil, "x"=>"3", "w"=>"1"}
+          )
+        end
+      end
+
+      context "self.contentify_body" do
+        before(:each) do
+          @body = { '1' => '2' }
+        end
+        it "returns JSON when content type says it should be json" do
+          expect(RightScale::CloudApi::Utils.contentify_body(@body,'json')).to eq '{"1":"2"}'
+        end
+        it "returns XML when content type says it should be json" do
+          expect(RightScale::CloudApi::Utils.contentify_body(@body,'xml')).to eq "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<1>2</1>" 
+        end
+        it "fails if there is an unsupported content-type" do
+          expect { RightScale::CloudApi::Utils.contentify_body(@body,'unsupported-smething') }.to raise_error(RightScale::CloudApi::Error)
+        end
+      end
+
+      context "self.generate_token" do
+        context "UUID" do
+          before(:each) do
+            @expectation = 'something-random-from-UUID.generate'
+            UUID         = double('UUID', :new => double(:generate => @expectation))
+          end
+          it "uses UUID when UUID is loaded" do
+            RightScale::CloudApi::Utils.generate_token == @expectation
+          end
+        end
+
+        context "self.random" do
+          before(:each) do
+            @expectation = 'something-random-from-self.random'
+            UUID         = double('UUID', :new => double(:generate => @expectation))
+            expect(UUID).to receive(:respond_to?).with(:new).and_return(false)
+          end
+        it "uses self.random when UUID is not loaded" do
+          expect(RightScale::CloudApi::Utils).to receive(:random).and_return(@expectation)
+          RightScale::CloudApi::Utils.generate_token == @expectation
+        end
+        end
+      end
+
+      context "self.random" do
+        it "generates a single random HEX digit by default" do
+          expect(RightScale::CloudApi::Utils.random[/^[0-9a-f]{1}$/]).to_not be(nil)
+        end
+        it "generates 'size' random HEX digits when size is set" do
+          expect(RightScale::CloudApi::Utils.random(13)[/^[0-9a-f]{13}$/]).to_not be(nil)
+        end
+        it "generates random decimal digits when :base is 10" do
+          expect(RightScale::CloudApi::Utils.random(13, :base => 10)[/^[0-9]{13}$/]).to_not be(nil)
+        end
+        it "generates random alpha symbols when :base is 26 and :offset is 10" do
+          expect(RightScale::CloudApi::Utils.random(13, :base => 26, :offset => 10)[/^[a-z]{13}$/]).to_not be(nil)
+        end
+      end
+
+      context "self.arrayify" do
+        it "does not change Array instances" do
+          expect(RightScale::CloudApi::Utils.arrayify([])).to eq []
+          expect(RightScale::CloudApi::Utils.arrayify([1,2,3])).to eq([1,2,3])
+        end
+        it "wraps all the other objects into Array" do
+          expect(RightScale::CloudApi::Utils.arrayify(nil)).to eq [nil]
+          expect(RightScale::CloudApi::Utils.arrayify(1)).to eq [1]
+          expect(RightScale::CloudApi::Utils.arrayify('something')).to eq ['something']
+          expect(RightScale::CloudApi::Utils.arrayify({1=>2})).to eq( [{1=>2}])
+        end
+      end
+
+      context "self.dearrayify" do
+        it "returns input if the input is not an Array instance" do
+          expect(RightScale::CloudApi::Utils.dearrayify(nil)).to be(nil)
+          expect(RightScale::CloudApi::Utils.dearrayify(1)).to eq 1
+          expect(RightScale::CloudApi::Utils.dearrayify('something')).to eq 'something'
+          expect(RightScale::CloudApi::Utils.dearrayify({1=>2})).to eq({1=>2})
+        end
+        it "returns the first element of the input if the input is an Array instance" do
+          expect(RightScale::CloudApi::Utils.dearrayify([])).to be(nil)
+          expect(RightScale::CloudApi::Utils.dearrayify([1])).to eq 1
+          expect(RightScale::CloudApi::Utils.dearrayify([1,2,3])).to eq 1
+        end
+      end
+
+      context "self.get_xml_parser_class" do
+        it "returns RightScale::CloudApiParser::Sax by default" do
+          expect(RightScale::CloudApi::Utils.get_xml_parser_class(nil)).to eq RightScale::CloudApi::Parser::Sax
+        end
+        it "returns RightScale::CloudApiParser::Sax by its name" do
+          expect(RightScale::CloudApi::Utils.get_xml_parser_class('sax')).to eq RightScale::CloudApi::Parser::Sax
+        end
+        it "returns RightScale::CloudApiParser::ReXml by its name" do
+          expect(RightScale::CloudApi::Utils.get_xml_parser_class('rexml')).to eq RightScale::CloudApi::Parser::ReXml
+        end
+        it "fails when an unknown parser is requested" do
+          expect { RightScale::CloudApi::Utils.get_xml_parser_class('something-unknown') }.to raise_error(RightScale::CloudApi::Error)
+        end
+      end
+
+      context "self.inheritance_chain" do
+      end
+
+    end
+  end
+end

data/spec/routines/connection_proxies/test_net_http_persistent_proxy_spec.rb

@@ -0,0 +1,143 @@
+#--
+# 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"
+require "net/http/persistent"
+
+describe "RightScale::CloudApi::ConnectionProxy::NetHTTPPersistentProxy" do
+  before(:each) do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @proxy = RightScale::CloudApi::ConnectionProxy::NetHttpPersistentProxy.new
+    @uri = double(:host   => 'host.com',
+                  :port   => '777',
+                  :scheme => 'scheme',
+                  :dup    => @uri)
+    @test_data = {
+      :options     => {:user_agent => 'user_agent_data',
+                       :connection_retry_count => 0,
+                       :cloud_api_logger => RightScale::CloudApi::CloudApiLogger.new({:logger => logger})},
+      :credentials => {},
+      :callbacks   => {},
+      :vars        => {:system => {:block => 'block'}},
+      :request     => {:instance => double(:verb => 'get',
+                                         :path     => 'some/path',
+                                         :body     => 'body',
+                                         :is_io?   => false,
+                                         :headers  => {'header1' => 'val1',
+                                                       'header2' => 'val2'},
+                                         :raw=     => nil)},
+      :connection  => {:uri => @uri}
+    }
+    @response = double(:code => '200', :body => 'body', :to_hash => {:code => '200', :body => 'body'})
+  end
+
+
+  context "when request succeeds" do
+    before :each do
+      @connection = double(
+        :request                => @response,
+        :retry_change_requests= => true )
+      expect(Net::HTTP::Persistent).to receive(:new).and_return(@connection)
+    end
+
+    it "works" do
+      @proxy.request(@test_data)
+    end
+  end
+
+
+  context "when there is a connection issue" do
+    before :each do
+      @connection = double( :retry_change_requests= => true )
+      expect(Net::HTTP::Persistent).to receive(:new).and_return(@connection)
+      # failure in the connection should finish and reraise the error
+      expect(@connection).to receive(:request).and_raise(StandardError.new("Banana"))
+      expect(@connection).to receive(:shutdown)
+    end
+
+    it "works" do
+      expect { @proxy.request(@test_data) }.to raise_error(Exception)
+    end
+  end
+
+
+  context "low level connection retries" do
+    before :each do
+      @connection = double(
+        :retry_change_requests= => true,
+        :shutdown => true
+       )
+      expect(Net::HTTP::Persistent).to receive(:new).and_return(@connection)
+    end
+
+    context "when retries are disabled" do
+      before:each do
+        expect(@connection).to receive(:request).and_raise( Timeout::Error)
+        @test_data[:options][:connection_retry_count] = 0
+        expect(@proxy).to receive(:sleep).never
+      end
+
+      it "makes no retries" do
+        expect { @proxy.request(@test_data) }.to raise_error(RightScale::CloudApi::ConnectionError)
+      end
+    end
+
+
+    context "when retries are enabled" do
+      context "timeouts are enabled" do
+        before:each do
+          @retries_count = 3
+          expect(@connection).to receive(:request).exactly(@retries_count+1).times.and_raise( Timeout::Error)
+          @test_data[:options][:connection_retry_count] = @retries_count
+          expect(@proxy).to receive(:sleep).exactly(@retries_count).times
+        end
+
+        it "makes no retries" do
+          expect { @proxy.request(@test_data) }.to raise_error(RightScale::CloudApi::ConnectionError)
+        end
+      end
+
+
+      context "but timeouts are disabled" do
+        before:each do
+          @retries_count = 3
+          @test_data[:options][:connection_retry_count] = @retries_count
+          @test_data[:options][:abort_on_timeout] = true
+        end
+
+        it "makes no retries on timeout" do
+          expect(@connection).to receive(:request).and_raise(Timeout::Error)
+          expect(@proxy).to receive(:sleep).never
+          expect { @proxy.request(@test_data) }.to raise_error(RightScale::CloudApi::ConnectionError)
+        end
+
+        it "makes retries on non timeout errors" do
+          expect(@connection).to receive(:request).exactly(@retries_count+1).times.and_raise(SocketError)
+          expect(@proxy).to receive(:sleep).exactly(@retries_count).times
+          expect { @proxy.request(@test_data) }.to raise_error(RightScale::CloudApi::ConnectionError)
+        end
+      end
+    end
+  end
+end

data/spec/routines/test_cache_validator_spec.rb

@@ -0,0 +1,152 @@
+#--
+# 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::CacheValidator" 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::CacheValidator
+    @api_manager.class.options[:error_patterns] = []
+
+    @cachevalidator = RightScale::CloudApi::CacheValidator.new
+    @test_data = {}
+    @test_data[:request] = { :verb => 'some_verb', :orig_params => {}, :instance => 'some_request'}
+    @test_data[:options] = {:error_patterns => []}
+    @callback = double
+    @test_data[:options][:cache] = {}
+    @test_data[:callbacks] = {:close_current_connection => @callback}
+    @test_data[:connection] = {}
+    @test_data[:response] = {}
+    @test_data[:vars] = {:system => {:storage => {}}}
+    @test_data[:response][:instance] = double(:is_io? => false)
+    allow(@cachevalidator).to receive(:log)
+  end
+
+  context "cache_pattern" do
+    it "fails when is has unexpected inputs" do
+      # non hash input
+      expect { @api_manager.class.cache_pattern(true) }.to raise_error(RightScale::CloudApi::CacheValidator::Error)
+      # blank pattern
+      expect { @api_manager.class.cache_pattern({}) }.to raise_error(RightScale::CloudApi::CacheValidator::Error)
+    end
+
+    context "pattern keys" do
+      before(:each) do
+        # test all pattern keys
+        @cache_pattern = RightScale::CloudApi::CacheValidator::ClassMethods::CACHE_PATTERN_KEYS.inject({}) { |result, k| result.merge(k => k.to_s)}
+        @api_manager.class.cache_pattern(@cache_pattern)
+      end
+      it "stores all the cache patterns keys properly" do
+        expect(@api_manager.class.options[:cache_patterns]).to eq([@cache_pattern])
+      end
+      it "complains when a mandatory key is missing" do
+        @cache_pattern.delete(:key)
+        expect { @api_manager.class.cache_pattern(@cache_pattern) }.to raise_error(RightScale::CloudApi::CacheValidator::Error)
+      end
+      it "complains when an unsupported key is passed" do
+        bad_keys = { :bad_key1 => "bad_key1", :bad_key2 => "bad_key2" }
+        @cache_pattern.merge!(bad_keys)
+        expect { @api_manager.class.cache_pattern(@cache_pattern) }.to raise_error(RightScale::CloudApi::CacheValidator::Error)
+      end
+    end
+  end
+
+  context "basic cache validation" do
+    it "returns true when it performed validation" do
+      expect(@cachevalidator.execute(@test_data)).to be(true)
+    end
+    it "returns nil if there is no way to parse a response object" do
+      @test_data[:response][:instance] = double(:is_io? => true)
+      expect(@cachevalidator.execute(@test_data)).to be(nil)
+    end
+    it "returns nil if caching is disabled" do
+      @test_data[:options].delete(:cache)
+      expect(@cachevalidator.execute(@test_data)).to be(nil)
+    end
+  end
+
+  context "cache validation with match" do
+    before(:each) do
+      expect(RightScale::CloudApi::Utils).to receive(:pattern_matches?).at_least(1).and_return(true)
+      @cache_pattern = RightScale::CloudApi::CacheValidator::ClassMethods::CACHE_PATTERN_KEYS.inject({}) { |result, k| result.merge(k  => k.to_s)}
+      @cache_pattern[:sign] = double(:call => "body_to_sign")
+      @test_data[:options][:cache_patterns] = [@cache_pattern]
+      @response = double(:code => '501', :body => 'body', :headers => 'headers', :is_io? => false)
+      @test_data[:response] = {:instance => @response}
+    end
+    it "fails if there is a missing key" do
+      @cache_pattern.delete(:key)
+      expect { @cachevalidator.execute(@test_data) }.to raise_error(RightScale::CloudApi::CacheValidator::Error)
+    end
+    
+    context "and one record cached" do
+      before(:each) do
+        expect(@cachevalidator).to receive(:build_cache_key).at_least(1).and_return(["some_key","some_response_body"])
+        expect(@cachevalidator).to receive(:log).with("New cache record created")
+        @cachevalidator.execute(@test_data)
+      end
+      it "succeeds when it builds a cache key for the first time" do
+        expect(@test_data[:vars][:cache][:key]).to eq "some_key"
+      end
+      it "raises CacheHit and increments a counter when cache hits" do
+        expect { @cachevalidator.execute(@test_data) }.to raise_error(RightScale::CloudApi::CacheHit)
+        expect(@test_data[:vars][:system][:storage][:cache]['some_key'][:hits]).to eq 1
+        expect { @cachevalidator.execute(@test_data) }.to raise_error(RightScale::CloudApi::CacheHit)
+        expect(@test_data[:vars][:system][:storage][:cache]['some_key'][:hits]).to eq 2
+      end
+      it "replaces a record if the same request gets a different response" do
+        @test_data[:vars][:system][:storage][:cache]['some_key'][:md5] = 'corrupted'
+        expect(@cachevalidator).to receive(:log).with("Missed. Record is replaced")
+        @cachevalidator.execute(@test_data)
+        expect(@test_data[:vars][:system][:storage][:cache]['some_key'][:hits]).to eq 0
+      end
+    end
+  end
+
+  context "build_cache_key" do
+    before(:each) do
+      # use send since this is a private method
+      @opts = {:response => double(:body => nil)}
+    end
+    it "fails when it cannot create a key" do
+      expect { @cachevalidator.__send__(:build_cache_key, {}, @opts) }.to raise_error((RightScale::CloudApi::CacheValidator::Error))
+    end
+    it "fails when it cannot create body" do
+      expect { @cachevalidator.__send__(:build_cache_key, {:key => 'normal_key'}, @opts) }.to raise_error(RightScale::CloudApi::CacheValidator::Error)
+    end
+    it "creates key and body from given inputs" do
+      pattern = {:key => 'normal_key'}
+      opts    = {:response => double(:body => "normal_body")}
+      expect(@cachevalidator.__send__(:build_cache_key, pattern, opts)).to eq(['normal_key', 'normal_body'])
+    end
+    it "creates key and body from given procs" do
+      proc = double(:is_a? => true)
+      expect(proc).to receive(:call).and_return("proc_key")
+      proc_pattern = { :key => proc, :sign => double(:call => "proc_sign_call") }
+      expect(@cachevalidator.__send__(:build_cache_key, proc_pattern, @opts)).to eq(['proc_key', 'proc_sign_call'])
+    end
+  end
+end