r10k 2.3.1 → 2.4.0

data/spec/unit/git/stateful_repository_spec.rb

@@ -5,38 +5,38 @@ 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('0.9.x', remote, '/some/nonexistent/basedir', 'some-dirname') }
+  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?).to eq true
+      expect(subject.sync_cache?(ref)).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
+      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(: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
+      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(: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
+      expect(subject.sync_cache?(ref)).to eq false
     end
 
   end

data/spec/unit/module/git_spec.rb

@@ -2,6 +2,13 @@ require 'spec_helper'
 require 'r10k/module/git'
 
 describe R10K::Module::Git do
+  let(:mock_repo) do
+    instance_double("R10K::Git::StatefulRepository")
+  end
+
+  before(:each) do
+    allow(R10K::Git::StatefulRepository).to receive(:new).and_return(mock_repo)
+  end
 
   describe "setting the owner and name" do
     describe "with a title of 'branan/eight_hundred'" do
@@ -55,7 +62,12 @@ describe R10K::Module::Git do
 
   describe "properties" do
     subject do
-      described_class.new('boolean', '/moduledir', {:git => 'git://github.com/adrienthebo/puppet-boolean'})
+      described_class.new('boolean', '/moduledir', {:git => 'git://git.example.com/adrienthebo/puppet-boolean'})
+    end
+
+    before(:each) do
+      allow(mock_repo).to receive(:resolve).with('master').and_return('abc123')
+      allow(mock_repo).to receive(:head).and_return('abc123')
     end
 
     it "sets the module type to :git" do
@@ -67,12 +79,12 @@ describe R10K::Module::Git do
     end
 
     it "sets the actual version to the revision when the revision is available" do
-      expect(subject.repo).to receive(:head).and_return('35d3517e67ceeb4b485b56d4a14d38fb95516c92')
+      expect(mock_repo).to receive(:head).and_return('35d3517e67ceeb4b485b56d4a14d38fb95516c92')
       expect(subject.properties).to include(:actual => '35d3517e67ceeb4b485b56d4a14d38fb95516c92')
     end
 
     it "sets the actual version to (unresolvable) when the revision is unavailable" do
-      expect(subject.repo).to receive(:head).and_return(nil)
+      expect(mock_repo).to receive(:head).and_return(nil)
       expect(subject.properties).to include(:actual => '(unresolvable)')
     end
   end
@@ -83,14 +95,153 @@ describe R10K::Module::Git do
         'boolean',
         '/moduledir',
         {
-          :git => 'git://github.com/adrienthebo/puppet-boolean'
+          :git => 'git://git.example.com/adrienthebo/puppet-boolean'
         }
       )
     end
 
     it "delegates to the repo" do
-      expect(subject.repo).to receive(:status).and_return :some_status
+      expect(subject).to receive(:version).and_return 'master'
+      expect(mock_repo).to receive(:status).with('master').and_return :some_status
+
       expect(subject.status).to eq(:some_status)
     end
   end
+
+  describe "option parsing" do
+    def test_module(extra_opts, env=nil)
+      described_class.new('boolean', '/moduledir', base_opts.merge(extra_opts), env)
+    end
+
+    let(:base_opts) { { git: 'git://git.example.com/adrienthebo/puppet-boolean' } }
+
+    before(:each) do
+      allow(mock_repo).to receive(:head).and_return('abc123')
+    end
+
+    context "when option is unrecognized" do
+      let(:opts) { { unrecognized: true } }
+
+      it "raises an error" do
+        expect { test_module(opts) }.to raise_error(ArgumentError, /unhandled options.*unrecognized/i)
+      end
+    end
+
+    describe "desired ref" do
+      context "when no desired ref is given" do
+        it "defaults to master" do
+          expect(mock_repo).to receive(:resolve).with('master').and_return('abc123')
+
+          expect(test_module({}).properties).to include(expected: 'master')
+        end
+      end
+
+      context "specifying a static desired branch" do
+        let(:opts) { { branch: 'banana' } }
+
+        it "sets expected to specified branch name" do
+          expect(mock_repo).to receive(:resolve).with('banana').and_return('def456')
+
+          mod = test_module(opts)
+          expect(mod.properties).to include(expected: 'banana')
+        end
+      end
+
+      context "specifying a static desired tag" do
+        let(:opts) { { tag: '1.2.3' } }
+
+        it "sets expected to specified tag" do
+          expect(mock_repo).to receive(:resolve).with('1.2.3').and_return('def456')
+
+          mod = test_module(opts)
+          expect(mod.properties).to include(expected: '1.2.3')
+        end
+      end
+
+      context "specifying a static desired commit sha" do
+        let(:opts) { { commit: 'ace789' } }
+
+        it "sets expected to specified commit sha" do
+          expect(mock_repo).to receive(:resolve).with('ace789').and_return('ace789')
+
+          mod = test_module(opts)
+          expect(mod.properties).to include(expected: 'ace789')
+        end
+      end
+
+      context "specifying a static desired ref" do
+        before(:each) do
+          expect(mock_repo).to receive(:resolve).and_return('abc123')
+        end
+
+        it "accepts a branch name" do
+          mod = test_module(ref: 'banana')
+          expect(mod.properties).to include(expected: 'banana')
+        end
+
+        it "accepts a tag name" do
+          mod = test_module(ref: '1.2.3')
+          expect(mod.properties).to include(expected: '1.2.3')
+        end
+
+        it "accepts a commit sha" do
+          mod = test_module(ref: 'abc123')
+          expect(mod.properties).to include(expected: 'abc123')
+        end
+      end
+
+      context "specifying branch to :control_branch" do
+        let(:mock_env) { instance_double("R10K::Environment::Git", ref: 'env_branch') }
+
+        context "when module belongs to an environment and matching branch is resolvable" do
+          before(:each) do
+            expect(mock_repo).to receive(:resolve).with(mock_env.ref).and_return('abc123')
+          end
+
+          it "tracks environment branch" do
+            mod = test_module({branch: :control_branch}, mock_env)
+            expect(mod.properties).to include(expected: mock_env.ref)
+          end
+        end
+
+        context "when module does not belong to an environment" do
+          it "raises appropriate error" do
+            expect { test_module(branch: :control_branch) }.to raise_error(ArgumentError, /cannot track control.*environment is nil/i)
+          end
+        end
+
+        context "when module does not have matching branch" do
+          before(:each) do
+            allow(mock_repo).to receive(:resolve).with(mock_env.ref).and_return(nil)
+          end
+
+          context "when default ref is provided and resolvable" do
+            it "uses default ref" do
+              expect(mock_repo).to receive(:resolve).with('default').and_return('abc123')
+              mod = test_module({branch: :control_branch, default_branch: 'default'}, mock_env)
+
+              expect(mod.properties).to include(expected: 'default')
+            end
+          end
+
+          context "when default ref is provided and not resolvable" do
+            it "raises appropriate error" do
+              expect(mock_repo).to receive(:resolve).with('default').and_return(nil)
+              mod = test_module({branch: :control_branch, default_branch: 'default'}, mock_env)
+
+              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve desired.*or default/i)
+            end
+          end
+
+          context "when default ref is not provided" do
+            it "raises appropriate error" do
+              mod = test_module({branch: :control_branch}, mock_env)
+
+              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*no default given/i)
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/unit/module_spec.rb

