r10k 3.11.0 → 3.14.0

data/spec/unit/action/deploy/module_spec.rb

@@ -77,6 +77,11 @@ describe R10K::Action::Deploy::Module do
             basedir: '/some/nonexistent/path/control',
             environments: %w[first second]
           }
+        },
+        overrides: {
+          modules: {
+            pool_size: 4
+          }
         }
       )
     end
@@ -97,28 +102,22 @@ describe R10K::Action::Deploy::Module do
         )
       end
 
-      before do
-        @modules = []
+      it 'generate_types is true' do
+        expect(subject.settings[:overrides][:environments][:generate_types]).to eq(true)
+      end
+
+      it 'only calls puppet generate types on environments where the specified module was updated' do
         allow(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
-          mod = R10K::Module::Local.new(environment.name, '/fakedir', {}, environment)
-          if mod.name == 'first'
+          if environment.name == 'first'
+            expect(environment).to receive(:deploy).and_return(['first'])
             expect(environment).to receive(:generate_types!)
           else
+            expect(environment).to receive(:deploy).and_return([])
             expect(environment).not_to receive(:generate_types!)
           end
-          @modules << mod
-          expect(environment.puppetfile).to receive(:modules).and_return([mod]).twice
           original.call(environment, &block)
         end
-      end
-
-      it 'generate_types is true' do
-        expect(subject.settings[:overrides][:environments][:generate_types]).to eq(true)
-      end
-
-      it 'only calls puppet generate types on environments with specified module' do
         subject.call
-        expect(@modules.length).to be(2)
       end
     end
 
@@ -242,35 +241,33 @@ describe R10K::Action::Deploy::Module do
 
       allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
       allow(R10K::Git).to receive_message_chain(:cache, :generate).and_return(cache)
-      allow_any_instance_of(R10K::Source::Git).to receive(:branch_names).and_return([R10K::Environment::Name.new('first', {})])
+      allow_any_instance_of(R10K::Source::Git).to receive(:environment_names).and_return([R10K::Environment::Name.new('first', {})])
 
       expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
         # For this test we want to have realistic Modules and access to
         # their internal Repos to validate the sync. Unfortunately, to
         # do so we do some invasive mocking, effectively implementing
-        # our own R10K::Puppetfile#load. We directly update the Puppetfile's
-        # internal ModuleLoader and then call `load` on it so it will create
-        # the correct loaded_content.
-        puppetfile = environment.puppetfile
-        loader = puppetfile.loader
-        expect(puppetfile).to receive(:load) do
+        # our own R10K::ModuleLoader::Puppetfile#load. We directly update
+        # the Environment's internal ModuleLoader and then call `load` on
+        # it so it will create the correct loaded_content.
+        loader = environment.loader
+        allow(loader).to receive(:puppetfile_content).and_return('')
+        expect(loader).to receive(:load) do
           loader.add_module('mod1', { git: 'git://remote' })
           loader.add_module('mod2', { git: 'git://remote' })
           loader.add_module('mod3', { git: 'git://remote' })
 
-          allow(loader).to receive(:puppetfile_content).and_return('')
-          loaded_content = loader.load
-          puppetfile.instance_variable_set(:@loaded_content, loaded_content)
-          puppetfile.instance_variable_set(:@loaded, true)
-        end
-
-        puppetfile.modules.each do |mod|
-          if ['mod1', 'mod2'].include?(mod.name)
-            expect(mod.should_sync?).to be(true)
-          else
-            expect(mod.should_sync?).to be(false)
+          loaded_content = loader.load!
+          loaded_content[:modules].each do |mod|
+            if ['mod1', 'mod2'].include?(mod.name)
+              expect(mod.should_sync?).to be(true)
+            else
+              expect(mod.should_sync?).to be(false)
+            end
+            expect(mod).to receive(:sync).and_call_original
           end
-          expect(mod).to receive(:sync).and_call_original
+
+          loaded_content
         end
 
         original.call(environment, &block)
@@ -303,40 +300,39 @@ describe R10K::Action::Deploy::Module do
 
       allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
       allow(R10K::Git).to receive_message_chain(:cache, :generate).and_return(cache)
-      allow_any_instance_of(R10K::Source::Git).to receive(:branch_names).and_return([R10K::Environment::Name.new('first', {}),
+      allow_any_instance_of(R10K::Source::Git).to receive(:environment_names).and_return([R10K::Environment::Name.new('first', {}),
                                                                                      R10K::Environment::Name.new('second', {})])
 
       expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
-        puppetfile = environment.puppetfile
+        loader = environment.loader
 
         if environment.name == 'first'
           # For this test we want to have realistic Modules and access to
           # their internal Repos to validate the sync. Unfortunately, to
           # do so we do some invasive mocking, effectively implementing
-          # our own R10K::Puppetfile#load. We directly update the Puppetfile's
-          # internal ModuleLoader and then call `load` on it so it will create
-          # the correct loaded_content.
-          loader = puppetfile.loader
-          expect(puppetfile).to receive(:load) do
+          # our own R10K::ModuleLoader::Puppetfile#load. We directly update
+          # the Environment's internal ModuleLoader and then call `load` on
+          # it so it will create the correct loaded_content.
+          allow(loader).to receive(:puppetfile_content).and_return('')
+          expect(loader).to receive(:load) do
             loader.add_module('mod1', { git: 'git://remote' })
             loader.add_module('mod2', { git: 'git://remote' })
 
-            allow(loader).to receive(:puppetfile_content).and_return('')
-            loaded_content = loader.load
-            puppetfile.instance_variable_set(:@loaded_content, loaded_content)
-            puppetfile.instance_variable_set(:@loaded, true)
-          end
-
-          puppetfile.modules.each do |mod|
-            if mod.name == 'mod1'
-              expect(mod.should_sync?).to be(true)
-            else
-              expect(mod.should_sync?).to be(false)
+            loaded_content = loader.load!
+            loaded_content[:modules].each do |mod|
+              if mod.name == 'mod1'
+                expect(mod.should_sync?).to be(true)
+              else
+                expect(mod.should_sync?).to be(false)
+              end
+              expect(mod).to receive(:sync).and_call_original
             end
-            expect(mod).to receive(:sync).and_call_original
+
+            loaded_content
           end
+
         else
-          expect(puppetfile).not_to receive(:load)
+          expect(loader).not_to receive(:load)
         end
 
         original.call(environment, &block)
@@ -415,16 +411,13 @@ describe R10K::Action::Deploy::Module do
           allow(mock_subprocess).to receive(:logger=)
           expect(mock_subprocess).to receive(:execute)
 
-          mock_mod = double('mock_mod', name: 'mod1')
-
           expect(R10K::Util::Subprocess).to receive(:new).
             with(["/generate/types/wrapper", "first"]).
             and_return(mock_subprocess)
 
           expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
             if environment.name == 'first'
-              expect(environment).to receive(:deploy).and_return(true)
-              expect(environment).to receive(:modules).and_return([mock_mod])
+              expect(environment).to receive(:deploy).and_return(['first'])
             end
             original.call(environment, &block)
           end.exactly(3).times
@@ -455,12 +448,9 @@ describe R10K::Action::Deploy::Module do
             with(["/generate/types/wrapper", "first third"]).
             and_return(mock_subprocess)
 
-          mock_mod = double('mock_mod', name: 'mod1')
-
           expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
-            expect(environment).to receive(:deploy).and_return(true)
             if ['first', 'third'].include?(environment.name)
-              expect(environment).to receive(:modules).and_return([mock_mod])
+              expect(environment).to receive(:deploy).and_return(['mod1'])
             end
             original.call(environment, &block)
           end.exactly(3).times
@@ -473,9 +463,7 @@ describe R10K::Action::Deploy::Module do
 
           mock_mod2 = double('mock_mod', name: 'mod2')
           expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
-            expect(environment).to receive(:deploy).and_return(true)
-            # Envs have a different module than the one we asked to deploy
-            expect(environment).to receive(:modules).and_return([mock_mod2])
+            expect(environment).to receive(:deploy).and_return([])
             original.call(environment, &block)
           end.exactly(3).times
 

data/spec/unit/action/puppetfile/check_spec.rb

@@ -3,7 +3,7 @@ require 'r10k/action/puppetfile/check'
 
 describe R10K::Action::Puppetfile::Check do
   let(:default_opts) { {root: "/some/nonexistent/path"} }
-  let(:puppetfile) { instance_double('R10K::Puppetfile', :load! => true) }
+  let(:loader) { instance_double('R10K::ModuleLoader::Puppetfile', :load! => {}) }
 
   def checker(opts = {}, argv = [], settings = {})
     opts = default_opts.merge(opts)
@@ -11,7 +11,11 @@ describe R10K::Action::Puppetfile::Check do
   end
 
   before(:each) do
-    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: nil}).and_return(puppetfile)
+    allow(R10K::ModuleLoader::Puppetfile).
+      to receive(:new).
+      with({
+        basedir: "/some/nonexistent/path",
+      }).and_return(loader)
   end
 
   it_behaves_like "a puppetfile action"
@@ -23,8 +27,11 @@ describe R10K::Action::Puppetfile::Check do
   end
 
   it "prints an error message when validating the Puppetfile syntax raised an error" do
-    allow(puppetfile).to receive(:load!).and_raise(R10K::Error.new("Boom!"))
-    allow(R10K::Errors::Formatting).to receive(:format_exception).with(instance_of(R10K::Error), anything).and_return("Formatted error message")
+    allow(loader).to receive(:load!).and_raise(R10K::Error.new("Boom!"))
+    allow(R10K::Errors::Formatting).
+      to receive(:format_exception).
+      with(instance_of(R10K::Error), anything).
+      and_return("Formatted error message")
 
     expect($stderr).to receive(:puts).with("Formatted error message")
 
@@ -34,7 +41,12 @@ describe R10K::Action::Puppetfile::Check do
   it "respects --puppetfile option" do
     allow($stderr).to receive(:puts)
 
-    expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: "/custom/puppetfile/path"}).and_return(puppetfile)
+    expect(R10K::ModuleLoader::Puppetfile).
+      to receive(:new).
+      with({
+        basedir: "/some/nonexistent/path",
+        puppetfile: "/custom/puppetfile/path"
+      }).and_return(loader)
 
     checker({puppetfile: "/custom/puppetfile/path"}).call
   end

