mockserver-client 7.0.0 → 7.1.0

data/lib/mockserver/client.rb

@@ -260,13 +260,14 @@ module MockServer
       response_body && !response_body.empty? ? JSON.parse(response_body) : {}
     end
 
-    # Verify that a request was received.
-    # @param request [HttpRequest]
+    # Verify that a request (and optionally a response) was received.
+    # @param request [HttpRequest, nil]
     # @param times [VerificationTimes, nil]
+    # @param response [HttpResponse, nil]
     # @return [nil]
     # @raise [VerificationError] if verification fails (HTTP 406)
-    def verify(request, times: nil)
-      verification = Verification.new(http_request: request, times: times)
+    def verify(request = nil, times: nil, response: nil)
+      verification = Verification.new(http_request: request, http_response: response, times: times)
       body = JSON.generate(verification.to_h)
       status, response_body = do_request('PUT', '/mockserver/verify', body)
       if status == 406
@@ -282,10 +283,14 @@ module MockServer
 
     # Verify that requests were received in sequence.
     # @param requests [Array<HttpRequest>]
+    # @param responses [Array<HttpResponse>, nil] index-aligned response matchers
     # @return [nil]
     # @raise [VerificationError] if verification fails (HTTP 406)
-    def verify_sequence(*requests)
-      verification = VerificationSequence.new(http_requests: requests.to_a)
+    def verify_sequence(*requests, responses: nil)
+      verification = VerificationSequence.new(
+        http_requests: requests.empty? ? nil : requests.to_a,
+        http_responses: responses
+      )
       body = JSON.generate(verification.to_h)
       status, response_body = request('PUT', '/mockserver/verifySequence', body)
       if status == 406
@@ -476,6 +481,120 @@ module MockServer
       ForwardChainExpectation.new(self, expectation)
     end
 
+    # -------------------------------------------------------------------
+    # Breakpoint matcher management
+    # -------------------------------------------------------------------
+
+    # Register a breakpoint matcher with callback handlers.
+    # The callback WebSocket is opened lazily and reused.
+    #
+    # @param matcher [HttpRequest] the request definition to match
+    # @param phases [Array<String>] e.g. ["REQUEST", "RESPONSE"]
+    # @param request_handler [Proc, nil] handler for REQUEST phase
+    # @param response_handler [Proc, nil] handler for RESPONSE phase
+    # @param stream_frame_handler [Proc, nil] handler for streaming phases
+    # @return [String] the server-assigned breakpoint matcher id
+    def add_breakpoint(matcher, phases,
+                       request_handler: nil, response_handler: nil,
+                       stream_frame_handler: nil)
+      raise ArgumentError, 'add_breakpoint requires a non-nil matcher' if matcher.nil?
+      raise ArgumentError, 'add_breakpoint requires a non-empty phases array' if phases.nil? || phases.empty?
+
+      ws_client = ensure_breakpoint_websocket
+      client_id = ws_client.client_id
+
+      body = JSON.generate({
+        'httpRequest' => matcher.to_h,
+        'phases' => phases,
+        'clientId' => client_id
+      })
+      status, response_body = request('PUT', '/mockserver/breakpoint/matcher', body)
+      if status >= 400
+        raise Error, "Failed to register breakpoint matcher (status=#{status}): #{response_body}"
+      end
+
+      parsed = response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+      breakpoint_id = parsed['id']
+      raise Error, 'Server did not return a breakpoint id' unless breakpoint_id
+
+      # Install per-breakpoint-id handlers
+      ws_client.set_breakpoint_request_handler(breakpoint_id, request_handler) if request_handler
+      ws_client.set_breakpoint_response_handler(breakpoint_id, response_handler) if response_handler
+      ws_client.set_breakpoint_stream_frame_handler(breakpoint_id, stream_frame_handler) if stream_frame_handler
+
+      breakpoint_id
+    end
+
+    # Convenience: register a REQUEST-only breakpoint.
+    # @param matcher [HttpRequest]
+    # @param request_handler [Proc]
+    # @return [String]
+    def add_request_breakpoint(matcher, request_handler)
+      add_breakpoint(matcher, ['REQUEST'], request_handler: request_handler)
+    end
+
+    # Convenience: register a REQUEST+RESPONSE breakpoint.
+    # @param matcher [HttpRequest]
+    # @param request_handler [Proc]
+    # @param response_handler [Proc]
+    # @return [String]
+    def add_request_and_response_breakpoint(matcher, request_handler, response_handler)
+      add_breakpoint(matcher, %w[REQUEST RESPONSE],
+                     request_handler: request_handler,
+                     response_handler: response_handler)
+    end
+
+    # List all registered breakpoint matchers.
+    # @return [Hash] e.g. {"matchers" => [{...}, ...]}
+    def list_breakpoint_matchers
+      status, response_body = request('GET', '/mockserver/breakpoint/matchers')
+      if status >= 400
+        raise Error, "Failed to list breakpoint matchers (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Remove a breakpoint matcher by id.
+    # @param breakpoint_id [String]
+    # @return [Hash]
+    def remove_breakpoint_matcher(breakpoint_id)
+      raise ArgumentError, 'remove_breakpoint_matcher requires a non-empty id' if breakpoint_id.nil? || breakpoint_id.empty?
+
+      body = JSON.generate({ 'id' => breakpoint_id })
+      status, response_body = request('PUT', '/mockserver/breakpoint/matcher/remove', body)
+      if status >= 400
+        raise Error, "Failed to remove breakpoint matcher (status=#{status}): #{response_body}"
+      end
+
+      # Remove client-side handlers
+      @websocket_mutex.synchronize do
+        @websocket_clients.each do |ws|
+          ws.remove_breakpoint_handlers(breakpoint_id) if ws.respond_to?(:remove_breakpoint_handlers)
+        end
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Clear all registered breakpoint matchers.
+    # @return [Hash]
+    def clear_breakpoint_matchers
+      status, response_body = request('PUT', '/mockserver/breakpoint/matcher/clear')
+      if status >= 400
+        raise Error, "Failed to clear breakpoint matchers (status=#{status}): #{response_body}"
+      end
+
+      # Clear client-side handlers
+      @websocket_mutex.synchronize do
+        @websocket_clients.each do |ws|
+          ws.clear_breakpoint_handlers if ws.respond_to?(:clear_breakpoint_handlers)
+        end
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
     # -------------------------------------------------------------------
     # Callback methods
     # -------------------------------------------------------------------
