r10k 3.9.0 → 3.10.0

data/spec/unit/module_spec.rb

@@ -30,12 +30,12 @@ describe R10K::Module do
     [ 'bar/quux',
       'bar-quux',
     ].each do |scenario|
-      it "accepts a name matching #{scenario} and args nil" do
-        obj = R10K::Module.new(scenario, '/modulepath', nil)
+      it "accepts a name matching #{scenario} and version nil" do
+        obj = R10K::Module.new(scenario, '/modulepath', { version: nil })
         expect(obj).to be_a_kind_of(R10K::Module::Forge)
       end
     end
-    [ '8.0.0',
+    [ {version: '8.0.0'},
       {type: 'forge', version: '8.0.0'},
     ].each do |scenario|
       it "accepts a name matching bar-quux and args #{scenario.inspect}" do
@@ -65,7 +65,7 @@ describe R10K::Module do
       end
 
       it 'sets the expected version to what is found in the metadata' do
-        obj = R10K::Module.new(@title, @dirname, nil)
+        obj = R10K::Module.new(@title, @dirname, {version: nil})
         expect(obj.send(:instance_variable_get, :'@expected_version')).to eq('1.2.0')
       end
     end
@@ -73,7 +73,24 @@ describe R10K::Module do
 
   it "raises an error if delegation fails" do
     expect {
-      R10K::Module.new('bar!quux', '/modulepath', ["NOPE NOPE NOPE NOPE!"])
+      R10K::Module.new('bar!quux', '/modulepath', {version: ["NOPE NOPE NOPE NOPE!"]})
     }.to raise_error RuntimeError, /doesn't have an implementation/
   end
+
+  describe 'when a user passes a `default_branch_override`' do
+    [ ['name', {git: 'git url'}],
+      ['name', {type: 'git', source: 'git url'}],
+      ['name', {svn: 'svn url'}],
+      ['name', {type: 'svn', source: 'svn url'}],
+      ['namespace-name', {version: '8.0.0'}],
+      ['namespace-name', {type: 'forge', version: '8.0.0'}]
+    ].each do |(name, options)|
+      it 'can handle the default_branch_override option' do
+        expect {
+          obj = R10K::Module.new(name, '/modulepath', options.merge({default_branch_override: 'foo'}))
+          expect(obj).to be_a_kind_of(R10K::Module::Base)
+        }.not_to raise_error
+      end
+    end
+  end
 end

data/spec/unit/puppetfile_spec.rb

@@ -6,9 +6,7 @@ describe R10K::Puppetfile do
   subject do
     described_class.new(
       '/some/nonexistent/basedir',
-      nil,
-      nil,
-      'Puppetfile.r10k'
+      {puppetfile_name: 'Puppetfile.r10k'}
     )
   end
 
@@ -23,9 +21,25 @@ end
 describe R10K::Puppetfile do
 
   subject do
-    described_class.new(
-      '/some/nonexistent/basedir'
-    )
+    described_class.new( '/some/nonexistent/basedir', {})
+  end
+
+  describe "backwards compatibility with older calling conventions" do
+    it "honors all arguments correctly" do
+      puppetfile = described_class.new('/some/nonexistant/basedir', '/some/nonexistant/basedir/site-modules', nil, 'Pupupupetfile', true)
+      expect(puppetfile.force).to eq(true)
+      expect(puppetfile.moduledir).to eq('/some/nonexistant/basedir/site-modules')
+      expect(puppetfile.puppetfile_path).to eq('/some/nonexistant/basedir/Pupupupetfile')
+      expect(puppetfile.overrides).to eq({})
+    end
+
+    it "handles defaults correctly" do
+      puppetfile = described_class.new('/some/nonexistant/basedir', nil, nil, nil)
+      expect(puppetfile.force).to eq(false)
+      expect(puppetfile.moduledir).to eq('/some/nonexistant/basedir/modules')
+      expect(puppetfile.puppetfile_path).to eq('/some/nonexistant/basedir/Puppetfile')
+      expect(puppetfile.overrides).to eq({})
+    end
   end
 
   describe "the default moduledir" do
@@ -53,230 +67,136 @@ 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' }
+  describe "loading a Puppetfile" do
+    context 'using load' do
+      it "returns the loaded content" do
+        path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+        subject = described_class.new(path, {})
 
-      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, module_opts, anything).and_call_original
+        loaded_content = subject.load
+        expect(loaded_content).to be_an_instance_of(Hash)
 
