mockserver-client 7.1.0 → 7.2.0

data/lib/mockserver/models.rb

@@ -3,6 +3,7 @@
 require 'base64'
 require 'json'
 require 'set'
+require 'erb'
 
 module MockServer
   # Explicit mapping from Ruby snake_case field names to the camelCase
@@ -30,6 +31,7 @@ module MockServer
     'response_callback'              => 'responseCallback',
     'drop_connection'                => 'dropConnection',
     'response_bytes'                 => 'responseBytes',
+    'stream_error'                   => 'streamError',
     'http_request'                   => 'httpRequest',
     'http_response'                  => 'httpResponse',
     'http_response_template'         => 'httpResponseTemplate',
@@ -84,7 +86,16 @@ module MockServer
     'http_class_callback'            => 'httpClassCallback',
     'http_object_callback'           => 'httpObjectCallback',
     'failure_policy'                 => 'failurePolicy',
-    'http_responses'                 => 'httpResponses'
+    'http_responses'                 => 'httpResponses',
+    'response_mode'                  => 'responseMode',
+    'response_weights'               => 'responseWeights',
+    'switch_after'                   => 'switchAfter',
+    'cross_protocol_scenarios'       => 'crossProtocolScenarios',
+    'scenario_name'                  => 'scenarioName',
+    'scenario_state'                 => 'scenarioState',
+    'new_scenario_state'             => 'newScenarioState',
+    'match_pattern'                  => 'matchPattern',
+    'target_state'                   => 'targetState'
   }.freeze
 
   REVERSE_FIELD_MAP = FIELD_MAP.invert.freeze
@@ -119,6 +130,30 @@ module MockServer
     hash.reject { |_k, v| v.nil? }
   end
 
+  # @api private
+  # Coerce a class-callback value into an {HttpClassCallback}. Accepts:
+  #   * +nil+              -> +nil+
+  #   * a +String+         -> +HttpClassCallback.new(callback_class: <string>)+
+  #   * an HttpClassCallback -> returned unchanged
+  # Any other type raises a TypeError. This lets the Expectation setters and the
+  # fluent builder accept either a fully-qualified class-name String or a
+  # pre-built {HttpClassCallback} (carrying +delay+ / +primary+).
+  def self.coerce_class_callback(value)
+    return nil if value.nil?
+    return HttpClassCallback.new(callback_class: value) if value.is_a?(String)
+    return value if value.is_a?(HttpClassCallback)
+
+    raise TypeError,
+          "Expected a class-name String or HttpClassCallback, got #{value.class.name}"
+  end
+
+  # @api private
+  # Percent-encode a single URL path segment (e.g. a scenario name), encoding
+  # spaces as %20 (not +) so the segment is safe inside +/mockserver/scenario/{name}+.
+  def self.encode_path_segment(value)
+    ERB::Util.url_encode(value.to_s)
+  end
+
   # @api private
   def self.serialize_value(value)
     case value
@@ -188,6 +223,29 @@ module MockServer
     end
   end
 
+  # @api private
+  # Unlike headers / query parameters, MockServer represents cookies as a
+  # single-value {name => value} object map, not a [{name, values}] array.
+  def self.serialize_cookies(items)
+    return nil if items.nil?
+
+    items.each_with_object({}) do |item, map|
+      map[item.name] = item.values.is_a?(Array) ? item.values.first : item.values
+    end
+  end
+
+  # @api private
+  def self.deserialize_cookies(data)
+    return nil if data.nil?
+
+    if data.is_a?(Hash)
+      return data.map { |k, v| KeyToMultiValue.new(name: k, values: v.is_a?(Array) ? v : [v]) }
+    end
+
+    # tolerate the legacy array form on read
+    deserialize_key_multi_values(data)
+  end
+
   # -------------------------------------------------------------------
   # Model classes
   # -------------------------------------------------------------------
@@ -564,7 +622,7 @@ module MockServer
         'path'                  => @path,
         'queryStringParameters' => MockServer.serialize_key_multi_values(@query_string_parameters),
         'headers'               => MockServer.serialize_key_multi_values(@headers),
-        'cookies'               => MockServer.serialize_key_multi_values(@cookies),
+        'cookies'               => MockServer.serialize_cookies(@cookies),
         'body'                  => MockServer.serialize_body(@body),
         'secure'                => @secure,
         'keepAlive'             => @keep_alive,
