r10k 1.4.2 → 1.5.1

data/spec/unit/feature_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'r10k/feature'
+
+describe R10K::Feature do
+  describe "confining a feature to a library" do
+    it "is available if the library can be loaded" do
+      feature = described_class.new(:r10k, :libraries => 'r10k')
+      expect(feature.available?).to be_truthy
+    end
+
+    it "is unavailable if the library cannot be loaded" do
+      feature = described_class.new(:squidlibs, :libraries => 'squid/libs')
+      expect(feature.available?).to be_falsey
+    end
+  end
+
+  describe "confining a feature to a block" do
+    it "is available if the block is true" do
+      feature = described_class.new(:blockfeature) { true }
+      expect(feature.available?).to be_truthy
+    end
+
+    it "is unavailable if the block is false" do
+      feature = described_class.new(:blockfeature) { false }
+      expect(feature.available?).to be_falsey
+    end
+  end
+
+  describe  "confining a feature to both a block and libraries" do
+    it "is unavailable if the block returns false and libraries are absent" do
+      feature = described_class.new(:nope, :libraries => 'nope/nope') { false }
+      expect(feature.available?).to be_falsey
+    end
+
+    it "is unavailable if the block returns true and libraries are absent" do
+      feature = described_class.new(:nope, :libraries => 'nope/nope') { true }
+      expect(feature.available?).to be_falsey
+    end
+
+    it "is unavailable if the block returns false and libraries are present" do
+      feature = described_class.new(:nope, :libraries => 'r10k') { false }
+      expect(feature.available?).to be_falsey
+    end
+
+    it "is available if the block returns true and libraries are present" do
+      feature = described_class.new(:yep, :libraries => 'r10k') { true }
+      expect(feature.available?).to be_truthy
+    end
+  end
+end

data/spec/unit/git/alternates_spec.rb

@@ -3,7 +3,7 @@ require 'stringio'
 require 'r10k/git'
 
 describe R10K::Git::Alternates do
-  subject { described_class.new("/some/nonexistent/path/.git") }
+  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")

data/spec/unit/git/cache_spec.rb

@@ -3,36 +3,49 @@ require 'r10k/git/cache'
 
 describe R10K::Git::Cache do
 
-  subject(:cache) { described_class.new('git://some/git/remote') }
-
-  before do
-    expect(cache).to receive(:execute).never
+  let(:subclass) do
+    Class.new(described_class) do
+      def self.bare_repository
+        Class.new { def initialize(*args) end }
+      end
+    end
   end
 
+  subject { subclass.new('git://some/git/remote') }
+
   describe "updating the cache" do
     it "only updates the cache once" do
-      expect(cache).to receive(:sync!).exactly(1).times
-      cache.sync
-      cache.sync
+      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
 
-  describe "enumerating branches" do
-    let(:refs) do
-      %w[
-        refs/heads/master
-        refs/heads/next
-        refs/heads/next-fetch-errors
-        refs/heads/next-update-forge-modules
-      ].map { |line| line + "\n" }.join
+    it "delegates #branches" do
+      expect_delegation(:branches)
     end
 
-    it "lists local branches using git for-each-ref" do
-      expect(cache).to receive(:git).with(%w[for-each-ref refs/heads --format %(refname)], anything).and_return(double(:stdout => refs))
+    it "delegates #tags" do
+      expect_delegation(:tags)
+    end
 
-      expect(cache.branches).to eq %w[master next next-fetch-errors next-update-forge-modules]
+    it "delegates #exist?" do
+      expect_delegation(:exist?)
     end
-  end
 
+    it "aliases #cached? to #exist?" do
+      expect(subject.repo).to receive(:exist?)
+      subject.cached?
+    end
+  end
 end

data/spec/unit/git/commit_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'r10k/git'
+require 'r10k/git/commit'
 
 describe R10K::Git::Commit do
 

data/spec/unit/git/head_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'r10k/git'
+require 'r10k/git/head'
 
 describe R10K::Git::Head do
 
@@ -7,11 +8,6 @@ describe R10K::Git::Head do
   let(:repo) { double('git repository') }
   subject { described_class.new(ref) }
 
-
-  describe "determining if the head can be resolved" do
-    it "is always false"
-  end
-
   describe "determining if the head needs to be fetched" do
     it "is always true" do
       expect(subject.fetch?).to be_truthy
@@ -24,4 +20,3 @@ describe R10K::Git::Head do
 
   it_behaves_like "a git ref"
 end
-

data/spec/unit/git/ref_spec.rb

@@ -37,29 +37,6 @@ describe R10K::Git::Ref do
     end
   end
 
-  describe "determining if the ref can be resolved" do
-    describe "and the ref is a head" do
-      it "is always false"
-    end
-
-    describe "and the ref is a tag" do
-      it "is true if the tag has been fetched"
-      it "is false if the tag cannot be resolved"
-    end
-
-    describe "and the ref is a commit" do
-      it "is true if the commit has been fetched"
-      it "is false if the commit cannot be resolved"
-    end
-  end
-
-  describe "determining if the ref needs to be fetched" do
-    it "uses the result of #resolvable? if the ref is a tag"
-    it "uses the result of #resolvable? if the ref is a commit"
-
-    it "is true if the ref is a head"
-  end
-
   it "can be converted to a string" do
     expect(subject.to_s).to eq ref
   end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'r10k/git/rugged/cache'
