puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/util/ssl_spec.rb

@@ -20,42 +20,42 @@ describe Puppet::Util::SSL do
     NO_PARTS = {}
 
     it "parses a DN with a single part" do
-      parse('CN=client.example.org').should be_a_subject_with({
+      expect(parse('CN=client.example.org')).to be_a_subject_with({
         'CN' => 'client.example.org'
       })
     end
 
     it "parses a DN with parts separated by slashes" do
-      parse('/CN=Root CA/OU=Server Operations/O=Example Org').should be_a_subject_with({
+      expect(parse('/CN=Root CA/OU=Server Operations/O=Example Org')).to be_a_subject_with({
         'CN' => 'Root CA',
         'OU' => 'Server Operations',
         'O'  => 'Example Org'
       })
     end
 
-    it "parses a DN with a single part preceeded by a slash" do
-      parse('/CN=client.example.org').should be_a_subject_with({
+    it "parses a DN with a single part preceded by a slash" do
+      expect(parse('/CN=client.example.org')).to be_a_subject_with({
         'CN' => 'client.example.org'
       })
     end
 
     it "parses a DN with parts separated by commas" do
-      parse('O=Foo\, Inc,CN=client2a.example.org').should be_a_subject_with({
+      expect(parse('O=Foo\, Inc,CN=client2a.example.org')).to be_a_subject_with({
         'O' => 'Foo, Inc',
         'CN' => 'client2a.example.org'
       })
     end
 
     it "finds no parts in something that is not a DN" do
-      parse('(no)').should be_a_subject_with(NO_PARTS)
+      expect(parse('(no)')).to be_a_subject_with(NO_PARTS)
     end
 
     it "finds no parts in a DN with an invalid part" do
-      parse('no=yes,CN=Root CA').should be_a_subject_with(NO_PARTS)
+      expect(parse('no=yes,CN=Root CA')).to be_a_subject_with(NO_PARTS)
     end
 
     it "finds no parts in an empty DN" do
-      parse('').should be_a_subject_with(NO_PARTS)
+      expect(parse('')).to be_a_subject_with(NO_PARTS)
     end
   end
 
@@ -66,26 +66,26 @@ describe Puppet::Util::SSL do
 
     it "should correctly parse a subject containing only a CN" do
       subj = parse('/CN=foo')
-      cn_from(subj).should == 'foo'
+      expect(cn_from(subj)).to eq('foo')
     end
 
     it "should correctly parse a subject containing other components" do
       subj = parse('/CN=Root CA/OU=Server Operations/O=Example Org')
-      cn_from(subj).should == 'Root CA'
+      expect(cn_from(subj)).to eq('Root CA')
     end
 
     it "should correctly parse a subject containing other components with CN not first" do
       subj = parse('/emailAddress=foo@bar.com/CN=foo.bar.com/O=Example Org')
-      cn_from(subj).should == 'foo.bar.com'
+      expect(cn_from(subj)).to eq('foo.bar.com')
     end
 
     it "should return nil for a subject with no CN" do
       subj = parse('/OU=Server Operations/O=Example Org')
-      cn_from(subj).should == nil
+      expect(cn_from(subj)).to eq(nil)
     end
 
     it "should return nil for a bare string" do
-      cn_from("/CN=foo").should == nil
+      expect(cn_from("/CN=foo")).to eq(nil)
     end
   end
 end

data/spec/unit/util/storage_spec.rb

@@ -14,20 +14,20 @@ describe Puppet::Util::Storage do
 
   describe "when caching a symbol" do
     it "should return an empty hash" do
-      Puppet::Util::Storage.cache(:yayness).should == {}
-      Puppet::Util::Storage.cache(:more_yayness).should == {}
+      expect(Puppet::Util::Storage.cache(:yayness)).to eq({})
+      expect(Puppet::Util::Storage.cache(:more_yayness)).to eq({})
     end
 
     it "should add the symbol to its internal state" do
       Puppet::Util::Storage.cache(:yayness)
-      Puppet::Util::Storage.state.should == {:yayness=>{}}
+      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     end
 
     it "should not clobber existing state when caching additional objects" do
       Puppet::Util::Storage.cache(:yayness)
-      Puppet::Util::Storage.state.should == {:yayness=>{}}
+      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
       Puppet::Util::Storage.cache(:bubblyness)
-      Puppet::Util::Storage.state.should == {:yayness=>{},:bubblyness=>{}}
+      expect(Puppet::Util::Storage.state).to eq({:yayness=>{},:bubblyness=>{}})
     end
   end
 
@@ -38,16 +38,16 @@ describe Puppet::Util::Storage do
     end
 
     it "should return an empty hash" do
-      Puppet::Util::Storage.cache(@file_test).should == {}
-      Puppet::Util::Storage.cache(@exec_test).should == {}
+      expect(Puppet::Util::Storage.cache(@file_test)).to eq({})
+      expect(Puppet::Util::Storage.cache(@exec_test)).to eq({})
     end
 
     it "should add the resource ref to its internal state" do
-      Puppet::Util::Storage.state.should == {}
+      expect(Puppet::Util::Storage.state).to eq({})
       Puppet::Util::Storage.cache(@file_test)
-      Puppet::Util::Storage.state.should == {"File[#{@basepath}/yayness]"=>{}}
+      expect(Puppet::Util::Storage.state).to eq({"File[#{@basepath}/yayness]"=>{}})
       Puppet::Util::Storage.cache(@exec_test)
-      Puppet::Util::Storage.state.should == {"File[#{@basepath}/yayness]"=>{}, "Exec[#{@basepath}/bin/ls /yayness]"=>{}}
+      expect(Puppet::Util::Storage.state).to eq({"File[#{@basepath}/yayness]"=>{}, "Exec[#{@basepath}/bin/ls /yayness]"=>{}})
     end
   end
 
@@ -55,15 +55,15 @@ describe Puppet::Util::Storage do
     it "should cache by converting to a string" do
       data = Puppet::Util::Storage.cache(42)
       data[:yay] = true
-      Puppet::Util::Storage.cache("42")[:yay].should be_true
+      expect(Puppet::Util::Storage.cache("42")[:yay]).to be_truthy
     end
   end
 
   it "should clear its internal state when clear() is called" do
     Puppet::Util::Storage.cache(:yayness)
-    Puppet::Util::Storage.state.should == {:yayness=>{}}
+    expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     Puppet::Util::Storage.clear
-    Puppet::Util::Storage.state.should == {}
+    expect(Puppet::Util::Storage.state).to eq({})
   end
 
   describe "when loading from the state file" do
@@ -77,7 +77,7 @@ describe Puppet::Util::Storage do
       end
 
       it "should not fail to load" do
-        Puppet::FileSystem.exist?(@path).should be_false
+        expect(Puppet::FileSystem.exist?(@path)).to be_falsey
         Puppet[:statedir] = @path
         Puppet::Util::Storage.load
         Puppet[:statefile] = @path
@@ -85,15 +85,15 @@ describe Puppet::Util::Storage do
       end
 
       it "should not lose its internal state when load() is called" do
-        Puppet::FileSystem.exist?(@path).should be_false
+        expect(Puppet::FileSystem.exist?(@path)).to be_falsey
 
         Puppet::Util::Storage.cache(:yayness)
-        Puppet::Util::Storage.state.should == {:yayness=>{}}
+        expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
 
         Puppet[:statefile] = @path
         Puppet::Util::Storage.load
 
-        Puppet::Util::Storage.state.should == {:yayness=>{}}
+        expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
       end
     end
 
@@ -111,11 +111,11 @@ describe Puppet::Util::Storage do
       it "should overwrite its internal state if load() is called" do
         # Should the state be overwritten even if Puppet[:statefile] is not valid YAML?
         Puppet::Util::Storage.cache(:yayness)
-        Puppet::Util::Storage.state.should == {:yayness=>{}}
+        expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
 
         Puppet::Util::Storage.load
 
-        Puppet::Util::Storage.state.should == {}
+        expect(Puppet::Util::Storage.state).to eq({})
       end
 
       it "should restore its internal state if the state file contains valid YAML" do
@@ -124,7 +124,7 @@ describe Puppet::Util::Storage do
 
         Puppet::Util::Storage.load
 
-        Puppet::Util::Storage.state.should == test_yaml
+        expect(Puppet::Util::Storage.state).to eq(test_yaml)
       end
 
       it "should initialize with a clear internal state if the state file does not contain valid YAML" do
@@ -132,7 +132,7 @@ describe Puppet::Util::Storage do
 
         Puppet::Util::Storage.load
 
-        Puppet::Util::Storage.state.should == {}
+        expect(Puppet::Util::Storage.state).to eq({})
       end
 
       it "should initialize with a clear internal state if the state file does not contain a hash of data" do
@@ -140,7 +140,7 @@ describe Puppet::Util::Storage do
 
         Puppet::Util::Storage.load
 
-        Puppet::Util::Storage.state.should == {}
+        expect(Puppet::Util::Storage.state).to eq({})
       end
 
       it "should raise an error if the state file does not contain valid YAML and cannot be renamed" do
@@ -176,12 +176,12 @@ describe Puppet::Util::Storage do
     end
 
     it "should create the state file if it does not exist" do
-      Puppet::FileSystem.exist?(Puppet[:statefile]).should be_false
+      expect(Puppet::FileSystem.exist?(Puppet[:statefile])).to be_falsey
       Puppet::Util::Storage.cache(:yayness)
 
       Puppet::Util::Storage.store
 
-      Puppet::FileSystem.exist?(Puppet[:statefile]).should be_true
+      expect(Puppet::FileSystem.exist?(Puppet[:statefile])).to be_truthy
     end
 
     it "should raise an exception if the state file is not a regular file" do
@@ -195,16 +195,16 @@ describe Puppet::Util::Storage do
 
     it "should load() the same information that it store()s" do
       Puppet::Util::Storage.cache(:yayness)
-      Puppet::Util::Storage.state.should == {:yayness=>{}}
+      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
 
       Puppet::Util::Storage.store
       Puppet::Util::Storage.clear
 
-      Puppet::Util::Storage.state.should == {}
+      expect(Puppet::Util::Storage.state).to eq({})
 
       Puppet::Util::Storage.load
 
-      Puppet::Util::Storage.state.should == {:yayness=>{}}
+      expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     end
   end
 end

data/spec/unit/util/suidmanager_spec.rb

@@ -33,8 +33,8 @@ describe Puppet::Util::SUIDManager do
       Puppet::Util::SUIDManager.egid = user[:gid]
       Puppet::Util::SUIDManager.euid = user[:uid]
 
-      xids[:egid].should == user[:gid]
-      xids[:euid].should == user[:uid]
+      expect(xids[:egid]).to eq(user[:gid])
+      expect(xids[:euid]).to eq(user[:uid])
     end
   end
 
@@ -48,7 +48,7 @@ describe Puppet::Util::SUIDManager do
 
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
-      xids.should be_empty
+      expect(xids).to be_empty
     end
 
     context "when root and not windows" do
@@ -57,11 +57,9 @@ describe Puppet::Util::SUIDManager do
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
-      it "should set euid/egid when root" do
-        Process.stubs(:uid).returns(0)
-
-        Process.stubs(:egid).returns(51)
-        Process.stubs(:euid).returns(50)
+      it "should set euid/egid" do
+        Process.stubs(:egid).returns(51).then.returns(51).then.returns(user[:gid])
+        Process.stubs(:euid).returns(50).then.returns(50).then.returns(user[:uid])
 
         Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
         Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
@@ -69,31 +67,31 @@ describe Puppet::Util::SUIDManager do
 
         yielded = false
         Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) do
-          xids[:egid].should == user[:gid]
-          xids[:euid].should == user[:uid]
+          expect(xids[:egid]).to eq(user[:gid])
+          expect(xids[:euid]).to eq(user[:uid])
           yielded = true
         end
 
-        xids[:egid].should == 51
-        xids[:euid].should == 50
+        expect(xids[:egid]).to eq(51)
+        expect(xids[:euid]).to eq(50)
 
         # It's possible asuser could simply not yield, so the assertions in the
         # block wouldn't fail. So verify those actually got checked.
-        yielded.should be_true
+        expect(yielded).to be_truthy
       end
 
       it "should just yield if user and group are nil" do
         yielded = false
         Puppet::Util::SUIDManager.asuser(nil, nil) { yielded = true }
-        yielded.should be_true
-        xids.should == {}
+        expect(yielded).to be_truthy
+        expect(xids).to eq({})
       end
 
       it "should just change group if only group is given" do
         yielded = false
         Puppet::Util::SUIDManager.asuser(nil, 42) { yielded = true }
-        yielded.should be_true
-        xids.should == { :egid => 42 }
+        expect(yielded).to be_truthy
+        expect(xids).to eq({ :egid => 42 })
       end
 
       it "should change gid to the primary group of uid by default" do
@@ -101,8 +99,8 @@ describe Puppet::Util::SUIDManager do
 
         yielded = false
         Puppet::Util::SUIDManager.asuser(42) { yielded = true }
-        yielded.should be_true
-        xids.should == { :euid => 42, :egid => 42 }
+        expect(yielded).to be_truthy
+        expect(xids).to eq({ :euid => 42, :egid => 42 })
       end
 
       it "should change both uid and gid if given" do
@@ -119,7 +117,7 @@ describe Puppet::Util::SUIDManager do
 
         yielded = false
         Puppet::Util::SUIDManager.asuser(42, 43) { yielded = true }
-        yielded.should be_true
+        expect(yielded).to be_truthy
       end
     end
 
@@ -128,7 +126,7 @@ describe Puppet::Util::SUIDManager do
 
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
-      xids.should be_empty
+      expect(xids).to be_empty
     end
   end
 
@@ -142,8 +140,20 @@ describe Puppet::Util::SUIDManager do
 
         Puppet::Util::SUIDManager.change_group(42, true)
 
-        xids[:egid].should == 42
-        xids[:gid].should == 42
+        expect(xids[:egid]).to eq(42)
+        expect(xids[:gid]).to eq(42)
+      end
+
+      it "should not change_privilege when gid already matches" do
+        Process::GID.expects(:change_privilege).with do |gid|
+          Process.gid = 42
+          Process.egid = 42
+        end
+
+        Puppet::Util::SUIDManager.change_group(42, true)
+
+        expect(xids[:egid]).to eq(42)
+        expect(xids[:gid]).to eq(42)
       end
     end
 
@@ -151,8 +161,8 @@ describe Puppet::Util::SUIDManager do
       it "should change only egid" do
         Puppet::Util::SUIDManager.change_group(42, false)
 
-        xids[:egid].should == 42
-        xids[:gid].should == 0
+        expect(xids[:egid]).to eq(42)
+        expect(xids[:gid]).to eq(0)
       end
     end
   end
@@ -169,8 +179,21 @@ describe Puppet::Util::SUIDManager do
 
         Puppet::Util::SUIDManager.change_user(42, true)
 
-        xids[:euid].should == 42
-        xids[:uid].should == 42
+        expect(xids[:euid]).to eq(42)
+        expect(xids[:uid]).to eq(42)
+      end
+      it "should not change_privilege when uid already matches" do
+        Process::UID.expects(:change_privilege).with do |uid|
+          Process.uid = 42
+          Process.euid = 42
+        end
+
+        Puppet::Util::SUIDManager.expects(:initgroups).with(42)
+
+        Puppet::Util::SUIDManager.change_user(42, true)
+
+        expect(xids[:euid]).to eq(42)
+        expect(xids[:uid]).to eq(42)
       end
     end
 
@@ -179,8 +202,8 @@ describe Puppet::Util::SUIDManager do
         Puppet::Util::SUIDManager.stubs(:initgroups).returns([])
         Puppet::Util::SUIDManager.change_user(42, false)
 
-        xids[:euid].should == 42
-        xids[:uid].should == 0
+        expect(xids[:euid]).to eq(42)
+        expect(xids[:uid]).to eq(0)
       end
 
       it "should set euid before groups if changing to root" do
@@ -207,40 +230,6 @@ describe Puppet::Util::SUIDManager do
     end
   end
 
-  describe "when running commands" do
-    before :each do
-      # We want to make sure $CHILD_STATUS is set
-      Kernel.system '' if $CHILD_STATUS.nil?
-    end
-
-    describe "with #run_and_capture" do
-      it "should capture the output and return process status" do
-        Puppet::Util::Execution.
-          expects(:execute).with() do |*args|
-              args[0] == 'yay' &&
-              args[1][:combine] == true &&
-              args[1][:failonfail] == false &&
-              args[1][:uid] == user[:uid] &&
-              args[1][:gid] == user[:gid] &&
-              args[1][:override_locale] == true &&
-              args[1].has_key?(:custom_environment)
-        end .
-          returns('output')
-        output = Puppet::Util::SUIDManager.run_and_capture 'yay', user[:uid], user[:gid]
-
-        output.first.should == 'output'
-        output.last.should be_a(Process::Status)
-      end
-
-      it "should log a deprecation notice" do
-        Puppet::Util::Execution.stubs(:execute).returns("success")
-        Puppet.expects(:deprecation_warning).with('Puppet::Util::SUIDManager.run_and_capture is deprecated; please use Puppet::Util::Execution.execute instead.')
-
-        output = Puppet::Util::SUIDManager.run_and_capture 'yay', user[:uid], user[:gid]
-      end
-    end
-  end
-
   describe "#root?" do
     describe "on POSIX systems" do
       before :each do
@@ -251,13 +240,13 @@ describe Puppet::Util::SUIDManager do
       it "should be root if uid is 0" do
         Process.stubs(:uid).returns(0)
 
-        Puppet::Util::SUIDManager.should be_root
+        expect(Puppet::Util::SUIDManager).to be_root
       end
 
       it "should not be root if uid is not 0" do
         Process.stubs(:uid).returns(1)
 
-        Puppet::Util::SUIDManager.should_not be_root
+        expect(Puppet::Util::SUIDManager).not_to be_root
       end
     end
 
@@ -265,13 +254,13 @@ describe Puppet::Util::SUIDManager do
       it "should be root if user is privileged" do
         Puppet::Util::Windows::User.stubs(:admin?).returns true
 
-        Puppet::Util::SUIDManager.should be_root
+        expect(Puppet::Util::SUIDManager).to be_root
       end
 
       it "should not be root if user is not privileged" do
         Puppet::Util::Windows::User.stubs(:admin?).returns false
 
-        Puppet::Util::SUIDManager.should_not be_root
+        expect(Puppet::Util::SUIDManager).not_to be_root
       end
     end
   end