aws-sdk-core 2.0.0.rc1

data/spec/aws/plugins/global_configuration_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Aws
+  module Plugins
+    describe GlobalConfiguration do
+
+      def plugin(&block)
+        Class.new(Seahorse::Client::Plugin, &block)
+      end
+
+      before(:each) do
+        api = Seahorse::Model::Api.new
+        api.metadata['service_class_name'] = 'Svc'
+        api.version = '2013-01-01'
+        Aws.add_service(:Svc, [api])
+        Aws::Svc.add_plugin(GlobalConfiguration)
+        Aws::Svc.add_plugin(plugin { option(:property, 'plugin-default') })
+        allow(Aws).to receive(:config).and_return({})
+      end
+
+      after(:each) do
+        # to silence warnings about Svc getting redefined each pass
+        Aws.send(:remove_const, :Svc)
+      end
+
+      it 'does not interfere with plugins and their defaults' do
+        expect(Aws.svc.config.property).to eq('plugin-default')
+      end
+
+      it 'gives priority to Aws.config over plugin defaults' do
+        Aws.config[:property] = 'aws-default'
+        expect(Aws.svc.config.property).to eq('aws-default')
+      end
+
+      it 'gives priority to Aws.config[:svc] over Aws.config' do
+        Aws.config[:property] = 'aws-default'
+        Aws.config[:svc] = { property: 'svc-default' }
+        expect(Aws.svc.config.property).to eq('svc-default')
+      end
+
+      it 'gives priority to constructor options over Aws.config' do
+        Aws.config[:property] = 'aws-default'
+        Aws.config[:svc] = { property: 'svc-default' }
+        expect(Aws.svc(property: 'arg').config.property).to eq('arg')
+      end
+
+      it 'ignores configuration for others services in Aws.config' do
+        Aws.config[:property] = 'aws-default'
+        Aws.config[:svc] = { property: 'svc-default' }
+        Aws.config[:s3] = { property: 's3-default' }
+        expect(Aws.svc.config.property).to eq('svc-default')
+      end
+
+    end
+  end
+end

data/spec/aws/plugins/region_endpoint_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Aws
+  module Plugins
+    describe RegionalEndpoint do
+
+      let(:env) { {} }
+
+      let(:client_class) {
+        Seahorse::Client.define(plugins: [RegionalEndpoint])
+      }
+
+      before do
+        stub_const("ENV", env)
+      end
+
+      describe 'region option' do
+
+        it 'adds a :region configuration option' do
+          expect(client_class.new(region: 'region').config.region).to eq('region')
+        end
+
+        it 'defaults to ENV["AWS_REGION"]' do
+          env['AWS_REGION'] = 'env-region'
+          expect(client_class.new.config.region).to eq('env-region')
+        end
+
+        it 'falls back to ENV["AMAZON_REGION"]' do
+          env['AMAZON_REGION'] = 'region-fallback'
+          expect(client_class.new.config.region).to eq('region-fallback')
+        end
+
+        it 'prefers AWS_REGION to AMAZON_REGION' do
+          env['AWS_REGION'] = 'aws-region'
+          env['AMAZON_REGION'] = 'amazon-region'
+          expect(client_class.new.config.region).to eq('aws-region')
+        end
+
+        it 'can be set directly, overriding the ENV["AWS_REGION"]' do
+          env['AWS_REGION'] = 'env-region'
+          expect(client_class.new(region:'cfg').config.region).to eq('cfg')
+        end
+
+        it 'raises an argument error when not set' do
+          client = Seahorse::Client.define
+          client.add_plugin(RegionalEndpoint)
+          expect { client.new }.to raise_error(Errors::MissingRegionError)
+        end
+
+        it 'raises an argument error when set to nil' do
+          client = Seahorse::Client.define
+          client.add_plugin(RegionalEndpoint)
+          expect { client.new(region:nil) }.to raise_error(Errors::MissingRegionError)
+        end
+
+      end
+
+      describe 'endpoint option' do
+
+        it 'defaults the endpoint to PREFIX.REGION.amazonaws.com' do
+          client_class.api.metadata['endpoint_prefix'] = 'PREFIX'
+          client = client_class.new(region: 'REGION')
+          expect(client.config.endpoint).to eq('PREFIX.REGION.amazonaws.com')
+        end
+
+        it 'uses the endpoint defined in metadata if present' do
+          client_class.api.metadata['regional_endpoints'] = {
+            'region-name' => 'ENDPOINT'
+          }
+          client = client_class.new(region: 'region-name')
+          expect(client.config.endpoint).to eq('ENDPOINT')
+        end
+
+      end
+    end
+  end
+end

data/spec/aws/plugins/retry_errors_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+module Aws
+  module Plugins
+    describe RetryErrors do
+
+      it 'defaults config.retry_limit to 3' do
+        config = Seahorse::Client::Configuration.new
+        RetryErrors.new.add_options(config)
+        config = config.build!
+        expect(config.retry_limit).to eq(3)
+      end
+
+      describe 'ErrorInspector' do
+
+        def inspector(error, http_status_code = 404)
+          RetryErrors::ErrorInspector.new(error, http_status_code)
+        end
+
+        describe '#expired_credentials?' do
+
+          it 'returns true if the error code is InvalidClientTokenId' do
+            error = IAM::Errors::InvalidClientTokenId.new
+            expect(inspector(error).expired_credentials?).to be(true)
+          end
+
+          it 'returns true if the error code is UnrecognizedClientException' do
+            error = SWF::Errors::UnrecognizedClientException.new
+            expect(inspector(error).expired_credentials?).to be(true)
+          end
+
+          it 'returns true if the error code is InvalidAccessKeyId' do
+            error = S3::Errors::InvalidAccessKeyId.new
+            expect(inspector(error).expired_credentials?).to be(true)
+          end
+
+          it 'returns true if the error code is AuthFailure' do
+            error = EC2::Errors::AuthFailure.new
+            expect(inspector(error).expired_credentials?).to be(true)
+          end
+
+          it 'returns true if the error code matches /expired/' do
+            error = IAM::Errors::SomethingExpiredError.new
+            expect(inspector(error).expired_credentials?).to be(true)
+          end
+
+          it 'returns false for other errors' do
+            error = IAM::Errors::SomeRandomError.new
+            expect(inspector(error).expired_credentials?).to be(false)
+          end
+
+        end
+
+        describe '#throttling_error?' do
+
+          it 'returns true for Throttling' do
+            error = IAM::Errors::Throttling.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns true for ThrottlingException' do
+            error = SWF::Errors::ThrottlingException.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns true for RequestThrottled' do
+            error = SQS::Errors::RequestThrottled.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns true for ProvisionedThroughputExceededException' do
+            error = DynamoDB::Errors::ProvisionedThroughputExceededException.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns true for RequestLimitExceeded' do
+            error = EC2::Errors::RequestLimitExceeded.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns true for BandwidthLimitExceeded' do
+            error = CloudSearch::Errors::BandwidthLimitExceeded.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns true for error codes that match /throttl/' do
+            error = IAM::Errors::Throttled.new
+            expect(inspector(error).throttling_error?).to be(true)
+          end
+
+          it 'returns false for other errors' do
+            error = IAM::Errors::SomeRandomError.new
+            expect(inspector(error).throttling_error?).to be(false)
+          end
+
+        end
+
+        describe '#checksum?' do
+
+          it 'returns true if the error extends Errors::ChecksumError' do
+            error = Errors::ChecksumError.new
+            expect(inspector(error).checksum?).to be(true)
+          end
+
+          it 'returns true if the error is a crc32 error' do
+            error = DynamoDB::Errors::CRC32CheckFailed.new
+            expect(inspector(error).checksum?).to be(true)
+          end
+
+          it 'returns false if the error does not exend ChecksumError' do
+            error = double('error')
+            expect(inspector(error).checksum?).to be(false)
+          end
+
+        end
+
+        describe '#server?' do
+
+          it 'returns true if the error is a 500 level error' do
+            error = EC2::Errors::RandomError.new
+            expect(inspector(error, 500).server?).to be(true)
+          end
+
+          it 'returns false if the error is not a 500 level error' do
+            error = EC2::Errors::RandomError.new
+            expect(inspector(error, 404).server?).to be(false)
+          end
+
+        end
+
+        describe '#networking?' do
+
+          it 'returns true if the error code is RequestTimeout' do
+            error = S3::Errors::RequestTimeout.new
+            expect(inspector(error).networking?).to be(true)
+          end
+
+          it 'returns true if the http status code is 0' do
+            error = double('error')
+            expect(inspector(error, 0).networking?).to be(true)
+          end
+
+          it 'returns false if the http status code is not 0' do
+            error = double('error')
+            expect(inspector(error, 307).networking?).to be(false)
+          end
+
+        end
+      end
+
+      describe 'Handler' do
+
+        let(:credentials) { Credentials.new }
+
+        let(:config) {
+          cfg = Seahorse::Client::Configuration.new
+          cfg.add_option(:credentials, credentials)
+          RetryErrors.new.add_options(cfg)
+          cfg.build!
+        }
+
+        let(:resp) { Seahorse::Client::Response.new }
+
+        let(:handler) { RetryErrors::Handler.new }
+
+        before(:each) do
+          resp.context.config = config
+          resp.context.http_response.status_code = 400
+        end
+
+        def handle(send_handler = nil, &block)
+          allow(Kernel).to receive(:sleep)
+          handler.handler = send_handler || block
+          handler.call(resp.context)
+        end
+
+        it 'does not retry responses that have no error' do
+          resp.error = nil
+          send_handler = double('send-handler')
+          expect(send_handler).to receive(:call).once.and_return(resp)
+          handle(send_handler)
+        end
+
+        it 'reties 3 times for a total of 4 attemps' do
+          resp.error = EC2::Errors::RequestLimitExceeded.new
+          send_handler = double('send-handler')
+          expect(send_handler).to receive(:call).
+            exactly(4).times.
+            with(resp.context).
+            and_return(resp)
+          handle(send_handler)
+        end
+
+        it 'backs off exponentially between each retry attempt' do
+          expect(Kernel).to receive(:sleep).with(0.3).ordered
+          expect(Kernel).to receive(:sleep).with(0.6).ordered
+          expect(Kernel).to receive(:sleep).with(1.2).ordered
+          resp.error = EC2::Errors::RequestLimitExceeded.new
+          handle { |context| resp }
+        end
+
+        it 'increments the retry count on the context' do
+          resp.error = EC2::Errors::RequestLimitExceeded.new
+          handle { |context| resp }
+          expect(resp.context.retries).to eq(3)
+        end
+
+        it 'rewinds the request body before each retry attempt' do
+          body = resp.context.http_request.body
+          expect(body).to receive(:rewind).exactly(3).times
+          resp.error = EC2::Errors::RequestLimitExceeded.new
+          handle { |context| resp }
+        end
+
+        it 'truncates the response body before each retry attempt' do
+          body = double('truncatable-body', pos: 100, truncate: 0)
+          resp.context.http_response.body = body
+          expect(body).to receive(:truncate).with(0).exactly(3).times
+          resp.error = EC2::Errors::RequestLimitExceeded.new
+          handle { |context| resp }
+        end
+
+        it 'skips retry if un-truncatable response body has received data' do
+          resp.context.http_response.body = double('write-once-body', pos: 100)
+          resp.error = EC2::Errors::RequestLimitExceeded.new
+          handle { |context| resp }
+          expect(resp.context.retries).to eq(0)
+        end
+
+        it 'retries if creds expire and are refreshable' do
+          expect(credentials).to receive(:refresh!).exactly(3).times
+          resp.error = EC2::Errors::AuthFailure.new
+          handle { |context| resp }
+          expect(resp.context.retries).to eq(3)
+        end
+
+        it 'skips retry if creds expire and are not refreshable' do
+          resp.error = EC2::Errors::AuthFailure.new
+          handle { |context| resp }
+          expect(resp.context.retries).to eq(0)
+        end
+
+        it 'retries 500 level errors' do
+          resp.context.http_response.status_code = 500
+          resp.error = RuntimeError.new('random-runtime-error')
+          handle { |context| resp }
+          expect(resp.context.retries).to eq(3)
+        end
+
+      end
+    end
+  end
+end

