beaker 7.6.0 → 7.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a103ea29759ffc3723d465fd0f0f06803701524d48b2c602a87a1a10a59cc5ed
-  data.tar.gz: 79ce1b1f90e3e435c36cb48c3f2c93f36e2a0506507bdd6fc2d2d22bebc71084
+  metadata.gz: 928c28e0ae2f5c8aa738b8bc402a9e61cc1392175e15bec5151186a63d565e8d
+  data.tar.gz: 55e3aabcda095f07e5315e9af08818cc050ea5514cb1409d373fe98b38482942
 SHA512:
-  metadata.gz: 25ce805f5b3303d8a8cc828b11652fd19fb47fd36c33795ec2df9a99e7eecce41402bc6d7fc118050d5265bad087a42459fab783e0061c18c622d7a27f333bfc
-  data.tar.gz: d41c8a37470b9f5c4e6440437e9f2643b96410d0a4010aaba6a8549337ea0867cb53992b74a03d44987cdce910e6215318e3a9dd25d2a02432fd39819adce188
+  metadata.gz: e25abfe8061d6566511bda5c51626e9e0e8c33216e77858104f8c300e07c5521ad524f87fade31a6f963ddcf1b595398747ec4a9ef800762e6348a6d919e64c0
+  data.tar.gz: 1b62bd88a3069e9f0b2c11df340d6d9515620cac2ccdf5ec0e5ff0afefc6ad0a0b94a0e0ea3a87484a058a2c6e21e1cf3f56de2da8b0387f8400c8259e3f7072

data/.github/workflows/release.yml

@@ -15,9 +15,9 @@ jobs:
     name: Build the gem
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Install Ruby
-        uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
           ruby-version: 'ruby'
       - name: Build gem
@@ -96,7 +96,7 @@ jobs:
         with:
           name: gem-artifact
       - name: Install Ruby
-        uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
           ruby-version: 'ruby'
       - name: Wait for release to propagate

data/.github/workflows/test.yml

@@ -16,16 +16,16 @@ jobs:
     outputs:
       ruby: ${{ steps.ruby.outputs.versions }}
     steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Install Ruby ${{ matrix.ruby }}
-        uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
           ruby-version: '4.0'
           bundler-cache: true
       - name: Run Rubocop
         run: bundle exec rake rubocop
       - id: ruby
-        uses: voxpupuli/ruby-version@656370e339050da63b86b1c631f5f88a3f4c0803 # 1.0.1
+        uses: voxpupuli/ruby-version@be0467ce7366d206b2e87f5b7a032a030120b7cb # 2.0.0
 
   test:
     name: "Ruby ${{ matrix.ruby }}"
@@ -38,9 +38,9 @@ jobs:
     env:
       BEAKER_HYPERVISOR: docker
     steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Install Ruby ${{ matrix.ruby }}
-        uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true

data/CHANGELOG.md

@@ -2,9 +2,23 @@
 
 All notable changes to this project will be documented in this file.
 
-## [7.6.0](https://github.com/voxpupuli/beaker/tree/7.6.0) (2026-07-13)
+## [7.7.0](https://github.com/voxpupuli/beaker/tree/7.7.0) (2026-08-14)
 
-[Full Changelog](https://github.com/voxpupuli/beaker/compare/v7.5.0...7.6.0)
+[Full Changelog](https://github.com/voxpupuli/beaker/compare/v7.6.0...7.7.0)
+
+**Implemented enhancements:**
+
+- Add Ruby 4.0 support [\#2015](https://github.com/voxpupuli/beaker/pull/2015) ([dependabot[bot]](https://github.com/apps/dependabot))
+
+**Fixed bugs:**
+
+- Stop Logger\#convert allocating a String per character [\#2021](https://github.com/voxpupuli/beaker/pull/2021) ([joshcooper](https://github.com/joshcooper))
+- Reduce Result allocations [\#2020](https://github.com/voxpupuli/beaker/pull/2020) ([joshcooper](https://github.com/joshcooper))
+- Reduce string allocations for junit results [\#2019](https://github.com/voxpupuli/beaker/pull/2019) ([joshcooper](https://github.com/joshcooper))
+
+## [v7.6.0](https://github.com/voxpupuli/beaker/tree/v7.6.0) (2026-07-13)
+
+[Full Changelog](https://github.com/voxpupuli/beaker/compare/v7.5.0...v7.6.0)
 
 **Implemented enhancements:**
 

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/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 = '7.6.0'
+    STRING = '7.7.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/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

data/spec/beaker/subcommand_spec.rb

@@ -120,8 +120,8 @@ module Beaker
       end
 
       it 'requires hosts flag' do
-        pending 'this was relying on FakeFS raising an exception'
-        expect { subcommand.init }.to raise_error(NotImplementedError)
+        expect { described_class.start(['init']) }
+          .to output(/No value provided for required options '--hosts'/).to_stderr
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beaker
 version: !ruby/object:Gem::Version
-  version: 7.6.0
+  version: 7.7.0
 platform: ruby
 authors:
 - Puppet
@@ -721,6 +721,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
@@ -754,7 +755,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Let's test Puppet!
 test_files: []