puppet 5.3.4 → 6.29.0

data/spec/unit/util/storage_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'yaml'
@@ -68,7 +67,7 @@ describe Puppet::Util::Storage do
 
   describe "when loading from the state file" do
     before do
-      Puppet.settings.stubs(:use).returns(true)
+      allow(Puppet.settings).to receive(:use).and_return(true)
     end
 
     describe "when the state file/directory does not exist" do
@@ -144,9 +143,11 @@ describe Puppet::Util::Storage do
       end
 
       it "should raise an error if the state file does not contain valid YAML and cannot be renamed" do
+        allow(File).to receive(:rename).and_call_original
+
         write_state_file('{ invalid')
 
-        File.expects(:rename).raises(SystemCallError)
+        expect(File).to receive(:rename).with(@state_file, "#{@state_file}.bad").and_raise(SystemCallError)
 
         expect { Puppet::Util::Storage.load }.to raise_error(Puppet::Error, /Could not rename/)
       end
@@ -154,7 +155,7 @@ describe Puppet::Util::Storage do
       it "should attempt to rename the state file if the file is corrupted" do
         write_state_file('{ invalid')
 
-        File.expects(:rename).at_least_once
+        expect(File).to receive(:rename).at_least(:once)
 
         Puppet::Util::Storage.load
       end
@@ -165,10 +166,24 @@ describe Puppet::Util::Storage do
 
         Puppet::Util::Storage.load
       end
+
+      it 'should load Time and Symbols' do
+        state = {
+          'File[/etc/puppetlabs/puppet]' =>
+          { :checked => Time.new('2018-08-08 15:28:25.546999000 -07:00') }
+        }
+        write_state_file(YAML.dump(state))
+
+        Puppet::Util::Storage.load
+
+        expect(Puppet::Util::Storage.state).to eq(state.dup)
+      end
     end
   end
 
   describe "when storing to the state file" do
+    A_SMALL_AMOUNT_OF_TIME = 0.001 #Seconds
+
     before(:each) do
       @state_file = tmpfile('storage_test')
       @saved_statefile = Puppet[:statefile]
@@ -188,14 +203,7 @@ describe Puppet::Util::Storage do
       Dir.mkdir(Puppet[:statefile])
       Puppet::Util::Storage.cache(:yayness)
 
-      if Puppet.features.microsoft_windows?
-        expect { Puppet::Util::Storage.store }.to raise_error do |error|
-          expect(error).to be_a(Puppet::Util::Windows::Error)
-          expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
-        end
-      else
-        expect { Puppet::Util::Storage.store }.to raise_error(Errno::EISDIR, /Is a directory/)
-      end
+      expect { Puppet::Util::Storage.store }.to raise_error(Errno::EISDIR, /Is a directory/)
 
       Dir.rmdir(Puppet[:statefile])
     end
@@ -213,5 +221,110 @@ describe Puppet::Util::Storage do
 
       expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     end
+
+    it "expires entries with a :checked older than statettl seconds ago" do
+      Puppet[:statettl] = '1d'
+      recent_checked = Time.now.round
+      stale_checked = recent_checked - (Puppet[:statettl] + 10)
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:stale)[:checked] = stale_checked
+      expect(Puppet::Util::Storage.state).to match(
+        {
+          :yayness => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
+          },
+          :stale => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(stale_checked)
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to match(
+        {
+          :yayness => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
+          }
+        }
+      )
+    end
+
+    it "does not expire entries when statettl is 0" do
+      Puppet[:statettl] = '0'
+      recent_checked = Time.now.round
+      older_checked = recent_checked - 10_000_000
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
+      expect(Puppet::Util::Storage.state).to match(
+        {
+          :yayness => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
+          },
+          :older => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to match(
+        {
+          :yayness => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
+          },
+          :older => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
+          }
+        }
+      )
+    end
+
+    it "does not expire entries when statettl is 'unlimited'" do
+      Puppet[:statettl] = 'unlimited'
+      recent_checked = Time.now
+      older_checked = Time.now - 10_000_000
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
+      expect(Puppet::Util::Storage.state).to match(
+        {
+          :yayness => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
+          },
+          :older => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to match(
+        {
+          :yayness => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
+          },
+          :older => {
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
+          }
+        }
+      )
+    end
   end
 end

