puppet 6.0.2-x64-mingw32 → 6.0.3-x64-mingw32

data/spec/unit/application_spec.rb

@@ -33,7 +33,7 @@ describe Puppet::Application do
   describe "application defaults" do
     it "should fail if required app default values are missing" do
       @app.stubs(:app_defaults).returns({ :foo => 'bar' })
-      Puppet.expects(:err).with(regexp_matches(/missing required app default setting/))
+      Puppet.expects(:send_log).with(:err, regexp_matches(/missing required app default setting/))
       expect {
         @app.run
       }.to exit_with(1)
@@ -55,10 +55,10 @@ describe Puppet::Application do
     end
 
     it "should error if it can't find a class" do
-      Puppet.expects(:err).with do |value|
-        value =~ /Unable to find application 'ThisShallNeverEverEverExist'/ and
-          value =~ /puppet\/application\/thisshallneverevereverexist/ and
-          value =~ /no such file to load|cannot load such file/
+      Puppet.expects(:send_log).with do |_level, message|
+        message =~ /Unable to find application 'ThisShallNeverEverEverExist'/ and
+          message =~ /puppet\/application\/thisshallneverevereverexist/ and
+          message =~ /no such file to load|cannot load such file/
       end
 
       expect {
@@ -422,7 +422,6 @@ describe Puppet::Application do
   end
 
   describe "when calling default setup" do
-
     before :each do
       @app.options.stubs(:[])
     end
@@ -443,6 +442,14 @@ describe Puppet::Application do
 
       @app.setup
     end
+  
+    it "sets the log destination if provided via settings" do
+      @app.options.unstub(:[])
+      Puppet[:logdest] = "set_via_config"
+      Puppet::Util::Log.expects(:newdestination).with("set_via_config")
+
+      @app.setup
+    end
 
     it "does not downgrade the loglevel when --verbose is specified" do
       Puppet[:log_level] = :debug
@@ -553,19 +560,19 @@ describe Puppet::Application do
     end
 
     it "should warn and exit if no command can be called" do
-      Puppet.expects(:err)
+      Puppet.expects(:send_log).with(:err, "Could not run: No valid command or main")
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
-      Puppet.expects(:err)
+      Puppet.expects(:send_log).with(:err, "Could not run: No valid command or main")
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
-      Puppet.expects(:err)
+      Puppet.expects(:send_log).with(:err, "Could not run: No valid command or main")
       expect { @app.run }.to exit_with 1
     end
   end
@@ -652,7 +659,6 @@ describe Puppet::Application do
   end
 
   describe "#handle_logdest_arg" do
-
     let(:test_arg) { "arg_test_logdest" }
 
     it "should log an exception that is raised" do
@@ -672,6 +678,18 @@ describe Puppet::Application do
       @app.handle_logdest_arg(test_arg)
       expect(@app.options[:setdest]).to be_truthy
     end
-  end
 
+    it "does not set the log destination if setdest is true" do
+      Puppet::Util::Log.expects(:newdestination).never
+      @app.options[:setdest] = true
+
+      @app.handle_logdest_arg(test_arg)
+    end
+
+    it "does not set the log destination if arg is nil" do
+      Puppet::Util::Log.expects(:newdestination).never
+
+      @app.handle_logdest_arg(nil)
+    end
+  end
 end

data/spec/unit/configurer/downloader_spec.rb

@@ -222,7 +222,7 @@ describe Puppet::Configurer::Downloader do
     end
 
     it "should catch and log exceptions" do
-      Puppet.expects(:err)
+      Puppet.expects(:log_exception)
       # The downloader creates a new catalog for each apply, and really the only object
       # that it is possible to stub for the purpose of generating a puppet error
       Puppet::Resource::Catalog.any_instance.stubs(:apply).raises(Puppet::Error, "testing")

data/spec/unit/configurer_spec.rb

@@ -551,8 +551,8 @@ describe Puppet::Configurer do
 
       Puppet::Transaction::Report.indirection.expects(:save).raises("whatever")
 
-      Puppet.expects(:err)
-      expect { @configurer.send_report(@report) }.not_to raise_error
+      Puppet.expects(:send_log).with(:err, 'Could not send report: whatever')
+      @configurer.send_report(@report)
     end
   end
 
@@ -590,8 +590,8 @@ describe Puppet::Configurer do
 
       Puppet::Util.expects(:replace_file).yields(fh)
 
-      Puppet.expects(:err)
-      expect { @configurer.save_last_run_summary(@report) }.to_not raise_error
+      Puppet.expects(:send_log).with(:err, 'Could not save last run local report: failed to do print')
+      @configurer.save_last_run_summary(@report)
     end
 
     it "should create the last run file with the correct mode" do
@@ -609,7 +609,7 @@ describe Puppet::Configurer do
 
     it "should report invalid last run file permissions" do
       Puppet.settings.setting(:lastrunfile).expects(:mode).returns('892')
-      Puppet.expects(:err).with(regexp_matches(/Could not save last run local report.*892 is invalid/))
+      Puppet.expects(:send_log).with(:err, regexp_matches(/Could not save last run local report.*892 is invalid/))
       @configurer.save_last_run_summary(@report)
     end
   end

data/spec/unit/face/node_spec.rb

@@ -2,8 +2,6 @@
 require 'spec_helper'
 require 'puppet/face'
 
-require 'puppetserver/ca/cli'
-
 describe Puppet::Face[:node, '0.0.1'] do
   describe '#cleanup' do
     it "should clean everything" do
@@ -90,7 +88,7 @@ describe Puppet::Face[:node, '0.0.1'] do
         end
       end
 
-      describe "when cleaning certificate" do
+      describe "when cleaning certificate", :if => Puppet.features.puppetserver_ca? do
         it "should call the CA CLI gem's clean action" do
           Puppetserver::Ca::Action::Clean.any_instance.expects(:run).with({ 'certnames' => ['hostname'] }).returns(0)
           subject.clean_cert('hostname')

data/spec/unit/file_serving/fileset_spec.rb

@@ -147,12 +147,12 @@ describe Puppet::FileServing::Fileset do
       top_names = %w{one two .svn CVS}
       sub_names = %w{file1 file2 .svn CVS 0 false}
 
-      Dir.stubs(:entries).with(path).returns(top_names)
+      Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
         Puppet::FileSystem.stubs(stat_method).with(subpath).returns @dirstat
-        Dir.stubs(:entries).with(subpath).returns(sub_names)
+        Dir.stubs(:entries).with(subpath, encoding: Encoding::UTF_8).returns(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
@@ -173,7 +173,7 @@ describe Puppet::FileServing::Fileset do
         extend Mocha::API
         path = File.join(base_path, name)
         Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, true)
-        Dir.stubs(:entries).with(path).returns(['.', '..'] + entries.map(&:name))
+        Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(['.', '..'] + entries.map(&:name))
         entries.each do |entry|
           entry.mock(path)
         end
@@ -295,7 +295,7 @@ describe Puppet::FileServing::Fileset do
     link_path = File.join(path, "mylink")
     Puppet::FileSystem.expects(:stat).with(link_path).raises(Errno::ENOENT)
 
-    Dir.stubs(:entries).with(path).returns(["mylink"])
+    Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(["mylink"])
 
     fileset = Puppet::FileServing::Fileset.new(path)
 
@@ -319,9 +319,9 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "returns a hash of all files in each fileset with the value being the base path" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one uno})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two dos})
-      Dir.expects(:entries).with(make_absolute("/third/path")).returns(%w{three tres})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one uno})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two dos})
+      Dir.expects(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).returns(%w{three tres})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
@@ -335,15 +335,15 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "includes the base directory from the first fileset" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{one})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end

