V4 improvements

Author: Matt Muller

gems/smithy-cbor/lib/smithy-cbor/codec.rb

@@ -8,29 +8,25 @@ module CBOR
     # Codec that serializes and deserializes in CBOR format.
     # TODO:
     #   * Update implementation to handle event streams
-    #   * Allow user to pass in their preferred type to deserialize
-    #     If it fails, resort to deserializing type on the shape.
     class Codec
-      include Schema::Shapes
-
       # @param [Hash] options
       def initialize(options = {})
         @options = options
       end
 
       # @param [Shape] shape
       # @param [Object] data
-      # @return [String, nil] the encoded bytes in CBOR format
+      # @return [String, nil]
       def serialize(shape, data)
         Serializer.new(@options).serialize(shape, data)
       end
 
       # @param [Shape] shape
       # @param [String] bytes
-      # @param [Struct] type
-      # @return [Object, Hash]
-      def deserialize(shape, bytes, type = nil)
-        Deserializer.new(@options).deserialize(shape, bytes, type)
+      # @param [Object] target
+      # @return [Object]
+      def deserialize(shape, bytes, target = nil)
+        Deserializer.new(@options).deserialize(shape, bytes, target)
       end
     end
   end

gems/smithy-cbor/lib/smithy-cbor/deserializer.rb

@@ -12,78 +12,78 @@ def initialize(options = {})
         @options = options
       end
 
-      def deserialize(shape, bytes, type)
+      def deserialize(shape, bytes, target)
         return {} if bytes.empty? || shape == Prelude::Unit
 
-        shape(shape, CBOR.decode(bytes), type)
+        shape(shape, CBOR.decode(bytes), target)
       end
 
       private
 
-      def shape(shape, value, type = nil)
+      def shape(shape, value, target = nil)
         return nil if value.nil?
 
         case shape
-        when StructureShape then structure(shape, value, type)
-        when UnionShape then union(shape, value, type)
-        when ListShape then list(shape, value, type)
-        when MapShape then map(shape, value, type)
+        when ListShape then list(shape, value, target)
+        when MapShape then map(shape, value, target)
+        when StructureShape then structure(shape, value, target)
+        when UnionShape then union(shape, value, target)
         else value
         end
       end
 
-      def list(shape, values, type = nil)
-        type = [] if type.nil?
+      def list(shape, values, target = nil)
+        target = [] if target.nil?
         values.each do |value|
           next if value.nil? && !sparse?(shape)
 
-          type <<
+          target <<
             if value.nil?
               nil
             else
               shape(shape.member.shape, value)
             end
         end
-        type
+        target
       end
 
-      def map(shape, values, type = nil)
-        type = {} if type.nil?
+      def map(shape, values, target = nil)
+        target = {} if target.nil?
         values.each do |key, value|
           next if value.nil? && !sparse?(shape)
 
-          type[key] =
+          target[key] =
             if value.nil?
               nil
             else
               shape(shape.value.shape, value)
             end
         end
-        type
+        target
       end
 
-      def structure(shape, values, type = nil)
+      def structure(shape, values, target = nil)
         return Schema::EmptyStructure.new if shape == Prelude::Unit
 
-        type = shape.type.new if type.nil?
+        target = shape.type.new if target.nil?
         values.each do |key, value|
           next unless shape.name_by_member_name?(key)
 
           name = shape.name_by_member_name(key)
           member_shape = shape.member(name)
-          type[name] = shape(member_shape.shape, value)
+          target[name] = shape(member_shape.shape, value)
         end
-        type
+        target
       end
 
-      def union(shape, values, type = nil)
+      def union(shape, values, target = nil)
         key, value = values.flatten
-        return nil if key.nil? || key == ' __type'
+        return nil if key.nil? || key == ' __target'
 
         if shape.name_by_member_name?(key)
           member_name = shape.name_by_member_name(key)
-          type = shape.member_type(member_name) if type.nil?
-          type.new(shape(shape.member(member_name).shape, value))
+          target = shape.member_type(member_name) if target.nil?
+          target.new(shape(shape.member(member_name).shape, value))
         else
           shape.member_type(:unknown).new(key, value)
         end

gems/smithy-cbor/lib/smithy-cbor/serializer.rb

@@ -20,14 +20,14 @@ def serialize(shape, data)
 
       private
 
-      def shape(shape, values)
+      def shape(shape, value)
         case shape
-        when BlobShape then blob(values)
-        when ListShape then list(shape, values)
-        when MapShape then map(shape, values)
-        when StructureShape then structure(shape, values)
-        when UnionShape then union(shape, values)
-        else values
+        when BlobShape then blob(value)
+        when ListShape then list(shape, value)
+        when MapShape then map(shape, value)
+        when StructureShape then structure(shape, value)
+        when UnionShape then union(shape, value)
+        else value
         end
       end
 

gems/smithy-client/lib/smithy-client/plugins/protocol.rb

@@ -24,8 +24,8 @@ def call(context)
         class ParseHandler < Handler
           def call(context)
             output = @handler.call(context)
-            output.error = context.config.protocol.parse_error(context) unless output.error
-            output.data = context.config.protocol.parse_data(context) unless output.error
+            output.error = context.config.protocol.parse_error(output) unless output.error
+            output.data = context.config.protocol.parse_data(output) unless output.error
             output
           end
         end