@@ -11,9 +11,9 @@ describe R10K::Module do
 
   describe 'delegating to R10K::Module::Forge' do
     [
-      ['bar/quux', []],
-      ['bar-quux', []],
-      ['bar/quux', ['8.0.0']],
+      ['bar/quux', nil],
+      ['bar-quux', nil],
+      ['bar/quux', '8.0.0'],
     ].each do |scenario|
       it "accepts a name matching #{scenario[0]} and args #{scenario[1].inspect}" do
         expect(R10K::Module.new(scenario[0], '/modulepath', scenario[1])).to be_a_kind_of(R10K::Module::Forge)

data/spec/unit/puppetfile_spec.rb

@@ -27,6 +27,107 @@ describe R10K::Puppetfile do
     end
   end
 
+  describe "adding modules" do
+    it "should accept Forge modules with a string arg" do
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, '1.2.3', anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', '1.2.3') }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should not accept Forge modules with a version comparison" do
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, '< 1.2.0', anything).and_call_original
+
+      expect {
+        subject.add_module('puppet/test_module', '< 1.2.0')
+      }.to raise_error(RuntimeError, /module puppet\/test_module.*doesn't have an implementation/i)
+
+      expect(subject.modules.collect(&:name)).not_to include('test_module')
+    end
+
+    it "should accept non-Forge modules with a hash arg" do
+      module_opts = { git: 'git@example.com:puppet/test_module.git' }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should accept non-Forge modules with a valid relative :install_path option" do
+      module_opts = {
+        install_path: 'vendor',
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should accept non-Forge modules with a valid absolute :install_path option" do
+      install_path = File.join(subject.basedir, 'vendor')
+
+      module_opts = {
+        install_path: install_path,
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', install_path, module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to change { subject.modules }
+      expect(subject.modules.collect(&:name)).to include('test_module')
+    end
+
+    it "should reject non-Forge modules with an invalid relative :install_path option" do
+      module_opts = {
+        install_path: '../../vendor',
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to raise_error(R10K::Error, /cannot manage content.*is not within/i).and not_change { subject.modules }
+    end
+
+    it "should reject non-Forge modules with an invalid absolute :install_path option" do
+      module_opts = {
+        install_path: '/tmp/mydata/vendor',
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+
+      expect { subject.add_module('puppet/test_module', module_opts) }.to raise_error(R10K::Error, /cannot manage content.*is not within/i).and not_change { subject.modules }
+    end
+  end
+
+  describe "#purge_exclusions" do
+    let(:managed_dirs) { ['dir1', 'dir2'] }
+
+    before(:each) do
+      allow(subject).to receive(:managed_directories).and_return(managed_dirs)
+    end
+
+    it "includes managed_directories" do
+      expect(subject.purge_exclusions).to match_array(managed_dirs)
+    end
+
+    context "when belonging to an environment" do
+      let(:env_contents) { ['env1', 'env2' ] }
+
+      before(:each) do
+        mock_env = double(:environment, desired_contents: env_contents)
+        allow(subject).to receive(:environment).and_return(mock_env)
+      end
+
+      it "includes environment's desired_contents" do
+        expect(subject.purge_exclusions).to match_array(managed_dirs + env_contents)
+      end
+    end
+  end
+
   describe "evaluating a Puppetfile" do
     def expect_wrapped_error(orig, pf_path, wrapped_error)
       expect(orig).to be_a_kind_of(R10K::Error)
@@ -66,6 +167,20 @@ describe R10K::Puppetfile do
         expect_wrapped_error(e, pf_path, ArgumentError)
       end
     end
+
+    it "accepts a forge module with a version" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect { subject.load! }.not_to raise_error
+    end
+
+    it "accepts a forge module without a version" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-without-version')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect { subject.load! }.not_to raise_error
+    end
   end
 
   describe "accepting a visitor" do

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