git-fastclone 1.3.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e6bcf21a8d3b9c1b30b93efc17487fa8dfa0c319b8636efc1f96a430e27c876
-  data.tar.gz: 7720184507344bc94ad63e45b135e0948aab6776d371867159a4cd84dcfd2a0d
+  metadata.gz: 9d5ae1cf32d0c0f13534a9e7d986cb4d1845cec980085b27332cf366829b0ccf
+  data.tar.gz: 909d9f98c4d09d9f52b70539749639b3fc57464f6b622ac9620d24509e690476
 SHA512:
-  metadata.gz: 13e48d37e5162a8288da830232476fb12ba7b8bb01c0ef0834a8eb372a224c0a2f8430d10002a9c54c1ec7fc7713db384ef32d0da9f1707366663bbe10e9ff04
-  data.tar.gz: 1f74af758cfbd3f47f98f6d4fc1a47e24bf574f9e7b58116b9aa3f6186ab334e66c66e413416641b7ce6494b3099b45158142fbd88b4c1bb3a0bb48a86c9b912
+  metadata.gz: 8f20b952bdfe79605012ae2b365dfb01b3621239f75e2e9e40aef76d807c9a2eb1af5b876dbd34032311efeea0ae1a9990c18295c3256ea8d7a622f99b1e1032
+  data.tar.gz: e9fa4c99ce664a1c1780b76a5a952cdef57b1d43ddf92ea870bba0c29a76fce2e2b0281b6698af48c5a60c1446427c66614fb226cb159f3870b614e06b2d897b

data/README.md

@@ -44,8 +44,10 @@ Usage
     git fastclone [options] <git-repo-url>
 
     -b, --branch <branch>   Clone a specific branch
-    -v, --verbose           Shows more info
-    -c, --color             Pretty colors!
+    -v, --verbose           Verbose mode
+    -c, --color             Display colored output
+        --config CONFIG     Git config applied to the cloned repo
+        --lock-timeout N    Timeout in seconds to acquire a lock on any reference repo.
 
 Change the default `REFERENCE_REPO_DIR` environment variable if necessary.
 

data/bin/git-fastclone

@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
 
 require 'git-fastclone'
 

data/lib/git-fastclone/version.rb

@@ -2,5 +2,5 @@
 
 # Version string for git-fastclone
 module GitFastCloneVersion
-  VERSION = '1.3.0'.freeze
+  VERSION = '1.3.2'
 end

data/lib/git-fastclone.rb

@@ -41,7 +41,7 @@ module GitFastClone
 
     def reference_repo_dir(url, reference_dir, using_local_repo)
       if using_local_repo
-        File.join(reference_dir, 'local' + reference_repo_name(url))
+        File.join(reference_dir, "local#{reference_repo_name(url)}")
       else
         File.join(reference_dir, reference_repo_name(url))
       end
@@ -69,9 +69,9 @@ module GitFastClone
 
     include GitFastClone::UrlHelper
 
-    DEFAULT_REFERENCE_REPO_DIR = '/var/tmp/git-fastclone/reference'.freeze
+    DEFAULT_REFERENCE_REPO_DIR = '/var/tmp/git-fastclone/reference'
 
-    DEFAULT_GIT_ALLOW_PROTOCOL = 'file:git:http:https:ssh'.freeze
+    DEFAULT_GIT_ALLOW_PROTOCOL = 'file:git:http:https:ssh'
 
     attr_accessor :reference_dir, :prefetch_submodules, :reference_updated, :reference_mutex,
                   :options, :logger, :abs_clone_path, :using_local_repo, :verbose, :color,
@@ -137,7 +137,7 @@ module GitFastClone
 
         opts.on('-v', '--verbose', 'Verbose mode') do
           self.verbose = true
-          self.logger = Logger.new(STDOUT)
+          self.logger = Logger.new($stdout)
           logger.formatter = proc do |_severity, _datetime, _progname, msg|
             "#{msg}\n"
           end
@@ -163,7 +163,7 @@ module GitFastClone
       parse_options
 
       unless ARGV[0]
-        STDERR.puts usage
+        warn usage
         exit(129)
       end
 
@@ -189,18 +189,40 @@ module GitFastClone
       [url, path, options]
     end
 
