aws-sdk-core 2.0.0.rc1

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

@@ -0,0 +1,159 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Seahorse
+  module Client
+    describe HandlerBuilder do
+
+      let(:klass) {
+        Class.new do
+
+          include HandlerBuilder
+
+          def initialize
+            @handlers = HandlerList.new
+          end
+
+          attr_reader :handlers
+
+        end
+      }
+
+      let(:obj) { klass.new }
+
+      describe '#handler' do
+
+        it 'registers a handler' do
+          handler_class = Class.new(Handler)
+          obj.handler(handler_class)
+          expect(obj.handlers).to include(handler_class)
+        end
+
+        it 'accepts a step option' do
+          handler1 = Class.new(Handler)
+          handler2 = Class.new(Handler)
+          obj.handler(handler1, step: :validate)
+          obj.handler(handler2, step: :build)
+          expect(obj.handlers).to include(handler1)
+          expect(obj.handlers).to include(handler2)
+        end
+
+        it 'builds a handler from a block' do
+          handler_class = obj.handler do |context|
+            context
+          end
+          expect(handler_class.ancestors).to include(Handler)
+          expect(handler_class.new.call('context')).to eq('context')
+        end
+
+        it 'accepts a step with the block' do
+          obj.handler(step: :validate) do |context|
+            context << :validate
+            super(context)
+          end
+          obj.handler(step: :build) do |context|
+            context << :build
+            @handler.call(context)
+          end
+          obj.handler(step: :sign) do |context|
+            context << :sign
+            handler.call(context)
+          end
+          obj.handler(step: :send) do |context|
+            context << :send
+            context
+          end
+          resp = obj.handlers.to_stack.call([])
+          expect(resp).to eq([:validate, :build, :sign, :send])
+        end
+
+        it 'returns the handler class' do
+          handler_class = Class.new(Handler)
+          expect(obj.handler(handler_class)).to be(handler_class)
+        end
+
+      end
+
+      describe '#handle_request' do
+
+        it 'passes the context to the block' do
+          yielded = nil
+          handler = obj.handle_request do |context|
+            yielded = context
+          end
+          handler.new(->(_) { }).call('context')
+          expect(yielded).to eq('context')
+        end
+
+        it 'calls the next handler in the stack reguardless of the return' do
+          handler = obj.handle_request do |context|
+            nil # still calls the next handler, despite the block return value
+          end
+          context = Object.new
+          resp = handler.new(->(context) { context }).call(context)
+          expect(resp).to be(context)
+        end
+
+      end
+
+      describe '#handle_response' do
+
+        it 'is called when the response is signaled complete' do
+          called = false
+          handler = obj.handle_response { |response| called = true }
+          handler.new(->(_) { Response.new.tap {|r| r.http_response.status_code = 200 } }).call(nil)
+          expect(called).to be(true)
+        end
+
+        it 'is not called if the response is not signaled complete' do
+          called = false
+          handler = obj.handle_response { |response| called = true }
+          handler.new(->(_) { Response.new }).call(nil)
+          expect(called).to be(false)
+        end
+
+      end
+
+      describe 'naming handlers inside modules' do
+
+        let(:mod) {
+          Module.new do
+            extend HandlerBuilder
+            def self.handlers
+              @handlers ||= HandlerList.new
+            end
+          end
+        }
+
+        it 'assigns the handler to a constant if a name is given' do
+          expect(mod.const_defined?('MyHandler')).to be(false)
+          handler_class = mod.handler('MyHandler') { |arg| }
+          expect(mod::MyHandler).to be(handler_class)
+        end
+
+        it 'accepts the handler name as a symbol' do
+          handler_class = mod.handler(:MyHandler) { |arg| }
+          expect(mod::MyHandler).to be(handler_class)
+        end
+
+        it 'accepts a name and options at the same time' do
+          mod.handler(:FirstSendHandler, step: :send) { |arg| }
+          mod.handler(:SecondSendHandler, step: :send) { |arg| }
+          expect(mod.handlers).not_to include(mod::FirstSendHandler)
+          expect(mod.handlers).to include(mod::SecondSendHandler)
+        end
+
+        it 'can assign a name when calling handle_request' do
+          handler_class = mod.handle_request(:MyHandler) { |arg| }
+          expect(mod::MyHandler).to be(handler_class)
+        end
+
+        it 'can assign a name when calling handle_response' do
+          handler_class = mod.handle_response(:MyHandler) { |arg| }
+          expect(mod::MyHandler).to be(handler_class)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    describe HandlerList do
+
+      let(:handlers) { HandlerList.new }
+
+      it 'is enumerable' do
+        expect(handlers).to be_kind_of(Enumerable)
+      end
+
+      describe '#add' do
+
+        it 'adds a handler' do
+          handler = Class.new
+          handlers.add(handler)
+          expect(handlers.to_a).to eq([handler])
+        end
+
+        it 'handlers added latter 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])
+        end
+
+        it 'returns the handler class' do
+          handler_class = Class.new(Handler)
+          expect(handlers.add(handler_class)).to be(handler_class)
+        end
+
+        describe ':step' do
+
+          it 'sorts handlers by step priority order' do
+            handlers.add('validate', step: :validate)
+            handlers.add('build', step: :build)
+            handlers.add('sign', step: :sign)
+            handlers.add('send', step: :send)
+            expect(handlers.to_a).to eq(%w(send sign build validate))
+          end
+
+          it 'defaults step to :build' do
+            handlers.add('validate', step: :validate)
+            handlers.add('build')
+            handlers.add('sign', step: :sign)
+            expect(handlers.to_a).to eq(['sign', 'build', 'validate'])
+          end
+
+          it 'accepts multiple handlers with the same step' do
+            handlers.add('h1', step: :validate)
+            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))
+          end
+
+        end
+
+        describe ':priority' do
+
+          it 'accepts a priority' do
+            handlers.add('medium', priority: 50)
+            handlers.add('high', priority: 80)
+            handlers.add('low', priority: 20)
+            expect(handlers.to_a).to eq(%w(low medium high))
+          end
+
+          it 'sorts handler with the same priority in FIFO order' do
+            handlers.add('a', priority: 20, step: :sign)
+            handlers.add('b', priority: 20, step: :sign)
+            handlers.add('c', priority: 20, step: :sign)
+            handlers.add('m', priority: 20, step: :build)
+            handlers.add('n', priority: 20, step: :build)
+            handlers.add('o', priority: 20, step: :build)
+            handlers.add('x', priority: 20, step: :validate)
+            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))
+          end
+
+        end
+
+        describe 'errors' do
+
+          it 'raises an error if :step is not valid' do
+            msg = "invalid :step `:bogus', must be one of :validate, :build, "
+            msg << ":sign or :send"
+            expect {
+              handlers.add('handler', step: :bogus)
+            }.to raise_error(ArgumentError, msg)
+          end
+
+          it 'raises an error if :priority is less than 0' do
+            msg = "invalid :priority `-1', must be between 0 and 99"
+            expect {
+              handlers.add('handler', priority: -1)
+            }.to raise_error(ArgumentError, msg)
+          end
+
+          it 'raises an error if :priority is greater than 99' do
+            msg = "invalid :priority `100', must be between 0 and 99"
+            expect {
+              handlers.add('handler', priority: 100)
+            }.to raise_error(ArgumentError, msg)
+          end
+
+        end
+
+        describe ':step => :send' do
+
+          it 'only keeps the latest send handler' do
+            handlers.add('handler1', step: :send)
+            handlers.add('handler2', step: :send)
+            handlers.add('handler3', step: :send)
+            expect(handlers.to_a).to eq(['handler3'])
+          end
+
+          it 'ignores :priority when adding :send handlers' do
+            handlers.add('handler1', step: :send, priority: 80)
+            handlers.add('handler2', step: :send, priority: 50)
+            handlers.add('handler3', step: :send, priority: 20)
+            expect(handlers.to_a).to eq(['handler3'])
+          end
+
+        end
+
+        describe ':operations' do
+
+          it 'adds a handler that is not enumerated by default' do
+            handlers.add('handler', operations: ['operation_name'])
+            expect(handlers.to_a).to eq([])
+          end
+
+          it 'adds a handler that is enumerated for a given :operation' do
+            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))
+          end
+
+        end
+
+      end
+
+      describe '#copy_from' do
+
+        it 'copies handlers from one list to another' do
+          handlers.add('send', step: :send)
+          handlers.add('handler')
+          handlers2 = HandlerList.new
+          handlers2.copy_from(handlers)
+          expect(handlers2.to_a).to eq(handlers.to_a)
+        end
+
+      end
+
+      describe '#for' do
+
+        it 'returns a handler list' do
+          expect(handlers.for('operation')).to be_kind_of(HandlerList)
+        end
+
+        it 'returns a different handler list' do
+          expect(handlers.for('operation')).to_not be(handlers)
+        end
+
+        it 'copies the send handler' do
+          handlers.add('send', step: :send)
+          expect(handlers.for('operation').to_a).to eq(['send'])
+        end
+
+        it 'copies the common handlers' do
+          handlers.add('validate', step: :validate)
+          handlers.add('build', step: :build)
+          handlers.add('sign', step: :sign)
+          expect(handlers.for('operation').to_a).to eq(%w(sign build validate))
+        end
+
+        it 'deep copies handlers' do
+          handlers.add('handler1')
+          handlers2 = handlers.for('operation')
+          handlers2.add('handler2')
+          expect(handlers.to_a).to eq(['handler1'])
+          expect(handlers2.to_a).to eq(['handler1', 'handler2'])
+        end
+
+        it 'copies operation handlers with the given name' do
+          handlers.add('handler', operations: ['operation'])
+          expect(handlers.for('operation').to_a).to eq(['handler'])
+        end
+
+        it 'does not copy operation handlers that have a different name' do
+          handlers.add('handler', operations: ['operation'])
+          expect(handlers.for('operation2').to_a).to eq([])
+        end
+
+        it 'merges operation and common handlers preserving priority' do
+          handlers.add('high', priority: 30, operation: 'operation')
+          handlers.add('medium', priority: 20, operation: 'operation')
+          handlers.add('low', priority: 10)
+          expect(handlers.for('operation').to_a).to eq(%w(low medium high))
+        end
+
+        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))
+        end
+
+      end
+
+      describe '#to_stack' do
+
+        it 'constructs a handler stack' do
+          handler = Handler
+          expect(handler).to receive(:new).with(nil).and_return(1)
+          expect(handler).to receive(:new).with(1).and_return(2)
+          expect(handler).to receive(:new).with(2).and_return(3)
+          handlers.add(handler)
+          handlers.add(handler)
+          handlers.add(handler)
+          expect(handlers.to_stack).to eq(3)
+        end
+
+        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)
+          handlers.add(handler1)
+          handlers.add(handler2)
+          handlers.to_stack
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    describe Handler do
+
+      let(:context) { RequestContext.new }
+      let(:response) { Response.new }
+
+      it 'provides access to the nested handler' do
+        handler = Handler.new
+        expect(Handler.new(handler).handler).to be(handler)
+      end
+
+      it 'responds to #call' do
+        expect(Handler.new).to respond_to(:call)
+      end
+
+      it 'chains #call to the nested handler' do
+        handler = double('handler')
+        expect(handler).to receive(:call).with(context) { response }
+        Handler.new(handler).call(context)
+      end
+
+      it 'returns the response from the nested handler' do
+        handler = double('handler')
+        expect(handler).to receive(:call).with(context) { response }
+        expect(Handler.new(handler).call(context)).to be(response)
+      end
+
+      describe '#inspect' do
+
+        it 'overrides class name for anonymous handler' do
+          handler = Class.new(Handler).new
+          expect(handler.inspect).to eql '#<UnnamedHandler @handler=nil>'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Http
+      describe Endpoint do
+        describe 'constructor' do
+
+          it 'can be constructed from a string' do
+            expect(Endpoint.new('abc.com')).to be_kind_of(Endpoint)
+          end
+
+          it 'can be constructed from a URI::HTTP' do
+            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'
+            expect(Endpoint.new(URI.parse(uri))).to eq(uri)
+          end
+
+          it 'can be constructed from an Endpoint' do
+            endpoint1 = Endpoint.new('abc.com')
+            endpoint2 = Endpoint.new(endpoint1) # copy constructor
+            expect(endpoint1).to eq(endpoint2)
+          end
+
+          it 'raises an error if you pass non valid enpoint' do
+            expect do
+              Endpoint.new(Class.new)
+            end.to raise_error(URI::InvalidURIError)
+          end
+
+        end
+
+        describe '#scheme' do
+
+          it 'can be specified in the constructor' do
+            expect(Endpoint.new('http://foo.com').scheme).to eq('http')
+            expect(Endpoint.new('https://foo.com').scheme).to eq('https')
+          end
+
+          it 'defaults to https when not passed to constructor' do
+            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.scheme = 'https'
+            expect(endpoint.port).to eq(80)
+            expect(endpoint.scheme).to eq('https')
+            expect(endpoint).to eq('https://foo.com:80')
+          end
+
+        end
+
+        describe '#http?' do
+
+          it 'returns true if the scheme is http' do
+            expect(Endpoint.new('http://foo.com').http?).to eq(true)
+          end
+
+          it 'returns false if the scheme is not http' do
+            expect(Endpoint.new('https://foo.com').http?).to eq(false)
+          end
+
+        end
+
+        describe '#https?' do
+
+          it 'returns true if the scheme is https' do
+            expect(Endpoint.new('https://foo.com').https?).to eq(true)
+          end
+
+          it 'returns false if the scheme is not https' do
+            expect(Endpoint.new('http://foo.com').https?).to eq(false)
+          end
+
+        end
+
+        describe '#host' do
+
+          it 'is passed into the constructor' do
+            expect(Endpoint.new('foo.com').host).to eq('foo.com')
+            expect(Endpoint.new('abc.mno.xyz').host).to eq('abc.mno.xyz')
+          end
+
+          it 'can be changed' do
+            endpoint = Endpoint.new('http://foo.com')
+            endpoint.host = 'bar.com'
+            expect(endpoint.host).to eq('bar.com')
+            expect(endpoint).to eq('http://bar.com')
+          end
+
+        end
+
+        describe '#port' do
+
+          it 'defaults to 80 for http endpoints' do
+            expect(Endpoint.new('http://foo.com').port).to eq(80)
+          end
+
+          it 'defaults to 443 for https endpoints' do
+            expect(Endpoint.new('https://foo.com').port).to eq(443)
+          end
+
+          it 'can be specified in the constructor' do
+            expect(Endpoint.new('http://foo.com:123').port).to eq(123)
+            expect(Endpoint.new('foo.com:321').port).to eq(321)
+          end
+
+          it 'can be changed' do
+            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')
+          end
+
+        end
+
+        describe '#user' do
+
+          it 'defaults to nil' do
+            expect(Endpoint.new('foo.com').user).to be(nil)
+          end
+
+          it 'is parsed from the endpoint string' do
+            expect(Endpoint.new('http://user@foo.com').user).to eq('user')
+          end
+
+          it 'can be set' do
+            endpoint = Endpoint.new('foo.com')
+            endpoint.user = 'abc'
+            expect(endpoint.user).to eq('abc')
+            expect(endpoint).to eq('https://abc@foo.com')
+          end
+
+        end
+
+        describe '#password' do
+
+          it 'defaults to nil' do
+            expect(Endpoint.new('foo.com').password).to be(nil)
+          end
+
+          it 'is parsed from the endpoint string' do
+            expect(Endpoint.new('http://u:p@foo.com').password).to eq('p')
+          end
+
+          it 'can be set' do
+            endpoint = Endpoint.new('foo.com')
+            endpoint.user = 'u'
+            endpoint.password = 'p'
+            expect(endpoint.password).to eq('p')
+            expect(endpoint).to eq('https://u:p@foo.com')
+          end
+
+        end
+      end
+    end
+  end
+end