puppet 6.17.0-x64-mingw32 → 6.18.0-x64-mingw32

data/spec/integration/directory_environments_spec.rb

@@ -2,11 +2,7 @@ require 'spec_helper'
 
 describe "directory environments" do
   let(:args) { ['--configprint', 'modulepath', '--environment', 'direnv'] }
-  let(:puppet) do
-    app = Puppet::Application[:apply]
-    allow(app).to receive(:command_line).and_return(double('command_line', :args => []))
-    app
-  end
+  let(:puppet) { Puppet::Application[:apply] }
 
   context "with a single directory environmentpath" do
     before(:each) do
@@ -17,17 +13,19 @@ describe "directory environments" do
 
     it "config prints the environments modulepath" do
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed('/direnv/modules')
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(%r{/direnv/modules}).to_stdout
     end
 
     it "config prints the cli --modulepath despite environment" do
       args << '--modulepath' << '/completely/different'
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed('/completely/different')
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(%r{/completely/different}).to_stdout
     end
 
     it 'given an 8.3 style path on Windows, will config print an expanded path',
@@ -41,9 +39,10 @@ describe "directory environments" do
       expect(Puppet[:environmentpath]).to match(/~/)
 
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed(expanded)
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(a_string_matching(expanded)).to_stdout
     end
   end
 
@@ -59,9 +58,10 @@ describe "directory environments" do
 
     it "config prints a directory environment modulepath" do
       Puppet.settings.initialize_global_settings(args)
-      expect do
-        expect { puppet.run }.to exit_with(0)
-      end.to have_printed('otherdirenv/modules')
+      expect {
+        puppet.run
+      }.to exit_with(0)
+       .and output(%r{otherdirenv/modules}).to_stdout
     end
   end
 end

data/spec/integration/indirector/facts/facter_spec.rb

@@ -43,9 +43,10 @@ describe Puppet::Node::Facts::Facter do
       Puppet.initialize_settings(['--modulepath', factdir])
       apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--modulepath', factdir, '-e', 'notify { $custom: }']))
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed(Puppet.version)
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/defined 'message' as '#{Puppet.version}'/).to_stdout
     end
 
     it "should resolve external facts" do
@@ -58,9 +59,10 @@ describe Puppet::Node::Facts::Facter do
       Puppet.initialize_settings(['--pluginfactdest', factdir])
       apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--pluginfactdest', factdir, '-e', 'notify { $foo: }']))
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('bar')
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/defined 'message' as 'bar'/).to_stdout
     end
   end
 

data/spec/integration/node/environment_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Node::Environment do
   it "should not yield a module with the same name as a defined Bolt project" do
     project_path = File.join(tmpfile('project'), 'bolt_project')
     FileUtils.mkdir_p(project_path)
-    project = Struct.new("Project", :name, :path).new('project', project_path)
+    project = Struct.new("Project", :name, :path, :load_as_module?).new('project', project_path, true)
 
     Puppet.override(bolt_project: project) do
       base = tmpfile("base")

data/spec/integration/util/execution_spec.rb

@@ -50,6 +50,28 @@ describe Puppet::Util::Execution, unless: Puppet::Util::Platform.jruby? do
       Puppet::Util::Execution.execute(str, sensitive: true)
       expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'"))
     end
+
+    it "allows stdout and stderr to share a file" do
+      command = "ruby -e '(1..10).each {|i| (i%2==0) ? $stdout.puts(i) : $stderr.puts(i)}'"
+
+      expect(Puppet::Util::Execution.execute(command, :combine => true).split).to match_array([*'1'..'10'])
+    end
+
+    it "returns output and set $CHILD_STATUS" do
+      command = "ruby -e 'puts \"foo\"; exit 42'"
+
+      output = Puppet::Util::Execution.execute(command, {:failonfail => false})
+
+      expect(output).to eq("foo\n")
+      expect($CHILD_STATUS.exitstatus).to eq(42)
+    end
+
+    it "raises an error if non-zero exit status is returned" do
+      command = "ruby -e 'exit 43'"
+
+      expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
+      expect($CHILD_STATUS.exitstatus).to eq(43)
+    end
   end
 
   describe "#execute (non-Windows)", :if => !Puppet::Util::Platform.windows? do

