puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/util/command_line_spec.rb

@@ -11,57 +11,50 @@ describe Puppet::Util::CommandLine do
     it "should pull off the first argument if it looks like a subcommand" do
       command_line = Puppet::Util::CommandLine.new("puppet", %w{ client --help whatever.pp })
 
-      command_line.subcommand_name.should == "client"
-      command_line.args.should            == %w{ --help whatever.pp }
+      expect(command_line.subcommand_name).to eq("client")
+      expect(command_line.args).to            eq(%w{ --help whatever.pp })
     end
 
     it "should return nil if the first argument looks like a .pp file" do
       command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.pp })
 
-      command_line.subcommand_name.should == nil
-      command_line.args.should            == %w{ whatever.pp }
-    end
-
-    it "should return nil if the first argument looks like a .rb file" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.rb })
-
-      command_line.subcommand_name.should == nil
-      command_line.args.should            == %w{ whatever.rb }
+      expect(command_line.subcommand_name).to eq(nil)
+      expect(command_line.args).to            eq(%w{ whatever.pp })
     end
 
     it "should return nil if the first argument looks like a flag" do
       command_line = Puppet::Util::CommandLine.new("puppet", %w{ --debug })
 
-      command_line.subcommand_name.should == nil
-      command_line.args.should            == %w{ --debug }
+      expect(command_line.subcommand_name).to eq(nil)
+      expect(command_line.args).to            eq(%w{ --debug })
     end
 
     it "should return nil if the first argument is -" do
       command_line = Puppet::Util::CommandLine.new("puppet", %w{ - })
 
-      command_line.subcommand_name.should == nil
-      command_line.args.should            == %w{ - }
+      expect(command_line.subcommand_name).to eq(nil)
+      expect(command_line.args).to            eq(%w{ - })
     end
 
     it "should return nil if the first argument is --help" do
       command_line = Puppet::Util::CommandLine.new("puppet", %w{ --help })
 
-      command_line.subcommand_name.should == nil
+      expect(command_line.subcommand_name).to eq(nil)
     end
 
 
     it "should return nil if there are no arguments" do
       command_line = Puppet::Util::CommandLine.new("puppet", [])
 
-      command_line.subcommand_name.should == nil
-      command_line.args.should            == []
+      expect(command_line.subcommand_name).to eq(nil)
+      expect(command_line.args).to            eq([])
     end
 
     it "should pick up changes to the array of arguments" do
       args = %w{subcommand}
       command_line = Puppet::Util::CommandLine.new("puppet", args)
       args[0] = 'different_subcommand'
-      command_line.subcommand_name.should == 'different_subcommand'
+      expect(command_line.subcommand_name).to eq('different_subcommand')
     end
   end
 
@@ -78,7 +71,7 @@ describe Puppet::Util::CommandLine do
   describe "when dealing with puppet commands" do
     it "should return the executable name if it is not puppet" do
       command_line = Puppet::Util::CommandLine.new("puppetmasterd", [])
-      command_line.subcommand_name.should == "puppetmasterd"
+      expect(command_line.subcommand_name).to eq("puppetmasterd")
     end
 
     describe "when the subcommand is not implemented" do
@@ -93,10 +86,6 @@ describe Puppet::Util::CommandLine do
       end
 
       describe "and an external implementation cannot be found" do
-        before :each do
-          Puppet::Util::CommandLine::UnknownSubcommand.any_instance.stubs(:console_has_color?).returns false
-        end
-
         it "should abort and show the usage message" do
           Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
           commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
@@ -131,23 +120,6 @@ describe Puppet::Util::CommandLine do
       end
     end
 
-    describe 'when loading commands' do
-      it "should deprecate the available_subcommands instance method" do
-        Puppet::Application.expects(:available_application_names)
-        Puppet.expects(:deprecation_warning).with("Puppet::Util::CommandLine#available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.")
-
-        command_line = Puppet::Util::CommandLine.new("foo", %w{ client --help whatever.pp })
-        command_line.available_subcommands
-      end
-
-      it "should deprecate the available_subcommands class method" do
-        Puppet::Application.expects(:available_application_names)
-        Puppet.expects(:deprecation_warning).with("Puppet::Util::CommandLine.available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.")
-
-        Puppet::Util::CommandLine.available_subcommands
-      end
-    end
-
     describe 'when setting process priority' do
       let(:command_line) do
         Puppet::Util::CommandLine.new("puppet", %w{ agent })