@@ -582,7 +640,7 @@ module MockServer
         path:                    data['path'],
         query_string_parameters: MockServer.deserialize_key_multi_values(data['queryStringParameters']),
         headers:                 MockServer.deserialize_key_multi_values(data['headers']),
-        cookies:                 MockServer.deserialize_key_multi_values(data['cookies']),
+        cookies:                 MockServer.deserialize_cookies(data['cookies']),
         body:                    MockServer.deserialize_body(data['body']),
         secure:                  data['secure'],
         keep_alive:              data['keepAlive'],
@@ -714,7 +772,7 @@ module MockServer
         'statusCode'       => @status_code,
         'reasonPhrase'     => @reason_phrase,
         'headers'          => MockServer.serialize_key_multi_values(@headers),
-        'cookies'          => MockServer.serialize_key_multi_values(@cookies),
+        'cookies'          => MockServer.serialize_cookies(@cookies),
         'body'             => MockServer.serialize_body(@body),
         'delay'            => @delay&.to_h,
         'connectionOptions' => @connection_options&.to_h,
@@ -729,7 +787,7 @@ module MockServer
         status_code:       data['statusCode'],
         reason_phrase:     data['reasonPhrase'],
         headers:           MockServer.deserialize_key_multi_values(data['headers']),
-        cookies:           MockServer.deserialize_key_multi_values(data['cookies']),
+        cookies:           MockServer.deserialize_cookies(data['cookies']),
         body:              MockServer.deserialize_body(data['body']),
         delay:             Delay.from_hash(data['delay']),
         connection_options: ConnectionOptions.from_hash(data['connectionOptions']),
@@ -935,11 +993,15 @@ module MockServer
   end
 
   class HttpError
-    attr_accessor :drop_connection, :response_bytes, :delay, :primary
+    # stream_error: reset the matched request stream with this error code (HTTP/2 RST_STREAM /
+    # HTTP/3 RESET_STREAM) instead of returning a response; HTTP/1.1 has no stream concept so this
+    # falls back to dropping the connection. Takes precedence over drop_connection when both are set.
+    attr_accessor :drop_connection, :response_bytes, :stream_error, :delay, :primary
 
-    def initialize(drop_connection: nil, response_bytes: nil, delay: nil, primary: nil)
+    def initialize(drop_connection: nil, response_bytes: nil, stream_error: nil, delay: nil, primary: nil)
       @drop_connection = drop_connection
       @response_bytes = response_bytes
+      @stream_error = stream_error
       @delay = delay
       @primary = primary
     end
@@ -948,6 +1010,7 @@ module MockServer
       MockServer.strip_none({
         'dropConnection' => @drop_connection,
         'responseBytes'  => @response_bytes,
+        'streamError'    => @stream_error,
         'delay'          => @delay&.to_h,
         'primary'        => @primary
       })
@@ -959,6 +1022,7 @@ module MockServer
       new(
         drop_connection: data['dropConnection'],
         response_bytes:  data['responseBytes'],
+        stream_error:    data['streamError'],
         delay:           Delay.from_hash(data['delay']),
         primary:         data['primary']
       )
@@ -1680,6 +1744,146 @@ module MockServer
     end
   end
 
