puppet 5.4.0 → 5.5.0

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 module PuppetSpec
   module ModuleTool
@@ -15,7 +15,7 @@ module PuppetSpec
         moddir = File.join(options[:into], name)
         FileUtils.mkdir_p(moddir)
         File.open(File.join(moddir, 'metadata.json'), 'w') do |file|
-          file.puts(JSON.generate(release.metadata))
+          file.puts(Puppet::Util::Json.dump(release.metadata))
         end
       end
 

data/spec/shared_behaviours/file_server_terminus.rb

@@ -34,8 +34,6 @@ shared_examples_for "Puppet::Indirector::FileServerTerminus" do
     @modules.stubs(:find).returns(nil)
     @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
 
-    path = File.join(@path, "myfile")
-
     expect(@terminus.find(@request)).to be_instance_of(@test_class)
   end
 end

data/spec/shared_behaviours/things_that_declare_options.rb

@@ -87,8 +87,8 @@ shared_examples_for "things that declare options" do
     it "should detect conflicts between #{base.inspect} and #{conflict.inspect}" do
       expect {
         add_options_to do
-          option *base
-          option *conflict
+          option(*base)
+          option(*conflict)
         end
       }.to raise_error ArgumentError, /conflicts with existing option/
     end

data/spec/spec_helper.rb

@@ -27,7 +27,7 @@ require 'rspec/collection_matchers'
 
 # So everyone else doesn't have to include this base constant.
 module PuppetSpec
-  FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
+  FIXTURE_DIR = File.join(File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
 end
 
 require 'pathname'

data/spec/unit/application/cert_spec.rb

@@ -191,9 +191,9 @@ describe Puppet::Application::Cert => true do
       @cert_app.subcommand = :destroy
       @cert_app.command_line.stubs(:args).returns(["unsigned-node"])
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to| cert_mode == :destroy
-        to[:to] == ["unsigned-node"]
-      }
+      Puppet::SSL::CertificateAuthority::Interface.unstub(:new)
+      Puppet::SSL::CertificateAuthority::Interface.expects(:new).with(:revoke, anything).never
+      Puppet::SSL::CertificateAuthority::Interface.expects(:new).with(:destroy, {:to => ['unsigned-node'], :digest => nil}).returns(@iface)
 
       @cert_app.main
     end
@@ -202,17 +202,29 @@ describe Puppet::Application::Cert => true do
       @cert_app.subcommand = :destroy
       @cert_app.command_line.stubs(:args).returns(["host","unsigned-node"])
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to|
-        cert_mode == :revoke
+      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with do |cert_mode,to|
+        cert_mode == :revoke &&
         to[:to] == ["host"]
-      }
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to|
-        cert_mode == :destroy
+      end
+      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with do |cert_mode,to|
+        cert_mode == :destroy &&
         to[:to] == ["host","unsigned-node"]
-      }
+      end
 
       @cert_app.main
     end
+
+    it "should refuse to destroy all certificates" do
+      @cert_app.subcommand = :destroy
+      @cert_app.all = true
+
+      Puppet::SSL::CertificateAuthority::Interface.unstub(:new)
+      Puppet::SSL::CertificateAuthority::Interface.expects(:new).never
+
+      Puppet.expects(:log_exception).with {|e| e.message == "Refusing to destroy all certs, provide an explicit list of certs to destroy"}
+
+      expect { @cert_app.main }.to exit_with(24)
+    end
   end
 
   describe "when identifying subcommands" do

data/spec/unit/application/device_spec.rb

@@ -5,6 +5,7 @@ require 'puppet/application/device'
 require 'puppet/util/network_device/config'
 require 'ostruct'
 require 'puppet/configurer'
+require 'puppet/application/apply'
 
 describe Puppet::Application::Device do
   include PuppetSpec::Files
@@ -127,6 +128,18 @@ describe Puppet::Application::Device do
       expect(@device.args[:Port]).to eq("42")
     end
 
+    it "should store the target options with --target" do
+      @device.options.expects(:[]=).with(:target,'test123')
+
+      @device.handle_target('test123')
+    end
+
+    it "should store the resource options with --resource" do
+      @device.options.expects(:[]=).with(:resource,true)
+
+      @device.handle_resource(true)
+    end
+
   end
 
   describe "during setup" do
@@ -277,7 +290,11 @@ describe Puppet::Application::Device do
       Puppet.stubs(:notice)
       @device.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
       @device.options.stubs(:[]).with(:target).returns(nil)
