r10k 3.9.0 → 3.10.0

data/spec/unit/action/runner_spec.rb

@@ -218,42 +218,66 @@ describe R10K::Action::Runner do
   end
 
   describe "configuration authorization" do
-    context "when license is not present" do
-      before(:each) do
-        expect(R10K::Util::License).to receive(:load).and_return(nil)
+    context "settings auth" do
+      it "sets the configured token as the forge authorization header" do
+        options = { config: "spec/fixtures/unit/action/r10k_forge_auth.yaml" }
+        runner = described_class.new(options, %w[args yes], action_class)
+
+        expect(PuppetForge).to receive(:host=).with('http://private-forge.com')
+        expect(PuppetForge::Connection).to receive(:authorization=).with('faketoken')
+        expect(PuppetForge::Connection).to receive(:authorization).and_return('faketoken')
+        expect(R10K::Util::License).not_to receive(:load)
+        runner.setup_settings
+        runner.setup_authorization
       end
 
-      it "does not set authorization header on connection class" do
-        expect(PuppetForge::Connection).not_to receive(:authorization=)
-        runner.setup_authorization
+      it 'errors if no custom forge URL is set' do
+        options = { config: "spec/fixtures/unit/action/r10k_forge_auth_no_url.yaml" }
+        runner = described_class.new(options, %w[args yes], action_class)
+        expect(PuppetForge::Connection).not_to receive(:authorization=).with('faketoken')
+
+        expect { runner.setup_settings }.to raise_error(R10K::Error, /Cannot specify a Forge auth/)
       end
     end
 
-    context "when license is present but invalid" do
-      before(:each) do
-        expect(R10K::Util::License).to receive(:load).and_raise(R10K::Error.new('invalid license'))
-      end
+    context "license auth" do
+      context "when license is not present" do
+        before(:each) do
+          expect(R10K::Util::License).to receive(:load).and_return(nil)
+        end
 
-      it "issues warning to logger" do
-        expect(runner.logger).to receive(:warn).with(/invalid license/)
-        runner.setup_authorization
+        it "does not set authorization header on connection class" do
+          expect(PuppetForge::Connection).not_to receive(:authorization=)
+          runner.setup_authorization
+        end
       end
 
-      it "does not set authorization header on connection class" do
-        expect(PuppetForge::Connection).not_to receive(:authorization=)
-        runner.setup_authorization
-      end
-    end
+      context "when license is present but invalid" do
+        before(:each) do
+          expect(R10K::Util::License).to receive(:load).and_raise(R10K::Error.new('invalid license'))
+        end
 
-    context "when license is present and valid" do
-      before(:each) do
-        mock_license = double('pe-license', :authorization_token => 'test token')
-        expect(R10K::Util::License).to receive(:load).and_return(mock_license)
+        it "issues warning to logger" do
+          expect(runner.logger).to receive(:warn).with(/invalid license/)
+          runner.setup_authorization
+        end
+
+        it "does not set authorization header on connection class" do
+          expect(PuppetForge::Connection).not_to receive(:authorization=)
+          runner.setup_authorization
+        end
       end
 
-      it "sets authorization header on connection class" do
-        expect(PuppetForge::Connection).to receive(:authorization=).with('test token')
-        runner.setup_authorization
+      context "when license is present and valid" do
+        before(:each) do
+          mock_license = double('pe-license', :authorization_token => 'test token')
+          expect(R10K::Util::License).to receive(:load).and_return(mock_license)
+        end
+
+        it "sets authorization header on connection class" do
+          expect(PuppetForge::Connection).to receive(:authorization=).with('test token')
+          runner.setup_authorization
+        end
       end
     end
   end

data/spec/unit/git/cache_spec.rb

@@ -62,4 +62,18 @@ describe R10K::Git::Cache do
       subject.cached?
     end
   end
+
+  describe "dirname sanitization" do
+    it 'sanitizes cache directory name' do
+      expect(subject.sanitized_dirname).to eq('git---some-git-remote')
+    end
+
+    context 'with username and password' do
+      subject { subclass.new('https://"user:pa$$w0rd:@some/git/remote') }
+
+      it 'sanitizes cache directory name' do
+        expect(subject.sanitized_dirname).to eq('https---some-git-remote')
+      end
+    end
+  end
 end

data/spec/unit/module/forge_spec.rb

@@ -11,15 +11,15 @@ describe R10K::Module::Forge do
 
   describe "implementing the Puppetfile spec" do
     it "should implement 'branan/eight_hundred', '8.0.0'" do
-      expect(described_class).to be_implement('branan/eight_hundred', '8.0.0')
+      expect(described_class).to be_implement('branan/eight_hundred', { version: '8.0.0' })
     end
 
     it "should implement 'branan-eight_hundred', '8.0.0'" do
