aws-sdk-core 2.0.48 → 2.1.0

data/lib/aws-sdk-core/assume_role_credentials.rb

@@ -13,8 +13,9 @@ module Aws
   #
   # If you omit `:client` option, a new {STS::Client} object will be
   # constructed.
-  class AssumeRoleCredentials < Credentials
+  class AssumeRoleCredentials
 
+    include CredentialProvider
     include RefreshingCredentials
 
     # @option options [required, String] :role_arn
@@ -35,11 +36,13 @@ module Aws
     private
 
     def refresh
-      creds = @client.assume_role(@options).credentials
-      @access_key_id = creds.access_key_id
-      @secret_access_key = creds.secret_access_key
-      @session_token = creds.session_token
-      @expiration = creds.expiration
+      c = @client.assume_role(@options).credentials
+      @credentials = Credentials.new(
+        c.access_key_id,
+        c.secret_access_key,
+        c.session_token
+      )
+      @expiration = c.expiration
     end
 
   end

data/lib/aws-sdk-core/client.rb

@@ -5,16 +5,18 @@ module Aws
     # @api private
     DEFAULT_PLUGINS = [
       'Seahorse::Client::Plugins::Logging',
-      'Seahorse::Client::Plugins::RestfulBindings',
       'Seahorse::Client::Plugins::ContentLength',
+      'Aws::Plugins::ParamConverter',
+      'Aws::Plugins::ParamValidator',
       'Aws::Plugins::UserAgent',
       'Aws::Plugins::RetryErrors',
       'Aws::Plugins::GlobalConfiguration',
       'Aws::Plugins::RegionalEndpoint',
       'Aws::Plugins::RequestSigner',
+      'Aws::Plugins::ResponsePaging',
+      'Aws::Plugins::StubResponses',
     ]
 
-    include ClientPaging
     include ClientStubs
     include ClientWaiters
 
@@ -28,11 +30,12 @@ module Aws
       def define(svc_name, options)
         client_class = Class.new(self)
         client_class.identifier = svc_name.downcase.to_sym
-        [:api, :paginators, :waiters].each do |definition|
-          client_class.send("set_#{definition}", options[definition])
+        client_class.set_api(Api::Builder.build(options[:api], options))
+        client_class.set_waiters(options[:waiters])
+        DEFAULT_PLUGINS.each do |plugin|
+          client_class.add_plugin(plugin)
         end
-        DEFAULT_PLUGINS.each { |plugin| client_class.add_plugin(plugin) }
-        Api::ServiceCustomizations.apply(client_class)
+        Api::Customizations.apply_plugins(client_class)
         client_class
       end
 

data/lib/aws-sdk-core/client_stubs.rb

@@ -8,15 +8,16 @@ module Aws
   # behavior.
   module ClientStubs
 
-    # @api private
-    def self.included(subclass)
-      subclass.add_plugin('Aws::Plugins::StubResponses')
-    end
-
     def initialize(*args)
       @stubs = {}
       @stub_mutex = Mutex.new
       super
+      if Hash === @config.stub_responses
+        @config.stub_responses.each do |operation_name, stubs|
+          apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
+        end
+        @config.stub_responses = true
+      end
     end
 
     # Configures what data / errors should be returned from the named operation
@@ -24,19 +25,45 @@ module Aws
     #
     # ## Basic usage
     #
-    # By default, fake responses are generated. You can override the default
-    # fake data with specific response data by passing a hash.
+    # When you enable response stubbing, the client will generate fake
+    # responses and will not make any HTTP requests.
     #
-    #     # enable response stubbing in the client constructor
     #     client = Aws::S3::Client.new(stub_responses: true)
+    #     client.list_buckets
+    #     #=> #<struct Aws::S3::Types::ListBucketsOutput buckets=[], owner=nil>
     #
-    #     # specify the response data for #list_buckets
-    #     client.stub_responses(:list_buckets, buckets:[{name:'aws-sdk'}])
+    # You can provide stub data that will be returned by the client.
     #