+      @device.options.stubs(:[]).with(:apply).returns(nil)
+      @device.options.stubs(:[]).with(:resource).returns(false)
+      @device.options.stubs(:[]).with(:to_yaml).returns(false)
       @device.options.stubs(:[]).with(:client)
+      @device.command_line.stubs(:args).returns([])
       Puppet::Util::NetworkDevice::Config.stubs(:devices).returns({})
     end
 
@@ -286,6 +303,12 @@ describe Puppet::Application::Device do
       @device.run_command
     end
 
+    it "should exit if resource is requested without target" do
+      @device.options.stubs(:[]).with(:resource).returns(true)
+      Puppet.expects(:err).with "resource command requires target"
+      expect { @device.main }.to exit_with 1
+    end
+
     it "should get the device list" do
       device_hash = stub_everything 'device hash'
       Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
@@ -301,8 +324,8 @@ describe Puppet::Application::Device do
       }
 
       Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
-      Puppet.expects(:info).with("starting applying configuration to device1 at ssh://testhost")
-      Puppet.expects(:info).with("starting applying configuration to device2 at https://testhost:443/some/path").never
+      URI.expects(:parse).with("ssh://user:pass@testhost")
+      URI.expects(:parse).with("https://user:pass@testhost/some/path").never
       expect { @device.main }.to exit_with 1
     end
 
@@ -318,6 +341,32 @@ describe Puppet::Application::Device do
       expect { @device.main }.to exit_with 1
     end
 
+    it "should error if target is passed and the apply path is incorrect" do
+      @device.options.stubs(:[]).with(:apply).returns('file.pp')
+      @device.options.stubs(:[]).with(:target).returns('device1')
+
+      File.expects(:file?).returns(false)
+      Puppet.expects(:err).with(regexp_matches(/does not exist, cannot apply/))
+      expect { @device.main }.to exit_with 1
+    end
+
+    it "should run an apply" do
+      @device.options.stubs(:[]).with(:apply).returns('file.pp')
+      @device.options.stubs(:[]).with(:target).returns('device1')
+      device_hash = {
+        "device1" => OpenStruct.new(:name => "device1", :url => "ssh://user:pass@testhost", :provider => "cisco"),
+      }
+      Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
+      Puppet::Util::NetworkDevice.stubs(:init)
+      File.expects(:file?).returns(true)
+
+      Puppet::Util::CommandLine.expects(:new).once
+      Puppet::Application::Apply.expects(:new).once
+
+      Puppet::Configurer.expects(:new).never
+      expect { @device.main }.to exit_with 1
+    end
+
     it "should exit if the device list is empty" do
       expect { @device.main }.to exit_with 1
     end
@@ -356,6 +405,51 @@ describe Puppet::Application::Device do
         expect { @device.main }.to exit_with 1
       end
 
+      it "should raise an error if no type is given" do
+        @device.options.stubs(:[]).with(:resource).returns(true)
+        @device.options.stubs(:[]).with(:target).returns('device1')
+        @device.command_line.stubs(:args).returns([])
+        Puppet.expects(:log_exception).with {|e| e.message == "You must specify the type to display"}
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "should raise an error if the type is not found" do
+        @device.options.stubs(:[]).with(:resource).returns(true)
+        @device.options.stubs(:[]).with(:target).returns('device1')
+        @device.command_line.stubs(:args).returns(['nope'])
+        Puppet.expects(:log_exception).with {|e| e.message == "Could not find type nope"}
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "should retrieve all resources of a type" do
+        @device.options.stubs(:[]).with(:resource).returns(true)
+        @device.options.stubs(:[]).with(:target).returns('device1')
+        @device.command_line.stubs(:args).returns(['user'])
+        Puppet::Resource.indirection.expects(:search).with('user/', {}).returns([])
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "should retrieve named resources of a type" do
+        @device.options.stubs(:[]).with(:resource).returns(true)
+        @device.options.stubs(:[]).with(:target).returns('device1')
+        @device.command_line.stubs(:args).returns(['user', 'title'])
+        Puppet::Resource.indirection.expects(:find).with('user/title')
+        expect { @device.main }.to exit_with 1
+      end
+
+      it "should output resources as YAML" do
+        resources = [
+          Puppet::Type.type(:user).new(:name => "title").to_resource,
+        ]
+        @device.options.stubs(:[]).with(:resource).returns(true)
+        @device.options.stubs(:[]).with(:target).returns('device1')
+        @device.options.stubs(:[]).with(:to_yaml).returns(true)
+        @device.command_line.stubs(:args).returns(['user'])
+        Puppet::Resource.indirection.expects(:search).with('user/', {}).returns(resources)
+        @device.expects(:puts).with("user:\n  title:\n")
+        expect { @device.main }.to exit_with 1
+      end
+
       it "should make sure all the required folders and files are created" do
         Puppet.settings.expects(:use).with(:main, :agent, :ssl).twice
         expect { @device.main }.to exit_with 1

