nonnative 2.1.0 → 2.10.0

data/lib/nonnative/configuration.rb

@@ -124,14 +124,10 @@ module Nonnative
       processes = cfg.processes || []
       processes.each do |fd|
         process do |d|
-          d.name = fd.name
           d.command = command(fd)
-          d.timeout = fd.timeout
-          d.wait = fd.wait if fd.wait
-          d.port = fd.port
-          d.log = fd.log
           d.signal = fd.signal
           d.environment = fd.environment
+          runner_attributes(d, fd)
 
           proxy d, fd.proxy
         end
@@ -154,12 +150,8 @@ module Nonnative
       servers = cfg.servers || []
       servers.each do |fd|
         server do |s|
-          s.name = fd.name
           s.klass = Object.const_get(fd.class)
-          s.timeout = fd.timeout
-          s.wait = fd.wait if fd.wait
-          s.port = fd.port
-          s.log = fd.log
+          runner_attributes(s, fd)
 
           proxy s, fd.proxy
         end
@@ -179,6 +171,15 @@ module Nonnative
       end
     end
 
+    def runner_attributes(runner, loaded)
+      runner.name = loaded.name
+      runner.timeout = loaded.timeout
+      runner.wait = loaded.wait if loaded.wait
+      runner.host = loaded.host if loaded.host
+      runner.port = loaded.port
+      runner.log = loaded.log if loaded.respond_to?(:log)
+    end
+
     def proxy(runner, proxy)
       return unless proxy
 

data/lib/nonnative/configuration_proxy.rb

@@ -20,7 +20,8 @@ module Nonnative
     # @return [String, nil] path to proxy log file (implementation-dependent)
     # @return [Numeric] wait interval (seconds) after proxy state changes (defaults to `0.1`)
     # @return [Hash] proxy implementation options (implementation-dependent)
-    attr_accessor :kind, :host, :port, :log, :wait, :options
+    attr_accessor :kind, :host, :port, :log, :wait
+    attr_reader :options
 
     # Creates a proxy configuration with defaults.
     #
@@ -39,5 +40,16 @@ module Nonnative
       self.wait = 0.1
       self.options = {}
     end
+
+    # Stores proxy implementation options.
+    #
+    # Nil is normalized to an empty hash so callers loading partial configuration do not erase the
+    # default options container.
+    #
+    # @param value [Hash, nil]
+    # @return [void]
+    def options=(value)
+      @options = value || {}
+    end
   end
 end

data/lib/nonnative/cucumber.rb

@@ -1,105 +1,221 @@
 # frozen_string_literal: true
 