data/spec/unit/network/http/connection_spec.rb

@@ -97,7 +97,7 @@ describe Puppet::Network::HTTP::Connection do
       :verify => ConstantErrorValidator.new(
         :fails_with => 'hostname was not match with server certificate',
         :peer_certs => [Puppet::TestCa.new.generate('not_my_server',
-                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server').content]))
+                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server')[:cert]]))
 
       expect do
         connection.get('request')
@@ -120,7 +120,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should check all peer certificates for upcoming expiration", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
       Puppet[:confdir] = tmpdir('conf')
       cert = Puppet::TestCa.new.generate('server',
-                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')
+                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')[:cert]
 
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,

data/spec/unit/pops/validator/validator_spec.rb

@@ -23,7 +23,11 @@ describe "validating 4x" do
 
   def with_environment(environment, env_params = {})
     override_env = environment
-    override_env = environment.override_with(env_params) if env_params.count > 0
+    override_env = environment.override_with({
+      modulepath:     env_params[:modulepath]     || environment.full_modulepath,
+      manifest:       env_params[:manifest]       || environment.manifest,
+      config_version: env_params[:config_version] || environment.config_version
+    }) if env_params.count > 0
     Puppet.override(current_environment: override_env) do
       yield
     end
@@ -72,15 +76,6 @@ describe "validating 4x" do
     end
   end
 
-  it 'should not raise error for legal definition locations' do
-    with_environment(environment, :manifest => 'a/manifest/file.pp') do
-      expect(validate(parse('function aaa::bbb() {}',      'path/aaa/manifests/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('class aaa() {}',      'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('function aaa::bbB::ccc() {}', 'path/aaa/manifests/bBb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('function aaa::bbb::ccc() {}', 'path/aaa/manifests/bbb/CCC.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-    end
-  end
-
   it 'should not raise error for definitions inside initial --manifest file' do
     with_environment(environment, :manifest => 'a/manifest/file.pp') do
       expect(validate(parse('class aaa() {}', 'a/manifest/file.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -100,6 +95,13 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error for empty files in modulepath' do
+    with_environment(environment) do
+      expect(validate(parse('', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      expect(validate(parse('#this is a comment', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+    end
+  end
+
   it 'should raise error if the file is in the modulepath but is not well formed' do
     with_environment(environment) do
       expect(validate(parse('class aaa::bbb::ccc() {}', 'path/manifest/aaa/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -113,6 +115,18 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error when one modulepath is a substring of another' do
+    with_environment(environment, modulepath: ['path', 'pathplus']) do
+      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error when a modulepath ends with a file separator' do
+    with_environment(environment, modulepath: ['path/']) do
+      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
   it 'should raise error for illegal type names' do
     expect(validate(parse('type ::Aaa = Any'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end

data/spec/unit/provider/package/windows/exe_package_spec.rb

@@ -76,7 +76,7 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     it 'should install using the source' do
       cmd = subject.install_command({:source => source})
 
-      expect(cmd).to eq(['cmd.exe', '/c', 'start', '"puppet-install"', '/w', source])
+      expect(cmd).to eq(source)
     end
   end
 
@@ -84,7 +84,7 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     ['C:\uninstall.exe', 'C:\Program Files\uninstall.exe'].each do |exe|
       it "should quote #{exe}" do
         expect(subject.new(name, version, exe).uninstall_command).to eq(
-          ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w', "\"#{exe}\""]
+          "\"#{exe}\""
         )
       end
     end
@@ -92,7 +92,7 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     ['"C:\Program Files\uninstall.exe"', '"C:\Program Files (x86)\Git\unins000.exe" /SILENT"'].each do |exe|
       it "should not quote #{exe}" do
         expect(subject.new(name, version, exe).uninstall_command).to eq(
-          ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w', exe]
+          exe
         )
       end
     end

data/spec/unit/provider/package/windows_spec.rb

@@ -1,12 +1,12 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:windows) do
+describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.microsoft_windows? do
   let (:name)        { 'mysql-5.1.58-win-x64' }
-  let (:source)      { 'E:\mysql-5.1.58-win-x64.msi' }
+  let (:source)      { 'E:\Rando\Directory\mysql-5.1.58-win-x64.msi' }
   let (:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :windows, :source => source) }
   let (:provider)    { resource.provider }
-  let (:execute_options) do {:failonfail => false, :combine => true} end
+  let (:execute_options) do {:failonfail => false, :combine => true, :suppress_window => true} end
 
   before :each do
     # make sure we never try to execute anything
@@ -86,7 +86,7 @@ describe Puppet::Type.type(:package).provider(:windows) do
   context '#install' do
     let(:command) { 'blarg.exe /S' }
     let(:klass) { mock('installer', :install_command => ['blarg.exe', '/S'] ) }
-
+    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
     before :each do
       Puppet::Provider::Package::Windows::Package.expects(:installer_class).returns(klass)
     end

data/spec/unit/provider/service/windows_spec.rb

@@ -36,6 +36,16 @@ describe 'Puppet::Type::Service::Provider::Windows',
   end
 
   describe "#start" do
+    before(:each) do
+      provider.stubs(:status).returns(:stopped)
+    end
+
+    it "should resume a paused service" do
+      provider.stubs(:status).returns(:paused)
+      service_util.expects(:resume).with(name)
+      provider.start
+    end
+
     it "should start the service" do
       service_util.expects(:service_start_type).with(name).returns(:SERVICE_AUTO_START)
       service_util.expects(:start).with(name)
@@ -85,10 +95,18 @@ describe 'Puppet::Type::Service::Provider::Windows',
     end
 
     [
-      :SERVICE_STOPPED,
       :SERVICE_PAUSED,
-      :SERVICE_STOP_PENDING,
-      :SERVICE_PAUSE_PENDING,
+      :SERVICE_PAUSE_PENDING
+    ].each do |state|
+      it "should report a #{state} service as paused" do
+        service_util.expects(:service_state).with(name).returns(state)
+        expect(provider.status).to eq(:paused)
+      end
+    end
+
+    [
+      :SERVICE_STOPPED,
+      :SERVICE_STOP_PENDING
     ].each do |state|
       it "should report a #{state} service as stopped" do
         service_util.expects(:service_state).with(name).returns(state)

data/spec/unit/provider/user/useradd_spec.rb

@@ -138,10 +138,10 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         provider.create
       end
 
-      it "should not use -e with luseradd, should call lusermod with -e after luseradd when expiry is set" do
+      it "should not use -e with luseradd, should call usermod with -e after luseradd when expiry is set" do
         resource[:expiry] = '2038-01-24'
         provider.expects(:execute).with(all_of(includes('/usr/sbin/luseradd'), Not(includes('-e'))), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
-        provider.expects(:execute).with(all_of(includes('/usr/sbin/lusermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/usermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 

data/spec/unit/resource/catalog_spec.rb

@@ -48,8 +48,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     catalog.add_resource(res, res2, res3, res4, comp_res)
     catalog.write_resource_file
     expect(File.readlines(resourcefile).map(&:chomp)).to match_array([
-      "file[#{File.expand_path('/tmp/sam')}]",
-      "exec[#{File.expand_path('/bin/rm')} -rf /]"
+      "file[#{res.title.downcase}]",
+      "exec[#{res2.title.downcase}]"
     ])
   end
 

data/spec/unit/ssl/host_spec.rb

@@ -601,7 +601,7 @@ describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
       @host.stubs(:generate)
       @host.stubs(:sleep)
 
-      Puppet.expects(:err)
+      Puppet.expects(:log_exception)
 
       @host.wait_for_cert(1)
     end

data/spec/unit/transaction/persistence_spec.rb

@@ -73,7 +73,7 @@ describe Puppet::Transaction::Persistence do
       it "should initialize with a clear internal state if the file does not contain valid YAML" do
         write_state_file('{ invalid')
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -97,8 +97,8 @@ describe Puppet::Transaction::Persistence do
 
         File.expects(:rename).raises(SystemCallError)
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
-        Puppet.expects(:err).with(regexp_matches(/Unable to rename/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Unable to rename/))
 
         persistence = Puppet::Transaction::Persistence.new
         expect { persistence.load }.to raise_error(Puppet::Error, /Could not rename/)
@@ -109,7 +109,7 @@ describe Puppet::Transaction::Persistence do
 
         File.expects(:rename).at_least_once
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load