-    #     # no api calls made, stub returned
-    #     client.list_buckets.map(&:name)
+    #     # stub data in the constructor
+    #     client = Aws::S3::Client.new(stub_responses: {
+    #       list_buckets: { bukets: [{name: 'my-bucket' }] },
+    #       get_object: { body: 'data' },
+    #     })
+    #
+    #     client.list_buckets.buckets.map(&:name) #=> ['my-bucket']
+    #     client.get_object(bucket:'name', key:'key').body.read #=> 'data'
+    #
+    # You can also specify the stub data using {#stub_responses}
+    #
+    #     client = Aws::S3::Client.new(stub_responses: true)
+    #     client.stub_resposnes(:list_buckets, {
+    #       buckets: [{ name: 'my-bucket' }]
+    #     })
+    #
+    #     client.list_buckets.buckets.map(&:name) #=> ['my-bucket']
     #     #=> ['aws-sdk']
     #
+    # Lastly, default stubs can be configured via `Aws.config`:
+    #
+    #     Aws.config[:s3] = {
+    #       stub_responses: {
+    #         list_buckets: { bukets: [{name: 'my-bucket' }] }
+    #       }
+    #     }
+    #
+    #     Aws::S3::Client.new.list_buckets.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
     # ## Stubbing Errors
     #
     # When stubbing is enabled, the SDK will default to generate
@@ -55,12 +82,29 @@ module Aws
     #     client.get_object(bucket:'aws-sdk', key:'foo')
     #     #=> raises the given runtime error object
     #
+    # ## Stubbing HTTP Responses
+    #
+    # As an alternative to providing the response data, you can provide
+    # an HTTP response.
+    #
+    #     client.stub_responses(:get_object, {
+    #       status_code: 200,
+    #       headers: { 'header-name' => 'header-value' },
+    #       body: "...",
+    #     })
+    #
+    # To stub a HTTP response, pass a Hash with all three of the following
+    # keys set:
+    #
+    # * **`:status_code`** - <Integer> - The HTTP status code
+    # * **`:headers`** - Hash<String,String> - A hash of HTTP header keys and values
+    # * **`:body`** - <String,IO> - The HTTP response body.
+    #
     # ## Stubbing Multiple Responses
     #
     # Calling an operation multiple times will return similar responses.
     # You can configure multiple stubs and they will be returned in sequence.
     #
-    #
     #     client.stub_responses(:head_object, [
     #       'NotFound',
     #       { content_length: 150 },
@@ -73,12 +117,16 @@ module Aws
     #     resp.content_length #=> 150
     #
     # @param [Symbol] operation_name
+    #
     # @param [Mixed] stubs One or more responses to return from the named
     #   operation.
+    #
     # @return [void]
+    #
     # @raise [RuntimeError] Raises a runtime error when called
     #   on a client that has not enabled response stubbing via
     #   `:stub_responses => true`.
+    #
     def stub_responses(operation_name, *stubs)
       if config.stub_responses
         apply_stubs(operation_name, stubs.flatten)
@@ -89,12 +137,35 @@ module Aws
       end
     end
 
+    # Generates and returns stubbed response data from the named operation.
+    #
+    #     s3 = Aws::S3::Client.new
+    #     s3.stub_data(:list_buckets)
+    #     #=> #<struct Aws::S3::Types::ListBucketsOutput buckets=[], owner=#<struct Aws::S3::Types::Owner display_name="DisplayName", id="ID">>
+    #
+    # In addition to generating default stubs, you can provide data to
+    # apply to the response stub.
+    #
+    #     s3.stub_data(:list_buckets, buckets:[{name:'aws-sdk'}])
+    #     #=> #<struct Aws::S3::Types::ListBucketsOutput
+    #       buckets=[#<struct Aws::S3::Types::Bucket name="aws-sdk", creation_date=nil>],
+    #       owner=#<struct Aws::S3::Types::Owner display_name="DisplayName", id="ID">>
+    #
+    # @param [Symbol] operation_name
+    # @param [Hash] data
+    # @return [Structure] Returns a stubbed response data structure. The
+    #   actual class returned will depend on the given `operation_name`.
+    def stub_data(operation_name, data = {})
+      Stubbing::StubData.new(operation(operation_name)).stub(data)
+    end
+
     # @api private
     def next_stub(operation_name)