data/spec/aws/query/builder_spec.rb

@@ -0,0 +1,361 @@
+require 'spec_helper'
+
+module Aws
+  module Query
+    describe Builder do
+
+      let(:rules) {{
+        'type' => 'input',
+        'members' => {}
+      }}
+
+      def query_params(params = {})
+        shape = Seahorse::Model::Shapes::Shape.from_hash(rules)
+        Builder.to_query_params(shape, params).map do |param|
+          [param.name, param.value]
+        end
+      end
+
+      describe '#to_query_params' do
+
+        it 'returns a param list' do
+          list = Builder.to_query_params(rules, {})
+          expect(list).to be_kind_of(ParamList)
+        end
+
+        describe 'structures' do
+
+          it 'returns an empty list when there are no members' do
+            expect(query_params).to be_empty
+          end
+
+          it 'returns an empty list when there are no params' do
+            rules['members'] = { 'name' => { 'type' => 'string' } }
+            expect(query_params({})).to be_empty
+          end
+
+          it 'serializes params by name' do
+            rules['members'] = {
+              'name' => { 'type' => 'string' },
+              'age' => { 'type' => 'integer' }
+            }
+            expect(query_params(name: 'John', age: 40)).to eq([
+              ['age', '40'],
+              ['name', 'John'],
+            ])
+          end
+
+          it 'observes serialized name properties' do
+            rules['members'] = {
+              'name' => { 'type' => 'string', 'serialized_name' => 'NAME' },
+              'age' => { 'type' => 'integer', 'serialized_name' => 'AGE' }
+            }
+            expect(query_params(name: 'John', age: 40)).to eq([
+              ['AGE', '40'],
+              ['NAME', 'John'],
+            ])
+          end
+
+          it 'serializes nested params' do
+            rules['members'] = {
+              'name' => { 'type' => 'string' },
+              'config' => {
+                'type' => 'structure',
+                'members' => { 'enabled' => { 'type' => 'boolean' }
+                }
+              }
+            }
+            params = { name: 'John', config: { enabled: true } }
+            expect(query_params(params)).to eq([
+              ['config.enabled', 'true'],
+              ['name', 'John'],
+            ])
+          end
+
+        end
+
+        describe 'flattened lists' do
+
+          it 'numbers list members starting at 1' do
+            rules['members'] = {
+              'items' => {
+                'type' => 'flat_list',
+                'members' => { 'type' => 'string' }
+              }
+            }
+            expect(query_params(items: %w(abc mno xyz))).to eq([
+              ['items.1', 'abc'],
+              ['items.2', 'mno'],
+              ['items.3', 'xyz'],
+            ])
+          end
+
+          it 'uses the list member serialized name as the param name' do
+            rules['members'] = {
+              'config' => {
+                'type' => 'structure',
+                'members' => {
+                  'items' => {
+                    'type' => 'flat_list',
+                    'members' => {
+                      'type' => 'string',
+                      'serialized_name' => 'Item'
+                    }
+                  }
+                }
+              }
+            }
+            params = { config: { items: %w(abc mno xyz) } }
+            expect(query_params(params)).to eq([
+              ['config.Item.1', 'abc'],
+              ['config.Item.2', 'mno'],
+              ['config.Item.3', 'xyz'],
+            ])
+          end
+
+          it 'supports lists of complex types' do
+            rules['members'] = {
+              'people' => {
+                'type' => 'flat_list',
+                'members' => {
+                  'type' => 'structure',
+                  'members' => {
+                    'name' => { 'type' => 'string' }
+                  }
+                }
+              }
+            }
+            params = { people: [ { name: 'John' }, { name: 'Jane' } ] }
+            expect(query_params(params)).to eq([
+              ['people.1.name', 'John'],
+              ['people.2.name', 'Jane'],
+            ])
+          end
+
+        end
+
+        describe 'non-flattened lists' do
+
+          it 'numbers list members starting at 1' do
+            rules['members'] = {
+              'items' => {
+                'type' => 'list',
+                'members' => { 'type' => 'string' }
+              }
+            }
+            expect(query_params(items: %w(abc mno xyz))).to eq([
+              ['items.member.1', 'abc'],
+              ['items.member.2', 'mno'],
+              ['items.member.3', 'xyz'],
+            ])
+          end
+
+          it 'ignores the list member name' do
+            rules['members'] = {
+              'config' => {
+                'type' => 'structure',
+                'members' => {
+                  'items' => {
+                    'type' => 'list',
+                    'members' => {
+                      'type' => 'string',
+                      'serialized_name' => 'Item' # has no effect
+                    }
+                  }
+                }
+              }
+            }
+            params = { config: { items: %w(abc mno xyz) } }
+            expect(query_params(params)).to eq([
+              ['config.items.member.1', 'abc'],
+              ['config.items.member.2', 'mno'],
+              ['config.items.member.3', 'xyz'],
+            ])
+          end
+
+          it 'supports lists of complex types' do
+            rules['members'] = {
+              'people' => {
+                'type' => 'list',
+                'members' => {
+                  'type' => 'structure',
+                  'members' => {
+                    'name' => { 'type' => 'string' }
+                  }
+                }
+              }
+            }
+            params = { people: [ { name: 'John' }, { name: 'Jane' } ] }
+            expect(query_params(params)).to eq([
+              ['people.member.1.name', 'John'],
+              ['people.member.2.name', 'Jane'],
+            ])
+          end
+
+        end
+
+        describe 'flattened maps' do
+
+          it 'serializes hashes with keys and values' do
+            rules['members'] = {
+              'attributes' => {
+                'type' => 'flat_map',
+                'keys' => { 'type' => 'string' },
+                'members' => { 'type' => 'string' }
+              }
+            }
+            params = { attributes: { 'Size' => 'large', 'Color' => 'red' } }
+            expect(query_params(params)).to eq([
+              ['attributes.1.key', 'Size'],
+              ['attributes.1.value', 'large'],
+              ['attributes.2.key', 'Color'],
+              ['attributes.2.value', 'red'],
+            ])
+          end
+
+          it 'serializes hashes with keys and values' do
+            rules['members'] = {
+              'attributes' => {
+                'type' => 'flat_map',
+                'keys' => { 'type' => 'string', 'serialized_name' => 'K' },
+                'members' => { 'type' => 'string', 'serialized_name' => 'V' }
+              }
+            }
+            params = { attributes: { 'Size' => 'large', 'Color' => 'red' } }
+            expect(query_params(params)).to eq([
+              ['attributes.1.K', 'Size'],
+              ['attributes.1.V', 'large'],
+              ['attributes.2.K', 'Color'],
+              ['attributes.2.V', 'red'],
+            ])
+          end
+
+        end
+
+        describe 'non-flattened maps' do
+
+          it 'serializes hashes with keys and values' do
+            rules['members'] = {
+              'attributes' => {
+                'type' => 'map',
+                'keys' => { 'type' => 'string' },
+                'members' => { 'type' => 'string' }
+              }
+            }
+            params = { attributes: { 'Size' => 'large', 'Color' => 'red' } }
+            expect(query_params(params)).to eq([
+              ['attributes.entry.1.key', 'Size'],
+              ['attributes.entry.1.value', 'large'],
+              ['attributes.entry.2.key', 'Color'],
+              ['attributes.entry.2.value', 'red'],
+            ])
+          end
+
+          it 'serializes hashes with keys and values' do
+            rules['members'] = {
+              'attributes' => {
+                'type' => 'map',
+                'keys' => { 'type' => 'string', 'serialized_name' => 'K' },
+                'members' => { 'type' => 'string', 'serialized_name' => 'V' }
+              }
+            }
+            params = { attributes: { 'Size' => 'large', 'Color' => 'red' } }
+            expect(query_params(params)).to eq([
+              ['attributes.entry.1.K', 'Size'],
+              ['attributes.entry.1.V', 'large'],
+              ['attributes.entry.2.K', 'Color'],
+              ['attributes.entry.2.V', 'red'],
+            ])
+          end
+
+        end
+
+        describe 'scalars' do
+
+          it 'serializes integers' do
+            rules['members'] = {
+              'count' => { 'type' => 'integer' }
+            }
+            expect(query_params(count: 123)).to eq([
+              ['count', '123'],
+            ])
+          end
+
+          it 'serializes floats' do
+            rules['members'] = {
+              'price' => { 'type' => 'float' }
+            }
+            expect(query_params(price: 12.34)).to eq([
+              ['price', '12.34'],
+            ])
+          end
+
+          it 'serializes booleans' do
+            rules['members'] = {
+              'hot' => { 'type' => 'boolean' },
+              'cold' => { 'type' => 'boolean' }
+            }
+            expect(query_params(hot:true, cold:false)).to eq([
+              ['cold', 'false'],
+              ['hot', 'true'],
+            ])
+          end
+
+          it 'serializes is8601 timestamps' do
+            now = Time.now
+            rules['members'] = {
+              'when' => { 'type' => 'iso8601_timestamp' }
+            }
+            expect(query_params(when:now)).to eq([
+              ['when', now.utc.iso8601]
+            ])
+          end
+
+          it 'can serializes timestamps as rfc8622 strings' do
+            now = Time.now
+            rules['members'] = {
+              'when' => {
+                'type' => 'rfc822_timestamp'
+              }
+            }
+            expect(query_params(when:now)).to eq([
+              ['when', now.utc.rfc822]
+            ])
+          end
+
+          it 'can serializes timestamps as unix timestamps' do
+            now = Time.now
+            rules['members'] = {
+              'when' => {
+                'type' => 'unix_timestamp'
+              }
+            }
+            expect(query_params(when:now)).to eq([
+              ['when', now.to_i.to_s]
+            ])
+          end
+
+          it 'raises an error when the timestamp format is not specified' do
+            now = Time.now
+            rules['members'] = {
+              'when' => {
+                'type' => 'timestamp',
+              }
+            }
+          expect { query_params(when:now) }.to raise_error(/invalid timestamp/)
+          end
+
+          it 'serializes blobs as base64 strings' do
+            rules['members'] = {
+              'data' => { 'type' => 'blob' }
+            }
+            expect(query_params(data:'hello')).to eq([
+              ['data', 'aGVsbG8=']
+            ])
+          end
+
+        end
+      end
+    end
+  end
+end