Generate specs for protocol tests

Rakefile

@@ -55,14 +55,62 @@ namespace :smithy do
     plans.each { |plan| SpecHelper.cleanup_gem(plan) }
   end
 
-  task 'spec' => %w[spec:unit spec:endpoints]
+  task 'spec:protocols', [:rbs_test] do |_t, args|
+    require_relative 'gems/smithy/spec/spec_helper'
+
+    spec_paths = []
+    include_paths = []
+    plans = []
+    rbs_targets = %w[Smithy Smithy::* Smithy::Client]
+    sig_paths = ['gems/smithy-client/sig']
+    Dir.glob('gems/smithy/spec/fixtures/protocol_tests/*/model.json') do |model_path|
+      test_name = model_path.split('/')[-2]
+      test_module = test_name.gsub('-', '').camelize
+      plan = SpecHelper.generate_gem(test_module, :client, fixture: "protocol_tests/#{test_name}")
+      plans << plan
+      tmpdir = plan.destination_root
+      spec_paths << "#{tmpdir}/spec"
+      include_paths << "#{tmpdir}/lib"
+      include_paths << "#{tmpdir}/spec"
+      sig_paths << "#{tmpdir}/sig"
+      rbs_targets += [test_module, "#{test_module}::*"]
+    end
+    specs = spec_paths.join(' ')
+    includes = include_paths.map { |p| "-I #{p}" }.join(' ')
+
+    env =
+      if args[:rbs_test]
+        {
+          'RUBYOPT' => '-r bundler/setup -r rbs/test/setup',
+          'RBS_TEST_RAISE' => 'true',
+          'RBS_TEST_LOGLEVEL' => 'error',
+          'RBS_TEST_OPT' => sig_paths.map { |p| "-I #{p}" }.join(' '),
+          'RBS_TEST_TARGET' => "\"#{rbs_targets.join(',')}\"",
+          'RBS_TEST_DOUBLE_SUITE' => 'rspec'
+        }
+      else
+        {}
+      end
+
+    sh(env, "bundle exec rspec #{specs} #{includes}")
+  ensure
+    plans.each { |plan| SpecHelper.cleanup_gem(plan) }
+  end
+
+  task 'spec' => %w[spec:unit spec:endpoints spec:protocols]
 
   desc 'Convert all fixture smithy models to JSON AST representation.'
   task 'sync-fixtures' do
     Dir.glob('gems/smithy/spec/fixtures/**/model.smithy') do |model_path|
       out_path = model_path.sub('.smithy', '.json')
       sh("smithy ast --aut #{model_path} > #{out_path}")
     end
+
+    Dir.glob('gems/smithy/spec/fixtures/protocol_tests/**/smithy-build.json') do |smithy_build_path|
+      Dir.chdir(File.dirname(smithy_build_path)) do
+        sh('smithy ast --flatten > model.json')
+      end
+    end
   end
 
   desc 'Validate that all fixtures JSON models are up to date.'
@@ -95,8 +143,13 @@ namespace :smithy do
     task('smithy:spec:endpoints').invoke('rbs_test')
   end
 
+  desc 'Run RBS spy tests for all generated protocol test specs.'
+  task 'rbs:protocol_tests' do
+    task('smithy:spec:protocols').invoke('rbs_test')
+  end
+
   desc 'Run RBS spy tests for unit tests and generated endpoint provider specs.'
-  task 'rbs' => %w[rbs:unit rbs:endpoints]
+  task 'rbs' => %w[rbs:unit rbs:endpoints rbs:protocol_tests]
 end
 
 namespace 'smithy-client' do

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

@@ -12,6 +12,7 @@
 require_relative 'smithy-client/handler_context'
 require_relative 'smithy-client/handler_list'
 require_relative 'smithy-client/handler_list_entry'
+require_relative 'smithy-client/handlers'
 require_relative 'smithy-client/managed_file'
 require_relative 'smithy-client/networking_error'
 require_relative 'smithy-client/plugin'
@@ -40,7 +41,10 @@
 # codecs
 
 require_relative 'smithy-client/cbor'