data/spec/unit/util/suidmanager_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Util::SUIDManager do
@@ -12,24 +10,26 @@ describe Puppet::Util::SUIDManager do
   end
 
   before :each do
-    Puppet::Util::SUIDManager.stubs(:convert_xid).returns(42)
-    pwent = stub('pwent', :name => 'fred', :uid => 42, :gid => 42)
-    Etc.stubs(:getpwuid).with(42).returns(pwent)
+    allow(Puppet::Util::SUIDManager).to receive(:convert_xid).and_return(42)
+    pwent = double('pwent', :name => 'fred', :uid => 42, :gid => 42)
+    allow(Etc).to receive(:getpwuid).with(42).and_return(pwent)
 
-    [:euid, :egid, :uid, :gid, :groups].each do |id|
-      Process.stubs("#{id}=").with {|value| xids[id] = value }
+    unless Puppet::Util::Platform.windows?
+      [:euid, :egid, :uid, :gid, :groups].each do |id|
+        allow(Process).to receive("#{id}=") {|value| xids[id] = value}
+      end
     end
   end
 
-  describe "#initgroups" do
+  describe "#initgroups", unless: Puppet::Util::Platform.windows? do
     it "should use the primary group of the user as the 'basegid'" do
-      Process.expects(:initgroups).with('fred', 42)
+      expect(Process).to receive(:initgroups).with('fred', 42)
       described_class.initgroups(42)
     end
   end
 
   describe "#uid" do
-    it "should allow setting euid/egid" do
+    it "should allow setting euid/egid", unless: Puppet::Util::Platform.windows? do
       Puppet::Util::SUIDManager.egid = user[:gid]
       Puppet::Util::SUIDManager.euid = user[:uid]
 
@@ -39,31 +39,29 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#asuser" do
-    it "should not get or set euid/egid when not root" do
-      Puppet.features.stubs(:microsoft_windows?).returns(false)
-      Process.stubs(:uid).returns(1)
+    it "should not get or set euid/egid when not root", unless: Puppet::Util::Platform.windows? do
+      allow(Process).to receive(:uid).and_return(1)
 
-      Process.stubs(:egid).returns(51)
-      Process.stubs(:euid).returns(50)
+      allow(Process).to receive(:egid).and_return(51)
+      allow(Process).to receive(:euid).and_return(50)
 
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
       expect(xids).to be_empty
     end
 
-    context "when root and not windows" do
+    context "when root and not Windows" do
       before :each do
-        Process.stubs(:uid).returns(0)
-        Puppet.features.stubs(:microsoft_windows?).returns(false)
+        allow(Process).to receive(:uid).and_return(0)
       end
 
-      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])
+      it "should set euid/egid", unless: Puppet::Util::Platform.windows? do
+        allow(Process).to receive(:egid).and_return(51, 51, user[:gid])
+        allow(Process).to receive(:euid).and_return(50, 50, user[:uid])
 
-        Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
-        Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
-        Puppet::Util::SUIDManager.stubs(:initgroups).returns([])
+        allow(Puppet::Util::SUIDManager).to receive(:convert_xid).with(:gid, 51).and_return(51)
+        allow(Puppet::Util::SUIDManager).to receive(:convert_xid).with(:uid, 50).and_return(50)
+        allow(Puppet::Util::SUIDManager).to receive(:initgroups).and_return([])
 
         yielded = false
         Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) do
@@ -81,59 +79,50 @@ describe Puppet::Util::SUIDManager do
       end
 
       it "should just yield if user and group are nil" do