data/spec/unit/application/face_base_spec.rb

@@ -343,7 +343,7 @@ describe Puppet::Application::FaceBase do
 
       it "should render a non-trivially-keyed Hash with using pretty printed JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        expect(app.render(hash, {})).to eq(JSON.pretty_generate(hash).chomp)
+        expect(app.render(hash, {})).to eq(Puppet::Util::Json.dump(hash, :pretty => true).chomp)
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -356,7 +356,7 @@ describe Puppet::Application::FaceBase do
         expect(app.render(hash, {})).to eq <<EOT
 5      5
 6.0    6
-four   #{object.to_json.chomp}
+four   #{Puppet::Util::Json.dump(object).chomp}
 one    1
 three  {}
 two    []

data/spec/unit/application/lookup_spec.rb

@@ -89,7 +89,6 @@ describe Puppet::Application::Lookup do
     end
   end
 
-
   context 'when given a valid configuration' do
     let (:lookup) { Puppet::Application[:lookup] }
 

data/spec/unit/configurer_spec.rb

@@ -352,6 +352,13 @@ describe Puppet::Configurer do
       expect(@agent.run).to be_nil
     end
 
+    it "should record the time it took to apply the catalog" do
+      report = Puppet::Transaction::Report.new
+      @catalog.stubs(:apply).with(:report => report)
+      report.expects(:add_times).with(:catalog_application, kind_of(Numeric))
+      @agent.apply_catalog(@catalog, {:report => report})
+    end
+
     it "should refetch the catalog if the server specifies a new environment in the catalog" do
       catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
       @agent.expects(:retrieve_catalog).returns(catalog).twice
@@ -930,6 +937,13 @@ describe Puppet::Configurer do
 
       @agent.convert_catalog(catalog, 10)
     end
+
+    it "should set catalog conversion time on the report" do
+      report = Puppet::Transaction::Report.new
+
+      report.expects(:add_times).with(:convert_catalog, kind_of(Numeric))
+      @agent.convert_catalog(catalog, 10, {:report => report})
+    end
   end
 
   describe "when determining whether to pluginsync" do

data/spec/unit/confine_spec.rb

@@ -74,4 +74,20 @@ describe Puppet::Confine do
       expect(@confine.result).to eq([true, false, true, false])
     end
   end
+
+  describe "when requiring" do
+    it "does not cache failed requires when always_retry_plugins is true" do
+      Puppet[:always_retry_plugins] = true
+      Puppet::Confine.expects(:require).with('puppet/confine/osfamily').twice.raises(LoadError)
+      Puppet::Confine.test(:osfamily)
+      Puppet::Confine.test(:osfamily)
+    end
+
+    it "caches failed requires when always_retry_plugins is false" do
+      Puppet[:always_retry_plugins] = false
+      Puppet::Confine.expects(:require).with('puppet/confine/osfamily').once.raises(LoadError)
+      Puppet::Confine.test(:osfamily)
+      Puppet::Confine.test(:osfamily)
+    end
+  end
 end

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -201,7 +201,7 @@ describe "when using a hiera data provider" do
     it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
-        value = Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to include(<<-EOS)
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
         Original path: "common.yaml"
@@ -216,7 +216,7 @@ describe "when using a hiera data provider" do
     it 'will report that merge options was found in the lookup_options hash' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
-        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to include("Using merge options from \"lookup_options\" hash")
       end
     end
@@ -224,7 +224,7 @@ describe "when using a hiera data provider" do
     it 'will report lookup_options details in combination with details of found value' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true))
-        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to eq(<<EOS)
 Searching for "lookup_options"
   Global Data Provider (hiera configuration version 5)
@@ -314,7 +314,7 @@ EOS
     it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true, true))
-        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
         expect(lookup_invocation.explainer.explain).to eq(<<EOS)
 Merge strategy hash
   Global Data Provider (hiera configuration version 5)

data/spec/unit/datatypes_spec.rb

@@ -229,6 +229,55 @@ describe "Puppet::DataTypes" do
     end
   end
 