-      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',
-      }
+        has_some_data = loaded_content.values.none?(&:empty?)
+        expect(has_some_data).to be true
+      end
 
-      allow(R10K::Module).to receive(:new).with('puppet/test_module', File.join(subject.basedir, 'vendor'), module_opts, anything).and_call_original
+      it "is idempotent" do
+        path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+        subject = described_class.new(path, {})
 
-      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
+        expect(subject.loader).to receive(:load).and_call_original.once
 
-    it "should disable and not add modules that conflict with the environment" do
-      env = instance_double('R10K::Environment::Base')
-      mod = instance_double('R10K::Module::Base', name: 'conflict', origin: :puppetfile)
-      allow(mod).to receive(:origin=).and_return(nil)
-      allow(subject).to receive(:environment).and_return(env)
-      allow(env).to receive(:'module_conflicts?').with(mod).and_return(true)
+        loaded_content1 = subject.load
+        expect(subject.loaded?).to be true
+        loaded_content2 = subject.load
 
-      allow(R10K::Module).to receive(:new).with('test', anything, anything, anything).and_return(mod)
-      expect { subject.add_module('test', {}) }.not_to change { subject.modules }
-    end
-  end
-
-  describe "#purge_exclusions" do
-    let(:managed_dirs) { ['dir1', 'dir2'] }
+        expect(loaded_content2).to eq(loaded_content1)
+      end
 
-    before(:each) do
-      allow(subject).to receive(:managed_directories).and_return(managed_dirs)
+      it "returns nil if Puppetfile doesn't exist" do
+        path = '/rando/path/that/wont/exist'
+        subject = described_class.new(path, {})
+        expect(subject.load).to eq nil
+      end
     end
 
-    it "includes managed_directories" do
-      expect(subject.purge_exclusions).to match_array(managed_dirs)
-    end
+    context 'using load!' do
+      it "returns the loaded content" do
+        path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+        subject = described_class.new(path, {})
 
-    context "when belonging to an environment" do
-      let(:env_contents) { ['env1', 'env2' ] }
+        loaded_content = subject.load!
+        expect(loaded_content).to be_an_instance_of(Hash)
 
-      before(:each) do
-        mock_env = double(:environment, desired_contents: env_contents)
-        allow(subject).to receive(:environment).and_return(mock_env)
+        has_some_data = loaded_content.values.none?(&:empty?)
+        expect(has_some_data).to be true
       end
 
-      it "includes environment's desired_contents" do
-        expect(subject.purge_exclusions).to match_array(managed_dirs + env_contents)
+      it "raises if Puppetfile doesn't exist" do
+        path = '/rando/path/that/wont/exist'
+        subject = described_class.new(path, {})
+        expect {
+          subject.load!
+        }.to raise_error(/No such file or directory.*\/rando\/path\/.*/)
       end
     end
   end
 
-  describe '#managed_directories' do
-    it 'returns an array of paths that can be purged' do
-      allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, '1.2.3', anything).and_call_original
+  describe 'default_branch_override' do
+    it 'is passed correctly to module loader init' do
+      # This path doesn't matter so long as it has a Puppetfile within it
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+      subject = described_class.new(path, {overrides: {environments: {default_branch_override: 'foo'}}})
 