-World(RSpec::Benchmark::Matchers)
-World(RSpec::Matchers)
-World(RSpec::Wait)
-
-Before('@startup') do
-  Nonnative.start
-end
-
-After('@startup') do
-  Nonnative.stop
-end
-
-After('@manual') do
-  Nonnative.stop
-end
-
-Before('@clear') do
-  Nonnative.clear
-end
-
-After('@reset') do
-  Nonnative.reset
-end
-
-Given('I set the proxy for process {string} to {string}') do |name, operation|
-  process = Nonnative.pool.process_by_name(name)
-  process.proxy.send(operation)
-end
-
-Given('I set the proxy for server {string} to {string}') do |name, operation|
-  server = Nonnative.pool.server_by_name(name)
-  server.proxy.send(operation)
-end
-
-Given('I set the proxy for service {string} to {string}') do |name, operation|
-  service = Nonnative.pool.service_by_name(name)
-  service.proxy.send(operation)
-end
-
-Given('I start the system') do
-  Nonnative.start
-end
-
-Given('I should see {string} as unhealthy') do |service|
-  opts = {
-    headers: { content_type: :json, accept: :json },
-    read_timeout: 10, open_timeout: 10
-  }
-
-  wait_for { Nonnative.observability.health(opts).code }.to eq(503)
-  wait_for { Nonnative.observability.health(opts).body }.to include(service)
-end
-
-Then('I should reset the proxy for process {string}') do |name|
-  process = Nonnative.pool.process_by_name(name)
-  process.proxy.reset
-end
-
-Then('I should reset the proxy for server {string}') do |name|
-  server = Nonnative.pool.server_by_name(name)
-  server.proxy.reset
-end
-
-Then('I should reset the proxy for service {string}') do |name|
-  service = Nonnative.pool.service_by_name(name)
-  service.proxy.reset
-end
-
-Then('the process {string} should consume less than {string} of memory') do |name, mem|
-  process = Nonnative.pool.process_by_name(name)
-  _, size, type = mem.split(/(\d+)/)
-  actual = process.memory.send(type)
-  size = size.to_i
-
-  expect(actual).to be < size
-end
-
-Then('starting the system should raise an error') do
-  expect { Nonnative.start }.to raise_error(Nonnative::StartError)
-end
-
-Then('stopping the system should raise an error') do
-  expect { Nonnative.stop }.to raise_error(Nonnative::StopError)
-end
-
-Then('I should see a log entry of {string} for process {string}') do |message, process|
-  process = Nonnative.configuration.process_by_name(process)
-  expect(Nonnative.log_lines(process.log, ->(l) { l.include?(message) }).first).to include(message)
-end
-
-Then('I should see a log entry of {string} in the file {string}') do |message, path|
-  expect(Nonnative.log_lines(path, ->(l) { l.include?(message) }).first).to include(message)
-end
-
-Then('I should see {string} as healthy') do |service|
-  opts = {
-    headers: { content_type: :json, accept: :json },
-    read_timeout: 10, open_timeout: 10
-  }
-
-  wait_for { Nonnative.observability.health(opts).code }.to eq(200)
-  wait_for { Nonnative.observability.health(opts).body }.to_not include(service)
-end
+require 'cucumber'
+
+module Nonnative
+  # Lazily installs the Cucumber integration once the Cucumber Ruby DSL is ready.
+  #
+  # Requiring `nonnative` outside a running Cucumber environment should not fail, but when Cucumber
+  # does finish booting its support-code registry this installer still needs to register the hooks
+  # and step definitions defined here.
+  module Cucumber
+    module LanguageHook
+      def rb_language=(value)
+        super.tap { ::Nonnative::Cucumber.install! }
+      end
+    end
+
+    module WorldHooks
+      def install_world
+        World(::RSpec::Benchmark::Matchers)
+        World(::RSpec::Matchers)
+        World(::RSpec::Wait)
+      end
+
+      def install_hooks
+        Before('@startup') { Nonnative.start }
+        After('@startup') { Nonnative.stop }
+        After('@manual') { Nonnative.stop }
+        Before('@clear') { Nonnative.clear }
+        After('@reset') { Nonnative.reset }
+      end
+    end
+
+    module ProxySteps
+      def install_proxy_steps
+        install_proxy_mutation_steps
+        install_proxy_reset_steps
+      end
+
+      def install_proxy_mutation_steps
+        Given('I set the proxy for process {string} to {string}') do |name, operation|
+          process = Nonnative.pool.process_by_name(name)
+          process.proxy.send(operation)
+        end
+
+        Given('I set the proxy for server {string} to {string}') do |name, operation|
+          server = Nonnative.pool.server_by_name(name)
+          server.proxy.send(operation)
+        end
+
+        Given('I set the proxy for service {string} to {string}') do |name, operation|
+          service = Nonnative.pool.service_by_name(name)
+          service.proxy.send(operation)
+        end
+      end
+
+      def install_proxy_reset_steps
+        Then('I should reset the proxy for process {string}') do |name|
+          process = Nonnative.pool.process_by_name(name)
+          process.proxy.reset
+        end
+
+        Then('I should reset the proxy for server {string}') do |name|
+          server = Nonnative.pool.server_by_name(name)
+          server.proxy.reset
+        end
+
+        Then('I should reset the proxy for service {string}') do |name|
+          service = Nonnative.pool.service_by_name(name)
+          service.proxy.reset
+        end
+      end
+    end
+
+    module LifecycleSteps
+      def install_state_steps
+        install_start_step
+        install_attempt_start_step
+        install_attempt_stop_step
+        install_unhealthy_step
+        install_healthy_step
+      end
+
+      def install_start_step
+        When('I start the system') do
+          Nonnative.start
+        end
+      end
+
+      def install_attempt_start_step
+        When('I attempt to start the system') do
+          @start_error = nil
+          Nonnative.start
+        rescue StandardError => e
+          @start_error = e
+        end
+      end
+
+      def install_attempt_stop_step
+        When('I attempt to stop the system') do
+          @stop_error = nil
+          Nonnative.stop
+        rescue StandardError => e
+          @stop_error = e
+        end
+      end
+
+      def install_unhealthy_step
+        opts = observability_options
+
+        Then('I should see {string} as unhealthy') do |service|
+          wait_for { Nonnative.observability.health(opts).code }.to eq(503)
+          wait_for { Nonnative.observability.health(opts).body }.to include(service)
+        end
+      end
+
+      def install_healthy_step
+        opts = observability_options
+
+        Then('I should see {string} as healthy') do |service|
+          wait_for { Nonnative.observability.health(opts).code }.to eq(200)
+          wait_for { Nonnative.observability.health(opts).body }.to_not include(service)
+        end
+      end
+
+      def observability_options
+        {
+          headers: { content_type: :json, accept: :json },
+          read_timeout: 10,
+          open_timeout: 10
+        }
+      end
+    end
+
+    module Assertions
+      def install_assertion_steps
+        install_memory_assertion_step
+        install_error_assertion_steps
+        install_log_assertion_steps
+      end
+
+      def install_memory_assertion_step
+        Then('the process {string} should consume less than {string} of memory') do |name, mem|
+          process = Nonnative.pool.process_by_name(name)
+          _, size, type = mem.split(/(\d+)/)
+          actual = process.memory.send(type)
+          size = size.to_i
+
+          expect(actual).to be < size
+        end
+      end
+
+      def install_error_assertion_steps
+        Then('starting the system should raise an error') do
+          expect(@start_error).to be_a(Nonnative::StartError)
+        end
+
+        Then('stopping the system should raise an error') do
+          expect(@stop_error).to be_a(Nonnative::StopError)
+        end
+      end
+
+      def install_log_assertion_steps
+        Then('I should see a log entry of {string} for process {string}') do |message, process|
+          process = Nonnative.configuration.process_by_name(process)
+          expect(Nonnative.log_lines(process.log, ->(l) { l.include?(message) }).first).to include(message)
+        end
+
+        Then('I should see a log entry of {string} in the file {string}') do |message, path|
+          expect(Nonnative.log_lines(path, ->(l) { l.include?(message) }).first).to include(message)
+        end
+      end
+    end
+
+    module Registration
+      extend ::Cucumber::Glue::Dsl
+      extend WorldHooks
+      extend ProxySteps
+      extend LifecycleSteps
+      extend Assertions
+
+      class << self
+        def install!
+          install_world
+          install_hooks
+          install_proxy_steps
+          install_state_steps
+          install_assertion_steps
+        end
+      end
+    end
+
+    class << self
+      def bootstrap!
+        return if @bootstrapped
+
+        dsl_singleton = ::Cucumber::Glue::Dsl.singleton_class
+        dsl_singleton.prepend(LanguageHook) unless dsl_singleton.ancestors.include?(LanguageHook)
+
+        @bootstrapped = true
+        install!
+      end
+
+      def install!
+        return if @installed
+        return unless ready?
+
+        Registration.install!
+        @installed = true
+      end
+
+      private
+
+      def ready?
+        !::Cucumber::Glue::Dsl.instance_variable_get(:@rb_language).nil?
+      end
+    end
+  end
+end
+
+Nonnative::Cucumber.bootstrap!