+  context 'when creating type with custom new_function' do
+    let(:datatypes) {
+      {
+        'mytest.rb' => <<-RUBY.unindent,
+          Puppet::DataTypes.create_type('Mytest') do
+            interface <<-PUPPET
+              attributes => {
+                strings => { type => Array[String] },
+                ints => { type => Array[Integer] },
+              }
+              PUPPET
+
+          implementation_class PuppetSpec::DataTypes::MyTest
+        end
+      RUBY
+      }
+    }
+
+    before(:each) do
+      class ::PuppetSpec::DataTypes::MyTest
+        def self.create_new_function(t)
+          Puppet::Functions.create_function('new_%s' % t.name) do
+            dispatch :create do
+              repeated_param 'Variant[String,Integer]', :args
+            end
+
+            def create(*args)
+              ::PuppetSpec::DataTypes::MyTest.new(*args.partition { |arg| arg.is_a?(String) })
+            end
+          end
+        end
+        attr_reader :strings, :ints
+
+        def initialize(strings, ints)
+          @strings = strings
+          @ints = ints
+        end
+      end
+    end
+
+    after(:each) do
+      ::PuppetSpec::DataTypes.send(:remove_const, :MyTest)
+    end
+
+    it 'loads and calls custom new function' do
+      expect(eval_and_collect_notices('notice(Mytest("A", 32, "B", 20).ints)', node)).to eql(['[32, 20]'])
+    end
+  end
+
   context 'with data type and class defined in a module' do
     let(:mytest_classes) {
       {

data/spec/unit/environments_spec.rb

@@ -421,6 +421,13 @@ config_version=$vardir/random/scripts
       expect(loader.get_conf(:doesnotexist)).to be_nil
     end
 
+    it "gets the conf environment_timeout if one is specified" do
+      Puppet[:environment_timeout] = 8675
+      conf = loader.get_conf(:static1)
+
+      expect(conf.environment_timeout).to eq(8675)
+    end
+
     context "that are private" do
       let(:private_env) { Puppet::Node::Environment.create(:private, []) }
       let(:loader) { Puppet::Environments::StaticPrivate.new(private_env) }

data/spec/unit/face/config_spec.rb

@@ -2,46 +2,117 @@
 require 'spec_helper'
 require 'puppet/face'
 
-module PuppetFaceSpecs 
+module PuppetFaceSpecs
 describe Puppet::Face[:config, '0.0.1'] do
 
+  let(:config) { described_class }
+
+  def render(action, result)
+    config.get_action(action).when_rendering(:console).call(result)
+  end
+
   FS = Puppet::FileSystem
 
+  before :each do
+    subject.stubs(:warn_default_section)
+    subject.stubs(:report_section_and_environment)
+  end
+
   it "prints a single setting without the name" do
     Puppet[:trace] = true
 
-    expect { subject.print("trace") }.to have_printed('true')
+    result = subject.print("trace")
+    expect(render(:print, result)).to eq("true\n")
   end
 
   it "prints multiple settings with the names" do
     Puppet[:trace] = true
     Puppet[:syslogfacility] = "file"
 
-    expect { subject.print("trace", "syslogfacility") }.to have_printed(<<-OUTPUT)
+    result = subject.print("trace", "syslogfacility")
+    expect(render(:print, result)).to eq(<<-OUTPUT)
 syslogfacility = file
 trace = true
     OUTPUT
   end
 
+  it "prints environment_timeout=unlimited correctly" do
+    Puppet[:environment_timeout] = "unlimited"
+
+    result = subject.print("environment_timeout")
+    expect(render(:print, result)).to eq("unlimited\n")
+  end
+
+  it "prints arrays correctly" do
+    pending "Still doesn't print arrays like they would appear in config"
+    Puppet[:server_list] = %w{server1 server2}
+
+    result = subject.print("server_list")
+    expect(render(:print, result)).to eq("server1, server2\n")
+  end
+
   it "prints the setting from the selected section" do
     Puppet.settings.parse_config(<<-CONF)
     [user]
     syslogfacility = file
     CONF
 
-    expect { subject.print("syslogfacility", :section => "user") }.to have_printed('file')
+    result = subject.print("syslogfacility", :section => "user")
+    expect(render(:print, result)).to eq("file\n")
   end
 
-  it "defaults to all when no arguments are given" do
-    subject.expects(:puts).times(Puppet.settings.to_a.length)
+  it "prints the section and environment, and not a warning,  when a section is given" do
+    Puppet.settings.parse_config(<<-CONF)
+    [user]
+    syslogfacility = file
+    CONF
 
-    subject.print
+    subject.expects(:warn_default_section).never
+    subject.expects(:report_section_and_environment).once
+
+    result = subject.print("syslogfacility", :section => "user")
+    expect(render(:print, result)).to eq("file\n")
+  end
+
+  it "prints a warning and the section and environment when no section is given" do
+    Puppet[:trace] = true
+
+    subject.expects(:warn_default_section).once
+    subject.expects(:report_section_and_environment).once
+
+    result = subject.print("trace")
+    expect(render(:print, result)).to eq("true\n")
+  end
+
+  it "defaults to all when no arguments are given" do
+    result = subject.print
+    expect(render(:print, result).lines.to_a.length).to eq(Puppet.settings.to_a.length)
   end
 
   it "prints out all of the settings when asked for 'all'" do
-    subject.expects(:puts).times(Puppet.settings.to_a.length)
+    result = subject.print('all')
+    expect(render(:print, result).lines.to_a.length).to eq(Puppet.settings.to_a.length)
+  end
+
+  it "stringifies all keys for network format handlers to consume" do
+    Puppet[:syslogfacility] = "file"
+
+    result = subject.print
+    expect(result["syslogfacility"]).to eq("file")
+    expect(result.keys).to all(be_a(String))
+  end
+
+  it "stringifies multiple keys for network format handlers to consume" do
+    Puppet[:trace] = true
+    Puppet[:syslogfacility] = "file"
+
+    expect(subject.print("trace", "syslogfacility")).to eq({"syslogfacility" => "file", "trace" => true})
+  end
+
+  it "stringifies single key for network format handlers to consume" do
+    Puppet[:trace] = true
 
-    subject.print('all')
+    expect(subject.print("trace")).to eq({"trace" => true})
   end
 
   context "when setting config values" do
@@ -53,6 +124,18 @@ trace = true
       Puppet::FileSystem.stubs(:touch)
     end
 
+    it "prints the section and environment when no section is given" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      subject.expects(:report_section_and_environment).once
+      subject.set('foo', 'bar')
+    end
+
+    it "prints the section and environment when a section is given" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      subject.expects(:report_section_and_environment).once
+      subject.set('foo', 'bar', {:section => "baz"})
+    end
+
     it "writes to the correct puppet config file" do
       Puppet::FileSystem.expects(:open).with(path, anything, anything)
       subject.set('foo', 'bar')
@@ -84,6 +167,21 @@ trace = true
       subject.set('foo', 'bar', {:section => "baz"})
     end
 
+    it "does not duplicate an existing default section when a section is not specified" do
+      contents = <<-CONF
+      [main]
+      myport = 4444
+      CONF
+
+      myfile = StringIO.new(contents)
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(myfile)
+
+      subject.set('foo', 'bar')
+
+      expect(myfile.string).to match(/foo = bar/)
+      expect(myfile.string).not_to match(/main.*main/)
+    end
+
     it "opens the file with UTF-8 encoding" do
       Puppet::FileSystem.expects(:open).with(path, nil, 'r+:UTF-8')
       subject.set('foo', 'bar')
@@ -152,7 +250,9 @@ trace = true
         ])
       ) do
         args = "environmentpath","manifest","modulepath","environment","basemodulepath"
