mockserver-client 7.3.0 → 7.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa28c69e849b63f6fa75a1f57f939a348cf30d3032d6b1dfb040276dbd51eb6b
-  data.tar.gz: 188c6469fc18b0ed51b4099a652d68a3b00b0bbccda233265b282e9d08e5c677
+  metadata.gz: 9eedfe80337a01b9026c0a59a4f95e98218ccfacf6344b4b7b435c1226d9e723
+  data.tar.gz: 06a19eaf8d0a7d435c5020c47ea7c2c764fc19d0b609b302e4116355c11df49b
 SHA512:
-  metadata.gz: c4d3d24b31236d09f8684b10bc114e6cb2154f532ff230453f9e3f566ecbd271ef4c770a8d3f6db6a2476bd89efdd529471ba4fb46ca2ebe0e89e8a97f2fc63e
-  data.tar.gz: daef70802e8ee57033d185f74c580c3b61d87eb97fc0c74ab31288f345e9fe86c9823b6ff6f90231d2066c8b9f05a6446d5ba06a7d917bdb61dd1215ef2094ae
+  metadata.gz: 3660064c5073f33c8dcb60cdb22df47c8609571d6328847f06912f2d211471974b515282bd9aeeb56ea7f654001a15efbaf78235e924f8ce85fac65abeed7248
+  data.tar.gz: 72a837da848c6ec9fc112c3f13f76362fa9b800694b55673d51fb38a7eaf62086dd89585cbac281dee65567bf56709bc037670fb116913e23546dcf7584f9aac

data/README.md

@@ -7,7 +7,7 @@ Hand-written Ruby client for [MockServer](https://www.mock-server.com) with full
 Add to your Gemfile:
 
 ```ruby
-gem 'mockserver-client', '~> 5.16'
+gem 'mockserver-client', '~> 7.3'
 ```
 
 Or install directly:
@@ -85,7 +85,7 @@ client.close
 
 ## Models
 
-All 25 domain model classes are available under the `MockServer` module:
+All 26 domain model classes are available under the `MockServer` module:
 
 - `Delay`, `Times`, `TimeToLive`
 - `KeyToMultiValue`, `Body`, `SocketAddress`
@@ -98,6 +98,43 @@ All 25 domain model classes are available under the `MockServer` module:
 - `Verification`, `VerificationSequence`, `VerificationTimes`
 - `Ports`
 - `RequestDefinition` (alias for `HttpRequest`)
+- `Jwt` (JWT / bearer-token request matcher)
+
+## JWT and combined body matchers
+
+Match a request by the claims in its JWT (carried by default in the
+`Authorization: Bearer <token>` header). Each claim value is an exact string or a
+regular expression; a leading `!` negates it (the same NottableString convention
+used elsewhere in MockServer). `issuer`, `audience`, `algorithm`, `header` and
+`scheme` are optional.
+
+```ruby
+jwt = MockServer::Jwt.new(
+  claims: {
+    'sub'   => 'user-123',
+    'role'  => '!admin',            # must NOT be "admin"
+    'email' => '^.+@example.com$'   # regex
+  },
+  issuer:    'https://issuer.example.com',
+  audience:  'my-api',
+  algorithm: 'RS256'
+)
+
+request = MockServer::HttpRequest.new(method: 'GET', path: '/api')
+                                 .with_jwt(jwt)
+```
+
+Combine several body matchers with `Body.all_of` — the request body must satisfy
+**all** of them:
+
+```ruby
+body = MockServer::Body.all_of(
+  MockServer::Body.json_path('$.name'),   # => {"type":"JSON_PATH","jsonPath":"$.name"}
+  MockServer::Body.regex('.*active.*')    # => {"type":"REGEX","regex":".*active.*"}
+)
+
+request = MockServer::HttpRequest.new(method: 'POST', path: '/api').with_body(body)
+```
 
 ## LLM Mocking
 
@@ -316,7 +353,7 @@ launcher_path = MockServer::BinaryLauncher.ensure_launcher
 ### Specify a version
 
 ```ruby
-handle = MockServer::BinaryLauncher.start(port: 1080, version: '7.3.0')
+handle = MockServer::BinaryLauncher.start(port: 1080, version: '7.4.0')
 ```
 
 ### API reference

data/lib/mockserver/client.rb

@@ -278,6 +278,39 @@ module MockServer
       response_body || ''
     end
 
+    # -------------------------------------------------------------------
+    # Drift detection
+    # -------------------------------------------------------------------
+
+    # Retrieve the recorded mock drift report (GET /mockserver/drift).
+    #
+    # Returns the parsed report, a Hash of the form
+    # +{ "count" => <n>, "drifts" => [ ... ] }+, where each entry describes a
+    # difference detected between a mock's configured response and the live
+    # upstream response for the same request. When no drift has been recorded an
+    # empty Hash is returned.
+    #
+    # @return [Hash] the parsed drift report
+    def retrieve_drift
+      status, response_body = request('GET', '/mockserver/drift')
+      if status >= 400
+        raise Error, "Failed to retrieve drift (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Clear all recorded mock drift (PUT /mockserver/drift/clear).
+    # @return [nil]
+    def clear_drift
+      status, response_body = request('PUT', '/mockserver/drift/clear')
+      if status >= 400
+        raise Error, "Failed to clear drift (status=#{status}): #{response_body}"
+      end
+
+      nil
+    end
+
     # -------------------------------------------------------------------
     # Pact (import / export / verify)
     # -------------------------------------------------------------------

data/lib/mockserver/models.rb

@@ -103,7 +103,8 @@ 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 FILE
+    STRING JSON REGEX XML BINARY JSON_SCHEMA JSON_PATH XPATH XML_SCHEMA JSON_RPC GRAPHQL FILE ALL_OF
+    PARAMETERS WASM
   ]).freeze
 
   # -------------------------------------------------------------------
