Stub config prototype (#3204)

Author: mullermp

Gemfile

@@ -42,6 +42,7 @@ group :build do
 end
 
 group :development do
+  gem 'byebug', platforms: :ruby
   gem 'rubocop', '1.28.0'
 end
 

build_tools/aws-sdk-code-generator/spec/interfaces/client/bearer_authorization_spec.rb

@@ -25,6 +25,7 @@
       it 'sets the Authorization header' do
         client.stub_responses(:bearer_auth, -> (context) {
           expect(context.http_request.headers['Authorization']).to eq('Bearer token')
+          {}
         })
         client.bearer_auth
       end
@@ -34,6 +35,7 @@
       it 'sets the Authorization header' do
         client.stub_responses(:sigv_4_auth, -> (context) {
           expect(context.http_request.headers['Authorization']).to include('AWS4-HMAC-SHA256')
+          {}
         })
         client.sigv_4_auth
       end
@@ -43,6 +45,7 @@
       it 'does not set the Authorization header' do
         client.stub_responses(:no_auth, -> (context) {
           expect(context.http_request.headers.key?('Authorization')).to be_falsey
+          {}
         })
         client.no_auth
       end

gems/aws-sdk-core/CHANGELOG.md

@@ -1,6 +1,8 @@
 Unreleased Changes
 ------------------
 
+* Issue - Convert stubs at request time.
+
 3.220.0 (2025-03-04)
 ------------------
 

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

@@ -15,27 +15,11 @@ module ClientStubs
 
     # @api private
     def setup_stubbing
-      @stubs = {}
-      @stub_mutex = Mutex.new
       if Hash === @config.stub_responses
         @config.stub_responses.each do |operation_name, stubs|
           apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
         end
       end
-
-      # When a client is stubbed allow the user to access the requests made
-      requests = @api_requests = []
-      requests_mutex = @requests_mutex = Mutex.new
-      self.handle do |context|
-        requests_mutex.synchronize do
-          requests << {
-            operation_name: context.operation_name,
-            params: context.params,
-            context: context
-          }
-        end
-        @handler.call(context)
-      end
     end
 
     # Configures what data / errors should be returned from the named operation
@@ -175,7 +159,7 @@ def setup_stubbing
     #   on a client that has not enabled response stubbing via
     #   `:stub_responses => true`.
     def stub_responses(operation_name, *stubs)
-      if config.stub_responses
+      if @config.stub_responses
         apply_stubs(operation_name, stubs.flatten)
       else
         msg = 'stubbing is not enabled; enable stubbing in the constructor '\
@@ -194,12 +178,12 @@ def stub_responses(operation_name, *stubs)
     # @raise [NotImplementedError] Raises `NotImplementedError` when the client
     #   is not stubbed.
     def api_requests(options = {})
-      if config.stub_responses
-        @requests_mutex.synchronize do
+      if @config.stub_responses
+        @config.api_requests_mutex.synchronize do
           if options[:exclude_presign]
-            @api_requests.reject {|req| req[:context][:presigned_url] }
+            @config.api_requests.reject {|req| req[:context][:presigned_url] }
           else
-            @api_requests
+            @config.api_requests
           end
         end
       else
@@ -228,54 +212,44 @@ def api_requests(options = {})
     # @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(config.api.operation(operation_name)).stub(data)
+      Stubbing::StubData.new(@config.api.operation(operation_name)).stub(data)
     end
 
     # @api private
     def next_stub(context)
       operation_name = context.operation_name.to_sym
-      stub = @stub_mutex.synchronize do
-        stubs = @stubs[operation_name] || []
+      stub = @config.stubs_mutex.synchronize do
+        stubs = @config.stubs[operation_name] || []
         case stubs.length
-        when 0 then default_stub(operation_name)
+        when 0 then stub_data(operation_name)
         when 1 then stubs.first
         else stubs.shift
         end
       end
-      Proc === stub ? convert_stub(operation_name, stub.call(context)) : stub
+      stub = convert_stub(operation_name, stub, context)
+      stub[:mutex] = Mutex.new
+      stub
     end
 
     private
 
-    def default_stub(operation_name)
-      stub = stub_data(operation_name)
-      http_response_stub(operation_name, stub)
+    def apply_stubs(operation_name, stubs)
+      @config.stubs_mutex.synchronize do
+        @config.stubs[operation_name.to_sym] = stubs
+      end
     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|
-          convert_stub(operation_name, stub)
-        end
-      end
-    end
-
-    def convert_stub(operation_name, stub)
-      stub = case stub
-      when Proc then stub
+    def convert_stub(operation_name, stub, context)
+      case stub
+      when Proc then convert_stub(operation_name, stub.call(context), context)
       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
-      if Hash === stub
-        stub[:mutex] = Mutex.new
+      else http_response_stub(operation_name, stub)
       end
-      stub
     end
 
     def service_error_stub(error_code)
@@ -299,14 +273,14 @@ def hash_to_http_resp(data)
     end
 
     def data_to_http_resp(operation_name, data)
-      api = config.api
+      api = @config.api
       operation = api.operation(operation_name)
       ParamValidator.new(operation.output, input: false).validate!(data)
       protocol_helper.stub_data(api, operation, data)
     end
 
     def protocol_helper
-      case config.api.metadata['protocol']
+      case @config.api.metadata['protocol']
       when 'json'               then Stubbing::Protocols::Json
       when 'rest-json'          then Stubbing::Protocols::RestJson
       when 'rest-xml'           then Stubbing::Protocols::RestXml

gems/aws-sdk-core/lib/aws-sdk-core/plugins/stub_responses.rb

@@ -29,8 +29,16 @@ class StubResponses < Seahorse::Client::Plugin
         end
       end
 
+      option(:stubs) { {} }
+      option(:stubs_mutex) { Mutex.new }
+      option(:api_requests) { [] }
+      option(:api_requests_mutex) { Mutex.new }
+
       def add_handlers(handlers, config)
-        handlers.add(Handler, step: :send) if config.stub_responses
+        return unless config.stub_responses
+
+        handlers.add(ApiRequestsHandler)
+        handlers.add(StubbingHandler, step: :send)
       end
 
       def after_initialize(client)
@@ -46,8 +54,20 @@ def after_initialize(client)
         end
       end
 
-      class Handler < Seahorse::Client::Handler
+      class ApiRequestsHandler < Seahorse::Client::Handler
+        def call(context)
+          context.config.api_requests_mutex.synchronize do
+            context.config.api_requests << {
+              operation_name: context.operation_name,
+              params: context.params,
+              context: context
+            }
+          end
+          @handler.call(context)
+        end
+      end
 
+      class StubbingHandler < Seahorse::Client::Handler
         def call(context)
           span_wrapper(context) do
             stub_responses(context)
@@ -57,14 +77,10 @@ def call(context)
         private
 
         def stub_responses(context)
-          stub = context.client.next_stub(context)
           resp = Seahorse::Client::Response.new(context: context)
           async_mode = context.client.is_a? Seahorse::Client::AsyncBase
-          if Hash === stub && stub[:mutex]
-            stub[:mutex].synchronize { apply_stub(stub, resp, async_mode) }
-          else
-            apply_stub(stub, resp, async_mode)
-          end
+          stub = context.client.next_stub(context)
+          stub[:mutex].synchronize { apply_stub(stub, resp, async_mode) }
 
           if async_mode
             Seahorse::Client::AsyncResponse.new(

gems/aws-sdk-core/spec/aws/plugins/checksum_algorithm_spec.rb

@@ -255,7 +255,7 @@ module Plugins
               test_case['expectTrailers'].each do |key, value|
                 expect(read_body).to include("#{key}:#{value}")
               end
-              context
+              {}
             end)
 
             client.http_checksum_streaming_operation(**options)

gems/aws-sdk-core/spec/aws/plugins/request_compression_spec.rb

@@ -171,6 +171,7 @@ def expect_uncompressed_body(resp, body)
             large_body.rewind
             uncompressed = Zlib::GzipReader.new(body)
             expect(uncompressed.read).to eq(large_body.read)
+            {}
           end)
           client.operation_streaming(body: large_body)
         end
@@ -185,6 +186,7 @@ def expect_uncompressed_body(resp, body)
             body.rewind
             uncompressed = Zlib::GzipReader.new(body)
             expect(uncompressed.read).to eq(small_body)
+            {}
           end)
           client.operation_streaming(body: small_body)
         end

gems/aws-sdk-dynamodb/spec/client_spec.rb

@@ -161,14 +161,10 @@ module DynamoDB
 
         it 'observes the :simple_attributes configuration option' do
           client = Client.new(stub_responses: true, simple_attributes: false)
+          client.stub_responses(:get_item, item: { 'id' => 'value' })
           expect {
-            client.stub_responses(:get_item, item: { 'id' => 'value' })
+            client.get_item(table_name: 'table', key: { 'id' => { s: 'value' }})
           }.to raise_error(ArgumentError)
-
-          client.stub_responses(:get_item, item: { 'id' => { s: 'value' }})
-          resp = client.get_item(table_name: 'table', key: { 'id' => { s: 'value' }})
-          expect(resp.item.keys).to eq(['id'])
-          expect(resp.item['id'].s).to eq('value')
         end
 
       end