mockserver-client 7.2.0 → 7.4.0

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
@@ -2368,39 +2875,262 @@ module MockServer
     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.
+  # A declarative named load shape that expands into ordinary {LoadStage} stages.
+  # Set this as a {LoadProfile}'s +shape+ instead of an explicit +stages+ list;
+  # only the parameters its +type+ needs are read. +type+ is one of +SPIKE+,
+  # +STAIRS+ or +RAMP_HOLD+; +metric+ (+VU+ or +RATE+) selects what the shape
+  # drives.
+  class LoadShape
+    attr_accessor :type, :metric, :curve, :baseline, :peak, :ramp_up_millis,
+                  :hold_millis, :ramp_down_millis, :recovery_hold_millis,
+                  :start, :step, :steps, :step_duration_millis, :target, :ramp_millis
+
+    def initialize(type:, metric: nil, curve: nil, baseline: nil, peak: nil,
+                   ramp_up_millis: nil, hold_millis: nil, ramp_down_millis: nil,
+                   recovery_hold_millis: nil, start: nil, step: nil, steps: nil,
+                   step_duration_millis: nil, target: nil, ramp_millis: nil)
+      @type = type
+      @metric = metric
+      @curve = curve
+      @baseline = baseline
+      @peak = peak
+      @ramp_up_millis = ramp_up_millis
+      @hold_millis = hold_millis
+      @ramp_down_millis = ramp_down_millis
+      @recovery_hold_millis = recovery_hold_millis
+      @start = start
+      @step = step
+      @steps = steps
+      @step_duration_millis = step_duration_millis
+      @target = target
+      @ramp_millis = ramp_millis
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'type'               => @type,
+        'metric'             => @metric,
+        'curve'              => @curve,
+        'baseline'           => @baseline,
+        'peak'               => @peak,
+        'rampUpMillis'       => @ramp_up_millis,
+        'holdMillis'         => @hold_millis,
+        'rampDownMillis'     => @ramp_down_millis,
+        'recoveryHoldMillis' => @recovery_hold_millis,
+        'start'              => @start,
+        'step'               => @step,
+        'steps'              => @steps,
+        'stepDurationMillis' => @step_duration_millis,
+        'target'             => @target,
+        'rampMillis'         => @ramp_millis
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        type:                 data['type'],
+        metric:               data['metric'],
+        curve:                data['curve'],
+        baseline:             data['baseline'],
+        peak:                 data['peak'],
+        ramp_up_millis:       data['rampUpMillis'],
+        hold_millis:          data['holdMillis'],
+        ramp_down_millis:     data['rampDownMillis'],
+        recovery_hold_millis: data['recoveryHoldMillis'],
+        start:                data['start'],
+        step:                 data['step'],
+        steps:                data['steps'],
+        step_duration_millis: data['stepDurationMillis'],
+        target:               data['target'],
+        ramp_millis:          data['rampMillis']
+      )
+    end
+  end
+
+  # The traffic-shaping profile of a load scenario: EITHER 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, OR a single
+  # named {LoadShape} that expands into stages. Set one, not both; if both are
+  # set the explicit stages win. The total run length is the sum of the stage
+  # durations.
   class LoadProfile
-    attr_accessor :stages
+    attr_accessor :stages, :shape
 
-    def initialize(stages: [])
-      @stages = stages || []
+    def initialize(stages: nil, shape: nil)
+      @stages = stages
+      @shape = shape
     end
 
     def to_h