data/spec/unit/util/command_line_utils/puppet_option_parser_spec.rb

@@ -76,7 +76,7 @@ describe Puppet::Util::CommandLine::PuppetOptionParser do
 
     option_parser.parse(args)
 
-    args.length.should == 1
+    expect(args.length).to eq(1)
   end
 
   # The ruby stdlib OptionParser has an awesome "feature" that you cannot disable, whereby if
@@ -124,6 +124,6 @@ describe Puppet::Util::CommandLine::PuppetOptionParser do
 
     option_parser.parse(arguments)
 
-    seen_value.should == expected_value
+    expect(seen_value).to eq(expected_value)
   end
 end

data/spec/unit/util/constant_inflector_spec.rb

@@ -5,52 +5,52 @@ require 'puppet/util/constant_inflector'
 
 describe Puppet::Util::ConstantInflector, "when converting file names to constants" do
   it "should capitalize terms" do
-    subject.file2constant("file").should == "File"
+    expect(subject.file2constant("file")).to eq("File")
   end
 
   it "should switch all '/' characters to double colons" do
-    subject.file2constant("file/other").should == "File::Other"
+    expect(subject.file2constant("file/other")).to eq("File::Other")
   end
 
   it "should remove underscores and capitalize the proceeding letter" do
-    subject.file2constant("file_other").should == "FileOther"
+    expect(subject.file2constant("file_other")).to eq("FileOther")
   end
 
   it "should correctly replace as many underscores as exist in the file name" do
-    subject.file2constant("two_under_scores/with_some_more_underscores").should == "TwoUnderScores::WithSomeMoreUnderscores"
+    expect(subject.file2constant("two_under_scores/with_some_more_underscores")).to eq("TwoUnderScores::WithSomeMoreUnderscores")
   end
 
   it "should collapse multiple underscores" do
-    subject.file2constant("many___scores").should == "ManyScores"
+    expect(subject.file2constant("many___scores")).to eq("ManyScores")
   end
 
   it "should correctly handle file names deeper than two directories" do
-    subject.file2constant("one_two/three_four/five_six").should == "OneTwo::ThreeFour::FiveSix"
+    expect(subject.file2constant("one_two/three_four/five_six")).to eq("OneTwo::ThreeFour::FiveSix")
   end
 end
 
 describe Puppet::Util::ConstantInflector, "when converting constnats to file names" do
   it "should convert them to a string if necessary" do
-    subject.constant2file(Puppet::Util::ConstantInflector).should be_instance_of(String)
+    expect(subject.constant2file(Puppet::Util::ConstantInflector)).to be_instance_of(String)
   end
 
   it "should accept string inputs" do
-    subject.constant2file("Puppet::Util::ConstantInflector").should be_instance_of(String)
+    expect(subject.constant2file("Puppet::Util::ConstantInflector")).to be_instance_of(String)
   end
 
   it "should downcase all terms" do
-    subject.constant2file("Puppet").should == "puppet"
+    expect(subject.constant2file("Puppet")).to eq("puppet")
   end
 
   it "should convert '::' to '/'" do
-    subject.constant2file("Puppet::Util::Constant").should == "puppet/util/constant"
+    expect(subject.constant2file("Puppet::Util::Constant")).to eq("puppet/util/constant")
   end
 
   it "should convert mid-word capitalization to an underscore" do
-    subject.constant2file("OneTwo::ThreeFour").should == "one_two/three_four"
+    expect(subject.constant2file("OneTwo::ThreeFour")).to eq("one_two/three_four")
   end
 
   it "should correctly handle constants with more than two parts" do
-    subject.constant2file("OneTwoThree::FourFiveSixSeven").should == "one_two_three/four_five_six_seven"
+    expect(subject.constant2file("OneTwoThree::FourFiveSixSeven")).to eq("one_two_three/four_five_six_seven")
   end
 end

data/spec/unit/util/diff_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Util::Diff do
       Puppet[:diff_args] = 'bar'
 
       Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
