test-kitchen 4.1.3 → 4.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35bb40be8e39ac171865c0bd23300293032f6558dbb62d788efcb1441dbbe66c
-  data.tar.gz: d9d9be6360a468f2cd55958e37a21a1f0b1ffa4435a0eb53dc84dae07a219369
+  metadata.gz: c56fc990001b04aa4573652682c08b02ea00508480f76beb1db8ed72e8ade07f
+  data.tar.gz: 575f723e4cd3105fdd6e3ec4961f3bcfaa08ab8d2d38bc434dab095c3e9f193c
 SHA512:
-  metadata.gz: 75dce025d9f85c60bb7b07cbc30f809d864eb2cdbf562557e9511376c050ae1b41f488ed3640dddf11c4664fa91ab5a048a7e5d434d0c1172195eaa055289276
-  data.tar.gz: dda50545d44c4c3522f28df5dd89eeeefb1356d3e349abfc22f0899ced79ed58b7eaa300a764a239e182ecec384dc8a39e76ad27cbf5e86dba48c8efbf0c63ea
+  metadata.gz: f629caaf011634872054a8e6fae1643758a50a97c98d28fd4967181d4a5e6f68719965894cdb007d571e9a71ae45eb41cf1de8d9639d917b2b9cab99540d5c3e
+  data.tar.gz: e10c5f823385e29b6d3c08fe9f7059d160e815ef02ebca55e81e5dd526bcbb081727b6f3aacdc4f46bcb0b0928f562014fcc0475a4c3fe95c88e6d4e67d898ab

data/Gemfile

@@ -12,19 +12,12 @@ group :test do
   gem "maruku",    "~> 0.7"
   gem "minitest",  "~> 6.0", "< 6.1"
   gem "mocha",     "~> 3.0"
+  gem "simplecov", "~> 0.22", require: false
   gem "yard",      "~> 0.9"
 end
 
-group :integration do
-  gem "cinc-auditor-bin", source: "https://rubygems.cinc.sh"
-  gem "kitchen-cinc"
-  gem "kitchen-cinc-auditor",
-    git: "https://github.com/test-kitchen/kitchen-cinc-auditor.git",
-    ref: "3d0b89eaa13f12da08a8761970e39c0f564c24c6"
-  gem "kitchen-dokken"
-  gem "kitchen-vagrant"
-end
+# Acceptance-suite gems live in Gemfile.integration.
 
 group :linting do
-  gem "cookstyle", "~> 8.2"
+  gem "cookstyle", "~> 9.0"
 end

data/Rakefile

@@ -7,6 +7,48 @@ Rake::TestTask.new(:unit) do |t|
   t.verbose = true
 end
 
+namespace :unit do
+  desc "Run each spec file in its own process to catch cross-file coupling"
+  task :isolated do
+    require "open3"
+
+    specs = FileList["spec/**/*_spec.rb"].sort
+    # Spec files are independent, and each one spends most of its time in
+    # process startup, so run a few at a time.
+    workers = (ENV["ISOLATED_WORKERS"] || 4).to_i
+    failed = []
+
+    specs.each_slice(workers) do |batch|
+      batch.map do |spec|
+        Thread.new do
+          out, status = Open3.capture2e(
+            Gem.ruby, "-Ilib", "-Ispec", spec
+          )
+          [spec, status.success?, out]
+        end
+      end.map(&:value).each do |spec, ok, out|
+        puts(ok ? "  ok   #{spec}" : "  FAIL #{spec}\n#{out}")
+        failed << spec unless ok
+      end
+    end
+
+    unless failed.empty?
+      abort "\n#{failed.length} of #{specs.length} spec files fail on their " \
+            "own:\n  #{failed.join("\n  ")}\n\n" \
+            "These pass in `rake unit` only because another spec file loads " \
+            "something they need. Add the missing require."
+    end
+
+    puts "\nAll #{specs.length} spec files pass in isolation."
+  end
+
+  desc "Run the unit tests with coverage reporting"
+  task :coverage do
+    ENV["COVERAGE"] = "1"
+    Rake::Task[:unit].invoke
+  end
+end
+
 begin
   require "cucumber"
   require "cucumber/rake/task"