-require_relative 'smithy-client/codecs/cbor'
+require_relative 'smithy-client/codecs'
+
+# protocols
+require_relative 'smithy-client/protocols'
 
 module Smithy
   # Base module for a generated Smithy gem.

gems/smithy-client/lib/smithy-client/cbor/value_matcher.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+def expected_nan?(expected)
+  expected == 'NaN' || expected.nan?
+end
+
+def expected_infinite?(expected)
+  expected == 'Infinity' || expected == '-Infinity' || expected.infinite?
+end
+
+# Provides an rspec matcher for CBOR encoded values
+# rubocop:disable Metrics/BlockLength
+RSpec::Matchers.define :match_cbor do |expected|
+  match do |actual|
+    # identical values don't need more comparison
+    return true if actual == expected
+
+    expect(actual.class).to eq(expected.class)
+
+    def match_hash(actual, expected)
+      expected.each do |key, value|
+        expect(actual).to include(key)
+        match_value(actual[key], value)
+      end
+
+      actual.each_key do |key|
+        expect(expected).to include(key)
+      end
+    end
+
+    def match_array(actual, expected)
+      actual.each_with_index do |value, index|
+        match_value(value, expected[index])
+      end
+    end
+
+    def match_float(actual, expected)
+      return if actual.nan? && expected_nan?(expected)
+      return if actual.infinite? && expected_infinite?(expected)
+
+      expect(actual).to be_within(0.0001).of(expected)
+    end
+
+    def match_value(actual, expected)
+      case actual
+      when Hash
+        match_hash(actual, expected)
+      when Array
+        match_array(actual, expected)
+      when Float
+        match_float(actual, expected)
+      when Time
+        expect(actual.utc.iso8601).to eq(expected.utc.iso8601)
+      else
+        expect(actual).to eq(expected)
+      end
+    end
+
+    match_value(actual, expected)
+  end
+
+  diffable
+end
+# rubocop:enable Metrics/BlockLength

gems/smithy-client/lib/smithy-client/handlers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # A collection of generic handlers that are used by Smithy Clients.
+    # @api private
+    module Handlers
+      # Generic build handler to build request based on protocol
+      class Build < Handler
+        def call(context)
+          context.config.protocol.build(context)
+          @handler.call(context)
+        end
+      end
+
+      # Generic parse handler to parse response based on protocol
+      class Parse < Handler
+        def call(context)
+          resp = @handler.call(context)
+          context.config.protocol.parse(context)
+          resp
+        end
+      end
+
+      # Generic error handler to parse error based on protocol
+      class Error < Handler
+        def call(context)
+          @handler.call(context).on(300..599) do |response|
+            context.config.protocol.error(context, response)
+          end
+        end
+      end
+    end
+  end
+end

gems/smithy-client/lib/smithy-client/protocols.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'protocols/rpc_v2'
+
+module Smithy
+  module Client
+    # In Smithy, a protocol is a named set of rules that defines the
+    # syntax and semantics of how a client and server communicate. To
+    # use a {Smithy::Client}, a protocol is required to be set on
+    # {Configuration}.
+    #
+    # We currently support the following protocols:
+    #
+    # - {RPCv2}, a RPC-based protocol over HTTP that sends requests
+    # and responses with CBOR payloads.
+    #
+    # You could also create a custom protocol to pass into the client
+    # configuration. The given protocol must provide the following
+    # functionalities:
+    #
+    #  - `build` - builds the request
+    #  - `parse` - parse the response
+    #  - `error` - extracts the error from response
+    #
+    # See {RPCv2} as an example implementation.
+    module Protocols; end
+  end
+end