-      subject.diff('a', 'b').should == 'baz'
+      expect(subject.diff('a', 'b')).to eq('baz')
     end
 
     it "should execute the diff command with multiple arguments" do
@@ -18,7 +18,7 @@ describe Puppet::Util::Diff do
       Puppet[:diff_args] = 'bar qux'
 
       Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'qux', 'a', 'b'], anything).returns('baz')
-      subject.diff('a', 'b').should == 'baz'
+      expect(subject.diff('a', 'b')).to eq('baz')
     end
 
     it "should omit diff arguments if none are specified" do
@@ -26,14 +26,14 @@ describe Puppet::Util::Diff do
       Puppet[:diff_args] = ''
 
       Puppet::Util::Execution.expects(:execute).with(['foo', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
-      subject.diff('a', 'b').should == 'baz'
+      expect(subject.diff('a', 'b')).to eq('baz')
     end
 
     it "should return empty string if the diff command is empty" do
       Puppet[:diff] = ''
 
       Puppet::Util::Execution.expects(:execute).never
-      subject.diff('a', 'b').should == ''
+      expect(subject.diff('a', 'b')).to eq('')
     end
   end
 end

data/spec/unit/util/errors_spec.rb

@@ -14,24 +14,24 @@ describe Puppet::Util::Errors do
   end
 
   it "should provide a 'fail' method" do
-    @tester.should respond_to(:fail)
+    expect(@tester).to respond_to(:fail)
   end
 
   it "should provide a 'devfail' method" do
-    @tester.should respond_to(:devfail)
+    expect(@tester).to respond_to(:devfail)
   end
 
   it "should raise any provided error when failing" do
-    lambda { @tester.fail(Puppet::ParseError, "stuff") }.should raise_error(Puppet::ParseError)
+    expect { @tester.fail(Puppet::ParseError, "stuff") }.to raise_error(Puppet::ParseError)
   end
 
   it "should default to Puppet::Error when failing" do
-    lambda { @tester.fail("stuff") }.should raise_error(Puppet::Error)
+    expect { @tester.fail("stuff") }.to raise_error(Puppet::Error)
   end
 
   it "should have a method for converting error context into a string" do
     @tester.file = "/my/file"
     @tester.line = 50
-    @tester.error_context.should == " at /my/file:50"
+    expect(@tester.error_context).to eq(" at /my/file:50")
   end
 end

data/spec/unit/util/execution_spec.rb

@@ -69,8 +69,8 @@ describe Puppet::Util::Execution do
 
         # we will get some fairly useless output if we just use the raw == operator on the hashes here, so we'll
         #  be a bit more explicit and laborious in the name of making the error more useful...
-        @saved_env.each_pair { |key,val| cur_env[key].should == val }
-        (cur_env.keys - @saved_env.keys).should == []
+        @saved_env.each_pair { |key,val| expect(cur_env[key]).to eq(val) }
+        expect(cur_env.keys - @saved_env.keys).to eq([])
 
       end
 
@@ -116,7 +116,7 @@ describe Puppet::Util::Execution do
       end
 
       it "should return the pid of the child process" do
-        call_exec_posix('test command', {}, @stdin, @stdout, @stderr).should == pid
+        expect(call_exec_posix('test command', {}, @stdin, @stdout, @stderr)).to eq(pid)
       end
     end
 
@@ -141,7 +141,7 @@ describe Puppet::Util::Execution do
       end
 
       it "should return the process info of the child process" do
-        call_exec_windows('test command', {}, @stdin, @stdout, @stderr).should == proc_info_stub
+        expect(call_exec_windows('test command', {}, @stdin, @stdout, @stderr)).to eq(proc_info_stub)
       end
 
       it "should quote arguments containing spaces if command is specified as an array" do
@@ -166,7 +166,7 @@ describe Puppet::Util::Execution do
         end
 
         it "should call the block on the stub" do
-          Puppet::Util::Execution.execute("/usr/bin/run_my_execute_stub").should == "execution stub output"
+          expect(Puppet::Util::Execution.execute("/usr/bin/run_my_execute_stub")).to eq("execution stub output")
         end
 
         it "should not actually execute anything" do
@@ -313,7 +313,7 @@ describe Puppet::Util::Execution do
           stub_process_wait(real_exit_status)
           $CHILD_STATUS.stubs(:exitstatus).returns(real_exit_status % 256) # The exitstatus is changed to be mod 256 so that ruby can fit it into 8 bits.
 
-          Puppet::Util::Execution.execute('test command', :failonfail => false).exitstatus.should == real_exit_status
+          expect(Puppet::Util::Execution.execute('test command', :failonfail => false).exitstatus).to eq(real_exit_status)
         end
       end
     end
@@ -334,8 +334,8 @@ describe Puppet::Util::Execution do
         cur_env = ENV.to_hash
         # we will get some fairly useless output if we just use the raw == operator on the hashes here, so we'll
         #  be a bit more explicit and laborious in the name of making the error more useful...
-        @saved_env.each_pair { |key,val| cur_env[key].should == val }
-        (cur_env.keys - @saved_env.keys).should == []
+        @saved_env.each_pair { |key,val| expect(cur_env[key]).to eq(val) }
+        expect(cur_env.keys - @saved_env.keys).to eq([])
       end
 
 
@@ -358,7 +358,7 @@ describe Puppet::Util::Execution do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             # we expect that all of the POSIX vars will have been cleared except for LANG and LC_ALL
             expected_value = (['LANG', 'LC_ALL'].include?(var)) ? "C" : ""
-            Puppet::Util::execute(get_env_var_cmd % var).strip.should == expected_value
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var).strip).to eq(expected_value)
           end
         end
       end
