puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/provider/exec_spec.rb

@@ -1,12 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/exec'
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
 
 describe Puppet::Provider::Exec do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-
   describe "#extractexe" do
     it "should return the first element of an array" do
       expect(subject.extractexe(['one', 'two'])).to eq('one')
@@ -36,208 +32,4 @@ describe Puppet::Provider::Exec do
       end
     end
   end
-
-  context "when handling sensitive data" do
-    before :each do
-      Puppet[:log_level] = 'debug'
-    end
-
-    let(:supersecret) { 'supersecret' }
-    let(:path) do
-      if Puppet::Util::Platform.windows?
-        # The `apply_compiled_manifest` helper doesn't add the `path` fact, so
-        # we can't reference that in our manifest. Windows PATHs can contain
-        # double quotes and trailing backslashes, which confuse HEREDOC
-        # interpolation below. So sanitize it:
-        ENV['PATH'].split(File::PATH_SEPARATOR).map do |dir|
-          dir.gsub(/"/, '\"').gsub(/\\$/, '')
-        end.join(File::PATH_SEPARATOR)
-      else
-        ENV['PATH']
-      end
-    end
-
-    def ruby_exit_0
-      "ruby -e 'exit 0'"
-    end
-
-    def echo_from_ruby_exit_0(message)
-      # Escape double quotes due to HEREDOC interpolation below
-      "ruby -e 'puts \"#{message}\"; exit 0'".gsub(/"/, '\"')
-    end
-
-    def echo_from_ruby_exit_1(message)
-      # Escape double quotes due to HEREDOC interpolation below
-      "ruby -e 'puts \"#{message}\"; exit 1'".gsub(/"/, '\"')
-    end
-
-    context "when validating the command" do
-      it "redacts the arguments if the command is relative" do
-        expect {
-          apply_compiled_manifest(<<-MANIFEST)
-            exec { 'echo':
-              command => Sensitive.new('echo #{supersecret}')
-            }
-          MANIFEST
-        }.to raise_error do |err|
-          expect(err).to be_a(Puppet::Error)
-          expect(err.message).to match(/'echo' is not qualified and no path was specified. Please qualify the command or specify a path./)
-          expect(err.message).to_not match(/#{supersecret}/)
-        end
-      end
-
-      it "redacts the arguments if the command is a directory" do
-        dir = tmpdir('exec')
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{dir} #{supersecret}'),
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{dir}' is a directory, not a file/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-
-      it "redacts the arguments if the command isn't executable" do
-        file = tmpfile('exec')
-        Puppet::FileSystem.touch(file)
-        Puppet::FileSystem.chmod(0644, file)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{file} #{supersecret}'),
-          }
-        MANIFEST
-        # Execute permission works differently on Windows, but execute will fail since the
-        # file doesn't have a valid extension and isn't a valid executable. The raised error
-        # will be Errno::EIO, which is not useful. The Windows execute code needs to raise
-        # Puppet::Util::Windows::Error so the Win32 error message is preserved.
-        pending("PUP-3561 Needs to raise a meaningful Puppet::Error") if Puppet::Util::Platform.windows?
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{file}' is not executable/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-
-      it "redacts the arguments if the relative command cannot be resolved using the path parameter" do
-        file = File.basename(tmpfile('exec'))
-        dir = tmpdir('exec')
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{file} #{supersecret}'),
-            path    => "#{dir}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /Could not find command '#{file}'/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-    end
-
-    it "redacts the command on success" do
-      command = echo_from_ruby_exit_0(supersecret)
-
-      apply_compiled_manifest(<<-MANIFEST)
-        exec { 'true':
-          command => Sensitive.new("#{command}"),
-          path    => "#{path}",
-        }
-      MANIFEST
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-      expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-    end
-
-    it "redacts the command on failure" do
-      command = echo_from_ruby_exit_1(supersecret)
-
-      apply_compiled_manifest(<<-MANIFEST)
-        exec { 'false':
-          command => Sensitive.new("#{command}"),
-          path    => "#{path}",
-        }
-      MANIFEST
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[false\]/))
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-      expect(@logs).to include(an_object_having_attributes(level: :err, message: "[command redacted] returned 1 instead of one of [0]"))
-      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-    end
-
-    context "when handling checks" do
-      let(:onlyifsecret) { "onlyifsecret" }
-      let(:unlesssecret) { "unlesssecret" }
-
-      it "redacts command and onlyif outputs" do
-        onlyif = echo_from_ruby_exit_0(onlyifsecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{ruby_exit_0}"),
-            onlyif  => Sensitive.new("#{onlyif}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
-      end
-
-      it "redacts the command that would have been executed but didn't due to onlyif" do
-        command = echo_from_ruby_exit_0(supersecret)
-        onlyif = echo_from_ruby_exit_1(onlyifsecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{command}"),
-            onlyif  => Sensitive.new("#{onlyif}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'onlyif'"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
-      end
-
-      it "redacts command and unless outputs" do
-        unlesscmd = echo_from_ruby_exit_1(unlesssecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{ruby_exit_0}"),
-            unless  => Sensitive.new("#{unlesscmd}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
-      end
-
-      it "redacts the command that would have been executed but didn't due to unless" do
-        command = echo_from_ruby_exit_0(supersecret)
-        unlesscmd = echo_from_ruby_exit_0(unlesssecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{command}"),
-            unless  => Sensitive.new("#{unlesscmd}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'unless'"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
-      end
-    end
-  end
 end

data/spec/unit/provider/file/posix_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix? do
@@ -39,7 +41,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#uid2name" do
     it "should return the name of the user identified by the id" do
-      allow(Etc).to receive(:getpwuid).with(501).and_return(Struct::Passwd.new('jilluser', nil, 501))
+      Etc.stubs(:getpwuid).with(501).returns(Struct::Passwd.new('jilluser', nil, 501))
 
       expect(provider.uid2name(501)).to eq('jilluser')
     end
@@ -53,7 +55,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return nil if the user doesn't exist" do
-      expect(Etc).to receive(:getpwuid).and_raise(ArgumentError, "can't find user for 999")
+      Etc.expects(:getpwuid).raises(ArgumentError, "can't find user for 999")
 
       expect(provider.uid2name(999)).to eq(nil)
     end
@@ -63,8 +65,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the id of the user if it exists" do
       passwd = Struct::Passwd.new('bobbo', nil, 502)
 
-      allow(Etc).to receive(:getpwnam).with('bobbo').and_return(passwd)
-      allow(Etc).to receive(:getpwuid).with(502).and_return(passwd)
+      Etc.stubs(:getpwnam).with('bobbo').returns(passwd)
+      Etc.stubs(:getpwuid).with(502).returns(passwd)
 
       expect(provider.name2uid('bobbo')).to eq(502)
     end
@@ -74,7 +76,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return false if the user doesn't exist" do
-      allow(Etc).to receive(:getpwnam).with('chuck').and_raise(ArgumentError, "can't find user for chuck")
+      Etc.stubs(:getpwnam).with('chuck').raises(ArgumentError, "can't find user for chuck")
 
       expect(provider.name2uid('chuck')).to eq(false)
     end
@@ -93,8 +95,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should warn and return :silly if the value is beyond the maximum uid" do
-      stat = double('stat', :uid => Puppet[:maximum_uid] + 1)
-      allow(resource).to receive(:stat).and_return(stat)
+      stat = stub('stat', :uid => Puppet[:maximum_uid] + 1)
+      resource.stubs(:stat).returns(stat)
 
       expect(provider.owner).to eq(:silly)
       expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
@@ -103,27 +105,27 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#owner=" do
     it "should set the owner but not the group of the file" do
-      expect(File).to receive(:lchown).with(15, nil, resource[:path])
+      File.expects(:lchown).with(15, nil, resource[:path])
 
       provider.owner = 15
     end
 
     it "should chown a link if managing links" do
       resource[:links] = :manage
-      expect(File).to receive(:lchown).with(20, nil, resource[:path])
+      File.expects(:lchown).with(20, nil, resource[:path])
 
       provider.owner = 20
     end
 
     it "should chown a link target if following links" do
       resource[:links] = :follow
-      expect(File).to receive(:chown).with(20, nil, resource[:path])
+      File.expects(:chown).with(20, nil, resource[:path])
 
       provider.owner = 20
     end
 
     it "should pass along any error encountered setting the owner" do
-      expect(File).to receive(:lchown).and_raise(ArgumentError)
+      File.expects(:lchown).raises(ArgumentError)
 
       expect { provider.owner = 25 }.to raise_error(Puppet::Error, /Failed to set owner to '25'/)
     end
@@ -131,7 +133,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#gid2name" do
     it "should return the name of the group identified by the id" do
-      allow(Etc).to receive(:getgrgid).with(501).and_return(Struct::Passwd.new('unicorns', nil, nil, 501))
+      Etc.stubs(:getgrgid).with(501).returns(Struct::Passwd.new('unicorns', nil, nil, 501))
 
       expect(provider.gid2name(501)).to eq('unicorns')
     end
@@ -145,7 +147,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return nil if the group doesn't exist" do
-      expect(Etc).to receive(:getgrgid).and_raise(ArgumentError, "can't find group for 999")
+      Etc.expects(:getgrgid).raises(ArgumentError, "can't find group for 999")
 
       expect(provider.gid2name(999)).to eq(nil)
     end
@@ -155,8 +157,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the id of the group if it exists" do
       passwd = Struct::Passwd.new('penguins', nil, nil, 502)
 
-      allow(Etc).to receive(:getgrnam).with('penguins').and_return(passwd)
-      allow(Etc).to receive(:getgrgid).with(502).and_return(passwd)
+      Etc.stubs(:getgrnam).with('penguins').returns(passwd)
+      Etc.stubs(:getgrgid).with(502).returns(passwd)
 
       expect(provider.name2gid('penguins')).to eq(502)
     end
@@ -166,7 +168,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return false if the group doesn't exist" do
-      allow(Etc).to receive(:getgrnam).with('wombats').and_raise(ArgumentError, "can't find group for wombats")
+      Etc.stubs(:getgrnam).with('wombats').raises(ArgumentError, "can't find group for wombats")
 
       expect(provider.name2gid('wombats')).to eq(false)
     end
@@ -186,8 +188,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should warn and return :silly if the value is beyond the maximum gid" do
-      stat = double('stat', :gid => Puppet[:maximum_uid] + 1)
-      allow(resource).to receive(:stat).and_return(stat)
+      stat = stub('stat', :gid => Puppet[:maximum_uid] + 1)
+      resource.stubs(:stat).returns(stat)
 
       expect(provider.group).to eq(:silly)
       expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
@@ -196,27 +198,27 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#group=" do
     it "should set the group but not the owner of the file" do
-      expect(File).to receive(:lchown).with(nil, 15, resource[:path])
+      File.expects(:lchown).with(nil, 15, resource[:path])
 
       provider.group = 15
     end
 
     it "should change the group for a link if managing links" do
       resource[:links] = :manage
-      expect(File).to receive(:lchown).with(nil, 20, resource[:path])
+      File.expects(:lchown).with(nil, 20, resource[:path])
 
       provider.group = 20
     end
 
     it "should change the group for a link target if following links" do
       resource[:links] = :follow
-      expect(File).to receive(:chown).with(nil, 20, resource[:path])
+      File.expects(:chown).with(nil, 20, resource[:path])
 
       provider.group = 20
     end
 
     it "should pass along any error encountered setting the group" do
-      expect(File).to receive(:lchown).and_raise(ArgumentError)
+      File.expects(:lchown).raises(ArgumentError)
 
       expect { provider.group = 25 }.to raise_error(Puppet::Error, /Failed to set group to '25'/)
     end

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

@@ -1,12 +1,14 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
-if Puppet.features.microsoft_windows?
+if Puppet::Util::Platform.windows?
   require 'puppet/util/windows'
   class WindowsSecurity
     extend Puppet::Util::Windows::Security
   end
 end
 
-describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:file).provider(:windows), :if => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
   let(:path) { tmpfile('windows_file_spec') }
@@ -47,22 +49,22 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#id2name" do
     it "should return the name of the user identified by the sid" do
-      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(sid).and_return(true)
-      expect(Puppet::Util::Windows::SID).to receive(:sid_to_name).with(sid).and_return(account)
+      Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
+      Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(account)
 
       expect(provider.id2name(sid)).to eq(account)
     end
 
     it "should return the argument if it's already a name" do
-      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(account).and_return(false)
-      expect(Puppet::Util::Windows::SID).not_to receive(:sid_to_name)
+      Puppet::Util::Windows::SID.expects(:valid_sid?).with(account).returns(false)
+      Puppet::Util::Windows::SID.expects(:sid_to_name).never
 
       expect(provider.id2name(account)).to eq(account)
     end
 
     it "should return nil if the user doesn't exist" do
-      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(sid).and_return(true)
-      expect(Puppet::Util::Windows::SID).to receive(:sid_to_name).with(sid).and_return(nil)
+      Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
+      Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(nil)
 
       expect(provider.id2name(sid)).to eq(nil)
     end
@@ -70,7 +72,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#name2id" do
     it "should delegate to name_to_sid" do
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with(account).and_return(sid)
+      Puppet::Util::Windows::SID.expects(:name_to_sid).with(account).returns(sid)
 
       expect(provider.name2id(account)).to eq(sid)
     end
@@ -79,7 +81,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   describe "#owner" do
     it "should return the sid of the owner if the file does exist" do
       FileUtils.touch(resource[:path])
-      allow(provider).to receive(:get_owner).with(resource[:path]).and_return(sid)
+      provider.stubs(:get_owner).with(resource[:path]).returns(sid)
 
       expect(provider.owner).to eq(sid)
     end
@@ -91,12 +93,12 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#owner=" do
     it "should set the owner to the specified value" do
-      expect(provider).to receive(:set_owner).with(sid, resource[:path])
+      provider.expects(:set_owner).with(sid, resource[:path])
       provider.owner = sid
     end
 
     it "should propagate any errors encountered when setting the owner" do
-      allow(provider).to receive(:set_owner).and_raise(ArgumentError)
+      provider.stubs(:set_owner).raises(ArgumentError)
 
       expect {
         provider.owner = sid
@@ -107,7 +109,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   describe "#group" do
     it "should return the sid of the group if the file does exist" do
       FileUtils.touch(resource[:path])
-      allow(provider).to receive(:get_group).with(resource[:path]).and_return(sid)
+      provider.stubs(:get_group).with(resource[:path]).returns(sid)
 
       expect(provider.group).to eq(sid)
     end
@@ -119,12 +121,12 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#group=" do
     it "should set the group to the specified value" do
-      expect(provider).to receive(:set_group).with(sid, resource[:path])
+      provider.expects(:set_group).with(sid, resource[:path])
       provider.group = sid
     end
 
     it "should propagate any errors encountered when setting the group" do
-      allow(provider).to receive(:set_group).and_raise(ArgumentError)
+      provider.stubs(:set_group).raises(ArgumentError)
 
       expect {
         provider.group = sid
@@ -135,7 +137,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   describe "when validating" do
     {:owner => 'foo', :group => 'foo', :mode => '0777'}.each do |k,v|
       it "should fail if the filesystem doesn't support ACLs and we're managing #{k}" do
-        allow_any_instance_of(described_class).to receive(:supports_acl?).and_return(false)
+        described_class.any_instance.stubs(:supports_acl?).returns false
 
         expect {
           Puppet::Type.type(:file).new :path => path, k => v
@@ -144,7 +146,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
     end
 
     it "should not fail if the filesystem doesn't support ACLs and we're not managing permissions" do
-      allow_any_instance_of(described_class).to receive(:supports_acl?).and_return(false)
+      described_class.any_instance.stubs(:supports_acl?).returns false
 
       Puppet::Type.type(:file).new :path => path
     end