@@ -204,6 +205,18 @@ module MockServer
     items.map(&:to_h)
   end
 
+  # @api private
+  # Serialise a keyToMultiValue collection in the { name => [values] } object form
+  # (rather than the [{name, values}] array form). MockServer accepts both wire
+  # encodings for keyToMultiValue fields, but pathParameters (a schema-matcher map
+  # whose values are themselves { "schema": {...} } objects) is conventionally
+  # emitted in the object form, so this preserves the caller's shape on round-trip.
+  def self.serialize_key_multi_values_object(items)
+    return nil if items.nil?
+
+    items.each_with_object({}) { |item, map| map[item.name] = item.values }
+  end
+
   # @api private
   def self.deserialize_key_multi_values(data)
     return nil if data.nil?
@@ -420,49 +433,109 @@ module MockServer
   end
 
   class Body
-    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, file_path: nil, template_type: nil)
+    # sub_string / match_type / match_numbers_as_strings / json_schema /
+    # parameter_styles / xml_schema / parameters / module_name / optional are the
+    # per-type matcher sub-fields carried by the server body DTOs
+    # (StringBodyDTO.subString, JsonBodyDTO.matchType/matchNumbersAsStrings,
+    # JsonSchemaBodyDTO.jsonSchema/parameterStyles, XmlSchemaBodyDTO.xmlSchema,
+    # ParameterBodyDTO.parameters, WasmBodyDTO.moduleName, BodyDTO.optional).
+    # xml carries the XML body's own +xml+ wire key (XmlBodyDTO.xml). It is distinct
+    # from +string+: the legacy Body.xml(...) factory populates +string+ (pinned by a
+    # test), whereas a server-produced XML body serialises its content under +xml+.
+    attr_accessor :type, :string, :xml, :json, :regex, :json_path, :xpath, :base64_bytes,
+                  :not_body, :content_type, :charset, :file_path, :template_type, :body_all_of,
+                  :sub_string, :match_type, :match_numbers_as_strings, :json_schema,
+                  :parameter_styles, :xml_schema, :parameters, :module_name, :optional
+
+    def initialize(type: nil, string: nil, xml: nil, json: nil, regex: nil, json_path: nil, xpath: nil,
+                   base64_bytes: nil, not_body: nil, content_type: nil, charset: nil,
+                   file_path: nil, template_type: nil, body_all_of: nil,
+                   sub_string: nil, match_type: nil, match_numbers_as_strings: nil,
+                   json_schema: nil, parameter_styles: nil, xml_schema: nil,
+                   parameters: nil, module_name: nil, optional: nil)
       @type = type
       @string = string
+      @xml = xml
       @json = json
+      @regex = regex
+      @json_path = json_path
+      @xpath = xpath
       @base64_bytes = base64_bytes
       @not_body = not_body
       @content_type = content_type
       @charset = charset
       @file_path = file_path
       @template_type = template_type
+      @body_all_of = body_all_of
+      @sub_string = sub_string
+      @match_type = match_type
+      @match_numbers_as_strings = match_numbers_as_strings
+      @json_schema = json_schema
+      @parameter_styles = parameter_styles
+      @xml_schema = xml_schema
+      @parameters = parameters
+      @module_name = module_name
+      @optional = optional
     end
 
     def to_h
       result = {}
       result['type']         = @type          unless @type.nil?
       result['string']       = @string        unless @string.nil?
+      result['xml']          = @xml           unless @xml.nil?
       result['json']         = @json          unless @json.nil?
+      result['regex']        = @regex         unless @regex.nil?
+      result['jsonPath']     = @json_path     unless @json_path.nil?
+      result['xpath']        = @xpath         unless @xpath.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['subString']    = @sub_string    unless @sub_string.nil?
+      result['matchType']    = @match_type    unless @match_type.nil?
+      result['matchNumbersAsStrings'] = @match_numbers_as_strings unless @match_numbers_as_strings.nil?
+      result['jsonSchema']   = @json_schema   unless @json_schema.nil?
+      result['parameterStyles'] = @parameter_styles unless @parameter_styles.nil?
+      result['xmlSchema']    = @xml_schema    unless @xml_schema.nil?
+      result['parameters']   = @parameters    unless @parameters.nil?
+      result['moduleName']   = @module_name   unless @module_name.nil?
+      result['optional']     = @optional      unless @optional.nil?
+      unless @body_all_of.nil?
+        result['bodyAllOf'] = @body_all_of.map { |b| MockServer.serialize_body(b) }
+      end
       result
     end
 
     def self.from_hash(data)
       return nil if data.nil?
 
+      all_of = data['bodyAllOf']
       new(
         type:          data['type'],
         string:        data['string'],
+        xml:           data['xml'],
         json:          data['json'],
+        regex:         data['regex'],
+        json_path:     data['jsonPath'],
+        xpath:         data['xpath'],
         base64_bytes:  data['base64Bytes'],
         not_body:      data['not'],
         content_type:  data['contentType'],
         charset:       data['charset'],
         file_path:     data['filePath'],
-        template_type: data['templateType']
+        template_type: data['templateType'],
+        sub_string:               data['subString'],
+        match_type:               data['matchType'],
+        match_numbers_as_strings: data['matchNumbersAsStrings'],
+        json_schema:              data['jsonSchema'],
+        parameter_styles:         data['parameterStyles'],
+        xml_schema:               data['xmlSchema'],
+        parameters:               data['parameters'],
+        module_name:              data['moduleName'],
+        optional:                 data['optional'],
+        body_all_of:   all_of&.map { |b| MockServer.deserialize_body(b) }
       )
     end
 