@@ -370,7 +370,7 @@ describe Puppet::Util::Execution do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             # we expect that all of the POSIX vars will have been cleared except for LANG and LC_ALL
             expected_value = (['LANG', 'LC_ALL'].include?(var)) ? "C" : ""
-            Puppet::Util::execute(get_env_var_cmd % var, {:override_locale => true}).strip.should == expected_value
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var, {:override_locale => true}).strip).to eq(expected_value)
           end
         end
       end
@@ -380,7 +380,7 @@ describe Puppet::Util::Execution do
         # execute is not setting them.
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            Puppet::Util::execute(get_env_var_cmd % var, {:override_locale => false}).strip.should == lang_sentinel_value
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var, {:override_locale => false}).strip).to eq(lang_sentinel_value)
           end
         end
       end
@@ -392,19 +392,19 @@ describe Puppet::Util::Execution do
           orig_env_vals[var] = ENV[var]
         end
         # now we can really execute any command--doesn't matter what it is...
-        Puppet::Util::execute(get_env_var_cmd % 'anything', {:override_locale => true})
+        Puppet::Util::Execution.execute(get_env_var_cmd % 'anything', {:override_locale => true})
         # now we check and make sure the original environment was restored
         Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-          ENV[var].should == orig_env_vals[var]
+          expect(ENV[var]).to eq(orig_env_vals[var])
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(locale_sentinel_env) do
           # now we can really execute any command--doesn't matter what it is...
-          Puppet::Util::execute(get_env_var_cmd % 'anything', {:override_locale => true})
+          Puppet::Util::Execution.execute(get_env_var_cmd % 'anything', {:override_locale => true})
           # now we check and make sure the original environment was restored
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            ENV[var].should == locale_sentinel_env[var]
+            expect(ENV[var]).to eq(locale_sentinel_env[var])
           end
         end
 
@@ -431,13 +431,13 @@ describe Puppet::Util::Execution do
           # with this environment, we loop over the vars in question
           Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
             # ensure that our temporary environment is set up as we expect
-            ENV[var].should == user_sentinel_env[var]
+            expect(ENV[var]).to eq(user_sentinel_env[var])
 
             # run an "exec" via the provider and ensure that it unsets the vars
-            Puppet::Util::execute(get_env_var_cmd % var).strip.should == ""
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var).strip).to eq("")
 
             # ensure that after the exec, our temporary env is still intact
-            ENV[var].should == user_sentinel_env[var]
+            expect(ENV[var]).to eq(user_sentinel_env[var])
           end
 
         end
@@ -450,25 +450,70 @@ describe Puppet::Util::Execution do
           orig_env_vals[var] = ENV[var]
         end
         # now we can really execute any command--doesn't matter what it is...