+  # The strategy used to pick which of an expectation's +http_responses+ is
+  # returned for each matching request. Mirrors the core +ResponseMode+ enum.
+  module ResponseMode
+    SEQUENTIAL = 'SEQUENTIAL'
+    RANDOM     = 'RANDOM'
+    WEIGHTED   = 'WEIGHTED'
+    SWITCH     = 'SWITCH'
+  end
+
+  # The protocol event that advances a cross-protocol scenario. Mirrors the
+  # core +CrossProtocolTrigger+ enum.
+  module CrossProtocolTrigger
+    DNS_QUERY         = 'DNS_QUERY'
+    WEBSOCKET_CONNECT = 'WEBSOCKET_CONNECT'
+    GRPC_REQUEST      = 'GRPC_REQUEST'
+    HTTP_REQUEST      = 'HTTP_REQUEST'
+  end
+
+  # Describes a cross-protocol scenario correlation: when a protocol event
+  # matching +trigger+ (and optionally +match_pattern+) is observed, the named
+  # scenario +scenario_name+ is advanced to +target_state+.
+  class CrossProtocolScenario
+    attr_accessor :trigger, :match_pattern, :scenario_name, :target_state
+
+    def initialize(trigger: nil, match_pattern: nil, scenario_name: nil, target_state: nil)
+      @trigger = trigger
+      @match_pattern = match_pattern
+      @scenario_name = scenario_name
+      @target_state = target_state
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'trigger'      => @trigger,
+        'matchPattern' => @match_pattern,
+        'scenarioName' => @scenario_name,
+        'targetState'  => @target_state
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        trigger:       data['trigger'],
+        match_pattern: data['matchPattern'],
+        scenario_name: data['scenarioName'],
+        target_state:  data['targetState']
+      )
+    end
+  end
+
+  # The state of a single named scenario as reported by the server's scenario
+  # control plane. +scenario_name+ is the state-machine name and +current_state+
+  # is its current state (+nil+ if not yet set).
+  class ScenarioState
+    attr_accessor :scenario_name, :current_state, :next_state, :transition_after_ms
+
+    def initialize(scenario_name: nil, current_state: nil, next_state: nil, transition_after_ms: nil)
+      @scenario_name = scenario_name
+      @current_state = current_state
+      @next_state = next_state
+      @transition_after_ms = transition_after_ms
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'scenarioName'      => @scenario_name,
+        'currentState'      => @current_state,
+        'nextState'         => @next_state,
+        'transitionAfterMs' => @transition_after_ms
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        scenario_name:       data['scenarioName'],
+        current_state:       data['currentState'],
+        next_state:          data['nextState'],
+        transition_after_ms: data['transitionAfterMs']
+      )
+    end
+  end
+
+  # A handle to a single named stateful scenario on the server, wrapping the
+  # +/mockserver/scenario/{name}+ control-plane endpoints.
+  #
+  # Obtained via {Client#scenario}:
+  #   client.scenario('Deploy').set('Deploying', transition_after_ms: 5000, next_state: 'Deployed')
+  #   client.scenario('Deploy').trigger('Failed')
+  #   client.scenario('Deploy').state # => "Failed"
+  class ScenarioHandle
+    attr_reader :name
+
+    def initialize(client, name)
+      @client = client
+      @name = name
+    end
+
+    # GET the current state of this scenario (+nil+ if not yet set).
+    # @return [String, nil]
+    def state
+      result = @client.scenario_request('GET', scenario_path)
+      result['currentState']
+    end
+
+    # PUT to set this scenario's state, optionally scheduling a timed transition
+    # to +next_state+ after +transition_after_ms+ milliseconds.
+    #
+    # @param state [String] the state to set
+    # @param transition_after_ms [Integer, nil] delay before auto-transitioning
+    # @param next_state [String, nil] the state to auto-transition to
+    # @return [ScenarioState]
+    def set(state, transition_after_ms: nil, next_state: nil)
+      payload = { 'state' => state }
+      payload['transitionAfterMs'] = transition_after_ms unless transition_after_ms.nil?
+      payload['nextState'] = next_state unless next_state.nil?
+      result = @client.scenario_request('PUT', scenario_path, JSON.generate(payload))
+      ScenarioState.from_hash(result)
+    end
+
+    # PUT an external trigger advancing this scenario to +new_state+.
+    #
+    # @param new_state [String]
+    # @return [ScenarioState]
+    def trigger(new_state)
+      body = JSON.generate({ 'newState' => new_state })
+      result = @client.scenario_request('PUT', "#{scenario_path}/trigger", body)
+      ScenarioState.from_hash(result)
+    end
+
+    private
+
+    def scenario_path
+      "/mockserver/scenario/#{MockServer.encode_path_segment(@name)}"
+    end
+  end
+
   class Expectation
     attr_accessor :id, :priority, :percentage, :http_request, :http_response,
                   :http_response_template, :http_response_class_callback,
@@ -1691,7 +1895,8 @@ module MockServer
                   :grpc_stream_response, :grpc_bidi_response,
                   :binary_response, :dns_response,
                   :before_actions, :after_actions,