gems/smithy-client/lib/smithy-client/rpc_v2_cbor/protocol.rb

@@ -17,12 +17,12 @@ def build_request(context)
           RequestBuilder.new(@options).build(context)
         end
 
-        def parse_error(context)
-          ResponseParser.new(@options).parse_error(context)
+        def parse_error(output)
+          ResponseParser.new(@options).parse_error(output.context)
         end
 
-        def parse_data(context)
-          ResponseParser.new(@options).parse_data(context)
+        def parse_data(output)
+          ResponseParser.new(@options).parse_data(output.context)
         end
 
         def stub_data(service, operation, data)

gems/smithy-client/lib/smithy-client/rpc_v2_cbor/request_builder.rb

@@ -10,18 +10,22 @@ def initialize(options = {})
         end
 
         def build(context)
-          context.request.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
-          context.request.http_method = 'POST'
-          context.request.body = build_body(context)
-          apply_content_type_header(context)
-          apply_accept_header(context)
-          build_url(context)
+          apply_http_method(context)
+          apply_headers(context)
+          apply_body(context)
+          apply_url_path(context)
         end
 
         private
 
-        def build_body(context)
-          @codec.serialize(context.operation.input, context.params)
+        def apply_http_method(context)
+          context.request.http_method = 'POST'
+        end
+
+        def apply_headers(context)
+          context.request.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
+          apply_content_type_header(context)
+          apply_accept_header(context)
         end
 
         def apply_content_type_header(context)
@@ -47,6 +51,16 @@ def apply_accept_header(context)
           context.request.headers['Accept'] ||= accept
         end
 
+        def apply_body(context)
+          context.request.body = @codec.serialize(context.operation.input, context.params)
+        end
+
+        def apply_url_path(context)
+          base = context.request.endpoint
+          service_name = context.config.service.name
+          base.path += "/service/#{service_name}/operation/#{context.operation.name}"
+        end
+
         def event_stream?(shape)
           shape.members.each_value do |member_shape|
             return true if event_stream_shape?(member_shape.shape)
@@ -57,12 +71,6 @@ def event_stream?(shape)
         def event_stream_shape?(shape)
           shape.traits.include?('smithy.api#streaming') && shape.is_a?(Schema::Shapes::UnionShape)
         end
-
-        def build_url(context)
-          base = context.request.endpoint
-          service_name = context.config.service.name
-          base.path += "/service/#{service_name}/operation/#{context.operation.name}"
-        end
       end
     end
   end

gems/smithy-client/lib/smithy-client/rpc_v2_cbor/response_stubber.rb

@@ -23,6 +23,7 @@ def stub_error(error_code)
           resp.status_code = 400
           resp.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
           resp.headers['Content-Type'] = 'application/cbor'
+          resp.headers['X-Amzn-RequestId'] = 'stubbed-request-id'
           data = { '__type' => error_code, 'message' => 'stubbed-error-message' }
           resp.body = CBOR.encode(data)
           resp

gems/smithy-client/lib/smithy-client/stubbing/protocol.rb

@@ -7,8 +7,8 @@ module Stubbing
       # @api private
       class Protocol
         def build_request(_context); end
-        def parse_data(_context); end
-        def parse_error(_context); end
+        def parse_data(_output); end
+        def parse_error(_output); end
 
         def stub_data(_service, _operation, data)
           resp = HTTP::Response.new

gems/smithy/lib/smithy/templates/client/protocol_spec.erb

@@ -86,9 +86,13 @@ module <%= module_name %>
           response = { status_code: <%= test['code'] %> }
 <% if test['headers'] -%>
           response[:headers] = <%= test['headers'] %>
+<% else -%>
+          response[:headers] = {}
 <% end -%>
 <% if test['body'] -%>
           response[:body] = <%= test.stub_body %>
+<% else -%>
+          response[:body] = nil
 <% end -%>
 
           client.stub_responses(:<%= operation_tests.name %>, response)
@@ -118,9 +122,13 @@ module <%= module_name %>
           response = { status_code: <%= test['code'] %> }
 <% if test['headers'] -%>
           response[:headers] = <%= test['headers'] %>
+<% else -%>
+          response[:headers] = {}
 <% end -%>
 <% if test['body'] -%>
           response[:body] = <%= test.stub_body %>
+<% else -%>
+          response[:body] = nil
 <% end -%>
 
           client.stub_responses(:<%= operation_tests.name %>, response)

gems/smithy/lib/smithy/views/client/protocol_spec.rb

@@ -121,6 +121,8 @@ def additional_requires
                 case test_case['bodyMediaType']
                 when 'application/cbor'
                   %w[base64 cbor_value_matcher]
+                when 'application/json'
+                  %w[json]
                 else
                   []
                 end
@@ -161,6 +163,8 @@ def body_expect
             when 'application/cbor'
               'expect(Smithy::CBOR.decode(request.body.read)).' \
               "to match_cbor(Smithy::CBOR.decode(::Base64.decode64('#{test_case['body']}')))"
+            when 'application/json'
+              "expect(JSON.parse(request.body.read)).to eq(JSON.parse(#{test_case['body']}))"
             else
               "expect(request.body.read).to eq('#{test_case['body']}')"
             end