-      expect(described_class).to be_implement('branan-eight_hundred', '8.0.0')
+      expect(described_class).to be_implement('branan-eight_hundred', { version: '8.0.0' })
     end
 
     it "should fail with an invalid title" do
-      expect(described_class).to_not be_implement('branan!eight_hundred', '8.0.0')
+      expect(described_class).to_not be_implement('branan!eight_hundred', { version: '8.0.0' })
     end
   end
 
@@ -30,7 +30,7 @@ describe R10K::Module::Forge do
   end
 
   describe "setting attributes" do
-    subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
+    subject { described_class.new('branan/eight_hundred', '/moduledir', { version: '8.0.0' }) }
 
     it "sets the name" do
       expect(subject.name).to eq 'eight_hundred'
@@ -50,7 +50,7 @@ describe R10K::Module::Forge do
   end
 
   describe "properties" do
-    subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
 
     it "sets the module type to :forge" do
       expect(subject.properties).to include(:type => :forge)
@@ -67,7 +67,7 @@ describe R10K::Module::Forge do
   end
 
   context "when a module is deprecated" do
-    subject { described_class.new('puppetlabs/corosync', fixture_modulepath, :latest) }
+    subject { described_class.new('puppetlabs/corosync', fixture_modulepath, { version: :latest }) }
 
     it "warns on sync if module is not already insync" do
       allow(subject).to receive(:status).and_return(:absent)
@@ -77,6 +77,7 @@ describe R10K::Module::Forge do
       logger_dbl = double(Log4r::Logger)
       allow_any_instance_of(described_class).to receive(:logger).and_return(logger_dbl)
 
+      allow(logger_dbl).to receive(:info).with(/Deploying module to.*/)
       expect(logger_dbl).to receive(:warn).with(/puppet forge module.*puppetlabs-corosync.*has been deprecated/i)
 
       subject.sync
@@ -88,6 +89,7 @@ describe R10K::Module::Forge do
       logger_dbl = double(Log4r::Logger)
       allow_any_instance_of(described_class).to receive(:logger).and_return(logger_dbl)
 
+      allow(logger_dbl).to receive(:info).with(/Deploying module to.*/)
       expect(logger_dbl).to_not receive(:warn).with(/puppet forge module.*puppetlabs-corosync.*has been deprecated/i)
 
       subject.sync
@@ -96,20 +98,27 @@ describe R10K::Module::Forge do
 
   describe '#expected_version' do
     it "returns an explicitly given expected version" do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0')
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
       expect(subject.expected_version).to eq '8.0.0'
     end
 
     it "uses the latest version from the forge when the version is :latest" do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, :latest)
-      expect(subject.v3_module).to receive_message_chain(:current_release, :version).and_return('8.8.8')
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: :latest })
+      release = double("Module Release", version: '8.8.8')
+      expect(subject.v3_module).to receive(:current_release).and_return(release).twice
       expect(subject.expected_version).to eq '8.8.8'
     end
+
+    it "throws when there are no available versions" do
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: :latest })
+      expect(subject.v3_module).to receive(:current_release).and_return(nil)
+      expect { subject.expected_version }.to raise_error(PuppetForge::ReleaseNotFound)
+    end
   end
 
   describe "determining the status" do
 
-    subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
 
     it "is :absent if the module directory is absent" do
       allow(subject).to receive(:exist?).and_return false
@@ -154,7 +163,7 @@ describe R10K::Module::Forge do
   end
 
   describe "#sync" do
-    subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
 
     it 'does nothing when the module is in sync' do
       allow(subject).to receive(:status).and_return :insync
@@ -186,7 +195,7 @@ describe R10K::Module::Forge do
 
   describe '#install' do
     it 'installs the module from the forge' do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0')
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
       release = instance_double('R10K::Forge::ModuleRelease')
       expect(R10K::Forge::ModuleRelease).to receive(:new).with('branan-eight_hundred', '8.0.0').and_return(release)
       expect(release).to receive(:install).with(subject.path)
@@ -196,7 +205,7 @@ describe R10K::Module::Forge do
 
   describe '#uninstall' do
     it 'removes the module path' do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0')
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
       expect(FileUtils).to receive(:rm_rf).with(subject.path.to_s)
       subject.uninstall
     end
@@ -204,7 +213,7 @@ describe R10K::Module::Forge do
 
   describe '#reinstall' do
     it 'uninstalls and then installs the module' do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0')
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
       expect(subject).to receive(:uninstall)
       expect(subject).to receive(:install)
       subject.reinstall

data/spec/unit/module/git_spec.rb

@@ -119,14 +119,6 @@ describe R10K::Module::Git 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, /cannot handle option 'unrecognized'/)
-      end
-    end
-
     describe "desired ref" do
       context "when no desired ref is given" do
         it "defaults to master" do
@@ -210,6 +202,14 @@ describe R10K::Module::Git do
             expect(mod.desired_ref).to eq(:control_branch)
           end
 
+          it "warns control branch may be unresolvable" do
+            logger = double("logger")
+            allow_any_instance_of(described_class).to receive(:logger).and_return(logger)
+            expect(logger).to receive(:warn).with(/Cannot track control repo branch.*boolean.*/)
+
+            test_module(branch: :control_branch)
+          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')

data/spec/unit/module_loader/puppetfile_spec.rb

@@ -0,0 +1,330 @@
+require 'spec_helper'
+require 'r10k/module_loader/puppetfile'
+
+describe R10K::ModuleLoader::Puppetfile do
+  describe 'initial parameters' do
+    describe 'honor' do
+      let(:options) do
+        {
+          basedir: '/test/basedir/env',
+          forge: 'localforge.internal.corp',
+          overrides: { modules: { deploy_modules: true } },
+          environment: R10K::Environment::Git.new('env',
+                                                  '/test/basedir/',
+                                                  'env',
+                                                  { remote: 'git://foo/remote',
+                                                    ref: 'env' })
+        }
+      end
+
+      subject { R10K::ModuleLoader::Puppetfile.new(**options) }
+
+      describe 'the moduledir' do
+        it 'respects absolute paths' do
+          absolute_options = options.merge({moduledir: '/opt/puppetlabs/special/modules'})
+          puppetfile = R10K::ModuleLoader::Puppetfile.new(**absolute_options)
+          expect(puppetfile.instance_variable_get(:@moduledir)).to eq('/opt/puppetlabs/special/modules')
+        end
+
+        it 'roots the moduledir in the basepath if a relative path is specified' do
+          relative_options = options.merge({moduledir: 'my/special/modules'})
+          puppetfile = R10K::ModuleLoader::Puppetfile.new(**relative_options)
+          expect(puppetfile.instance_variable_get(:@moduledir)).to eq('/test/basedir/env/my/special/modules')
+        end
+      end
+
+      describe 'the Puppetfile' do
+        it 'respects absolute paths' do
+          absolute_options = options.merge({puppetfile: '/opt/puppetlabs/special/Puppetfile'})
+          puppetfile = R10K::ModuleLoader::Puppetfile.new(**absolute_options)
+          expect(puppetfile.instance_variable_get(:@puppetfile)).to eq('/opt/puppetlabs/special/Puppetfile')
+        end
+
+        it 'roots the Puppetfile in the basepath if a relative path is specified' do
+          relative_options = options.merge({puppetfile: 'Puppetfile.global'})
+          puppetfile = R10K::ModuleLoader::Puppetfile.new(**relative_options)
+          expect(puppetfile.instance_variable_get(:@puppetfile)).to eq('/test/basedir/env/Puppetfile.global')
+        end
+      end
+
+      it 'the forge' do
+        expect(subject.instance_variable_get(:@forge)).to eq('localforge.internal.corp')
+      end
+
+      it 'the overrides' do
+        expect(subject.instance_variable_get(:@overrides)).to eq({ modules: { deploy_modules: true }})
+      end
+
+      it 'the environment' do
+        expect(subject.instance_variable_get(:@environment).name).to eq('env')
+      end
+    end
+
+    describe 'sane defaults' do
+      subject { R10K::ModuleLoader::Puppetfile.new(basedir: '/test/basedir') }
+
+      it 'has a moduledir rooted in the basedir' do
+        expect(subject.instance_variable_get(:@moduledir)).to eq('/test/basedir/modules')
+      end
+
+      it 'has a Puppetfile rooted in the basedir' do
+        expect(subject.instance_variable_get(:@puppetfile)).to eq('/test/basedir/Puppetfile')
+      end
+
+      it 'uses the public forge' do
+        expect(subject.instance_variable_get(:@forge)).to eq('forgeapi.puppetlabs.com')
+      end
+
+      it 'creates an empty overrides' do
+        expect(subject.instance_variable_get(:@overrides)).to eq({})
+      end
+
+      it 'does not require an environment' do
+        expect(subject.instance_variable_get(:@environment)).to eq(nil)
+      end
+    end
+  end
+
+  describe 'adding modules' do
+    let(:basedir) { '/test/basedir' }
+
+    subject { R10K::ModuleLoader::Puppetfile.new(basedir: basedir) }
+
+    it 'should transform Forge modules with a string arg to have a version key' do
+      expect(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, hash_including(version: '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
+      expect(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, hash_including(version: '< 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' }
+
+      expect(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',
+      }
+
+      expect(R10K::Module).to receive(:new).with('puppet/test_module', File.join(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(basedir, 'vendor')
+
+      module_opts = {
+        install_path: install_path,
+        git: 'git@example.com:puppet/test_module.git',
+      }
+
+      expect(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',
+      }
+
+      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',
+      }
+
+      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 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, 'origin=': nil)
+      loader = R10K::ModuleLoader::Puppetfile.new(basedir: basedir, environment: env)
+      allow(env).to receive(:'module_conflicts?').with(mod).and_return(true)
+
+      expect(R10K::Module).to receive(:new).with('conflict', anything, anything, anything).and_return(mod)
+      expect { loader.add_module('conflict', {}) }.not_to change { loader.modules }
+    end
+  end
+
+  describe '#purge_exclusions' do
+    let(:managed_dirs) { ['dir1', 'dir2'] }
+    subject { R10K::ModuleLoader::Puppetfile.new(basedir: '/test/basedir') }
+
+    it 'includes managed_directories' do
+      expect(subject.send(:determine_purge_exclusions, managed_dirs)).to match_array(managed_dirs)
+    end
+
+    context 'when belonging to an environment' do
+      let(:env_contents) { ['env1', 'env2' ] }
+      let(:env) { double(:environment, desired_contents: env_contents) }
+
+      subject { R10K::ModuleLoader::Puppetfile.new(basedir: '/test/basedir', environment: env) }
+
+      it "includes environment's desired_contents" do
+        expect(subject.send(:determine_purge_exclusions, managed_dirs)).to match_array(managed_dirs + env_contents)
+      end
+    end
+  end
+
+  describe '#managed_directories' do
+
+    let(:basedir) { '/test/basedir' }
+    subject { R10K::ModuleLoader::Puppetfile.new(basedir: basedir) }
+
+    before do
+      allow(subject).to receive(:puppetfile_content).and_return('')
+    end
+
+    it 'returns an array of paths that #purge! will operate within' do
+      expect(R10K::Module).to receive(:new).with('puppet/test_module', subject.moduledir, hash_including(version: '1.2.3'), anything).and_call_original
+      subject.add_module('puppet/test_module', '1.2.3')
+      subject.load
+
+      expect(subject.modules.length).to be 1
+      expect(subject.managed_directories).to match_array([subject.moduledir])
+    end
+
+    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' }
+
+        expect(R10K::Module).to receive(:new).with('puppet/test_module', basedir, module_opts, anything).and_call_original
+        subject.add_module('puppet/test_module', module_opts)
+        subject.load
+
+        expect(subject.modules.length).to be 1
+        expect(subject.managed_directories).to be_empty
+      end
+    end
+  end
+
+  describe 'evaluating a Puppetfile' do
+    def expect_wrapped_error(error, pf_path, error_type)
+      expect(error).to be_a_kind_of(R10K::Error)
+      expect(error.message).to eq("Failed to evaluate #{pf_path}")
+      expect(error.original).to be_a_kind_of(error_type)
+    end
+
+    subject { described_class.new(basedir: @path) }
+
+    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')
+      expect {
+        subject.load
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, SyntaxError)
+      end
+    end
+
+    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')
+      expect {
+        subject.load
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, LoadError)
+      end
+    end
+
+    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')
+      expect {
+        subject.load
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, ArgumentError)
+      end
+    end
+
+    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')
+      expect {
+        subject.load
+      }.to raise_error(R10K::Error, /Puppetfiles cannot contain duplicate module names/i)
+    end
+
+    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')
+      expect {
+        subject.load
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, NameError)
+      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')
+      expect { subject.load }.not_to raise_error
+    end
+
+    describe 'setting a custom moduledir' do
+      it 'allows setting an absolute moduledir' do
+        @path = '/fake/basedir'
+        allow(subject).to receive(:puppetfile_content).and_return('moduledir "/fake/moduledir"')
+        subject.load
+        expect(subject.instance_variable_get(:@moduledir)).to eq('/fake/moduledir')
+      end
+
+      it 'roots relative moduledirs in the basedir' do
+        @path = '/fake/basedir'
+        allow(subject).to receive(:puppetfile_content).and_return('moduledir "my/moduledir"')
+        subject.load
+        expect(subject.instance_variable_get(:@moduledir)).to eq(File.join(@path, 'my/moduledir'))
+      end
+    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')
+      expect { subject.load }.not_to raise_error
+    end
+
+    it 'creates a git module and applies the default branch specified in the Puppetfile' do
+      @path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'default-branch-override')
+      pf_path = File.join(@path, 'Puppetfile')
+      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
+
+    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')
+      default_branch_override = 'default_branch_override_name'
+      subject.default_branch_override = default_branch_override
+      expect { subject.load }.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'
+    end
+  end
+end