-                  :http_responses, :response_mode, :steps,
+                  :http_responses, :response_mode, :response_weights, :switch_after,
+                  :cross_protocol_scenarios, :steps,
                   :scenario_name, :scenario_state, :new_scenario_state
 
     def initialize(id: nil, priority: nil, percentage: nil, http_request: nil, http_response: nil,
@@ -1704,7 +1909,8 @@ module MockServer
                    grpc_stream_response: nil, grpc_bidi_response: nil,
                    binary_response: nil, dns_response: nil,
                    before_actions: nil, after_actions: nil,
-                   http_responses: nil, response_mode: nil, steps: nil,
+                   http_responses: nil, response_mode: nil, response_weights: nil,
+                   switch_after: nil, cross_protocol_scenarios: nil, steps: nil,
                    scenario_name: nil, scenario_state: nil, new_scenario_state: nil)
       @id = id
       @priority = priority
@@ -1712,11 +1918,14 @@ module MockServer
       @http_request = http_request
       @http_response = http_response
       @http_response_template = http_response_template
-      @http_response_class_callback = http_response_class_callback
+      # Route the two class-callback fields through their setters so a bare
+      # class-name String passed to the constructor is coerced to an
+      # HttpClassCallback (matching the setter / fluent-builder behaviour).
+      self.http_response_class_callback = http_response_class_callback
       @http_response_object_callback = http_response_object_callback
       @http_forward = http_forward
       @http_forward_template = http_forward_template
-      @http_forward_class_callback = http_forward_class_callback
+      self.http_forward_class_callback = http_forward_class_callback
       @http_forward_object_callback = http_forward_object_callback
       @http_override_forwarded_request = http_override_forwarded_request
       @http_error = http_error
@@ -1733,12 +1942,31 @@ module MockServer
       @after_actions = after_actions
       @http_responses = http_responses
       @response_mode = response_mode
+      @response_weights = response_weights
+      @switch_after = switch_after
+      @cross_protocol_scenarios = cross_protocol_scenarios
       @steps = steps
       @scenario_name = scenario_name
       @scenario_state = scenario_state
       @new_scenario_state = new_scenario_state
     end
 
+    # Set the response class-callback action. Accepts either a fully-qualified
+    # class-name String (e.g. "com.example.MyResponseCallback") or a pre-built
+    # {HttpClassCallback} (carrying an optional +delay+ / +primary+). A String is
+    # wrapped into an {HttpClassCallback} so +to_h+ always emits
+    # +httpResponseClassCallback.callbackClass+.
+    def http_response_class_callback=(value)
+      @http_response_class_callback = MockServer.coerce_class_callback(value)
+    end
+
+    # Set the forward class-callback action. Accepts either a fully-qualified
+    # class-name String or a pre-built {HttpClassCallback}; serialized as
+    # +httpForwardClassCallback+.
+    def http_forward_class_callback=(value)
+      @http_forward_class_callback = MockServer.coerce_class_callback(value)
+    end
+
     def to_h
       before_actions_h = nil
       if @before_actions.is_a?(Array)
@@ -1779,6 +2007,9 @@ module MockServer
         'afterActions'                 => after_actions_h,
         'httpResponses'                => @http_responses&.map(&:to_h),
         'responseMode'                 => @response_mode,
+        'responseWeights'              => @response_weights,
+        'switchAfter'                  => @switch_after,
+        'crossProtocolScenarios'       => @cross_protocol_scenarios&.map(&:to_h),
         'steps'                        => @steps&.map(&:to_h),
         'times'                        => @times&.to_h,
         'timeToLive'                   => @time_to_live&.to_h,
@@ -1831,6 +2062,9 @@ module MockServer
         after_actions:                   after_actions,
         http_responses:                  data['httpResponses']&.map { |r| HttpResponse.from_hash(r) },
         response_mode:                   data['responseMode'],
+        response_weights:                data['responseWeights'],
+        switch_after:                    data['switchAfter'],
+        cross_protocol_scenarios:        data['crossProtocolScenarios']&.map { |c| CrossProtocolScenario.from_hash(c) },
         steps:                           data['steps']&.map { |s| ExpectationStep.from_hash(s) },
         times:                           Times.from_hash(data['times']),
         time_to_live:                    TimeToLive.from_hash(data['timeToLive']),
@@ -2053,6 +2287,188 @@ module MockServer
     end
   end
 
