github_bitbucket_deployer 0.4.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4820cbe9e8b032c3db7d59d2be77d80539790037
-  data.tar.gz: ac6b647de50319ee45de35979adc9654b3db9f15
+  metadata.gz: 26db8331ec93b1bfcca69796b62706b44bde7df7
+  data.tar.gz: ab86f9d0b91833e8b4c23dc516ddab529b1f409c
 SHA512:
-  metadata.gz: bc6b5b1b659986d83c491d4d7f1bc903d8969c68126db2ae1bad6713d2e836dd96ac77525356cf31bf28269dc88a896f90368fa9721dafd573b56819ee235cea
-  data.tar.gz: 39dd999a8fa195a7a6ff7094db494e3757f3d27b54c2f8755ccdd358463641a79a2ac89f82e84e47b90879e8704d9efbfc32a427302b90542be177d2dd6a12ca
+  metadata.gz: cd08ab565ec6cc99721f810869843ed9db8af8d9022d688fb3440f383d49913ad0467b5ca588e3352a959e2e39bf5a5993de7442ba611324d36f056adb91ac28
+  data.tar.gz: 2fec783ed7da9e3a094f3f71e8a9aa155156468477edbc69fe2a1dddec82ce4250fc459e47257ca07bc061e336c7b23147798976f6e7b5a84386c05e8907bf6b

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.2.5

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## v1.0.0 (2016-11-04)
+
+* Enhancements to error handling with general refactoring of
+  `GithubBitbucketDeployer::Git`
+  ([#2](https://github.com/g5search/github_bitbucket_deployer/pull/2))

data/README.md

@@ -8,14 +8,12 @@ Ruby gem to deploy public and private Github repos to Bitbucket
 
 ## Current Version
 
-0.3.1
-
+1.0.0
 
 ## Requirements
 
-* ["git", "~> 1.2.5"](http://rubygems.org/gems/git)
-* ["git-ssh-wrapper", "~> 0.1.0"](http://rubygems.org/gems/git-ssh-wrapper)
-
+* [git](https://git-scm.com/) >= 1.6.0.0
+* [ruby](https://www.ruby-lang.org/) >= 2.2
 
 ## Installation
 

data/github_bitbucket_deployer.gemspec

@@ -15,11 +15,12 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "git", "~> 1.2.5"
-  gem.add_dependency "git-ssh-wrapper", "~> 0.1.0"
+  gem.add_dependency "git", "~> 1.2", ">= 1.2.9.1"
+  gem.add_dependency "git-ssh-wrapper", "~> 0.1"
+  gem.add_dependency "retriable", "~> 2.1"
 
   gem.add_development_dependency "simplecov", "~> 0.7.1"
-  gem.add_development_dependency "rspec", "~> 2.11.0"
-  gem.add_development_dependency "guard-rspec", "~> 2.1.0"
-  gem.add_development_dependency "rb-fsevent", "~> 0.9.2"
+  gem.add_development_dependency "rspec", "~> 3.5"
+  gem.add_development_dependency "fakefs", "~> 0.9.2"
+  gem.add_development_dependency "pry-byebug", "~> 3.3"
 end

data/lib/github_bitbucket_deployer/clone_logger_fix.rb

@@ -0,0 +1,21 @@
+require 'git'
+
+# Patch ruby-git to support logger for Git.clone
+# See https://github.com/schacon/ruby-git/issues/208
+module CloneLoggerFix
+  module ClassMethods
+    def clone(repository, name, opts = {})
+      lib = ::Git::Lib.new(nil, opts[:log])
+      clone_opts = lib.clone(repository, name, opts)
+      new(clone_opts.merge(log: opts[:log]))
+    end
+  end
+
+  def self.prepended(base)
+    class << base
+      prepend ClassMethods
+    end
+  end
+end
+
+::Git::Base.prepend(CloneLoggerFix)

data/lib/github_bitbucket_deployer/git.rb

@@ -1,8 +1,11 @@
-require "git"
-require "git-ssh-wrapper"
+require 'git'
+require 'git-ssh-wrapper'
+require 'retriable'
+require 'github_bitbucket_deployer/clone_logger_fix'
 
 module GithubBitbucketDeployer
   class Git
+    attr_reader :bitbucket_repo_url, :git_repo_name, :id_rsa, :repo_dir, :logger
 
     def initialize(options)
       @bitbucket_repo_url = options[:bitbucket_repo_url]
@@ -12,92 +15,91 @@ module GithubBitbucketDeployer
       @repo_dir = options[:repo_dir]
     end
 
-    def push_app_to_bitbucket(remote="bitbucket", branch="master", &block)
-      @logger.info "push_app_to_bitbucket"
-      wrapper = ssh_wrapper
-      run "cd #{repo.dir}; git remote rm #{remote}" if repo.remote(remote).url
-      repo.add_remote(remote, @bitbucket_repo_url)
-      yield(repo) if block_given?
-      @logger.info "deploying #{repo.dir} to #{repo.remote(remote).url} from branch #{branch}"
-      run "cd #{repo.dir}; env #{wrapper.git_ssh} git push -f #{remote} #{branch}"
-    ensure
-      wrapper.unlink
+    def push_app_to_bitbucket(remote = 'bitbucket', branch = 'master')
+      logger.info('push_app_to_bitbucket')
+      add_remote(remote)
+      with_ssh { yield(repo) } if block_given?
+      push(remote, branch)
     end
 
     def repo
       @repo ||= setup_repo
     end
 
-    def setup_repo
-      @logger.info "setup_repo"
-      clone_or_pull
-      open
-    end
-
     def folder
       @folder ||= setup_folder
     end
 
-    def setup_folder
-      @logger.info "setup_folder"
-      folder = File.join(@repo_dir, Zlib.crc32(@git_repo_name).to_s)
-      FileUtils.mkdir_p(folder).first
+    def clone
+      logger.info("git clone: cloning #{bitbucket_repo_url} to #{folder}")
+      run { ::Git.clone(bitbucket_repo_url, folder, log: logger) }
     end
 
-    def clone_or_pull
-      @logger.info "clone_or_pull"
-      exists_locally? ? pull : clone
+    def pull
+      logger.info("git pull: pulling from #{folder}")
+      run { open.pull }
+      open
     end
 
-    def exists_locally?
-      File.exists?(File.join(folder, ".git", "config"))
+    def open
+      logger.info('git open')
+      ::Git.open(folder, log: logger)
     end
 
-    def clone
-      @logger.info "git clone"
-      wrapper = ssh_wrapper
-      @logger.info "cloning #{@bitbucket_repo_url} to #{folder}"
-      run "unset GIT_WORK_TREE; env #{wrapper.git_ssh} git clone #{@bitbucket_repo_url} #{folder}"
-    ensure
-      wrapper.unlink
+    def push(remote, branch)
+      logger.info("git push: deploying #{repo.dir} to " \
+                  "#{repo.remote(remote).url} from branch #{branch}")
+      run { repo.push(remote, branch, force: true) }
     end
 
-    def pull
-      @logger.info "git pull"
-      wrapper = ssh_wrapper
-      dir = Dir.pwd # need to cd back to here
-      @logger.info "pulling from #{folder}"
-      run "cd #{folder}; env #{wrapper.git_ssh} git pull; cd #{dir}"
-    ensure
-      wrapper.unlink
+    def add_remote(remote = 'bitbucket')
+      logger.info("git add_remote: #{remote}")
+      repo.remote(remote).remove if repo.remote(remote).url
+      repo.add_remote(remote, bitbucket_repo_url)
     end
 
-    def open
-      @logger.info "git open"
-      ::Git.open(folder)
+    private
+
+    def setup_folder
+      logger.info('setup_folder')
+      folder = File.join(repo_dir, Zlib.crc32(git_repo_name).to_s)
+      FileUtils.mkdir_p(folder).first
+    end
+
+    def setup_repo
+      logger.info('setup_repo')
+      update_working_copy
+      open
     end
 
-    def ssh_wrapper
-      GitSSHWrapper.new(private_key_path: id_rsa_path)
+    def update_working_copy
+      logger.info('update_working_copy')
+      exists_locally? ? pull : clone
+    end
+
+    def exists_locally?
+      git_config = File.join(folder, '.git', 'config')
+      File.exist?(git_config)
     end
 
-    def id_rsa_path
-      file = Tempfile.new("id_rsa")
-      file.write(@id_rsa)
-      file.rewind
-      file.path
+    def run
+      Retriable.retriable(on: ::Git::GitExecuteError, tries: 3) do
+        with_ssh { yield }
+      end
+    rescue ::Git::GitExecuteError => error
+      logger.error(error)
+      raise GithubBitbucketDeployer::CommandException, error
     end
 
-    def run(command)
-      @logger.info "git run command: #{command}"
-      result = system("#{command} 2>&1")
-      sleep 20
-      if result
-        @logger.info $?.to_s
-      else
-        raise GithubBitbucketDeployer::CommandException, $?.to_s
+    def with_ssh
+      @old_git_ssh = ENV['GIT_SSH']
+
+      GitSSHWrapper.with_wrapper(private_key: id_rsa) do |wrapper|
+        wrapper.set_env
+        yield if block_given?
       end
+    ensure
+      ENV['GIT_SSH'] = @old_git_ssh
     end
   end
 end
-

data/lib/github_bitbucket_deployer/version.rb

@@ -1,3 +1,3 @@
 module GithubBitbucketDeployer
-  VERSION = "0.4.2"
+  VERSION = '1.0.0'.freeze
 end

data/spec/lib/github_bitbucket_deployer/configuration_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
-require 'github_bitbucket_deployer'
-require 'github_bitbucket_deployer/configuration'
 
 describe GithubBitbucketDeployer::Configuration do
-  it { should respond_to :"[]" }
-  it { should respond_to :to_hash }
-  it { should respond_to :merge }
+  it { is_expected.to respond_to :"[]" }
+  it { is_expected.to respond_to :to_hash }
+  it { is_expected.to respond_to :merge }
 
   it "provides default values" do
     assert_config_default :id_rsa, ENV["ID_RSA"]
@@ -19,24 +17,24 @@ describe GithubBitbucketDeployer::Configuration do
     config = GithubBitbucketDeployer::Configuration.new
     hash = config.to_hash
     GithubBitbucketDeployer::Configuration::OPTIONS.each_pair do |key, value|
-      config[key].should eq(hash[key])
+      expect(config[key]).to eq(hash[key])
     end
   end
 
   it "is mergable" do
     config = GithubBitbucketDeployer::Configuration.new
     hash = config.to_hash
-    config.merge(:key => 'value').should eq(hash.merge(:key => 'value'))
+    expect(config.merge(:key => 'value')).to eq(hash.merge(:key => 'value'))
   end
 
   def assert_config_default(option, default_value, config = nil)
     config ||= GithubBitbucketDeployer::Configuration.new
-    config.send(option).should eq(default_value)
+    expect(config.send(option)).to eq(default_value)
   end
 
   def assert_config_overridable(option, value = 'a value')
     config = GithubBitbucketDeployer::Configuration.new
     config.send(:"#{option}=", value)
-    config.send(option).should eq(value)
+    expect(config.send(option)).to eq(value)
   end
 end

data/spec/lib/github_bitbucket_deployer/git_spec.rb

@@ -1,5 +1,442 @@
 require 'spec_helper'
-require 'github_bitbucket_deployer/git'
 
 describe GithubBitbucketDeployer::Git do
+  include GitHelpers
+
+  let(:git) { described_class.new(options) }
+
+  let(:options) do
+    { bitbucket_repo_url: bitbucket_repo_url,
+      git_repo_name: git_repo_name,
+      id_rsa: id_rsa,
+      logger: logger,
+      repo_dir: repo_dir }
+  end
+
+  let(:bitbucket_repo_url) { 'git@bitbucket.org:g5dev/some_repo.git' }
+  let(:git_repo_name) { 'some_repo' }
+  let(:local_repo_folder) { Zlib.crc32(git_repo_name) }
+  let(:id_rsa) { 'this is the value of my key' }
+  let(:logger) { double('logger', info: true, error: true) }
+  let(:repo_dir) { '/my_home/projects' }
+  let(:working_dir) { "#{repo_dir}/#{local_repo_folder}" }
+
+  let(:git_repo) do
+    instance_double(::Git::Base, remote: empty_remote,
+                                 dir: git_working_dir,
+                                 add_remote: true,
+                                 pull: true,
+                                 push: true)
+  end
+  let(:empty_remote) { instance_double(::Git::Remote, url: nil) }
+
+  let(:bitbucket_remote) do
+    instance_double(::Git::Remote, url: bitbucket_repo_url,
+                                   remove: true)
+  end
+  before do
+    allow(git_repo).to receive(:remote)
+      .with('bitbucket').and_return(bitbucket_remote)
+  end
+
+  let(:git_working_dir) do
+    instance_double(::Git::WorkingDirectory, path: working_dir,
+                                             to_s: working_dir)
+  end
+
+  before do
+    allow(::Git).to receive(:open).and_return(git_repo)
+    allow(::Git).to receive(:clone).and_return(git_repo)
+  end
+
+  describe '#initialize' do
+    subject { git }
+
+    it 'sets the bitbucket_repo_url' do
+      expect(git.bitbucket_repo_url).to eq(bitbucket_repo_url)
+    end
+
+    it 'sets the git_repo_name' do
+      expect(git.git_repo_name).to eq(git_repo_name)
+    end
+
+    it 'sets the id_rsa' do
+      expect(git.id_rsa).to eq(id_rsa)
+    end
+
+    it 'sets the logger' do
+      expect(git.logger).to eq(logger)
+    end
+
+    it 'sets the repo_dir' do
+      expect(git.repo_dir).to eq(repo_dir)
+    end
+  end
+
+  describe '#push_app_to_bitbucket', :fakefs do
+    subject { push_app }
+
+    context 'with default arguments' do
+      let(:push_app) { git.push_app_to_bitbucket }
+
+      context 'when local repo already exists' do
+        before { create_local_repo(working_dir) }
+
+        it 'pulls from the remote repo' do
+          expect(git_repo).to receive(:pull).and_return(true)
+          push_app
+        end
+
+        it 'removes the existing remote' do
+          expect(bitbucket_remote).to receive(:remove)
+          push_app
+        end
+
+        it 'creates the bitbucket remote anew' do
+          expect(git_repo).to receive(:add_remote)
+            .with('bitbucket', bitbucket_repo_url)
+          push_app
+        end
+
+        it 'force pushes master to bitbucket' do
+          expect(git_repo).to receive(:push)
+            .with('bitbucket', 'master', force: true)
+          push_app
+        end
+      end
+
+      context 'when local repo does not exist' do
+        before do
+          allow(git_repo).to receive(:remote)
+            .with('bitbucket').and_return(empty_remote)
+        end
+
+        it 'clones the bitbucket repo into the local folder' do
+          expect(::Git).to receive(:clone)
+            .with(bitbucket_repo_url, working_dir, log: logger)
+            .and_return(git_repo)
+          push_app
+        end
+
+        it 'creates the bitbucket remote' do
+          expect(git_repo).to receive(:add_remote)
+            .with('bitbucket', bitbucket_repo_url)
+          push_app
+        end
+
+        it 'force pushes master to bitbucket' do
+          expect(git_repo).to receive(:push)
+            .with('bitbucket', 'master', force: true)
+          push_app
+        end
+      end
+    end
+
+    context 'with custom arguments' do
+      let(:push_app) { git.push_app_to_bitbucket(remote_name, branch) }
+
+      let(:remote_name) { 'my_git_server' }
+      let(:branch) { 'my_topic_branch' }
+
+      before { create_local_repo(working_dir) }
+
+      it 'pulls from the remote repo' do
+        expect(git_repo).to receive(:pull).and_return(true)
+        push_app
+      end
+
+      it 'creates the new remote' do
+        expect(git_repo).to receive(:add_remote)
+          .with(remote_name, bitbucket_repo_url)
+        push_app
+      end
+
+      it 'yields to the block' do
+        expect do |block|
+          git.push_app_to_bitbucket(remote_name, branch, &block)
+        end.to yield_with_args(git_repo)
+      end
+
+      it 'forces pushes the branch' do
+        expect(git_repo).to receive(:push)
+          .with(remote_name, branch, force: true)
+        push_app
+      end
+    end
+  end
+
+  describe '#repo', :fakefs do
+    subject(:repo) { git.repo }
+
+    context 'when repo_dir exists' do
+      before { FileUtils.mkdir_p(repo_dir) }
+
+      context 'with a git repo' do
+        before { create_local_repo(working_dir) }
+
+        it { is_expected.to eq(git_repo) }
+
+        it 'points to the local working dir' do
+          expect(repo.dir.path).to eq(working_dir)
+        end
+
+        it 'pulls into the existing repo' do
+          expect(git_repo).to receive(:pull).and_return(true)
+          repo
+        end
+      end
+
+      context 'without a git repo' do
+        before do
+          FileUtils.rm_rf(working_dir)
+        end
+
+        it { is_expected.to eq(git_repo) }
+
+        it 'clones the repo locally' do
+          expect(::Git).to receive(:clone)
+            .with(bitbucket_repo_url, working_dir, log: logger)
+            .and_return(git_repo)
+          repo
+        end
+      end
+    end
+
+    context 'when repo_dir does not exist' do
+      before do
+        FileUtils.rm_rf(repo_dir)
+      end
+
+      it 'creates the local repo dir' do
+        repo
+        expect(File).to exist(repo_dir)
+      end
+
+      it { is_expected.to eq(git_repo) }
+
+      it 'clones the repo locally' do
+        expect(::Git).to receive(:clone)
+          .with(bitbucket_repo_url, working_dir, log: logger)
+          .and_return(git_repo)
+        repo
+      end
+    end
+  end
+
+  describe '#folder', :fakefs do
+    subject(:folder) { git.folder }
+
+    context 'when repo_dir exists' do
+      before { FileUtils.mkdir_p(repo_dir) }
+
+      it { is_expected.to eq(working_dir) }
+
+      it 'creates the local folder' do
+        expect(File).to exist(folder)
+      end
+    end
+
+    context 'when repo_dir does not exist' do
+      before { FileUtils.rm_rf(repo_dir) }
+
+      it { is_expected.to eq(working_dir) }
+
+      it 'creates the absolute path to the local folder' do
+        expect(File).to exist(folder)
+      end
+    end
+  end
+
+  describe '#clone', :fakefs do
+    subject(:clone) { git.clone }
+
+    it { is_expected.to be(git_repo) }
+
+    it 'clones the bitbucket repo into the local folder' do
+      expect(::Git).to receive(:clone)
+        .with(bitbucket_repo_url, working_dir, log: logger)
+        .and_return(git_repo)
+      clone
+    end
+
+    it_behaves_like 'a git error handler' do
+      before { allow(::Git).to receive(:clone).and_raise(error) }
+
+      let(:retry_git_command) do
+        expect(::Git).to have_received(:clone).exactly(retry_limit).times
+      end
+    end
+
+    it_behaves_like 'a git ssh wrapper' do
+      def run_git_command
+        expect(::Git).to receive(:clone) { yield }
+      end
+    end
+  end
+
+  describe '#pull', :fakefs do
+    subject(:pull) { git.pull }
+
+    it { is_expected.to be(git_repo) }
+
+    it 'pulls from the remote server' do
+      expect(git_repo).to receive(:pull)
+      pull
+    end
+
+    it 'does not change the current dir' do
+      expect { pull }.to_not change { Dir.pwd }
+    end
+
+    it_behaves_like 'a git error handler' do
+      before { allow(git_repo).to receive(:pull).and_raise(error) }
+
+      let(:retry_git_command) do
+        expect(git_repo).to have_received(:pull).exactly(retry_limit).times
+      end
+    end
+
+    it_behaves_like 'a git ssh wrapper' do
+      def run_git_command
+        expect(git_repo).to receive(:pull) { yield }
+      end
+    end
+  end
+
+  describe '#open', :fakefs do
+    subject(:open) { git.open }
+
+    it { is_expected.to eq(git_repo) }
+
+    it 'opens the local repo with logging' do
+      expect(::Git).to receive(:open)
+        .with(working_dir, log: logger).and_return(git_repo)
+      open
+    end
+  end
+
+  describe '#push', :fakefs do
+    subject(:push) { git.push(remote_name, branch) }
+
+    let(:remote_name) { 'bitbucket' }
+    let(:branch) { 'master' }
+
+    it 'force pushes the branch to the remote' do
+      expect(git_repo).to receive(:push).with(remote_name, branch, force: true)
+      push
+    end
+
+    it_behaves_like 'a git error handler' do
+      before { allow(git_repo).to receive(:push).and_raise(error) }
+
+      let(:retry_git_command) do
+        expect(git_repo).to have_received(:push).exactly(retry_limit).times
+      end
+    end
+
+    it_behaves_like 'a git ssh wrapper' do
+      def run_git_command
+        expect(git_repo).to receive(:push) { yield }
+      end
+    end
+  end
+
+  describe '#add_remote', :fakefs do
+    subject { add_remote }
+
+    let(:unrelated_remote) do
+      instance_double(::Git::Remote, url: 'git@heroku.com:my_app.git')
+    end
+
+    before do
+      allow(git_repo).to receive(:remote)
+        .with('heroku').and_return(unrelated_remote)
+    end
+
+    context 'with default remote name' do
+      let(:add_remote) { git.add_remote }
+
+      context 'when bitbucket remote already exists' do
+        it 'removes the existing remote' do
+          expect(bitbucket_remote).to receive(:remove)
+          add_remote
+        end
+
+        it 'does not remove the unrelated remote' do
+          expect(unrelated_remote).to_not receive(:remove)
+          add_remote
+        end
+
+        it 'adds the new bitbucket remote' do
+          expect(git_repo).to receive(:add_remote)
+            .with('bitbucket', bitbucket_repo_url)
+          add_remote
+        end
+      end
+
+      context 'when bitbucket remote does not exist' do
+        let(:bitbucket_remote) { empty_remote }
+
+        it 'does not remove any existing remotes' do
+          expect(empty_remote).to_not receive(:remove)
+          expect(unrelated_remote).to_not receive(:remove)
+          add_remote
+        end
+
+        it 'adds the new bitbucket remote' do
+          expect(git_repo).to receive(:add_remote)
+            .with('bitbucket', bitbucket_repo_url)
+          add_remote
+        end
+      end
+    end
+
+    context 'with custom remote name' do
+      let(:add_remote) { git.add_remote(remote_name) }
+
+      let(:custom_remote) do
+        instance_double(::Git::Remote, url: 'git@some_server.com:my_app.git',
+                                       remove: true)
+      end
+      let(:remote_name) { 'custom_remote' }
+      before do
+        allow(git_repo).to receive(:remote)
+          .with(remote_name).and_return(custom_remote)
+      end
+
+      context 'when custom remote already exists' do
+        it 'removes the existing remote' do
+          expect(custom_remote).to receive(:remove)
+          add_remote
+        end
+
+        it 'does not remove unrelated remotes' do
+          expect(unrelated_remote).to_not receive(:remove)
+          add_remote
+        end
+
+        it 'creates the new custom remote' do
+          expect(git_repo).to receive(:add_remote)
+            .with(remote_name, bitbucket_repo_url)
+          add_remote
+        end
+      end
+
+      context 'when custom remote does not already exist' do
+        let(:custom_remote) { empty_remote }
+
+        it 'does not remove any existing remotes' do
+          expect(empty_remote).to_not receive(:remove)
+          expect(unrelated_remote).to_not receive(:remove)
+          add_remote
+        end
+
+        it 'creates the new custom remote' do
+          expect(git_repo).to receive(:add_remote)
+            .with(remote_name, bitbucket_repo_url)
+          add_remote
+        end
+      end
+    end
+  end
 end

data/spec/lib/github_bitbucket_deployer_spec.rb

@@ -1,33 +1,33 @@
 require 'spec_helper'
-require 'github_bitbucket_deployer'
 
 describe GithubBitbucketDeployer do
-  it { should respond_to :configuration }
-  it { should respond_to :configure }
-  it { should respond_to :deploy }
+  it { is_expected.to respond_to(:configuration) }
+  it { is_expected.to respond_to(:configure) }
+  it { is_expected.to respond_to(:deploy) }
+
+  describe ".configuration" do
+    subject(:config) { GithubBitbucketDeployer.configuration }
 
-  describe "::configuration" do
     it "should be the configuration object" do
-      GithubBitbucketDeployer.configuration.should(
-        be_a_kind_of GithubBitbucketDeployer::Configuration)
+      expect(config).to be_a_kind_of(GithubBitbucketDeployer::Configuration)
     end
 
     it "give a new instance if non defined" do
       GithubBitbucketDeployer.configuration = nil
-      GithubBitbucketDeployer.configuration.should(
-        be_a_kind_of GithubBitbucketDeployer::Configuration)
+      expect(config).to be_a_kind_of(GithubBitbucketDeployer::Configuration)
     end
   end
 
-  describe "::configure" do
+  describe ".configure" do
     it "should yield the configuration object" do
       GithubBitbucketDeployer.configure do |config|
-        config.should equal(GithubBitbucketDeployer.configuration)
+        expect(config).to equal(GithubBitbucketDeployer.configuration)
       end
     end
   end
 
   describe "::deploy" do
+    subject(:deploy) { GithubBitbucketDeployer.deploy }
 
     context "when unconfigured" do
       before :each do
@@ -37,16 +37,15 @@ describe GithubBitbucketDeployer do
       end
 
       it "requires github_repo to be set" do
-        lambda { GithubBitbucketDeployer.deploy }.should(
-          raise_error ::GithubBitbucketDeployer::ConfigurationException)
+        expect { deploy }.to raise_error(GithubBitbucketDeployer::ConfigurationException)
       end
     end
 
     # TODO: how can I test these better?
     context "when configured" do
       before :each do
-        @deployer = mock("github_bitbucket_deployer")
-        @deployer.stub!(:deploy).and_return(true)
+        @deployer = double("github_bitbucket_deployer")
+        allow(@deployer).to receive(:deploy).and_return(true)
       end
 
       it "overrides defaults" do
@@ -54,9 +53,8 @@ describe GithubBitbucketDeployer do
           config.id_rsa = ""
         end
 
-        override = ENV["ID_RSA"]
-        override.should_not equal GithubBitbucketDeployer.configuration[:id_rsa]
-        @deployer.deploy(id_rsa: override).should be true
+        override = 'override-value'
+        expect(@deployer.deploy(id_rsa: override)).to be true
       end
 
     end

data/spec/spec_helper.rb

@@ -3,12 +3,17 @@ SimpleCov.start
 
 require 'rubygems'
 require 'rspec'
-require 'rspec/autorun'
+require 'pp' # See https://github.com/fakefs/fakefs/issues/99
+require 'pry-byebug'
+require 'fakefs/spec_helpers'
 
-RSpec.configure do |config|
-  config.order = "random"
-end
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f }
 
 ENV['ID_RSA']="id_rsa"
 ENV['REPO_DIR']="foo"
 
+require 'github_bitbucket_deployer'
+
+RSpec.configure do |config|
+  config.order = "random"
+end

data/spec/support/fakefs.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |config|
+  config.include FakeFS::SpecHelpers, fakefs: true
+  config.before(:each, fakefs: true) do
+    source_dir = File.join(File.dirname(__FILE__), '..', '..')
+    FakeFS::FileSystem.clone(source_dir)
+    FakeFS::FileSystem.add(Dir.tmpdir)
+    FakeFS::FileSystem.add('/tmp')
+  end
+end

data/spec/support/git_helpers.rb

@@ -0,0 +1,7 @@
+module GitHelpers
+  def create_local_repo(working_dir)
+    git_dir = "#{working_dir}/.git"
+    FileUtils.mkdir_p(git_dir)
+    Dir.chdir(git_dir) { FileUtils.touch('config') }
+  end
+end

data/spec/support/shared_examples/git_error_handler.rb

@@ -0,0 +1,46 @@
+# Prerequisites:
+# * set up any method stubs on the git repo to raise error, e.g.
+#     before { allow(git_repo).to receive(:pull).and raise_error(error) }
+# * define a method named retry_git_command to set up retry expectations, e.g.
+#     let(:retry_git_command) do
+#       expect(git_repo).to have_received(:pull).exactly(retry_limit).times
+#     end
+shared_examples_for 'a git error handler' do
+  let(:safe_subject) { subject rescue error }
+
+  context 'with Git::GitExecuteError' do
+    let(:error) { Git::GitExecuteError.new('some git error') }
+
+    let(:retry_limit) { 3 }
+
+    it 'retries 3 times' do
+      safe_subject
+      retry_git_command
+    end
+
+    it 'logs the error' do
+      expect(logger).to receive(:error)
+      safe_subject
+    end
+
+    it 'raises a GithubBitbucketDeployer::CommandException' do
+      expect { subject }
+        .to raise_error(GithubBitbucketDeployer::CommandException)
+    end
+  end
+
+  context 'with any other type of error' do
+    let(:error) { ArgumentError.new('some non-git error') }
+
+    let(:retry_limit) { 1 }
+
+    it 'only tries once' do
+      safe_subject
+      retry_git_command
+    end
+
+    it 'raises the original exception' do
+      expect { subject }.to raise_error(error)
+    end
+  end
+end

data/spec/support/shared_examples/git_ssh_wrapper.rb

@@ -0,0 +1,59 @@
+# Prerequisites:
+# Must define a method names run_git_command that yields control, e.g.
+#   def run_git_command
+#     expect(git_repo).to receive(:pull) { yield }
+#   end
+shared_examples_for 'a git ssh wrapper' do
+  let(:temp_files) do
+    Dir.glob("#{Dir.tmpdir}/git-ssh-wrapper*").sort_by { |f| File.mtime(f) }
+  end
+
+  it 'constructs a wrapper with the private key' do
+    expect(GitSSHWrapper).to receive(:with_wrapper)
+      .with(private_key: id_rsa).at_least(:once)
+    subject
+  end
+
+  it 'writes the ssh wrapper to a tempfile' do
+    run_git_command do
+      expect(temp_files).to_not be_empty
+    end
+    subject
+  end
+
+  it 'sets the GIT_SSH env var during command execution' do
+    run_git_command do
+      expect(temp_files).to include(ENV['GIT_SSH'])
+    end
+    subject
+  end
+
+  context 'when command is successful' do
+    it 'resets the GIT_SSH env var after exiting' do
+      expect { subject }.to_not change { ENV['GIT_SSH'] }
+    end
+
+    it 'unlinks the temp ssh files' do
+      subject
+      expect(temp_files).to be_empty
+    end
+  end
+
+  context 'when command raises an error' do
+    let(:safe_subject) do
+      run_git_command do
+        raise GitExecuteError, 'some git error'
+      end
+      subject rescue 'whatever'
+    end
+
+    it 'resets the GIT_SSH env var after exiting' do
+      expect { safe_subject }.to_not change { ENV['GIT_SSH'] }.from(nil)
+    end
+
+    it 'unlinks the temp ssh files' do
+      safe_subject
+      expect(temp_files).to be_empty
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: github_bitbucket_deployer
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Jessica Lynn Suttles
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-23 00:00:00.000000000 Z
+date: 2016-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -17,28 +17,48 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.5
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.9.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.5
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.9.1
 - !ruby/object:Gem::Dependency
   name: git-ssh-wrapper
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: retriable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -59,42 +79,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.0
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.0
+        version: '3.5'
 - !ruby/object:Gem::Dependency
-  name: guard-rspec
+  name: fakefs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 0.9.2
 - !ruby/object:Gem::Dependency
-  name: rb-fsevent
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '3.3'
 description: Deploys Github repos to bitbucket
 email:
 - jlsuttles@gmail.com
@@ -104,14 +124,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
-- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - github_bitbucket_deployer.gemspec
 - lib/github_bitbucket_deployer.rb
+- lib/github_bitbucket_deployer/clone_logger_fix.rb
 - lib/github_bitbucket_deployer/configuration.rb
 - lib/github_bitbucket_deployer/exceptions.rb
 - lib/github_bitbucket_deployer/git.rb
@@ -120,6 +143,10 @@ files:
 - spec/lib/github_bitbucket_deployer/git_spec.rb
 - spec/lib/github_bitbucket_deployer_spec.rb
 - spec/spec_helper.rb
+- spec/support/fakefs.rb
+- spec/support/git_helpers.rb
+- spec/support/shared_examples/git_error_handler.rb
+- spec/support/shared_examples/git_ssh_wrapper.rb
 homepage: https://github.com/G5/github_bitbucket_deployer
 licenses: []
 metadata: {}
@@ -139,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Deploys public and private Github repos to bitbucket
@@ -148,3 +175,7 @@ test_files:
 - spec/lib/github_bitbucket_deployer/git_spec.rb
 - spec/lib/github_bitbucket_deployer_spec.rb
 - spec/spec_helper.rb
+- spec/support/fakefs.rb
+- spec/support/git_helpers.rb
+- spec/support/shared_examples/git_error_handler.rb
+- spec/support/shared_examples/git_ssh_wrapper.rb

data/Guardfile

@@ -1,5 +0,0 @@
-guard 'rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-end