data/spec/unit/action/puppetfile/install_spec.rb

@@ -3,9 +3,10 @@ require 'r10k/action/puppetfile/install'
 
 describe R10K::Action::Puppetfile::Install do
   let(:default_opts) { { root: "/some/nonexistent/path" } }
-  let(:puppetfile) {
-    R10K::Puppetfile.new('/some/nonexistent/path',
-                         {:moduledir => nil, :puppetfile_path => nil, :force => false})
+  let(:loader) {
+    R10K::ModuleLoader::Puppetfile.new(
+      basedir: '/some/nonexistent/path',
+      overrides: {force: false})
   }
 
   def installer(opts = {}, argv = [], settings = {})
@@ -14,11 +15,11 @@ describe R10K::Action::Puppetfile::Install do
   end
 
   before(:each) do
-    allow(puppetfile).to receive(:load!).and_return(nil)
-    allow(R10K::Puppetfile).to receive(:new).
-      with("/some/nonexistent/path",
-           {:moduledir => nil, :puppetfile_path => nil, :force => false}).
-      and_return(puppetfile)
+    allow(loader).to receive(:load!).and_return({})
+    allow(R10K::ModuleLoader::Puppetfile).to receive(:new).
+      with({basedir: "/some/nonexistent/path",
+            overrides: {force: false}}).
+      and_return(loader)
   end
 
   it_behaves_like "a puppetfile install action"
@@ -26,13 +27,19 @@ describe R10K::Action::Puppetfile::Install do
   describe "installing modules" do
     let(:modules) do
       (1..4).map do |idx|
-        R10K::Module::Base.new("author/modname#{idx}", "/some/nonexistent/path/modname#{idx}", {})
+        R10K::Module::Base.new("author/modname#{idx}",
+                               "/some/nonexistent/path/modname#{idx}",
+                               {})
       end
     end
 
     before do
-      allow(puppetfile).to receive(:modules).and_return(modules)
-      allow(puppetfile).to receive(:modules_by_vcs_cachedir).and_return({none: modules})
+      allow(loader).to receive(:load!).and_return({
+        modules: modules,
+        managed_directories: [],
+        desired_contents: [],
+        purge_exclusions: []
+      })
     end
 
     it "syncs each module in the Puppetfile" do
@@ -50,15 +57,15 @@ describe R10K::Action::Puppetfile::Install do
   end
 
   describe "purging" do
-    before do
-      allow(puppetfile).to receive(:modules).and_return([])
-    end
-
     it "purges the moduledir after installation" do
+      allow(loader).to receive(:load!).and_return({
+        modules:             [],
+        desired_contents:    [ 'root/foo' ],
+        managed_directories: [ 'root' ],
+        purge_exclusions:    [ 'root/**/**.rb' ]
+      })
+
       mock_cleaner = double("cleaner")
-      allow(puppetfile).to receive(:desired_contents).and_return(["root/foo"])
-      allow(puppetfile).to receive(:managed_directories).and_return(["root"])
-      allow(puppetfile).to receive(:purge_exclusions).and_return(["root/**/**.rb"])
 
       expect(R10K::Util::Cleaner).to receive(:new).
         with(["root"], ["root/foo"], ["root/**/**.rb"]).
@@ -70,35 +77,34 @@ describe R10K::Action::Puppetfile::Install do
   end
 
   describe "using custom paths" do
-    it "can use a custom puppetfile path" do
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path",
-             {:moduledir => nil, :force => false, puppetfile_path: "/some/other/path/Puppetfile"}).
-        and_return(puppetfile)
+    it "can use a custom moduledir path" do
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              overrides: { force: false },
+              puppetfile: "/some/other/path/Puppetfile"}).
+        and_return(loader)
 
       installer({puppetfile: "/some/other/path/Puppetfile"}).call