@@ -475,7 +548,7 @@ module MockServer
     end
 
     def self.regex(value)
-      new(type: 'REGEX', string: value)
+      new(type: 'REGEX', regex: value)
     end
 
     def self.exact(value)
@@ -486,6 +559,50 @@ module MockServer
       new(type: 'XML', string: value)
     end
 
+    # Combine several body matchers into a single ALL_OF matcher; all of the
+    # supplied sub-bodies must match the request body. Each sub-body is any
+    # existing body matcher (e.g. +Body.json_path+, +Body.regex+) and is
+    # serialised through the normal body-serialisation path.
+    def self.all_of(*bodies)
+      new(type: 'ALL_OF', body_all_of: bodies.flatten)
+    end
+
+    def self.json_path(value)
+      new(type: 'JSON_PATH', json_path: value)
+    end
+
+    def self.xpath(value)
+      new(type: 'XPATH', xpath: value)
+    end
+
+    # A JSON_SCHEMA body matcher. +parameter_styles+ is an optional
+    # { parameter-name => style } map (serialised as +parameterStyles+).
+    def self.json_schema(schema, parameter_styles: nil)
+      new(type: 'JSON_SCHEMA', json_schema: schema, parameter_styles: parameter_styles)
+    end
+
+    # An XML_SCHEMA body matcher.
+    def self.xml_schema(schema)
+      new(type: 'XML_SCHEMA', xml_schema: schema)
+    end
+
+    # A STRING body matcher that matches when +value+ appears as a substring.
+    def self.sub_string(value)
+      new(type: 'STRING', string: value, sub_string: true)
+    end
+
+    # A PARAMETERS (form / query) body matcher. +parameters+ is the wire form
+    # of the parameter collection (either a { name => [values] } map or the
+    # [{name, values}] array form).
+    def self.parameters(parameters)
+      new(type: 'PARAMETERS', parameters: parameters)
+    end
+
+    # A WASM body matcher that delegates matching to the named WASM module.
+    def self.wasm(module_name)
+      new(type: 'WASM', module_name: module_name)
+    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
@@ -535,12 +652,22 @@ module MockServer
   end
 
   class GraphQLBody
-    attr_accessor :query, :operation_name, :variables_schema, :not_body, :optional
-
-    def initialize(query:, operation_name: nil, variables_schema: nil, not_body: false, optional: false)
+    # selection_set_match_type selects how the query's selection set is matched
+    # (NORMALISED_STRING / AST_EXACT / AST_SUBSET) and +fields+ is the array of
+    # top-level field names the matcher restricts to, mirroring the server
+    # GraphQLBodyDTO +selectionSetMatchType+ / +fields+ (the GRAPHQL body's +fields+
+    # is a plain string array, distinct from the MULTIPART body's keyToMultiValue
+    # +fields+ map — the server discriminates the two by the body +type+).
+    attr_accessor :query, :operation_name, :variables_schema,
+                  :selection_set_match_type, :fields, :not_body, :optional
+
+    def initialize(query:, operation_name: nil, variables_schema: nil,
+                   selection_set_match_type: nil, fields: nil, not_body: false, optional: false)
       @query = query
       @operation_name = operation_name
       @variables_schema = variables_schema
+      @selection_set_match_type = selection_set_match_type
+      @fields = fields
       @not_body = not_body
       @optional = optional
     end
@@ -549,6 +676,8 @@ module MockServer
       result = { 'type' => 'GRAPHQL', 'query' => @query }
       result['operationName'] = @operation_name if @operation_name
       result['variablesSchema'] = @variables_schema if @variables_schema
+      result['selectionSetMatchType'] = @selection_set_match_type unless @selection_set_match_type.nil?
+      result['fields'] = @fields unless @fields.nil?
       result['not'] = true if @not_body
       result['optional'] = true if @optional
       result
@@ -558,11 +687,13 @@ module MockServer
       return nil if data.nil?
 
       new(
-        query:            data['query'] || '',
-        operation_name:   data['operationName'],
-        variables_schema: data['variablesSchema'],
-        not_body:         data.fetch('not', false),
-        optional:         data.fetch('optional', false)
+        query:                    data['query'] || '',
+        operation_name:           data['operationName'],
+        variables_schema:         data['variablesSchema'],
+        selection_set_match_type: data['selectionSetMatchType'],
+        fields:                   data['fields'],
+        not_body:                 data.fetch('not', false),
+        optional:                 data.fetch('optional', false)
       )
     end
   end
@@ -595,14 +726,75 @@ module MockServer
     end
   end
 
+  # JWT (bearer-token) request matcher. Matches a request whose JWT — carried by
+  # default in the +Authorization: Bearer <token>+ header — satisfies every
+  # constraint below.
+  #
+  # +claims+ is a { claim-name => value } map where each value is an exact string
+  # or a regular expression; a leading +!+ negates the match (the NottableString
+  # convention shared across MockServer matchers). +issuer+, +audience+,
+  # +algorithm+, +header+ and +scheme+ are optional; unset keys are omitted.
+  class Jwt
+    attr_accessor :claims, :issuer, :audience, :algorithm, :header, :scheme
+
+    def initialize(claims: nil, issuer: nil, audience: nil, algorithm: nil, header: nil, scheme: nil)
+      @claims = claims
+      @issuer = issuer
+      @audience = audience
+      @algorithm = algorithm
+      @header = header
+      @scheme = scheme
+    end
+
+    def to_h
+      result = {}
+      result['claims']    = @claims    unless @claims.nil?
+      result['issuer']    = @issuer    unless @issuer.nil?
+      result['audience']  = @audience  unless @audience.nil?
+      result['algorithm'] = @algorithm unless @algorithm.nil?
+      result['header']    = @header    unless @header.nil?
+      result['scheme']    = @scheme    unless @scheme.nil?
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        claims:    data['claims'],
+        issuer:    data['issuer'],
+        audience:  data['audience'],
+        algorithm: data['algorithm'],
+        header:    data['header'],
+        scheme:    data['scheme']
+      )
+    end
+
+    def with_claim(name, value)
+      @claims ||= {}
+      @claims[name] = value
+      self
+    end
+  end
+
   class HttpRequest
