fix: fix tests failing on Windows for platform-specific reasons

Author: jcouball

.github/workflows/continuous_integration.yml

@@ -15,8 +15,8 @@ env:
   JRUBY_OPTS: --debug
 
 # Supported platforms / Ruby versions:
-#  - Ubuntu: MRI (3.1, 3.2, 3.3), TruffleRuby (24), JRuby (9.4)
-#  - Windows: MRI (3.1), JRuby (9.4)
+#  - Ubuntu: MRI (3.1, 3.2, 3.3, 3.4), TruffleRuby (24), JRuby (9.4)
+#  - Windows: MRI (3.1)
 
 jobs:
   build:
@@ -25,16 +25,25 @@ jobs:
     runs-on: ${{ matrix.operating-system }}
     continue-on-error: true
 
+    env:
+      FAIL_ON_LOW_COVERAGE: ${{ matrix.fail_on_low_coverage }}
+
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["3.1", "3.2", "3.3", "jruby-9.4", "truffleruby-24"]
+        ruby: ["3.1", "3.2", "3.3", "3.4"]
         operating-system: [ubuntu-latest]
+        fail_on_low_coverage: [true]
         include:
           - ruby: "3.1"
             operating-system: windows-latest
+            fail_on_low_coverage: false
           - ruby: "jruby-9.4"
-            operating-system: windows-latest
+            operating-system: ubuntu-latest
+            fail_on_low_coverage: false
+          - ruby: "truffleruby-24"
+            operating-system: ubuntu-latest
+            fail_on_low_coverage: false
 
     steps:
       - name: Checkout

.github/workflows/experimental_ruby_builds.yml

@@ -13,7 +13,7 @@ env:
 
 # Experimental platforms / Ruby versions:
 #  - Ubuntu: MRI (head), TruffleRuby (head), JRuby (head)
-#  - Windows: MRI (head), JRuby (head)
+#  - Windows: MRI (head), JRuby (head), JRuby (9.4)
 
 jobs:
   build:
@@ -25,17 +25,24 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
+        fail_on_low_coverage: [true]
         include:
           - ruby: head
             operating-system: ubuntu-latest
           - ruby: head
             operating-system: windows-latest
           - ruby: truffleruby-head
             operating-system: ubuntu-latest
+            fail_on_low_coverage: false
           - ruby: jruby-head
             operating-system: ubuntu-latest
+            fail_on_low_coverage: false
+          - ruby: "jruby-9.4"
+            operating-system: windows-latest
+            fail_on_low_coverage: false
           - ruby: jruby-head
             operating-system: windows-latest
+            fail_on_low_coverage: false
 
     steps:
       - name: Checkout

lib/ruby_git.rb

@@ -3,7 +3,6 @@
 require 'ruby_git/command_line'
 require 'ruby_git/encoding_normalizer'
 require 'ruby_git/errors'
-require 'ruby_git/file_helpers'
 require 'ruby_git/git_binary'
 require 'ruby_git/version'
 require 'ruby_git/working_tree'

lib/ruby_git/command_line/runner.rb

@@ -147,7 +147,7 @@ def initialize(env, binary_path, global_options, logger)
       #
       #   This array should be splatted into the parameter list.
       #
-      # @params options_hash [Hash] the options to initialize {RubyGit::CommandLine::Options}
+      # @param options_hash [Hash] the options to initialize {RubyGit::CommandLine::Options}
       #
       # @return [RubyGit::CommandLine::Result] the result of the command
       #

lib/ruby_git/file_helpers.rb

@@ -8,13 +8,33 @@ module RubyGit
   class GitBinary
     # Return a new GitBinary object
     #
+    # If the path is a command name, the command is search for in the PATH.
+    #
+    # If the path is a relative path, it is expanded to an absolute path relative to
+    # the current directory.
+    #
+    # If the path is an absolute path, it is used as is.
+    #
     # @example
     #   GitBinary.new
     #
-    def initialize(path = nil)
+    # @param [String] path the path to the git binary
+    #
+    def initialize(path = 'git')
       @path = Pathname.new(path) unless path.nil?
     end
 
+    # @attribute [r] path
+    #
+    # The path to the git binary
+    #
+    # @example
+    #   error.result #=> #<Pathname:git>
+    #
+    # @return [RubyGit::CommandLineResult]
+    #
+    attr_reader :path
+
     # Sets the path to the git binary
     #
     # The given path must point to an executable file or a RuntimeError is raised.
@@ -30,47 +50,7 @@ def initialize(path = nil)
     #   to an existing executable file.
     #
     def path=(path)
-      new_path = Pathname.new(path)
-      raise "'#{new_path}' does not exist." unless new_path.exist?
-      raise "'#{new_path}' is not a file." unless new_path.file?
-      raise "'#{new_path}' is not executable." unless new_path.executable?
-
-      @path = new_path
-    end
-
-    # Retrieve the path to the git binary
-    #
-    # @example Get the git found on the PATH
-    #   git = RubyGit::GitBinary.new
-    #   git.path
-    #    => #<Pathname:/usr/bin/git>
-    #
-    # @return [Pathname] the path to the git binary
-    #
-    # @raise [RuntimeError] if path was not set via `path=` and either PATH is not set
-    #   or git was not found on the path.
-    #
-    def path
-      @path || (@path = self.class.default_path)
-    end
-
-    # Get the default path to to a git binary by searching the PATH
-    #
-    # @example Find the pathname to `super_git`
-    #   git = RubyGit::GitBinary.new
-    #   git.default_path(basename: 'super_git')
-    #    => #<Pathname:/usr/bin/super_git>
-    #
-    # @param [String] basename The basename of the git command
-    #
-    # @return [Pathname] the path to the git binary found in the path
-    #
-    # @raise [RuntimeError] if either PATH is not set or an executable file
-    #   `basename` was not found on the path.
-    #
-    def self.default_path(basename: 'git', path: ENV.fetch('PATH', nil), path_ext: ENV.fetch('PATHEXT', nil))
-      RubyGit::FileHelpers.which(basename, path:, path_ext:) ||
-        raise("Could not find '#{basename}' in the PATH.")
+      @path = Pathname.new(path)
     end
 
     # The version of git referred to by the path