@@ -20,6 +62,9 @@ end
 desc "Run all test suites"
 task test: %i{unit features}
 
+desc "Run the checks that must pass before a change is merged"
+task verify: %i{unit unit:isolated style}
+
 desc "Display LOC stats"
 task :stats do
   puts "\n## Production Code Stats"

data/lib/kitchen/command/doctor.rb

@@ -28,10 +28,12 @@ module Kitchen
         end
         # By default only doctor the first instance to avoid output spam.
         results = [results.first] unless options[:all]
-        failed = results.any? do |instance|
+        # Doctor every instance before deciding the outcome. #any? would
+        # stop at the first instance reporting a problem and skip the rest.
+        failed = results.map do |instance|
           debug "Doctor on #{instance.name}."
           instance.doctor_action
-        end
+        end.any?
         exit(1) if failed
       end
     end

data/lib/kitchen/command.rb

@@ -195,18 +195,20 @@ module Kitchen
       end
 
       # Determines how many instances may be acted on at once, clamped to the
-      # number of instances available.
+      # number of instances available and to at least one worker. Without the
+      # lower bound a zero or negative --concurrency would start no worker
+      # threads at all, so every instance would be skipped and the run would
+      # still report success.
       #
       # @param instances [Array<Instance>] the instances to be acted on
       # @return [Integer] the number of worker threads to start
       # @api private
       def concurrency_setting(instances)
-        concurrency = 1
-        if options[:concurrency]
-          concurrency = options[:concurrency] || instances.size
-          concurrency = instances.size if concurrency > instances.size
-        end
-        concurrency
+        return 1 unless options[:concurrency]
+
+        concurrency = options[:concurrency]
+        concurrency = instances.size if concurrency > instances.size
+        [concurrency, 1].max
       end
 
       # Performs an action on a single instance, recording any instance or

data/lib/kitchen/data_munger.rb

@@ -1037,9 +1037,7 @@ module Kitchen
     #   Hash if not found
     # @api private
     def platform_data_for(name)
-      data.fetch(:platforms, {}).find(-> { {} }) do |platform|
-        platform.fetch(:name, nil) == name
-      end
+      platform_index[name] || {}
     end
 
     # Destructively sets a base kitchen config key/value pair at the root of
@@ -1068,8 +1066,41 @@ module Kitchen
     #   Hash if not found
     # @api private
     def suite_data_for(name)
-      data.fetch(:suites, {}).find(-> { {} }) do |suite|
-        suite.fetch(:name, nil) == name
+      suite_index[name] || {}
+    end
+
+    # Name-keyed index of the platform data, built once on first use.
+    #
+    # Every plugin lookup for every instance resolves a platform and a suite by
+    # name, so the linear scans this replaces made building a project's
+    # instances quadratic in its size.
+    #
+    # @return [Hash{String => Hash}] platform name to platform data
+    # @api private
+    def platform_index
+      @platform_index ||= index_by_name(data.fetch(:platforms, []))
+    end
+
+    # Name-keyed index of the suite data, built once on first use.
+    #
+    # @return [Hash{String => Hash}] suite name to suite data
+    # @api private
+    def suite_index
+      @suite_index ||= index_by_name(data.fetch(:suites, []))
+    end
+
+    # Indexes a collection of named data hashes by their :name value.
+    #
+    # An earlier entry wins over a later duplicate, matching the first match
+    # that a linear search would have returned.
+    #
+    # @param collection [Enumerable<Hash>] platform or suite data
+    # @return [Hash{String => Hash}] name to entry
+    # @api private
+    def index_by_name(collection)
+      collection.each_with_object({}) do |entry, index|
+        key = entry.fetch(:name, nil)
+        index[key] = entry unless index.key?(key)
       end
     end
   end

data/lib/kitchen/errors.rb

@@ -52,7 +52,7 @@ module Kitchen
                else
                  [
                    formatted_exception(exception.original, "Nested Exception"),
-                   formatted_backtrace(exception),
+                   formatted_backtrace(exception.original),
                  ].flatten
                end
       end