data/spec/integration/util/windows/monkey_patches/dir_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Dir, :if => Puppet::Util::Platform.windows? do
+  it "should always have the PERSONAL constant defined" do
+    expect(described_class).to be_const_defined(:PERSONAL)
+  end
+
+  it "should not raise any errors when accessing the PERSONAL constant" do
+    expect { described_class::PERSONAL }.not_to raise_error
+  end
+end

data/spec/integration/util/windows/process_spec.rb

@@ -33,17 +33,7 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
   end
 
   describe "when reading environment variables" do
-    after :each do
-      # spec\integration\test\test_helper_spec.rb calls set_environment_strings
-      # after :all and thus needs access to the real APIs once again
-      allow(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_call_original
-      allow(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW).and_call_original
-    end
-
     it "will ignore only keys or values with corrupt byte sequences" do
-      arraydest = []
-      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
-
       env_vars = {}
 
       # Create a UTF-16LE version of the below null separated environment string
@@ -61,9 +51,9 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
         ptr.put_array_of_uchar(0, env_var_block_bytes)
 
         # stub the block of memory that the Win32 API would typically return via pointer
-        expect(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_return(ptr)
+        allow(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_return(ptr)
         # stub out the real API call to free memory, else process crashes
-        expect(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW)
+        allow(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW)
 
         env_vars = Puppet::Util::Windows::Process.get_environment_strings
       end
@@ -72,39 +62,43 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
       expect(env_vars).to eq({'a' => 'b', 'c' => 'd', 'f' => 'g'})
 
       # and Puppet should emit a warning about it
-      expect(arraydest.last.level).to eq(:warning)
-      expect(arraydest.last.message).to eq("Discarding environment variable e=\uFFFD which contains invalid bytes")
+      expect(@logs.last.level).to eq(:warning)
+      expect(@logs.last.message).to eq("Discarding environment variable e=\uFFFD which contains invalid bytes")
     end
   end
 
   describe "when setting environment variables" do
-    it "can properly handle env var values with = in them" do
-      begin
-        name = SecureRandom.uuid
-        value = 'foo=bar'
+    let(:name) { SecureRandom.uuid }
 
-        Puppet::Util::Windows::Process.set_environment_variable(name, value)
-
-        env = Puppet::Util::Windows::Process.get_environment_strings
-
-        expect(env[name]).to eq(value)
+    around :each do |example|
+      begin
+        example.run
       ensure
         Puppet::Util::Windows::Process.set_environment_variable(name, nil)
       end
     end
 
-    it "can properly handle empty env var values" do
-      begin
-        name = SecureRandom.uuid
+    it "sets environment variables containing '='" do
+      value = 'foo=bar'
+      Puppet::Util::Windows::Process.set_environment_variable(name, value)
+      env = Puppet::Util::Windows::Process.get_environment_strings
 
-        Puppet::Util::Windows::Process.set_environment_variable(name, '')
+      expect(env[name]).to eq(value)
+    end
 
-        env = Puppet::Util::Windows::Process.get_environment_strings
+    it "sets environment variables contains spaces" do
+      Puppet::Util::Windows::Process.set_environment_variable(name, '')
+      env = Puppet::Util::Windows::Process.get_environment_strings
 
-        expect(env[name]).to eq('')
-      ensure
-        Puppet::Util::Windows::Process.set_environment_variable(name, nil)
-      end
+      expect(env[name]).to eq('')
+    end
+
+    it "sets environment variables containing UTF-8" do
+      rune_utf8 = "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7"
+      Puppet::Util::Windows::Process.set_environment_variable(name, rune_utf8)
+      env = Puppet::Util::Windows::Process.get_environment_strings
+
+      expect(env[name]).to eq(rune_utf8)
     end
   end
 end

data/spec/integration/util/windows/user_spec.rb

@@ -215,5 +215,12 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
         expect(Puppet::Util::Windows::User.localsystem?('OtherUser')).to eq(false)
       end
     end
+
+    describe "get_rights" do
+      it "should be empty when given user does not exist" do
+        allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('NonExistingUser').and_return(nil)
+        expect(Puppet::Util::Windows::User.get_rights('NonExistingUser')).to eq("")
+      end
+    end
   end
 end

data/spec/integration/util_spec.rb

@@ -1,32 +1,9 @@
+# coding: utf-8
 require 'spec_helper'
 
 describe Puppet::Util do
   include PuppetSpec::Files
 
-  describe "#execute", unless: Puppet::Util::Platform.jruby? do
-    it "should properly allow stdout and stderr to share a file" do
-      command = "ruby -e '(1..10).each {|i| (i%2==0) ? $stdout.puts(i) : $stderr.puts(i)}'"
-
-      expect(Puppet::Util::Execution.execute(command, :combine => true).split).to match_array([*'1'..'10'])
-    end
-
-    it "should return output and set $CHILD_STATUS" do
-      command = "ruby -e 'puts \"foo\"; exit 42'"
-
-      output = Puppet::Util::Execution.execute(command, {:failonfail => false})
-
-      expect(output).to eq("foo\n")
-      expect($CHILD_STATUS.exitstatus).to eq(42)
-    end
-
-    it "should raise an error if non-zero exit status is returned" do
-      command = "ruby -e 'exit 43'"
-
-      expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
-      expect($CHILD_STATUS.exitstatus).to eq(43)
-    end
-  end
-
   describe "#replace_file on Windows", :if => Puppet::Util::Platform.windows? do
     it "replace_file should preserve original ACEs from existing replaced file on Windows" do
 
@@ -110,18 +87,15 @@ describe Puppet::Util do
   describe "#which on Windows", :if => Puppet::Util::Platform.windows? do
     let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
     let (:filename) { 'foo.exe' }
-    let (:filepath) { File.expand_path('C:\\' + rune_utf8 + '\\' + filename) }
 
-    before :each do
-      allow(FileTest).to receive(:file?).and_return(false)
-      allow(FileTest).to receive(:file?).with(filepath).and_return(true)
+    it "should be able to use UTF8 characters in the path" do
+      utf8 = tmpdir(rune_utf8)
+      Puppet::FileSystem.mkpath(utf8)
 
-      allow(FileTest).to receive(:executable?).and_return(false)
-      allow(FileTest).to receive(:executable?).with(filepath).and_return(true)
-    end
+      filepath = File.join(utf8, filename)
+      Puppet::FileSystem.touch(filepath)
 
-    it "should be able to use UTF8 characters in the path" do
-      path = "C:\\" + rune_utf8 + "#{File::PATH_SEPARATOR}c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
+      path = [utf8, "c:\\windows\\system32", "c:\\windows"].join(File::PATH_SEPARATOR)
       Puppet::Util.withenv( { "PATH" => path } , :windows) do
         expect(Puppet::Util.which(filename)).to eq(filepath)
       end

data/spec/lib/puppet_spec/matchers.rb

@@ -41,86 +41,6 @@ RSpec::Matchers.define :exit_with do |expected|
   end
 end
 
-
-RSpec::Matchers.define :have_printed do |expected|
-
-  case expected
-  when String, Regexp, Proc
-    expected = expected
-  else
-    expected = expected.to_s
-  end
-
-  chain :and_exit_with do |code|
-    @expected_exit_code = code
-  end
-
-  define_method :matches_exit_code? do |actual|
-    @expected_exit_code.nil? || @expected_exit_code == actual
-  end
-
-  define_method :matches_output? do |actual|
-    return false unless actual
-    case expected
-      when String
-        actual.include?(expected)
-      when Regexp
-        expected.match(actual)
-      when Proc
-        expected.call(actual)
-      else
-        raise ArgumentError, "No idea how to match a #{actual.class.name}"
-    end
-  end
-
-  match do |block|
-    $stderr = $stdout = StringIO.new
-    $stdout.set_encoding('UTF-8') if $stdout.respond_to?(:set_encoding)
-
-    begin
-      block.call
-    rescue SystemExit => e
-      raise unless @expected_exit_code
-      @actual_exit_code = e.status
-    ensure
-      $stdout.rewind
-      @actual = $stdout.read
-
-      $stdout = STDOUT
-      $stderr = STDERR
-    end
-
-    matches_output?(@actual) && matches_exit_code?(@actual_exit_code)
-  end
-
-  supports_block_expectations
-
-  failure_message do |actual|
-    if actual.nil? then
-      "expected #{expected.inspect}, but nothing was printed"
-    else
-      if !@expected_exit_code.nil? && matches_output?(actual)
-        "expected exit with code #{@expected_exit_code} but " +
-          (@actual_exit_code.nil? ? " exit was not called" : "exited with #{@actual_exit_code} instead")
-      else
-        "expected #{expected.inspect} to be printed; got:\n#{actual}"
-      end
-    end
-  end
-
-  failure_message_when_negated do |actual|
-    if @expected_exit_code && matches_exit_code?(@actual_exit_code)
-      "expected exit code to not be #{@actual_exit_code}"
-    else
-      "expected #{expected.inspect} to not be printed; got:\n#{actual}"
-    end
-  end
-
-  description do
-    "expect #{expected.inspect} to be printed" + (@expected_exit_code.nil ? '' : " with exit code #{@expected_exit_code}")
-  end
-end
-
 RSpec::Matchers.define :equal_attributes_of do |expected|
   match do |actual|
     actual.instance_variables.all? do |attr|

data/spec/lib/puppet_spec/puppetserver.rb

@@ -47,9 +47,13 @@ class PuppetSpec::Puppetserver
   class FilebucketServlet < WEBrick::HTTPServlet::AbstractServlet
     def do_GET request, response
     end
+
     def do_PUT request, response
+      upload = File.join(@config.config[:TempDir], 'filebucket')
+      File.open(upload, 'wb') { |f| f.write(request.body) }
       response['Content-Type'] = 'application/octet-stream'
     end
+
     def do_HEAD request, response
       response.status = 404
     end
@@ -116,4 +120,8 @@ class PuppetSpec::Puppetserver
               end
     @https.mount(path, handler)
   end
+
+  def upload_directory
+    @https.config[:TempDir]
+  end
 end

data/spec/unit/application/agent_spec.rb

@@ -571,10 +571,9 @@ describe Puppet::Application::Agent do
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_request).and_return(nil)
 
         expect {
-          expect {
-            @puppetd.fingerprint
-          }.to exit_with(1)
-        }.to output(/Fingerprint asked but neither the certificate, nor the certificate request have been issued/).to_stderr
+          @puppetd.fingerprint
+        }.to exit_with(1)
+         .and output(/Fingerprint asked but neither the certificate, nor the certificate request have been issued/).to_stderr
       end
 
       it "should log an error if an exception occurs" do

data/spec/unit/application/face_base_spec.rb

@@ -423,16 +423,18 @@ EOT
     it "should work if asked to render json" do
       allow(app.command_line).to receive(:args).and_return(%w{count_args a b c --render-as json})
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/3/)
+        app.run
+      }.to exit_with(0)
+       .and output(/3/).to_stdout
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       allow(app.command_line).to receive(:args).and_return(%w{with_s_rendering_hook --render-as s})
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/you invoked the 's' rendering hook/)
+        app.run
+      }.to exit_with(0)
+       .and output(/you invoked the 's' rendering hook/).to_stdout
     end
   end