puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/type/mailalias_spec.rb

@@ -4,18 +4,46 @@ require 'spec_helper'
 describe Puppet::Type.type(:mailalias) do
   include PuppetSpec::Files
 
+  let :tmpfile_path do tmpfile('afile') end
   let :target do tmpfile('mailalias') end
-  let :resource do
+  let :recipient_resource do
     described_class.new(:name => "luke", :recipient => "yay", :target => target)
   end
 
-  it "should be initially absent" do
-    resource.retrieve_resource[:recipient].should == :absent
+  let :file_resource do
+    described_class.new(:name => "lukefile", :file => tmpfile_path, :target => target)
+  end
+
+  it "should be initially absent as a recipient" do
+    expect(recipient_resource.retrieve_resource[:recipient]).to eq(:absent)
+  end
+
+  it "should be initially absent as an included file" do
+    expect(file_resource.retrieve_resource[:file]).to eq(:absent)
   end
 
   it "should try and set the recipient when it does the sync" do
-    resource.retrieve_resource[:recipient].should == :absent
-    resource.property(:recipient).expects(:set).with(["yay"])
-    resource.property(:recipient).sync
+    expect(recipient_resource.retrieve_resource[:recipient]).to eq(:absent)
+    recipient_resource.property(:recipient).expects(:set).with(["yay"])
+    recipient_resource.property(:recipient).sync
+  end
+
+  it "should try and set the included file when it does the sync" do
+    expect(file_resource.retrieve_resource[:file]).to eq(:absent)
+    file_resource.property(:file).expects(:set).with(tmpfile_path)
+    file_resource.property(:file).sync
+  end
+
+  it "should fail when file is not an absolute path" do
+    expect {
+      Puppet::Type.type(:mailalias).new(:name => 'x', :file => 'afile')
+    }.to raise_error Puppet::Error, /File paths must be fully qualified/
+  end
+
+  it "should fail when both file and recipient are specified" do
+    expect {
+      Puppet::Type.type(:mailalias).new(:name => 'x', :file => tmpfile_path,
+					:recipient => 'foo@example.com')
+    }.to raise_error Puppet::Error, /cannot specify both a recipient and a file/
   end
 end

data/spec/unit/type/maillist_spec.rb

@@ -33,8 +33,8 @@ describe maillist do
     @provider.stubs(:aliases).returns({"test1" => 'this will get included', "test2" => 'this will dropped', "test3" => 'this will get included'})
 
     generated = @maillist.generate
-    generated.map{ |x| x.name  }.sort.should == ['test1', 'test3']
-    generated.map{ |x| x.class }.should      == [Puppet::Type::Mailalias, Puppet::Type::Mailalias]
+    expect(generated.map{ |x| x.name  }.sort).to eq(['test1', 'test3'])
+    expect(generated.map{ |x| x.class }).to      eq([Puppet::Type::Mailalias, Puppet::Type::Mailalias])
 
   end
 

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