data/lib/kitchen/generator/init.rb

@@ -15,7 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "rubygems/gem_runner"
 require "thor/group"
 
 module Kitchen

data/lib/kitchen/instance.rb

@@ -242,9 +242,12 @@ module Kitchen
     #
     def doctor_action
       banner "The doctor is in"
-      [driver, provisioner, transport, verifier].any? do |obj|
+      # Each plugin reports its own problems as it finds them, so run all of
+      # them and reduce afterwards. #any? would stop at the first plugin with
+      # something to say and hide the rest.
+      [driver, provisioner, transport, verifier].map do |obj|
         obj.doctor(state_file.read)
-      end
+      end.any?
     end
 
     # Returns a Hash of configuration and other useful diagnostic information.
@@ -771,12 +774,12 @@ module Kitchen
       # reported transitioned state into the desired transitioned state.
       #
       # @param last [String,Symbol,nil] the last known transitioned state of
-      #   the Instance, defaulting to `nil` (for unknown or no history)
+      #   the Instance, or `nil` for unknown or no history
       # @param desired [String,Symbol] the desired transitioned state for the
       #   Instance
       # @return [Array<Symbol>] an Array of transition actions to perform
       # @api private
-      def self.actions(last = nil, desired)
+      def self.actions(last, desired)
         last_index = index(last)
         desired_index = index(desired)
 

data/lib/kitchen/lazy_hash.rb

@@ -95,6 +95,41 @@ module Kitchen
       end
     end
 
+    # Sets the raw value for the given key. Values are stored unrendered, so a
+    # callable assigned here is still evaluated lazily on read.
+    #
+    # SimpleDelegator would forward this through #method_missing; defining it
+    # here keeps the hot path off that dispatch, which every plugin walks once
+    # per default attribute while applying its defaults.
+    #
+    # @param key [Object] hash key
+    # @param value [Object] the value to store
+    # @return [Object] the stored value
+    def []=(key, value)
+      __getobj__[key] = value
+    end
+
+    # Returns whether the given key is present, without rendering its value.
+    #
+    # Defined for the same reason as {#[]=}: to bypass SimpleDelegator's
+    # #method_missing on a hot path.
+    #
+    # @param key [Object] hash key
+    # @return [Boolean] whether the key is present
+    def key?(key)
+      __getobj__.key?(key)
+    end
+
+    # Returns the keys of the underlying hash.
+    #
+    # Defined for the same reason as {#[]=}: to bypass SimpleDelegator's
+    # #method_missing on a hot path.
+    #
+    # @return [Array] the hash keys
+    def keys
+      __getobj__.keys
+    end
+
     # Returns a new Hash with all keys and rendered values of the LazyHash.
     #
     # @return [Hash] a new hash

data/lib/kitchen/logger.rb

@@ -312,8 +312,10 @@ module Kitchen
 
     # @return [Hash] metadata added to structured log events
     def metadata
-      metadata_stack.inject(@base_metadata.dup) do |result, values|
-        result.merge(values)
+      # Merge in place into the fresh dup rather than allocating a new hash per
+      # stack entry; this runs once per structured log event.
+      metadata_stack.each_with_object(@base_metadata.dup) do |values, result|
+        result.merge!(values)
       end
     end
 
@@ -449,15 +451,20 @@ module Kitchen
 
       private
 
+      # Builds the formatter used for console output.
+      #
+      # The colour is fixed for the life of the logger, so both escape
+      # sequences are resolved once here rather than on every line. An
+      # uncolourised logger, and one whose colour did not resolve, share the
+      # same uncoloured formatter.
       def stdout_formatter(color, colorize)
-        if colorize
-          proc do |_severity, _datetime, _progname, msg|
-            Color.colorize(msg.dup.to_s, color).concat("\n")
-          end
+        escape = colorize ? Color.escape(color) : ""
+
+        if escape.empty?
+          proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
         else