@@ -530,6 +649,32 @@ module MockServer
 
     private
 
+    # @api private
+    # Ensure a callback WS is connected for breakpoint use, returning it.
+    def ensure_breakpoint_websocket
+      # Hold the mutex for the whole check-create-append so two concurrent
+      # add_breakpoint calls cannot both create a breakpoint WS (TOCTOU).
+      # Breakpoint WS creation is rare, so blocking on connect under the lock
+      # is acceptable.
+      @websocket_mutex.synchronize do
+        existing = @websocket_clients.find { |ws| ws.instance_variable_get(:@is_breakpoint_ws) }
+        return existing if existing
+
+        ws_client = WebSocketClient.new
+        ws_client.connect(
+          @host, @port,
+          context_path: @context_path,
+          secure: @secure,
+          ca_cert_path: @ca_cert_path,
+          tls_verify: @tls_verify
+        )
+        ws_client.instance_variable_set(:@is_breakpoint_ws, true)
+        ws_client.listen
+        @websocket_clients << ws_client
+        ws_client
+      end
+    end
+
     # @api private
     def register_websocket_callback(callback_type, callback_fn, forward_response_fn = nil)
       ws_client = WebSocketClient.new

data/lib/mockserver/models.rb

@@ -44,6 +44,8 @@ module MockServer
     'http_sse_response'              => 'httpSseResponse',
     'http_websocket_response'        => 'httpWebSocketResponse',
     'template_type'                  => 'templateType',
+    'template_file'                  => 'templateFile',
+    'file_path'                      => 'filePath',
     'base64_bytes'                   => 'base64Bytes',
     'not_body'                       => 'not',
     'content_type'                   => 'contentType',
@@ -81,7 +83,8 @@ module MockServer
     'degradation_ramp_millis'        => 'degradationRampMillis',
     'http_class_callback'            => 'httpClassCallback',
     'http_object_callback'           => 'httpObjectCallback',
-    'failure_policy'                 => 'failurePolicy'
+    'failure_policy'                 => 'failurePolicy',
+    'http_responses'                 => 'httpResponses'
   }.freeze
 
   REVERSE_FIELD_MAP = FIELD_MAP.invert.freeze
