r10k 3.5.2

data/spec/unit/util/commands_spec.rb

@@ -0,0 +1,61 @@
+require 'r10k/util/commands'
+require 'r10k/util/exec_env'
+
+require 'tmpdir'
+
+describe R10K::Util::Commands do
+  describe "#which" do
+
+    before do
+      allow(File).to receive(:executable?).and_return false
+      allow(File).to receive(:file?).and_return false
+    end
+
+    def stub_executable(exe)
+      allow(File).to receive(:executable?).with(exe).and_return true
+      allow(File).to receive(:file?).with(exe).and_return true
+    end
+
+    describe "when ENV['PATHEXT'] is unset" do
+      let(:path) { Dir.mktmpdir }
+
+      around(:each) do |example|
+        R10K::Util::ExecEnv.withenv('PATHEXT' => nil, 'PATH' => path) do
+          example.run
+        end
+      end
+
+      it "returns the first matching command in PATH" do
+        exe = File.join(path, 'git')
+        stub_executable(exe)
+        expect(described_class.which("git")).to eq exe
+      end
+
+      it "returns nil if the command could not be found" do
+        exe = File.join(path, 'git')
+        expect(described_class.which("git")).to be_nil
+      end
+    end
+
+    describe "when ENV['PATHEXT'] is set" do
+      let(:path) { Dir.mktmpdir }
+
+      around(:each) do |example|
+        R10K::Util::ExecEnv.withenv('PATHEXT' => '.bat;.exe;.cmd', 'PATH' => path) do
+          example.run
+        end
+      end
+
+      it "returns the first matching command in PATH" do
+        exe = File.join(path, 'git.exe')
+        stub_executable(exe)
+        expect(described_class.which("git")).to eq exe
+      end
+
+      it "returns nil if the command could not be found" do
+        exe = File.join(path, 'git.exe')
+        expect(described_class.which("git")).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/util/exec_env_spec.rb

@@ -0,0 +1,56 @@
+require 'r10k/util/exec_env'
+
+describe R10K::Util::ExecEnv do
+  describe "withenv" do
+    it "adds the keys to the environment during the block" do
+      val = nil
+      described_class.withenv('VAL' => 'something') do
+        val = ENV['VAL']
+      end
+      expect(val).to eq 'something'
+    end
+
+    it "doesn't modify values that were not modified by the passed hash" do
+      origpath = ENV['PATH']
+      path = nil
+      described_class.withenv('VAL' => 'something') do
+        path = ENV['PATH']
+      end
+      expect(path).to eq origpath
+    end
+
+    it "removes new values after the block" do
+      val = nil
+      described_class.withenv('VAL' => 'something') { }
+      expect(ENV['VAL']).to be_nil
+    end
+
+    it "restores old values after the block" do
+      path = ENV['PATH']
+      described_class.withenv('PATH' => '/usr/bin') { }
+      expect(ENV['PATH']).to eq path
+    end
+  end
+
+  describe "reset" do
+
+    after { ENV.delete('VAL') }
+
+    it "replaces environment keys with the specified keys" do
+      ENV['VAL'] = 'hi'
+
+      newenv = ENV.to_hash
+      newenv['VAL'] = 'bye'
+
+      described_class.reset(newenv)
+      expect(ENV['VAL']).to eq 'bye'
+    end
+
+    it "removes any keys that were not provided" do
+      env = ENV.to_hash
+      ENV['VAL'] = 'hi'
+      described_class.reset(env)
+      expect(ENV['VAL']).to be_nil
+    end
+  end
+end

