puppet 3.8.7 → 4.0.0

data/spec/unit/type/mcx_spec.rb

@@ -12,19 +12,19 @@ describe mcx_type, "when validating attributes" do
 
   parameters.each do |p|
     it "should have a #{p} parameter" do
-      mcx_type.attrclass(p).ancestors.should be_include(Puppet::Parameter)
+      expect(mcx_type.attrclass(p).ancestors).to be_include(Puppet::Parameter)
     end
     it "should have documentation for its #{p} parameter" do
-      mcx_type.attrclass(p).doc.should be_instance_of(String)
+      expect(mcx_type.attrclass(p).doc).to be_instance_of(String)
     end
   end
 
   properties.each do |p|
     it "should have a #{p} property" do
-      mcx_type.attrclass(p).ancestors.should be_include(Puppet::Property)
+      expect(mcx_type.attrclass(p).ancestors).to be_include(Puppet::Property)
     end
     it "should have documentation for its #{p} property" do
-      mcx_type.attrclass(p).doc.should be_instance_of(String)
+      expect(mcx_type.attrclass(p).doc).to be_instance_of(String)
     end
   end
 
@@ -38,15 +38,15 @@ describe mcx_type, "default values" do
   end
 
   it "should be nil for :ds_type" do
-    mcx_type.new(:name => '/Foo/bar')[:ds_type].should be_nil
+    expect(mcx_type.new(:name => '/Foo/bar')[:ds_type]).to be_nil
   end
 
   it "should be nil for :ds_name" do
-    mcx_type.new(:name => '/Foo/bar')[:ds_name].should be_nil
+    expect(mcx_type.new(:name => '/Foo/bar')[:ds_name]).to be_nil
   end
 
   it "should be nil for :content" do
-    mcx_type.new(:name => '/Foo/bar')[:content].should be_nil
+    expect(mcx_type.new(:name => '/Foo/bar')[:content]).to be_nil
   end
 
 end
@@ -59,21 +59,21 @@ describe mcx_type, "when validating properties" do
   end
 
   it "should be able to create an instance" do
