mockserver-client 6.0.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52c92809897fcdfe317afdab740419e5bef114b46482df4a9756821916bd4a73
-  data.tar.gz: 8b8ee1a6a5c341edecbe70a90ccb1dda4c481162eca2f30e83ee121beaa656d5
+  metadata.gz: 97517808097f2af911f727db3decbafcab8454285325b141ad5899a53af70be1
+  data.tar.gz: 60b5bff4ef90906b229064f23b1593bec547dc428b9d93c61b387d29a2615dd0
 SHA512:
-  metadata.gz: 476994411a429882a93e0fe6852527b14ac9ce60ffc2ac328f0536eef2adee69f7c2ce8061bc8dfda7cc32869fe0e227ed3f5e979a3a1e1513c1ae3540be2f27
-  data.tar.gz: 94828363b6159101e0288c15b604e7e9acf19716f67efb5edf56f591a79946aaf987ed2c32f079f421d3ad74045d61fa0aac62b93820d162df3299b284108cd7
+  metadata.gz: d91bb153b43f523a60812dc4f100fb1e7deb04c6ddc6353266d632f8f074df3683e0292d9cd77efb464034e618d4e4d63fafc3b11b333c009098cc5b48b49684
+  data.tar.gz: 7484d0dfa3e38edb7ad83dd2bb760a2b17dd2c4f474538e5673630f9fd28c056f4f7c2d2389ddbda2aa56f43eb052915cb4b5a432b4f15e7594e4db54cf92c9f

data/lib/mockserver/client.rb

@@ -148,6 +148,118 @@ module MockServer
       close
     end
 
+    # -------------------------------------------------------------------
+    # Clock Control
+    # -------------------------------------------------------------------
+
+    # Freeze the server clock at the given ISO-8601 instant.
+    # If +instant+ is nil, the clock freezes at the current real time.
+    # @param instant [String, nil] ISO-8601 instant (e.g. "2025-01-15T09:30:00Z")
+    # @return [Hash] response with status, currentInstant, currentEpochMillis
+    def freeze_clock(instant = nil)
+      payload = { 'action' => 'freeze' }
+      payload['instant'] = instant if instant
+      body = JSON.generate(payload)
+      status, response_body = request('PUT', '/mockserver/clock', body)
+      if status >= 400
+        raise Error, "Failed to freeze clock (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Advance the frozen clock by +duration_millis+ milliseconds.
+    # @param duration_millis [Integer]
+    # @return [Hash] response with status, currentInstant, currentEpochMillis
+    def advance_clock(duration_millis)
+      body = JSON.generate({ 'action' => 'advance', 'durationMillis' => duration_millis })
+      status, response_body = request('PUT', '/mockserver/clock', body)
+      if status >= 400
+        raise Error, "Failed to advance clock (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Reset the server clock to real wall-clock time.
+    # @return [Hash] response with status, currentInstant, currentEpochMillis
+    def reset_clock
+      body = JSON.generate({ 'action' => 'reset' })
+      status, response_body = request('PUT', '/mockserver/clock', body)
+      if status >= 400
+        raise Error, "Failed to reset clock (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Query the current clock status.
+    # @return [Hash] with currentInstant, currentEpochMillis, frozen
+    def clock_status
+      status, response_body = request('GET', '/mockserver/clock')
+      if status >= 400
+        raise Error, "Failed to get clock status (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Register a service-scoped HTTP chaos profile for an upstream host. The profile
+    # is applied to every matched forward expectation to that host that does not
+    # define its own chaos (an expectation's own chaos always wins). The host is
+    # matched case-insensitively, ignoring any +:port+.
+    # @param host [String] the upstream host to break
+    # @param chaos [HttpChaosProfile] the chaos profile to apply
+    # @param ttl_millis [Integer, nil] if set, the chaos auto-reverts after this many ms
+    # @return [Hash] response with status and host
+    def set_service_chaos(host, chaos, ttl_millis = nil)
+      payload = { 'host' => host, 'chaos' => chaos.to_h }
+      payload['ttlMillis'] = ttl_millis unless ttl_millis.nil?
+      body = JSON.generate(payload)
+      status, response_body = request('PUT', '/mockserver/serviceChaos', body)
+      if status >= 400
+        raise Error, "Failed to set service chaos (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Remove the service-scoped chaos profile registered for +host+.
+    # @param host [String]
+    # @return [Hash]
+    def remove_service_chaos(host)
+      body = JSON.generate({ 'host' => host, 'remove' => true })
+      status, response_body = request('PUT', '/mockserver/serviceChaos', body)
+      if status >= 400
+        raise Error, "Failed to remove service chaos (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Clear all service-scoped chaos profiles.
+    # @return [Hash]
+    def clear_service_chaos
+      body = JSON.generate({ 'clear' => true })
+      status, response_body = request('PUT', '/mockserver/serviceChaos', body)
+      if status >= 400
+        raise Error, "Failed to clear service chaos (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
+    # Query the current service-scoped chaos registrations.
+    # @return [Hash] of the form { "services" => { host => profile, ... } }
+    def service_chaos_status
+      status, response_body = request('GET', '/mockserver/serviceChaos')
+      if status >= 400
+        raise Error, "Failed to get service chaos (status=#{status}): #{response_body}"
+      end
+
+      response_body && !response_body.empty? ? JSON.parse(response_body) : {}
+    end
+
     # Verify that a request was received.
     # @param request [HttpRequest]
     # @param times [VerificationTimes, nil]