-          proc do |_severity, _datetime, _progname, msg|
-            msg.dup.concat("\n")
-          end
+          reset = Color.escape(:reset)
+          proc { |_severity, _datetime, _progname, msg| "#{escape}#{msg}#{reset}\n" }
         end
       end
 
@@ -496,22 +503,50 @@ module Kitchen
       # @return [void]
       # @api private
       def <<(msg)
-        @buffer += msg
+        @buffer << msg
         flush_lines
       end
 
       private
 
+      # Emits every complete line in the buffer, then drops the emitted bytes
+      # in a single pass. Scanning from a moving offset instead of deleting
+      # each line as it is found keeps a chunk of n lines linear rather than
+      # quadratic, which matters because one SSH or WinRM read can carry
+      # thousands of lines.
       def flush_lines
-        while (i = @buffer.index("\n"))
-          @line_handler.call(@buffer[0, i].chomp)
-          @buffer[0, i + 1] = ""
+        start = 0
+        while (i = @buffer.index("\n", start))
+          @line_handler.call(@buffer[start, i - start].chomp)
+          start = i + 1
         end
+        @buffer.slice!(0, start) unless start == 0
       end
     end
 
     # Rewrites already-prefixed stream lines into the matching logger call.
     class StreamLineFormatter
+      # Width of every stream prefix in {PREFIXES}. All prefixes are the same
+      # width so that a line's severity is a fixed-offset lookup.
+      #
+      # @return [Integer] the prefix width in characters
+      # @api private
+      PREFIX_WIDTH = 7
+
+      # Maps each stream prefix to the severity it denotes and whether the line
+      # must be replayed verbatim on sinks that cannot accept stream events.
+      #
+      # @return [Hash{String => Array}] prefix to [severity, structured] pairs
+      # @api private
+      PREFIXES = {
+        "-----> " => [:banner, false],
+        "D      " => [:debug,  true],
+        "$$$$$$ " => [:warn,   true],
+        ">>>>>> " => [:error,  false],
+        "!!!!!! " => [:fatal,  true],
+        "       " => [:info,   false],
+      }.freeze
+
       def initialize(logger)
         @logger = logger
       end
@@ -519,18 +554,22 @@ module Kitchen
       # Routes an already-prefixed stream line to the logger call matching its
       # prefix, stripping the prefix before logging.
       #
+      # A hash lookup on the fixed-width prefix replaces a chain of anchored
+      # regexp matches, so an unprefixed line costs one lookup rather than six
+      # failed matches.
+      #
       # @param line [String] a single line of prefixed stream output
       # @return [void]
       # @api private
       def format(line)
-        case line
-        when /^-----> / then log_line(:banner, line.gsub(/^[ >-]{6} /, ""))
-        when /^D      / then structured_line(:debug, line.gsub(/^D {6}/, ""), line)
-        when /^\$\$\$\$\$\$ / then structured_line(:warn, line.gsub(/^\${6} /, ""), line)
-        when /^>>>>>> / then log_line(:error, line.gsub(/^[ >-]{6} /, ""))
-        when /^!!!!!! / then structured_line(:fatal, line.gsub(/^!{6} /, ""), line)
-        when /^       / then log_line(:info, line.gsub(/^[ >-]{6} /, ""))
-        else log_line(:info, line)
+        severity, structured = PREFIXES[line[0, PREFIX_WIDTH]]
+
+        if severity.nil?
+          log_line(:info, line)
+        elsif structured
+          structured_line(severity, line[PREFIX_WIDTH..], line)
+        else
+          log_line(severity, line[PREFIX_WIDTH..])
         end
       end
 
@@ -808,9 +847,11 @@ module Kitchen
             message: message.to_s,
             progname:,
             sequence: next_sequence
-          ).compact
-          @logdev.write(JSON.generate(event))
-          @logdev.write("\n")
+          )
+          event.compact!
+          # One writev rather than two writes: the log device is opened with
+          # sync = true, so each call is a syscall.
+          @logdev.write(JSON.generate(event), "\n")
         end
         true
       end

data/lib/kitchen/platform_filter.rb