-    end
 
-    it "can use a custom moduledir path" do
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path",
-             {:puppetfile_path => nil, :force => false, moduledir: "/some/other/path/site-modules"}).
-        and_return(puppetfile)
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              overrides: { force: false },
+              moduledir: "/some/other/path/site-modules"}).
+        and_return(loader)
 
       installer({moduledir: "/some/other/path/site-modules"}).call
     end
   end
 
   describe "forcing to overwrite local changes" do
-    before do
-      allow(puppetfile).to receive(:modules).and_return([])
-    end
-
     it "can use the force overwrite option" do
+      allow(loader).to receive(:load!).and_return({ modules: [] })
+
       subject = described_class.new({root: "/some/nonexistent/path", force: true}, [], {})
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path", {:moduledir => nil, :puppetfile_path => nil, :force => true}).
-        and_return(puppetfile)
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              overrides: { force: true }}).
+        and_return(loader)
       subject.call
     end
 

data/spec/unit/action/puppetfile/purge_spec.rb

@@ -4,11 +4,13 @@ require 'r10k/action/puppetfile/purge'
 describe R10K::Action::Puppetfile::Purge do
   let(:default_opts) { {root: "/some/nonexistent/path"} }
   let(:puppetfile) do
-    instance_double('R10K::Puppetfile',
-                    :load!               => nil,
-                    :managed_directories => %w{foo},
-                    :desired_contents    => %w{bar},
-                    :purge_exclusions    => %w{baz})
+    instance_double('R10K::ModuleLoader::Puppetfile',
+                    :load! => {
+                      :modules             => %w{mod},
+                      :managed_directories => %w{foo},
+                      :desired_contents    => %w{bar},
+                      :purge_exclusions    => %w{baz}
+                    })
   end
 
   def purger(opts = {}, argv = [], settings = {})
