transport agnostic error test fixes + protocol fixes.

codegen/smithy-ruby-codegen-test/integration-specs/errors_spec.rb

@@ -51,7 +51,8 @@ module Errors
 
     describe ClientError do
       it 'is retryable without throttling' do
-        error = ClientError.new(data: nil, metadata: {},
+        error = ClientError.new(data: Types::ClientError.new,
+                                metadata: {},
                                 error_code: 'error')
         expect(error.retryable?).to be true
         expect(error.throttling?).to be false
@@ -60,7 +61,7 @@ module Errors
 
     describe ServerError do
       it 'is retryable with throttling' do
-        error = ServerError.new(data: nil, metadata: {},
+        error = ServerError.new(data: Types::ServerError.new, metadata: {},
                                 error_code: 'error')
         expect(error.retryable?).to be true
         expect(error.throttling?).to be true

codegen/smithy-ruby-codegen-test/integration-specs/event_stream_stubs_spec.rb

@@ -287,7 +287,7 @@
       subject.stub_responses(
         :start_event_stream,
         WhiteLabel::Errors::ClientError.new(
-          data: nil,
+          data: Types::ClientError.new,
           error_code: 'ClientError'
         )
       )

codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/HttpProtocolTestGenerator.java

@@ -299,7 +299,7 @@ private void renderErrorTests(OperationShape operation) {
                             .dedent()
                             .write("rescue Errors::$L => e", error.getId().getName())
                             .indent()
-                            .write("expect(e.http_status).to eq($L)", testCase.getCode())
+                            .write("expect(e.metadata[:http_resp].status).to eq($L)", testCase.getCode())
                             .write("expect(e.data.to_h).to eq($L)",
                                     getRubyHashFromParams(error, testCase.getParams()))
                             .closeBlock("end")

codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestParserGeneratorBase.java

@@ -135,12 +135,12 @@ protected void renderOperationParseMethod(OperationShape operation, Shape output
     @Override
     protected void renderErrorParseMethod(Shape s) {
         writer
-                .openBlock("def self.parse(http_resp)")
+                .openBlock("def self.parse(http_resp, **kwargs)")
                 .write("data = $T.new", context.symbolProvider().toSymbol(s))
                 .call(() -> renderHeaderParsers(s))
-                .call(() -> renderPrefixHeaderParsers(s))
                 .call(() -> renderOperationBodyParser(s))
-                .write("data")
+                .write("Errors::$L.new(data: data, **kwargs)",
+                        context.symbolProvider().toSymbol(s).getName())
                 .closeBlock("end");
     }
 

codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/ParserGenerator.java

@@ -152,14 +152,15 @@ protected void renderOperationParseMethod(OperationShape operation, Shape output
     @Override
     protected void renderErrorParseMethod(Shape shape) {
         writer
-                .openBlock("def self.parse(http_resp)")
+                .openBlock("def self.parse(http_resp, **kwargs)")
                 .write("data = $T.new", context.symbolProvider().toSymbol(shape))
                 .write("body = http_resp.body.read")
-                .write("return data if body.empty?")
-                .write("map = $T.decode(body)", Hearth.CBOR);
-        renderMemberParsers(shape);
-        writer
-                .write("data")
+                .openBlock("unless body.empty?")
+                .write("map = $T.decode(body)", Hearth.CBOR)
+                 .call(() -> renderMemberParsers(shape))
+                .closeBlock("end")
+                .write("Errors::$L.new(data: data, **kwargs)",
+                        context.symbolProvider().toSymbol(shape).getName())
                 .closeBlock("end");
     }
 

hearth/spec/hearth/event_stream/handler_base_spec.rb

@@ -31,6 +31,7 @@ module EventStream
         Class.new(HandlerBase) do
           def parse_event(_, _); end
           def parse_error_event(_); end
+          def parse_exception_event(_, _); end
         end.new
       end
 
@@ -87,9 +88,9 @@ def parse_error_event(_); end
           let(:exception_class) { Class.new }
           let(:exception_event) { exception_class.new }
 
-          it 'calls registered MyException handlers' do
-            subject.send(:on, exception_class, handler1)
-            expect(subject).to receive(:parse_event)
+          it 'calls registered error handlers' do
+            subject.on_error(&handler1)
+            expect(subject).to receive(:parse_exception_event)
               .with(exception_type, message)
               .and_return(exception_event)
             expect(handler1).to receive(:call).with(exception_event)

hearth/spec/hearth/http/error_inspector_spec.rb

@@ -12,8 +12,7 @@ module HTTP
       let(:message) { 'message' }
 
       let(:error) do
-        Hearth::HTTP::ApiError.new(
-          http_resp: http_resp,
+        Hearth::ApiError.new(
           error_code: 'error_code',
           metadata: {},
           message: message

hearth/spec/hearth/http/error_parser_spec.rb

@@ -7,7 +7,7 @@ def self.error_code(_http_resp)
         nil
       end
 
-      class ApiError < Hearth::HTTP::ApiError; end
+      class ApiError < Hearth::ApiError; end
 
       class ApiRedirectError < ApiError
         def initialize(location:, **kwargs)
@@ -23,12 +23,20 @@ class ApiClientError < ApiError; end
       class ApiServerError < ApiError; end
 
       class ModeledError < ApiClientError; end
+
+      module Parsers
+        class ModeledError
+          def self.parse(_http_resp, **_kwargs)
+            TestErrors::ModeledError.new(error_code: 'ModeledError')
+          end
+        end
+      end
     end
 
     describe ErrorParser do
       let(:error_module) { TestErrors }
       let(:success_status) { 200 }
-      let(:errors) { [TestErrors::ModeledError] }
+      let(:error_parsers) { [TestErrors::Parsers::ModeledError] }
 
       let(:resp_status) { 200 }
       let(:fields) { Fields.new }
@@ -39,7 +47,7 @@ class ModeledError < ApiClientError; end
         Hearth::HTTP::ErrorParser.new(
           error_module: error_module,
           success_status: success_status,
-          errors: errors
+          error_parsers: error_parsers
         )
       end