data/lib/nonnative/http_proxy_server.rb

@@ -30,10 +30,11 @@ module Nonnative
     # @param request [Sinatra::Request] the incoming request
     # @return [Hash{String=>String}] headers to forward to the upstream
     def retrieve_headers(request)
-      headers = request.env.map do |header, value|
-        [header[5..].split('_').map(&:capitalize).join('-'), value] if header.start_with?('HTTP_')
+      headers = request.env.each_with_object({}) do |(header, value), result|
+        next unless forward_header?(header)
+
+        result[normalized_header_name(header)] = value
       end
-      headers = headers.compact.to_h
 
       headers.except('Host', 'Accept-Encoding', 'Version')
     end
@@ -53,19 +54,45 @@ module Nonnative
     # @param uri [String] upstream URI
     # @param opts [Hash] RestClient options (e.g. headers)
     # @return [RestClient::Response] response for error statuses, otherwise RestClient return value
-    def api_response(verb, uri, opts)
-      client = RestClient::Resource.new(uri, opts)
+    def api_response(method:, url:, headers:, payload: nil)
+      options = { method:, url:, headers: }
+      options[:payload] = payload unless payload.nil?
 
-      client.send(verb)
+      RestClient::Request.execute(options)
     rescue RestClient::Exception => e
       e.response
     end
 