+      operation_name = operation_name.to_sym
       @stub_mutex.synchronize do
-        stubs = @stubs[operation_name.to_sym] || []
+        stubs = @stubs[operation_name] || []
         case stubs.length
-        when 0 then new_stub(operation_name)
+        when 0 then default_stub(operation_name)
         when 1 then stubs.first
         else stubs.shift
         end
@@ -103,141 +174,64 @@ module Aws
 
     private
 
-    # @param [Symbol] operation_name
-    # @param [Hash, nil] data
-    # @return [Structure]
-    def new_stub(operation_name, data = nil)
-      Stub.new(operation(operation_name).output).format(data || {})
+    def default_stub(operation_name)
+      stub = stub_data(operation_name)
+      http_response_stub(operation_name, stub)
     end
 
+    # This method converts the given stub data and converts it to a
+    # HTTP response (when possible). This enables the response stubbing
+    # plugin to provide a HTTP response that triggers all normal events
+    # during response handling.
     def apply_stubs(operation_name, stubs)
       @stub_mutex.synchronize do
         @stubs[operation_name.to_sym] = stubs.map do |stub|
           case stub
-          when Exception then stub
-          when String then service_error_class(stub)
-          when Hash then new_stub(operation_name, stub)
-          else stub
+          when Exception, Class then { error: stub }
+          when String then service_error_stub(stub)
+          when Hash then http_response_stub(operation_name, stub)
+          else { data: stub }
           end
         end
       end
     end
 
-    def service_error_class(name)
-      svc_module = Aws.const_get(self.class.name.split('::')[1])
-      svc_module.const_get(:Errors).const_get(name)
+    def service_error_stub(error_code)
+      { http: protocol_helper.stub_error(error_code) }
     end
 
-    class Stub
-
-      # @param [Seahorse::Models::Shapes::Structure] output_shape This should
-      #   be the output shape for an operation.
-      def initialize(output_shape)
-        @shape = output_shape
-      end
-
-      # @param [Hash] data An optional hash of data to format into the stubbed
-      #   object.
-      def format(data = {})
-        if @shape.nil?
-          empty_stub(data)
-        else
-          validate_data(data)
-          stub(@shape, data)
-        end
-      end
-
-      private
-
-      def stub(shape, value)
-        case shape
-        when Seahorse::Model::Shapes::Structure then stub_structure(shape, value)
-        when Seahorse::Model::Shapes::List then stub_list(shape, value || [])
-        when Seahorse::Model::Shapes::Map then stub_map(shape, value || {})
-        else stub_scalar(shape, value)
-        end
-      end
-
-      def stub_structure(shape, hash)
-        if hash
-          structure_obj(shape, hash)
-        else
-          nil
-        end
-      end
-
-      def structure_obj(shape, hash)
-        stubs = Structure.new(shape.member_names)
-        shape.members.each do |member_name, member_shape|
-          if hash.key?(member_name) && hash[member_name].nil?
-            stubs[member_name] = nil
-          else
-            value = structure_value(shape, member_name, member_shape, hash)
-            stubs[member_name] = stub(member_shape, value)
-          end
-        end
-        stubs
-      end
-
-      def structure_value(shape, member_name, member_shape, hash)
-        if hash.key?(member_name)
-          hash[member_name]
-        elsif
-          Seahorse::Model::Shapes::Structure === member_shape &&
-          shape.required.include?(member_name)
-        then
-          {}
-        else
-          nil
-        end
-      end
-
-      def stub_list(shape, array)
-        stubs = []
-        array.each do |value|
-          stubs << stub(shape.member, value)
-        end
-        stubs
-      end
-
-      def stub_map(shape, value)
-        stubs = {}
-        value.each do |key, value|
-          stubs[key] = stub(shape.value, value)
-        end
-        stubs
-      end
-
-      def stub_scalar(shape, value)
-        if value.nil?
-          case shape
-          when Seahorse::Model::Shapes::String then shape.name
-          when Seahorse::Model::Shapes::Integer then 0
-          when Seahorse::Model::Shapes::Float then 0.0
-          when Seahorse::Model::Shapes::Boolean then false
-          when Seahorse::Model::Shapes::Timestamp then Time.now
-          else nil
-          end
-        else
-          value
-        end
+    def http_response_stub(operation_name, data)
+      if Hash === data && data.keys.sort == [:body, :headers, :status_code]
+        { http: hash_to_http_resp(data) }
+      else
+        { http: data_to_http_resp(operation_name, data) }
       end