data/lib/mockserver/forward_chain_expectation.rb

@@ -29,6 +29,14 @@ module MockServer
       self
     end
 
+    # Set a declarative HTTP chaos/fault injection profile.
+    # @param chaos [HttpChaosProfile]
+    # @return [self]
+    def with_chaos(chaos)
+      @expectation.chaos = chaos
+      self
+    end
+
     # Set the response action. Accepts an HttpResponse, HttpTemplate, or
     # a Proc/lambda callback.
     # @param response_or_callback [HttpResponse, HttpTemplate, Proc]
@@ -113,5 +121,92 @@ module MockServer
       @expectation.http_websocket_response = websocket_response
       @client.upsert(@expectation)
     end
+
+    # Set a gRPC stream response action.
+    # @param grpc_stream_response [GrpcStreamResponse]
+    # @return [Array<Expectation>]
+    def respond_with_grpc_stream(grpc_stream_response)
+      unless grpc_stream_response.is_a?(GrpcStreamResponse)
+        raise TypeError,
+              "Expected GrpcStreamResponse, got #{grpc_stream_response.class.name}"
+      end
+      @expectation.grpc_stream_response = grpc_stream_response
+      @client.upsert(@expectation)
+    end
+
+    # Set a gRPC bidi streaming response action.
+    # @param grpc_bidi_response [GrpcBidiResponse]
+    # @return [Array<Expectation>]
+    def respond_with_grpc_bidi(grpc_bidi_response)
+      unless grpc_bidi_response.is_a?(GrpcBidiResponse)
+        raise TypeError,
+              "Expected GrpcBidiResponse, got #{grpc_bidi_response.class.name}"
+      end
+      @expectation.grpc_bidi_response = grpc_bidi_response
+      @client.upsert(@expectation)
+    end
+
+    # Set a binary response action.
+    # @param binary_response [BinaryResponse]
+    # @return [Array<Expectation>]
+    def respond_with_binary(binary_response)
+      unless binary_response.is_a?(BinaryResponse)
+        raise TypeError,
+              "Expected BinaryResponse, got #{binary_response.class.name}"
+      end
+      @expectation.binary_response = binary_response
+      @client.upsert(@expectation)
+    end
+
+    # Set a DNS response action.
+    # @param dns_response [DnsResponse]
+    # @return [Array<Expectation>]
+    def respond_with_dns(dns_response)
+      unless dns_response.is_a?(DnsResponse)
+        raise TypeError,
+              "Expected DnsResponse, got #{dns_response.class.name}"
+      end
+      @expectation.dns_response = dns_response
+      @client.upsert(@expectation)
+    end
+
+    # Set a forward template action.
+    # @param template [HttpTemplate]
+    # @return [Array<Expectation>]
+    def forward_with_template(template)
+      unless template.is_a?(HttpTemplate)
+        raise TypeError,
+              "Expected HttpTemplate, got #{template.class.name}"
+      end
+      @expectation.http_forward_template = template
+      @client.upsert(@expectation)
+    end
+
+    # Set a forward class callback action.
+    # @param class_callback [HttpClassCallback]
+    # @return [Array<Expectation>]
+    def forward_with_class_callback(class_callback)
+      unless class_callback.is_a?(HttpClassCallback)
+        raise TypeError,
+              "Expected HttpClassCallback, got #{class_callback.class.name}"
+      end
+      @expectation.http_forward_class_callback = class_callback
+      @client.upsert(@expectation)
+    end
+
+    # Set an ordered multi-action pipeline of steps.
+    #
+    # Exactly one step must have +responder: true+; that step produces the
+    # HTTP response. All other steps are side-effects executed in order.
+    # @param steps [Array<ExpectationStep>]
+    # @return [Array<Expectation>]
+    def with_steps(steps)
+      unless steps.is_a?(Array) && steps.all? { |s| s.is_a?(ExpectationStep) }
+        raise TypeError, 'Expected an Array of ExpectationStep objects'
+      end
+
+      @expectation.steps = steps
+      @client.upsert(@expectation)
+    end
   end
 end