@@ -32,9 +32,10 @@ module Kitchen
     # A string "looks-like" a regexp if it starts with / and ends with / + Regexp options i or x
     #
     # @return [Array] filters with regexp-like string converted to PlatformRegexpFilter
+    # @raise [ArgumentError] if a filter is neither a String nor a Regexp
     def self.convert(filters)
       ::Kernel.Array(filters).map do |filter|
-        if (match = filter.match(REGEXP_LIKE_PATTERN))
+        if filter.is_a?(::String) && (match = filter.match(REGEXP_LIKE_PATTERN))
           options = match["options"].include?("i") ? ::Regexp::IGNORECASE : 0
           options |= ::Regexp::EXTENDED if match["options"].include?("x")
           filter = ::Regexp.new(match["pattern"], options)
@@ -51,7 +52,8 @@ module Kitchen
     # @param [Regexp,String] value of the filter
     def initialize(value)
       unless value.is_a?(::Regexp) || value.is_a?(::String)
-        raise ::ArgumentError, "PlatformFilter#new requires value to be a String or a Regexp"
+        raise ::ArgumentError, "PlatformFilter#new requires value to be a String or a Regexp, " \
+          "got #{value.inspect} (#{value.class})"
       end
 
       @value = value

data/lib/kitchen/provisioner/base.rb

@@ -230,7 +230,11 @@ module Kitchen
       # will persist after the process terminates. In other words, cleanup is
       # explicit. This method is safe to call multiple times.
       def cleanup_sandbox
-        return if sandbox_path.nil?
+        # Check the ivar, not #sandbox_path, which raises rather than
+        # returning nil when the sandbox was never created. This runs from
+        # an ensure block, so raising here would mask the error that kept
+        # #create_sandbox from finishing.
+        return if @sandbox_path.nil?
 
         debug("Cleaning up local sandbox in #{sandbox_path}")
         @install_script_path = nil

data/lib/kitchen/transport/exec.rb

@@ -134,11 +134,11 @@ module Kitchen
       # @return [Hash] hash of connection options
       # @api private
       def connection_options(data)
-        opts = {
+        {
           instance_name: instance.name,
-          kitchen_root: Dir.pwd,
+          kitchen_root: data[:kitchen_root] || Dir.pwd,
+          logger:,
         }
-        opts
       end
     end
   end

data/lib/kitchen/util.rb

@@ -99,17 +99,35 @@ module Kitchen
       end
     end
 
+    # The text substituted for a masked value.
+    MASK = "******".freeze
+
+    # A double-quoted string value, allowing for backslash escapes so that a
+    # quote inside the value does not end the match early.
+    QUOTED_VALUE = /"(?:\\.|[^"\\])*"/.source
+
     # Returns a string with masked values for specified parameters.
     #
+    # Hashes are commonly interpolated into these strings via Hash#inspect,
+    # whose rendering has changed over time, so every spelling a key/value
+    # pair has had is matched:
+    #
+    #   :key=>"value"     symbol key, Ruby <= 3.3
+    #   "key"=>"value"    string key, Ruby <= 3.3
+    #   key: "value"      symbol key, Ruby >= 3.4
+    #   "key" => "value"  string key, Ruby >= 3.4
+    #
     # @param string_to_mask [String] the object whose string representation is parsed
     # @param keys [Array] the list of keys whose values should be masked
-    # @return [String] the string representation of passed object with masked values
+    # @return [String] a new string with the values of the given keys masked
     def self.mask_values(string_to_mask, keys)