-        yielded = false
-        Puppet::Util::SUIDManager.asuser(nil, nil) { yielded = true }
-        expect(yielded).to be_truthy
+        expect { |b| Puppet::Util::SUIDManager.asuser(nil, nil, &b) }.to yield_control
         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 }
-        expect(yielded).to be_truthy
+      it "should just change group if only group is given", unless: Puppet::Util::Platform.windows? do
+        expect { |b| Puppet::Util::SUIDManager.asuser(nil, 42, &b) }.to yield_control
         expect(xids).to eq({ :egid => 42 })
       end
 
-      it "should change gid to the primary group of uid by default" do
-        Process.stubs(:initgroups)
+      it "should change gid to the primary group of uid by default", unless: Puppet::Util::Platform.windows? do
+        allow(Process).to receive(:initgroups)
 
-        yielded = false
-        Puppet::Util::SUIDManager.asuser(42) { yielded = true }
-        expect(yielded).to be_truthy
+        expect { |b| Puppet::Util::SUIDManager.asuser(42, nil, &b) }.to yield_control
         expect(xids).to eq({ :euid => 42, :egid => 42 })
       end
 
-      it "should change both uid and gid if given" do
+      it "should change both uid and gid if given", unless: Puppet::Util::Platform.windows? do
         # I don't like the sequence, but it is the only way to assert on the
         # internal behaviour in a reliable fashion, given we need multiple
         # sequenced calls to the same methods. --daniel 2012-02-05
-        horror = sequence('of user and group changes')
-        Puppet::Util::SUIDManager.expects(:change_group).with(43, false).in_sequence(horror)
-        Puppet::Util::SUIDManager.expects(:change_user).with(42, false).in_sequence(horror)
-        Puppet::Util::SUIDManager.expects(:change_group).
-          with(Puppet::Util::SUIDManager.egid, false).in_sequence(horror)
-        Puppet::Util::SUIDManager.expects(:change_user).
-          with(Puppet::Util::SUIDManager.euid, false).in_sequence(horror)
+        expect(Puppet::Util::SUIDManager).to receive(:change_group).with(43, false).ordered()
+        expect(Puppet::Util::SUIDManager).to receive(:change_user).with(42, false).ordered()
+        expect(Puppet::Util::SUIDManager).to receive(:change_group).with(Puppet::Util::SUIDManager.egid, false).ordered()
+        expect(Puppet::Util::SUIDManager).to receive(:change_user).with(Puppet::Util::SUIDManager.euid, false).ordered()
 
-        yielded = false
-        Puppet::Util::SUIDManager.asuser(42, 43) { yielded = true }
-        expect(yielded).to be_truthy
+        expect { |b| Puppet::Util::SUIDManager.asuser(42, 43, &b) }.to yield_control
       end
     end
 
-    it "should not get or set euid/egid on Windows" do
-      Puppet.features.stubs(:microsoft_windows?).returns true
-
-      Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
-
-      expect(xids).to be_empty
+    it "should just yield on Windows", if: Puppet::Util::Platform.windows? do
+      expect { |b| Puppet::Util::SUIDManager.asuser(1, 2, &b) }.to yield_control
     end
   end
 
   describe "#change_group" do
-    describe "when changing permanently" do
+    it "raises on Windows", if: Puppet::Util::Platform.windows? do
+      expect {
+        Puppet::Util::SUIDManager.change_group(42, true)
+      }.to raise_error(NotImplementedError, /change_privilege\(\) function is unimplemented/)
+    end
+
+    describe "when changing permanently", unless: Puppet::Util::Platform.windows? do
       it "should change_privilege" do
-        Process::GID.expects(:change_privilege).with do |gid|
+        expect(Process::GID).to receive(:change_privilege) do |gid|
           Process.gid = gid
           Process.egid = gid
         end
@@ -145,7 +134,7 @@ describe Puppet::Util::SUIDManager do
       end
 
       it "should not change_privilege when gid already matches" do
-        Process::GID.expects(:change_privilege).with do |gid|
+        expect(Process::GID).to receive(:change_privilege) do |gid|
           Process.gid = 42
           Process.egid = 42
         end