+    def clear_clone_dest_if_needed(attempt_number, clone_dest)
+      return unless attempt_number.positive?
+
+      dest_with_dotfiles = Dir.glob("#{clone_dest}/*", File::FNM_DOTMATCH)
+      dest_files = dest_with_dotfiles.reject { |f| %w[. ..].include?(File.basename(f)) }
+      return if dest_files.empty?
+
+      clear_clone_dest(dest_files)
+    end
+
+    def clear_clone_dest(dest_files)
+      puts 'Non-empty clone directory found, clearing its content now.'
+      FileUtils.rm_rf(dest_files)
+    end
+
     # Checkout to SOURCE_DIR. Update all submodules recursively. Use reference
     # repos everywhere for speed.
     def clone(url, rev, src_dir, config)
+      clone_dest = File.join(abs_clone_path, src_dir).to_s
       initial_time = Time.now
 
-      with_git_mirror(url) do |mirror|
+      if Dir.exist?(clone_dest) && !Dir.empty?(clone_dest)
+        raise "Can't clone into an existing non-empty path: #{clone_dest}"
+      end
+
+      with_git_mirror(url) do |mirror, attempt_number|
+        clear_clone_dest_if_needed(attempt_number, clone_dest)
+
         clone_command = '--quiet --reference :mirror :url :path'
         clone_command += ' --config :config' unless config.nil?
         Terrapin::CommandLine.new('git clone', clone_command)
                              .run(mirror: mirror.to_s,
                                   url: url.to_s,
-                                  path: File.join(abs_clone_path, src_dir).to_s,
+                                  path: clone_dest,
                                   config: config.to_s)
       end
 
@@ -245,7 +267,7 @@ module GitFastClone
 
     def thread_update_submodule(submodule_url, submodule_path, threads, pwd)
       threads << Thread.new do
