aws-sdk-core 2.0.0.rc1

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

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'pathname'
+
+module Seahorse
+  module  Client
+    module Logging
+      describe Formatter do
+
+        let(:response) { Response.new }
+
+        def format(pattern, options = {})
+          Logging::Formatter.new(pattern, options).format(response)
+        end
+
+        describe '#format' do
+
+          it 'provides a :client_class replacement' do
+            response.context.client = String.new
+            expect(format(':client_class')).to eq('String')
+          end
+
+          it 'provides a :operation replacement' do
+            response.context.operation_name = 'operation-name'
+            expect(format(':operation')).to eq('operation-name')
+          end
+
+          it 'provides a :request_params replacement' do
+            response.context.params = {
+              foo: 'bar',
+              attributes: {
+                'color' => 'red',
+                'size' => 'large'
+              },
+              config: {
+                nested: true,
+                values: [1,2,3],
+                file: File.open('Rakefile'),
+                path: Pathname.new('Rakefile'),
+                complex: double('obj', inspect: '"inspected"')
+              },
+              huge: '-' * 1000
+            }
+            formatted = format('{:request_params}', max_string_size: 20)
+            size = File.size('Rakefile')
+            expect(formatted).to eq(<<-FORMATTED.strip)
+{foo:"bar",attributes:{"color"=>"red","size"=>"large"},config:{nested:true,values:[1,2,3],file:#<File:Rakefile (#{size} bytes)>,path:#<File:Rakefile (#{size} bytes)>,complex:"inspected"},huge:#<String "--------------------" ... (1000 bytes)>}
+            FORMATTED
+          end
+
+          it 'provides a :time replacement' do
+            now = Time.now
+            response.context[:logging_started_at] = now - 1.54321
+            response.context[:logging_completed_at] = now
+            expect(format(':time')).to eq('1.54321')
+          end
+
+          it 'provides a :retries replacement' do
+            response.context.retries = 3
+            expect(format(':retries')).to eq('3')
+          end
+
+          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')
+          end
+
+          it 'provides a :http_request_scheme replacement' do
+            response.context.http_request.endpoint =
+              Http::Endpoint.new('http://foo.com')
+            expect(format(':http_request_scheme')).to eq('http')
+            response.context.http_request.endpoint =
+              Http::Endpoint.new('https://foo.com')
+            expect(format(':http_request_scheme')).to eq('https')
+          end
+
+          it 'provides a :http_request_host replacement' do
+            response.context.http_request.endpoint =
+              Http::Endpoint.new('http://foo.com')
+            expect(format(':http_request_host')).to eq('foo.com')
+          end
+
+          it 'provides a :http_request_port replacement' do
+            response.context.http_request.endpoint =
+              Http::Endpoint.new('http://foo.com')
+            expect(format(':http_request_port')).to eq('80')
+            response.context.http_request.endpoint =
+              Http::Endpoint.new('https://foo.com')
+            expect(format(':http_request_port')).to eq('443')
+            response.context.http_request.endpoint =
+              Http::Endpoint.new('http://foo.com:123')
+            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"}')
+          end
+
+          it 'provides a :http_request_body replacement' do
+            response.context.http_request.body = StringIO.new('abc')
+            expect(format(':http_request_body')).to eq('"abc"')
+            response.context.http_request.body = '-' * 1024 * 1024
+            formatted = format(':http_request_body', max_string_size: 5)
+            expect(formatted).to eq("#<String \"-----\" ... (1048576 bytes)>")
+          end
+
+          it 'provides a :http_response_status_code replacement' do
+            response.context.http_response.status_code = 200
+            expect(format(':http_response_status_code')).to eq('200')
+          end
+
+          it 'provides a :http_response_headers replacement' do
+            response.context.http_response.headers['foo'] = 'bar'
+            expect(format(':http_response_headers')).to eq('{"foo"=>"bar"}')
+          end
+
+          it 'provides a :http_response_body replacement' do
+            response.context.http_response.body = StringIO.new('abc')
+            expect(format(':http_response_body')).to eq('"abc"')
+            response.context.http_response.body = '-' * 1024 * 1024
+            formatted = format(':http_response_body', max_string_size: 5)
+            expect(formatted).to eq("#<String \"-----\" ... (1048576 bytes)>")
+          end
+
+          it 'provides a :error_class replacement' do
+            response.error = String.new
+            expect(format(':error_class')).to eq('String')
+          end
+
+          it 'provides a :error_message replacement' do
+            response.error = RuntimeError.new('foo')
+            expect(format(':error_message')).to eq('foo')
+          end
+
+          it 'leaves placeholders intact that are not defined' do
+            expect(format('abc :mno xyz')).to eq('abc :mno xyz')
+          end
+
+        end
+
+        describe 'canned loggers' do
+
+          before(:each) do
+            now = Time.now
+            response.context.client = String
+            response.context.operation_name = 'operation_name'
+            response.context.retries = 3
+            response.context.params = { limit: 1 }
+            response.error = RuntimeError.new('error-message')
+            response.context.http_response.status_code = 200
+            response.context[:logging_started_at] = now - 1.12345
+            response.context[:logging_completed_at] = now
+          end
+
+          describe '.default' do
+
+            it 'provides a basic logging format' do
+              formatted = format(Formatter.default.pattern)
+              expect(formatted).to eq(<<-EXAMPLE)
+[Class 200 1.12345 3 retries] operation_name(limit:1) RuntimeError error-message
+              EXAMPLE
+            end
+
+          end
+
+          describe '.short' do
+
+            it 'provides a basic logging format' do
+              formatted = format(Formatter.short.pattern)
+              expect(formatted).to eq(<<-EXAMPLE)
+[Class 200 1.12345] operation_name RuntimeError
+              EXAMPLE
+            end
+
+          end
+
+          describe '.colored' do
+
+            it 'provides a basic logging format' do
+              formatted = format(Formatter.colored.pattern)
+              expect(formatted).to eq(<<-EXAMPLE)
+\e[1m\e[34m[Class 200 1.12345 3 retries]\e[0m\e[1m operation_name(limit:1) RuntimeError error-message\e[0m
+              EXAMPLE
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'logger'
+
+module Seahorse
+  module  Client
+    module Logging
+      describe Handler do
+
+        class LogNullDevice
+          attr_reader :messages
+          def write(msg)
+            @messages ||= ''
+            @messages << msg
+          end
+          def close; end
+        end
+
+        class TestFormatter
+          def format(response)
+            'test-formatter-log-msg'
+          end
+        end
+
+        def handle!
+          @log_dev ||= LogNullDevice.new
+          @logger ||= Logger.new(@log_dev)
+          @log_level ||= :info
+          @formatter ||= TestFormatter.new
+          @config ||= double('config',
+            logger: @logger,
+            log_level: @log_level,
+            log_formatter: @formatter)
+          @handler ||= Handler.new(lambda { |context|
+            context.http_response.status_code = 200
+            Response.new(context: context)
+          })
+          @handler.call(RequestContext.new(config: @config))
+        end
+
+        it 'populates the request context with timing information' do
+          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]
+        end
+
+        it 'sends the formatted message to the logger' do
+          handle!
+          expect(@log_dev.messages).to match(/test-formatter-log-msg/)
+        end
+
+        it 'sends the message at the right log level' do
+          @log_dev = LogNullDevice.new
+          @logger = Logger.new(@log_dev)
+          @logger.level = Logger::WARN
+          handle!
+          expect(@log_dev.messages).to be(nil)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+      module NetHttp
+      describe ConnectionPool do
+      end
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+require 'spec_helper'
+require 'ostruct'
+require 'stringio'
+
+module Seahorse
+  module Client
+    module NetHttp
+      describe Handler do
+
+        before(:each) { WebMock.disable_net_connect! }
+
+        let(:config) { OpenStruct.new }
+
+        let(:handler) { Handler.new }
+
+        let(:make_request) { handler.call(context) }
+
+        let(:context) do
+          RequestContext.new.tap do |context|
+            context.config = config
+            context.http_request.endpoint = endpoint
+          end
+        end
+
+        def endpoint
+          @endpoint ||= Http::Endpoint.new('test.endpoint.api')
+        end
+
+        describe '#pool' do
+
+          let(:handler_pool) { handler.pool_for(config) }
+
+          it 'constructs a ConnectionPool' do
+            expect(handler_pool).to be_kind_of(ConnectionPool)
+          end
+
+          it 'configures the pool#http_proxy' do
+            config.http_proxy = 'http://proxy.com'
+            expect(handler_pool.http_proxy).to eq(URI.parse('http://proxy.com'))
+          end
+
+          it 'configures the pool#http_continue_timeout' do
+            config.http_continue_timeout = 123
+            expect(handler_pool.http_continue_timeout).to eq(123)
+          end
+
+          it 'configures the pool#http_open_timeout' do
+            config.http_open_timeout = 123
+            expect(handler_pool.http_open_timeout).to eq(123)
+          end
+
+          it 'configures the pool#http_read_timeout' do
+            config.http_read_timeout = 123
+            expect(handler_pool.http_read_timeout).to eq(123)
+          end
+
+          it 'configures the pool#http_idle_timeout' do
+            config.http_idle_timeout = 123
+            expect(handler_pool.http_idle_timeout).to eq(123)
+          end
+
+          it 'configures the pool#http_wire_trace' do
+            config.http_wire_trace = true
+            expect(handler_pool.http_wire_trace).to eq(true)
+          end
+
+          it 'configures the pool#logger' do
+            config.http_wire_trace = true
+            config.logger = Object.new
+            expect(handler_pool.logger).to be(config.logger)
+          end
+
+          it 'configures the pool#ssl_verify_peer' do
+            config.ssl_verify_peer = false
+            expect(handler_pool.ssl_verify_peer).to eq(false)
+          end
+
+          it 'configures the pool#ssl_ca_bundle' do
+            config.ssl_ca_bundle = '/path/to/ca-bundle.crt'
+            expect(handler_pool.ssl_ca_bundle).to eq('/path/to/ca-bundle.crt')
+          end
+
+          it 'configures the pool#ssl_ca_directory' do
+            config.ssl_ca_bundle = '/path/to/certs'
+            expect(handler_pool.ssl_ca_bundle).to eq('/path/to/certs')
+          end
+
+        end
+
+        describe '#call' do
+
+          let(:http_request) { context.http_request }
+
+          it 'returns a Response object from #call' do
+            stub_request(:any, endpoint)
+            resp = make_request
+            expect(resp).to be_kind_of(Response)
+          end
+
+          it 'populates the #context of the returned response' do
+            stub_request(:any, endpoint)
+            resp = make_request
+            expect(resp.context).to be(context)
+          end
+
+          describe 'request endpoint' do
+
+            it 'makes a request against the given endpoint' do
+              @endpoint = Http::Endpoint.new('http://foo.bar.com')
+              stub_request(:any, 'http://foo.bar.com')
+              make_request
+            end
+
+            it 'observes the Endpoint#port' do
+              @endpoint = Http::Endpoint.new('http://foo.bar.com:9876')
+              stub_request(:any, 'http://foo.bar.com:9876')
+              make_request
+            end
+
+            it 'observes the Endpoint#scheme' do
+              @endpoint = Http::Endpoint.new('https://foo.bar.com')
+              stub_request(:any, 'https://foo.bar.com')
+              make_request
+            end
+
+          end
+
+          describe 'request http method' do
+
+            it 'uses the http_request#http_method to make the request' do
+              http_request.http_method = 'POST'
+              stub_request(:post, endpoint)
+              make_request
+            end
+
+            it 'raises a helpful error if the request method is invalid' do
+              message = '`abc` is not a valid http verb'
+              http_request.http_method = 'abc'
+              expect { make_request }.to raise_error(
+                Handler::InvalidHttpVerbError, message)
+            end
+
+          end
+
+          describe 'request headers' do
+
+            it 'passes along http_request#headers' do
+              http_request.headers['abc'] = 'xyz'
+              stub_request(:any, endpoint).with(:headers => { 'abc' => 'xyz' })
+              make_request
+            end
+
+            it 'populates a default content-type header' do
+              # this prevents net/http from setting content-type on our behalf
+              stub_request(:any, endpoint).
+                with(:headers => { 'content-type' => '' })
+              make_request
+            end
+
+            it 'does not clobber a custom content-type' do
+              http_request.headers['Content-Type'] = 'application/json'
+              stub_request(:any, endpoint).
+                with(:headers => { 'content-type' => 'application/json' })
+              make_request
+            end
+
+            it 'populates a default accept-encoding header' do
+              # this prevents net/http from setting accept-encoding on our behalf
+              stub_request(:any, endpoint).
+                with(:headers => { 'accept-encoding' => '' })
+              make_request
+            end
+
+            it 'does not clobber a custom accept-encoding' do
+              http_request.headers['Accept-Encoding'] = 'text/plain'
+              stub_request(:any, endpoint).
+                with(:headers => { 'accept-encoding' => 'text/plain' })
+              make_request
+            end
+
+          end
+
+          describe 'request path' do
+
+            it 'sends the request with the correct request uri' do
+              http_request.path = '/path'
+              stub_request(:any, "#{endpoint}/path")
+              make_request
+            end
+
+            it 'sends the request with the querystring' do
+              http_request.path = '/abc?mno=xyz'
+              stub_request(:any, "#{endpoint}/abc?mno=xyz")
+              make_request
+            end
+
+          end
+
+          describe 'request body' do
+
+            it 'sends the body' do
+              http_request.body = StringIO.new('request-body')
+              stub_request(:any, endpoint).with(body: 'request-body')
+              make_request
+            end
+
+          end
+
+          describe 'response' do
+
+            it 'populates the status code' do
+              stub_request(:any, endpoint).to_return(status: 200)
+              expect(make_request.http_response.status_code).to eq(200)
+            end
+
+            it 'populates the headers' do
+              stub_request(:any, endpoint).to_return(headers: { foo: 'bar' })
+              expect(make_request.http_response.headers['foo']).to eq('bar')
+            end
+
+            it 'populates the response body' do
+              stub_request(:any, endpoint).to_return(body: 'response-body')
+              resp_body = make_request.http_response.body
+              expect(resp_body.read).to eq('response-body')
+            end
+
+          end
+        end
+      end
+    end
+  end
+end