data/spec/unit/util/purgeable_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+require 'r10k/util/purgeable'
+
+RSpec.describe R10K::Util::Purgeable do
+  let(:managed_directories) do
+    [
+      'spec/fixtures/unit/util/purgeable/managed_one',
+      'spec/fixtures/unit/util/purgeable/managed_two',
+    ]
+  end
+
+  let(:desired_contents) do
+    [
+      'spec/fixtures/unit/util/purgeable/managed_one/expected_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/new_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1/subdir_expected_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1/subdir_new_1',
+      'spec/fixtures/unit/util/purgeable/managed_two/expected_2',
+      'spec/fixtures/unit/util/purgeable/managed_two/new_2',
+    ]
+  end
+
+  let(:test_class) do
+    Struct.new(:managed_directories, :desired_contents) do
+      include R10K::Util::Purgeable
+      include R10K::Logging
+    end
+  end
+
+  subject { test_class.new(managed_directories, desired_contents) }
+
+  context 'without recurse option' do
+    let(:recurse) { false }
+
+    describe '#current_contents' do
+      it 'collects direct contents of all managed directories' do
+        expect(subject.current_contents(recurse)).to contain_exactly(/\/expected_1/, /\/expected_2/, /\/unmanaged_1/, /\/unmanaged_2/, /\/managed_subdir_1/)
+      end
+    end
+
+    describe '#pending_contents' do
+      it 'collects desired_contents that do not yet exist' do
+        expect(subject.pending_contents(recurse)).to include(/\/new_1/, /\/new_2/)
+      end
+    end
+
+    describe '#stale_contents' do
+      context 'with no whitelist or exclusions' do
+        let(:exclusions) { [] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist' do
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_1/, /\/unmanaged_2/)
+        end
+      end
+
+      context 'with whitelisted items' do
+        let(:exclusions) { [] }
+        let(:whitelist) { ['**/unmanaged_1'] }
+
+        it 'collects current_contents that should not exist except whitelisted items' do
+          expect(subject.logger).to receive(:debug).with(/unmanaged_1.*whitelist match/i)
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_2/)
+        end
+      end
+
+      context 'with excluded items' do
+        let(:exclusions) { ['**/unmanaged_2'] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist except excluded items' do
+          expect(subject.logger).to receive(:debug2).with(/unmanaged_2.*internal exclusion match/i)
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_1/)
+        end
+      end
+    end
+
+    describe '#purge!' do
+      let(:exclusions) { [] }
+      let(:whitelist) { [] }
+      let(:purge_opts) { { recurse: recurse, whitelist: whitelist } }
+
+      it 'does nothing when there is no stale_contents' do
+        allow(subject).to receive(:stale_contents).and_return([])
+
+        expect(FileUtils).to_not receive(:rm_rf)
+
+        subject.purge!(purge_opts)
+      end
+
+      it 'recursively deletes all stale_contents' do
+        subject.stale_contents(recurse, exclusions, whitelist).each do |stale|
+          expect(FileUtils).to receive(:rm_r).with(stale, hash_including(secure: true))
+        end
+
+        subject.purge!(purge_opts)
+      end
+    end
+  end
+
+  context 'with recurse option' do
+    let(:recurse) { true }
+
+    describe '#current_contents' do
+      it 'collects contents of all managed directories recursively' do
+        expect(subject.current_contents(recurse)).to contain_exactly(/\/expected_1/, /\/expected_2/, /\/unmanaged_1/, /\/unmanaged_2/, /\/managed_subdir_1/, /\/subdir_expected_1/, /\/subdir_unmanaged_1/)
+      end
+    end
+
+    describe '#pending_contents' do
+      it 'collects desired_contents that do not yet exist recursively' do
+        expect(subject.pending_contents(recurse)).to include(/\/new_1/, /\/new_2/, /\/subdir_new_1/)
+      end
+    end
+
+    describe '#stale_contents' do
+      context 'with no whitelist or exclusions' do
+        let(:exclusions) { [] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist recursively' do
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_1/, /\/unmanaged_2/, /\/subdir_unmanaged_1/)
+        end
+      end
+
+      context 'with whitelisted items' do
+        let(:exclusions) { [] }
+        let(:whitelist) { ['**/unmanaged_1'] }
+
+        it 'collects current_contents that should not exist except whitelisted items' do
+          expect(subject.logger).to receive(:debug).with(/unmanaged_1.*whitelist match/i)
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_2/, /\/subdir_unmanaged_1/)
+        end
+      end
+
+      context 'with excluded items' do
+        let(:exclusions) { ['**/unmanaged_2'] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist except excluded items' do
+          expect(subject.logger).to receive(:debug2).with(/unmanaged_2.*internal exclusion match/i)
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_1/, /\/subdir_unmanaged_1/)
+        end
+      end
+    end
+
+    describe '#purge!' do
+      let(:exclusions) { [] }
+      let(:whitelist) { [] }
+      let(:purge_opts) { { recurse: recurse, whitelist: whitelist } }
+
+      it 'does nothing when there is no stale_contents' do
+        allow(subject).to receive(:stale_contents).and_return([])
+
+        expect(FileUtils).to_not receive(:rm_r)
+
+        subject.purge!(purge_opts)
+      end
+
+      it 'recursively deletes all stale_contents' do
+        subject.stale_contents(recurse, exclusions, whitelist).each do |stale|
+          expect(FileUtils).to receive(:rm_r).with(stale, hash_including(secure: true))
+        end
+
+        subject.purge!(purge_opts)
+      end
+    end
+  end
+
+  describe "user whitelist functionality" do
+    context "non-recursive whitelist glob" do
+      let(:whitelist) { managed_directories.collect { |dir| File.join(dir, "*unmanaged*") } }
+      let(:purge_opts) { { recurse: true, whitelist: whitelist } }
+
+      describe '#purge!' do
+        it 'does not purge items matching glob at root level' do
+          allow(FileUtils).to receive(:rm_r)
+          expect(FileUtils).to_not receive(:rm_r).with(/\/unmanaged_[12]/, anything)
+          expect(subject.logger).to receive(:debug).with(/whitelist match/i).at_least(:once)
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+
+    context "recursive whitelist glob" do
+      let(:whitelist) { managed_directories.collect { |dir| File.join(dir, "**", "*unmanaged*") } }
+      let(:purge_opts) { { recurse: true, whitelist: whitelist } }
+
+      describe '#purge!' do
+        it 'does not purge items matching glob at any level' do
+          expect(FileUtils).to_not receive(:rm_r)
+          expect(subject.logger).to receive(:debug).with(/whitelist match/i).at_least(:once)
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+  end
+
+  describe "internal exclusions functionality" do
+    let(:purge_opts) { { recurse: true, whitelist: [] } }
+    let(:exclusions) { [ File.join('**', 'unmanaged_1') ] }
+
+    context "when class implements #purge_exclusions" do
+      describe '#purge!' do
+        it 'does not purge items matching exclusion glob' do
+          expect(subject).to receive(:purge_exclusions).and_return(exclusions)
+
+          allow(FileUtils).to receive(:rm_r)
+          expect(FileUtils).to_not receive(:rm_r).with(/\/unmanaged_1/, anything)
+          expect(subject.logger).to receive(:debug2).with(/unmanaged_1.*internal exclusion match/i)
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+
+    context "when class does not implement #purge_exclusions" do
+      describe '#purge!' do
+        it 'purges normally' do
+          expect(FileUtils).to receive(:rm_r).at_least(3).times
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/setopts_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'r10k/util/setopts'
+
+describe R10K::Util::Setopts do
+  let(:klass) do
+    Class.new do
+      include R10K::Util::Setopts
+
+      attr_reader :valid, :alsovalid, :truthyvalid
+
+      def initialize(opts = {})
+        setopts(opts, {
+          :valid => :self, :alsovalid => :self, :truthyvalid => true,
+          :validalias => :valid,
+          :ignoreme => nil
+        })
+      end
+    end
+  end
+
+  it "can handle an empty hash of options" do
+    o = klass.new()
+    expect(o.valid).to be_nil
+    expect(o.alsovalid).to be_nil
+  end
+
+  it "can handle a single valid option" do
+    o = klass.new(:valid => 'yep')
+    expect(o.valid).to eq 'yep'
+    expect(o.alsovalid).to be_nil
+  end
+
+  it "can handle multiple valid options" do
+    o = klass.new(:valid => 'yep', :alsovalid => 'yarp')
+    expect(o.valid).to eq 'yep'
+    expect(o.alsovalid).to eq 'yarp'
+  end
+
+  it "can handle options marked with TrueClass" do
+    o = klass.new(:truthyvalid => 'so truthy')
+    expect(o.truthyvalid).to eq 'so truthy'
+  end
+
+  it "can handle aliases marked with :self" do
+    o = klass.new(:validalias => 'yuuup')
+    expect(o.valid).to eq 'yuuup'
+  end
+
+
+  it "raises an error when given an unhandled option" do
+    expect {
+      klass.new(:valid => 'yep', :notvalid => 'newp')
+    }.to raise_error(ArgumentError, /cannot handle option 'notvalid'/)
+  end
+
+  it "ignores values that are marked as unhandled" do
+    klass.new(:ignoreme => "IGNORE ME!")
+  end
+end