-        Puppet::Util::execute(get_env_var_cmd % 'anything')
+        Puppet::Util::Execution.execute(get_env_var_cmd % 'anything')
         # now we check and make sure the original environment was restored
         Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
-          ENV[var].should == orig_env_vals[var]
+          expect(ENV[var]).to eq(orig_env_vals[var])
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(user_sentinel_env) do
           # now we can really execute any command--doesn't matter what it is...
-          Puppet::Util::execute(get_env_var_cmd % 'anything')
+          Puppet::Util::Execution.execute(get_env_var_cmd % 'anything')
           # now we check and make sure the original environment was restored
           Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
-            ENV[var].should == user_sentinel_env[var]
+            expect(ENV[var]).to eq(user_sentinel_env[var])
           end
         end
 
       end
     end
 
+    describe "#execute (debug logging)" do
+      before :each do
+        stub_process_wait(0)
+
+        if Puppet.features.microsoft_windows?
+          Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
+        else
+          Puppet::Util::Execution.stubs(:execute_posix).returns(pid)
+        end
+      end
+
+      it "should log if no uid or gid specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello')
+      end
+      it "should log numeric uid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=100: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 100})
+      end
+      it "should log numeric gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with gid=500: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:gid => 500})
+      end
+      it "should log numeric uid and gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=100 gid=500: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 100, :gid => 500})
+      end
+      it "should log string uid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=myuser: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 'myuser'})
+      end
+      it "should log string gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with gid=mygroup: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:gid => 'mygroup'})
+      end
+      it "should log string uid and gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=myuser gid=mygroup: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 'myuser', :gid => 'mygroup'})
+      end
+      it "should log numeric uid and string gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=100 gid=mygroup: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 100, :gid => 'mygroup'})
+      end
+    end
+
     describe "after execution" do
       before :each do
         stub_process_wait(0)
@@ -505,7 +550,7 @@ describe Puppet::Util::Execution do
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
-        Puppet::Util::Execution.execute('test command').should == "My expected command output"
+        expect(Puppet::Util::Execution.execute('test command')).to eq("My expected command output")
       end
 
       it "should not read the output if squelch is true" do
@@ -513,7 +558,7 @@ describe Puppet::Util::Execution do
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
-        Puppet::Util::Execution.execute('test command', :squelch => true).should == ''
+        expect(Puppet::Util::Execution.execute('test command', :squelch => true)).to eq('')
       end
 
       it "should delete the file used for output if squelch is false" do
@@ -523,7 +568,7 @@ describe Puppet::Util::Execution do
 
         Puppet::Util::Execution.execute('test command')
 
-        Puppet::FileSystem.exist?(path).should be_false
+        expect(Puppet::FileSystem.exist?(path)).to be_falsey
       end
 
       it "should not raise an error if the file is open" do
@@ -531,7 +576,7 @@ describe Puppet::Util::Execution do
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         file = File.new(stdout.path, 'r')
 
-        Puppet::Util.execute('test command')
+        Puppet::Util::Execution.execute('test command')
       end
 
       it "should raise an error if failonfail is true and the child failed" do
@@ -592,7 +637,7 @@ describe Puppet::Util::Execution do
     it "should execute a string as a string" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
-      Puppet::Util::Execution.execpipe('echo hello').should == 'hello'
+      expect(Puppet::Util::Execution.execpipe('echo hello')).to eq('hello')
     end
 
     it "should print meaningful debug message for string argument" do
@@ -612,7 +657,7 @@ describe Puppet::Util::Execution do
     it "should execute an array by pasting together with spaces" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
-      Puppet::Util::Execution.execpipe(['echo', 'hello']).should == 'hello'
+      expect(Puppet::Util::Execution.execpipe(['echo', 'hello'])).to eq('hello')
     end
 
     it "should fail if asked to fail, and the child does" do
@@ -624,7 +669,7 @@ describe Puppet::Util::Execution do
 
     it "should not fail if asked not to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).returns('error message')
-      Puppet::Util::Execution.execpipe('echo hello', false).should == 'error message'
+      expect(Puppet::Util::Execution.execpipe('echo hello', false)).to eq('error message')
     end
   end
 end