@@ -157,7 +146,7 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    describe "when changing temporarily" do
+    describe "when changing temporarily", unless: Puppet::Util::Platform.windows? do
       it "should change only egid" do
         Puppet::Util::SUIDManager.change_group(42, false)
 
@@ -168,27 +157,34 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#change_user" do
-    describe "when changing permanently" do
+    it "raises on Windows", if: Puppet::Util::Platform.windows? do
+      expect {
+        Puppet::Util::SUIDManager.change_user(42, true)
+      }.to raise_error(NotImplementedError, /initgroups\(\) function is unimplemented/)
+    end
+
+    describe "when changing permanently", unless: Puppet::Util::Platform.windows? do
       it "should change_privilege" do
-        Process::UID.expects(:change_privilege).with do |uid|
+        expect(Process::UID).to receive(:change_privilege) do |uid|
           Process.uid = uid
           Process.euid = uid
         end
 
-        Puppet::Util::SUIDManager.expects(:initgroups).with(42)
+        expect(Puppet::Util::SUIDManager).to receive(:initgroups).with(42)
 
         Puppet::Util::SUIDManager.change_user(42, true)
 
         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|
+        expect(Process::UID).to receive(:change_privilege) do |uid|
           Process.uid = 42
           Process.euid = 42
         end
 
-        Puppet::Util::SUIDManager.expects(:initgroups).with(42)
+        expect(Puppet::Util::SUIDManager).to receive(:initgroups).with(42)
 
         Puppet::Util::SUIDManager.change_user(42, true)
 
@@ -197,9 +193,9 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    describe "when changing temporarily" do
+    describe "when changing temporarily", unless: Puppet::Util::Platform.windows? do
       it "should change only euid and groups" do
-        Puppet::Util::SUIDManager.stubs(:initgroups).returns([])
+        allow(Puppet::Util::SUIDManager).to receive(:initgroups).and_return([])
         Puppet::Util::SUIDManager.change_user(42, false)
 
         expect(xids[:euid]).to eq(42)
@@ -207,23 +203,19 @@ describe Puppet::Util::SUIDManager do
       end
 
       it "should set euid before groups if changing to root" do
-        Process.stubs(:euid).returns 50
+        allow(Process).to receive(:euid).and_return(50)
 
-        when_not_root = sequence 'when_not_root'
-
-        Process.expects(:euid=).in_sequence(when_not_root)
-        Puppet::Util::SUIDManager.expects(:initgroups).in_sequence(when_not_root)
+        expect(Process).to receive(:euid=).ordered()
+        expect(Puppet::Util::SUIDManager).to receive(:initgroups).ordered()
 
         Puppet::Util::SUIDManager.change_user(0, false)
       end
 
       it "should set groups before euid if changing from root" do
-        Process.stubs(:euid).returns 0
-
-        when_root = sequence 'when_root'
+        allow(Process).to receive(:euid).and_return(0)
 
-        Puppet::Util::SUIDManager.expects(:initgroups).in_sequence(when_root)
-        Process.expects(:euid=).in_sequence(when_root)
+        expect(Puppet::Util::SUIDManager).to receive(:initgroups).ordered()
+        expect(Process).to receive(:euid=).ordered()
 
         Puppet::Util::SUIDManager.change_user(50, false)
       end
@@ -231,34 +223,29 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#root?" do
-    describe "on POSIX systems" do
-      before :each do
-        Puppet.features.stubs(:posix?).returns(true)
-        Puppet.features.stubs(:microsoft_windows?).returns(false)
-      end
-
+    describe "on POSIX systems", unless: Puppet::Util::Platform.windows? do
       it "should be root if uid is 0" do
-        Process.stubs(:uid).returns(0)
+        allow(Process).to receive(:uid).and_return(0)
 
         expect(Puppet::Util::SUIDManager).to be_root
       end
 
       it "should not be root if uid is not 0" do
