r10k 3.14.1 → 3.15.1

data/spec/unit/git/alternates_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'stringio'
-require 'r10k/git'
-
-describe R10K::Git::Alternates do
-  subject { described_class.new(Pathname.new("/some/nonexistent/path/.git")) }
-
-  it "interacts with the alternates file in the given git repository" do
-    expect(subject.file.to_s).to eq("/some/nonexistent/path/.git/objects/info/alternates")
-  end
-
-  describe "reading alternate object entries" do
-    it "reads the alternates file and splits on lines" do
-      expect(subject.file).to receive(:file?).and_return true
-      expect(subject.file).to receive(:readlines).and_return([
-        "/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git\n",
-        "/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git\n",
-      ])
-
-      expect(subject.read).to eq([
-        "/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-        "/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-      ])
-    end
-
-    it "returns an empty array when the file is not present" do
-      expect(subject.file).to receive(:file?).and_return false
-      expect(subject.file).to receive(:readlines).never
-      expect(subject.to_a).to eq([])
-    end
-  end
-
-  describe "determining if an entry is already present" do
-    before do
-      allow(subject).to receive(:to_a).and_return([
-        "/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-        "/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-      ])
-    end
-
-    it "is true if the element is in the array of read entries" do
-      expect(subject).to include("/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git")
-    end
-
-    it "is false if the element is not in the array of read entries" do
-      expect(subject).to_not include("/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git")
-    end
-  end
-
-
-  describe "writing alternate entries" do
-    describe "and the git objects/info directory does not exist" do
-      it "raises an error when the parent directory does not exist" do
-        expect {
-          subject.write(["/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git"])
-        }.to raise_error(R10K::Git::GitError,"Cannot write /some/nonexistent/path/.git/objects/info/alternates; parent directory does not exist")
-      end
-    end
-
-    describe "and the git objects/info directory exists" do
-      let(:io) { StringIO.new }
-
-      before do
-        expect(subject.file).to receive(:open).with('w').and_yield(io)
-        expect(subject.file).to receive_message_chain(:parent, :directory?).and_return true
-      end
-
-      it "creates the alternates file with the new entry when not present" do
-        subject.write(["/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git"])
-        expect(io.string).to eq("/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git\n")
-      end
-
-      it "rewrites the file with all alternate entries" do
-        subject.write(["/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-                       "/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-                       "/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git"])
-
-        expect(io.string).to eq(<<-EOD)
-/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git
-/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git
-/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git
-        EOD
-      end
-    end
-
-    describe "appending a new alternate object entry" do
-      it "re-writes the file with the new entry concatenated to the file" do
-        expect(subject).to receive(:to_a).and_return(["/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-                                                       "/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git"])
-
-        expect(subject).to receive(:write).with(["/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-                                                 "/vagrant/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-                                                 "/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git"])
-
-        subject.add("/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git")
-      end
-    end
-  end
-
-  describe "conditionally appending a new alternate object entry" do
-    before do
-      expect(subject).to receive(:read).and_return(%w[/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git])
-    end
-
-    it "adds the entry and returns true when the entry doesn't exist" do
-      expect(subject).to receive(:write).with(["/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git",
-                                               "/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git"])
-      expect(subject.add?("/tmp/.r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git")).to eq true
-    end
-
-    it "doesn't modify the file and returns false when the entry exists" do
-      expect(subject).to_not receive(:write)
-      expect(subject.add?("/var/cache/r10k/git/git---github.com-puppetlabs-puppetlabs-apache.git")).to eq false
-    end
-  end
-end

data/spec/unit/git/cache_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'r10k/git/cache'
-
-describe R10K::Git::Cache do
-
-  describe 'the default cache_root' do
-    it 'is in the right location in linux', unless: R10K::Util::Platform.windows?  do
-      expect(described_class.defaults[:cache_root]).to match(/\.r10k\/git/)
-    end
-
-    it 'is in the right location for windows', if: R10K::Util::Platform.windows? do
-      expect(described_class.defaults[:cache_root]).to match(/[^.]r10k\/git/)
-    end
-  end
-
-  let(:subclass) do
-    Class.new(described_class) do
-      def self.bare_repository
-        Class.new { def initialize(*args) end }
-      end
-    end
-  end
-
-  let(:remote) { 'git://some/git/remote' }
-  subject { subclass.new(remote) }
-
-  describe "updating the cache" do
-    it "only updates the cache once" do
-      expect(subject).to receive(:sync!).exactly(1).times
-      subject.sync
-      subject.sync
-    end
-  end
-
-  describe "methods on the repository" do
-    def expect_delegation(method)
-      expect(subject.repo).to receive(method)
-      subject.send(method)
-    end
-
-    it "delegates #git_dir" do
-      expect_delegation(:git_dir)
-    end
-
-    it "delegates #objects_dir" do
-      expect_delegation(:objects_dir)
-    end
-
-    it "delegates #branches" do
-      expect_delegation(:branches)
-    end
-
-    it "delegates #tags" do
-      expect_delegation(:tags)
-    end
-
-    it "delegates #exist?" do
-      expect_delegation(:exist?)
-    end
-
-    it "aliases #cached? to #exist?" do
-      expect(subject.repo).to receive(:exist?)
-      subject.cached?
-    end
-  end
-end

data/spec/unit/git/rugged/cache_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe R10K::Git::Rugged::Cache, :unless => R10K::Util::Platform.jruby? do
-  before(:all) do
-    require 'r10k/git/rugged/cache'
-  end
-
-  subject(:cache) { described_class.new('git://some/git/remote') }
-
-  it "wraps a Rugged::BareRepository instance" do
-    expect(cache.repo).to be_a_kind_of R10K::Git::Rugged::BareRepository
-  end
-
-  describe "settings" do
-    before do
-      R10K::Git::Cache.settings[:cache_root] = '/some/path'
-      described_class.settings.reset!
-    end
-
-    after do
-      R10K::Git::Cache.settings.reset!
-      described_class.settings.reset!
-    end
-
-    it "falls back to the parent class settings" do
-      expect(described_class.settings[:cache_root]).to eq '/some/path'
-    end
-  end
-
-  describe "remote url updates" do
-    before do
-      allow(subject.repo).to receive(:exist?).and_return true
-      allow(subject.repo).to receive(:fetch)
-      allow(subject.repo).to receive(:remotes).and_return({ 'origin' => 'git://some/git/remote' })
-    end
-
-    it "does not update the URLs if they match" do
-      expect(subject.repo).to_not receive(:update_remote)
-      subject.sync!
-    end
-
-    it "updates the remote URL if they do not match" do
-      allow(subject.repo).to receive(:remotes).and_return({ 'origin' => 'foo'})
-      expect(subject.repo).to receive(:update_remote)
-      subject.sync!
-    end
-  end
-end

data/spec/unit/git/rugged/credentials_spec.rb

@@ -1,215 +0,0 @@
-require 'spec_helper'
-
-describe R10K::Git::Rugged::Credentials, :unless => R10K::Util::Platform.jruby?  || R10K::Util::Platform.windows? do
-  before(:all) do
-    require 'r10k/git/rugged/credentials'
-    require 'rugged/credentials'
-  end
-
-  let(:repo) { R10K::Git::Rugged::BareRepository.new("/some/nonexistent/path", "repo.git") }
-
-  subject { described_class.new(repo) }
-
-  after(:each) { R10K::Git.settings.reset! }
-
-  describe "determining the username" do
-    before { R10K::Git.settings[:username] = "moderns" }
-    after { R10K::Git.settings.reset! }
-
-    it "prefers a username from the URL" do
-      user = subject.get_git_username("https://tessier-ashpool.freeside/repo.git", "ashpool")
-      expect(user).to eq "ashpool"
-    end
-
-    it "uses the username from the Git config when specified" do
-      user = subject.get_git_username("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(user).to eq "moderns"
-    end
-
-    it "falls back to the current user" do
-      R10K::Git.settings.reset!
-      expect(Etc).to receive(:getlogin).and_return("finn")
-      user = subject.get_git_username("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(user).to eq "finn"
-    end
-  end
-
-  describe "generating ssh key credentials" do
-    after(:each) { R10K::Git.settings.reset! }
-
-    it "prefers a per-repository SSH private key" do
-      allow(File).to receive(:readable?).with("/etc/puppetlabs/r10k/ssh/tessier-ashpool-id_rsa").and_return true
-      R10K::Git.settings[:private_key] = "/etc/puppetlabs/r10k/ssh/id_rsa"
-      R10K::Git.settings[:repositories] = [{ remote: "ssh://git@tessier-ashpool.freeside/repo.git",
-        private_key: "/etc/puppetlabs/r10k/ssh/tessier-ashpool-id_rsa"}]
-      creds = subject.get_ssh_key_credentials("ssh://git@tessier-ashpool.freeside/repo.git", nil)
-      expect(creds).to be_a_kind_of(Rugged::Credentials::SshKey)
-      expect(creds.instance_variable_get(:@privatekey)).to eq("/etc/puppetlabs/r10k/ssh/tessier-ashpool-id_rsa")
-    end
-
-    it "falls back to the global SSH private key" do
-      allow(File).to receive(:readable?).with("/etc/puppetlabs/r10k/ssh/id_rsa").and_return true
-      R10K::Git.settings[:private_key] = "/etc/puppetlabs/r10k/ssh/id_rsa"
-      creds = subject.get_ssh_key_credentials("ssh://git@tessier-ashpool.freeside/repo.git", nil)
-      expect(creds).to be_a_kind_of(Rugged::Credentials::SshKey)
-      expect(creds.instance_variable_get(:@privatekey)).to eq("/etc/puppetlabs/r10k/ssh/id_rsa")
-    end
-
-    it "raises an error if no key has been set" do
-      R10K::Git.settings[:private_key] = nil
-      expect {
-        subject.get_ssh_key_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      }.to raise_error(R10K::Git::GitError, /no private key was given/)
-    end
-
-    it "raises an error if the private key is unreadable" do
-      R10K::Git.settings[:private_key] = "/some/nonexistent/.ssh/key"
-      expect(File).to receive(:readable?).with("/some/nonexistent/.ssh/key").and_return false
-      expect {
-        subject.get_ssh_key_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      }.to raise_error(R10K::Git::GitError, /Unable to use SSH key auth for.*is missing or unreadable/)
-    end
-
-    it "generates the rugged sshkey credential type" do
-      allow(File).to receive(:readable?).with("/etc/puppetlabs/r10k/ssh/id_rsa").and_return true
-      R10K::Git.settings[:private_key] = "/etc/puppetlabs/r10k/ssh/id_rsa"
-      creds = subject.get_ssh_key_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(creds).to be_a_kind_of(Rugged::Credentials::SshKey)
-      expect(creds.instance_variable_get(:@privatekey)).to eq("/etc/puppetlabs/r10k/ssh/id_rsa")
-    end
-  end
-
-  describe "generating github app tokens" do
-    it 'errors if app id has invalid characters' do
-      expect { subject.github_app_token("123A567890", "fake", "300")
-      }.to raise_error(R10K::Git::GitError, /App id contains invalid characters/)
-    end
-    it 'errors if app ttl has invalid characters' do
-      expect { subject.github_app_token("123456", "fake", "abc")
-      }.to raise_error(R10K::Git::GitError, /Github App token ttl contains/)
-    end
-    it 'errors if private file does not exist' do
-      R10K::Git.settings[:github_app_key] = "/missing/token/file"
-      expect(File).to receive(:readable?).with(R10K::Git.settings[:github_app_key]).and_return false
-      expect {
-        subject.github_app_token("123456", R10K::Git.settings[:github_app_key], "300")
-      }.to raise_error(R10K::Git::GitError, /App key is missing or unreadable/)
-    end
-    it 'errors if file is not a valid SSL key' do
-      token_file = Tempfile.new('token')
-      token_file.write('my_token')
-      token_file.close
-      R10K::Git.settings[:github_app_key] = token_file.path
-      expect(File).to receive(:readable?).with(token_file.path).and_return true
-      expect {
-        subject.github_app_token("123456", R10K::Git.settings[:github_app_key], "300")
-      }.to raise_error(R10K::Git::GitError, /App key is not a valid SSL key/)
-      token_file.unlink
-    end
-  end
-
-  describe "generating token credentials" do
-    it 'errors if token file does not exist' do
-      R10K::Git.settings[:oauth_token] = "/missing/token/file"
-      expect(File).to receive(:readable?).with("/missing/token/file").and_return false
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
-      expect {
-        subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      }.to raise_error(R10K::Git::GitError, /cannot load OAuth token/)
-    end
-
-    it 'errors if the token on stdin is not a valid OAuth token' do
-      allow($stdin).to receive(:read).and_return("<bad>token")
-      R10K::Git.settings[:oauth_token] = "-"
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
-      expect {
-        subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      }.to raise_error(R10K::Git::GitError, /invalid characters/)
-    end
-
-    it 'errors if the token in the file is not a valid OAuth token' do
-      token_file = Tempfile.new('token')
-      token_file.write('my bad \ntoken')
-      token_file.close
-      R10K::Git.settings[:oauth_token] = token_file.path
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
-      expect {
-        subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      }.to raise_error(R10K::Git::GitError, /invalid characters/)
-    end
-
-    it 'prefers per-repo token file' do
-      token_file = Tempfile.new('token')
-      token_file.write('my_token')
-      token_file.close
-      R10K::Git.settings[:oauth_token] = "/do/not/use"
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git",
-                                            oauth_token: token_file.path }]
-      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(creds).to be_a_kind_of(Rugged::Credentials::UserPassword)
-      expect(creds.instance_variable_get(:@password)).to eq("my_token")
-      expect(creds.instance_variable_get(:@username)).to eq("x-oauth-token")
-    end
-
-    it 'uses the token from a file as a password' do
-      token_file = Tempfile.new('token')
-      token_file.write('my_token')
-      token_file.close
-      R10K::Git.settings[:oauth_token] = token_file.path
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
-      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(creds).to be_a_kind_of(Rugged::Credentials::UserPassword)
-      expect(creds.instance_variable_get(:@password)).to eq("my_token")
-      expect(creds.instance_variable_get(:@username)).to eq("x-oauth-token")
-    end
-
-    it 'uses the token from stdin as a password' do
-      allow($stdin).to receive(:read).and_return("my_token")
-      R10K::Git.settings[:oauth_token] = '-'
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
-      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(creds).to be_a_kind_of(Rugged::Credentials::UserPassword)
-      expect(creds.instance_variable_get(:@password)).to eq("my_token")
-      expect(creds.instance_variable_get(:@username)).to eq("x-oauth-token")
-    end
-
-    it 'only reads the token in once' do
-      expect($stdin).to receive(:read).and_return("my_token").once
-      R10K::Git.settings[:oauth_token] = '-'
-      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
-      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(creds.instance_variable_get(:@password)).to eq("my_token")
-      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
-      expect(creds.instance_variable_get(:@password)).to eq("my_token")
-    end
-  end
-
-  describe "generating default credentials" do
-    it "generates the rugged default credential type" do
-      creds = subject.get_default_credentials("https://azurediamond:hunter2@tessier-ashpool.freeside/repo.git", "azurediamond")
-      expect(creds).to be_a_kind_of(Rugged::Credentials::Default)
-    end
-  end
-
-  describe "generating credentials" do
-    it "creates ssh key credentials for the sshkey allowed type" do
-      allow(File).to receive(:readable?).with("/etc/puppetlabs/r10k/ssh/id_rsa").and_return true
-      R10K::Git.settings[:private_key] = "/etc/puppetlabs/r10k/ssh/id_rsa"
-      expect(subject.call("https://tessier-ashpool.freeside/repo.git", nil, [:ssh_key])).to be_a_kind_of(Rugged::Credentials::SshKey)
-    end
-
-    it "creates user/password credentials for the default allowed type" do
-      expect(subject.call("https://tessier-ashpool.freeside/repo.git", nil, [:plaintext])).to be_a_kind_of(Rugged::Credentials::UserPassword)
-    end
-
-    it "creates default credentials when no other types are allowed" do
-      expect(subject.call("https://tessier-ashpool.freeside/repo.git", nil, [])).to be_a_kind_of(Rugged::Credentials::Default)
-    end
-
-    it "refuses to generate credentials more than 50 times" do
-      (1..50).each { subject.call("https://tessier-ashpool.freeside/repo.git", nil, [:plaintext]) }
-
-      expect { subject.call("https://tessier-ashpool.freeside/repo.git", nil, [:plaintext]) }.to raise_error(R10K::Git::GitError, /authentication failed/i)
-    end
-  end
-end

data/spec/unit/git/shellgit/cache_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'r10k/git/shellgit/cache'
-
-describe R10K::Git::ShellGit::Cache do
-
-  subject { described_class.new('git://some/git/remote') }
-
-  it "wraps a ShellGit::BareRepository instance" do
-    expect(subject.repo).to be_a_kind_of R10K::Git::ShellGit::BareRepository
-  end
-
-  describe "settings" do
-    before do
-      R10K::Git::Cache.settings[:cache_root] = '/some/path'
-      described_class.settings.reset!
-    end
-
-    after do
-      R10K::Git::Cache.settings.reset!
-      described_class.settings.reset!
-    end
-
-    it "falls back to the parent class settings" do
-      expect(described_class.settings[:cache_root]).to eq '/some/path'
-    end
-  end
-end

data/spec/unit/git/stateful_repository_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'r10k/git'
-require 'r10k/git/stateful_repository'
-
-describe R10K::Git::StatefulRepository do
-
-  let(:remote) { 'git://some.site/some-repo.git' }
-  let(:ref) { '0.9.x' }
-
-  subject { described_class.new(remote, '/some/nonexistent/basedir', 'some-dirname') }
-
-  describe "determining if the cache needs to be synced" do
-    let(:cache) { double('cache') }
-
-    before { expect(R10K::Git.cache).to receive(:generate).with(remote).and_return(cache) }
-
-    it "is true if the cache is absent" do
-      expect(cache).to receive(:exist?).and_return false
-      expect(subject.sync_cache?(ref)).to eq true
-    end
-
-    it "is true if the ref is HEAD" do
-      expect(cache).to receive(:exist?).and_return true
-      expect(subject.sync_cache?('HEAD')).to eq true
-    end
-
-    it "is true if the ref is unresolvable" do
-      expect(cache).to receive(:exist?).and_return true
-      expect(cache).to receive(:ref_type).with('0.9.x').and_return(:unknown)
-      expect(subject.sync_cache?(ref)).to eq true
-    end
-
-    it "is true if the ref is not a tag or commit" do
-      expect(cache).to receive(:exist?).and_return true
-      expect(cache).to receive(:ref_type).with('0.9.x').and_return(:branch)
-      expect(subject.sync_cache?(ref)).to eq true
-    end
-
-    it "is false otherwise" do
-      expect(cache).to receive(:exist?).and_return true
-      expect(cache).to receive(:ref_type).with('0.9.x').and_return(:tag)
-      expect(subject.sync_cache?(ref)).to eq false
-    end
-  end
-end

data/spec/unit/git_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-require 'r10k/git'
-
-describe R10K::Git do
-  before { described_class.reset! }
-  after  { described_class.reset! }
-
-  describe 'selecting the default provider' do
-    it 'returns shellgit when the git executable is present' do
-      expect(R10K::Features).to receive(:available?).with(:shellgit).and_return true
-      expect(described_class.default_name).to eq :shellgit
-    end
-
-    context 'under c-based rubies with rugged available', :unless => R10K::Util::Platform.jruby? || R10K::Util::Platform.windows? do
-      it 'returns rugged when the git executable is absent and the rugged library is present' do
-        expect(R10K::Features).to receive(:available?).with(:shellgit).and_return false
-        expect(R10K::Features).to receive(:available?).with(:rugged).and_return true
-        expect(described_class.default_name).to eq :rugged
-      end
-    end
-
-    it 'raises an error when the git executable and rugged library are absent' do
-      expect(R10K::Features).to receive(:available?).with(:shellgit).and_return false
-      expect(R10K::Features).to receive(:available?).with(:rugged).and_return false
-      expect {
-        described_class.default_name
-      }.to raise_error(R10K::Error, 'No Git providers are functional.')
-    end
-
-    it "goes into an error state if an invalid provider was set" do
-      begin
-        described_class.provider = :nope
-      rescue R10K::Error
-      end
-
-      expect {
-        described_class.provider
-      }.to raise_error(R10K::Error, "No Git provider set.")
-    end
-  end
-
-  describe 'explicitly setting the provider' do
-    it "raises an error if the provider doesn't exist" do
-      expect {
-        described_class.provider = :nope
-      }.to raise_error(R10K::Error, "No Git provider named 'nope'.")
-    end
-
-    it "raises an error if the provider isn't functional" do
-      expect(R10K::Features).to receive(:available?).with(:shellgit).and_return false
-      expect {
-        described_class.provider = :shellgit
-      }.to raise_error(R10K::Error, "Git provider 'shellgit' is not functional.")
-    end
-
-    context 'under c-based rubies with rugged available', :unless => R10K::Util::Platform.jruby? || R10K::Util::Platform.windows? do
-      it "sets the current provider if the provider exists and is functional" do
-        expect(R10K::Features).to receive(:available?).with(:rugged).and_return true
-        described_class.provider = :rugged
-        expect(described_class.provider).to eq(R10K::Git::Rugged)
-      end
-    end
-
-    context 'under jruby', :if => R10K::Util::Platform.jruby? do
-      it "sets the current provider if the provider exists and is functional" do
-        expect(R10K::Features).to receive(:available?).with(:shellgit).and_return true
-        described_class.provider = :shellgit
-        expect(described_class.provider).to eq(R10K::Git::ShellGit)
-      end
-    end
-  end
-
-  describe "retrieving the current provider" do
-    context 'under c-based rubies', :unless => R10K::Util::Platform.jruby? || R10K::Util::Platform.windows? do
-      it "uses the default if a provider has not been set" do
-        expect(described_class).to receive(:default_name).and_return :rugged
-        expect(described_class.provider).to eq(R10K::Git::Rugged)
-      end
-
-      it "uses an explicitly set provider" do
-        expect(R10K::Features).to receive(:available?).with(:rugged).and_return true
-        described_class.provider = :rugged
-        expect(described_class).to_not receive(:default)
-        expect(described_class.provider).to eq R10K::Git::Rugged
-      end
-    end
-
-    context 'under jruby', :if => R10K::Util::Platform.jruby? do
-      it "uses the default if a provider has not been set" do
-        expect(described_class).to receive(:default_name).and_return :shellgit
-        expect(described_class.provider).to eq(R10K::Git::ShellGit)
-      end
-
-      it "uses an explicitly set provider" do
-        expect(R10K::Features).to receive(:available?).with(:shellgit).and_return true
-        described_class.provider = :shellgit
-        expect(described_class).to_not receive(:default)
-        expect(described_class.provider).to eq R10K::Git::ShellGit
-      end
-    end
-  end
-end