@@ -89,7 +92,7 @@ module MockServer
   # Known Body type strings used to distinguish Body objects from plain hashes
   # during deserialization.
   BODY_TYPES = Set.new(%w[
-    STRING JSON REGEX XML BINARY JSON_SCHEMA JSON_PATH XPATH XML_SCHEMA JSON_RPC GRAPHQL
+    STRING JSON REGEX XML BINARY JSON_SCHEMA JSON_PATH XPATH XML_SCHEMA JSON_RPC GRAPHQL FILE
   ]).freeze
 
   # -------------------------------------------------------------------
@@ -359,9 +362,11 @@ module MockServer
   end
 
   class Body
-    attr_accessor :type, :string, :json, :base64_bytes, :not_body, :content_type, :charset
+    attr_accessor :type, :string, :json, :base64_bytes, :not_body, :content_type, :charset,
+                  :file_path, :template_type
 
-    def initialize(type: nil, string: nil, json: nil, base64_bytes: nil, not_body: nil, content_type: nil, charset: nil)
+    def initialize(type: nil, string: nil, json: nil, base64_bytes: nil, not_body: nil,
+                   content_type: nil, charset: nil, file_path: nil, template_type: nil)
       @type = type
       @string = string
       @json = json
@@ -369,17 +374,21 @@ module MockServer
       @not_body = not_body
       @content_type = content_type
       @charset = charset
+      @file_path = file_path
+      @template_type = template_type
     end
 
     def to_h
       result = {}
-      result['type']        = @type        unless @type.nil?
-      result['string']      = @string      unless @string.nil?
-      result['json']        = @json        unless @json.nil?
-      result['base64Bytes'] = @base64_bytes unless @base64_bytes.nil?
-      result['not']         = @not_body    unless @not_body.nil?
-      result['contentType'] = @content_type unless @content_type.nil?
-      result['charset']     = @charset     unless @charset.nil?
+      result['type']         = @type          unless @type.nil?
+      result['string']       = @string        unless @string.nil?
+      result['json']         = @json          unless @json.nil?
+      result['base64Bytes']  = @base64_bytes  unless @base64_bytes.nil?
+      result['not']          = @not_body      unless @not_body.nil?
+      result['contentType']  = @content_type  unless @content_type.nil?
+      result['charset']      = @charset       unless @charset.nil?
+      result['filePath']     = @file_path     unless @file_path.nil?
+      result['templateType'] = @template_type unless @template_type.nil?
       result
     end
 
@@ -387,13 +396,15 @@ module MockServer
       return nil if data.nil?
 
       new(
-        type:         data['type'],
-        string:       data['string'],
-        json:         data['json'],
-        base64_bytes: data['base64Bytes'],
-        not_body:     data['not'],
-        content_type: data['contentType'],
-        charset:      data['charset']
+        type:          data['type'],
+        string:        data['string'],
+        json:          data['json'],
+        base64_bytes:  data['base64Bytes'],
+        not_body:      data['not'],
+        content_type:  data['contentType'],
+        charset:       data['charset'],
+        file_path:     data['filePath'],
+        template_type: data['templateType']
       )
     end
 
@@ -417,6 +428,10 @@ module MockServer
       new(type: 'XML', string: value)
     end
 
+    def self.file(file_path, content_type: nil, template_type: nil)
+      new(type: 'FILE', file_path: file_path, content_type: content_type, template_type: template_type)
+    end
+
     def self.json_rpc(method_name, params_schema: nil)
       JsonRpcBody.new(method_name: method_name, params_schema: params_schema)
     end
@@ -424,6 +439,11 @@ module MockServer
     def self.graphql(query, operation_name: nil, variables_schema: nil)
       GraphQLBody.new(query: query, operation_name: operation_name, variables_schema: variables_schema)
     end
+
+    def with_template_type(template_type)
+      @template_type = template_type
+      self
+    end
   end
 
   class JsonRpcBody
@@ -809,11 +829,12 @@ module MockServer
   end
 
   class HttpTemplate
-    attr_accessor :template_type, :template, :delay, :primary
+    attr_accessor :template_type, :template, :template_file, :delay, :primary
 
-    def initialize(template_type: 'JAVASCRIPT', template: nil, delay: nil, primary: nil)
+    def initialize(template_type: 'JAVASCRIPT', template: nil, template_file: nil, delay: nil, primary: nil)
       @template_type = template_type
       @template = template
+      @template_file = template_file
       @delay = delay
       @primary = primary
     end
@@ -822,6 +843,7 @@ module MockServer
       MockServer.strip_none({
         'templateType' => @template_type,
         'template'     => @template,
+        'templateFile' => @template_file,
         'delay'        => @delay&.to_h,
         'primary'      => @primary
       })
