aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/lib/seahorse/model/types.rb

@@ -0,0 +1,8 @@
+
+module Seahorse
+  module Model
+    module Types
+      Boolean = Class.new
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/version.rb

@@ -0,0 +1,3 @@
+module Seahorse
+  VERSION = '0.1.0'
+end

data/vendor/seahorse/seahorse.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'seahorse'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'seahorse'
+  spec.version       = Seahorse::VERSION
+  spec.authors       = ['Amazon Web Services', 'Trevor Rowe']
+  spec.email         = ['trevorrowe@gmail.com']
+  spec.summary       = 'Client for Seahorse compatible web services.'
+  spec.description   = 'Seahorse::Client is an extensible web service client that consumes Seahorse model descriptions.'
+  spec.homepage      = 'http://github.com/seahorse/client'
+  spec.license       = 'Apache 2.0'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+end

data/vendor/seahorse/spec/fixtures/plugin.rb

@@ -0,0 +1,4 @@
+module SeahorseFixtures
+  class Plugin
+  end
+end

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

@@ -0,0 +1,308 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Seahorse
+  module Client
+    describe Base do
+
+      let(:api) {{
+        'endpoint' => 'http://endpoint:123',
+        'operations' => {
+          'operation_name' => {},
+        }
+      }}
+
+      let(:client_class) { Base.define(api: api) }
+
+      let(:client) { client_class.new }
+
+      let(:required_plugins) { Base::REQUIRED_PLUGINS }
+
+      let(:plugin_a) { Class.new }
+
+      let(:plugin_b) { Class.new }
+
+      it 'is a HandlerBuilder' do
+        expect(client).to be_kind_of(HandlerBuilder)
+      end
+
+      describe '#config' do
+
+        it 'returns a Configuration struct' do
+          expect(client.config).to be_kind_of(Struct)
+        end
+
+        it 'contains the client api' do
+          expect(client.config.api).to be(client_class.api)
+        end
+
+        it 'defaults endpoint to the api endpoint' do
+          expect(client.config.endpoint).to eq(api['endpoint'])
+        end
+
+        it 'defaults ssl_default to true' do
+          expect(client.config.ssl_default).to equal(true)
+        end
+
+        it 'passes constructor args to the config' do
+          expect {
+            client_class.new(foo: 'bar')
+          }.to raise_error(ArgumentError, /invalid configuration option/)
+        end
+
+      end
+
+      describe '#handlers' do
+
+        it 'returns a HandlerList' do
+          expect(client.handlers).to be_kind_of(HandlerList)
+        end
+
+        it 'builds a handler list from client plugins' do
+          client_class.clear_plugins
+          client_class.add_plugin(Plugins::NetHttp)
+          expect(client.handlers.to_a).to eq([
+            NetHttp::Handler,
+            Plugins::Endpoint::EndpointHandler,
+          ])
+        end
+
+        it 'defaults the send handler to a NetHttp::Handler' do
+          expect(client.handlers.first).to be(NetHttp::Handler)
+        end
+
+      end
+
+      describe '#build_request' do
+
+        let(:request) { client.build_request('operation_name') }
+
+        it 'returns a Request' do
+          expect(request).to be_kind_of(Request)
+        end
+
+        it 'populates the request handlers' do
+          expect(request.handlers.to_a).to eq(client.handlers.to_a)
+        end
+
+        it 'includes operation specific handlers in the handler list' do
+          handler = double('handler')
+          client.handler(handler, operations: ['operation_name'])
+          request = client.build_request('operation_name')
+          expect(request.handlers.to_a).to include(handler)
+        end
+
+        it 'populates the request context operation name' do
+          request = client.build_request('operation_name')
+          expect(request.context.operation_name).to eq('operation_name')
+        end
+
+        it 'stringifies the operation name' do
+          request = client.build_request(:operation_name)
+          expect(request.context.operation_name).to eq('operation_name')
+        end
+
+        it 'populates the request context params' do
+          params = double('params')
+          request = client.build_request('operation_name', params)
+          expect(request.context.params).to be(params)
+        end
+
+        it 'defaults params to an empty hash' do
+          request = client.build_request('operation_name')
+          expect(request.context.params).to eq({})
+        end
+
+        it 'populates the request context configuration' do
+          request = client.build_request('operation_name')
+          expect(request.context.config).to be(client.config)
+        end
+
+        it 'raises an error for unknown operations' do
+          expect {
+            client.build_request('foo')
+          }.to raise_error("unknown operation `foo'")
+        end
+
+      end
+
+      describe '.api' do
+
+        it 'can be set' do
+          api = Model::Api.from_hash({})
+          client_class = Class.new(Base)
+          client_class.set_api(api)
+          expect(client_class.api).to be(api)
+        end
+
+        it 'can be set as a hash, returning a Model::Api' do
+          client_class = Class.new(Base)
+          api = client_class.set_api({})
+          expect(api).to be_kind_of(Model::Api)
+          expect(api.to_hash).to eq(Model::Api.from_hash({}).to_hash)
+        end
+
+      end
+
+      describe '.define' do
+
+        it 'creates a new client class' do
+          client_class = Client.define
+          expect(client_class.ancestors).to include(Client::Base)
+        end
+
+        it 'sets the api on the client class' do
+          api = Model::Api.from_hash({})
+          client_class = Client.define(api: api)
+          expect(client_class.api).to be(api)
+        end
+
+        it 'extends from subclasses of client' do
+          klass1 = Client.define
+          klass2 = klass1.define
+          expect(klass2.ancestors).to include(klass1)
+          expect(klass2.ancestors).to include(Client::Base)
+        end
+
+        it 'applies plugins passed in via :plugins' do
+          client_class = Client.define(plugins: [plugin_a])
+          expect(client_class.plugins).to include(plugin_a)
+        end
+
+      end
+
+      describe '.add_plugin' do
+
+        it 'adds plugins to the client' do
+          client_class.add_plugin(plugin_a)
+          expect(client_class.plugins).to include(plugin_a)
+        end
+
+        it 'does not add plugins to the client parent class' do
+          subclass = Class.new(client_class)
+          subclass.add_plugin(plugin_a)
+          expect(client_class.plugins).to_not include(plugin_a)
+          expect(subclass.plugins).to include(plugin_a)
+        end
+
+      end
+
+      describe '.remove_plugin' do
+
+        it 'removes a plugin from the client' do
+          client_class.add_plugin(plugin_a)
+          client_class.add_plugin(plugin_b)
+          client_class.remove_plugin(plugin_a)
+          expect(client_class.plugins).not_to include(plugin_a)
+          expect(client_class.plugins).to include(plugin_b)
+        end
+
+        it 'does not remove plugins from the client parent class' do
+          client_class.add_plugin(plugin_a)
+          subclass = client_class.define
+          subclass.remove_plugin(plugin_a)
+          expect(client_class.plugins).to include(plugin_a)
+          expect(subclass.plugins).not_to include(plugin_a)
+        end
+
+      end
+
+      describe '.set_plugins' do
+
+        it 'replaces existing plugins' do
+          client_class.add_plugin(plugin_a)
+          client_class.set_plugins([plugin_b])
+          expect(client_class.plugins).to eq(required_plugins + [plugin_b])
+        end
+
+      end
+
+      describe '.clear_plugins' do
+
+        it 'removes all plugins' do
+          client_class.add_plugin(plugin_a)
+          client_class.clear_plugins
+          expect(client_class.plugins).to eq(required_plugins + [])
+        end
+
+      end
+
+      describe '.plugins' do
+
+        it 'returns a list of plugins applied to the client' do
+          expect(client_class.plugins).to be_kind_of(Array)
+        end
+
+        it 'returns a frozen list of plugins' do
+          expect(client_class.plugins.frozen?).to eq(true)
+        end
+
+        it 'has a defualt list of plugins' do
+          client_class = Class.new(Base)
+          expect(client_class.plugins.to_a).to eq([
+            Plugins::Api,
+            Plugins::Endpoint,
+            Plugins::NetHttp,
+            Plugins::OperationMethods,
+            Plugins::ParamConversion,
+            Plugins::ParamValidation,
+            Plugins::RaiseResponseErrors,
+          ])
+        end
+
+        it 'add plugins specified in the api to the default plugins' do
+          stub_const('Seahorse::Client::PluginA', plugin_a)
+          api = { 'plugins' => ['Seahorse::Client::PluginA'] }
+          client_class = Base.define(api: api)
+          expect(client_class.plugins).to include(Plugins::NetHttp)
+          expect(client_class.plugins).to include(Client::Plugins::NetHttp)
+        end
+
+      end
+
+      describe '.new' do
+
+        let(:plugin) {
+          p = double('plugin')
+          allow(p).to receive(:is_a?).with(kind_of(Class)).and_return(false)
+          p
+        }
+
+        it 'instructs plugins to #before_initialize' do
+          options = {}
+          expect(plugin).to receive(:before_initialize).with(client_class, options)
+          client_class.add_plugin(plugin)
+          client_class.new(options)
+        end
+
+        it 'instructs plugins to #add_options' do
+          expect(plugin).to receive(:add_options) do |config|
+            config.add_option(:foo, 'bar')
+          end
+          client_class.add_plugin(plugin)
+          expect(client_class.new.config.foo).to eq('bar')
+        end
+
+        it 'instructs plugins to #add_handlers' do
+          expect(plugin).to receive(:add_handlers).
+            with(kind_of(HandlerList), kind_of(Struct))
+          client_class.add_plugin(plugin)
+          client_class.new
+        end
+
+        it 'instructs plugins to #after_initialize' do
+          expect(plugin).to receive(:after_initialize).with(kind_of(Client::Base))
+          client_class.add_plugin(plugin)
+          client_class.new
+        end
+
+        it 'does not call methods that plugin does not respond to' do
+          plugin = Object.new
+          client_class.add_plugin(plugin)
+          client_class.new
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    describe Configuration do
+
+      let(:config) { Configuration.new }
+
+      describe '#add_option' do
+
+        it 'defines a getter' do
+          config.add_option(:name)
+          expect(config.build!).to respond_to(:name)
+        end
+
+        it 'defaults the value to nil' do
+          config.add_option(:name)
+          expect(config.build!.name).to be(nil)
+        end
+
+        it 'accepts a default value' do
+          config.add_option(:name, 'John Doe')
+          expect(config.build!.name).to eq('John Doe')
+        end
+
+        it 'accepts blocks' do
+          config.add_option(:name) { 'John Doe' }
+          expect(config.build!.name).to eq('John Doe')
+        end
+
+        it 'accepts blocks with an arity of 1, yielding self' do
+          config.add_option(:name) { 'John Doe' }
+          config.add_option(:username) { |cfg| cfg.name.gsub(/\W+/, '').downcase }
+          expect(config.build!.name).to eq('John Doe')
+          expect(config.build!.username).to eq('johndoe')
+        end
+
+        it 'blocks can rely on other blocks' do
+          config.add_option(:base) { 2 }
+          config.add_option(:next) { |cfg| cfg.base * 2 }
+          config.add_option(:last) { |cfg| cfg.next * 3 }
+          cfg = config.build!
+          expect(cfg.last).to eq(12)
+          expect(cfg.next).to eq(4)
+          expect(cfg.base).to eq(2)
+        end
+
+        it 'blocks work with supplied values' do
+          config.add_option(:base) { 2 }
+          config.add_option(:next) { |cfg| cfg.base * 2 }
+          config.add_option(:last) { |cfg| cfg.next * 3 }
+          cfg = config.build!(base: 1, next: 1)
+          expect(cfg.base).to eq(1)
+          expect(cfg.next).to eq(1)
+          expect(cfg.last).to eq(3)
+        end
+
+        it 'replaces previous default values when called twice' do
+          config.add_option(:name, 'abc')
+          config.add_option(:name, 'xyz')
+          expect(config.build!.name).to eq('xyz')
+        end
+
+        it 'returns self so it can be chained' do
+          c = config.add_option(:name).add_option(:color)
+          expect(c).to be(config)
+          expect(c.build!.members).to eq([:name, :color])
+        end
+
+      end
+
+      describe '#build!' do
+
+        it 'returns a Struct' do
+          expect(config.add_option(:opt).build!).to be_kind_of(Struct)
+        end
+
+        it 'returns a frozen structure' do
+          config.add_option(:foo)
+          c = config.build!
+          expect(c).to be_frozen
+          expect {
+            c.foo = 'bar'
+          }.to raise_error(/can't modify frozen/)
+        end
+
+        it 'accepts a hash of options' do
+          config.add_option(:size, 'default')
+          config.add_option(:color, 'default')
+          cfg = config.build!(size: 'large', color: 'red')
+          expect(cfg.size).to eq('large')
+          expect(cfg.color).to eq('red')
+        end
+
+        it 'raises an argument error for uknown options' do
+          config.add_option(:known)
+          expect {
+            config.build!(unknown: 'option')
+          }.to raise_error(ArgumentError, /invalid configuration option/)
+        end
+
+        it 'resolves nested dependent options' do
+          config.add_option(:base, 1)
+          config.add_option(:top) { |cfg| cfg.middle }
+          config.add_option(:middle) { |cfg| cfg.base }
+          expect(config.build!.top).to eq(1)
+        end
+
+        it 'does not resolve procs passed as args' do
+          value = lambda {}
+          config.add_option(:proc, value)
+          expect(config.build!.proc).to be(value)
+        end
+
+      end
+    end
+  end
+end