puppet 6.0.10 → 6.1.0

data/spec/unit/provider/command_spec.rb

@@ -9,8 +9,8 @@ describe Puppet::Provider::Command do
   let(:executable) { "foo" }
   let(:executable_absolute_path) { "/foo/bar" }
 
-  let(:executor) { double('executor') }
-  let(:resolver) { double('resolver') }
+  let(:executor) { mock('executor') }
+  let(:resolver) { mock('resolver') }
 
   let(:path_resolves_to_itself) do
     resolves = Object.new
@@ -23,37 +23,37 @@ describe Puppet::Provider::Command do
   end
 
   it "executes a simple command" do
-    expect(executor).to receive(:execute).with([executable], no_options)
+    executor.expects(:execute).with([executable], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
     command.execute()
   end
 
   it "executes a command with extra options" do
-    expect(executor).to receive(:execute).with([executable], the_options)
+    executor.expects(:execute).with([executable], the_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor, the_options)
     command.execute()
   end
 
   it "executes a command with arguments" do
-    expect(executor).to receive(:execute).with([executable, "arg1", "arg2"], no_options)
+    executor.expects(:execute).with([executable, "arg1", "arg2"], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
     command.execute("arg1", "arg2")
   end
 
   it "resolves to an absolute path for better execution" do
-    expect(resolver).to receive(:which).with(executable).and_return(executable_absolute_path)
-    expect(executor).to receive(:execute).with([executable_absolute_path], no_options)
+    resolver.expects(:which).with(executable).returns(executable_absolute_path)
+    executor.expects(:execute).with([executable_absolute_path], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, resolver, executor)
     command.execute()
   end
 
   it "errors when the executable resolves to nothing" do
-    expect(resolver).to receive(:which).with(executable).and_return(nil)
-    expect(executor).not_to receive(:execute)
+    resolver.expects(:which).with(executable).returns(nil)
+    executor.expects(:execute).never
 
     command = Puppet::Provider::Command.new(name, executable, resolver, executor)
 

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix? do
@@ -50,7 +51,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
       it "should fail if the command isn't executable" do
         FileUtils.touch(command)
-        allow(File).to receive(:executable?).with(command).and_return(false)
+        File.stubs(:executable?).with(command).returns(false)
 
         expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is not executable")
       end
@@ -62,7 +63,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         provider.resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
-        expect(Puppet::Util::Execution).to receive(:execute).with(filename, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        Puppet::Util::Execution.expects(:execute).with(filename, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
         provider.run(filename)
       end
@@ -76,7 +77,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       it "should fail if the command is in the path but not executable" do
         command = make_exe
         File.chmod(0644, command)
-        allow(FileTest).to receive(:executable?).with(command).and_return(false)
+        FileTest.stubs(:executable?).with(command).returns(false)
         resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
@@ -93,7 +94,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.resource[:path] = ['/bogus/bin']
       command = make_exe
 
-      expect(Puppet::Util::Execution).to receive(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      Puppet::Util::Execution.expects(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
       provider.run("#{command} bar --sillyarg=true --blah")
     end
@@ -109,16 +110,40 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
       command = make_exe
 
-      expect(Puppet::Util::Execution).to receive(:execute).with(command, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
       provider.run(command)
 
       expect(@logs.map {|l| "#{l.level}: #{l.message}" }).to eq(["warning: Overriding environment setting 'WHATEVER' with '/foo'"])
     end
 
+    it "should warn when setting an empty environment variable" do
+      provider.resource[:environment] = ['WHATEVER=']
+      command = make_exe
+
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+      provider.run(command)
+
+      expect(@logs.map(&:to_s).join).to match(/Empty environment setting 'WHATEVER'\n\s+\(file & line not available\)/m)
+    end
+
+    it "should warn when setting an empty environment variable (within a manifest)" do
+      provider.resource[:environment] = ['WHATEVER=']
+      provider.resource.file = '/tmp/foobar'
+      provider.resource.line = 42
+      command = make_exe
+
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+      provider.run(command)
+
+      expect(@logs.map(&:to_s).join).to match(/Empty environment setting 'WHATEVER'\n\s+\(file: \/tmp\/foobar, line: 42\)/m)
+    end
+
     it "should set umask before execution if umask parameter is in use" do
       provider.resource[:umask] = '0027'
-      expect(Puppet::Util).to receive(:withumask).with(0027)
+      Puppet::Util.expects(:withumask).with(0027)
       provider.run(provider.resource[:command])
     end
 

data/spec/unit/provider/exec/shell_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:shell),

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

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet::Util::Platform.windows? do
@@ -66,12 +68,12 @@ describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet::Util::Platf
     describe "when the command is relative" do
       describe "and a path is specified" do
         before :each do
-          allow(provider).to receive(:which)
+          provider.stubs(:which)
         end
 
         it "should search for executables with no extension" do
           provider.resource[:path] = [File.expand_path('/bogus/bin')]
-          expect(provider).to receive(:which).with('foo').and_return('foo')
+          provider.expects(:which).with('foo').returns('foo')
 
           provider.checkexe('foo')
         end

data/spec/unit/provider/exec_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/exec'
 

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,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 if Puppet::Util::Platform.windows?
   require 'puppet/util/windows'
@@ -47,22 +49,22 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet::Util::Platf
 
   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::Util::Platf
 
   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::Util::Platf
   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::Util::Platf
 
   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::Util::Platf
   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::Util::Platf
 
   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::Util::Platf
   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::Util::Platf
     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

data/spec/unit/provider/group/aix_spec.rb

@@ -9,7 +9,6 @@ describe 'Puppet::Type::Group::Provider::Aix' do
       :ensure => :present
     )
   end
-
   let(:provider) do
     provider_class.new(resource)
   end
@@ -34,7 +33,7 @@ describe 'Puppet::Type::Group::Provider::Aix' do
     end
 
     before(:each) do
-      allow(provider_class).to receive(:list_all).with(ia_module_args).and_return(groups)
+      provider_class.stubs(:list_all).with(ia_module_args).returns(groups)
     end
 
     it 'raises an ArgumentError if the group does not exist' do
@@ -79,7 +78,7 @@ describe 'Puppet::Type::Group::Provider::Aix' do
       before(:each) do
         resource[:auth_membership] = false
 
-        allow(provider).to receive(:members).and_return(['user3', 'user1'])
+        provider.stubs(:members).returns(['user3', 'user1'])
       end
 
       it 'adds the passed-in members to the current list of members, filtering out any duplicates' do