-        Process.stubs(:uid).returns(1)
+        allow(Process).to receive(:uid).and_return(1)
 
         expect(Puppet::Util::SUIDManager).not_to be_root
       end
     end
 
-    describe "on Microsoft Windows", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows", :if => Puppet::Util::Platform.windows? do
       it "should be root if user is privileged" do
-        Puppet::Util::Windows::User.stubs(:admin?).returns true
+        allow(Puppet::Util::Windows::User).to receive(:admin?).and_return(true)
 
         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
+        allow(Puppet::Util::Windows::User).to receive(:admin?).and_return(false)
 
         expect(Puppet::Util::SUIDManager).not_to be_root
       end
@@ -271,16 +258,21 @@ describe 'Puppet::Util::SUIDManager#groups=' do
     Puppet::Util::SUIDManager
   end
 
+  it "raises on Windows", if: Puppet::Util::Platform.windows? do
+    expect {
+      subject.groups = []
+    }.to raise_error(NotImplementedError, /groups=\(\) function is unimplemented/)
+  end
 
-  it "(#3419) should rescue Errno::EINVAL on OS X" do
-    Process.expects(:groups=).raises(Errno::EINVAL, 'blew up')
-    subject.expects(:osx_maj_ver).returns('10.7').twice
+  it "(#3419) should rescue Errno::EINVAL on OS X", unless: Puppet::Util::Platform.windows? do
+    expect(Process).to receive(:groups=).and_raise(Errno::EINVAL, 'blew up')
+    expect(subject).to receive(:osx_maj_ver).and_return('10.7').twice
     subject.groups = ['list', 'of', 'groups']
   end
 
-  it "(#3419) should fail if an Errno::EINVAL is raised NOT on OS X" do
-    Process.expects(:groups=).raises(Errno::EINVAL, 'blew up')
-    subject.expects(:osx_maj_ver).returns(false)
+  it "(#3419) should fail if an Errno::EINVAL is raised NOT on OS X", unless: Puppet::Util::Platform.windows? do
+    expect(Process).to receive(:groups=).and_raise(Errno::EINVAL, 'blew up')
+    expect(subject).to receive(:osx_maj_ver).and_return(false)
     expect { subject.groups = ['list', 'of', 'groups'] }.to raise_error(Errno::EINVAL)
   end
 end

data/spec/unit/util/symbolic_file_mode_spec.rb

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

data/spec/unit/util/tag_set_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/tag_set'
@@ -20,7 +19,7 @@ describe Puppet::Util::TagSet do
     array = ['a', :b, 1, 5.4]
     set.merge(array)
 
-    expect(Set.new(YAML.load(set.to_yaml))).to eq(Set.new(array))
+    expect(Set.new(Puppet::Util::Yaml.safe_load(set.to_yaml, [Symbol, Puppet::Util::TagSet]))).to eq(Set.new(array))
   end
 
   it 'deserializes from a yaml array' do
@@ -43,4 +42,11 @@ describe Puppet::Util::TagSet do
 
     expect(set.join(', ')).to be_one_of('a, b', 'b, a')
   end
+
+  it 'raises when deserializing unacceptable objects' do
+    yaml = [Object.new].to_yaml
+    expect {
+      Puppet::Util::TagSet.from_yaml(yaml)
+    }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /Tried to load unspecified class: Object/)
+  end
 end

data/spec/unit/util/tagging_spec.rb

@@ -1,4 +1,4 @@
-#! /usr/bin/env ruby
+# coding: utf-8
 require 'spec_helper'
 
 require 'puppet/util/tagging'
@@ -11,13 +11,6 @@ describe Puppet::Util::Tagging do
     expect(tagger.tags).to include("one")
   end
 
-  it "should return a duplicate of the tag list, rather than the original" do
-    tagger.tag("one")
-    tags = tagger.tags
-    tags << "two"
-    expect(tagger.tags).to_not include("two")
-  end
-
   it "should add all provided tags to the tag list" do
     tagger.tag("one", "two")
     expect(tagger.tags).to include("one")