+    # dns_name / dns_type / dns_class carry a DNS request matcher
+    # (org.mockserver.model.DnsRequestDefinition). The server discriminates a DNS
+    # request definition from an HTTP one purely by the presence of a non-blank
+    # +dnsName+ on the +httpRequest+ object, so these fields round-trip through
+    # the same +httpRequest+ slot as the HTTP matcher fields.
+    # protocol pins the transport the matcher requires
+    # (org.mockserver.model.Protocol: HTTP_1_1 / HTTP_2 / HTTP_3 / SOCKS / ...),
+    # round-tripping the httpRequest +protocol+ wire key.
     attr_accessor :method, :path, :query_string_parameters, :headers,
-                  :cookies, :body, :secure, :keep_alive, :respond_before_body,
-                  :path_parameters, :socket_address
+                  :cookies, :body, :secure, :protocol, :keep_alive, :respond_before_body,
+                  :path_parameters, :socket_address, :jwt,
+                  :dns_name, :dns_type, :dns_class
 
     def initialize(method: nil, path: nil, query_string_parameters: nil, headers: nil,
-                   cookies: nil, body: nil, secure: nil, keep_alive: nil,
-                   respond_before_body: nil, path_parameters: nil, socket_address: nil)
+                   cookies: nil, body: nil, secure: nil, protocol: nil, keep_alive: nil,
+                   respond_before_body: nil, path_parameters: nil, socket_address: nil,
+                   jwt: nil, dns_name: nil, dns_type: nil, dns_class: nil)
       @method = method
       @path = path
       @query_string_parameters = query_string_parameters
@@ -610,10 +802,15 @@ module MockServer
       @cookies = cookies
       @body = body
       @secure = secure
+      @protocol = protocol
       @keep_alive = keep_alive
       @respond_before_body = respond_before_body
       @path_parameters = path_parameters
       @socket_address = socket_address
+      @jwt = jwt
+      @dns_name = dns_name
+      @dns_type = dns_type
+      @dns_class = dns_class
     end
 
     def to_h
@@ -625,10 +822,15 @@ module MockServer
         'cookies'               => MockServer.serialize_cookies(@cookies),
         'body'                  => MockServer.serialize_body(@body),
         'secure'                => @secure,
+        'protocol'              => @protocol,
         'keepAlive'             => @keep_alive,
         'respondBeforeBody'     => @respond_before_body,
-        'pathParameters'        => MockServer.serialize_key_multi_values(@path_parameters),
-        'socketAddress'         => @socket_address&.to_h
+        'pathParameters'        => MockServer.serialize_key_multi_values_object(@path_parameters),
+        'socketAddress'         => @socket_address&.to_h,
+        'jwt'                   => @jwt&.to_h,
+        'dnsName'               => @dns_name,
+        'dnsType'               => @dns_type,
+        'dnsClass'              => @dns_class
       })
     end
 
@@ -643,13 +845,23 @@ module MockServer
         cookies:                 MockServer.deserialize_cookies(data['cookies']),
         body:                    MockServer.deserialize_body(data['body']),
         secure:                  data['secure'],
+        protocol:                data['protocol'],
         keep_alive:              data['keepAlive'],
         respond_before_body:     data['respondBeforeBody'],
         path_parameters:         MockServer.deserialize_key_multi_values(data['pathParameters']),
-        socket_address:          SocketAddress.from_hash(data['socketAddress'])
+        socket_address:          SocketAddress.from_hash(data['socketAddress']),
+        jwt:                     Jwt.from_hash(data['jwt']),
+        dns_name:                data['dnsName'],
+        dns_type:                data['dnsType'],
+        dns_class:               data['dnsClass']
       )
     end
 
+    # Build a DNS request matcher (org.mockserver.model.DnsRequestDefinition).
+    def self.dns_request(dns_name, dns_type: nil, dns_class: nil)
+      new(dns_name: dns_name, dns_type: dns_type, dns_class: dns_class)
+    end
+
     def self.request(path: nil)
       new(path: path)
     end
@@ -687,6 +899,11 @@ module MockServer
       self
     end
 
+    def with_jwt(jwt)
+      @jwt = jwt
+      self
+    end
+
     def with_secure(secure)
       @secure = secure
       self
@@ -752,11 +969,13 @@ module MockServer
   end
 
   class HttpResponse
+    # trailers carries HTTP trailing headers (org.mockserver.model.Headers on the
+    # response's +trailers+ slot), a keyToMultiValue collection like +headers+.
     attr_accessor :status_code, :reason_phrase, :headers, :cookies,
-                  :body, :delay, :connection_options, :primary
+                  :body, :delay, :connection_options, :trailers, :primary
 
     def initialize(status_code: nil, reason_phrase: nil, headers: nil, cookies: nil,
-                   body: nil, delay: nil, connection_options: nil, primary: nil)
+                   body: nil, delay: nil, connection_options: nil, trailers: nil, primary: nil)
       @status_code = status_code
       @reason_phrase = reason_phrase
       @headers = headers