data/lib/mockserver/models.rb

@@ -61,7 +61,27 @@ module MockServer
     'base_path'                      => 'basePath',
     'id_field'                       => 'idField',
     'id_strategy'                    => 'idStrategy',
-    'initial_data'                   => 'initialData'
+    'initial_data'                   => 'initialData',
+    'error_status'                   => 'errorStatus',
+    'error_probability'              => 'errorProbability',
+    'drop_connection_probability'    => 'dropConnectionProbability',
+    'retry_after'                    => 'retryAfter',
+    'succeed_first'                  => 'succeedFirst',
+    'fail_request_count'             => 'failRequestCount',
+    'outage_after_millis'            => 'outageAfterMillis',
+    'outage_duration_millis'         => 'outageDurationMillis',
+    'truncate_body_at_fraction'      => 'truncateBodyAtFraction',
+    'malformed_body'                 => 'malformedBody',
+    'slow_response_chunk_size'       => 'slowResponseChunkSize',
+    'slow_response_chunk_delay'      => 'slowResponseChunkDelay',
+    'quota_name'                     => 'quotaName',
+    'quota_limit'                    => 'quotaLimit',
+    'quota_window_millis'            => 'quotaWindowMillis',
+    'quota_error_status'             => 'quotaErrorStatus',
+    'degradation_ramp_millis'        => 'degradationRampMillis',
+    'http_class_callback'            => 'httpClassCallback',
+    'http_object_callback'           => 'httpObjectCallback',
+    'failure_policy'                 => 'failurePolicy'
   }.freeze
 
   REVERSE_FIELD_MAP = FIELD_MAP.invert.freeze
@@ -1146,14 +1166,396 @@ module MockServer
     end
   end
 