lib/ruby_git/git_binary.rb

@@ -11,21 +11,21 @@
 
   describe '#stdout' do
     it 'should return the stdout' do
-      expect(result.stdout.gsub("\r\n", "\n")).to eq("stdout message\n")
+      expect(result.stdout.with_linux_eol).to eq("stdout message\n")
     end
 
     context 'when #process_stdout has been called' do
       it 'should return the value returned from #process_stdout' do
         result.process_stdout { |s, _r| s.upcase! }
-        expect(result.stdout).to eq("STDOUT MESSAGE\n")
+        expect(result.stdout.with_linux_eol).to eq("STDOUT MESSAGE\n")
       end
     end
 
     context 'when #process_stdout has been called multiple times' do
       it 'should return the value returned from the last #process_stdout' do
-        result.process_stdout { |s, _r| s.upcase! }
+        result.process_stdout { |s, _r| s.chomp!.upcase! }
         result.process_stdout { |s, _r| s.reverse! }
-        expect(result.stdout).to eq("\nEGASSEM TUODTS")
+        expect(result.stdout.with_linux_eol).to eq('EGASSEM TUODTS')
       end
     end
   end
@@ -40,49 +40,49 @@
     end
 
     it 'should yield to the given block with the stdout and self' do
-      expect { |b| result.process_stdout(&b) }.to yield_with_args("stdout message\n", result)
+      expect { |b| result.process_stdout(&b) }.to yield_with_args("stdout message#{eol}", result)
     end
 
     context 'when called multiple times' do
       it 'should yield most recent value returned from #process_stdout' do
         result.process_stdout { |s, _r| s.upcase! }
-        expect { |b| result.process_stdout(&b) }.to yield_with_args("STDOUT MESSAGE\n", result)
+        expect { |b| result.process_stdout(&b) }.to yield_with_args("STDOUT MESSAGE#{eol}", result)
       end
     end
   end
 
   describe '#unprocessed_stdout' do
     context 'when #process_stdout HAS NOT been called' do
       it 'should return stdout' do
-        expect(result.unprocessed_stdout).to eq("stdout message\n")
+        expect(result.unprocessed_stdout).to eq("stdout message#{eol}")
       end
     end
 
     context 'when #process_stdout HAS been called' do
       it 'should return the original stdout' do
         result.process_stdout { |s, _r| s.upcase! }
-        expect(result.unprocessed_stdout).to eq("stdout message\n")
+        expect(result.unprocessed_stdout).to eq("stdout message#{eol}")
       end
     end
   end
 
   describe '#stderr' do
     it 'should return the stderr' do
-      expect(result.stderr.gsub("\r\n", "\n")).to eq("stderr message\n")
+      expect(result.stderr.with_linux_eol).to eq("stderr message\n")
     end
 
     context 'when #process_stderr has been called' do
       it 'should return the value returned from #process_stderr' do
         result.process_stderr { |s, _r| s.upcase! }
-        expect(result.stderr).to eq("STDERR MESSAGE\n")
+        expect(result.stderr.with_linux_eol).to eq("STDERR MESSAGE\n")
       end
     end
 
     context 'when #process_stderr has been called multiple times' do
       it 'should return the value returned from the last #process_stderr' do
-        result.process_stderr { |s, _r| s.upcase! }
+        result.process_stderr { |s, _r| s.chomp!.upcase! }
         result.process_stderr { |s, _r| s.reverse! }
-        expect(result.stderr).to eq("\nEGASSEM RREDTS")
+        expect(result.stderr.with_linux_eol).to eq('EGASSEM RREDTS')
       end
     end
   end
@@ -97,14 +97,14 @@
     end
 
     it 'should yield to the given block with the stderr and self' do
-      expect { |b| result.process_stderr(&b) }.to yield_with_args("stderr message\n", result)
+      expect { |b| result.process_stderr(&b) }.to yield_with_args("stderr message#{eol}", result)
     end
 
     context 'when called multiple times' do
       context 'on the last time it is called' do
         it 'should yield most recent value returned from #process_stderr' do
           result.process_stderr { |s, _r| s.upcase! }
-          expect { |b| result.process_stderr(&b) }.to yield_with_args("STDERR MESSAGE\n", result)
+          expect { |b| result.process_stderr(&b) }.to yield_with_args("STDERR MESSAGE#{eol}", result)
         end
       end
     end
@@ -113,14 +113,14 @@
   describe '#unprocessed_stderr' do
     context 'when #process_stderr HAS NOT been called' do
       it 'should return stderr' do
-        expect(result.unprocessed_stderr).to eq("stderr message\n")
+        expect(result.unprocessed_stderr.with_linux_eol).to eq("stderr message\n")
       end
     end
 
     context 'when #process_stderr HAS been called' do
       it 'should return the original stderr' do
         result.process_stderr { |s, _r| s.upcase! }
-        expect(result.unprocessed_stderr).to eq("stderr message\n")
+        expect(result.unprocessed_stderr.with_linux_eol).to eq("stderr message\n")
       end
     end
   end