@@ -764,6 +983,7 @@ module MockServer
       @body = body
       @delay = delay
       @connection_options = connection_options
+      @trailers = trailers
       @primary = primary
     end
 
@@ -776,6 +996,7 @@ module MockServer
         'body'             => MockServer.serialize_body(@body),
         'delay'            => @delay&.to_h,
         'connectionOptions' => @connection_options&.to_h,
+        'trailers'         => MockServer.serialize_key_multi_values(@trailers),
         'primary'          => @primary
       })
     end
@@ -791,6 +1012,7 @@ module MockServer
         body:              MockServer.deserialize_body(data['body']),
         delay:             Delay.from_hash(data['delay']),
         connection_options: ConnectionOptions.from_hash(data['connectionOptions']),
+        trailers:          MockServer.deserialize_key_multi_values(data['trailers']),
         primary:           data['primary']
       )
     end
@@ -1222,12 +1444,49 @@ module MockServer
     end
   end
 
+  # A per-incoming-frame response rule for a WebSocket mock (mirrors the server
+  # WebSocketMessageMatcher). When +frame_type+ (TEXT / BINARY / PING / PONG / ANY)
+  # and the optional +text_matcher+ match an inbound frame, the rule's +responses+
+  # (each a {WebSocketMessage}) are sent back.
+  class WebSocketFrameMatcher
+    attr_accessor :frame_type, :text_matcher, :responses
+
+    def initialize(frame_type: nil, text_matcher: nil, responses: nil)
+      @frame_type = frame_type
+      @text_matcher = text_matcher
+      @responses = responses
+    end
+
+    def to_h
+      result = {}
+      result['frameType'] = @frame_type unless @frame_type.nil?
+      result['textMatcher'] = @text_matcher unless @text_matcher.nil?
+      result['responses'] = @responses&.map(&:to_h) if @responses
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      responses_data = data['responses']
+      responses = responses_data&.map { |r| WebSocketMessage.from_hash(r) }
+      new(
+        frame_type:   data['frameType'],
+        text_matcher: data['textMatcher'],
+        responses:    responses
+      )
+    end
+  end
+
   class HttpWebSocketResponse
-    attr_accessor :subprotocol, :messages, :close_connection, :delay, :primary
+    # matchers carries per-incoming-frame response rules (server
+    # HttpWebSocketResponseDTO.matchers); each is a {WebSocketFrameMatcher}.
+    attr_accessor :subprotocol, :messages, :matchers, :close_connection, :delay, :primary
 
-    def initialize(subprotocol: nil, messages: nil, close_connection: nil, delay: nil, primary: nil)
+    def initialize(subprotocol: nil, messages: nil, matchers: nil, close_connection: nil, delay: nil, primary: nil)
       @subprotocol = subprotocol
       @messages = messages
+      @matchers = matchers
       @close_connection = close_connection
       @delay = delay
       @primary = primary
@@ -1237,6 +1496,7 @@ module MockServer
       result = {}
       result['subprotocol'] = @subprotocol unless @subprotocol.nil?
       result['messages'] = @messages&.map(&:to_h) if @messages
+      result['matchers'] = @matchers&.map(&:to_h) if @matchers
       result['closeConnection'] = @close_connection unless @close_connection.nil?
       result['delay'] = @delay.to_h if @delay
       result['primary'] = @primary unless @primary.nil?
@@ -1248,9 +1508,12 @@ module MockServer
 
       messages_data = data['messages']
       messages = messages_data&.map { |m| WebSocketMessage.from_hash(m) }
+      matchers_data = data['matchers']
+      matchers = matchers_data&.map { |m| WebSocketFrameMatcher.from_hash(m) }
       new(
         subprotocol:      data['subprotocol'],
         messages:         messages,
+        matchers:         matchers,
         close_connection: data['closeConnection'],
         delay:            Delay.from_hash(data['delay']),
         primary:          data['primary']
@@ -1259,16 +1522,21 @@ module MockServer
   end
 
   class GrpcStreamMessage
-    attr_accessor :json, :delay
+    # template_type marks the message +json+ as a response template rendered by the
+    # named engine (VELOCITY / JAVASCRIPT / MUSTACHE), mirroring the server
+    # GrpcStreamResponseDTO / GrpcBidiResponseDTO message +templateType+.
+    attr_accessor :json, :template_type, :delay
 
-    def initialize(json: nil, delay: nil)
+    def initialize(json: nil, template_type: nil, delay: nil)
       @json = json
+      @template_type = template_type
       @delay = delay
     end
 
     def to_h
       result = {}
       result['json'] = @json unless @json.nil?
+      result['templateType'] = @template_type unless @template_type.nil?
       result['delay'] = @delay.to_h if @delay
       result
     end
@@ -1277,8 +1545,9 @@ module MockServer
       return nil if data.nil?
 
       new(
-        json:  data['json'],
-        delay: Delay.from_hash(data['delay'])
+        json:          data['json'],
+        template_type: data['templateType'],
+        delay:         Delay.from_hash(data['delay'])
       )
     end
   end
@@ -1547,13 +1816,20 @@ module MockServer
   end
 
   class HttpChaosProfile
+    # graphql_errors / graphql_error_message / graphql_error_code /
+    # graphql_nullify_data carry the GraphQL fault-injection knobs from the server
+    # HttpChaosProfileDTO: when graphqlErrors is set the mocked GraphQL response is
+    # rewritten to carry an "errors" array (message/code from graphqlErrorMessage /
+    # graphqlErrorCode) and, when graphqlNullifyData is true, a null "data" field.
     attr_accessor :error_status, :error_probability, :drop_connection_probability,
                   :retry_after, :latency, :seed, :succeed_first, :fail_request_count,
                   :outage_after_millis, :outage_duration_millis,
                   :truncate_body_at_fraction, :malformed_body,
                   :slow_response_chunk_size, :slow_response_chunk_delay,
                   :quota_name, :quota_limit, :quota_window_millis, :quota_error_status,
-                  :degradation_ramp_millis
+                  :degradation_ramp_millis,
+                  :graphql_errors, :graphql_error_message, :graphql_error_code,
+                  :graphql_nullify_data
 
     def initialize(error_status: nil, error_probability: nil, drop_connection_probability: nil,
                    retry_after: nil, latency: nil, seed: nil, succeed_first: nil, fail_request_count: nil,
@@ -1561,7 +1837,9 @@ module MockServer
                    truncate_body_at_fraction: nil, malformed_body: nil,
                    slow_response_chunk_size: nil, slow_response_chunk_delay: nil,
                    quota_name: nil, quota_limit: nil, quota_window_millis: nil, quota_error_status: nil,
-                   degradation_ramp_millis: nil)
+                   degradation_ramp_millis: nil,
+                   graphql_errors: nil, graphql_error_message: nil, graphql_error_code: nil,
+                   graphql_nullify_data: nil)
       @error_status = error_status
       @error_probability = error_probability
       @drop_connection_probability = drop_connection_probability