@@ -833,13 +855,19 @@ module MockServer
       new(
         template_type: data.fetch('templateType', 'JAVASCRIPT'),
         template:      data['template'],
+        template_file: data['templateFile'],
         delay:         Delay.from_hash(data['delay']),
         primary:       data['primary']
       )
     end
 
-    def self.template(template_type, template = nil)
-      new(template_type: template_type, template: template)
+    def self.template(template_type, template = nil, template_file: nil)
+      new(template_type: template_type, template: template, template_file: template_file)
+    end
+
+    def with_template_file(template_file)
+      @template_file = template_file
+      self
     end
   end
 
@@ -1910,12 +1938,13 @@ module MockServer
   end
 
   class Verification
-    attr_accessor :http_request, :expectation_id, :times,
+    attr_accessor :http_request, :http_response, :expectation_id, :times,
                   :maximum_number_of_request_to_return_in_verification_failure
 
-    def initialize(http_request: nil, expectation_id: nil, times: nil,
+    def initialize(http_request: nil, http_response: nil, expectation_id: nil, times: nil,
                    maximum_number_of_request_to_return_in_verification_failure: nil)
       @http_request = http_request
+      @http_response = http_response
       @expectation_id = expectation_id
       @times = times
       @maximum_number_of_request_to_return_in_verification_failure = maximum_number_of_request_to_return_in_verification_failure
@@ -1924,6 +1953,7 @@ module MockServer
     def to_h
       MockServer.strip_none({
         'httpRequest'    => @http_request&.to_h,
+        'httpResponse'   => @http_response&.to_h,
         'expectationId'  => @expectation_id&.to_h,
         'times'          => @times&.to_h,
         'maximumNumberOfRequestToReturnInVerificationFailure' => @maximum_number_of_request_to_return_in_verification_failure
@@ -1935,6 +1965,7 @@ module MockServer
 
       new(
         http_request:    HttpRequest.from_hash(data['httpRequest']),
+        http_response:   HttpResponse.from_hash(data['httpResponse']),
         expectation_id:  ExpectationId.from_hash(data['expectationId']),
         times:           VerificationTimes.from_hash(data['times']),
         maximum_number_of_request_to_return_in_verification_failure: data['maximumNumberOfRequestToReturnInVerificationFailure']
@@ -1943,16 +1974,18 @@ module MockServer
   end
 
   class VerificationSequence
-    attr_accessor :http_requests, :expectation_ids
+    attr_accessor :http_requests, :http_responses, :expectation_ids
 
-    def initialize(http_requests: nil, expectation_ids: nil)
+    def initialize(http_requests: nil, http_responses: nil, expectation_ids: nil)
       @http_requests = http_requests
+      @http_responses = http_responses
       @expectation_ids = expectation_ids
     end
 
     def to_h
       MockServer.strip_none({
         'httpRequests'   => @http_requests&.map(&:to_h),
+        'httpResponses'  => @http_responses&.map(&:to_h),
         'expectationIds' => @expectation_ids&.map(&:to_h)
       })
     end
@@ -1961,9 +1994,11 @@ module MockServer
       return nil if data.nil?
 
       http_requests_data = data['httpRequests']
+      http_responses_data = data['httpResponses']
       expectation_ids_data = data['expectationIds']
       new(
-        http_requests:  http_requests_data&.map { |r| HttpRequest.from_hash(r) },
+        http_requests:   http_requests_data&.map { |r| HttpRequest.from_hash(r) },
+        http_responses:  http_responses_data&.map { |r| HttpResponse.from_hash(r) },
         expectation_ids: expectation_ids_data&.map { |e| ExpectationId.from_hash(e) }
       )
     end

data/lib/mockserver/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MockServer
-  VERSION = '7.0.0'
+  VERSION = '7.1.0'
 end

data/lib/mockserver/websocket_client.rb

@@ -8,6 +8,7 @@ require 'timeout'
 
 module MockServer
   WEB_SOCKET_CORRELATION_ID_HEADER_NAME = 'WebSocketCorrelationId'
+  BREAKPOINT_ID_HEADER_NAME = 'X-MockServer-BreakpointId'
   CLIENT_REGISTRATION_ID_HEADER = 'X-CLIENT-REGISTRATION-ID'
 
   WEBSOCKET_PATH = '/_mockserver_callback_websocket'
@@ -17,6 +18,8 @@ module MockServer
   TYPE_HTTP_REQUEST_AND_RESPONSE = 'org.mockserver.model.HttpRequestAndHttpResponse'
   TYPE_CLIENT_ID_DTO             = 'org.mockserver.serialization.model.WebSocketClientIdDTO'
   TYPE_ERROR_DTO                 = 'org.mockserver.serialization.model.WebSocketErrorDTO'
+  TYPE_PAUSED_STREAM_FRAME_DTO   = 'org.mockserver.serialization.model.PausedStreamFrameDTO'
+  TYPE_STREAM_FRAME_DECISION_DTO = 'org.mockserver.serialization.model.StreamFrameDecisionDTO'
 
   MAX_RECONNECT_ATTEMPTS = 3
   REGISTRATION_TIMEOUT   = 10
@@ -32,6 +35,17 @@ module MockServer
     nil
   end
 
+  def self.extract_breakpoint_id(request)
+    return nil if request.headers.nil?
+
+    request.headers.each do |header|
+      if header.name == BREAKPOINT_ID_HEADER_NAME
+        return header.values.first if header.values && !header.values.empty?
+      end
+    end
+    nil
+  end
+
   def self.add_correlation_id_header(message, correlation_id)
     message.headers ||= []
     message.headers.each do |header|
@@ -94,6 +108,10 @@ module MockServer
       @logger.progname = 'MockServer::WebSocketClient'
       @logger.level = Logger::WARN
       @registration_queue = nil
+      # Per-breakpoint-id handlers for matcher-driven breakpoints
+      @breakpoint_request_handlers = {}
+      @breakpoint_response_handlers = {}
+      @breakpoint_stream_frame_handlers = {}
     end
 
     def connected?
@@ -124,6 +142,37 @@ module MockServer
       @forward_response_callback = response_fn
     end
 
+    # Register a REQUEST-phase breakpoint handler keyed by breakpoint id.
+    def set_breakpoint_request_handler(breakpoint_id, handler)
+      @breakpoint_request_handlers[breakpoint_id] = handler if breakpoint_id && handler
+    end
+
+    # Register a RESPONSE-phase breakpoint handler keyed by breakpoint id.
+    def set_breakpoint_response_handler(breakpoint_id, handler)
+      @breakpoint_response_handlers[breakpoint_id] = handler if breakpoint_id && handler
+    end
+
+    # Register a stream-frame breakpoint handler keyed by breakpoint id.
+    def set_breakpoint_stream_frame_handler(breakpoint_id, handler)
+      @breakpoint_stream_frame_handlers[breakpoint_id] = handler if breakpoint_id && handler
+    end
+
+    # Remove all handlers for the given breakpoint id.
+    def remove_breakpoint_handlers(breakpoint_id)
+      return unless breakpoint_id
+
+      @breakpoint_request_handlers.delete(breakpoint_id)
+      @breakpoint_response_handlers.delete(breakpoint_id)
+      @breakpoint_stream_frame_handlers.delete(breakpoint_id)
+    end
+
+    # Remove all breakpoint handlers.
+    def clear_breakpoint_handlers
+      @breakpoint_request_handlers.clear
+      @breakpoint_response_handlers.clear
+      @breakpoint_stream_frame_handlers.clear
+    end
+
     def listen
       @listen_thread = Thread.new { listen_loop }
       @listen_thread.abort_on_exception = false
@@ -270,8 +319,12 @@ module MockServer
       if msg_type == TYPE_HTTP_REQUEST
         request = HttpRequest.from_hash(JSON.parse(msg_value))
         correlation_id = MockServer.extract_correlation_id(request)
+        breakpoint_id = MockServer.extract_breakpoint_id(request)
 
-        if @forward_callback
+        bp_handler = breakpoint_id ? @breakpoint_request_handlers[breakpoint_id] : nil
+        if bp_handler
+          handle_breakpoint_request(request, correlation_id, bp_handler)
+        elsif @forward_callback
           handle_forward_request(request, correlation_id)
         elsif @response_callback
           handle_response_request(request, correlation_id)
@@ -284,8 +337,12 @@ module MockServer
       if msg_type == TYPE_HTTP_REQUEST_AND_RESPONSE
         req_and_resp = HttpRequestAndHttpResponse.from_hash(JSON.parse(msg_value))
         correlation_id = MockServer.extract_correlation_id(req_and_resp.http_request)
+        breakpoint_id = MockServer.extract_breakpoint_id(req_and_resp.http_request)
 
-        if @forward_response_callback
+        bp_handler = breakpoint_id ? @breakpoint_response_handlers[breakpoint_id] : nil
+        if bp_handler
+          handle_breakpoint_response(req_and_resp, correlation_id, bp_handler)
+        elsif @forward_response_callback
           handle_forward_response(req_and_resp, correlation_id)
         else
           @logger.warn("Received HttpRequestAndHttpResponse callback but no forward_response_callback registered")
@@ -293,6 +350,12 @@ module MockServer
         return
       end
 
+      if msg_type == TYPE_PAUSED_STREAM_FRAME_DTO
+        paused_frame = JSON.parse(msg_value)
+        handle_breakpoint_stream_frame(paused_frame)
+        return
+      end
+
       @logger.warn("Received unhandled WebSocket message type: #{msg_type}")
     end
 
@@ -349,5 +412,69 @@ module MockServer
         @ws.send(error_msg)
       end
     end
+
+    def handle_breakpoint_request(request, correlation_id, handler)
+      result = handler.call(request)
+      result = request if result.nil? # auto-continue
+
+      MockServer.add_correlation_id_header(result, correlation_id) if correlation_id
+
+      type_name = result.is_a?(HttpResponse) ? TYPE_HTTP_RESPONSE : TYPE_HTTP_REQUEST
+      msg = MockServer.build_ws_message(type_name, result.to_h)
+      @ws.send(msg)
+    rescue StandardError => exc
+      @logger.error("Error in breakpoint request handler, auto-continuing: #{exc.message}")
+      MockServer.add_correlation_id_header(request, correlation_id) if correlation_id
+      msg = MockServer.build_ws_message(TYPE_HTTP_REQUEST, request.to_h)
+      @ws.send(msg)
+    end
+
+    def handle_breakpoint_response(req_and_resp, correlation_id, handler)
+      result = handler.call(req_and_resp.http_request, req_and_resp.http_response)
+      result = req_and_resp.http_response if result.nil? # auto-continue
+
+      unless result.is_a?(HttpResponse)
+        raise CallbackError, "Breakpoint response handler must return HttpResponse, got #{result.class}"
+      end
+
+      MockServer.add_correlation_id_header(result, correlation_id) if correlation_id
+      msg = MockServer.build_ws_message(TYPE_HTTP_RESPONSE, result.to_h)
+      @ws.send(msg)
+    rescue StandardError => exc
+      @logger.error("Error in breakpoint response handler, auto-continuing: #{exc.message}")
+      resp = req_and_resp.http_response || HttpResponse.new
+      MockServer.add_correlation_id_header(resp, correlation_id) if correlation_id
+      msg = MockServer.build_ws_message(TYPE_HTTP_RESPONSE, resp.to_h)
+      @ws.send(msg)
+    end
+
+    def handle_breakpoint_stream_frame(paused_frame)
+      breakpoint_id = paused_frame['breakpointId']
+      correlation_id = paused_frame['correlationId'] || ''
+      handler = breakpoint_id ? @breakpoint_stream_frame_handlers[breakpoint_id] : nil
+
+      decision = if handler
+                   begin
+                     result = handler.call(paused_frame)
+                     if result.nil?
+                       { 'correlationId' => correlation_id, 'action' => 'CONTINUE' }
+                     else
+                       result['correlationId'] = correlation_id # ensure echoed
+                       result
+                     end
+                   rescue StandardError => exc
+                     @logger.error("Error in breakpoint stream frame handler, auto-continuing: #{exc.message}")
+                     { 'correlationId' => correlation_id, 'action' => 'CONTINUE' }
+                   end
+                 else
+                   { 'correlationId' => correlation_id, 'action' => 'CONTINUE' }
+                 end
+
+      msg = JSON.generate({
+        'type'  => TYPE_STREAM_FRAME_DECISION_DTO,
+        'value' => JSON.generate(decision)
+      })
+      @ws.send(msg)
+    end
   end
 end

data/lib/mockserver-client.rb

@@ -6,3 +6,4 @@ require_relative 'mockserver/models'
 require_relative 'mockserver/websocket_client'
 require_relative 'mockserver/forward_chain_expectation'
 require_relative 'mockserver/client'
+require_relative 'mockserver/binary_launcher'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mockserver-client
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.0
 platform: ruby
 authors:
 - James Bloom
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-06 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -91,6 +91,7 @@ files:
 - Gemfile
 - README.md
 - lib/mockserver-client.rb
+- lib/mockserver/binary_launcher.rb
 - lib/mockserver/client.rb
 - lib/mockserver/errors.rb
 - lib/mockserver/forward_chain_expectation.rb