@@ -97,11 +90,25 @@ describe Puppet::Util::Tagging do
     "\"",
     "'",
   ].each do |char|
-    it "should not allow UTF-8 punctuation characters" do
+    it "should not allow UTF-8 punctuation characters, e.g. #{char}" do
       expect { tagger.tag(char) }.to raise_error(Puppet::ParseError)
     end
   end
 
+  it "should allow encodings that can be coerced to UTF-8" do
+     chinese = "標記你是它".force_encoding(Encoding::UTF_8)
+     ascii   = "tags--".force_encoding(Encoding::ASCII_8BIT)
+     jose    = "jos\xE9".force_encoding(Encoding::ISO_8859_1)
+
+     [chinese, ascii, jose].each do |tag|
+       expect(tagger.valid_tag?(tag)).to be_truthy
+     end
+  end
+
+  it "should not allow strings that cannot be converted to UTF-8" do
+    invalid = "\xA0".force_encoding(Encoding::ASCII_8BIT)
+    expect(tagger.valid_tag?(invalid)).to be_falsey
+  end
 
   it "should add qualified classes as tags" do
     tagger.tag("one::two")
@@ -158,6 +165,17 @@ describe Puppet::Util::Tagging do
       tagger.tag("my-tag")
       expect(tagger).to be_tagged("my-tag")
     end
+
+    it 'skips undef /nil tags' do
+      tagger.tag('before')
+      tagger.tag(nil)
+      tagger.tag('after')
+      expect(tagger).to_not be_tagged(nil)
+      expect(tagger).to_not be_tagged('')
+      expect(tagger).to_not be_tagged('undef')
+      expect(tagger).to be_tagged('before')
+      expect(tagger).to be_tagged('after')
+    end
   end
 
   context "when querying if tagged" do

data/spec/unit/util/terminal_spec.rb

@@ -1,41 +1,40 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/terminal'
 
 describe Puppet::Util::Terminal do
   describe '.width' do
-    before { Puppet.features.stubs(:posix?).returns(true) }
+    before { allow(Puppet.features).to receive(:posix?).and_return(true) }
 
     it 'should invoke `stty` and return the width' do
       height, width = 100, 200
-      subject.expects(:`).with('stty size 2>/dev/null').returns("#{height} #{width}\n")
+      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_return("#{height} #{width}\n")
       expect(subject.width).to eq(width)
     end
 
     it 'should use `tput` if `stty` is unavailable' do
       width = 200
-      subject.expects(:`).with('stty size 2>/dev/null').returns("\n")
-      subject.expects(:`).with('tput cols 2>/dev/null').returns("#{width}\n")
+      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_return("\n")
+      expect(subject).to receive(:`).with('tput cols 2>/dev/null').and_return("#{width}\n")
       expect(subject.width).to eq(width)
     end
 
     it 'should default to 80 columns if `tput` and `stty` are unavailable' do
       width = 80
-      subject.expects(:`).with('stty size 2>/dev/null').returns("\n")
-      subject.expects(:`).with('tput cols 2>/dev/null').returns("\n")
+      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_return("\n")
+      expect(subject).to receive(:`).with('tput cols 2>/dev/null').and_return("\n")
       expect(subject.width).to eq(width)
     end
 
     it 'should default to 80 columns if `tput` or `stty` raise exceptions' do
       width = 80
-      subject.expects(:`).with('stty size 2>/dev/null').raises()
-      subject.stubs(:`).with('tput cols 2>/dev/null').returns("#{width + 1000}\n")
+      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_raise()
+      allow(subject).to receive(:`).with('tput cols 2>/dev/null').and_return("#{width + 1000}\n")
       expect(subject.width).to eq(width)
     end
 
     it 'should default to 80 columns if not in a POSIX environment' do
       width = 80
-      Puppet.features.stubs(:posix?).returns(false)
+      allow(Puppet.features).to receive(:posix?).and_return(false)
       expect(subject.width).to eq(width)
     end
   end