-        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+
+        result = subject.print(*add_section_option(args, section))
+        expect(render(:print, result)).to eq(<<-OUTPUT)
 basemodulepath = #{File.expand_path("/some/base")}
 environment = production
 environmentpath = #{File.expand_path("/dev/null/environments")}
@@ -173,7 +273,9 @@ modulepath = #{File.expand_path("/dev/null/environments/production/modules")}#{F
         ])
       ) do
         args = "environmentpath","manifest","modulepath","environment","basemodulepath"
-        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+
+        result = subject.print(*add_section_option(args, section))
+        expect(render(:print, result)).to eq(<<-OUTPUT)
 basemodulepath = #{File.expand_path("/some/base")}
 environment = production
 environmentpath = #{File.expand_path("/dev/null/environments")}
@@ -192,7 +294,9 @@ modulepath = #{File.expand_path("/custom/modules")}#{File::PATH_SEPARATOR}#{File
         ])
       ) do
         args = "environmentpath","manifest","modulepath","environment","basemodulepath"
-        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+
+        result = subject.print(*add_section_option(args, section))
+        expect(render(:print, result)).to eq(<<-OUTPUT)
 basemodulepath = #{File.expand_path("/some/base")}
 environment = doesnotexist
 environmentpath = #{File.expand_path("/dev/null/environments")}