+    # Extracts the request payload for verbs that can carry a body.
+    #
+    # @param request [Sinatra::Request] the incoming request
+    # @param verb [String] HTTP verb name (e.g. `"post"`)
+    # @return [String, nil] request payload for body-carrying verbs
+    def retrieve_payload(request, verb)
+      return unless %w[post put patch delete].include?(verb)
+
+      payload = request.body.read
+      payload unless payload.empty?
+    end
+
+    private
+
+    def forward_header?(header)
+      header.start_with?('HTTP_') || %w[CONTENT_TYPE CONTENT_LENGTH].include?(header)
+    end
+
+    def normalized_header_name(header)
+      header.delete_prefix('HTTP_').split('_').map(&:capitalize).join('-')
+    end
+
     %w[get post put patch delete].each do |verb|
       send(verb, /.*/) do
-        uri = build_url(request, settings)
-        opts = { headers: retrieve_headers(request) }
-        res = api_response(verb, uri, opts)
+        res = api_response(
+          method: verb.to_sym,
+          url: build_url(request, settings),
+          headers: retrieve_headers(request),
+          payload: retrieve_payload(request, verb)
+        )
 
         status res.code
         res.body

data/lib/nonnative/invalid_data_socket_pair.rb

@@ -3,8 +3,8 @@
 module Nonnative
   # Socket-pair variant used by the fault-injection proxy to simulate corrupted/incoherent traffic.
   #
-  # When active, data written to the upstream socket is corrupted by shuffling the characters in the
-  # payload before forwarding.
+  # When active, data written to the upstream socket is corrupted by shuffling the payload bytes
+  # before forwarding.
   #
   # This behavior is enabled by calling {Nonnative::FaultInjectionProxy#invalid_data}.
   #
@@ -12,7 +12,10 @@ module Nonnative
   # @see Nonnative::SocketPairFactory
   # @see Nonnative::SocketPair
   class InvalidDataSocketPair < SocketPair
-    # Writes corrupted data to the socket by shuffling characters.
+    # Writes corrupted data to the socket by shuffling bytes.
+    #
+    # The payload must always change, otherwise short or repetitive inputs such as "test" can
+    # occasionally pass through unchanged and make fault-injection scenarios flaky.
     #
     # @param socket [IO] the socket to write to
     # @param data [String] the original payload
@@ -20,9 +23,18 @@ module Nonnative
     def write(socket, data)
       Nonnative.logger.info "shuffling socket data '#{socket.inspect}' for 'invalid_data' pair"
 
-      data = data.chars.shuffle.join
+      super(socket, corrupt(data))
+    end
+
+    private
+
+    def corrupt(data)
+      bytes = data.bytes
+      corrupted = bytes.shuffle
+      return corrupted.pack('C*') unless corrupted == bytes
 
-      super
+      corrupted[0] = (corrupted[0] + 1) % 256
+      corrupted.pack('C*')
     end
   end
 end