beaker 6.8.1 → 6.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 569f6e836d92183b8d192a6865f0db91f711fe52235c37a4d3faaf0dbde2daec
-  data.tar.gz: 49dd48391cb708a5dd9eb17272c8a84df1658b1263664c185caa8da81592b213
+  metadata.gz: f34a28e10b3448ee6294cdfd53903ec145d6c81d28b95dc7370a30936922e80c
+  data.tar.gz: 7e7ba934516ed374c96c97357047d56693dddbd23a45be3a6b088b5dcdbae52a
 SHA512:
-  metadata.gz: a0f60c37aa1325936de181703c981bab351560035cb42b50b9c0789ce39463c655848c7856d4387dac64a4d7dbf1be6b16102447017aec25fb3befe0a7af3b78
-  data.tar.gz: b26dc87dbff51e7437594c17a0dfac7dd0287a7e91a5f03070dbb7783f2e32a26d832ce7048a32713aec9d04824aa4b2bc1780a0625b71c1d1dd9cd0ead43142
+  metadata.gz: b7a2345337cec50941ba9aa8c20a8f4cfab3bd0c84e1bb74f0e8c506ff29f894568562c423aa815fcaaf16b423dbde3150117a579c3463481802b91d3bb159eb
+  data.tar.gz: ba81525b5f025ad793d7175b694a2a95702af799282ddcec8f060e3c4e0badd5ded71a905b2239c7230d4161056c0a9a69511fd7e318eb675605bcfde0aa3aa5

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [6.9.0](https://github.com/voxpupuli/beaker/tree/6.9.0) (2026-08-14)
+
+[Full Changelog](https://github.com/voxpupuli/beaker/compare/6.8.1...6.9.0)
+
+**Implemented enhancements:**
+
+- \(maint\) Add Ubuntu 26.04 \(resolute\) codename mapping [\#2024](https://github.com/voxpupuli/beaker/pull/2024) ([bastelfreak](https://github.com/bastelfreak))
+
+**Fixed bugs:**
+
+- Ensure correct encoding for logging and fix performance bugs [\#2027](https://github.com/voxpupuli/beaker/pull/2027) ([bastelfreak](https://github.com/bastelfreak))
+- Don't lose a whole junit report to one bad byte [\#2026](https://github.com/voxpupuli/beaker/pull/2026) ([bastelfreak](https://github.com/bastelfreak))
+- Stop escape\_invalid\_xml\_chars allocating per character [\#2025](https://github.com/voxpupuli/beaker/pull/2025) ([bastelfreak](https://github.com/bastelfreak))
+
+**Closed issues:**
+
+- The tmpfile method in pswindows needs to implement the use of the extension parameter [\#1955](https://github.com/voxpupuli/beaker/issues/1955)
+
 ## [6.8.1](https://github.com/voxpupuli/beaker/tree/6.8.1) (2025-06-16)
 
 [Full Changelog](https://github.com/voxpupuli/beaker/compare/6.8.0...6.8.1)

data/Rakefile

@@ -191,8 +191,8 @@ begin
     config.project = 'beaker'
     gem_version = Gem::Specification.load("#{config.project}.gemspec").version
     config.future_release = gem_version
-    config.release_branch = 'master'
-    config.exclude_tags_regex = /\A4\./
+    config.release_branch = '6.x'
+    config.exclude_tags_regex = /^v?[4,7]\./
     config.since_tag = '5.7.0'
   end
 rescue LoadError

data/lib/beaker/logger.rb

@@ -197,7 +197,7 @@ module Beaker
       else
         # Remove invalid and undefined UTF-8 character encodings
         string = string.to_s.dup.force_encoding('UTF-8')
-        return string.to_s.chars.select { |i| i.valid_encoding? }.join
+        string.scrub('')
       end
     end
 

data/lib/beaker/logger_junit.rb

@@ -120,21 +120,34 @@ module Beaker
       self.escape_invalid_xml_chars(Logger.strip_color_codes(string))
     end
 
+    # Every character {is_valid_xml} rejects, as one pattern. Note that this
+    # tracks that method rather than the specification it cites: #xD is absent
+    # from both, and both take the last range as 0x100000 rather than the
+    # 0x10000 the specification gives. Changing either would change the
+    # contents of every junit report, so they are left alone here and the specs
+    # walk the whole range to keep the two in step.
+    INVALID_XML_CHARS = /[^\u{9}\u{A}\u{20}-\u{D7FF}\u{E000}-\u{FFFD}\u{100000}-\u{10FFFF}]/
+
     # Escape invalid XML UTF-8 codes from provided string, see http://www.w3.org/TR/xml/#charsets for valid
     # character specification
     # @param [String] string The string to remove invalid codes from
     # @return [String] Properly escaped string
     def self.escape_invalid_xml_chars string
-      escaped_string = ""
-      string.chars.each do |i|
-        char_as_codestring = i.unpack("U*").join
-        escaped_string << if self.is_valid_xml(char_as_codestring.to_i)
-                            i
-                          else
-                            "\\#{char_as_codestring}"
-                          end
-      end
-      escaped_string
+      # Bytes that are not valid in their own encoding cannot be represented in
+      # xml at all, and would make the gsub below raise. Drop them, the same
+      # way Logger#convert does further upstream. Raising matters more here
+      # than it might look: TestSuiteResult calls #format_cdata from inside a
+      # blanket rescue that abandons the whole junit document, so one stray
+      # byte in one sublog loses every test result for the run.
+      string = string.dup.force_encoding(Encoding::UTF_8) unless string.encoding == Encoding::UTF_8
+      string = string.scrub('') unless string.valid_encoding?
+
+      # This walked the string a character at a time, unpacking each one into
+      # an array and joining it back into a string just to read its codepoint.
+      # That is around four objects per character, and it runs over the whole
+      # sublog of every test case at the end of a run: 28 million objects, and
+      # 98MB of permanently grown ruby heap, for a 6MB suite.
+      string.gsub(INVALID_XML_CHARS) { |char| "\\#{char.ord}" }
     end
 
     # Determine if the provided number falls in the range of accepted xml unicode values

data/lib/beaker/platform.rb

@@ -11,7 +11,8 @@ module Beaker
                      "bookworm" => "12",
                      "bullseye" => "11",
                      "buster" => "10", },
-        :ubuntu => { "noble" => "2404",
+        :ubuntu => { "resolute" => "2604",
+                     "noble" => "2404",
                      "jammy" => "2204",
                      "focal" => "2004",
                      "bionic" => "1804", },

data/lib/beaker/result.rb

@@ -31,10 +31,24 @@ module Beaker
       return string.gsub(/\r\n?/, "\n")
     end
 
-    def convert string
-      # Remove invalid and undefined UTF-8 character encodings
-      string.to_s.force_encoding('UTF-8')
-      string.to_s.chars.select { |i| i.valid_encoding? }.join
+    # This method behaves differently when given a string instance, subclass
+    # or something else. The latter two cases should be deprecated.
+    def convert(string)
+      # guard against nil, which never worked on accident
+      raise TypeError, "Beaker::Result#convert cannot convert nil to a String" if string.nil?
+
+      unless string.instance_of?(String)
+        # For a string subclass, `string.to_s` returns a copy, so calling
+        # `force_encoding` on it was meaningless.
+        return string.to_s.scrub('')
+      end
+
+      # Data collected from the connection is binary (ASCII-8BIT). In that
+      # encoding, every byte is a valid character, so we tag the string as UTF-8
+      string.force_encoding('UTF-8')
+
+      # And remove invalid and undefined UTF-8 character encodings.
+      string.scrub('')
     end
 
     def log(logger)

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '6.8.1'
+    STRING = '6.9.0'
   end
 end

data/spec/beaker/logger_junit_spec.rb

@@ -32,6 +32,42 @@ module Beaker
         testing_string = 'pants man, pants!'
         expect(described_class.escape_invalid_xml_chars(testing_string)).to be === testing_string
       end
+
+      it 'escapes carriage returns, which is_valid_xml does not accept' do
+        expect(described_class.escape_invalid_xml_chars("a\rb")).to be === 'a\13b'
+      end
+
+      it 'agrees with is_valid_xml on every codepoint' do
+        # INVALID_XML_CHARS has to track is_valid_xml rather than the spec that
+        # method cites, so walk the whole range instead of trusting either.
+        codepoints = (0..0xD7FF).to_a + (0xE000..0x10FFFF).to_a # surrogates cannot be in a String
+        codepoints.each_slice(50_000) do |slice|
+          string = slice.map { |c| c.chr(Encoding::UTF_8) }.join
+          expected = slice.map { |c| described_class.is_valid_xml(c) ? c.chr(Encoding::UTF_8) : "\\#{c}" }.join
+          expect(described_class.escape_invalid_xml_chars(string)).to eq(expected)
+        end
+      end
+
+      it 'drops invalid encodings rather than raising' do
+        # TestSuiteResult calls format_cdata from inside a blanket rescue that
+        # abandons the whole junit document, so an exception raised here would
+        # cost the run its entire test report.
+        expect(described_class.escape_invalid_xml_chars("ok\xFFbad".b)).to eq('okbad')
+      end
+
+      it 'accepts a frozen string' do
+        expect(described_class.escape_invalid_xml_chars('pants'.freeze)).to eq('pants')
+      end
+    end
+
+    describe '#format_cdata' do
+      it 'strips colour codes and escapes what is left' do
+        expect(described_class.format_cdata("\e[00;33mpants\e[00;00m")).to eq('pants')
+      end
+
+      it 'survives invalid encodings' do
+        expect(described_class.format_cdata("\e[00;33mok\xFFbad".b)).to eq('okbad')
+      end
     end
 
     describe '#copy_stylesheet_into_xml_dir' do

data/spec/beaker/logger_spec.rb

@@ -24,6 +24,24 @@ module Beaker
         valid_utf8.freeze
         expect(logger.convert(valid_utf8)).to be === valid_utf8
       end
+
+      it 'leaves the string it was given alone' do
+        expect(logger.convert(invalid_utf8)).not_to equal(invalid_utf8)
+        expect(invalid_utf8.bytes).to include(0xAD)
+      end
+
+      it 'converts each item of an array' do
+        expect(logger.convert([valid_utf8, invalid_utf8])).to eq([valid_utf8, valid_utf8])
+      end
+
+      it 'converts arrays of arrays' do
+        expect(logger.convert([[invalid_utf8], valid_utf8])).to eq([[valid_utf8], valid_utf8])
+      end
+
+      it 'converts anything that can describe itself' do
+        expect(logger.convert(42)).to eq('42')
+        expect(logger.convert(nil)).to eq('')
+      end
     end
 
     describe '#generate_dated_log_folder' do

data/spec/beaker/platform_spec.rb

@@ -78,6 +78,11 @@ module Beaker
         expect(platform.with_version_codename).to be === 'debian-bullseye-xxx'
       end
 
+      it "can convert ubuntu-2604-xxx to ubuntu-resolute-xxx" do
+        @name = 'ubuntu-2604-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-resolute-xxx'
+      end
+
       it "can convert ubuntu-2404-xxx to ubuntu-noble-xxx" do
         @name = 'ubuntu-2404-xxx'
         expect(platform.with_version_codename).to be === 'ubuntu-noble-xxx'
@@ -122,6 +127,11 @@ module Beaker
         expect(platform.with_version_number).to be === 'ubuntu-2204-xxx'
       end
 
+      it "can convert ubuntu-resolute-xxx to ubuntu-2604-xxx" do
+        @name = 'ubuntu-resolute-xxx'
+        expect(platform.with_version_number).to be === 'ubuntu-2604-xxx'
+      end
+
       %w[centos redhat].each do |p|
         it "leaves #{p}-7-xxx alone" do
           @name = "#{p}-7-xxx"

data/spec/beaker/result_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+module Beaker
+  describe Result do
+    subject(:result) { described_class.new(host, cmd) }
+
+    let(:host) { 'my_host' }
+    let(:cmd)  { 'ls -la' }
+
+    # Command output reaches a Result the way net-ssh hands it over: as chunks
+    # of binary data, appended as they arrive.
+    def binary(string)
+      string.dup.force_encoding('ASCII-8BIT')
+    end
+
+    describe '#initialize' do
+      it 'starts with empty streams and no exit code' do
+        expect(result.stdout).to eq('')
+        expect(result.stderr).to eq('')
+        expect(result.output).to eq('')
+        expect(result.exit_code).to be_nil
+      end
+    end
+
+    describe '#convert' do
+      let(:valid_utf8) { "modules\n├── jimmy-appleseed (v1.1.0)\n└── jimmy-crakorn (v0.4.0)\n" }
+
+      it 'preserves valid utf-8' do
+        expect(result.convert(valid_utf8.dup)).to eq(valid_utf8)
+      end
+
+      it 'strips invalid utf-8 byte sequences' do
+        expect(result.convert(binary("ok\xFFbad"))).to eq('okbad')
+      end
+
+      it 'strips a truncated multi-byte sequence' do
+        expect(result.convert(binary("ok\xE3\x81"))).to eq('ok')
+      end
+
+      it 'returns utf-8 whatever encoding it was handed' do
+        expect(result.convert(binary('plain')).encoding).to eq(Encoding::UTF_8)
+      end
+
+      it 'modifies the argument encoding in place' do
+        string = binary('plain')
+        result.convert(string)
+        expect(string.encoding).to eq(Encoding::UTF_8)
+      end
+
+      it 'returns a new string rather than scrubbing the one it was given' do
+        string = binary("ok\xFFbad")
+        expect(result.convert(string)).not_to equal(string)
+        expect(string.bytes).to include(0xFF)
+      end
+
+      context 'when handed String subclass' do
+        let(:string_subclass) { Class.new(String) }
+
+        it 'accepts String subclass' do
+          expect(result.convert(string_subclass.new('plain'))).to eq('plain')
+        end
+
+        it 'leaves invalid encodings in place, as it always has' do
+          subclass = string_subclass.new(binary("ok\xFFbad"))
+          expect(result.convert(subclass).bytes).to include(0xFF)
+        end
+
+        it 'converts anything else that can describe itself' do
+          expect(result.convert(5)).to eq('5')
+        end
+
+        it 'raises TypeError on nil' do
+          expect { result.convert(nil) }.to raise_error(TypeError, /cannot convert nil to a String/)
+        end
+      end
+    end
+
+    describe '#normalize_line_endings' do
+      it 'converts crlf to lf' do
+        expect(result.normalize_line_endings("a\r\nb")).to eq("a\nb")
+      end
+
+      it 'converts a lone cr to lf' do
+        expect(result.normalize_line_endings("a\rb")).to eq("a\nb")
+      end
+
+      it 'leaves lf alone' do
+        expect(result.normalize_line_endings("a\nb")).to eq("a\nb")
+      end
+    end
+
+    describe '#finalize!' do
+      before do
+        result.stdout << binary("out\xFF\r\n")
+        result.stderr << binary("err\xFF\r\n")
+        result.output << binary("out\xFF\r\nerr\xFF\r\n")
+        result.finalize!
+      end
+
+      it 'scrubs and normalizes every stream' do
+        expect(result.stdout).to eq("out\n")
+        expect(result.stderr).to eq("err\n")
+        expect(result.output).to eq("out\nerr\n")
+      end
+
+      it 'keeps the unscrubbed bytes in the raw_ attributes' do
+        expect(result.raw_stdout.bytes).to include(0xFF)
+        expect(result.raw_stderr.bytes).to include(0xFF)
+        expect(result.raw_output.bytes).to include(0xFF)
+      end
+
+      it 'leaves the raw_ line endings alone' do
+        expect(result.raw_stdout).to include("\r\n")
+      end
+    end
+
+    describe '#formatted_output' do
+      before do
+        result.output << (1..15).map { |i| "line #{i}" }.join("\n")
+      end
+
+      it 'returns the last ten lines by default, tab indented' do
+        expect(result.formatted_output).to eq((6..15).map { |i| "\tline #{i}" }.join("\n"))
+      end
+
+      it 'honours a limit' do
+        expect(result.formatted_output(2)).to eq("\tline 14\n\tline 15")
+      end
+    end
+
+    describe '#exit_code_in?' do
+      it 'is true when the exit code is in the range' do
+        result.exit_code = 2
+        expect(result.exit_code_in?([0, 2])).to be true
+      end
+
+      it 'is false when it is not' do
+        result.exit_code = 1
+        expect(result.exit_code_in?([0, 2])).to be false
+      end
+    end
+
+    describe '#success?' do
+      it 'is true only for an exit code of zero' do
+        result.exit_code = 0
+        expect(result).to be_success
+      end
+
+      it 'is false for a non-zero exit code' do
+        result.exit_code = 1
+        expect(result).not_to be_success
+      end
+
+      it 'is false when no exit code was collected' do
+        expect(result).not_to be_success
+      end
+    end
+
+    describe '#log' do
+      let(:logger) { instance_double(Beaker::Logger) }
+
+      it 'reports a non-zero exit code' do
+        result.exit_code = 1
+        expect(logger).to receive(:debug).with('Exited: 1')
+        result.log(logger)
+      end
+
+      it 'says nothing for a successful command' do
+        result.exit_code = 0
+        expect(logger).not_to receive(:debug)
+        result.log(logger)
+      end
+
+      it 'says nothing when no exit code was collected' do
+        expect(logger).not_to receive(:debug)
+        result.log(logger)
+      end
+    end
+  end
+
+  describe NullResult do
+    subject(:result) { described_class.new('my_host', 'ls -la') }
+
+    it 'succeeds without having run anything' do
+      expect(result.exit_code).to eq(0)
+      expect(result).to be_success
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beaker
 version: !ruby/object:Gem::Version
-  version: 6.8.1
+  version: 6.9.0
 platform: ruby
 authors:
 - Puppet
@@ -659,6 +659,7 @@ files:
 - spec/beaker/options/validator_spec.rb
 - spec/beaker/perf_spec.rb
 - spec/beaker/platform_spec.rb
+- spec/beaker/result_spec.rb
 - spec/beaker/shared/error_handler_spec.rb
 - spec/beaker/shared/fog_credentials_spec.rb
 - spec/beaker/shared/host_manager_spec.rb
@@ -692,7 +693,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Let's test Puppet!
 test_files: []