aws-sdk-core 2.0.48 → 2.1.0

data/lib/aws-sdk-core/stubbing/protocols/json.rb

@@ -0,0 +1,40 @@
+module Aws
+  module Stubbing
+    module Protocols
+      class Json
+
+        def stub_data(api, operation, data)
+          resp = Seahorse::Client::Http::Response.new
+          resp.status_code = 200
+          resp.headers["Content-Type"] = content_type(api)
+          resp.headers["x-amzn-RequestId"] = "stubbed-request-id"
+          resp.body = build_body(operation, data)
+          resp
+        end
+
+        def stub_error(error_code)
+          http_resp = Seahorse::Client::Http::Response.new
+          http_resp.status_code = 400
+          http_resp.body = <<-JSON.strip
+{
+  "code": #{error_code.inspect},
+  "message": "stubbed-response-error-message"
+}
+          JSON
+          http_resp
+        end
+
+        private
+
+        def content_type(api)
+          "application/x-amz-json-#{api.metadata['jsonVerison']}"
+        end
+
+        def build_body(operation, data)
+          Aws::Json::Builder.new(operation.output).to_json(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/stubbing/protocols/query.rb

@@ -0,0 +1,40 @@
+module Aws
+  module Stubbing
+    module Protocols
+      class Query
+
+        def stub_data(api, operation, data)
+          resp = Seahorse::Client::Http::Response.new
+          resp.status_code = 200
+          resp.body = build_body(api, operation, data)
+          resp
+        end
+
+        def stub_error(error_code)
+        end
+
+        private
+
+        def build_body(api, operation, data)
+          xml = []
+          builder = Aws::Xml::DocBuilder.new(target: xml, indent: '  ')
+          builder.node(operation.name + 'Response', xmlns: xmlns(api)) do
+            if rules = operation.output
+              rules.location_name = operation.name + 'Result'
+              Xml::Builder.new(rules, target:xml, pad:'  ').to_xml(data)
+            end
+            builder.node('ResponseMetadata') do
+              builder.node('RequestId', 'stubbed-request-id')
+            end
+          end
+          xml.join
+        end
+
+        def xmlns(api)
+          api.metadata['xmlNamespace']
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/stubbing/protocols/rest.rb

@@ -0,0 +1,67 @@
+module Aws
+  module Stubbing
+    module Protocols
+      class Rest
+
+        include Seahorse::Model::Shapes
+
+        def stub_data(api, operation, data)
+          resp = new_http_response
+          apply_status_code(operation, resp, data)
+          apply_headers(operation, resp, data)
+          apply_body(api, operation, resp, data)
+          resp
+        end
+
+        private
+
+        def new_http_response
+          resp = Seahorse::Client::Http::Response.new
+          resp.status_code = 200
+          resp.headers["x-amzn-RequestId"] = "stubbed-request-id"
+          resp
+        end
+
+        def apply_status_code(operation, resp, data)
+          operation.output.shape.members.each do |member_name, member_ref|
+            if member_ref.location == 'statusCode'
+              resp.status_code = data[member_name] if data.key?(member_name)
+            end
+          end
+        end
+
+        def apply_headers(operation, resp, data)
+          Aws::Rest::Request::Headers.new(operation.output).apply(resp, data)
+        end
+
+        def apply_body(api, operation, resp, data)
+          resp.body = build_body(api, operation, data)
+        end
+
+        def build_body(api, operation, data)
+          rules = operation.output
+          if streaming?(rules)
+            data[rules[:payload]]
+          elsif rules[:payload]
+            body_for(api, operation, rules[:payload_member], data[rules[:payload]])
+          else
+            body_for(api, operation, rules, data)
+          end
+        end
+
+        def streaming?(ref)
+          if ref[:payload]
+            case ref[:payload_member].shape
+            when StringShape then true
+            when BlobShape then true
+            else false
+            end
+          else
+            false
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/stubbing/protocols/rest_json.rb

@@ -0,0 +1,25 @@
+module Aws
+  module Stubbing
+    module Protocols
+      class RestJson < Rest
+
+        def body_for(_, _, rules, data)
+          Aws::Json::Builder.new(rules).serialize(data)
+        end
+
+        def stub_error(error_code)
+          http_resp = Seahorse::Client::Http::Response.new
+          http_resp.status_code = 400
+          http_resp.body = <<-JSON.strip
+{
+  "code": #{error_code.inspect},
+  "message": "stubbed-response-error-message"
+}
+          JSON
+          http_resp
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/stubbing/protocols/rest_xml.rb

@@ -0,0 +1,38 @@
+module Aws
+  module Stubbing
+    module Protocols
+      class RestXml < Rest
+
+        include Seahorse::Model::Shapes
+
+        def body_for(api, operation, rules, data)
+          xml = []
+          builder = Aws::Xml::DocBuilder.new(target: xml, indent: '  ')
+          rules.location_name = operation.name + 'Result'
+          rules['xmlNamespace'] = { 'uri' => api.metadata['xmlNamespace'] }
+          Xml::Builder.new(rules, target:xml).to_xml(data)
+          xml.join
+        end
+
+        def stub_error(error_code)
+          http_resp = Seahorse::Client::Http::Response.new
+          http_resp.status_code = 400
+          http_resp.body = <<-XML.strip
+<ErrorResponse>
+  <Error>
+    <Code>#{error_code}</Code>
+    <Message>stubbed-response-error-message</Message>
+  </Error>
+</ErrorResponse>
+          XML
+          http_resp
+        end
+
+        def xmlns(api)
+          api.metadata['xmlNamespace']
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/stubbing/stub_data.rb

@@ -0,0 +1,34 @@
+module Aws
+  module Stubbing
+    class StubData
+
+      def initialize(operation)
+        @rules = operation.output
+        @pager = operation[:pager]
+      end
+
+      def stub(data = {})
+        stub = EmptyStub.new(@rules).stub
+        remove_paging_tokens(stub)
+        apply_data(data, stub)
+        stub
+      end
+
+      private
+
+      def remove_paging_tokens(stub)
+        if @pager
+          @pager.instance_variable_get("@tokens").keys.each do |path|
+            key = path.split(/\b/)[0]
+            stub[key] = nil
+          end
+        end
+      end
+
+      def apply_data(data, stub)
+        ParamValidator.new(@rules, validate_required:false).validate!(data)
+        DataApplicator.new(@rules).apply_data(data, stub)
+      end
+    end
+  end
+end

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

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.0.48'
+  VERSION = '2.1.0'
 end

data/lib/aws-sdk-core/xml/builder.rb

@@ -1,89 +1,99 @@
-require 'builder'
 require 'base64'
 
 module Aws
   module Xml
     class Builder
 
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      def initialize(shape)
-        @shape = shape
-        @xml = []
-        @builder = ::Builder::XmlMarkup.new(target: @xml, indent: 2)
+      include Seahorse::Model::Shapes
+
+      def initialize(rules, options = {})
+        @rules = rules
+        @xml = options[:target] || []
+        indent = options[:indent] || '  '
+        pad = options[:pad] || ''
+        @builder = DocBuilder.new(target:@xml, indent:indent, pad:pad)
       end
 
-      # @param [Hash] params
-      # @return [String] Returns an XML doc string.
       def to_xml(params)
-        structure(@shape.location_name, @shape, params)
+        structure(@rules.location_name, @rules, params)
         @xml.join
       end
+      alias serialize to_xml
 
       private
 
-      def structure(name, shape, values)
+      def structure(name, ref, values)
         if values.empty?
-          node(name, shape)
+          node(name, ref)
         else
-          node(name, shape, structure_attrs(shape, values)) do
-            shape.members.each do |member_name, member_shape|
-              unless values[member_name].nil?
-                next if xml_attribute?(member_shape)
-                mname = member_shape.location_name || member_name.to_s
-                member(mname, member_shape, values[member_name])
-              end
+          node(name, ref, structure_attrs(ref, values)) do
+            ref.shape.members.each do |member_name, member_ref|
+              next if values[member_name].nil?
+              next if xml_attribute?(member_ref)
+              member(member_ref.location_name, member_ref, values[member_name])
             end
           end
         end
       end
 
-      def structure_attrs(shape, values)
-        shape.members.inject({}) do |attrs, (member_name, member_shape)|
-          if xml_attribute?(member_shape) && values.key?(member_name)
-            attrs[member_shape.location_name] = values[member_name]
+      def structure_attrs(ref, values)
+        ref.shape.members.inject({}) do |attrs, (member_name, member_ref)|
+          if xml_attribute?(member_ref) && values.key?(member_name)
+            attrs[member_ref.location_name] = values[member_name]
           end
           attrs
         end
       end
 
-      def list(name, shape, values)
-        if flat?(shape)
+      def list(name, ref, values)
+        if ref['flattened']
           values.each do |value|
-            member(name, shape.member, value)
+            member(ref.shape.member.location_name || name, ref.shape.member, value)
           end
         else
-          node(name, shape) do
+          node(name, ref) do
             values.each do |value|
-              mname = shape.member.location_name || 'member'
-              member(mname, shape.member, value)
+              mname = ref.shape.member.location_name || 'member'
+              member(mname, ref.shape.member, value)
             end
           end
         end
       end
 
-      def map(name, shape, hash)
-        node(name, shape) do
+      def map(name, ref, hash)
+        key_ref = ref.shape.key
+        value_ref = ref.shape.value
+        node(name, ref) do
           hash.each do |key, value|
-            node('entry', shape)  do
-              member(shape.key.location_name || 'key', shape.key, key)
-              member(shape.value.location_name || 'value', shape.value, value)
+            node('entry', ref)  do
+              member(key_ref.location_name || 'key', key_ref, key)
+              member(value_ref.location_name || 'value', value_ref, value)
             end
           end
         end
       end
 
-      def member(name, shape, value)
-        case shape.type
-        when 'structure' then structure(name, shape, value)
-        when 'list'      then list(name, shape, value)
-        when 'timestamp' then node(name, shape, shape.format_time(value, 'iso8601'))
-        when 'blob'      then node(name, shape, Base64.strict_encode64(value.read))
-        when 'map'       then map(name, shape, value)
+      def member(name, ref, value)
+        case ref.shape
+        when StructureShape then structure(name, ref, value)
+        when ListShape      then list(name, ref, value)
+        when MapShape       then map(name, ref, value)
+        when TimestampShape then node(name, ref, timestamp(value))
+        when BlobShape      then node(name, ref, blob(value))
         else
-          node(name, shape, value.to_s)
+          node(name, ref, value.to_s)
         end
       end
 
+      def blob(value)
+        value = value.read unless String === value
+        Base64.strict_encode64(value)
+      end
+
+      def timestamp(value)
+        value.utc.iso8601
+      end
+
       # The `args` list may contain:
       #
       #   * [] - empty, no value or attributes
@@ -94,15 +104,15 @@ module Aws
       # Pass a block if you want to nest XML nodes inside.  When doing this,
       # you may *not* pass a value to the `args` list.
       #
-      def node(name, shape, *args, &block)
+      def node(name, ref, *args, &block)
         attrs = args.last.is_a?(Hash) ? args.pop : {}
-        attrs = shape_attrs(shape).merge(attrs)
+        attrs = shape_attrs(ref).merge(attrs)
         args << attrs
-        @builder.__send__(name, *args, &block)
+        @builder.node(name, *args, &block)
       end
 
-      def shape_attrs(shape)
-        if xmlns = shape.metadata('xmlNamespace')
+      def shape_attrs(ref)
+        if xmlns = ref['xmlNamespace']
           if prefix = xmlns['prefix']
             { 'xmlns:' + prefix => xmlns['uri'] }
           else
@@ -113,12 +123,8 @@ module Aws
         end
       end
 
-      def xml_attribute?(shape)
-        !!shape.metadata('xmlAttribute')
-      end
-
-      def flat?(shape)
-        shape.metadata('flattened')
+      def xml_attribute?(ref)
+        !!ref['xmlAttribute']
       end
 
     end

data/lib/aws-sdk-core/xml/default_map.rb

@@ -0,0 +1,10 @@
+module Aws
+  module Xml
+    # @api private
+    class DefaultMap < Hash
+
+      alias nil? empty?
+
+    end
+  end
+end

data/lib/aws-sdk-core/xml/doc_builder.rb

@@ -0,0 +1,86 @@
+module Aws
+  module Xml
+    class DocBuilder
+
+      # @option options [#<<] :target ('')
+      # @option options [String] :pad ('')
+      # @option options [String] :indent ('')
+      def initialize(options = {})
+        @target = options[:target] || ''
+        @indent = options[:indent] || ''
+        @pad = options[:pad] || ''
+        @end_of_line = @indent == '' ? '' : "\n"
+      end
+
+      attr_reader :target
+
+      # @overload node(name, attributes = {})
+      #   Adds a self closing element without any content.
+      #
+      # @overload node(name, value, attributes = {})
+      #   Adds an element that opens and closes on the same line with
+      #   simple text content.
+      #
+      # @overload node(name, attributes = {}, &block)
+      #   Adds a wrapping element.  Calling {#node} from inside
+      #   the yielded block creates nested elements.
+      #
+      # @return [void]
+      #
+      def node(name, *args, &block)
+        attrs = args.last.is_a?(Hash) ? args.pop : {}
+        if block_given?
+          @target << open_el(name, attrs)
+          @target << @end_of_line
+          increase_pad { yield }
+          @target << @pad
+          @target << close_el(name)
+        elsif args.empty?
+          @target << empty_element(name, attrs)
+        else
+          @target << inline_element(name, args.first, attrs)
+        end
+      end
+
+      private
+
+      def empty_element(name, attrs)
+        "#{@pad}<#{name}#{attributes(attrs)}/>#{@end_of_line}"
+      end
+
+      def inline_element(name, value, attrs)
+        "#{open_el(name, attrs)}#{escape(value, :text)}#{close_el(name)}"
+      end
+
+      def open_el(name, attrs)
+        "#{@pad}<#{name}#{attributes(attrs)}>"
+      end
+
+      def close_el(name)
+        "</#{name}>#{@end_of_line}"
+      end
+
+      def escape(string, text_or_attr)
+        string.to_s.encode(:xml => text_or_attr)
+      end
+
+      def attributes(attr)
+        if attr.empty?
+          ''
+        else
+          ' ' + attr.map do |key, value|
+            "#{key}=#{escape(value, :attr)}"
+          end.join(' ')
+        end
+      end
+
+      def increase_pad(&block)
+        pre_increase = @pad
+        @pad = @pad + @indent
+        yield
+        @pad = pre_increase
+      end
+
+    end
+  end
+end