-      subject.add_module('puppet/test_module', '1.2.3')
-      expect(subject.managed_directories).to match_array(["/some/nonexistent/basedir/modules"])
-    end
+      repo = instance_double('R10K::Git::StatefulRepository')
+      allow(repo).to receive(:resolve).with('foo').and_return(true)
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
 
-    context 'with a module with install_path == \'\'' do
-      it 'basedir isn\'t in the list of paths to purge' do
-        module_opts = { install_path: '', git: 'git@example.com:puppet/test_module.git' }
+      allow(subject.loader).to receive(:puppetfile_content).and_return <<-EOPF
+        # Track control branch and fall-back to main if no matching branch.
+        mod 'hieradata',
+          :git => 'git@git.example.com:organization/hieradata.git',
+          :branch => :control_branch,
+          :default_branch => 'main'
+        EOPF
 
-        allow(R10K::Module).to receive(:new).with('puppet/test_module', subject.basedir, module_opts, anything).and_call_original
+      expect(subject.logger).not_to receive(:warn).
+        with(/Mismatch between passed and initialized.*preferring passed value/)
 
-        subject.add_module('puppet/test_module', module_opts)
-        expect(subject.managed_directories).to be_empty
-      end
-    end
-  end
+      subject.load
 
-  describe "evaluating a Puppetfile" do
-    def expect_wrapped_error(orig, pf_path, wrapped_error)
-      expect(orig).to be_a_kind_of(R10K::Error)
-      expect(orig.message).to eq("Failed to evaluate #{pf_path}")
-      expect(orig.original).to be_a_kind_of(wrapped_error)
+      loaded_module = subject.modules.first
+      expect(loaded_module.version).to eq('foo')
     end
 
-    it "wraps and re-raises syntax errors" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'invalid-syntax')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      expect {
-        subject.load!
-      }.to raise_error do |e|
-        expect_wrapped_error(e, pf_path, SyntaxError)
-      end
-    end
+    it 'overrides module loader init if needed' do
+      # This path doesn't matter so long as it has a Puppetfile within it
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'valid-forge-with-version')
+      subject = described_class.new(path, {overrides: {environments: {default_branch_override: 'foo'}}})
 
-    it "wraps and re-raises load errors" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'load-error')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      expect {
-        subject.load!
-      }.to raise_error do |e|
-        expect_wrapped_error(e, pf_path, LoadError)
-      end
-    end
+      repo = instance_double('R10K::Git::StatefulRepository')
+      allow(repo).to receive(:resolve).with('bar').and_return(true)
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
 
-    it "wraps and re-raises argument errors" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'argument-error')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      expect {
-        subject.load!
-      }.to raise_error do |e|
-        expect_wrapped_error(e, pf_path, ArgumentError)
-      end
-    end
+      allow(subject.loader).to receive(:puppetfile_content).and_return <<-EOPF
+        # Track control branch and fall-back to main if no matching branch.
+        mod 'hieradata',
+          :git => 'git@git.example.com:organization/hieradata.git',
+          :branch => :control_branch,
+          :default_branch => 'main'
+        EOPF
 
-    it "rejects Puppetfiles with duplicate module names" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'duplicate-module-error')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      expect {
-        subject.load!
-      }.to raise_error(R10K::Error, /Puppetfiles cannot contain duplicate module names/i)
-    end
+      expect(subject.logger).to receive(:warn).
+        with(/Mismatch between passed and initialized.*preferring passed value/)
 
-    it "wraps and re-raises name errors" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'name-error')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      expect {
-        subject.load!
-      }.to raise_error do |e|
-        expect_wrapped_error(e, pf_path, NameError)
-      end
+      subject.load('bar')
+      loaded_module = subject.modules.first
+      expect(loaded_module.version).to eq('bar')
     end
 
-    it "accepts a forge module with a version" do
+    it 'does not warn if passed and initialized default_branch_overrides match' do
+      # This path doesn't matter so long as it has a Puppetfile within it
       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