+  class GrpcStreamMessage
+    attr_accessor :json, :delay
+
+    def initialize(json: nil, delay: nil)
+      @json = json
+      @delay = delay
+    end
+
+    def to_h
+      result = {}
+      result['json'] = @json unless @json.nil?
+      result['delay'] = @delay.to_h if @delay
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        json:  data['json'],
+        delay: Delay.from_hash(data['delay'])
+      )
+    end
+  end
+
+  class GrpcStreamResponse
+    attr_accessor :status_name, :status_message, :headers, :messages,
+                  :close_connection, :delay, :primary
+
+    def initialize(status_name: nil, status_message: nil, headers: nil,
+                   messages: nil, close_connection: nil, delay: nil, primary: nil)
+      @status_name = status_name
+      @status_message = status_message
+      @headers = headers
+      @messages = messages
+      @close_connection = close_connection
+      @delay = delay
+      @primary = primary
+    end
+
+    def to_h
+      result = {}
+      result['statusName'] = @status_name unless @status_name.nil?
+      result['statusMessage'] = @status_message unless @status_message.nil?
+      result['headers'] = MockServer.serialize_key_multi_values(@headers) if @headers
+      result['messages'] = @messages&.map(&:to_h) if @messages
+      result['closeConnection'] = @close_connection unless @close_connection.nil?
+      result['delay'] = @delay.to_h if @delay
+      result['primary'] = @primary unless @primary.nil?
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      messages_data = data['messages']
+      messages = messages_data&.map { |m| GrpcStreamMessage.from_hash(m) }
+      new(
+        status_name:      data['statusName'],
+        status_message:   data['statusMessage'],
+        headers:          MockServer.deserialize_key_multi_values(data['headers']),
+        messages:         messages,
+        close_connection: data['closeConnection'],
+        delay:            Delay.from_hash(data['delay']),
+        primary:          data['primary']
+      )
+    end
+  end
+
+  class GrpcBidiRule
+    attr_accessor :match_json, :responses
+
+    def initialize(match_json: nil, responses: nil)
+      @match_json = match_json
+      @responses = responses
+    end
+
+    def to_h
+      result = {}
+      result['matchJson'] = @match_json unless @match_json.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| GrpcStreamMessage.from_hash(r) }
+      new(
+        match_json: data['matchJson'],
+        responses:  responses
+      )
+    end
+  end
+
+  class GrpcBidiResponse
+    attr_accessor :status_name, :status_message, :headers, :messages,
+                  :rules, :close_connection, :delay, :primary
+
+    def initialize(status_name: nil, status_message: nil, headers: nil,
+                   messages: nil, rules: nil, close_connection: nil, delay: nil, primary: nil)
+      @status_name = status_name
+      @status_message = status_message
+      @headers = headers
+      @messages = messages
+      @rules = rules
+      @close_connection = close_connection
+      @delay = delay
+      @primary = primary
+    end
+
+    def to_h
+      result = {}
+      result['statusName'] = @status_name unless @status_name.nil?
+      result['statusMessage'] = @status_message unless @status_message.nil?
+      result['headers'] = MockServer.serialize_key_multi_values(@headers) if @headers
+      result['messages'] = @messages&.map(&:to_h) if @messages
+      result['rules'] = @rules&.map(&:to_h) if @rules
+      result['closeConnection'] = @close_connection unless @close_connection.nil?
+      result['delay'] = @delay.to_h if @delay
+      result['primary'] = @primary unless @primary.nil?
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      messages_data = data['messages']
+      messages = messages_data&.map { |m| GrpcStreamMessage.from_hash(m) }
+      rules_data = data['rules']
+      rules = rules_data&.map { |r| GrpcBidiRule.from_hash(r) }
+      new(
+        status_name:      data['statusName'],
+        status_message:   data['statusMessage'],
+        headers:          MockServer.deserialize_key_multi_values(data['headers']),
+        messages:         messages,
+        rules:            rules,
+        close_connection: data['closeConnection'],
+        delay:            Delay.from_hash(data['delay']),
+        primary:          data['primary']
+      )
+    end
+  end
+
+  class BinaryResponse
+    attr_accessor :binary_data, :delay, :primary
+
+    def initialize(binary_data: nil, delay: nil, primary: nil)
+      @binary_data = binary_data
+      @delay = delay
+      @primary = primary
+    end
+
+    def to_h
+      result = {}
+      result['binaryData'] = @binary_data unless @binary_data.nil?
+      result['delay'] = @delay.to_h if @delay
+      result['primary'] = @primary unless @primary.nil?
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        binary_data: data['binaryData'],
+        delay:       Delay.from_hash(data['delay']),
+        primary:     data['primary']
+      )
+    end
+  end
+
+  class DnsRecord
+    attr_accessor :name, :type, :dns_class, :ttl, :value,
+                  :priority, :weight, :port
+
+    def initialize(name: nil, type: nil, dns_class: nil, ttl: nil,
+                   value: nil, priority: nil, weight: nil, port: nil)
+      @name = name
+      @type = type
+      @dns_class = dns_class
+      @ttl = ttl
+      @value = value
+      @priority = priority
+      @weight = weight
+      @port = port
+    end
+
+    def to_h
+      result = {}
+      result['name'] = @name unless @name.nil?
+      result['type'] = @type unless @type.nil?
+      result['dnsClass'] = @dns_class unless @dns_class.nil?
+      result['ttl'] = @ttl unless @ttl.nil?
+      result['value'] = @value unless @value.nil?
+      result['priority'] = @priority unless @priority.nil?
+      result['weight'] = @weight unless @weight.nil?
+      result['port'] = @port unless @port.nil?
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        name:      data['name'],
+        type:      data['type'],
+        dns_class: data['dnsClass'],
+        ttl:       data['ttl'],
+        value:     data['value'],
+        priority:  data['priority'],
+        weight:    data['weight'],
+        port:      data['port']
+      )
+    end
+
+    def self.a_record(name, ip)
+      new(name: name, type: 'A', value: ip)
+    end
+
+    def self.aaaa_record(name, ip)
+      new(name: name, type: 'AAAA', value: ip)
+    end
+
+    def self.cname_record(name, cname)
+      new(name: name, type: 'CNAME', value: cname)
+    end
+
+    def self.mx_record(name, priority, exchange)
+      new(name: name, type: 'MX', priority: priority, value: exchange)
+    end
+
+    def self.srv_record(name, priority, weight, port, target)
+      new(name: name, type: 'SRV', priority: priority, weight: weight, port: port, value: target)
+    end
+
+    def self.txt_record(name, text)
+      new(name: name, type: 'TXT', value: text)
+    end
+
+    def self.ptr_record(name, pointer)
+      new(name: name, type: 'PTR', value: pointer)
+    end
+  end
+
+  class DnsResponse
+    attr_accessor :response_code, :answer_records, :authority_records,
+                  :additional_records, :delay, :primary
+
+    def initialize(response_code: nil, answer_records: nil, authority_records: nil,
+                   additional_records: nil, delay: nil, primary: nil)
+      @response_code = response_code
+      @answer_records = answer_records
+      @authority_records = authority_records
+      @additional_records = additional_records
+      @delay = delay
+      @primary = primary
+    end
+
+    def to_h
+      result = {}
+      result['responseCode'] = @response_code unless @response_code.nil?
+      result['answerRecords'] = @answer_records.map(&:to_h) if @answer_records
+      result['authorityRecords'] = @authority_records.map(&:to_h) if @authority_records
+      result['additionalRecords'] = @additional_records.map(&:to_h) if @additional_records
+      result['delay'] = @delay.to_h if @delay
+      result['primary'] = @primary unless @primary.nil?
+      result
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      answer_data = data['answerRecords']
+      authority_data = data['authorityRecords']
+      additional_data = data['additionalRecords']
+      new(
+        response_code:    data['responseCode'],
+        answer_records:   answer_data&.map { |r| DnsRecord.from_hash(r) },
+        authority_records: authority_data&.map { |r| DnsRecord.from_hash(r) },
+        additional_records: additional_data&.map { |r| DnsRecord.from_hash(r) },
+        delay:            Delay.from_hash(data['delay']),
+        primary:          data['primary']
+      )
+    end
+  end
+
+  class HttpChaosProfile
+    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
+
+    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,
+                   outage_after_millis: nil, outage_duration_millis: nil,
+                   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)
+      @error_status = error_status
+      @error_probability = error_probability
+      @drop_connection_probability = drop_connection_probability
+      @retry_after = retry_after
+      @latency = latency
+      @seed = seed
+      @succeed_first = succeed_first
+      @fail_request_count = fail_request_count
+      @outage_after_millis = outage_after_millis
+      @outage_duration_millis = outage_duration_millis
+      @truncate_body_at_fraction = truncate_body_at_fraction
+      @malformed_body = malformed_body
+      @slow_response_chunk_size = slow_response_chunk_size
+      @slow_response_chunk_delay = slow_response_chunk_delay
+      @quota_name = quota_name
+      @quota_limit = quota_limit
+      @quota_window_millis = quota_window_millis
+      @quota_error_status = quota_error_status
+      @degradation_ramp_millis = degradation_ramp_millis
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'errorStatus'               => @error_status,
+        'errorProbability'           => @error_probability,
+        'dropConnectionProbability'  => @drop_connection_probability,
+        'retryAfter'                 => @retry_after,
+        'latency'                    => @latency&.to_h,
+        'seed'                       => @seed,
+        'succeedFirst'               => @succeed_first,
+        'failRequestCount'           => @fail_request_count,
+        'outageAfterMillis'          => @outage_after_millis,
+        'outageDurationMillis'       => @outage_duration_millis,
+        'truncateBodyAtFraction'     => @truncate_body_at_fraction,
+        'malformedBody'              => @malformed_body,
+        'slowResponseChunkSize'      => @slow_response_chunk_size,
+        'slowResponseChunkDelay'     => @slow_response_chunk_delay&.to_h,
+        'quotaName'                  => @quota_name,
+        'quotaLimit'                 => @quota_limit,
+        'quotaWindowMillis'          => @quota_window_millis,
+        'quotaErrorStatus'           => @quota_error_status,
+        'degradationRampMillis'      => @degradation_ramp_millis
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        error_status:               data['errorStatus'],
+        error_probability:           data['errorProbability'],
+        drop_connection_probability: data['dropConnectionProbability'],
+        retry_after:                 data['retryAfter'],
+        latency:                     Delay.from_hash(data['latency']),
+        seed:                        data['seed'],
+        succeed_first:               data['succeedFirst'],
+        fail_request_count:          data['failRequestCount'],
+        outage_after_millis:         data['outageAfterMillis'],
+        outage_duration_millis:      data['outageDurationMillis'],
+        truncate_body_at_fraction:   data['truncateBodyAtFraction'],
+        malformed_body:              data['malformedBody'],
+        slow_response_chunk_size:    data['slowResponseChunkSize'],
+        slow_response_chunk_delay:   Delay.from_hash(data['slowResponseChunkDelay']),
+        quota_name:                  data['quotaName'],
+        quota_limit:                 data['quotaLimit'],
+        quota_window_millis:         data['quotaWindowMillis'],
+        quota_error_status:          data['quotaErrorStatus'],
+        degradation_ramp_millis:     data['degradationRampMillis']
+      )
+    end
+  end
+
   class AfterAction