@@ -17,8 +19,8 @@ describe R10K::Action::Puppetfile::Purge do
   end
 
   before(:each) do
-    allow(R10K::Puppetfile).to receive(:new).
-      with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: nil}).
+    allow(R10K::ModuleLoader::Puppetfile).to receive(:new).
+      with({basedir: "/some/nonexistent/path"}).
       and_return(puppetfile)
   end
 
@@ -37,23 +39,19 @@ describe R10K::Action::Puppetfile::Purge do
   end
 
   describe "using custom paths" do
-    before(:each) do
-      allow(puppetfile).to receive(:purge!)
-    end
-
     it "can use a custom puppetfile path" do
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path",
-             {moduledir: nil, puppetfile_path: "/some/other/path/Puppetfile"}).
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              puppetfile: "/some/other/path/Puppetfile"}).
         and_return(puppetfile)
 
       purger({puppetfile: "/some/other/path/Puppetfile"}).call
     end
 
     it "can use a custom moduledir path" do
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path",
-             {moduledir: "/some/other/path/site-modules", puppetfile_path: nil}).
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              moduledir: "/some/other/path/site-modules"}).
         and_return(puppetfile)
 
       purger({moduledir: "/some/other/path/site-modules"}).call

data/spec/unit/action/runner_spec.rb

