akerl-r10k 3.14.2.1

data/spec/unit/git/alternates_spec.rb

@@ -0,0 +1,116 @@
+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/https---github.com-puppetlabs-puppetlabs-apache.git\n",
+        "/vagrant/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git\n",
+      ])
+
+      expect(subject.read).to eq([
+        "/var/cache/r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git",
+        "/vagrant/.r10k/git/https---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/https---github.com-puppetlabs-puppetlabs-apache.git",
+        "/vagrant/.r10k/git/https---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/https---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/https---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/https---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/https---github.com-puppetlabs-puppetlabs-apache.git"])
+        expect(io.string).to eq("/tmp/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git\n")
+      end
+
+      it "rewrites the file with all alternate entries" do
+        subject.write(["/var/cache/r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git",
+                       "/vagrant/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git",
+                       "/tmp/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git"])
+
+        expect(io.string).to eq(<<-EOD)
+/var/cache/r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git
+/vagrant/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git
+/tmp/.r10k/git/https---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/https---github.com-puppetlabs-puppetlabs-apache.git",
+                                                       "/vagrant/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git"])
+
+        expect(subject).to receive(:write).with(["/var/cache/r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git",
+                                                 "/vagrant/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git",
+                                                 "/tmp/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git"])
+
+        subject.add("/tmp/.r10k/git/https---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/https---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/https---github.com-puppetlabs-puppetlabs-apache.git",
+                                               "/tmp/.r10k/git/https---github.com-puppetlabs-puppetlabs-apache.git"])
+      expect(subject.add?("/tmp/.r10k/git/https---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/https---github.com-puppetlabs-puppetlabs-apache.git")).to eq false
+    end
+  end
+end

data/spec/unit/git/cache_spec.rb

@@ -0,0 +1,66 @@
+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) { 'https://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

@@ -0,0 +1,48 @@
+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('https://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' => 'https://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

@@ -0,0 +1,215 @@
+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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'r10k/git/shellgit/cache'
+
+describe R10K::Git::ShellGit::Cache do
+
+  subject { described_class.new('https://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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'r10k/git'
+require 'r10k/git/stateful_repository'
+
+describe R10K::Git::StatefulRepository do
+
+  let(:remote) { 'https://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

@@ -0,0 +1,102 @@
+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