data/spec/unit/util/subprocess/result_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'r10k/util/subprocess'
+
+describe R10K::Util::Subprocess::Result do
+  describe "formatting" do
+    it "includes the exit code" do
+      result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
+      expect(result.format).to match(%r[Exit code: 42])
+    end
+
+    describe "stdout" do
+      it "is omitted when empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
+        expect(result.format).to_not match(%r[Stdout])
+      end
+      it "is included when non-empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], 'stuff here', '', 42)
+        expect(result.format).to match(%r[Stdout:])
+        expect(result.format).to match(%r[stuff here])
+      end
+    end
+
+    describe "stderr" do
+      it "is omitted when empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
+        expect(result.format).to_not match(%r[Stderr])
+      end
+
+      it "is included when non-empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], '', 'other stuff', 42)
+        expect(result.format).to match(%r[Stderr:])
+        expect(result.format).to match(%r[other stuff])
+      end
+    end
+  end
+end

data/spec/unit/util/subprocess/runner/posix_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'r10k/util/subprocess/runner'
+
+describe R10K::Util::Subprocess::Runner::POSIX, :if => R10K::Util::Platform.posix? do
+  fixture_root = File.expand_path('spec/fixtures/unit/util/subprocess/runner', PROJECT_ROOT)
+  it_behaves_like 'a subprocess runner', fixture_root
+end