@@ -1581,6 +1859,10 @@ module MockServer
       @quota_window_millis = quota_window_millis
       @quota_error_status = quota_error_status
       @degradation_ramp_millis = degradation_ramp_millis
+      @graphql_errors = graphql_errors
+      @graphql_error_message = graphql_error_message
+      @graphql_error_code = graphql_error_code
+      @graphql_nullify_data = graphql_nullify_data
     end
 
     def to_h
@@ -1603,7 +1885,11 @@ module MockServer
         'quotaLimit'                 => @quota_limit,
         'quotaWindowMillis'          => @quota_window_millis,
         'quotaErrorStatus'           => @quota_error_status,
-        'degradationRampMillis'      => @degradation_ramp_millis
+        'degradationRampMillis'      => @degradation_ramp_millis,
+        'graphqlErrors'              => @graphql_errors,
+        'graphqlErrorMessage'        => @graphql_error_message,
+        'graphqlErrorCode'           => @graphql_error_code,
+        'graphqlNullifyData'         => @graphql_nullify_data
       })
     end
 
@@ -1629,7 +1915,11 @@ module MockServer
         quota_limit:                 data['quotaLimit'],
         quota_window_millis:         data['quotaWindowMillis'],
         quota_error_status:          data['quotaErrorStatus'],
-        degradation_ramp_millis:     data['degradationRampMillis']
+        degradation_ramp_millis:     data['degradationRampMillis'],
+        graphql_errors:              data['graphqlErrors'],
+        graphql_error_message:       data['graphqlErrorMessage'],
+        graphql_error_code:          data['graphqlErrorCode'],
+        graphql_nullify_data:        data['graphqlNullifyData']
       )
     end
   end
@@ -1884,34 +2174,230 @@ module MockServer
     end
   end
 