-    attr_accessor :http_request, :http_class_callback, :http_object_callback, :delay
+    # blocking, timeout and failure_policy are only meaningful for before-actions
+    attr_accessor :http_request, :http_class_callback, :http_object_callback, :delay,
+                  :blocking, :timeout, :failure_policy
 
-    def initialize(http_request: nil, http_class_callback: nil, http_object_callback: nil, delay: nil)
+    def initialize(http_request: nil, http_class_callback: nil, http_object_callback: nil, delay: nil,
+                   blocking: nil, timeout: nil, failure_policy: nil)
       @http_request = http_request
       @http_class_callback = http_class_callback
       @http_object_callback = http_object_callback
       @delay = delay
+      @blocking = blocking
+      @timeout = timeout
+      @failure_policy = failure_policy
     end
 
     def to_h
@@ -1161,7 +1563,10 @@ module MockServer
         'httpRequest'        => @http_request&.to_h,
         'httpClassCallback'  => @http_class_callback&.to_h,
         'httpObjectCallback' => @http_object_callback&.to_h,
-        'delay'              => @delay&.to_h
+        'delay'              => @delay&.to_h,
+        'blocking'           => @blocking,
+        'timeout'            => @timeout&.to_h,
+        'failurePolicy'      => @failure_policy
       })
     end
 