+      subject = described_class.new(path, {overrides: {environments: {default_branch_override: 'foo'}}})
 
-    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
+      repo = instance_double('R10K::Git::StatefulRepository')
+      allow(repo).to receive(:resolve).with('foo').and_return(true)
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
 
-    it "creates a git module and applies the default branch sepcified in the Puppetfile" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'default-branch-override')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      expect { subject.load! }.not_to raise_error
-      git_module = subject.modules[0]
-      expect(git_module.default_ref).to eq 'here_lies_the_default_branch'
-    end
+      allow(subject.loader).to receive(:puppetfile_content).and_return <<-EOPF
+        # Track control branch and fall-back to main if no matching branch.
+        mod 'hieradata',
+          :git => 'git@git.example.com:organization/hieradata.git',
+          :branch => :control_branch,
+          :default_branch => 'main'
+        EOPF
+
+      expect(subject.logger).not_to receive(:warn).
+        with(/Mismatch between passed and initialized.*preferring passed value/)
 
-    it "creates a git module and applies the provided default_branch_override" do
-      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'default-branch-override')
-      pf_path = File.join(path, 'Puppetfile')
-      subject = described_class.new(path)
-      default_branch_override = 'default_branch_override_name'
-      expect { subject.load!(default_branch_override) }.not_to raise_error
-      git_module = subject.modules[0]
-      expect(git_module.default_override_ref).to eq default_branch_override
-      expect(git_module.default_ref).to eq "here_lies_the_default_branch"
+      subject.load('foo')
+      loaded_module = subject.modules.first
+      expect(loaded_module.version).to eq('foo')
     end
   end
 
@@ -287,7 +207,7 @@ describe R10K::Puppetfile do
       subject.accept(visitor)
     end
 
-    it "passes the visitor to each module if the visitor yields" do
+    it "synchronizes each module if the visitor yields" do
       visitor = spy('visitor')
       expect(visitor).to receive(:visit) do |type, other, &block|
         expect(type).to eq :puppetfile
@@ -297,8 +217,8 @@ describe R10K::Puppetfile do
 
       mod1 = instance_double('R10K::Module::Base', :cachedir => :none)
       mod2 = instance_double('R10K::Module::Base', :cachedir => :none)
-      expect(mod1).to receive(:accept).with(visitor)
-      expect(mod2).to receive(:accept).with(visitor)
+      expect(mod1).to receive(:sync)
+      expect(mod2).to receive(:sync)
       expect(subject).to receive(:modules).and_return([mod1, mod2])
 
       subject.accept(visitor)
@@ -318,8 +238,8 @@ describe R10K::Puppetfile do
 
       mod1 = instance_double('R10K::Module::Base', :cachedir => :none)
       mod2 = instance_double('R10K::Module::Base', :cachedir => :none)
-      expect(mod1).to receive(:accept).with(visitor)
-      expect(mod2).to receive(:accept).with(visitor)
+      expect(mod1).to receive(:sync)
+      expect(mod2).to receive(:sync)
       expect(subject).to receive(:modules).and_return([mod1, mod2])
 
       expect(Thread).to receive(:new).exactly(pool_size).and_call_original
@@ -343,9 +263,9 @@ describe R10K::Puppetfile do
       m5 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/D')
       m6 = instance_double('R10K::Module::Base', :cachedir => '/dev/null/D')
 
-      expect(subject).to receive(:modules).and_return([m1, m2, m3, m4, m5, m6])
+      modules = [m1, m2, m3, m4, m5, m6]
 
-      queue = subject.modules_queue(visitor)
+      queue = R10K::ContentSynchronizer.modules_visit_queue(modules, visitor, subject)
       expect(queue.length).to be 4
       queue_array = 4.times.map { queue.pop }
       expect(queue_array).to match_array([[m1], [m2], [m3, m4], [m5, m6]])