@@ -159,10 +159,61 @@ describe R10K::Action::Runner do
   end
 
   describe "configuring logging" do
+    before(:each) do
+      R10K::Logging.outputters.clear
+    end
+
     it "sets the log level if :loglevel is provided" do
       runner = described_class.new({:opts => :yep, :loglevel => 'FATAL'}, %w[args yes], action_class)
-      expect(R10K::Logging).to receive(:level=).with('FATAL')
+      # The settings/overrides system causes the level to be set twice
+      expect(R10K::Logging).to receive(:level=).with('FATAL').twice
+      runner.call
+    end
+
+    # The logging fixture tests require a platform with syslog
+    if !R10K::Util::Platform.windows?
+      it "sets the log level if the logging.level setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        expect(R10K::Logging).to receive(:level=).with('FATAL')
+        runner.call
+      end
+
+      it "sets the outputters if logging.outputs is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml' }, %w[args yes], action_class)
+        expect(R10K::Logging).to receive(:add_outputters).with([
+          { type: 'file', parameters: { filename: 'r10k.log' } },
+          { type: 'syslog' }
+        ])
+        runner.call
+      end
+
+      it "disables the default outputter if the logging.disable_default_stderr setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        expect(R10K::Logging).to receive(:disable_default_stderr=).with(true)
+        runner.call
+      end
+
+      it "adds additional log outputs if the logging.outputs setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        runner.call
+        expect(R10K::Logging.outputters).to_not be_empty
+      end
+
+      it "disables the default output if the logging.disable_default_stderr setting is provided" do
+        runner = described_class.new({ opts: :yep, config: 'spec/fixtures/unit/action/r10k_logging.yaml'}, %w[args yes], action_class)
+        runner.call
+        expect(runner.logger.outputters).to satisfy { |outputs| outputs.any? { |output| output.is_a?(R10K::Logging::TerminalOutputter) && output.level == Log4r::OFF } }
+      end
+    end
+
+    it "doesn't add additional log outputs if the logging.outputs setting is not provided" do
+      runner.call
+      expect(R10K::Logging.outputters).to be_empty
+    end
+
+    it "includes the default stderr outputter" do
       runner.call
+      expect(runner.logger.outputters).to satisfy { |outputs| outputs.any? { |output| output.is_a? R10K::Logging::TerminalOutputter } }
     end
 
     it "does not modify the loglevel if :loglevel is not provided" do
@@ -310,14 +361,6 @@ describe R10K::Action::Runner do
         runner.setup_settings
         runner.setup_authorization
       end
-
-      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 "license auth" do

data/spec/unit/environment/bare_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Bare do
+  it "warns on initialization" do
+    logger_spy = spy('logger')
+    allow_any_instance_of(described_class).to receive(:logger).and_return(logger_spy)
+
+    described_class.new('envname', '/basedir', 'dirname', {})
+
+    expect(logger_spy).to have_received(:warn).with(%r{deprecated.*envname})
+  end
+end