@@ -1172,7 +1577,77 @@ module MockServer
         http_request:        HttpRequest.from_hash(data['httpRequest']),
         http_class_callback: HttpClassCallback.from_hash(data['httpClassCallback']),
         http_object_callback: HttpObjectCallback.from_hash(data['httpObjectCallback']),
-        delay:               Delay.from_hash(data['delay'])
+        delay:               Delay.from_hash(data['delay']),
+        blocking:            data['blocking'],
+        timeout:             Delay.from_hash(data['timeout']),
+        failure_policy:      data['failurePolicy']
+      )
+    end
+  end
+
+  # A single step in an ordered multi-action expectation pipeline.
+  #
+  # Each step carries exactly ONE action target and a +responder+ flag.
+  # Steps without +responder = true+ are side-effects (fire-and-forget
+  # webhooks/callbacks). Exactly one step in the list must be marked as the
+  # responder; that step's action produces the HTTP response.
+  class ExpectationStep
+    attr_accessor :http_request, :http_class_callback, :http_object_callback,
+                  :http_forward, :http_override_forwarded_request,
+                  :http_response, :http_error,
+                  :responder, :delay, :blocking, :timeout, :failure_policy
+
+    def initialize(http_request: nil, http_class_callback: nil, http_object_callback: nil,
+                   http_forward: nil, http_override_forwarded_request: nil,
+                   http_response: nil, http_error: nil,
+                   responder: nil, delay: nil, blocking: nil, timeout: nil, failure_policy: nil)
+      @http_request = http_request
+      @http_class_callback = http_class_callback
+      @http_object_callback = http_object_callback
+      @http_forward = http_forward
+      @http_override_forwarded_request = http_override_forwarded_request
+      @http_response = http_response
+      @http_error = http_error
+      @responder = responder
+      @delay = delay
+      @blocking = blocking
+      @timeout = timeout
+      @failure_policy = failure_policy
+    end
+
+    def to_h
+      MockServer.strip_none({
+        'httpRequest'                  => @http_request&.to_h,
+        'httpClassCallback'            => @http_class_callback&.to_h,
+        'httpObjectCallback'           => @http_object_callback&.to_h,
+        'httpForward'                  => @http_forward&.to_h,
+        'httpOverrideForwardedRequest' => @http_override_forwarded_request&.to_h,
+        'httpResponse'                 => @http_response&.to_h,
+        'httpError'                    => @http_error&.to_h,
+        'responder'                    => @responder,
+        'delay'                        => @delay&.to_h,
+        'blocking'                     => @blocking,
+        'timeout'                      => @timeout&.to_h,
+        'failurePolicy'                => @failure_policy
+      })
+    end
+
+    def self.from_hash(data)
+      return nil if data.nil?
+
+      new(
+        http_request:                  HttpRequest.from_hash(data['httpRequest']),
+        http_class_callback:           HttpClassCallback.from_hash(data['httpClassCallback']),
+        http_object_callback:          HttpObjectCallback.from_hash(data['httpObjectCallback']),
+        http_forward:                  HttpForward.from_hash(data['httpForward']),
+        http_override_forwarded_request: HttpOverrideForwardedRequest.from_hash(data['httpOverrideForwardedRequest']),
+        http_response:                 HttpResponse.from_hash(data['httpResponse']),
+        http_error:                    HttpError.from_hash(data['httpError']),
+        responder:                     data['responder'],
+        delay:                         Delay.from_hash(data['delay']),
+        blocking:                      data['blocking'],
+        timeout:                       Delay.from_hash(data['timeout']),
+        failure_policy:                data['failurePolicy']
       )
     end
   end