+  # One stage of a {LoadProfile}, run in sequence. Each stage holds or ramps a
+  # setpoint for +duration_millis+:
+  #
+  # * +VU+ (closed model) - hold +vus+ virtual users, or ramp +start_vus+ to
+  #   +end_vus+ along +curve+.
+  # * +RATE+ (open model) - hold +rate+ iterations/second, or ramp +start_rate+
+  #   to +end_rate+ along +curve+, optionally capping the auto-scaling
+  #   virtual-user pool at +max_vus+.
+  # * +PAUSE+ - drive no load for +duration_millis+.
+  #
+  # Prefer the {.vu}, {.rate} and {.pause} factories, which emit only the fields
+  # relevant to the stage type and mode.
+  class LoadStage
+    attr_accessor :type, :duration_millis, :curve, :vus, :start_vus, :end_vus,
+                  :rate, :start_rate, :end_rate, :max_vus
+
+    def initialize(type:, duration_millis:, curve: nil, vus: nil, start_vus: nil,
+                   end_vus: nil, rate: nil, start_rate: nil, end_rate: nil, max_vus: nil)
+      @type = type
+      @duration_millis = duration_millis
+      @curve = curve
+      @vus = vus
+      @start_vus = start_vus
+      @end_vus = end_vus
+      @rate = rate
+      @start_rate = start_rate
+      @end_rate = end_rate
+      @max_vus = max_vus
+    end
+
+    # A +VU+ (closed-model) stage - hold +vus+ or ramp +start_vus+ to +end_vus+.
+    def self.vu(duration_millis, vus: nil, start_vus: nil, end_vus: nil, curve: nil)
+      new(type: 'VU', duration_millis: duration_millis, vus: vus,
+          start_vus: start_vus, end_vus: end_vus, curve: curve)
+    end
+
+    # A +RATE+ (open-model) stage - hold +rate+ or ramp +start_rate+ to
+    # +end_rate+ (iterations/second).
+    def self.rate(duration_millis, rate: nil, start_rate: nil, end_rate: nil, max_vus: nil, curve: nil)
+      new(type: 'RATE', duration_millis: duration_millis, rate: rate,
+          start_rate: start_rate, end_rate: end_rate, max_vus: max_vus, curve: curve)
+    end
+
+    # A +PAUSE+ stage - drive no load for +duration_millis+.
+    def self.pause(duration_millis)
+      new(type: 'PAUSE', duration_millis: duration_millis)
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'type'           => @type,
+        'durationMillis' => @duration_millis,
+        'curve'          => @curve,
+        'vus'            => @vus,
+        'startVus'       => @start_vus,
+        'endVus'         => @end_vus,
+        'rate'           => @rate,
+        'startRate'      => @start_rate,
+        'endRate'        => @end_rate,
+        'maxVus'         => @max_vus
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        type:            data['type'],
+        duration_millis: data['durationMillis'],
+        curve:           data['curve'],
+        vus:             data['vus'],
+        start_vus:       data['startVus'],
+        end_vus:         data['endVus'],
+        rate:            data['rate'],
+        start_rate:      data['startRate'],
+        end_rate:        data['endRate'],
+        max_vus:         data['maxVus']
+      )
+    end
+  end
+
+  # The traffic-shaping profile of a load scenario: an ordered list of {LoadStage}
+  # objects run in sequence, each holding or ramping a setpoint (virtual users, an
+  # arrival rate, or a pause) for its duration. The total run length is the sum of
+  # the stage durations.
+  class LoadProfile
+    attr_accessor :stages
+
+    def initialize(stages: [])
+      @stages = stages || []
+    end
+
+    def to_h
+      { 'stages' => @stages.map(&:to_h) }
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      stages_data = data['stages'] || []
+      new(stages: stages_data.map { |s| LoadStage.from_hash(s) })
+    end
+  end
+
+  # A single step within a load scenario. Each step fires +request+ (an HttpRequest)
+  # against the target, optionally pausing for +think_time+ (a Delay) afterwards.
+  class LoadStep
+    attr_accessor :name, :labels, :think_time, :request
+
+    def initialize(request:, name: nil, labels: nil, think_time: nil)
+      @request = request
+      @name = name
+      @labels = labels
+      @think_time = think_time
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'name'      => @name,
+        'labels'    => @labels,
+        'thinkTime' => @think_time&.to_h,
+        'request'   => @request&.to_h
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        name:       data['name'],
+        labels:     data['labels'],
+        think_time: Delay.from_hash(data['thinkTime']),
+        request:    HttpRequest.from_hash(data['request'])
+      )
+    end
+  end
+
+  # A load-injection scenario: a named set of +steps+ driven by a traffic +profile+.
+  # +template_type+ selects the templating engine (+VELOCITY+ or +MUSTACHE+) used to
+  # render step requests; +max_requests+ caps the total requests issued.
+  class LoadScenario
+    attr_accessor :name, :template_type, :labels, :max_requests, :start_delay_millis, :profile, :steps
+
+    def initialize(name:, profile:, steps:, template_type: nil, labels: nil, max_requests: nil,
+                   start_delay_millis: nil)
+      @name = name
+      @profile = profile
+      @steps = steps
+      @template_type = template_type
+      @labels = labels
+      @max_requests = max_requests
+      @start_delay_millis = start_delay_millis
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'name'             => @name,
+        'templateType'     => @template_type,
+        'labels'           => @labels,
+        'maxRequests'      => @max_requests,
+        'startDelayMillis' => @start_delay_millis,
+        'profile'          => @profile&.to_h,
+        'steps'            => @steps&.map(&:to_h)
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      steps_data = data['steps']
+      new(
+        name:               data['name'],
+        template_type:      data['templateType'],
+        labels:             data['labels'],
+        max_requests:       data['maxRequests'],
+        start_delay_millis: data['startDelayMillis'],
+        profile:            LoadProfile.from_hash(data['profile']),
+        steps:              steps_data ? steps_data.map { |s| LoadStep.from_hash(s) } : nil
+      )
+    end
+  end
+
   # Alias matching the Python client
   RequestDefinition = HttpRequest
 end

data/lib/mockserver/rspec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+module MockServer
+  # RSpec integration helpers for MockServer.
+  #
+  # Require this file from your `spec_helper.rb` to get a shared context that
+  # provides a fresh {MockServer::Client} per example and automatically resets
+  # the server between examples, so recorded requests, expectations and logs
+  # never leak from one example to the next:
+  #
+  #     require 'mockserver/rspec'
+  #
+  #     RSpec.describe 'my integration', :mockserver do
+  #       it 'records the request' do
+  #         # `mockserver` is the shared, reset client
+  #         mockserver.when(MockServer::HttpRequest.request(path: '/hello'))
+  #                   .respond(MockServer::HttpResponse.response(body: 'world'))
+  #       end
+  #     end
+  #
+  # The host and port default to `127.0.0.1:1080` and can be overridden with the
+  # `MOCKSERVER_HOST` / `MOCKSERVER_PORT` environment variables, or by defining a
+  # `mockserver_host` / `mockserver_port` `let` in your example group.
+  module RSpec
+    SHARED_CONTEXT_NAME = 'mockserver client'
+
+    if defined?(::RSpec)
+      ::RSpec.shared_context SHARED_CONTEXT_NAME do
+        let(:mockserver_host) { ENV.fetch('MOCKSERVER_HOST', '127.0.0.1') }
+        let(:mockserver_port) { Integer(ENV.fetch('MOCKSERVER_PORT', '1080')) }
+
+        # A fresh client per example. Memoised so the same instance is returned
+        # within a single example, but rebuilt for the next one.
+        let(:mockserver) { MockServer::Client.new(mockserver_host, mockserver_port) }
+
+        # Start each example from a clean server and tear down again afterwards,
+        # closing any websocket connections opened by the client.
+        before do
+          mockserver.reset
+        end
+
+        after do
+          mockserver.reset
+        end
+      end
+
+      # Make the shared context available to any example group tagged
+      # `:mockserver` without an explicit `include_context`.
+      ::RSpec.configure do |config|
+        config.include_context SHARED_CONTEXT_NAME, :mockserver
+      end
+    end
+  end
+end

data/lib/mockserver/version.rb

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

data/lib/mockserver-client.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mockserver-client
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.2.0
 platform: ruby
 authors:
 - James Bloom
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-15 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -95,7 +95,10 @@ files:
 - lib/mockserver/client.rb
 - lib/mockserver/errors.rb
 - lib/mockserver/forward_chain_expectation.rb
+- lib/mockserver/llm.rb
+- lib/mockserver/mcp.rb
 - lib/mockserver/models.rb
+- lib/mockserver/rspec.rb
 - lib/mockserver/version.rb
 - lib/mockserver/websocket_client.rb
 - mockserver-client.gemspec