+  # Per-expectation rate limit (org.mockserver.model.RateLimit). When the counter
+  # keyed by +name+ (or the expectation id when +name+ is nil) exceeds the
+  # configured limit, the server returns +error_status+ (default 429).
+  #
+  # +algorithm+ is the wire enum value: "fixed_window" (default) or
+  # "token_bucket" (the server serialises it lower-case). FIXED_WINDOW uses
+  # +limit+ / +window_millis+; TOKEN_BUCKET uses +burst+ / +refill_per_second+.
+  class RateLimit
+    attr_accessor :name, :algorithm, :limit, :window_millis, :burst,
+                  :refill_per_second, :error_status, :retry_after
+
+    def initialize(name: nil, algorithm: nil, limit: nil, window_millis: nil, burst: nil,
+                   refill_per_second: nil, error_status: nil, retry_after: nil)
+      @name = name
+      @algorithm = algorithm
+      @limit = limit
+      @window_millis = window_millis
+      @burst = burst
+      @refill_per_second = refill_per_second
+      @error_status = error_status
+      @retry_after = retry_after
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'name'            => @name,
+        'algorithm'       => @algorithm,
+        'limit'           => @limit,
+        'windowMillis'    => @window_millis,
+        'burst'           => @burst,
+        'refillPerSecond' => @refill_per_second,
+        'errorStatus'     => @error_status,
+        'retryAfter'      => @retry_after
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        name:              data['name'],
+        algorithm:         data['algorithm'],
+        limit:             data['limit'],
+        window_millis:     data['windowMillis'],
+        burst:             data['burst'],
+        refill_per_second: data['refillPerSecond'],
+        error_status:      data['errorStatus'],
+        retry_after:       data['retryAfter']
+      )
+    end
+
+    def self.fixed_window(limit, window_millis, name: nil)
+      new(name: name, algorithm: 'fixed_window', limit: limit, window_millis: window_millis)
+    end
+
+    def self.token_bucket(burst, refill_per_second, name: nil)
+      new(name: name, algorithm: 'token_bucket', burst: burst, refill_per_second: refill_per_second)
+    end
+  end
+
+  # A single expectation-level capture rule (org.mockserver.model.CaptureRule):
+  # extract a value from the matched request via +source+/+expression+ and store
+  # it under the +into+ key for use by later actions/templates.
+  #
+  # +source+ is the wire enum value, one of: "jsonPath", "xpath", "header",
+  # "queryStringParameter", "cookie", "pathParameter".
+  class CaptureRule
+    attr_accessor :source, :expression, :into
+
+    def initialize(source: nil, expression: nil, into: nil)
+      @source = source
+      @expression = expression
+      @into = into
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'source'     => @source,
+        'expression' => @expression,
+        'into'       => @into
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        source:     data['source'],
+        expression: data['expression'],
+        into:       data['into']
+      )
+    end
+  end
+
+  # Forward-and-validate action (org.mockserver.model.HttpForwardValidateAction):
+  # forwards the request to +host+/+port+ (+scheme+) and validates the request
+  # and/or response against the OpenAPI +spec_url_or_payload+.
+  #
+  # +validation_mode+ is the wire enum value "STRICT" (default) or "LOG_ONLY".
+  class HttpForwardValidateAction
+    attr_accessor :spec_url_or_payload, :host, :port, :scheme,
+                  :validate_request, :validate_response, :validation_mode,
+                  :delay, :primary
+
+    def initialize(spec_url_or_payload: nil, host: nil, port: nil, scheme: nil,
+                   validate_request: nil, validate_response: nil, validation_mode: nil,
+                   delay: nil, primary: nil)
+      @spec_url_or_payload = spec_url_or_payload
+      @host = host
+      @port = port
+      @scheme = scheme
+      @validate_request = validate_request
+      @validate_response = validate_response
+      @validation_mode = validation_mode
+      @delay = delay
+      @primary = primary
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'specUrlOrPayload' => @spec_url_or_payload,
+        'host'             => @host,
+        'port'             => @port,
+        'scheme'           => @scheme,
+        'validateRequest'  => @validate_request,
+        'validateResponse' => @validate_response,
+        'validationMode'   => @validation_mode,
+        'delay'            => @delay&.to_h,
+        'primary'          => @primary
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        spec_url_or_payload: data['specUrlOrPayload'],
+        host:                data['host'],
+        port:                data['port'],
+        scheme:              data['scheme'],
+        validate_request:    data['validateRequest'],
+        validate_response:   data['validateResponse'],
+        validation_mode:     data['validationMode'],
+        delay:               Delay.from_hash(data['delay']),
+        primary:             data['primary']
+      )
+    end
+  end
+
+  # Forward-with-fallback action (org.mockserver.model.HttpForwardWithFallback):
+  # forwards via +http_forward+, but returns +fallback_response+ when the
+  # upstream responds with one of +fallback_on_status_codes+ or (when
+  # +fallback_on_timeout+ is true) times out.
+  class HttpForwardWithFallback
+    attr_accessor :http_forward, :fallback_response, :fallback_on_status_codes,
+                  :fallback_on_timeout, :delay, :primary
+
+    def initialize(http_forward: nil, fallback_response: nil, fallback_on_status_codes: nil,
+                   fallback_on_timeout: nil, delay: nil, primary: nil)
+      @http_forward = http_forward
+      @fallback_response = fallback_response
+      @fallback_on_status_codes = fallback_on_status_codes
+      @fallback_on_timeout = fallback_on_timeout
+      @delay = delay
+      @primary = primary
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'httpForward'          => @http_forward&.to_h,
+        'fallbackResponse'     => @fallback_response&.to_h,
+        'fallbackOnStatusCodes' => @fallback_on_status_codes,
+        'fallbackOnTimeout'    => @fallback_on_timeout,
+        'delay'                => @delay&.to_h,
+        'primary'              => @primary
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        http_forward:             HttpForward.from_hash(data['httpForward']),
+        fallback_response:        HttpResponse.from_hash(data['fallbackResponse']),
+        fallback_on_status_codes: data['fallbackOnStatusCodes'],
+        fallback_on_timeout:      data['fallbackOnTimeout'],
+        delay:                    Delay.from_hash(data['delay']),
+        primary:                  data['primary']
+      )
+    end
+  end
+
   class Expectation
     attr_accessor :id, :priority, :percentage, :http_request, :http_response,
                   :http_response_template, :http_response_class_callback,
                   :http_response_object_callback, :http_forward,
                   :http_forward_template, :http_forward_class_callback,
                   :http_forward_object_callback, :http_override_forwarded_request,
-                  :http_error, :times, :time_to_live, :chaos,
-                  :http_sse_response, :http_websocket_response,
+                  :http_error, :times, :time_to_live, :chaos, :rate_limit,
+                  :http_sse_response, :http_llm_response, :http_websocket_response,
                   :grpc_stream_response, :grpc_bidi_response,
                   :binary_response, :dns_response,
+                  :http_forward_with_fallback, :http_forward_validate_action,
                   :before_actions, :after_actions,
                   :http_responses, :response_mode, :response_weights, :switch_after,
-                  :cross_protocol_scenarios, :steps,
-                  :scenario_name, :scenario_state, :new_scenario_state
+                  :cross_protocol_scenarios, :steps, :capture, :namespace,
+                  :scenario_name, :scenario_state, :new_scenario_state, :timestamp
 
     def initialize(id: nil, priority: nil, percentage: nil, http_request: nil, http_response: nil,
                    http_response_template: nil, http_response_class_callback: nil,
                    http_response_object_callback: nil, http_forward: nil,
                    http_forward_template: nil, http_forward_class_callback: nil,
                    http_forward_object_callback: nil, http_override_forwarded_request: nil,
-                   http_error: nil, times: nil, time_to_live: nil, chaos: nil,
-                   http_sse_response: nil, http_websocket_response: nil,
+                   http_error: nil, times: nil, time_to_live: nil, chaos: nil, rate_limit: nil,
+                   http_sse_response: nil, http_llm_response: nil, http_websocket_response: nil,
                    grpc_stream_response: nil, grpc_bidi_response: nil,
                    binary_response: nil, dns_response: nil,
+                   http_forward_with_fallback: nil, http_forward_validate_action: nil,
                    before_actions: nil, after_actions: 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)