-      masked_string = string_to_mask
-      keys.each do |key|
-        masked_string.gsub!(/:#{key}=>"([^"]*)"/, %{:#{key}=>"******"})
+      keys.reduce(string_to_mask.to_s) do |masked, key|
+        key = ::Regexp.escape(key.to_s)
+        masked.gsub(
+          /(?<assignment>(?::#{key}|"#{key}")\s*=>\s*|(?<!\w)#{key}:\s*)#{QUOTED_VALUE}/,
+          %{\\k<assignment>"#{MASK}"}
+        )
       end
-      masked_string
     end
 
     # Returns a formatted string representing a duration in seconds.

data/lib/kitchen/verifier/base.rb

@@ -115,7 +115,11 @@ module Kitchen
       # will persist after the process terminates. In other words, cleanup is
       # explicit. This method is safe to call multiple times.
       def cleanup_sandbox
-        return if sandbox_path.nil?
+        # Check the ivar, not #sandbox_path, which raises rather than
+        # returning nil when the sandbox was never created. This runs from
+        # an ensure block, so raising here would mask the error that kept
+        # #create_sandbox from finishing.
+        return if @sandbox_path.nil?
 
         debug("Cleaning up local sandbox in #{sandbox_path}")
         FileUtils.rmtree(sandbox_path)

data/lib/kitchen/verifier/shell.rb

@@ -39,13 +39,12 @@ module Kitchen
       def call(state)
         info("[#{name}] Verify on instance #{instance.name} with state=#{state}")
         sleep_if_set
-        merge_state_to_env(state)
         if config[:remote_exec]
           instance.transport.connection(state) do |conn|
             conn.execute(config[:command])
           end
         else
-          shellout
+          shellout(state)
         end
         debug("[#{name}] Verify completed.")
       end
@@ -72,8 +71,8 @@ module Kitchen
         end
       end
 
-      def shellout
-        cmd = Mixlib::ShellOut.new(config[:command], config[:shellout_opts])
+      def shellout(state = {})
+        cmd = Mixlib::ShellOut.new(config[:command], shellout_opts(state))
         cmd.live_stream = config[:live_stream]
         cmd.run_command
         begin
@@ -83,16 +82,38 @@ module Kitchen
         end
       end
 
-      def merge_state_to_env(state)
-        env_state = { environment: {} }
-        env_state[:environment]["KITCHEN_INSTANCE"] = instance.name
-        env_state[:environment]["KITCHEN_PLATFORM"] = instance.platform.name
-        env_state[:environment]["KITCHEN_SUITE"] = instance.suite.name
-        env_state[:environment]["KITCHEN_USERNAME"] = instance.transport[:username] if instance.respond_to?(:transport)
+      # Returns the options to run the command with: whatever the user
+      # configured, with the KITCHEN_* variables merged into their environment
+      # rather than replacing it.
+      #
+      # This builds a new Hash instead of writing back to config. Nested config
+      # hashes are shared between every instance, so mutating :shellout_opts
+      # would leak one instance's environment into the others.
+      #
+      # @param state [Hash] mutable instance state
+      # @return [Hash] options for Mixlib::ShellOut
+      # @api private
+      def shellout_opts(state)
+        opts = config[:shellout_opts].to_h
+        opts.merge(
+          environment: opts.fetch(:environment, {}).to_h.merge(kitchen_environment(state))
+        )
+      end
+
+      # @param state [Hash] mutable instance state
+      # @return [Hash] the KITCHEN_* environment variables for this instance
+      # @api private
+      def kitchen_environment(state)
+        env = {
+          "KITCHEN_INSTANCE" => instance.name,
+          "KITCHEN_PLATFORM" => instance.platform.name,
+          "KITCHEN_SUITE" => instance.suite.name,
+        }
+        env["KITCHEN_USERNAME"] = instance.transport[:username] if instance.respond_to?(:transport)
         state.each_pair do |key, value|
-          env_state[:environment]["KITCHEN_" + key.to_s.upcase] = value.to_s
+          env["KITCHEN_" + key.to_s.upcase] = value.to_s
         end
-        config[:shellout_opts].merge!(env_state)
+        env
       end
     end
   end

data/lib/kitchen/version.rb

@@ -19,5 +19,5 @@ module Kitchen
   # The currently released version of Test Kitchen.
   #
   # @return [String] a semantic version string
-  VERSION = "4.1.3".freeze
+  VERSION = "4.1.4".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-kitchen
 version: !ruby/object:Gem::Version
-  version: 4.1.3
+  version: 4.1.4
 platform: ruby
 authors:
 - Fletcher Nichol
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf