aws-sdk-core 2.0.0.rc1 → 2.0.0.rc2

data/vendor/seahorse/spec/seahorse/client/handler_list_spec.rb

@@ -18,12 +18,12 @@ module Seahorse
           expect(handlers.to_a).to eq([handler])
         end
 
-        it 'handlers added latter have a higher priority' do
+        it 'handlers added first have a higher priority' do
           handler1 = Class.new
           handler2 = Class.new
           handlers.add(handler1)
           handlers.add(handler2)
-          expect(handlers.to_a).to eq([handler1, handler2])
+          expect(handlers.to_a).to eq([handler2, handler1])
         end
 
         it 'returns the handler class' do
@@ -53,7 +53,7 @@ module Seahorse
             handlers.add('h2', step: :validate)
             handlers.add('h3', step: :build)
             handlers.add('h4', step: :build)
-            expect(handlers.to_a).to eq(%w(h3 h4 h1 h2))
+            expect(handlers.to_a).to eq(%w(h4 h3 h2 h1))
           end
 
         end
@@ -78,7 +78,7 @@ module Seahorse
             handlers.add('y', priority: 20, step: :validate)
             handlers.add('z', priority: 20, step: :validate)
             handlers.add('-', step: :send)
-            expect(handlers.to_a).to eq(%w(- a b c m n o x y z))
+            expect(handlers.to_a).to eq(%w(- c b a o n m z y x))
           end
 
         end
@@ -138,7 +138,7 @@ module Seahorse
             handlers.add('handler1', operations: ['operation1'])
             handlers.add('handler2', operations: ['operation1'])
             handlers.add('handler3', operations: ['operation2'])
-            expect(handlers.for('operation1').to_a).to eq(%w(handler1 handler2))
+            expect(handlers.for('operation1').to_a).to eq(%w(handler2 handler1))
           end
 
         end
@@ -184,7 +184,7 @@ module Seahorse
           handlers2 = handlers.for('operation')
           handlers2.add('handler2')
           expect(handlers.to_a).to eq(['handler1'])
-          expect(handlers2.to_a).to eq(['handler1', 'handler2'])
+          expect(handlers2.to_a).to eq(['handler2', 'handler1'])
         end
 
         it 'copies operation handlers with the given name' do
@@ -207,8 +207,8 @@ module Seahorse
         it 'accpets operation names as symbols' do
           handlers.add('handler1', operations: [:operation])
           handlers.add('handler2', operations: ['operation'])
-          expect(handlers.for('operation').to_a).to eq(%w(handler1 handler2))
-          expect(handlers.for(:operation).to_a).to eq(%w(handler1 handler2))
+          expect(handlers.for('operation').to_a).to eq(%w(handler2 handler1))
+          expect(handlers.for(:operation).to_a).to eq(%w(handler2 handler1))
         end
 
       end
@@ -229,8 +229,8 @@ module Seahorse
         it 'does not construct handlers that are not classes' do
           handler1 = double('handler1')
           handler2 = double('handler2')
-          expect(handler1).to receive(:handler=).with(nil)
-          expect(handler2).to receive(:handler=).with(handler1)
+          expect(handler2).to receive(:handler=).with(nil)
+          expect(handler1).to receive(:handler=).with(handler2)
           handlers.add(handler1)
           handlers.add(handler2)
           handlers.to_stack

data/vendor/seahorse/spec/seahorse/client/http/endpoint_spec.rb

@@ -11,12 +11,12 @@ module Seahorse
           end
 
           it 'can be constructed from a URI::HTTP' do
-            uri = 'http://foo.com'
+            uri = 'http://foo.com/'
             expect(Endpoint.new(URI.parse(uri))).to eq(uri)
           end
 
           it 'can be constructed from a URI::HTTPS' do
-            uri = 'https://foo.com'
+            uri = 'https://foo.com/'
             expect(Endpoint.new(URI.parse(uri))).to eq(uri)
           end
 
@@ -45,16 +45,12 @@ module Seahorse
             expect(Endpoint.new('foo.com').scheme).to eq('https')
           end
 
-          it 'looks for the :ssl_default options when picking the default scheme' do
-            expect(Endpoint.new('foo.com', ssl_default: false).scheme).to eq('http')
-          end
-
           it 'can be changed' do
-            endpoint = Endpoint.new('http://foo.com')
+            endpoint = Endpoint.new('http://foo.com/')
             endpoint.scheme = 'https'
             expect(endpoint.port).to eq(80)
             expect(endpoint.scheme).to eq('https')
-            expect(endpoint).to eq('https://foo.com:80')
+            expect(endpoint).to eq('https://foo.com:80/')
           end
 
         end
@@ -91,10 +87,10 @@ module Seahorse
           end
 
           it 'can be changed' do
-            endpoint = Endpoint.new('http://foo.com')
+            endpoint = Endpoint.new('http://foo.com/')
             endpoint.host = 'bar.com'
             expect(endpoint.host).to eq('bar.com')
-            expect(endpoint).to eq('http://bar.com')
+            expect(endpoint).to eq('http://bar.com/')
           end
 
         end
@@ -115,11 +111,47 @@ module Seahorse
           end
 
           it 'can be changed' do
-            endpoint = Endpoint.new('http://foo.com')
+            endpoint = Endpoint.new('http://foo.com/')
             endpoint.port = 443
             expect(endpoint.scheme).to eq('http')
             expect(endpoint.port).to eq(443)
-            expect(endpoint).to eq('http://foo.com:443')
+            expect(endpoint).to eq('http://foo.com:443/')
+          end
+
+        end
+
+        describe '#request_uri' do
+
+          it 'defaults to /' do
+            expect(Endpoint.new('foo.com').request_uri).to eq('/')
+          end
+
+          it 'can be set in the constructor' do
+            expect(Endpoint.new('foo.com/bar?a=b').request_uri).to eq('/bar?a=b')
+          end
+
+        end
+
+        describe '#path' do
+
+          it 'defaults to /' do
+            expect(Endpoint.new('foo.com').path).to eq('/')
+          end
+
+          it 'can be set in the constructor' do
+            expect(Endpoint.new('foo.com/bar?a=b').path).to eq('/bar')
+          end
+
+        end
+
+        describe '#querystring' do
+
+          it 'defaults to nil' do
+            expect(Endpoint.new('foo.com').querystring).to be(nil)
+          end
+
+          it 'can be set in the constructor' do
+            expect(Endpoint.new('foo.com/bar?a=b').querystring).to eq('a=b')
           end
 
         end
@@ -138,7 +170,7 @@ module Seahorse
             endpoint = Endpoint.new('foo.com')
             endpoint.user = 'abc'
             expect(endpoint.user).to eq('abc')
-            expect(endpoint).to eq('https://abc@foo.com')
+            expect(endpoint).to eq('https://abc@foo.com/')
           end
 
         end
@@ -158,7 +190,7 @@ module Seahorse
             endpoint.user = 'u'
             endpoint.password = 'p'
             expect(endpoint.password).to eq('p')
-            expect(endpoint).to eq('https://u:p@foo.com')
+            expect(endpoint).to eq('https://u:p@foo.com/')
           end
 
         end

data/vendor/seahorse/spec/seahorse/client/http/request_spec.rb

@@ -15,7 +15,7 @@ module Seahorse
           end
 
           it 'can be set in the constructor' do
-            endpoint = 'http://foo.com'
+            endpoint = 'http://foo.com/'
             req = request(endpoint: endpoint)
             expect(req.endpoint).to eq(endpoint)
           end
@@ -35,47 +35,6 @@ module Seahorse
 
         end
 