-    lambda {
+    expect {
       mcx_type.new(:name => '/Foo/bar')
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should support :present as a value to :ensure" do
-    lambda {
+    expect {
       mcx_type.new(:name => "/Foo/bar", :ensure => :present)
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should support :absent as a value to :ensure" do
-    lambda {
+    expect {
       mcx_type.new(:name => "/Foo/bar", :ensure => :absent)
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
 end

data/spec/unit/type/mount_spec.rb

@@ -37,28 +37,28 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
   end
 
   it "should have a :refreshable feature that requires the :remount method" do
-    described_class.provider_feature(:refreshable).methods.should == [:remount]
+    expect(described_class.provider_feature(:refreshable).methods).to eq([:remount])
   end
 
   it "should have no default value for :ensure" do
     mount = described_class.new(:name => "yay")
-    mount.should(:ensure).should be_nil
+    expect(mount.should(:ensure)).to be_nil
   end
 
   it "should have :name as the only keyattribut" do
-    described_class.key_attributes.should == [:name]
+    expect(described_class.key_attributes).to eq([:name])
   end
 
   describe "when validating attributes" do
     [:name, :remounts, :provider].each do |param|
       it "should have a #{param} parameter" do
-        described_class.attrtype(param).should == :param
+        expect(described_class.attrtype(param)).to eq(:param)
       end
     end
 
     [:ensure, :device, :blockdevice, :fstype, :options, :pass, :dump, :atboot, :target].each do |param|
       it "should have a #{param} property" do
-        described_class.attrtype(param).should == :property
+        expect(described_class.attrtype(param)).to eq(:property)
       end
     end
   end
@@ -67,15 +67,15 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
 
     describe "for name" do
       it "should allow full qualified paths" do
-        described_class.new(:name => "/mnt/foo")[:name].should == '/mnt/foo'
+        expect(described_class.new(:name => "/mnt/foo")[:name]).to eq('/mnt/foo')
       end
 
       it "should remove trailing slashes" do
-        described_class.new(:name => '/')[:name].should == '/'
-        described_class.new(:name => '//')[:name].should == '/'
-        described_class.new(:name => '/foo/')[:name].should == '/foo'
-        described_class.new(:name => '/foo/bar/')[:name].should == '/foo/bar'
-        described_class.new(:name => '/foo/bar/baz//')[:name].should == '/foo/bar/baz'
+        expect(described_class.new(:name => '/')[:name]).to eq('/')
+        expect(described_class.new(:name => '//')[:name]).to eq('/')
+        expect(described_class.new(:name => '/foo/')[:name]).to eq('/foo')
+        expect(described_class.new(:name => '/foo/bar/')[:name]).to eq('/foo/bar')
+        expect(described_class.new(:name => '/foo/bar/baz//')[:name]).to eq('/foo/bar/baz')
       end
 
       it "should not allow spaces" do
@@ -83,14 +83,14 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       end
 
       it "should allow pseudo mountpoints (e.g. swap)" do
-        described_class.new(:name => 'none')[:name].should == 'none'
+        expect(described_class.new(:name => 'none')[:name]).to eq('none')
       end
     end
 
     describe "for ensure" do
       it "should alias :present to :defined as a value to :ensure" do
         mount = described_class.new(:name => "yay", :ensure => :present)
-        mount.should(:ensure).should == :defined
+        expect(mount.should(:ensure)).to eq(:defined)
       end
 
       it "should support :present as a value to :ensure" do
@@ -164,22 +164,22 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
 
       it "should default to /dev/rdsk/DEVICE if device is /dev/dsk/DEVICE" do
         obj = described_class.new(:name => "/foo", :device => '/dev/dsk/c0d0s0')
-        obj[:blockdevice].should == '/dev/rdsk/c0d0s0'
+        expect(obj[:blockdevice]).to eq('/dev/rdsk/c0d0s0')
       end
 
       it "should default to - if it is an nfs-share" do
         obj = described_class.new(:name => "/foo", :device => "server://share", :fstype => 'nfs')
-        obj[:blockdevice].should == '-'
+        expect(obj[:blockdevice]).to eq('-')
       end
 
       it "should have no default otherwise" do
-        described_class.new(:name => "/foo")[:blockdevice].should == nil
-        described_class.new(:name => "/foo", :device => "/foo")[:blockdevice].should == nil
+        expect(described_class.new(:name => "/foo")[:blockdevice]).to eq(nil)
+        expect(described_class.new(:name => "/foo", :device => "/foo")[:blockdevice]).to eq(nil)
       end
 
       it "should overwrite any default if blockdevice is explicitly set" do
-        described_class.new(:name => "/foo", :device => '/dev/dsk/c0d0s0', :blockdevice => '/foo')[:blockdevice].should == '/foo'
-        described_class.new(:name => "/foo", :device => "server://share", :fstype => 'nfs', :blockdevice => '/foo')[:blockdevice].should == '/foo'
+        expect(described_class.new(:name => "/foo", :device => '/dev/dsk/c0d0s0', :blockdevice => '/foo')[:blockdevice]).to eq('/foo')
+        expect(described_class.new(:name => "/foo", :device => "server://share", :fstype => 'nfs', :blockdevice => '/foo')[:blockdevice]).to eq('/foo')
       end
     end
 
@@ -204,7 +204,7 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
         expect { described_class.new(:name => "/foo", :ensure => :present, :options => 'ro') }.to_not raise_error
       end
 
-      it "should support muliple options as a comma separated list" do
+      it "should support multiple options as a comma separated list" do
         expect { described_class.new(:name => "/foo", :ensure => :present, :options => 'ro,rsize=4096') }.to_not raise_error
       end
 
@@ -229,13 +229,13 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       it "should default to 0 on non Solaris" do
         Facter.stubs(:value).with(:osfamily).returns nil
         Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
-        described_class.new(:name => "/foo", :ensure => :present)[:pass].should == 0
+        expect(described_class.new(:name => "/foo", :ensure => :present)[:pass]).to eq(0)
       end
 
       it "should default to - on Solaris" do
         Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
         Facter.stubs(:value).with(:osfamily).returns 'Solaris'
-        described_class.new(:name => "/foo", :ensure => :present)[:pass].should == '-'
+        expect(described_class.new(:name => "/foo", :ensure => :present)[:pass]).to eq('-')
       end
     end
 
@@ -258,7 +258,7 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       end
 
       it "should default to 0" do
-        described_class.new(:name => "/foo", :ensure => :present)[:dump].should == 0
+        expect(described_class.new(:name => "/foo", :ensure => :present)[:dump]).to eq(0)
       end
     end
 
@@ -304,7 +304,7 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       ensureprop.stubs(:syncothers)
       ensureprop.should = options[:to]
       ensureprop.sync
-      (!!provider.property_hash[:needs_mount]).should == (!!options[:mount])
+      expect(!!provider.property_hash[:needs_mount]).to eq(!!options[:mount])
     end
 
     it "should create itself when changing from :ghost to :present" do
@@ -354,84 +354,84 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
 
     it "should be in sync if it is :absent and should be :absent" do
       ensureprop.should = :absent
-      ensureprop.safe_insync?(:absent).should == true
+      expect(ensureprop.safe_insync?(:absent)).to eq(true)
     end
 
     it "should be out of sync if it is :absent and should be :defined" do
       ensureprop.should = :defined
-      ensureprop.safe_insync?(:absent).should == false
+      expect(ensureprop.safe_insync?(:absent)).to eq(false)
     end
 
     it "should be out of sync if it is :absent and should be :mounted" do
       ensureprop.should = :mounted
-      ensureprop.safe_insync?(:absent).should == false
+      expect(ensureprop.safe_insync?(:absent)).to eq(false)
     end
 
     it "should be out of sync if it is :absent and should be :unmounted" do
       ensureprop.should = :unmounted
-      ensureprop.safe_insync?(:absent).should == false
+      expect(ensureprop.safe_insync?(:absent)).to eq(false)
     end
 
     it "should be out of sync if it is :mounted and should be :absent" do
       ensureprop.should = :absent
-      ensureprop.safe_insync?(:mounted).should == false
+      expect(ensureprop.safe_insync?(:mounted)).to eq(false)
     end
 
     it "should be in sync if it is :mounted and should be :defined" do
       ensureprop.should = :defined
-      ensureprop.safe_insync?(:mounted).should == true
+      expect(ensureprop.safe_insync?(:mounted)).to eq(true)
     end
 
     it "should be in sync if it is :mounted and should be :mounted" do
       ensureprop.should = :mounted
-      ensureprop.safe_insync?(:mounted).should == true
+      expect(ensureprop.safe_insync?(:mounted)).to eq(true)
     end
 
     it "should be out in sync if it is :mounted and should be :unmounted" do
       ensureprop.should = :unmounted
-      ensureprop.safe_insync?(:mounted).should == false
+      expect(ensureprop.safe_insync?(:mounted)).to eq(false)
     end
 
 
     it "should be out of sync if it is :unmounted and should be :absent" do
       ensureprop.should = :absent
-      ensureprop.safe_insync?(:unmounted).should == false
+      expect(ensureprop.safe_insync?(:unmounted)).to eq(false)
     end
 
     it "should be in sync if it is :unmounted and should be :defined" do
       ensureprop.should = :defined
-      ensureprop.safe_insync?(:unmounted).should == true
+      expect(ensureprop.safe_insync?(:unmounted)).to eq(true)
     end
 
     it "should be out of sync if it is :unmounted and should be :mounted" do
       ensureprop.should = :mounted
-      ensureprop.safe_insync?(:unmounted).should == false
+      expect(ensureprop.safe_insync?(:unmounted)).to eq(false)
     end
 
     it "should be in sync if it is :unmounted and should be :unmounted" do
       ensureprop.should = :unmounted
-      ensureprop.safe_insync?(:unmounted).should == true
+      expect(ensureprop.safe_insync?(:unmounted)).to eq(true)
     end
 
 
     it "should be out of sync if it is :ghost and should be :absent" do
       ensureprop.should = :absent
-      ensureprop.safe_insync?(:ghost).should == false
+      expect(ensureprop.safe_insync?(:ghost)).to eq(false)
     end
 
     it "should be out of sync if it is :ghost and should be :defined" do
       ensureprop.should = :defined
-      ensureprop.safe_insync?(:ghost).should == false
+      expect(ensureprop.safe_insync?(:ghost)).to eq(false)
     end
 
     it "should be out of sync if it is :ghost and should be :mounted" do
       ensureprop.should = :mounted
-      ensureprop.safe_insync?(:ghost).should == false
+      expect(ensureprop.safe_insync?(:ghost)).to eq(false)
     end
 
     it "should be out of sync if it is :ghost and should be :unmounted" do
       ensureprop.should = :unmounted
-      ensureprop.safe_insync?(:ghost).should == false
+      expect(ensureprop.safe_insync?(:ghost)).to eq(false)
     end
   end
 

data/spec/unit/type/nagios_spec.rb

@@ -101,7 +101,7 @@ EOL
     results = parser.parse(NONESCAPED_SEMICOLON_COMMENT)
     results.each do |obj|
       it "should have the proper base type" do
-        obj.should be_a_kind_of(Nagios::Base)
+        expect(obj).to be_a_kind_of(Nagios::Base)
       end
     end
   end
@@ -131,13 +131,13 @@ EOL
     it "should ignore it if it is a comment" do
       parser =  Nagios::Parser.new
       results = parser.parse(NONESCAPED_SEMICOLON_COMMENT)
-      results[0].use.should eql("linux-server")
+      expect(results[0].use).to eql("linux-server")
     end
 
     it "should parse correctly if it is escaped" do
       parser =  Nagios::Parser.new
       results = parser.parse(ESCAPED_SEMICOLON)
-      results[0].command_line.should eql("$USER3$/check_mysql_health --hostname localhost --username nagioschecks --password nagiosCheckPWD --mode sql --name \"SELECT ROUND(Data_length/1024) as Data_kBytes from INFORMATION_SCHEMA.TABLES where TABLE_NAME=\\\"$ARG1$\\\";\" --name2 \"table size\" --units kBytes -w $ARG2$ -c $ARG3$")
+      expect(results[0].command_line).to eql("$USER3$/check_mysql_health --hostname localhost --username nagioschecks --password nagiosCheckPWD --mode sql --name \"SELECT ROUND(Data_length/1024) as Data_kBytes from INFORMATION_SCHEMA.TABLES where TABLE_NAME=\\\"$ARG1$\\\";\" --name2 \"table size\" --units kBytes -w $ARG2$ -c $ARG3$")
     end
   end
 
@@ -154,13 +154,13 @@ EOL
     it "should ignore it at the beginning of a line" do
       parser =  Nagios::Parser.new
       results = parser.parse(LINE_COMMENT_SNIPPET)
-      results[0].command_line.should eql("command_line")
+      expect(results[0].command_line).to eql("command_line")
     end
 
     it "should let it go anywhere else" do
       parser =  Nagios::Parser.new
       results = parser.parse(POUND_SIGN_HASH_SYMBOL_NOT_IN_FIRST_COLUMN)
-      results[0].command_line.should eql("/usr/local/bin/riseup-nagios-client.pl \"$HOSTNAME$ ($SERVICEDESC$) $NOTIFICATIONTYPE$ \#$SERVICEATTEMPT$ $SERVICESTATETYPE$ $SERVICEEXECUTIONTIME$s $SERVICELATENCY$s $SERVICEOUTPUT$ $SERVICEPERFDATA$\"")
+      expect(results[0].command_line).to eql("/usr/local/bin/riseup-nagios-client.pl \"$HOSTNAME$ ($SERVICEDESC$) $NOTIFICATIONTYPE$ \#$SERVICEATTEMPT$ $SERVICESTATETYPE$ $SERVICEEXECUTIONTIME$s $SERVICELATENCY$s $SERVICEOUTPUT$ $SERVICEPERFDATA$\"")
     end
 
   end
@@ -176,7 +176,7 @@ EOL
     it "should parse correctly" do
       parser =  Nagios::Parser.new
       results = parser.parse(ANOTHER_ESCAPED_SEMICOLON)
-      results[0].command_line.should eql("LC_ALL=en_US.UTF-8 /usr/lib/nagios/plugins/check_haproxy -u 'http://blah:blah@$HOSTADDRESS$:8080/haproxy?stats;csv'")
+      expect(results[0].command_line).to eql("LC_ALL=en_US.UTF-8 /usr/lib/nagios/plugins/check_haproxy -u 'http://blah:blah@$HOSTADDRESS$:8080/haproxy?stats;csv'")
     end
   end
 
@@ -188,7 +188,7 @@ EOL
     nagios_type = Nagios::Base.create(:command)
     nagios_type.command_name = results[0].command_name
     nagios_type.command_line = results[0].command_line
-    nagios_type.to_s.should eql(ANOTHER_ESCAPED_SEMICOLON)
+    expect(nagios_type.to_s).to eql(ANOTHER_ESCAPED_SEMICOLON)
   end
 
 end
@@ -199,14 +199,14 @@ describe "Nagios generator" do
     param = '$USER3$/check_mysql_health --hostname localhost --username nagioschecks --password nagiosCheckPWD --mode sql --name "SELECT ROUND(Data_length/1024) as Data_kBytes from INFORMATION_SCHEMA.TABLES where TABLE_NAME=\"$ARG1$\";" --name2 "table size" --units kBytes -w $ARG2$ -c $ARG3$'
     nagios_type = Nagios::Base.create(:command)
     nagios_type.command_line = param
-    nagios_type.to_s.should eql("define command {\n\tcommand_line                   $USER3$/check_mysql_health --hostname localhost --username nagioschecks --password nagiosCheckPWD --mode sql --name \"SELECT ROUND(Data_length/1024) as Data_kBytes from INFORMATION_SCHEMA.TABLES where TABLE_NAME=\\\"$ARG1$\\\"\\;\" --name2 \"table size\" --units kBytes -w $ARG2$ -c $ARG3$\n}\n")
+    expect(nagios_type.to_s).to eql("define command {\n\tcommand_line                   $USER3$/check_mysql_health --hostname localhost --username nagioschecks --password nagiosCheckPWD --mode sql --name \"SELECT ROUND(Data_length/1024) as Data_kBytes from INFORMATION_SCHEMA.TABLES where TABLE_NAME=\\\"$ARG1$\\\"\\;\" --name2 \"table size\" --units kBytes -w $ARG2$ -c $ARG3$\n}\n")
   end
 
   it "should escape ';' if it is not already the case" do
     param = "LC_ALL=en_US.UTF-8 /usr/lib/nagios/plugins/check_haproxy -u 'http://blah:blah@$HOSTADDRESS$:8080/haproxy?stats;csv'"
     nagios_type = Nagios::Base.create(:command)
     nagios_type.command_line = param
-    nagios_type.to_s.should eql("define command {\n\tcommand_line                   LC_ALL=en_US.UTF-8 /usr/lib/nagios/plugins/check_haproxy -u 'http://blah:blah@$HOSTADDRESS$:8080/haproxy?stats\\;csv'\n}\n")
+    expect(nagios_type.to_s).to eql("define command {\n\tcommand_line                   LC_ALL=en_US.UTF-8 /usr/lib/nagios/plugins/check_haproxy -u 'http://blah:blah@$HOSTADDRESS$:8080/haproxy?stats\\;csv'\n}\n")
   end
 
   it "should be idempotent" do
@@ -215,7 +215,7 @@ describe "Nagios generator" do
     nagios_type.command_line = param
     parser =  Nagios::Parser.new
     results = parser.parse(nagios_type.to_s)
-    results[0].command_line.should eql(param)
+    expect(results[0].command_line).to eql(param)
   end
 
   it "should accept FixNum params and convert to string" do
@@ -224,7 +224,7 @@ describe "Nagios generator" do
     nagios_type.first_notification = param
     parser =  Nagios::Parser.new
     results = parser.parse(nagios_type.to_s)
-    results[0].first_notification.should eql(param.to_s)
+    expect(results[0].first_notification).to eql(param.to_s)
   end
 end
 
@@ -233,59 +233,59 @@ describe "Nagios resource types" do
     puppet_type = Puppet::Type.type("nagios_#{name}")
 
     it "should have a valid type for #{name}" do
-      puppet_type.should_not be_nil
+      expect(puppet_type).not_to be_nil
     end
 
     next unless puppet_type
 
     describe puppet_type do
       it "should be defined as a Puppet resource type" do
-        puppet_type.should_not be_nil
+        expect(puppet_type).not_to be_nil
       end
 
       it "should have documentation" do
-        puppet_type.instance_variable_get("@doc").should_not == ""
+        expect(puppet_type.instance_variable_get("@doc")).not_to eq("")
       end
 
       it "should have #{nagios_type.namevar} as its key attribute" do
-        puppet_type.key_attributes.should == [nagios_type.namevar]
+        expect(puppet_type.key_attributes).to eq([nagios_type.namevar])
       end
 
       it "should have documentation for its #{nagios_type.namevar} parameter" do
-        puppet_type.attrclass(nagios_type.namevar).instance_variable_get("@doc").should_not be_nil
+        expect(puppet_type.attrclass(nagios_type.namevar).instance_variable_get("@doc")).not_to be_nil
       end
 
       it "should have an ensure property" do
-        puppet_type.should be_validproperty(:ensure)
+        expect(puppet_type).to be_validproperty(:ensure)
       end
 
       it "should have a target property" do
-        puppet_type.should be_validproperty(:target)
+        expect(puppet_type).to be_validproperty(:target)
       end
 
       it "should have documentation for its target property" do
-        puppet_type.attrclass(:target).instance_variable_get("@doc").should_not be_nil
+        expect(puppet_type.attrclass(:target).instance_variable_get("@doc")).not_to be_nil
       end
 
       [ :owner, :group, :mode ].each do |fileprop|
         it "should have a #{fileprop} parameter" do
-          puppet_type.parameters.should be_include(fileprop)
+          expect(puppet_type.parameters).to be_include(fileprop)
         end
       end
 
       nagios_type.parameters.reject { |param| param == nagios_type.namevar or param.to_s =~ /^[0-9]/ }.each do |param|
         it "should have a #{param} property" do
-          puppet_type.should be_validproperty(param)
+          expect(puppet_type).to be_validproperty(param)
         end
 
         it "should have documentation for its #{param} property" do
-          puppet_type.attrclass(param).instance_variable_get("@doc").should_not be_nil
+          expect(puppet_type.attrclass(param).instance_variable_get("@doc")).not_to be_nil
         end
       end
 
       nagios_type.parameters.find_all { |param| param.to_s =~ /^[0-9]/ }.each do |param|
         it "should have not have a #{param} property" do
-          puppet_type.should_not be_validproperty(:param)
+          expect(puppet_type).not_to be_validproperty(:param)
         end
       end
     end

data/spec/unit/type/noop_metaparam_spec.rb

@@ -12,27 +12,27 @@ describe Puppet::Type.type(:file).attrclass(:noop) do
   end
 
   it "should accept true as a value" do
-    lambda { @file[:noop] = true }.should_not raise_error
+    expect { @file[:noop] = true }.not_to raise_error
   end
 
   it "should accept false as a value" do
-    lambda { @file[:noop] = false }.should_not raise_error
+    expect { @file[:noop] = false }.not_to raise_error
   end
 
   describe "when set on a resource" do
     it "should default to the :noop setting" do
       Puppet[:noop] = true
-      @file.noop.should == true
+      expect(@file.noop).to eq(true)
     end
 
     it "should prefer true values from the attribute" do
       @file[:noop] = true
-      @file.noop.should be_true
+      expect(@file.noop).to be_truthy
     end
 
     it "should prefer false values from the attribute" do
       @file[:noop] = false
-      @file.noop.should be_false
+      expect(@file.noop).to be_falsey
     end
   end
 end

data/spec/unit/type/package/package_settings_spec.rb

@@ -8,12 +8,12 @@ describe Puppet::Type.type(:package) do
   end
 
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
-    described_class.provider_feature(:package_settings).methods.should == [:package_settings_insync?, :package_settings, :package_settings=]
+    expect(described_class.provider_feature(:package_settings).methods).to eq([:package_settings_insync?, :package_settings, :package_settings=])
   end
 
   context "when validating attributes" do
     it "should have a package_settings property" do
-      described_class.attrtype(:package_settings).should == :property
+      expect(described_class.attrtype(:package_settings)).to eq(:property)
     end
   end
 
@@ -36,7 +36,7 @@ describe Puppet::Type.type(:package) do
           end
           it { expect { resource }.to_not raise_error }
           it "should set package_settings to :settings" do
-            resource.value(:package_settings).should be :settings
+            expect(resource.value(:package_settings)).to be :settings
           end
         end
       end
@@ -50,7 +50,7 @@ describe Puppet::Type.type(:package) do
           end
           it { expect { resource }.to_not raise_error }
           it "should set package_settings to :valid_value" do
-            resource.value(:package_settings).should == :valid_value
+            expect(resource.value(:package_settings)).to eq(:valid_value)
           end
         end
         context "and {:package_settings => :invalid_value}" do
@@ -80,7 +80,7 @@ describe Puppet::Type.type(:package) do
             expect { resource }.to_not raise_error 
           end
           it "should set package_settings to :a" do
-            resource.value(:package_settings).should be :a
+            expect(resource.value(:package_settings)).to be :a
           end
         end
       end
@@ -104,19 +104,19 @@ describe Puppet::Type.type(:package) do
       describe "#insync?(:is)" do
         it "returns the result of provider.package_settings_insync?(:should,:is)" do
           resource.provider.expects(:package_settings_insync?).once.with(:should,:is).returns :ok1
-          resource.property(:package_settings).insync?(:is).should be :ok1
+          expect(resource.property(:package_settings).insync?(:is)).to be :ok1
         end
       end
       describe "#should_to_s(:newvalue)" do
         it "returns the result of provider.package_settings_should_to_s(:should,:newvalue)" do
           resource.provider.expects(:package_settings_should_to_s).once.with(:should,:newvalue).returns :ok2
-          resource.property(:package_settings).should_to_s(:newvalue).should be :ok2
+          expect(resource.property(:package_settings).should_to_s(:newvalue)).to be :ok2
         end
       end
       describe "#is_to_s(:currentvalue)" do
         it "returns the result of provider.package_settings_is_to_s(:should,:currentvalue)" do
           resource.provider.expects(:package_settings_is_to_s).once.with(:should,:currentvalue).returns :ok3
-          resource.property(:package_settings).is_to_s(:currentvalue).should be :ok3
+          expect(resource.property(:package_settings).is_to_s(:currentvalue)).to be :ok3
         end
       end
     end
@@ -127,7 +127,7 @@ describe Puppet::Type.type(:package) do
         end
         it "returns the result of provider.package_settings_change_to_s(:currentvalue,:newvalue)" do
           resource.provider.expects(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).returns :ok4
-          resource.property(:package_settings).change_to_s(:currentvalue,:newvalue).should be :ok4
+          expect(resource.property(:package_settings).change_to_s(:currentvalue,:newvalue)).to be :ok4
         end
       end
     end