chef 18.8.11-universal-mingw-ucrt → 18.8.46-universal-mingw-ucrt

data/spec/unit/provider/git_spec.rb

@@ -1,822 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-describe Chef::Provider::Git do
-
-  before(:each) do
-    allow(STDOUT).to receive(:tty?).and_return(true)
-    @original_log_level = Chef::Log.level
-    Chef::Log.level = :info
-
-    @current_resource = Chef::Resource::Git.new("web2.0 app")
-    @current_resource.revision("d35af14d41ae22b19da05d7d03a0bafc321b244c")
-
-    @resource = Chef::Resource::Git.new("web2.0 app")
-    @resource.repository "git://github.com/opscode/chef.git"
-    @resource.destination "/my/deploy/dir"
-    @resource.revision "d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @provider = Chef::Provider::Git.new(@resource, @run_context)
-    @provider.current_resource = @current_resource
-  end
-
-  after(:each) do
-    Chef::Log.level = @original_log_level
-  end
-
-  context "determining the revision of the currently deployed checkout" do
-
-    before do
-      @stdout = double("standard out")
-      @stderr = double("standard error")
-      @exitstatus = double("exitstatus")
-    end
-
-    it "sets the current revision to nil if the deploy dir does not exist" do
-      expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(false)
-      expect(@provider.find_current_revision).to be_nil
-    end
-
-    it "determines the current revision when there is one" do
-      expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-      @stdout = "9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13\n"
-      expect(@provider).to receive(:shell_out!).with("git rev-parse HEAD", { cwd: "/my/deploy/dir", returns: [0, 128], log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.find_current_revision).to eql("9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13")
-    end
-
-    it "gives the current revision as nil when there is no current revision" do
-      expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-      @stderr = "fatal: Not a git repository (or any of the parent directories): .git"
-      @stdout = ""
-      expect(@provider).to receive(:shell_out!).with("git rev-parse HEAD", cwd: "/my/deploy/dir", returns: [0, 128], log_tag: "git[web2.0 app]" ).and_return(double("ShellOut result", stdout: "", stderr: @stderr))
-      expect(@provider.find_current_revision).to be_nil
-    end
-  end
-
-  it "creates a current_resource with the currently deployed revision when a clone exists in the destination dir" do
-    allow(@provider).to receive(:find_current_revision).and_return("681c9802d1c62a45b490786c18f0b8216b309440")
-    @provider.load_current_resource
-    expect(@provider.current_resource.name).to eql(@resource.name)
-    expect(@provider.current_resource.revision).to eql("681c9802d1c62a45b490786c18f0b8216b309440")
-  end
-
-  it "keeps the node and resource passed to it on initialize" do
-    expect(@provider.node).to equal(@node)
-    expect(@provider.new_resource).to equal(@resource)
-  end
-
-  context "cast git version into gem version object" do
-    it "returns correct version with standard git" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version 2.14.1"))
-      expect(@provider.git_gem_version).to eq Gem::Version.new("2.14.1")
-    end
-
-    it "returns correct version with Apple git" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version 2.11.0 (Apple Git-81)"))
-      expect(@provider.git_gem_version).to eq Gem::Version.new("2.11.0")
-    end
-
-    it "maintains deprecated method name" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version 1.2.3"))
-      expect(@provider.git_minor_version).to eq Gem::Version.new("1.2.3")
-    end
-
-    it "does not know how to handle other version" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version home-grown-git-99"))
-      expect(@provider.git_gem_version).to be_nil
-    end
-
-    it "determines single branch option when it fails to parse git version" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version home-grown-git-99"))
-      expect(@provider.git_has_single_branch_option?).to be false
-    end
-
-    it "determines single branch option as true when it parses git version and version is large" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version 1.8.0"))
-      expect(@provider.git_has_single_branch_option?).to be true
-    end
-
-    it "determines single branch option as false when it parses git version and version is small" do
-      expect(@provider).to receive(:shell_out!)
-        .with("git --version", log_tag: "git[web2.0 app]")
-        .and_return(double("ShellOut result", stdout: "git version 1.7.4"))
-      expect(@provider.git_has_single_branch_option?).to be false
-    end
-
-    it "is compatible with git in travis" do
-      expect(@provider.git_gem_version).to be > Gem::Version.new("1.0")
-    end
-  end
-
-  context "resolving revisions to a SHA" do
-
-    before do
-      @git_ls_remote = "git ls-remote \"git://github.com/opscode/chef.git\" "
-    end
-
-    it "returns resource.revision as is if revision is already a full SHA" do
-      expect(@provider.target_revision).to eql("d35af14d41ae22b19da05d7d03a0bafc321b244c")
-    end
-
-    it "converts resource.revision from a tag to a SHA" do
-      @resource.revision "v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-                 "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("503c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "converts resource.revision from an annotated tag to the tagged SHA (not SHA of tag)" do
-      @resource.revision "v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-                 "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n" +
-                 "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0^{}\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("663c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "converts resource.revision from a tag to a SHA using an exact match" do
-      @resource.revision "v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-                 "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/tags/releases/v1.0\n" +
-                 "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/tags/v1.0\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("503c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "converts resource.revision from a tag to a SHA, matching tags first, then heads" do
-      @resource.revision "v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-          "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/tags/v1.0\n" +
-          "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("663c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "converts resource.revision from a tag to a SHA, matching heads if no tags match" do
-      @resource.revision "v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-          "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/tags/v1.1\n" +
-          "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("503c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "converts resource.revision from a tag to a SHA, matching tags first, then heads, then revision" do
-      @resource.revision "refs/pulls/v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-          "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/tags/v1.0\n" +
-          "805c22a5e41f5ae3193460cca044ed1435029f53\trefs/pulls/v1.0\n" +
-          "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"refs/pulls/v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("805c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "converts resource.revision from a tag to a SHA, using full path if provided" do
-      @resource.revision "refs/heads/v1.0"
-      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
-          "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/tags/v1.0\n" +
-          "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"refs/heads/v1.0*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("503c22a5e41f5ae3193460cca044ed1435029f53")
-    end
-
-    it "raises an invalid remote reference error if you try to deploy from ``origin'' and assertions are run" do
-      @resource.revision "origin/"
-      @provider.action = :checkout
-      @provider.define_resource_requirements
-      allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::InvalidRemoteGitReference)
-    end
-
-    it "raises an unresolvable git reference error if the revision can't be resolved to any revision and assertions are run" do
-      @resource.revision "FAIL, that's the revision I want"
-      @provider.action = :checkout
-      expect(@provider).to receive(:shell_out!).and_return(double("ShellOut result", stdout: "\n"))
-      @provider.define_resource_requirements
-      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::UnresolvableGitReference)
-    end
-
-    it "does not raise an error if the revision can't be resolved when assertions are not run" do
-      @resource.revision "FAIL, that's the revision I want"
-      expect(@provider).to receive(:shell_out!).and_return(double("ShellOut result", stdout: "\n"))
-      expect(@provider.target_revision).to eq(nil)
-    end
-
-    it "does not raise an error when the revision is valid and assertions are run." do
-      @resource.revision "0.8-alpha"
-      @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"0.8-alpha*\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      @provider.action = :checkout
-      allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-      @provider.define_resource_requirements
-      expect { @provider.process_resource_requirements }.not_to raise_error
-    end
-
-    it "gives the latest HEAD revision SHA if nothing is specified" do
-      @stdout = <<~SHAS
-        28af684d8460ba4793eda3e7ac238c864a5d029a\tHEAD
-        503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha
-        28af684d8460ba4793eda3e7ac238c864a5d029a\trefs/heads/master
-        c44fe79bb5e36941ce799cee6b9de3a2ef89afee\trefs/tags/0.5.2
-        14534f0e0bf133dc9ff6dbe74f8a0c863ff3ac6d\trefs/tags/0.5.4
-        d36fddb4291341a1ff2ecc3c560494e398881354\trefs/tags/0.5.6
-        9e5ce9031cbee81015de680d010b603bce2dd15f\trefs/tags/0.6.0
-        9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13\trefs/tags/0.6.2
-        014a69af1cdce619de82afaf6cdb4e6ac658fede\trefs/tags/0.7.0
-        fa8097ff666af3ce64761d8e1f1c2aa292a11378\trefs/tags/0.7.2
-        44f9be0b33ba5c10027ddb030a5b2f0faa3eeb8d\trefs/tags/0.7.4
-        d7b9957f67236fa54e660cc3ab45ffecd6e0ba38\trefs/tags/0.7.8
-        b7d19519a1c15f1c1a324e2683bd728b6198ce5a\trefs/tags/0.7.8^{}
-        ebc1b392fe7e8f0fbabc305c299b4d365d2b4d9b\trefs/tags/chef-server-package
-      SHAS
-      @resource.revision ""
-      expect(@provider).to receive(:shell_out!).with(@git_ls_remote + "\"HEAD\"", { log_tag: "git[web2.0 app]" }).and_return(double("ShellOut result", stdout: @stdout))
-      expect(@provider.target_revision).to eql("28af684d8460ba4793eda3e7ac238c864a5d029a")
-    end
-  end
-
-  it "responds to :revision_slug as an alias for target_revision" do
-    expect(@provider).to respond_to(:revision_slug)
-  end
-
-  context "with an ssh wrapper" do
-    let(:deploy_user)  { "deployNinja" }
-    let(:wrapper)      { "do_it_this_way.sh" }
-    let(:expected_cmd) { 'git clone "git://github.com/opscode/chef.git" "/my/deploy/dir"' }
-    let(:default_options) do
-      {
-        user: deploy_user,
-        environment: { "GIT_SSH" => wrapper, "HOME" => "/home/deployNinja" },
-        log_tag: "git[web2.0 app]",
-      }
-    end
-    before do
-      @resource.user deploy_user
-      @resource.ssh_wrapper wrapper
-      allow(Etc).to receive(:getpwnam).and_return(double("Struct::Passwd", name: @resource.user, dir: "/home/deployNinja"))
-    end
-    context "without a timeout set" do
-      it "clones a repo with default git options" do
-        expect(@provider).to receive(:shell_out!).with(expected_cmd, default_options)
-        @provider.clone
-      end
-    end
-    context "with a timeout set" do
-      let(:seconds) { 10 }
-      before { @resource.timeout(seconds) }
-      it "clones a repo with amended git options" do
-        expect(@provider).to receive(:shell_out!).with(expected_cmd, default_options.merge(timeout: seconds))
-        @provider.clone
-      end
-    end
-    context "with a specific home" do
-      let(:override_home) do
-        { "HOME" => "/home/masterNinja" }
-      end
-      let(:overrided_options) do
-        {
-          user: deploy_user,
-          environment: { "GIT_SSH" => wrapper, "HOME" => "/home/masterNinja" },
-          log_tag: "git[web2.0 app]",
-        }
-      end
-      before do
-        @resource.environment(override_home)
-      end
-      before { @resource.environment(override_home) }
-      it "clones a repo with amended git options with specific home" do
-        expect(@provider).to receive(:shell_out!).with(expected_cmd, overrided_options)
-        @provider.clone
-      end
-    end
-  end
-
-  context "with a user id" do
-    let(:deploy_user)  { 123 }
-    let(:expected_cmd) { 'git clone "git://github.com/opscode/chef.git" "/my/deploy/dir"' }
-    let(:default_options) do
-      {
-        user: 123,
-        environment: { "HOME" => "/home/deployNinja" },
-        log_tag: "git[web2.0 app]",
-      }
-    end
-    before do
-      @resource.user deploy_user
-      allow(Etc).to receive(:getpwuid).and_return(double("Struct::Passwd", name: @resource.user, dir: "/home/deployNinja"))
-    end
-    context "with a specific home" do
-      let(:override_home) do
-        { "HOME" => "/home/masterNinja" }
-      end
-      let(:overrided_options) do
-        {
-          user: 123,
-          environment: { "HOME" => "/home/masterNinja" },
-          log_tag: "git[web2.0 app]",
-        }
-      end
-      before do
-        @resource.environment(override_home)
-      end
-      before { @resource.environment(override_home) }
-      it "clones a repo with amended git options with specific home" do
-        expect(@provider).to receive(:shell_out!).with(expected_cmd, hash_including(overrided_options))
-        @provider.clone
-      end
-    end
-  end
-
-  it "runs a clone command with escaped destination" do
-    @resource.user "deployNinja"
-    allow(Etc).to receive(:getpwnam).and_return(double("Struct::Passwd", name: @resource.user, dir: "/home/deployNinja"))
-    @resource.destination "/Application Support/with/space"
-    @resource.ssh_wrapper "do_it_this_way.sh"
-    expected_cmd = "git clone \"git://github.com/opscode/chef.git\" \"/Application Support/with/space\""
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, user: "deployNinja",
-                                                                 log_tag: "git[web2.0 app]",
-                                                                 environment: { "HOME" => "/home/deployNinja",
-                                                                                "GIT_SSH" => "do_it_this_way.sh" })
-    @provider.clone
-  end
-
-  it "compiles a clone command using --depth for shallow cloning" do
-    @resource.depth 5
-    expected_cmd = "git clone --depth 5 \"git://github.com/opscode/chef.git\" \"/my/deploy/dir\""
-    version_response = double("shell_out")
-    allow(version_response).to receive(:stdout) { "git version 1.7.9" }
-    expect(@provider).to receive(:shell_out!).with("git --version",
-      log_tag: "git[web2.0 app]").and_return(version_response)
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, log_tag: "git[web2.0 app]")
-    @provider.clone
-  end
-
-  it "compiles a clone command using --no-single-branch for shallow cloning when git >= 1.7.10" do
-    @resource.depth 5
-    expected_cmd = "git clone --depth 5 --no-single-branch \"git://github.com/opscode/chef.git\" \"/my/deploy/dir\""
-    version_response = double("shell_out")
-    allow(version_response).to receive(:stdout) { "git version 1.7.10" }
-    expect(@provider).to receive(:shell_out!).with("git --version",
-      log_tag: "git[web2.0 app]").and_return(version_response)
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, log_tag: "git[web2.0 app]")
-    @provider.clone
-  end
-
-  it "compiles a clone command with a remote other than ``origin''" do
-    @resource.remote "opscode"
-    expected_cmd = "git clone -o opscode \"git://github.com/opscode/chef.git\" \"/my/deploy/dir\""
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, log_tag: "git[web2.0 app]")
-    @provider.clone
-  end
-
-  it "runs a checkout command when the local branch is set" do
-    @resource.checkout_branch "deploy"
-    expect(@provider).to receive(:shell_out!).with("git branch -f deploy d35af14d41ae22b19da05d7d03a0bafc321b244c", cwd: "/my/deploy/dir",
-                                                                                                                    log_tag: "git[web2.0 app]").ordered
-    expect(@provider).to receive(:shell_out!).with("git checkout deploy", cwd: "/my/deploy/dir",
-                                                                          log_tag: "git[web2.0 app]").ordered
-    @provider.checkout
-  end
-
-  it "runs an enable_submodule command" do
-    @resource.enable_submodules true
-    expected_cmd = "git submodule sync"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, cwd: "/my/deploy/dir",
-                                                                 log_tag: "git[web2.0 app]")
-    expected_cmd = "git submodule update --init --recursive"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    @provider.enable_submodules
-  end
-
-  it "does nothing for enable_submodules if resource.enable_submodules #=> false" do
-    expect(@provider).not_to receive(:shell_out!)
-    @provider.enable_submodules
-  end
-
-  it "runs a sync command with default options" do
-    expect(@provider).to receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
-    expected_cmd1 = "git fetch --prune origin"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd1, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    expected_cmd2 = "git fetch origin --tags"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd2, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    expected_cmd3 = "git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd3, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    @provider.fetch_updates
-  end
-
-  it "runs a sync command with the user and group specified in the resource" do
-    @resource.user("whois")
-    allow(Etc).to receive(:getpwnam).and_return(double("Struct::Passwd", name: @resource.user, dir: "/home/whois"))
-    @resource.group("thisis")
-    expect(@provider).to receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
-
-    expected_cmd1 = "git fetch --prune origin"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd1, cwd: "/my/deploy/dir",
-                                                                  user: "whois", group: "thisis",
-                                                                  log_tag: "git[web2.0 app]",
-                                                                  environment: { "HOME" => "/home/whois" })
-    expected_cmd2 = "git fetch origin --tags"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd2, cwd: "/my/deploy/dir",
-                                                                  user: "whois", group: "thisis",
-                                                                  log_tag: "git[web2.0 app]",
-                                                                  environment: { "HOME" => "/home/whois" })
-    expected_cmd3 = "git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd3, cwd: "/my/deploy/dir",
-                                                                  user: "whois", group: "thisis",
-                                                                  log_tag: "git[web2.0 app]",
-                                                                  environment: { "HOME" => "/home/whois" })
-    @provider.fetch_updates
-  end
-
-  it "configures remote tracking branches when remote is ``origin''" do
-    @resource.remote "origin"
-    expect(@provider).to receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
-    fetch_command1 = "git fetch --prune origin"
-    expect(@provider).to receive(:shell_out!).with(fetch_command1, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    fetch_command2 = "git fetch origin --tags"
-    expect(@provider).to receive(:shell_out!).with(fetch_command2, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    fetch_command3 = "git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    expect(@provider).to receive(:shell_out!).with(fetch_command3, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    @provider.fetch_updates
-  end
-
-  it "configures remote tracking branches when remote is not ``origin''" do
-    @resource.remote "opscode"
-    expect(@provider).to receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
-    fetch_command1 = "git fetch --prune opscode"
-    expect(@provider).to receive(:shell_out!).with(fetch_command1, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    fetch_command2 = "git fetch opscode --tags"
-    expect(@provider).to receive(:shell_out!).with(fetch_command2, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    fetch_command3 = "git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    expect(@provider).to receive(:shell_out!).with(fetch_command3, cwd: "/my/deploy/dir", log_tag: "git[web2.0 app]")
-    @provider.fetch_updates
-  end
-
-  context "configuring remote tracking branches" do
-
-    it "checks if a remote with this name already exists" do
-      command_response = double("shell_out")
-      allow(command_response).to receive(:exitstatus) { 1 }
-      expected_command = "git config --get remote.#{@resource.remote}.url"
-      expect(@provider).to receive(:shell_out!).with(expected_command,
-        cwd: "/my/deploy/dir",
-        log_tag: "git[web2.0 app]",
-        returns: [0, 1, 2]).and_return(command_response)
-      add_remote_command = "git remote add #{@resource.remote} #{@resource.repository}"
-      expect(@provider).to receive(:shell_out!).with(add_remote_command,
-        cwd: "/my/deploy/dir",
-        log_tag: "git[web2.0 app]")
-      @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
-    end
-
-    it "runs the config with the user and group specified in the resource" do
-      @resource.user("whois")
-      @resource.group("thisis")
-      allow(Etc).to receive(:getpwnam).and_return(double("Struct::Passwd", name: @resource.user, dir: "/home/whois"))
-      command_response = double("shell_out")
-      allow(command_response).to receive(:exitstatus) { 1 }
-      expected_command = "git config --get remote.#{@resource.remote}.url"
-      expect(@provider).to receive(:shell_out!).with(expected_command,
-        cwd: "/my/deploy/dir",
-        log_tag: "git[web2.0 app]",
-        user: "whois",
-        group: "thisis",
-        environment: { "HOME" => "/home/whois" },
-        returns: [0, 1, 2]).and_return(command_response)
-      add_remote_command = "git remote add #{@resource.remote} #{@resource.repository}"
-      expect(@provider).to receive(:shell_out!).with(add_remote_command,
-        cwd: "/my/deploy/dir",
-        log_tag: "git[web2.0 app]",
-        user: "whois",
-        group: "thisis",
-        environment: { "HOME" => "/home/whois" })
-      @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
-    end
-
-    describe "when a remote with a given name hasn't been configured yet" do
-      it "adds a new remote " do
-        command_response = double("shell_out")
-        allow(command_response).to receive(:exitstatus) { 1 }
-        check_remote_command = "git config --get remote.#{@resource.remote}.url"
-        expect(@provider).to receive(:shell_out!).with(check_remote_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]",
-          returns: [0, 1, 2]).and_return(command_response)
-        expected_command = "git remote add #{@resource.remote} #{@resource.repository}"
-        expect(@provider).to receive(:shell_out!).with(expected_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]")
-        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
-      end
-    end
-
-    describe "when a remote with a given name has already been configured" do
-      it "updates remote url when the url is different" do
-        command_response = double("shell_out")
-        allow(command_response).to receive(:exitstatus) { 0 }
-        allow(command_response).to receive(:stdout) { "some_other_url" }
-        check_remote_command = "git config --get remote.#{@resource.remote}.url"
-        expect(@provider).to receive(:shell_out!).with(check_remote_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]",
-          returns: [0, 1, 2]).and_return(command_response)
-        expected_command = "git config --replace-all remote.#{@resource.remote}.url \"#{@resource.repository}\""
-        expect(@provider).to receive(:shell_out!).with(expected_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]")
-        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
-      end
-
-      it "doesn't update remote url when the url is the same" do
-        command_response = double("shell_out")
-        allow(command_response).to receive(:exitstatus) { 0 }
-        allow(command_response).to receive(:stdout) { @resource.repository }
-        check_remote_command = "git config --get remote.#{@resource.remote}.url"
-        expect(@provider).to receive(:shell_out!).with(check_remote_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]",
-          returns: [0, 1, 2]).and_return(command_response)
-        unexpected_command = "git config --replace-all remote.#{@resource.remote}.url \"#{@resource.repository}\""
-        expect(@provider).not_to receive(:shell_out!).with(unexpected_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]")
-        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
-      end
-
-      it "resets remote url when it has multiple values" do
-        command_response = double("shell_out")
-        allow(command_response).to receive(:exitstatus) { 2 }
-        check_remote_command = "git config --get remote.#{@resource.remote}.url"
-        expect(@provider).to receive(:shell_out!).with(check_remote_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]",
-          returns: [0, 1, 2]).and_return(command_response)
-        expected_command = "git config --replace-all remote.#{@resource.remote}.url \"#{@resource.repository}\""
-        expect(@provider).to receive(:shell_out!).with(expected_command,
-          cwd: "/my/deploy/dir",
-          log_tag: "git[web2.0 app]")
-        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
-      end
-    end
-  end
-
-  context "with why-run mode" do
-    before do
-      Chef::Config[:why_run] = true
-      @resource.user "test"
-    end
-
-    after do
-      Chef::Config[:why_run] = false
-    end
-
-    it "does not raise an error if user does not exist" do
-      allow(@provider).to receive(:get_homedir).with(@resource.user).and_return(nil)
-      expect { @provider.run_action(:sync) }.not_to raise_error
-    end
-
-    it "does not raise an error if user exists" do
-      allow(@provider).to receive(:get_homedir).with(@resource.user).and_return("/home/test")
-      expect { @provider.run_action(:sync) }.not_to raise_error
-    end
-  end
-
-  context "without why-run mode" do
-    before do
-      @resource.user "test"
-    end
-
-    it "raises an error if user does not exist" do
-      allow(@provider).to receive(:get_homedir).with(@resource.user).and_return(nil)
-      expect { @provider.run_action(:sync) }.to raise_error(Chef::Exceptions::User)
-    end
-
-    it "does not raise an error if user exists" do
-      allow(@provider).to receive(:action_sync) # stub the entire action
-      allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-      allow(@provider).to receive(:get_homedir).with(@resource.user).and_return("/home/test")
-      expect { @provider.run_action(:sync) }.not_to raise_error
-    end
-  end
-
-  it "raises an error if the git clone command would fail because the enclosing directory doesn't exist" do
-    allow(@provider).to receive(:shell_out!)
-    expect { @provider.run_action(:sync) }.to raise_error(Chef::Exceptions::MissingParentDirectory)
-  end
-
-  it "does a checkout by cloning the repo and then enabling submodules" do
-    # will be invoked in load_current_resource
-    allow(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(false)
-
-    allow(::File).to receive(:exist?).with("/my/deploy/dir").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    allow(::Dir).to receive(:entries).with("/my/deploy/dir").and_return([".", ".."])
-    expect(@provider).to receive(:clone)
-    expect(@provider).to receive(:checkout)
-    expect(@provider).to receive(:enable_submodules)
-    @provider.run_action(:checkout)
-    # Even though an actual run will cause an update to occur, the fact that we've stubbed out
-    # the actions above will prevent updates from registering
-    # @resource.should be_updated
-  end
-
-  it "does not call checkout if enable_checkout is false" do
-    # will be invoked in load_current_resource
-    allow(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(false)
-
-    allow(::File).to receive(:exist?).with("/my/deploy/dir").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    allow(::Dir).to receive(:entries).with("/my/deploy/dir").and_return([".", ".."])
-
-    @resource.enable_checkout false
-    expect(@provider).to receive(:clone)
-    expect(@provider).not_to receive(:checkout)
-    expect(@provider).to receive(:enable_submodules)
-    @provider.run_action(:checkout)
-  end
-
-  # REGRESSION TEST: on some OSes, the entries from an empty directory will be listed as
-  # ['..', '.'] but this shouldn't change the behavior
-  it "does a checkout by cloning the repo and then enabling submodules when the directory entries are listed as %w{.. .}" do
-    allow(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(false)
-    allow(::File).to receive(:exist?).with("/my/deploy/dir").and_return(false)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    allow(::Dir).to receive(:entries).with("/my/deploy/dir").and_return(["..", "."])
-    expect(@provider).to receive(:clone)
-    expect(@provider).to receive(:checkout)
-    expect(@provider).to receive(:enable_submodules)
-    expect(@provider).to receive(:add_remotes)
-    @provider.run_action(:checkout)
-    # @resource.should be_updated
-  end
-
-  it "should not checkout if the destination exists or is a non empty directory" do
-    # will be invoked in load_current_resource
-    allow(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(false)
-
-    allow(::File).to receive(:exist?).with("/my/deploy/dir").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    allow(::Dir).to receive(:entries).with("/my/deploy/dir").and_return([".", "..", "foo", "bar"])
-    expect(@provider).not_to receive(:clone)
-    expect(@provider).not_to receive(:checkout)
-    expect(@provider).not_to receive(:enable_submodules)
-    expect(@provider).not_to receive(:add_remotes)
-    @provider.run_action(:checkout)
-    expect(@resource).not_to be_updated
-  end
-
-  it "syncs the code by updating the source when the repo has already been checked out" do
-    expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    expect(@provider).to receive(:find_current_revision).exactly(1).and_return("d35af14d41ae22b19da05d7d03a0bafc321b244c")
-    expect(@provider).not_to receive(:fetch_updates)
-    expect(@provider).to receive(:add_remotes)
-    @provider.run_action(:sync)
-    expect(@resource).not_to be_updated
-  end
-
-  it "marks the resource as updated when the repo is updated and gets a new version" do
-    expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    # invoked twice - first time from load_current_resource
-    expect(@provider).to receive(:find_current_revision).exactly(1).and_return("d35af14d41ae22b19da05d7d03a0bafc321b244c")
-    allow(@provider).to receive(:target_revision).and_return("28af684d8460ba4793eda3e7ac238c864a5d029a")
-    expect(@provider).to receive(:fetch_updates)
-    expect(@provider).to receive(:enable_submodules)
-    expect(@provider).to receive(:add_remotes)
-    @provider.run_action(:sync)
-    # @resource.should be_updated
-  end
-
-  it "does not fetch any updates if the remote revision matches the current revision" do
-    expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    allow(@provider).to receive(:find_current_revision).and_return("d35af14d41ae22b19da05d7d03a0bafc321b244c")
-    allow(@provider).to receive(:target_revision).and_return("d35af14d41ae22b19da05d7d03a0bafc321b244c")
-    expect(@provider).not_to receive(:fetch_updates)
-    expect(@provider).to receive(:add_remotes)
-    @provider.run_action(:sync)
-    expect(@resource).not_to be_updated
-  end
-
-  it "clones the repo instead of fetching it if the deploy directory doesn't exist" do
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").exactly(2).and_return(false)
-    expect(@provider).to receive(:action_checkout)
-    expect(@provider).not_to receive(:shell_out!)
-    @provider.run_action(:sync)
-    # @resource.should be_updated
-  end
-
-  it "clones the repo instead of fetching updates if the deploy directory is empty" do
-    expect(::File).to receive(:exist?).with("/my/deploy/dir/.git").exactly(2).and_return(false)
-    allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
-    allow(::File).to receive(:directory?).with("/my/deploy/dir").and_return(true)
-    allow(@provider).to receive(:sync_command).and_return("huzzah!")
-    expect(@provider).to receive(:action_checkout)
-    expect(@provider).not_to receive(:shell_out!).with("huzzah!", cwd: "/my/deploy/dir")
-    @provider.run_action(:sync)
-    # @resource.should be_updated
-  end
-
-  it "does an export by cloning the repo then removing the .git directory" do
-    expect(@provider).to receive(:action_checkout)
-    expect(FileUtils).to receive(:rm_rf).with(@resource.destination + "/.git")
-    @provider.run_action(:export)
-    expect(@resource).to be_updated
-  end
-
-  describe "calling add_remotes" do
-    it "adds a new remote for each entry in additional remotes hash" do
-      @resource.additional_remotes({ opscode: "opscode_repo_url",
-                                     another_repo: "some_other_repo_url" })
-      allow(STDOUT).to receive(:tty?).and_return(false)
-      command_response = double("shell_out")
-      allow(command_response).to receive(:exitstatus) { 0 }
-      @resource.additional_remotes.each_pair do |remote_name, remote_url|
-        expect(@provider).to receive(:setup_remote_tracking_branches).with(remote_name, remote_url)
-      end
-      @provider.add_remotes
-    end
-  end
-
-  describe "calling multiple_remotes?" do
-    before(:each) do
-      @command_response = double("shell_out")
-    end
-
-    describe "when check remote command returns with status 2" do
-      it "returns true" do
-        allow(@command_response).to receive(:exitstatus) { 2 }
-        expect(@provider.multiple_remotes?(@command_response)).to be_truthy
-      end
-    end
-
-    describe "when check remote command returns with status 0" do
-      it "returns false" do
-        allow(@command_response).to receive(:exitstatus) { 0 }
-        expect(@provider.multiple_remotes?(@command_response)).to be_falsey
-      end
-    end
-
-    describe "when check remote command returns with status 0" do
-      it "returns false" do
-        allow(@command_response).to receive(:exitstatus) { 1 }
-        expect(@provider.multiple_remotes?(@command_response)).to be_falsey
-      end
-    end
-  end
-
-  describe "calling remote_matches?" do
-    before(:each) do
-      @command_response = double("shell_out")
-    end
-
-    describe "when output of the check remote command matches the repository url" do
-      it "returns true" do
-        allow(@command_response).to receive(:exitstatus) { 0 }
-        allow(@command_response).to receive(:stdout) { @resource.repository }
-        expect(@provider.remote_matches?(@resource.repository, @command_response)).to be_truthy
-      end
-    end
-
-    describe "when output of the check remote command doesn't match the repository url" do
-      it "returns false" do
-        allow(@command_response).to receive(:exitstatus) { 0 }
-        allow(@command_response).to receive(:stdout) { @resource.repository + "test" }
-        expect(@provider.remote_matches?(@resource.repository, @command_response)).to be_falsey
-      end
-    end
-  end
-end