-      { 'stages' => @stages.map(&:to_h) }
+      MockServer.strip_none({
+        'stages' => @stages.nil? ? nil : @stages.map(&:to_h),
+        'shape'  => @shape&.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) })
+      stages_data = data['stages']
+      new(
+        stages: stages_data ? stages_data.map { |s| LoadStage.from_hash(s) } : nil,
+        shape:  LoadShape.from_hash(data['shape'])
+      )
+    end
+  end
+
+  # A declarative cross-step capture / correlation rule: extracts a value from a
+  # step's response and binds it to +name+, which a later step in the same
+  # iteration can reference from its templated request fields. +source+ is one of
+  # +BODY_JSONPATH+, +HEADER+ or +BODY_REGEX+; +expression+ drives the extraction;
+  # +default_value+ is an optional fallback when extraction yields nothing.
+  class LoadCapture
+    attr_accessor :name, :source, :expression, :default_value
+
+    def initialize(name:, source:, expression:, default_value: nil)
+      @name = name
+      @source = source
+      @expression = expression
+      @default_value = default_value
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'name'         => @name,
+        'source'       => @source,
+        'expression'   => @expression,
+        'defaultValue' => @default_value
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        name:          data['name'],
+        source:        data['source'],
+        expression:    data['expression'],
+        default_value: data['defaultValue']
+      )
+    end
+  end
+
+  # An in-run pass/fail threshold for a load scenario: a per-run +metric+ compared
+  # with +comparator+ against +threshold+. All thresholds must hold for the run
+  # verdict to be +PASS+; any breach makes it +FAIL+. +metric+ is one of
+  # +LATENCY_P50+/+LATENCY_P95+/+LATENCY_P99+/+LATENCY_P999+/+ERROR_RATE+/
+  # +THROUGHPUT_RPS+; +comparator+ is one of +LESS_THAN+/+LESS_THAN_OR_EQUAL+/
+  # +GREATER_THAN+/+GREATER_THAN_OR_EQUAL+.
+  class LoadThreshold
+    attr_accessor :metric, :comparator, :threshold
+
+    def initialize(metric:, comparator:, threshold:)
+      @metric = metric
+      @comparator = comparator
+      @threshold = threshold
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'metric'     => @metric,
+        'comparator' => @comparator,
+        'threshold'  => @threshold
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        metric:     data['metric'],
+        comparator: data['comparator'],
+        threshold:  data['threshold']
+      )
+    end
+  end
+
+  # Adaptive iteration pacing (think-time) for a load scenario: a target
+  # per-virtual-user iteration cycle time. +mode+ is one of +NONE+,
+  # +CONSTANT_PACING+ (+value+ is the target cycle in milliseconds) or
+  # +CONSTANT_THROUGHPUT+ (+value+ is the target iterations/second per VU).
+  class LoadPacing
+    attr_accessor :mode, :value
+
+    def initialize(mode:, value: nil)
+      @mode = mode
+      @value = value
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'mode'  => @mode,
+        'value' => @value
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        mode:  data['mode'],
+        value: data['value']
+      )
+    end
+  end
+
+  # Parameterized test data (a data feeder) for a load scenario: an inline dataset
+  # from which one row is selected per iteration and exposed to the templated
+  # request. Supply EITHER +rows+ (inline list of column-name to value maps, the
+  # primary form) OR +data+ + +format+ (raw CSV/JSON parsed server-side).
+  # +strategy+ (+CIRCULAR+, +RANDOM+ or +SEQUENTIAL+) chooses how a row is picked.
+  class LoadFeeder
+    attr_accessor :rows, :data, :format, :strategy
+
+    def initialize(rows: nil, data: nil, format: nil, strategy: nil)
+      @rows = rows
+      @data = data
+      @format = format
+      @strategy = strategy
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'rows'     => @rows,
+        'data'     => @data,
+        'format'   => @format,
+        'strategy' => @strategy
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        rows:     data['rows'],
+        data:     data['data'],
+        format:   data['format'],
+        strategy: data['strategy']
+      )
     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.
+  # +captures+ binds values from this step's response for later steps in the same
+  # iteration; +weight+ is the relative selection weight when the scenario's
+  # +step_selection+ is +WEIGHTED+.
   class LoadStep
-    attr_accessor :name, :labels, :think_time, :request
+    attr_accessor :name, :labels, :think_time, :request, :captures, :weight
 
-    def initialize(request:, name: nil, labels: nil, think_time: nil)
+    def initialize(request:, name: nil, labels: nil, think_time: nil, captures: nil, weight: nil)
       @request = request
       @name = name
       @labels = labels
       @think_time = think_time
+      @captures = captures
+      @weight = weight
     end
 
     def to_h