+                   capture: nil, namespace: nil,
+                   scenario_name: nil, scenario_state: nil, new_scenario_state: nil,
+                   timestamp: nil)
       @id = id
       @priority = priority
       @percentage = percentage
@@ -1932,12 +2418,16 @@ module MockServer
       @times = times
       @time_to_live = time_to_live
       @chaos = chaos
+      @rate_limit = rate_limit
       @http_sse_response = http_sse_response
+      @http_llm_response = http_llm_response
       @http_websocket_response = http_websocket_response
       @grpc_stream_response = grpc_stream_response
       @grpc_bidi_response = grpc_bidi_response
       @binary_response = binary_response
       @dns_response = dns_response
+      @http_forward_with_fallback = http_forward_with_fallback
+      @http_forward_validate_action = http_forward_validate_action
       @before_actions = before_actions
       @after_actions = after_actions
       @http_responses = http_responses
@@ -1946,9 +2436,12 @@ module MockServer
       @switch_after = switch_after
       @cross_protocol_scenarios = cross_protocol_scenarios
       @steps = steps
+      @capture = capture
+      @namespace = namespace
       @scenario_name = scenario_name
       @scenario_state = scenario_state
       @new_scenario_state = new_scenario_state
+      @timestamp = timestamp
     end
 
     # Set the response class-callback action. Accepts either a fully-qualified
@@ -1996,8 +2489,11 @@ module MockServer
         'httpForwardClassCallback'     => @http_forward_class_callback&.to_h,
         'httpForwardObjectCallback'    => @http_forward_object_callback&.to_h,
         'httpOverrideForwardedRequest' => @http_override_forwarded_request&.to_h,
+        'httpForwardValidateAction'    => @http_forward_validate_action&.to_h,
+        'httpForwardWithFallback'      => @http_forward_with_fallback&.to_h,
         'httpError'                    => @http_error&.to_h,
         'httpSseResponse'              => @http_sse_response&.to_h,
+        'httpLlmResponse'              => MockServer.serialize_value(@http_llm_response),
         'httpWebSocketResponse'        => @http_websocket_response&.to_h,
         'grpcStreamResponse'           => @grpc_stream_response&.to_h,
         'grpcBidiResponse'             => @grpc_bidi_response&.to_h,
@@ -2011,12 +2507,16 @@ module MockServer
         'switchAfter'                  => @switch_after,
         'crossProtocolScenarios'       => @cross_protocol_scenarios&.map(&:to_h),
         'steps'                        => @steps&.map(&:to_h),
+        'capture'                      => @capture&.map(&:to_h),
+        'rateLimit'                    => @rate_limit&.to_h,
+        'namespace'                    => @namespace,
         'times'                        => @times&.to_h,
         'timeToLive'                   => @time_to_live&.to_h,
         'chaos'                        => @chaos&.to_h,
         'scenarioName'                 => @scenario_name,
         'scenarioState'                => @scenario_state,
-        'newScenarioState'             => @new_scenario_state
+        'newScenarioState'             => @new_scenario_state,
+        'timestamp'                    => @timestamp
       })
     end
 
@@ -2051,8 +2551,11 @@ module MockServer
         http_forward_class_callback:     HttpClassCallback.from_hash(data['httpForwardClassCallback']),
         http_forward_object_callback:    HttpObjectCallback.from_hash(data['httpForwardObjectCallback']),
         http_override_forwarded_request: HttpOverrideForwardedRequest.from_hash(data['httpOverrideForwardedRequest']),
+        http_forward_validate_action:    HttpForwardValidateAction.from_hash(data['httpForwardValidateAction']),
+        http_forward_with_fallback:      HttpForwardWithFallback.from_hash(data['httpForwardWithFallback']),
         http_error:                      HttpError.from_hash(data['httpError']),
         http_sse_response:               HttpSseResponse.from_hash(data['httpSseResponse']),
+        http_llm_response:               data['httpLlmResponse'],
         http_websocket_response:         HttpWebSocketResponse.from_hash(data['httpWebSocketResponse']),
         grpc_stream_response:            GrpcStreamResponse.from_hash(data['grpcStreamResponse']),
         grpc_bidi_response:              GrpcBidiResponse.from_hash(data['grpcBidiResponse']),
@@ -2066,12 +2569,16 @@ module MockServer
         switch_after:                    data['switchAfter'],
         cross_protocol_scenarios:        data['crossProtocolScenarios']&.map { |c| CrossProtocolScenario.from_hash(c) },
         steps:                           data['steps']&.map { |s| ExpectationStep.from_hash(s) },
+        capture:                         data['capture']&.map { |c| CaptureRule.from_hash(c) },
+        rate_limit:                      RateLimit.from_hash(data['rateLimit']),
+        namespace:                       data['namespace'],
         times:                           Times.from_hash(data['times']),
         time_to_live:                    TimeToLive.from_hash(data['timeToLive']),
         chaos:                           HttpChaosProfile.from_hash(data['chaos']),
         scenario_name:                   data['scenarioName'],
         scenario_state:                  data['scenarioState'],
-        new_scenario_state:              data['newScenarioState']
+        new_scenario_state:              data['newScenarioState'],
+        timestamp:                       data['timestamp']
       )
     end
   end

data/lib/mockserver/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mockserver-client
 version: !ruby/object:Gem::Version
-  version: 7.3.0
+  version: 7.4.0
 platform: ruby
 authors:
 - James Bloom
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger