aws-sdk-core 2.0.0.rc4 → 2.0.0.rc5

data/lib/aws/plugins/s3_regional_endpoint.rb

@@ -3,8 +3,6 @@ module Aws
   module Plugins
     class S3RegionalEndpoint < RegionalEndpoint
 
-      option(:region) { ENV['AWS_REGION'] || ENV['AMAZON_REGION'] }
-
       option(:endpoint) do |config|
         raise ArgumentError, MISSING_REGION unless config.region
         if config.region == 'us-east-1'

data/lib/aws/request_handler.rb

@@ -20,12 +20,17 @@ module Aws
 
     def serialize_params(context)
       input = context.operation.input
+      rules = input.payload_member
       if input.payload
-        rules = input.payload_member
         params = context.params[input.payload] || {}
       else
-        rules = input
-        params = context.params
+        params = {}
+        rules.members.keys.each do |param_name|
+          param_name = param_name.to_sym
+          if context.params.include?(param_name)
+            params[param_name] = context.params[param_name]
+          end
+        end
       end
       @serializer.serialize_params(context, rules, params)
     end

data/lib/aws/signers/s3.rb

@@ -23,17 +23,19 @@ module Aws
       def self.sign(context)
         new(
           context.config.credentials,
-          context.params
+          context.params,
+          context.config.force_path_style
         ).sign(context.http_request)
       end
 
       # @param [Credentials] credentials
-      def initialize(credentials, params)
+      def initialize(credentials, params, force_path_style)
         @credentials = credentials
         @params = Query::ParamList.new
         params.each_pair do |param_name, param_value|
           @params.set(param_name, param_value)
         end
+        @force_path_style = force_path_style
       end
 
       attr_reader :credentials, :params
@@ -45,14 +47,6 @@ module Aws
         request.headers['Authorization'] = authorization(request)
       end
 
-      # @param [RequestContext] context
-      def self.sign(context)
-        new(context.config.credentials, context.params).
-          sign(context.http_request)
-      end
-
-      private
-
       def authorization(request)
         "AWS #{credentials.access_key_id}:#{signature(request)}"
       end
@@ -87,7 +81,7 @@ module Aws
           request.headers.values_at('Content-Md5', 'Content-Type').join("\n"),
           signing_string_date(request),
           canonicalized_headers(request),
-          canonicalized_resource(request),
+          canonicalized_resource(request.endpoint),
         ].flatten.compact.join("\n")
       end
 
@@ -123,25 +117,27 @@ module Aws
       #       "?logging", or "?torrent"];
       #
       # @api private
-      def canonicalized_resource(request)
+      def canonicalized_resource(endpoint)
 
         parts = []
 
         # virtual hosted-style requests require the hostname to appear
         # in the canonicalized resource prefixed by a forward slash.
         if bucket = params[:bucket]
-          ssl = request.endpoint.https?
-          if Plugins::S3BucketDns.dns_compatible?(bucket.value, ssl)
+          ssl = endpoint.https?
+          if Plugins::S3BucketDns.dns_compatible?(bucket.value, ssl) &&
+            !@force_path_style
+          then
             parts << "/#{bucket.value}"
           end
         end
 
         # append the path name (no querystring)
-        parts << request.endpoint.path
+        parts << endpoint.path
 
         # lastly any sub resource querystring params need to be appened
         # in lexigraphical ordered joined by '&' and prefixed by '?'
-        params = signed_querystring_params(request)
+        params = signed_querystring_params(endpoint)
 
         unless params.empty?
           parts << '?'
@@ -151,8 +147,8 @@ module Aws
         parts.join
       end
 
-      def signed_querystring_params(request)
-        request.endpoint.querystring.to_s.split('&').select do |p|
+      def signed_querystring_params(endpoint)
+        endpoint.querystring.to_s.split('&').select do |p|
           SIGNED_QUERYSTRING_PARAMS.include?(p.split('=')[0])
         end.map { |p| URI.decode(p) }
       end

data/lib/aws/version.rb

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.0.0.rc4'
+  VERSION = '2.0.0.rc5'
 end

data/spec/aws/errors_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Aws
+  module Errors
+    describe DynamicErrors do
+
+      let(:mod) {
+        mod = Module.new
+        mod.send(:extend, DynamicErrors)
+        mod
+      }
+
+      it 'dynamically creates error classes' do
+        expect(mod::MyError.ancestors).to include(ServiceError)
+      end
+
+      it 'removes non letters and numbers from the error code' do
+        expect(mod.error_class('My.Error')).to be(mod::MyError)
+      end
+
+      it 'removes http namespaces from the error code' do
+        expect(mod.error_class('ErrorClass:http://foo.com')).to be(mod::ErrorClass)
+      end
+
+      it 'prevents #const_missing from re-setting the error constant' do
+        error_class = mod::FooError
+        expect(mod.const_missing(:FooError)).to be(error_class)
+        expect(mod.const_missing('FooError')).to be(error_class)
+      end
+
+      it 'prevents #const_missing from re-setting the error constant' do
+        error_class = mod::FooError
+        expect(mod.const_missing(:FooError)).to be(error_class)
+        expect(mod.const_missing('FooError')).to be(error_class)
+      end
+
+    end
+  end
+end

data/spec/aws/plugins/credentials_spec.rb

@@ -26,6 +26,18 @@ module Aws
           expect(config.build!.credentials).to be(nil)
         end
 
+        it 'hydrates credentials from the cmdline env (AWS_)' do
+          env['AWS_ACCESS_KEY'] = 'akid'
+          env['AWS_SECRET_KEY'] = 'secret'
+          env['AWS_SESSION_TOKEN'] = 'token'
+          plugin.add_options(config)
+          cfg = config.build!
+          expect(cfg.credentials.set?).to be(true)
+          expect(cfg.credentials.access_key_id).to eq('akid')
+          expect(cfg.credentials.secret_access_key).to eq('secret')
+          expect(cfg.credentials.session_token).to eq('token')
+        end
+
         it 'hydrates credentials from the env (AWS_)' do
           env['AWS_ACCESS_KEY_ID'] = 'akid'
           env['AWS_SECRET_ACCESS_KEY'] = 'secret'

data/spec/aws/plugins/region_endpoint_spec.rb

@@ -20,14 +20,26 @@ module Aws
           expect(client_class.new(region: 'region').config.region).to eq('region')
         end
 
-        it 'defaults to ENV["AWS_REGION"]' do
-          env['AWS_REGION'] = 'env-region'
+        it 'defaults to ENV["AWS_DEFAULT_REGION"]' do
+          env['AWS_DEFAULT_REGION'] = 'env-region'
           expect(client_class.new.config.region).to eq('env-region')
         end
 
+        it 'defaults to ENV["AWS_REGION"]' do
+          env['AWS_REGION'] = 'env-fallback1'
+          expect(client_class.new.config.region).to eq('env-fallback1')
+        end
+
         it 'falls back to ENV["AMAZON_REGION"]' do
-          env['AMAZON_REGION'] = 'region-fallback'
-          expect(client_class.new.config.region).to eq('region-fallback')
+          env['AMAZON_REGION'] = 'region-fallback2'
+          expect(client_class.new.config.region).to eq('region-fallback2')
+        end
+
+        it 'prefers AWS_DEFAULT_REGION to AWS_REGION or AMAZON_REGION' do
+          env['AWS_DEFAULT_REGION'] = 'aws-default-region'
+          env['AWS_REGION'] = 'aws-region'
+          env['AMAZON_REGION'] = 'amazon-region'
+          expect(client_class.new.config.region).to eq('aws-default-region')
         end
 
         it 'prefers AWS_REGION to AMAZON_REGION' do

data/spec/aws/plugins/retry_errors_spec.rb

@@ -20,32 +20,32 @@ module Aws
         describe '#expired_credentials?' do
 
           it 'returns true if the error code is InvalidClientTokenId' do
-            error = IAM::Errors::InvalidClientTokenId.new
+            error = IAM::Errors::InvalidClientTokenId.new(nil,nil)
             expect(inspector(error).expired_credentials?).to be(true)
           end
 
           it 'returns true if the error code is UnrecognizedClientException' do
-            error = SWF::Errors::UnrecognizedClientException.new
+            error = SWF::Errors::UnrecognizedClientException.new(nil,nil)
             expect(inspector(error).expired_credentials?).to be(true)
           end
 
           it 'returns true if the error code is InvalidAccessKeyId' do
-            error = S3::Errors::InvalidAccessKeyId.new
+            error = S3::Errors::InvalidAccessKeyId.new(nil,nil)
             expect(inspector(error).expired_credentials?).to be(true)
           end
 
           it 'returns true if the error code is AuthFailure' do
-            error = EC2::Errors::AuthFailure.new
+            error = EC2::Errors::AuthFailure.new(nil,nil)
             expect(inspector(error).expired_credentials?).to be(true)
           end
 
           it 'returns true if the error code matches /expired/' do
-            error = IAM::Errors::SomethingExpiredError.new
+            error = IAM::Errors::SomethingExpiredError.new(nil,nil)
             expect(inspector(error).expired_credentials?).to be(true)
           end
 
           it 'returns false for other errors' do
-            error = IAM::Errors::SomeRandomError.new
+            error = IAM::Errors::SomeRandomError.new(nil,nil)
             expect(inspector(error).expired_credentials?).to be(false)
           end
 
@@ -54,42 +54,42 @@ module Aws
         describe '#throttling_error?' do
 
           it 'returns true for Throttling' do
-            error = IAM::Errors::Throttling.new
+            error = IAM::Errors::Throttling.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns true for ThrottlingException' do
-            error = SWF::Errors::ThrottlingException.new
+            error = SWF::Errors::ThrottlingException.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns true for RequestThrottled' do
-            error = SQS::Errors::RequestThrottled.new
+            error = SQS::Errors::RequestThrottled.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns true for ProvisionedThroughputExceededException' do
-            error = DynamoDB::Errors::ProvisionedThroughputExceededException.new
+            error = DynamoDB::Errors::ProvisionedThroughputExceededException.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns true for RequestLimitExceeded' do
-            error = EC2::Errors::RequestLimitExceeded.new
+            error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns true for BandwidthLimitExceeded' do
-            error = CloudSearch::Errors::BandwidthLimitExceeded.new
+            error = CloudSearch::Errors::BandwidthLimitExceeded.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns true for error codes that match /throttl/' do
-            error = IAM::Errors::Throttled.new
+            error = IAM::Errors::Throttled.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(true)
           end
 
           it 'returns false for other errors' do