@@ -2408,18 +3138,23 @@ module MockServer
         'name'      => @name,
         'labels'    => @labels,
         'thinkTime' => @think_time&.to_h,
-        'request'   => @request&.to_h
+        'request'   => @request&.to_h,
+        'captures'  => @captures.nil? ? nil : @captures.map(&:to_h),
+        'weight'    => @weight
       })
     end
 
     def self.from_hash(data)
       return nil if data.nil?
 
+      captures_data = data['captures']
       new(
         name:       data['name'],
         labels:     data['labels'],
         think_time: Delay.from_hash(data['thinkTime']),
-        request:    HttpRequest.from_hash(data['request'])
+        request:    HttpRequest.from_hash(data['request']),
+        captures:   captures_data ? captures_data.map { |c| LoadCapture.from_hash(c) } : nil,
+        weight:     data['weight']
       )
     end
   end
@@ -2427,11 +3162,18 @@ module MockServer
   # 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.
+  # +thresholds+ are in-run pass/fail checks; +abort_on_fail+/+abort_grace_millis+
+  # control early-abort behaviour; +pacing+ shapes inter-iteration timing; +feeder+
+  # supplies per-iteration data; +step_selection+ (+SEQUENTIAL+ or +WEIGHTED+)
+  # controls how each iteration selects steps.
   class LoadScenario
-    attr_accessor :name, :template_type, :labels, :max_requests, :start_delay_millis, :profile, :steps
+    attr_accessor :name, :template_type, :labels, :max_requests, :start_delay_millis,
+                  :profile, :steps, :thresholds, :abort_on_fail, :abort_grace_millis,
+                  :pacing, :feeder, :step_selection
 
     def initialize(name:, profile:, steps:, template_type: nil, labels: nil, max_requests: nil,
-                   start_delay_millis: nil)
+                   start_delay_millis: nil, thresholds: nil, abort_on_fail: nil,
+                   abort_grace_millis: nil, pacing: nil, feeder: nil, step_selection: nil)
       @name = name
       @profile = profile
       @steps = steps
@@ -2439,6 +3181,12 @@ module MockServer
       @labels = labels
       @max_requests = max_requests
       @start_delay_millis = start_delay_millis
+      @thresholds = thresholds
+      @abort_on_fail = abort_on_fail
+      @abort_grace_millis = abort_grace_millis
+      @pacing = pacing
+      @feeder = feeder
+      @step_selection = step_selection
     end
 
     def to_h
@@ -2448,6 +3196,12 @@ module MockServer
         'labels'           => @labels,
         'maxRequests'      => @max_requests,
         'startDelayMillis' => @start_delay_millis,
+        'thresholds'       => @thresholds.nil? ? nil : @thresholds.map(&:to_h),
+        'abortOnFail'      => @abort_on_fail,
+        'abortGraceMillis' => @abort_grace_millis,
+        'pacing'           => @pacing&.to_h,
+        'feeder'           => @feeder&.to_h,
+        'stepSelection'    => @step_selection,
         'profile'          => @profile&.to_h,
         'steps'            => @steps&.map(&:to_h)
       })
@@ -2457,12 +3211,19 @@ module MockServer
       return nil if data.nil?
 
       steps_data = data['steps']
+      thresholds_data = data['thresholds']
       new(
         name:               data['name'],
         template_type:      data['templateType'],
         labels:             data['labels'],
         max_requests:       data['maxRequests'],
         start_delay_millis: data['startDelayMillis'],
+        thresholds:         thresholds_data ? thresholds_data.map { |t| LoadThreshold.from_hash(t) } : nil,
+        abort_on_fail:      data['abortOnFail'],
+        abort_grace_millis: data['abortGraceMillis'],
+        pacing:             LoadPacing.from_hash(data['pacing']),
+        feeder:             LoadFeeder.from_hash(data['feeder']),
+        step_selection:     data['stepSelection'],
         profile:            LoadProfile.from_hash(data['profile']),
         steps:              steps_data ? steps_data.map { |s| LoadStep.from_hash(s) } : nil
       )