-        describe '#path' do
-
-          it 'defaults to GET' do
-            expect(request.path).to eq('/')
-          end
-
-          it 'can be set in the constructor' do
-            req = request(path: '/path?abc=xyz')
-            expect(req.path).to eq('/path?abc=xyz')
-          end
-
-        end
-
-        describe '#pathname' do
-
-          it 'returns the path up to but not including the querystring' do
-            req = request(path: '/path?query')
-            expect(req.pathname).to eq('/path')
-          end
-
-          it 'returns the full path when a querystring is not present' do
-            req = request(path: '/path')
-            expect(req.pathname).to eq('/path')
-          end
-
-        end
-
-        describe '#querystring' do
-
-          it 'returns the querystring portion of the path' do
-            req = request(path: '/path?query')
-            expect(req.querystring).to eq('query')
-          end
-
-          it 'returns the empty string when not present' do
-            req = request(path: '/path')
-            expect(req.querystring).to eq('')
-          end
-
-        end
-
         describe '#headers' do
 
           it 'defaults to a Http::Headers' do

data/vendor/seahorse/spec/seahorse/client/logging/formatter_spec.rb

@@ -62,7 +62,7 @@ module Seahorse
           it 'provides a :http_request_endpoint replacement' do
             response.context.http_request.endpoint =
               Http::Endpoint.new('http://foo.com:123')
-            expect(format(':http_request_endpoint')).to eq('http://foo.com:123')
+            expect(format(':http_request_endpoint')).to eq('http://foo.com:123/')
           end
 
           it 'provides a :http_request_scheme replacement' do
@@ -92,11 +92,6 @@ module Seahorse
             expect(format(':http_request_port')).to eq('123')
           end
 
-          it 'provides a :http_request_path replacement' do
-            response.context.http_request.path = '/foo?bar=1'
-            expect(format(':http_request_path')).to eq('/foo?bar=1')
-          end
-
           it 'provides a :http_request_headers replacement' do
             response.context.http_request.headers = { 'foo' => 'bar' }
             expect(format(':http_request_headers')).to eq('{"foo"=>"bar"}')

data/vendor/seahorse/spec/seahorse/client/logging/handler_spec.rb

@@ -41,7 +41,7 @@ module Seahorse
           resp = handle!
           expect(resp.context[:logging_started_at]).to be_kind_of(Time)
           expect(resp.context[:logging_completed_at]).to be_kind_of(Time)
-          expect(resp.context[:logging_started_at]).to be < resp.context[:logging_completed_at]
+          expect(resp.context[:logging_started_at]).to be <= resp.context[:logging_completed_at]
         end
 
         it 'sends the formatted message to the logger' do

data/vendor/seahorse/spec/seahorse/client/net_http/handler_spec.rb

@@ -183,14 +183,14 @@ module Seahorse
           describe 'request path' do
 
             it 'sends the request with the correct request uri' do
-              http_request.path = '/path'
-              stub_request(:any, "#{endpoint}/path")
+              http_request.endpoint.request_uri = '/path'
+              stub_request(:any, http_request.endpoint)
               make_request
             end
 
             it 'sends the request with the querystring' do
-              http_request.path = '/abc?mno=xyz'
-              stub_request(:any, "#{endpoint}/abc?mno=xyz")
+              http_request.endpoint.request_uri = '/abc?mno=xyz'
+              stub_request(:any, http_request.endpoint)
               make_request
             end
 
@@ -221,6 +221,7 @@ module Seahorse
             it 'populates the response body' do
               stub_request(:any, endpoint).to_return(body: 'response-body')
               resp_body = make_request.http_response.body
+              resp_body.rewind
               expect(resp_body.read).to eq('response-body')
             end
 

data/vendor/seahorse/spec/seahorse/client/param_converter_spec.rb

@@ -271,6 +271,7 @@ module Seahorse
           it 'accepts io objects (like tempfiles)' do
             file = Tempfile.new('abc')
             expect(ParamConverter.c(shape_class, file)).to be(file)
+            file.close
             file.delete
           end
 

data/vendor/seahorse/spec/seahorse/client/plugins/{restful_bindings/uri_path_builder_spec.rb → endpoint/request_uri_builder_spec.rb}

@@ -3,14 +3,14 @@ require 'spec_helper'
 module Seahorse
   module Client
     module Plugins
-      class RestfulBindings
-        describe UriPathBuilder do
+      class Endpoint
+        describe RequestUriBuilder do
 
           let(:rules) {{ 'type' => 'input', 'members' => {} }}
 
           def path_for(pattern, params)
             input = Model::Shapes::Shape.from_hash(rules)