gems/smithy-client/lib/smithy-client/protocols/rpc_v2.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Protocols
+      # A RPC-based protocol over HTTP that sends requests
+      # and responses with CBOR payloads.
+      #
+      # TODO: Refactor methods to handle eventstreams
+      class RPCv2
+        SHAPE_ID = 'smithy.protocols#rpcv2Cbor'
+
+        def initialize(options = {})
+          @query_compatible = options[:query_compatible]
+        end
+
+        # @api private
+        def build(context)
+          codec = Client::Codecs::CBOR.new(setting(context))
+          context.request.body = codec.serialize(context.params, context.operation.input)
+          context.request.http_method = 'POST'
+          apply_headers(context)
+          build_url(context)
+        end
+
+        # @api private
+        def parse(context)
+          output_shape = context.operation.output
+          codec = Client::Codecs::CBOR.new(setting(context))
+          codec.deserialize(context.response.body.read, output_shape, output_shape.type.new)
+        end
+
+        # @api private
+        # TODO: To implement after error handling
+        def error(_context, _response); end
+
+        private
+
+        def apply_headers(context)
+          context.request.headers['X-Amzn-Query-Mode'] = 'true' if query_compatible?(context)
+          context.request.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
+          apple_content_type(context)
+          apply_accept_header(context)
+          # TODO: Implement Content-Length Plugin/Handler - maybe?
+          context.request.headers['Content-Length'] = context.request.body.size
+        end
+
+        def apply_accept_header(context)
+          # TODO: Needs an update when streaming is handled
+          context.request.headers['Accept'] = 'application/cbor'
+        end
+
+        def apple_content_type(context)
+          return if context.operation.input == Shapes::Prelude::Unit
+
+          # TODO: Needs an update when streaming is handled
+          context.request.headers['Content-Type'] = 'application/cbor'
+        end
+
+        def build_url(context)
+          base = context.request.endpoint
+          base.path +=
+            "/service/#{context.config.schema.service.name}/operation/#{context.operation.name}"
+        end
+
+        def setting(context)
+          {}.tap do |h|
+            h[:query_compatible] = true if query_compatible?(context)
+          end
+        end
+
+        def query_compatible?(context)
+          @query_compatible ||
+            context.config.schema.service.traits.one? { |k, _v| k == 'aws.protocols#awsQuery' }
+        end
+      end
+    end
+  end
+end

gems/smithy-client/lib/smithy-client/shapes.rb

@@ -22,23 +22,31 @@ def initialize(options = {})
       class ServiceShape < Shape
         def initialize(options = {})
           super
+          @name = options[:name]
           @version = options[:version]
         end
 
         # @return [String, nil]
         attr_accessor :version
+
+        # @return [String, nil]
+        attr_accessor :name
       end
 
       # Represents an Operation shape.
       class OperationShape < Shape
         def initialize(options = {})
           super
+          @name = options[:name]
           @input = options[:input]
           @output = options[:output]
           @errors = options[:errors] || []
           yield self if block_given?
         end
 
+        # @return [String, nil]
+        attr_accessor :name
+
         # @return [StructureShape, nil]
         attr_accessor :input
 

gems/smithy-client/sig/interfaces.rbs

@@ -10,5 +10,11 @@ module Smithy
     end
 
     type endpoint_url = String | URI::HTTP | URI::HTTPS
+
+    interface _Protocol
+      def build: (HandlerContext context) -> void
+      def parse: (HandlerContext context) -> void
+      def error: (HandlerContext context, HTTP::Response response) -> void
+    end
   end
 end

gems/smithy-client/sig/smithy-client/protocols/rpc_v2.rbs

@@ -0,0 +1,11 @@
+module Smithy
+  module Client
+    module Protocols
+      # A RPC-based protocol over HTTP that sends requests
+      # and responses with CBOR payloads.
+      class RPCv2
+        def initialize: (?::Hash[untyped, untyped] options) -> void
+      end
+    end
+  end
+end

gems/smithy-client/sig/smithy-client/shapes.rbs

@@ -9,10 +9,13 @@ module Smithy
       end
 
       class ServiceShape < Shape
+
+        attr_accessor name: String?
         attr_accessor version: String?
       end
 
       class OperationShape < Shape
+        attr_accessor name: String?
         attr_accessor input: StructureShape?
         attr_accessor output: StructureShape?
         attr_accessor errors: Array[StructureShape]