+
+describe R10K::Git::Rugged::Cache do
+  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
+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('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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'r10k/git'
+require 'r10k/git/stateful_repository'
+
+describe R10K::Git::StatefulRepository do
+
+  let(:remote) { 'git://some.site/some-repo.git' }
+
+  subject { described_class.new('0.9.x', 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?).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(:resolve).with('0.9.x')
+      expect(subject.sync_cache?).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(:resolve).with('0.9.x').and_return('93456ec7dc0f6fd3ac193b4df64f6544615dfbc9')
+      expect(cache).to receive(:ref_type).with('0.9.x').and_return(:branch)
+      expect(subject.sync_cache?).to eq true
+    end
+
+    it "is false otherwise" do
+      expect(cache).to receive(:exist?).and_return true
+      expect(cache).to receive(:resolve).with('0.9.x').and_return('93456ec7dc0f6fd3ac193b4df64f6544615dfbc9')
+      expect(cache).to receive(:ref_type).with('0.9.x').and_return(:tag)
+      expect(subject.sync_cache?).to eq false
+    end
+
+  end
+end

data/spec/unit/git/tag_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'r10k/git'
+require 'r10k/git/tag'
 
 describe R10K::Git::Tag do
 

data/spec/unit/git/working_dir_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'r10k/git'
+require 'r10k/git/working_dir'
 
 describe R10K::Git::WorkingDir do
   include_context "fail on execution"

data/spec/unit/git_spec.rb

@@ -0,0 +1,74 @@
+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).to eq R10K::Git::ShellGit
+    end
+
+    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).to eq R10K::Git::Rugged
+    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
+      }.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
+
+    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
+
+  describe "retrieving the current provider" do
+    it "uses the default if a provider has not been set" do
+      expect(described_class).to receive(:default).and_return :def
+      expect(described_class.provider).to eq :def
+    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
+end

data/spec/unit/logging/terminaloutputter_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'stringio'
+require 'r10k/logging/terminaloutputter'
+
+describe R10K::Logging::TerminalOutputter do
+
+  let(:stream) { StringIO.new }
+
+  let(:formatter) do
+    Class.new(Log4r::Formatter) do
+      def format(logevent)
+        logevent.data
+      end
+    end
+  end
+
+  subject do
+    described_class.new('test', stream, :level => 0, :formatter => formatter).tap do |o|
+      o.use_color = true
+    end
+  end
+
+  tests = [
+    [:debug2, :cyan],
+    [:debug1, :cyan],
+    [:debug,  :green],
+    [:info,   nil],
+    [:notice, nil],
+    [:warn,   :yellow],
+    [:error,  :red],
+    [:fatal,  :red],
+  ]
+
+  tests.each_with_index do |(level, color), index|
+    # Note for the unwary - using a loop in this manner shows strange
+    # behavior with variable closure. The describe block is needed to retain
+    # the loop variables for each test; without this the let helpers are
+    # overwritten and the last set of helpers are used for all tests.
+    describe "at level #{level}" do
+      let(:message) { "level #{level}: #{color}" }
+
+      let(:event) do
+        Log4r::LogEvent.new(index + 1, Log4r::Logger.new('test::logger'), nil, message)
+      end
+
+      it "logs messages as #{color ? color : "uncolored"}" do
+        output = color.nil? ? message : message.send(color)
+        subject.send(level, event)
+        expect(stream.string).to eq output
+      end
+    end
+  end
+end

data/spec/unit/logging_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'r10k/logging'
+
+describe R10K::Logging do
+
+  describe "parsing a log level" do
+    it "parses 'true:TrueClass' as INFO" do
+      expect(described_class.parse_level(true)).to eq Log4r::INFO
+    end
+
+    it "parses 'true:String' as nil" do
+      expect(described_class.parse_level("true")).to be_nil
+    end
+
+    it "parses a numeric string as an integer" do
+      expect(described_class.parse_level('2')).to eq 2
+    end
+
+    it "parses a log level string as a log level" do
+      expect(described_class.parse_level('debug')).to eq Log4r::DEBUG
+    end
+
+    it "returns nil when given an invalid log level" do
+      expect(described_class.parse_level('deblag')).to be_nil
+    end
+  end
+
+  describe "setting the log level" do
+    after(:all) { R10K::Logging.level = 'warn' }
+
+    it "sets the outputter log level" do
+      expect(described_class.outputter).to receive(:level=).with(Log4r::DEBUG)
+      described_class.level = 'debug'
+    end
+
+    it "stores the new log level" do
+      allow(described_class.outputter).to receive(:level=)
+      described_class.level = 'debug'
+      expect(described_class.level).to eq(Log4r::DEBUG)
+    end
+
+    it "raises an exception when given an invalid log level" do
+      expect {
+        described_class.level = 'deblag'
+      }.to raise_error(ArgumentError, /Invalid log level/)
+    end
+
+    describe "switching the formatter" do
+      before do
+        allow(described_class.outputter).to receive(:level=)
+      end
+
+      it "switches to the debug formatter if the new log level is debug or greater" do
+        debug_formatter = double('debug formatter')
+        expect(described_class).to receive(:debug_formatter).and_return(debug_formatter)
+        expect(described_class.outputter).to receive(:formatter=).with(debug_formatter)
+        described_class.level = 'debug'
+      end
+
+      it "switches to the default formatter if the new log level is info or less" do
+        default_formatter = double('default formatter')
+        expect(described_class).to receive(:default_formatter).and_return(default_formatter)
+        expect(described_class.outputter).to receive(:formatter=).with(default_formatter)
+        described_class.level = 'info'
+      end
+    end
+  end
+end