-            UriPathBuilder.new(pattern, input.uri_members).path(params)
+            RequestUriBuilder.new(pattern, input.uri_members).path(params)
           end
 
           it 'does not modify paths without placeholders' do

data/vendor/seahorse/spec/seahorse/client/plugins/endpoint_spec.rb

@@ -22,21 +22,11 @@ module Seahorse
           expect(client.config.endpoint).to eq('foo.com')
         end
 
-        it 'adds an #ssl_default option to config' do
-          expect(client.config.ssl_default).to be(true)
-        end
-
         it 'populates the http request endpoint' do
           resp = client.build_request('operation').send_request
-          expect(resp.context.http_request.endpoint).to eq('https://foo.com')
+          expect(resp.context.http_request.endpoint).to eq('https://foo.com/')
         end
 
-        it 'defaults to http when ssl_default is false' do
-          client = client(ssl_default: false)
-          resp = client.build_request('operation').send_request
-          expect(resp.context.http_request.endpoint).to eq('http://foo.com')
-       end
-
       end
     end
   end

data/vendor/seahorse/spec/seahorse/client/request_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'tempfile'
 
 module Seahorse
   module Client
@@ -63,7 +64,7 @@ module Seahorse
 
       end
 
-      describe '#send_request with a block' do
+      describe '#send_request with a target' do
 
         let(:handler) do
           Proc.new do
@@ -78,24 +79,73 @@ module Seahorse
           allow(handlers).to receive(:to_stack).and_return(handler)
         end
 
-        it 'streams data from the handler to the #send_request block' do
-          data = []
-          request.send_request { |chunk| data << chunk }
-          expect(data).to eq(['part1', 'part2', 'part3'])
+        describe 'String target' do
+
+          it 'writes to the file named' do
+            tmpfile = Tempfile.new('tempfile')
+            tmpfile.close
+            request.send_request(target: tmpfile.path)
+            expect(File.read(tmpfile.path)).to eq("part1part2part3")
+          end
+
+          it 'closes the file before returning the response' do
+            tmpfile = Tempfile.new('tempfile')
+            tmpfile.close
+            resp = request.send_request(target: tmpfile.path)
+            expect(resp.context.http_response.body).to be_closed
+          end
+
         end
 
-        it 'counts the bytes yielded' do
-          resp = request.send_request { |chunk| }
-          expect(resp.http_response.body.size).to eq(15)
+        describe 'Pathname target' do
+
+          it 'writes to the file named' do
+            tmpfile = Tempfile.new('tempfile')
+            tmpfile.close
+            request.send_request(target: Pathname.new(tmpfile.path))
+            expect(File.read(tmpfile.path)).to eq("part1part2part3")
+          end
+
+          it 'closes the file before returning the response' do
+            tmpfile = Tempfile.new('tempfile')
+            tmpfile.close
+            resp = request.send_request(target: Pathname.new(tmpfile.path))
+            expect(resp.context.http_response.body).to be_closed
+          end
+
         end
 
-        it 'does not buffer the response chunks' do
-          response = request.send_request { |chunk| }
-          body = response.http_response.body
-          expect(body.read).to eq('')
-          expect { body.rewind }.to raise_error(NotImplementedError)
+        describe 'IO object target' do
+
+          it 'writes to the given object' do
+            buffer = StringIO.new('')
+            request.send_request(target: buffer)
+            expect(buffer.string).to eq("part1part2part3")
+          end
+
         end
 
+        describe 'Block target' do
+
+          it 'streams data from the handler to the #send_request block' do
+            data = []
+            request.send_request { |chunk| data << chunk }
+            expect(data).to eq(['part1', 'part2', 'part3'])
+          end
+
+          it 'counts the bytes yielded' do
+            resp = request.send_request { |chunk| }
+            expect(resp.http_response.body.size).to eq(15)
+          end
+
+          it 'does not buffer the response chunks' do
+            response = request.send_request { |chunk| }
+            body = response.http_response.body
+            expect(body.read).to eq('')
+            expect(body).not_to respond_to(:truncate)
+          end
+
+        end
       end
     end
   end