-            error = IAM::Errors::SomeRandomError.new
+            error = IAM::Errors::SomeRandomError.new(nil,nil)
             expect(inspector(error).throttling_error?).to be(false)
           end
 
@@ -103,7 +103,7 @@ module Aws
           end
 
           it 'returns true if the error is a crc32 error' do
-            error = DynamoDB::Errors::CRC32CheckFailed.new
+            error = DynamoDB::Errors::CRC32CheckFailed.new(nil,nil)
             expect(inspector(error).checksum?).to be(true)
           end
 
@@ -117,12 +117,12 @@ module Aws
         describe '#server?' do
 
           it 'returns true if the error is a 500 level error' do
-            error = EC2::Errors::RandomError.new
+            error = EC2::Errors::RandomError.new(nil,nil)
             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
+            error = EC2::Errors::RandomError.new(nil,nil)
             expect(inspector(error, 404).server?).to be(false)
           end
 
@@ -131,7 +131,7 @@ module Aws
         describe '#networking?' do
 
           it 'returns true if the error code is RequestTimeout' do
-            error = S3::Errors::RequestTimeout.new
+            error = S3::Errors::RequestTimeout.new(nil,nil)
             expect(inspector(error).networking?).to be(true)
           end
 
@@ -188,7 +188,7 @@ module Aws
         end
 
         it 'reties 3 times for a total of 4 attemps' do
-          resp.error = EC2::Errors::RequestLimitExceeded.new
+          resp.error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
           send_handler = double('send-handler')
           expect(send_handler).to receive(:call).
             exactly(4).times.
@@ -201,12 +201,12 @@ module Aws
           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
+          resp.error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
           handle { |context| resp }
         end
 
         it 'increments the retry count on the context' do
-          resp.error = EC2::Errors::RequestLimitExceeded.new
+          resp.error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
           handle { |context| resp }
           expect(resp.context.retries).to eq(3)
         end
@@ -214,7 +214,7 @@ module Aws
         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
+          resp.error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
           handle { |context| resp }
         end
 
@@ -222,26 +222,26 @@ module Aws
           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
+          resp.error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
           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
+          resp.error = EC2::Errors::RequestLimitExceeded.new(nil,nil)
           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
+          resp.error = EC2::Errors::AuthFailure.new(nil,nil)
           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
+          resp.error = EC2::Errors::AuthFailure.new(nil,nil)
           handle { |context| resp }
           expect(resp.context.retries).to eq(0)
         end

data/spec/aws/service_spec.rb

@@ -232,7 +232,7 @@ module Aws
 
       it 'lazily creates error classes' do
         err_class = errors.const_get(:AbcXyz)
-        expect(err_class.new).to be_kind_of(Errors::ServiceError)
+        expect(err_class.new(nil, nil)).to be_kind_of(Errors::ServiceError)
       end
 
     end

data/spec/fixtures/operations/route53/change_resource_record_sets.yml

@@ -0,0 +1,18 @@
+# Ensure that params bound for the request URI (like hosted_zone_id) do not
+# end up in the XML request body
+operation: change_resource_record_sets
+config:
+  region: us-east-1
+params:
+  :hosted_zone_id: 'ZONE-ID'
+  :change_batch:
+    :changes: []
+request:
+  path: '/2012-12-12/hostedzone/ZONE-ID/rrset/'
+  body: |
+    <ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/2012-12-12/">
+      <ChangeBatch>
+        <Changes>
+        </Changes>
+      </ChangeBatch>
+    </ChangeResourceRecordSetsRequest>

data/tasks/test.rake

@@ -1,27 +1,15 @@
-def execute_cmd cmd
-  puts cmd if Rake.application.options.trace
-  system(cmd)
-  unless $?.to_i == 0
-    $stderr.puts "Command failed (#{$?}): #{cmd}"
-    exit($? >> 8)
-  end
-end
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
 
 namespace :test do
 
   desc "Runs unit tests"
-  task :unit do
-    opts = ['bundle exec rspec']
-    opts += FileList[ENV['FILES'] || 'spec/**/*_spec.rb'].sort
-    execute_cmd(opts.join(' '))
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = "spec"
   end
 
-  desc "Runs integration tests"
-  task :integration do
-    tags = []
-    tags << "--tags ~@pending"
-    tags << "--tags #{ENV['TAGS']}" if ENV['TAGS']
-    execute_cmd("bundle exec cucumber #{tags.join(' ')}".strip)
+  Cucumber::Rake::Task.new(:integration) do |t|
+    t.cucumber_opts = "features"
   end
 
 end