-        with_git_mirror(submodule_url) do |mirror|
+        with_git_mirror(submodule_url) do |mirror, _|
           Terrapin::CommandLine.new('cd', ':dir; git submodule update --quiet --reference :mirror :path')
                                .run(dir: File.join(abs_clone_path, pwd).to_s,
                                     mirror: mirror.to_s,
@@ -270,14 +292,12 @@ module GitFastClone
       lockfile.close
     end
 
-    def with_reference_repo_thread_lock(url)
+    def with_reference_repo_thread_lock(url, &block)
       # We also need thread level locking because pre-fetch means multiple threads can
       # attempt to update the same repository from a single git-fastclone process
       # file locks in posix are tracked per process, not per userland thread.
       # This gives us the equivalent of pthread_mutex around these accesses.
-      reference_mutex[reference_repo_name(url)].synchronize do
-        yield
-      end
+      reference_mutex[reference_repo_name(url)].synchronize(&block)
     end
 
     def update_submodule_reference(url, submodule_url_list)
@@ -338,6 +358,32 @@ module GitFastClone
       raise e if fail_hard
     end
 
+    def retriable_error?(error)
+      error_strings = [
+        'fatal: missing blob object',
+        'fatal: remote did not send all necessary objects',
+        /fatal: packed object [a-z0-9]+ \(stored in .*?\) is corrupt/,
+        /fatal: pack has \d+ unresolved delta/,
+        'error: unable to read sha1 file of ',
+        'fatal: did not receive expected object',
+        /^fatal: unable to read tree [a-z0-9]+\n^warning: Clone succeeded, but checkout failed/
+      ]
+      error.to_s =~ /^STDERR:\n.*^#{Regexp.union(error_strings)}/m
+    end
+
+    def print_formatted_error(error)
+      indented_error = error.to_s.split("\n").map { |s| ">  #{s}\n" }.join
+      puts "Encountered a retriable error:\n#{indented_error}\n\nRemoving the fastclone cache."
+    end
+
+    # To avoid corruption of the cache, if we failed to update or check out we remove
+    # the cache directory entirely. This may cause the current clone to fail, but if the
+    # underlying error from git is transient it will not affect future clones.
+    def clear_cache(dir, url)
+      FileUtils.remove_entry_secure(dir, force: true)
+      reference_updated.delete(reference_repo_name(url))
+    end
+
     # This command will create and bring the mirror up-to-date on-demand,
     # blocking any code passed in while the mirror is brought up-to-date
     #
@@ -346,42 +392,31 @@ module GitFastClone
     # moment means we only need to synchronize our own threads in case a single
     # submodule url is included twice via multiple dependency paths
     def with_git_mirror(url)
+      retries_allowed ||= 1
+      attempt_number ||= 0
+
       update_reference_repo(url, true)
+      dir = reference_repo_dir(url, reference_dir, using_local_repo)
 
       # Sometimes remote updates involve re-packing objects on a different thread
       # We grab the reference repo lock here just to make sure whatever thread
       # ended up doing the update is done with its housekeeping.
       # This makes sure we have control and unlock when the block returns:
       with_reference_repo_lock(url) do
-        dir = reference_repo_dir(url, reference_dir, using_local_repo)
-        retries_left = 1
-
-        begin
-          yield dir
-        rescue Terrapin::ExitStatusError => e
-          error_strings = [
-            'fatal: missing blob object',
-            'fatal: remote did not send all necessary objects',
-            /fatal: packed object [a-z0-9]+ \(stored in .*?\) is corrupt/,
-            /fatal: pack has \d+ unresolved delta/,
-            'error: unable to read sha1 file of ',
-            'fatal: did not receive expected object',
-            /^fatal: unable to read tree [a-z0-9]+\n^warning: Clone succeeded, but checkout failed/
-          ]
-          if e.to_s =~ /^STDERR:\n.+^#{Regexp.union(error_strings)}/m
-            # To avoid corruption of the cache, if we failed to update or check out we remove
-            # the cache directory entirely. This may cause the current clone to fail, but if the
-            # underlying error from git is transient it will not affect future clones.
-            FileUtils.remove_entry_secure(dir, force: true)
-            if retries_left > 0
-              retries_left -= 1
-              retry
-            end
-          end
+        yield dir, attempt_number
+      end
+    rescue Terrapin::ExitStatusError => e
+      if retriable_error?(e)
+        print_formatted_error(e)
+        clear_cache(dir, url)
 
-          raise
+        if attempt_number < retries_allowed
+          attempt_number += 1
+          retry
         end
       end
+
+      raise
     end
 
     def usage

data/spec/git_fastclone_runner_spec.rb

@@ -24,7 +24,7 @@ describe GitFastClone::Runner do
   let(:test_reference_repo_dir) { '/var/tmp/git-fastclone/reference/test_reference_dir' }
   let(:placeholder_arg) { 'PH' }
 
-  let(:lockfile) do
+  def create_lockfile_double
     lockfile = double
     expect(lockfile).to receive(:flock).with(File::LOCK_EX).once
     expect(lockfile).to receive(:flock).with(File::LOCK_UN).once
@@ -32,6 +32,8 @@ describe GitFastClone::Runner do
     lockfile
   end
 
+  let(:lockfile) { create_lockfile_double }
+
   before do
     stub_const('ARGV', ['ssh://git@git.com/git-fastclone.git', 'test_reference_dir'])
   end
@@ -91,7 +93,8 @@ describe GitFastClone::Runner do
       expect(Time).to receive(:now).twice { 0 }
       allow(Dir).to receive(:pwd) { '/pwd' }
       allow(Dir).to receive(:chdir).and_yield
-      allow(subject).to receive(:with_git_mirror).and_yield('/cache')
+      allow(subject).to receive(:with_git_mirror).and_yield('/cache', 0)
+      expect(subject).to receive(:clear_clone_dest_if_needed).once {}
     end
 
     it 'should clone correctly' do
@@ -114,21 +117,39 @@ describe GitFastClone::Runner do
       subject.clone(placeholder_arg, placeholder_arg, '.', nil)
     end
 
-    describe 'with custom configs' do
-      it 'should clone correctly' do
-        expect(Terrapin::CommandLine).to receive(:new).with(
-          'git clone',
-          '--quiet --reference :mirror :url :path --config :config'
-        ) { terrapin_commandline_double }
-        expect(terrapin_commandline_double).to receive(:run).with(
-          mirror: '/cache',
-          url: placeholder_arg,
-          path: '/pwd/.',
-          config: 'config'
-        )
-
-        subject.clone(placeholder_arg, nil, '.', 'config')
-      end
+    it 'should clone correctly with custom configs' do
+      expect(Terrapin::CommandLine).to receive(:new).with(
+        'git clone',
+        '--quiet --reference :mirror :url :path --config :config'
+      ) { terrapin_commandline_double }
+      expect(terrapin_commandline_double).to receive(:run).with(
+        mirror: '/cache',
+        url: placeholder_arg,
+        path: '/pwd/.',
+        config: 'config'
+      )
+
+      subject.clone(placeholder_arg, nil, '.', 'config')
+    end
+  end
+
+  describe '.clear_clone_dest_if_needed' do
+    it 'does not clear on first attempt' do
+      expect(Dir).not_to receive(:glob)
+      expect(subject).not_to receive(:clear_clone_dest)
+      subject.clear_clone_dest_if_needed(0, '/some/path')
+    end
+
+    it 'does not clear if the directory is only FNM_DOTMATCH self and parent refs' do
+      expect(Dir).to receive(:glob).and_return(%w[. ..])
+      expect(subject).not_to receive(:clear_clone_dest)
+      subject.clear_clone_dest_if_needed(1, '/some/path')
+    end
+
+    it 'does clear if the directory is not empty' do
+      expect(Dir).to receive(:glob).and_return(%w[. .. /some/path/file.txt])
+      expect(subject).to receive(:clear_clone_dest) {}
+      subject.clear_clone_dest_if_needed(1, '/some/path')
     end
   end
 
@@ -312,209 +333,200 @@ describe GitFastClone::Runner do
   end
 
   describe '.with_git_mirror' do
-    it 'should yield properly' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    def retriable_error
+      %(
+        STDOUT:
 
-      subject.with_git_mirror(test_url_valid) do
-        yielded << test_url_valid
-      end
+        STDERR:
 
-      expect(yielded).to eq([test_url_valid])
+        fatal: bad object ee35b1e14e7c3a53dcc14d82606e5b872f6a05a7
+        fatal: remote did not send all necessary objects
+      ).strip.split("\n").map(&:strip).join("\n")
     end
 
-    it 'should retry when the cache looks corrupted' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+    def try_with_git_mirror(responses, results)
+      lambdas = responses.map do |response|
+        if response == true
+          # Simulate successful response
+          ->(url) { url }
+        else
+          # Simulate failed error response
+          ->(_url) { raise Terrapin::ExitStatusError, response }
+        end
+      end
 
-            STDERR:
+      subject.with_git_mirror(test_url_valid) do |url, attempt|
+        raise 'Not enough responses were provided!' if lambdas.empty?
 
-            fatal: bad object ee35b1e14e7c3a53dcc14d82606e5b872f6a05a7
-            fatal: remote did not send all necessary objects
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
+        yielded << [lambdas.shift.call(url), attempt]
       end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+      expect(lambdas).to be_empty
+      expect(yielded).to eq(results)
     end
 
-    it 'should retry when the clone succeeds but checkout fails with corrupt packed object' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+    let(:expected_commands) { [] }
+    let(:expected_commands_args) { [] }
 
-            STDERR:
-
-            fatal: packed object 7c4d79704f8adf701f38a7bfb3e33ec5342542f1 (stored in /private/var/tmp/git-fastclone/reference/some-repo.git/objects/pack/pack-d37d7ed3e88d6e5f0ac141a7b0a2b32baf6e21a0.pack) is corrupt
-            warning: Clone succeeded, but checkout failed.
-            You can inspect what was checked out with 'git status' and retry with 'git restore --source=HEAD :/'
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
+    before(:each) do
+      expect(expected_commands.length).to eq(expected_commands_args.length)
+      allow(Terrapin::CommandLine).to receive(:new) do |*command|
+        expect(expected_commands.length).to be > 0
+        expected_command = expected_commands.shift
+        expected_args = expected_commands_args.shift
+        expect(command).to eq(expected_command)
+        stub = double(Terrapin::CommandLine)
+        expect(stub).to receive(:run).with(expected_args)
+        stub
       end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+      allow(subject).to receive(:print_formatted_error) {}
+      allow(subject).to receive(:reference_repo_dir).and_return(test_reference_repo_dir)
+      allow(subject).to receive(:reference_repo_lock_file) { create_lockfile_double }
     end
 
-    it 'should retry when the clone succeeds but checkout fails with unable to read tree' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+    after(:each) do
+      expect(expected_commands).to be_empty
+    end
 
-            STDERR:
+    def clone_cmds
+      [
+        ['git clone', '--mirror :url :mirror'],
+        ['cd', ':path; git remote update --prune']
+      ]
+    end
 
-            error: Could not read 92cf57b8f07df010ab5f607b109c325e30e46235
-            fatal: unable to read tree 0c32c0521d3b0bfb4e74e4a39b97a84d1a3bb9a1
-            warning: Clone succeeded, but checkout failed.
-            You can inspect what was checked out with 'git status'
-            and retry with 'git restore --source=HEAD :/'
-          ERROR
+    def clone_args
+      [
+        {
+          mirror: test_reference_repo_dir,
+          url: test_url_valid
         },
-        ->(url) { url }
+        {
+          path: test_reference_repo_dir
+        }
       ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
+    end
+
+    context 'expecting 1 clone attempt' do
+      let(:expected_commands) { clone_cmds }
+      let(:expected_commands_args) { clone_args }
+
+      it 'should succeed with a successful clone' do
+        expect(subject).not_to receive(:clear_cache)
+        try_with_git_mirror([true], [[test_reference_repo_dir, 0]])
       end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+      it 'should fail after a non-retryable clone error' do
+        expect(subject).not_to receive(:clear_cache)
+        expect do
+          try_with_git_mirror(['Some unexpected error message'], [])
+        end.to raise_error(Terrapin::ExitStatusError)
+      end
     end
 
-    it 'should retry when one delta is missing' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+    context 'expecting 2 clone attempts' do
+      let(:expected_commands) { clone_cmds + clone_cmds }
+      let(:expected_commands_args) { clone_args + clone_args }
 
-            STDERR:
+      it 'should succeed after a single retryable clone failure' do
+        expect(subject).to receive(:clear_cache).and_call_original
+        try_with_git_mirror([retriable_error, true], [[test_reference_repo_dir, 1]])
+      end
 
-            error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
-            fatal: pack has 1 unresolved delta
-            fatal: index-pack failed
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
+      it 'should fail after two retryable clone failures' do
+        expect(subject).to receive(:clear_cache).twice.and_call_original
+        expect do
+          try_with_git_mirror([retriable_error, retriable_error], [])
+        end.to raise_error(Terrapin::ExitStatusError)
       end
+    end
+  end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+  describe '.retriable_error?' do
+    def format_error(error)
+      error_wrapper = "STDOUT:\n\nSTDERR:\n#{error}"
+      error_wrapper.strip.lines.map(&:strip).join("\n")
     end
 
-    it 'should retry when deltas are missing' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    it 'not for a random error message' do
+      error = format_error 'random error message'
 
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+      expect(subject.retriable_error?(error)).to be_falsey
+    end
 
-            STDERR:
+    it 'when the cache looks corrupted' do
+      error = format_error <<-ERROR
+        fatal: bad object ee35b1e14e7c3a53dcc14d82606e5b872f6a05a7
+        fatal: remote did not send all necessary objects
+      ERROR
 
-            error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
-            fatal: pack has 138063 unresolved deltas
-            fatal: index-pack failed
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
-      end
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+    it 'when the clone succeeds but checkout fails with corrupt packed object' do
+      error = format_error <<-ERROR
+        fatal: packed object 7c4d79704f8adf701f38a7bfb3e33ec5342542f1 (stored in /private/var/tmp/git-fastclone/reference/some-repo.git/objects/pack/pack-d37d7ed3e88d6e5f0ac141a7b0a2b32baf6e21a0.pack) is corrupt
+        warning: Clone succeeded, but checkout failed.
+        You can inspect what was checked out with 'git status' and retry with 'git restore --source=HEAD :/'
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
     end
-  end
 
-  it 'should retry when the cache errors with unable to read sha1 file' do
-    allow(subject).to receive(:update_reference_repo) {}
-    expect(subject).to receive(:reference_repo_dir)
-    expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-    responses = [
-      lambda { |_url|
-        raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            error: unable to read sha1 file of sqiosbuild/lib/action/action.rb (6113b739af82d8b07731de8a58d6e233301f80ab)
-            fatal: unable to checkout working tree
-            warning: Clone succeeded, but checkout failed.
-            You can inspect what was checked out with 'git status'
-            and retry with 'git restore --source=HEAD :/'
-        ERROR
-      },
-      ->(url) { url }
-    ]
-    subject.with_git_mirror(test_url_valid) do
-      yielded << responses.shift.call(test_url_valid)
-    end
-
-    expect(responses).to be_empty
-    expect(yielded).to eq([test_url_valid])
-  end
+    it 'when the clone succeeds but checkout fails with unable to read tree' do
+      error = format_error <<-ERROR
+        error: Could not read 92cf57b8f07df010ab5f607b109c325e30e46235
+        fatal: unable to read tree 0c32c0521d3b0bfb4e74e4a39b97a84d1a3bb9a1
+        warning: Clone succeeded, but checkout failed.
+        You can inspect what was checked out with 'git status'
+        and retry with 'git restore --source=HEAD :/'
+      ERROR
 
-  it 'should retry when the cache errors with did not receive expected object' do
-    allow(subject).to receive(:update_reference_repo) {}
-    expect(subject).to receive(:reference_repo_dir)
-    expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
 
-    responses = [
-      lambda { |_url|
-        raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+    it 'when one delta is missing' do
+      error = format_error <<-ERROR
+        error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
+        fatal: pack has 1 unresolved delta
+        fatal: index-pack failed
+      ERROR
 
-            STDERR:
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
 
-            error: Could not read 6682dfe81f66656436e60883dd795e7ec6735153
-            error: Could not read 0cd3703c23fa44c0043d97fbc26356a23939f31b
-            fatal: did not receive expected object 3c64c9dd49c79bd09aa13d4b05ac18263ca29ccd
-            fatal: index-pack failed
-        ERROR
-      },
-      ->(url) { url }
-    ]
-    subject.with_git_mirror(test_url_valid) do
-      yielded << responses.shift.call(test_url_valid)
+    it 'when deltas are missing' do
+      error = format_error <<-ERROR
+        error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
+        fatal: pack has 138063 unresolved deltas
+        fatal: index-pack failed
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
     end
 
-    expect(responses).to be_empty
-    expect(yielded).to eq([test_url_valid])
+    it 'when the cache errors with unable to read sha1 file' do
+      error = format_error <<-ERROR
+        error: unable to read sha1 file of sqiosbuild/lib/action/action.rb (6113b739af82d8b07731de8a58d6e233301f80ab)
+        fatal: unable to checkout working tree
+        warning: Clone succeeded, but checkout failed.
+        You can inspect what was checked out with 'git status'
+        and retry with 'git restore --source=HEAD :/'
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
+
+    it 'when the cache errors with did not receive expected object' do
+      error = format_error <<-ERROR
+      error: Could not read 6682dfe81f66656436e60883dd795e7ec6735153
+      error: Could not read 0cd3703c23fa44c0043d97fbc26356a23939f31b
+      fatal: did not receive expected object 3c64c9dd49c79bd09aa13d4b05ac18263ca29ccd
+      fatal: index-pack failed
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
   end
 end

data/spec/git_fastclone_url_helper_spec.rb

@@ -62,7 +62,7 @@ describe GitFastClone::UrlHelper do
       allow(subject).to receive(:reference_repo_name) { test_reference_dir }
 
       expect(subject.reference_repo_dir(test_url_valid, test_reference_dir, false))
-        .to eq(test_reference_dir + '/' + test_reference_dir)
+        .to eq("#{test_reference_dir}/#{test_reference_dir}")
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fastclone
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.2
 platform: ruby
 authors:
 - Michael Tauraso
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-03 00:00:00.000000000 Z
+date: 2023-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -61,7 +61,8 @@ files:
 homepage: http://square.github.io/git-fastclone/
 licenses:
 - Apache
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -70,7 +71,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -81,7 +82,4 @@ rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: git-clone --recursive on steroids!
-test_files:
-- spec/git_fastclone_runner_spec.rb
-- spec/git_fastclone_url_helper_spec.rb
-- spec/spec_helper.rb
+test_files: []