aws-sdk-core 2.0.0.rc1

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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Plugins
+      describe OperationMethods do
+        let(:client_class) do
+          Client::Base.define api: {
+            'plugins' => [DummySendPlugin],
+            'operations' => {
+              'operation1' => { 'name' => 'operation1' },
+              'operation2' => { 'name' => 'operation2' },
+              'operation3' => { 'name' => 'operation3' }
+            }
+          }
+        end
+
+        let(:client) { client_class.new endpoint: 'localhost' }
+
+        let(:operations) { %w(operation1 operation2 operation3) }
+
+        it 'adds methods for every operation in the API model' do
+          expect(client.methods).to include(*operations.map(&:to_sym))
+        end
+
+        it 'sets up the method to call build_request and sends it' do
+          client_class.remove_plugin(ParamValidation)
+          expect(client).to receive(:build_request).
+            with('operation1', param: 'X').and_call_original
+          expect(client.operation1(param: 'X').data).to eq(result: 'success')
+        end
+
+        it 'passes block arguments to the #send_request method' do
+          req = double('request')
+          allow(client).to receive(:build_request).and_return(req)
+          allow(req).to receive(:send_request).
+            and_yield('chunk1').
+            and_yield('chunk2').
+            and_yield('chunk3')
+
+          chunks = []
+          client.operation1 do |chunk|
+            chunks << chunk
+          end
+          expect(chunks).to eq(%w(chunk1 chunk2 chunk3))
+        end
+
+        it 'can be removed from client' do
+          next_client_class = Class.new(client_class)
+          next_client_class.remove_plugin OperationMethods
+          client = next_client_class.new
+
+          expect(client.methods).not_to include(*operations.map(&:to_sym))
+          expect { client.operation1 }.to raise_error(NoMethodError)
+        end
+
+        it 'defines a helper that returns the list of valid operation names' do
+          expect(client.operation_names).to eq(operations)
+        end
+
+        it 'only registers methods on the client class once' do
+          expect(client_class).to receive(:define_method).
+            with(:operation_names).exactly(1).times
+          operations.each do |operation_name|
+            expect(client_class).to receive(:define_method).
+              with(operation_name).exactly(1).times
+          end
+          client_class.new(endpoint: 'localhost')
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client/plugins/restful_bindings/uri_path_builder_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Plugins
+      class RestfulBindings
+        describe UriPathBuilder 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)
+          end
+
+          it 'does not modify paths without placeholders' do
+            path = path_for('/', {})
+            expect(path).to eq('/')
+          end
+
+          describe 'path params' do
+
+            it 'replaces querystring placeholders' do
+              rules['members'] = {
+                'foo' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/{foo}', foo: 'bar')
+              expect(path).to eq('/bar')
+            end
+
+            it 'uri escapes path params' do
+              rules['members'] = {
+                'foo' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/{foo}', foo: 'foo&bar')
+              expect(path).to eq('/foo%26bar')
+            end
+
+            it 'it does not escape forward slashes' do
+              rules['members'] = {
+                'foo' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/{foo}/yuck', foo: 'foo/bar')
+              expect(path).to eq('/foo/bar/yuck')
+            end
+
+          end
+
+          describe 'querystring params' do
+
+            it 'replaces querystring placeholders' do
+              rules['members'] = {
+                'foo' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/path?foo={foo}', { foo: 'bar'})
+              expect(path).to eq('/path?foo=bar')
+            end
+
+            it 'removes empty querystring params' do
+              rules['members'] = {
+                'mno' => { 'type' => 'string', 'location' => 'uri' },
+                'xyz' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/path?Mno={mno}&Xyz={xyz}', { mno: '123' })
+              expect(path).to eq('/path?Mno=123')
+            end
+
+            it 'prunes the querystring if empty' do
+              rules['members'] = {
+                'mno' => { 'type' => 'string', 'location' => 'uri' },
+                'xyz' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/path?Mno={mno}Xyz={xyz}', {})
+              expect(path).to eq('/path')
+            end
+
+            it 'uri escapes querystring params' do
+              rules['members'] = {
+                'abc' => { 'type' => 'string', 'location' => 'uri' },
+                'xyz' => { 'type' => 'string', 'location' => 'uri' }
+              }
+              path = path_for('/{abc}?Xyz={xyz}', abc: 'a b', xyz: 'foo&bar')
+              expect(path).to eq('/a%20b?Xyz=foo%26bar')
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    describe RequestContext do
+
+      describe '#operation_name' do
+
+        it 'defaults to nil' do
+          expect(RequestContext.new.operation_name).to be(nil)
+        end
+
+        it 'can be set in the constructor' do
+          context = RequestContext.new(operation_name: 'operation_name')
+          expect(context.operation_name).to eq('operation_name')
+        end
+
+      end
+
+      describe '#params' do
+
+        it 'defaults to a empty hash' do
+          expect(RequestContext.new.params).to eq({})
+        end
+
+        it 'can be set in the constructor' do
+          params = Object.new
+          expect(RequestContext.new(params: params).params).to be(params)
+        end
+
+      end
+
+      describe '#config' do
+
+        it 'defaults to nil' do
+          expect(RequestContext.new.config).to be(nil)
+        end
+
+        it 'can be set in the constructor' do
+          config = Object.new
+          expect(RequestContext.new(config: config).config).to be(config)
+        end
+
+      end
+
+      describe '#retries' do
+
+        it 'defaults to 0' do
+          expect(RequestContext.new.retries).to eq(0)
+        end
+
+        it 'can be incremented' do
+          context = RequestContext.new
+          context.retries += 1
+          context.retries += 1
+          expect(context.retries).to eq(2)
+        end
+
+      end
+
+      describe '#http_request' do
+
+        it 'defaults to a Http::Request object' do
+          expect(RequestContext.new.http_request).to be_kind_of(Http::Request)
+        end
+
+        it 'can be set in the constructor' do
+          http_req = Object.new
+          context = RequestContext.new(http_request: http_req)
+          expect(context.http_request).to be(http_req)
+        end
+
+      end
+
+      describe '#http_response' do
+
+        it 'defaults to a Http::Response object' do
+          expect(RequestContext.new.http_response).to be_kind_of(Http::Response)
+        end
+
+        it 'can be set in the constructor' do
+          http_resp = Object.new
+          context = RequestContext.new(http_response: http_resp)
+          expect(context.http_response).to be(http_resp)
+        end
+
+      end
+
+      describe 'metadata' do
+
+        it 'returns nil for non-set keys' do
+          context = RequestContext.new
+          expect(context[:color]).to eq(nil)
+        end
+
+        it 'can be set via #[]=' do
+          context = RequestContext.new
+          context[:color] = 'red'
+          expect(context[:color]).to eq('red')
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    describe Request do
+
+      let(:handlers) { HandlerList.new }
+
+      let(:context) { RequestContext.new }
+
+      let(:request) { Request.new(handlers, context) }
+
+      it 'is a HandlerBuilder' do
+        expect(request).to be_kind_of(HandlerBuilder)
+      end
+
+      describe '#handlers' do
+
+        it 'returns the handler list' do
+          handlers = HandlerList.new
+          request = Request.new(handlers, context)
+          expect(request.handlers).to be(handlers)
+        end
+
+      end
+
+      describe '#context' do
+
+        it 'returns the request context given the constructor' do
+          context = RequestContext.new
+          request = Request.new(handlers, context)
+          expect(request.context).to be(context)
+        end
+
+      end
+
+      describe '#send_request' do
+
+        it 'contructs a stack from the handler list' do
+          expect(handlers).to receive(:to_stack).and_return(->(context) {})
+          request.send_request
+        end
+
+        it 'returns the response from the handler stack #call method' do
+          response = double('response')
+          allow(handlers).to receive(:to_stack).and_return(->(_) { response })
+          expect(request.send_request).to be(response)
+        end
+
+        it 'passes the request context to the handler stack' do
+          passed = nil
+          allow(handlers).to receive(:to_stack).
+            and_return(->(context) { passed = context })
+          request.send_request
+          expect(passed).to be(context)
+        end
+
+        it 'returns the response from the handler stack' do
+          resp = Response.new
+          allow(handlers).to receive(:to_stack).and_return(->(context) { resp })
+          expect(Request.new(handlers, context).send_request).to be(resp)
+        end
+
+      end
+
+      describe '#send_request with a block' do
+
+        let(:handler) do
+          Proc.new do
+            context.http_response.body.write('part1')
+            context.http_response.body.write('part2')
+            context.http_response.body.write('part3')
+            Response.new(context: context)
+          end
+        end
+
+        before(:each) do
+          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'])
+        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.rewind }.to raise_error(NotImplementedError)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+require 'spec_helper'
+require 'pp'
+
+module Seahorse
+  module Client
+    describe Response do
+
+      describe '#inspect' do
+
+        it 'returns the inspect string for the data' do
+          resp = Response.new
+          resp.data = double('data')
+          expect(resp.inspect).to eq(resp.data.pretty_inspect)
+        end
+
+        it 'returns the default inspect if data is not set' do
+          expect(Response.new.inspect).to include('#<Seahorse::Client::Response:')
+        end
+
+      end
+
+      describe '#data' do
+
+        it 'can be set' do
+          data = double('data')
+          resp = Response.new
+          resp.data = data
+          expect(resp.data).to be(data)
+        end
+
+        it 'can be accessed via method_missing on the response' do
+          data = double('data', foo: 'bar')
+          resp = Response.new
+          resp.data = data
+          expect(resp.foo).to be(data.foo)
+        end
+
+        it 'correctly answers respond_to?' do
+          data = double('data', foo: 'bar')
+          resp = Response.new
+          resp.data = data
+          expect(resp.respond_to?(:foo)).to be(true)
+        end
+
+      end
+
+      describe '#context' do
+
+        it 'defaults to a new context' do
+          expect(Response.new.context).to be_kind_of(RequestContext)
+        end
+
+        it 'can be set in the constructor' do
+          context = RequestContext.new
+          expect(Response.new(context: context).context).to be(context)
+        end
+
+      end
+
+      describe '#http_request' do
+
+        it 'returns the context #http_request' do
+          http_request = Http::Request.new
+          context = RequestContext.new(http_request: http_request)
+          resp = Response.new(context: context)
+          expect(resp.http_request).to be(http_request)
+        end
+
+      end
+
+      describe '#http_response' do
+
+        it 'returns the context #http_response' do
+          http_response = Http::Response.new
+          context = RequestContext.new(http_response: http_response)
+          resp = Response.new(context: context)
+          expect(resp.http_response).to be(http_response)
+        end
+
+      end
+
+      describe 'callbacks' do
+
+        let(:http_resp) { Http::Response.new }
+
+        let(:response) {
+          Response.new(context: RequestContext.new(http_response: http_resp))
+        }
+
+        describe '#on_complete' do
+
+          it 'triggers the callback when a response is received' do
+            http_resp.status_code = 200
+            expect { |b| response.on_complete(&b) }.to yield_control
+          end
+
+          it 'does not trigger when when a response is not received' do
+            http_resp.status_code = 0
+            expect { |b| response.on_complete(&b) }.not_to yield_control
+          end
+
+        end
+
+        describe '#on_success' do
+
+          it 'triggers the callback when response has a ~ 200 status code' do
+            http_resp.status_code = 0
+            expect { |b| response.on_success(&b) }.not_to yield_control
+            http_resp.status_code = 200
+            expect { |b| response.on_success(&b) }.to yield_control
+            http_resp.status_code = 299
+            expect { |b| response.on_success(&b) }.to yield_control
+            http_resp.status_code = 300
+            expect { |b| response.on_success(&b) }.not_to yield_control
+          end
+
+        end
+
+        describe '#on_redirect' do
+
+          it 'triggers the callback when response has a ~ 300 status code' do
+            http_resp.status_code = 200
+            expect { |b| response.on_redirect(&b) }.not_to yield_control
+            http_resp.status_code = 304
+            expect { |b| response.on_redirect(&b) }.to yield_control
+            http_resp.status_code = 307
+            expect { |b| response.on_redirect(&b) }.to yield_control
+            http_resp.status_code = 400
+            expect { |b| response.on_redirect(&b) }.not_to yield_control
+          end
+
+        end
+
+        describe '#on_error' do
+
+          it 'triggers the callback when response has a ~ 400-500 code' do
+            http_resp.status_code = 0
+            expect { |b| response.on_error(&b) }.not_to yield_control
+            http_resp.status_code = 200
+            expect { |b| response.on_error(&b) }.not_to yield_control
+            http_resp.status_code = 300
+            expect { |b| response.on_error(&b) }.not_to yield_control
+            http_resp.status_code = 400
+            expect { |b| response.on_error(&b) }.to yield_control
+            http_resp.status_code = 500
+            expect { |b| response.on_error(&b) }.to yield_control
+          end
+
+        end
+
+        describe '#on_failure' do
+
+          it 'triggers the callback when a response is not received' do
+            http_resp.status_code = 0
+            expect { |b| response.on_failure(&b) }.to yield_control
+            http_resp.status_code = 200
+            expect { |b| response.on_failure(&b) }.not_to yield_control
+            http_resp.status_code = 300
+            expect { |b| response.on_failure(&b) }.not_to yield_control
+            http_resp.status_code = 400
+            expect { |b| response.on_failure(&b) }.not_to yield_control
+            http_resp.status_code = 500
+            expect { |b| response.on_failure(&b) }.not_to yield_control
+          end
+
+        end
+
+      end
+    end
+  end
+end