@@ -1183,9 +1658,12 @@ module MockServer
                   :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,
-                  :http_sse_response, :http_websocket_response, :after_actions,
-                  :http_responses, :response_mode,
+                  :http_error, :times, :time_to_live, :chaos,
+                  :http_sse_response, :http_websocket_response,
+                  :grpc_stream_response, :grpc_bidi_response,
+                  :binary_response, :dns_response,
+                  :before_actions, :after_actions,
+                  :http_responses, :response_mode, :steps,
                   :scenario_name, :scenario_state, :new_scenario_state
 
     def initialize(id: nil, priority: nil, percentage: nil, http_request: nil, http_response: nil,
@@ -1193,9 +1671,12 @@ module MockServer
                    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,
-                   http_sse_response: nil, http_websocket_response: nil, after_actions: nil,
-                   http_responses: nil, response_mode: nil,
+                   http_error: nil, times: nil, time_to_live: nil, chaos: nil,
+                   http_sse_response: nil, http_websocket_response: nil,
+                   grpc_stream_response: nil, grpc_bidi_response: nil,
+                   binary_response: nil, dns_response: nil,
+                   before_actions: nil, after_actions: nil,
+                   http_responses: nil, response_mode: nil, steps: nil,
                    scenario_name: nil, scenario_state: nil, new_scenario_state: nil)
       @id = id
       @priority = priority