data/spec/unit/environment/base_spec.rb

@@ -3,10 +3,13 @@ require 'r10k/environment'
 
 describe R10K::Environment::Base do
 
-  subject(:environment) { described_class.new('envname', '/some/imaginary/path', 'env_name', {}) }
+  let(:basepath) { '/some/imaginary/path' }
+  let(:envname) { 'env_name' }
+  let(:path) { File.join(basepath, envname) }
+  subject(:environment) { described_class.new('envname', basepath, envname, {}) }
 
   it "can return the fully qualified path" do
-    expect(environment.path).to eq(Pathname.new('/some/imaginary/path/env_name'))
+    expect(environment.path).to eq(Pathname.new(path))
   end
 
   it "raises an exception when #sync is called" do
@@ -49,45 +52,55 @@ describe R10K::Environment::Base do
   describe "#purge_exclusions" do
     let(:mock_env) { instance_double("R10K::Environment::Base") }
     let(:mock_puppetfile) { instance_double("R10K::Puppetfile", :environment= => true, :environment => mock_env) }
+    let(:loader) do
+      instance_double("R10K::ModuleLoader::Puppetfile",
+                      :environment= => nil,
+                      :load => { :modules => @modules,
+                                  :managed_directories => @managed_dirs,
+                                  :desired_contents => @desired_contents,
+                                  :purge_exclusions => @purge_ex })
+    end
 
     before(:each) do
-      allow(mock_puppetfile).to receive(:managed_directories).and_return([])
-      allow(mock_puppetfile).to receive(:desired_contents).and_return([])
-      allow(R10K::Puppetfile).to receive(:new).and_return(mock_puppetfile)
+      @modules = []
+      @managed_dirs = []
+      @desired_contents = []
+      @purge_exclusions = []
     end
 
     it "excludes .r10k-deploy.json" do
+      allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+      subject.deploy
+
       expect(subject.purge_exclusions).to include(/r10k-deploy\.json/)
     end
 
     it "excludes puppetfile managed directories" do
-      managed_dirs = [
+      @managed_dirs = [
         '/some/imaginary/path/env_name/modules',
         '/some/imaginary/path/env_name/data',
       ]
 
-      expect(mock_puppetfile).to receive(:managed_directories).and_return(managed_dirs)
+      allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+      subject.deploy
 
       exclusions = subject.purge_exclusions
 
-      managed_dirs.each do |dir|
+      @managed_dirs.each do |dir|
         expect(exclusions).to include(dir)
       end
     end
 
     describe "puppetfile desired contents" do
-      let(:desired_contents) do
-        basedir = subject.path.to_s
-
-        [ 'modules/apache', 'data/local/site' ].collect do |c|
-          File.join(basedir, c)
-        end
-      end
 
       before(:each) do
-        allow(File).to receive(:directory?).with(/^\/some\/imaginary\/path/).and_return(true)
+        @desired_contents = [ 'modules/apache', 'data/local/site' ].collect do |c|
+          File.join(path, c)
+        end
 
-        expect(mock_puppetfile).to receive(:desired_contents).and_return(desired_contents)
+        allow(File).to receive(:directory?).and_return true
+        allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+        subject.deploy
       end
 
       it "excludes desired directory contents with glob" do

data/spec/unit/environment/git_spec.rb

@@ -78,9 +78,9 @@ describe R10K::Environment::Git do
 
   describe "enumerating modules" do
     it "loads the Puppetfile and returns modules in that puppetfile" do
+      loaded = { desired_contents: [], managed_directories: [], purge_exclusions: [] }
       mod = double('A module', :name => 'dbl')
-      expect(subject.puppetfile).to receive(:load)
-      expect(subject.puppetfile).to receive(:modules).and_return [mod]
+      expect(subject.loader).to receive(:load).and_return(loaded.merge(modules: [mod]))
       expect(subject.modules).to eq([mod])
     end
   end