+    end
 
-      def empty_stub(data)
-        if data.empty?
-          Structure.new(data)
-        else
-          msg = 'unable to generate a stubbed response from the given data; '
-          msg << 'this operation does not return data'
-          raise ArgumentError, msg
-        end
-      end
+    def hash_to_http_resp(data)
+      http_resp = Seahorse::Client::Http::Response.new
+      http_resp.status_code = data[:status_code]
+      http_resp.headers.update(data[:headers])
+      http_resp.body = data[:body]
+      http_resp
+    end
 
-      def validate_data(data)
-        args = [@shape, { validate_required:false }]
-        Seahorse::Client::ParamValidator.new(*args).validate!(data)
-      end
+    def data_to_http_resp(operation_name, data)
+      api = config.api
+      operation = api.operation(operation_name)
+      ParamValidator.validate!(operation.output, data)
+      protocol_helper.stub_data(api, operation, data)
+    end
 
+    def protocol_helper
+      case config.api.metadata['protocol']
+      when 'json'      then Stubbing::Protocols::Json
+      when 'query'     then Stubbing::Protocols::Query
+      when 'ec2'       then Stubbing::Protocols::EC2
+      when 'rest-json' then Stubbing::Protocols::RestJson
+      when 'rest-xml'  then Stubbing::Protocols::RestXml
+      else raise "unsupported protocol"
+      end.new
     end
   end
 end

data/lib/aws-sdk-core/client_waiters.rb

@@ -10,7 +10,7 @@ module Aws
             case waiters
             when Waiters::Provider then waiters
             when Hash then Waiters::Provider.new(waiters)
-            when String, Pathname then Waiters::Provider.new(Aws.load_json(waiters))
+            when String, Pathname then Waiters::Provider.new(Json.load_file(waiters))
             when nil then Waiters::NullProvider.new
             else raise ArgumentError, 'invalid waiters'
             end

data/lib/aws-sdk-core/credential_provider.rb

@@ -0,0 +1,44 @@
+module Aws
+  module CredentialProvider
+
+    extend Deprecations
+
+    # @return [Credentials]
+    def credentials
+      @credentials
+    end
+
+    # @return [Boolean]
+    def set?
+      !!@credentials && @credentials.set?
+    end
+
+    # @deprecated Deprecated in 2.1.0. This method is subject to errors
+    #   from a race condition when called against refreshable credential
+    #   objects. Will be removed in 2.2.0.
+    # @see #credentials
+    def access_key_id
+      @credentials ? @credentials.access_key_id : nil
+    end
+    deprecated(:access_key_id, use: '#credentials')
+
+    # @deprecated Deprecated in 2.1.0. This method is subject to errors
+    #   from a race condition when called against refreshable credential
+    #   objects. Will be removed in 2.2.0.
+    # @see #credentials
+    def secret_access_key
+      @credentials ? @credentials.secret_access_key : nil
+    end
+    deprecated(:secret_access_key, use: '#credentials')
+
+    # @deprecated Deprecated in 2.1.0. This method is subject to errors
+    #   from a race condition when called against refreshable credential
+    #   objects. Will be removed in 2.2.0.
+    # @see #credentials
+    def session_token
+      @credentials ? @credentials.session_token : nil
+    end
+    deprecated(:session_token, use: '#credentials')
+
+  end
+end