@@ -1213,17 +1694,31 @@ module MockServer
       @http_error = http_error
       @times = times
       @time_to_live = time_to_live
+      @chaos = chaos
       @http_sse_response = http_sse_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
+      @before_actions = before_actions
       @after_actions = after_actions
       @http_responses = http_responses
       @response_mode = response_mode
+      @steps = steps
       @scenario_name = scenario_name
       @scenario_state = scenario_state
       @new_scenario_state = new_scenario_state
     end
 
     def to_h
+      before_actions_h = nil
+      if @before_actions.is_a?(Array)
+        before_actions_h = @before_actions.map(&:to_h) unless @before_actions.empty?
+      elsif @before_actions
+        before_actions_h = @before_actions.to_h
+      end
+
       after_actions_h = nil
       if @after_actions.is_a?(Array)
         after_actions_h = @after_actions.map(&:to_h) unless @after_actions.empty?
@@ -1248,11 +1743,18 @@ module MockServer
         'httpError'                    => @http_error&.to_h,
         'httpSseResponse'              => @http_sse_response&.to_h,
         'httpWebSocketResponse'        => @http_websocket_response&.to_h,
+        'grpcStreamResponse'           => @grpc_stream_response&.to_h,
+        'grpcBidiResponse'             => @grpc_bidi_response&.to_h,
+        'binaryResponse'               => @binary_response&.to_h,
+        'dnsResponse'                  => @dns_response&.to_h,
+        'beforeActions'                => before_actions_h,
         'afterActions'                 => after_actions_h,
         'httpResponses'                => @http_responses&.map(&:to_h),
         'responseMode'                 => @response_mode,
+        'steps'                        => @steps&.map(&:to_h),
         'times'                        => @times&.to_h,
         'timeToLive'                   => @time_to_live&.to_h,
+        'chaos'                        => @chaos&.to_h,
         'scenarioName'                 => @scenario_name,
         'scenarioState'                => @scenario_state,
         'newScenarioState'             => @new_scenario_state
@@ -1262,11 +1764,18 @@ module MockServer
     def self.from_hash(data)
       return nil if data.nil?
 
+      before_actions_data = data['beforeActions']
+      before_actions = if before_actions_data.is_a?(Array)
+                         before_actions_data.map { |a| AfterAction.from_hash(a) }
+                       elsif before_actions_data
+                         [AfterAction.from_hash(before_actions_data)]
+                       end
+
       after_actions_data = data['afterActions']
       after_actions = if after_actions_data.is_a?(Array)
                         after_actions_data.map { |a| AfterAction.from_hash(a) }
                       elsif after_actions_data
-                        AfterAction.from_hash(after_actions_data)
+                        [AfterAction.from_hash(after_actions_data)]
                       end
 
       new(
@@ -1286,11 +1795,18 @@ module MockServer
         http_error:                      HttpError.from_hash(data['httpError']),
         http_sse_response:               HttpSseResponse.from_hash(data['httpSseResponse']),
         http_websocket_response:         HttpWebSocketResponse.from_hash(data['httpWebSocketResponse']),
+        grpc_stream_response:            GrpcStreamResponse.from_hash(data['grpcStreamResponse']),
+        grpc_bidi_response:              GrpcBidiResponse.from_hash(data['grpcBidiResponse']),
+        binary_response:                 BinaryResponse.from_hash(data['binaryResponse']),
+        dns_response:                    DnsResponse.from_hash(data['dnsResponse']),
+        before_actions:                  before_actions,
         after_actions:                   after_actions,
         http_responses:                  data['httpResponses']&.map { |r| HttpResponse.from_hash(r) },
         response_mode:                   data['responseMode'],
+        steps:                           data['steps']&.map { |s| ExpectationStep.from_hash(s) },
         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']

data/lib/mockserver/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mockserver-client
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 7.0.0
 platform: ruby
 authors:
 - James Bloom
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-21 00:00:00.000000000 Z
+date: 2026-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger