From 42743614cb13541a2973f28251b1f79a33019d77 Mon Sep 17 00:00:00 2001
From: Ryan McKern <ryan.mckern@puppetlabs.com>
Date: Tue, 13 May 2014 15:01:44 -0700
Subject: (MODULES-905) Add bool2str() and camelcase() for string manipulation

Python likes to have its constants Capitalized, and the capitalize
function only understands strings... so I shave a yak.

bool2str will convert a boolean to its equivalent string value,
and camelcase extends on uppercase & downcase to convert an underscore
delimited string into a camelcased string.
---
 lib/puppet/parser/functions/bool2str.rb  | 30 +++++++++++++++++++++++++++++
 lib/puppet/parser/functions/camelcase.rb | 33 ++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 lib/puppet/parser/functions/bool2str.rb
 create mode 100644 lib/puppet/parser/functions/camelcase.rb

diff --git a/lib/puppet/parser/functions/bool2str.rb b/lib/puppet/parser/functions/bool2str.rb
new file mode 100644
index 0000000..a97d356
--- /dev/null
+++ b/lib/puppet/parser/functions/bool2str.rb
@@ -0,0 +1,30 @@
+#
+# bool2str.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:bool2str, :type => :rvalue, :doc => <<-EOS
+    Converts a boolean to a string.
+    Requires a single boolean or string as an input.
+    EOS
+  ) do |arguments|
+
+    raise(Puppet::ParseError, "bool2str(): Wrong number of arguments " +
+      "given (#{arguments.size} for 1)") if arguments.size < 1
+
+    value = arguments[0]
+    klass = value.class
+
+    # We can have either true or false, or string which resembles boolean ...
+    unless [FalseClass, TrueClass, String].include?(klass)
+      raise(Puppet::ParseError, 'bool2str(): Requires either ' +
+        'boolean or string to work with')
+    end
+
+    result = value.is_a?(String) ? value : value.to_s
+
+    return result
+  end
+end
+
+# vim: set ts=2 sw=2 et :
diff --git a/lib/puppet/parser/functions/camelcase.rb b/lib/puppet/parser/functions/camelcase.rb
new file mode 100644
index 0000000..d7f43f7
--- /dev/null
+++ b/lib/puppet/parser/functions/camelcase.rb
@@ -0,0 +1,33 @@
+#
+#  camelcase.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:camelcase, :type => :rvalue, :doc => <<-EOS
+Converts the case of a string or all strings in an array to camel case.
+    EOS
+  ) do |arguments|
+
+    raise(Puppet::ParseError, "camelcase(): Wrong number of arguments " +
+      "given (#{arguments.size} for 1)") if arguments.size < 1
+
+    value = arguments[0]
+    klass = value.class
+
+    unless [Array, String].include?(klass)
+      raise(Puppet::ParseError, 'camelcase(): Requires either ' +
+        'array or string to work with')
+    end
+
+    if value.is_a?(Array)
+      # Numbers in Puppet are often string-encoded which is troublesome ...
+      result = value.collect { |i| i.is_a?(String) ? i.split('_').map{|e| e.capitalize}.join : i }
+    else
+      result = value.split('_').map{|e| e.capitalize}.join
+    end
+
+    return result
+  end
+end
+
+# vim: set ts=2 sw=2 et :
-- 
cgit v1.2.3


From 0761fcf0433b1c73ff9925d1b8fa20a618f28875 Mon Sep 17 00:00:00 2001
From: Ryan McKern <ryan.mckern@puppetlabs.com>
Date: Tue, 13 May 2014 15:33:49 -0700
Subject: (maint) Add bool2str & camelcase spec tests

---
 spec/unit/puppet/parser/functions/bool2str_spec.rb | 34 ++++++++++++++++++++++
 .../unit/puppet/parser/functions/camelcase_spec.rb | 24 +++++++++++++++
 2 files changed, 58 insertions(+)
 create mode 100755 spec/unit/puppet/parser/functions/bool2str_spec.rb
 create mode 100755 spec/unit/puppet/parser/functions/camelcase_spec.rb

diff --git a/spec/unit/puppet/parser/functions/bool2str_spec.rb b/spec/unit/puppet/parser/functions/bool2str_spec.rb
new file mode 100755
index 0000000..c73f7df
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/bool2str_spec.rb
@@ -0,0 +1,34 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the bool2str function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("bool2str").should == "function_bool2str"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_bool2str([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should convert true to 'true'" do
+    result = scope.function_bool2str([true])
+    result.should(eq('true'))
+  end
+
+  it "should convert true to a string" do
+    result = scope.function_bool2str([true])
+    result.class.should(eq(String))
+  end
+
+  it "should convert false to 'false'" do
+    result = scope.function_bool2str([false])
+    result.should(eq('false'))
+  end
+
+  it "should convert false to a string" do
+    result = scope.function_bool2str([false])
+    result.class.should(eq(String))
+  end
+end
diff --git a/spec/unit/puppet/parser/functions/camelcase_spec.rb b/spec/unit/puppet/parser/functions/camelcase_spec.rb
new file mode 100755
index 0000000..3b1f1d0
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/camelcase_spec.rb
@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the camelcase function" do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("camelcase").should == "function_camelcase"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { scope.function_camelcase([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should capitalize the beginning of a normal string" do
+    result = scope.function_camelcase(["abc"])
+    result.should(eq("Abc"))
+  end
+
+  it "should camelcase an underscore-delimited string" do
+    result = scope.function_camelcase(["aa_bb_cc"])
+    result.should(eq("AaBbCc"))
+  end
+end
-- 
cgit v1.2.3


From 6eaa592cd8d5af097a4624b3d1cead74408aabf2 Mon Sep 17 00:00:00 2001
From: Stephen Benjamin <stephen@bitbin.de>
Date: Wed, 14 May 2014 20:33:57 +0200
Subject: (PUP-2571) add 'before' functionality to file_line

file_line supports adding lines after a match, but there are use cases when
having "before" would be useful. For example, in Debian-based OS's, the last
line of /etc/rc.local is "exit 0" it's an incredible pain to deal with
that scenario today.

This commit adds a 'before' parameter to the file_line type, and implements
it for the ruby provider.
---
 lib/puppet/provider/file_line/ruby.rb            | 16 ++++---
 lib/puppet/type/file_line.rb                     |  4 ++
 spec/unit/puppet/provider/file_line/ruby_spec.rb | 59 ++++++++++++++++++++++++
 spec/unit/puppet/type/file_line_spec.rb          |  8 ++++
 4 files changed, 80 insertions(+), 7 deletions(-)

diff --git a/lib/puppet/provider/file_line/ruby.rb b/lib/puppet/provider/file_line/ruby.rb
index 94e7fac..2cbd172 100644
--- a/lib/puppet/provider/file_line/ruby.rb
+++ b/lib/puppet/provider/file_line/ruby.rb
@@ -9,7 +9,9 @@ Puppet::Type.type(:file_line).provide(:ruby) do
     if resource[:match]
       handle_create_with_match
     elsif resource[:after]
-      handle_create_with_after
+      handle_create_with_position :after
+    elsif resource[:before]
+      handle_create_with_position :before
     else
       append_line
     end
@@ -49,29 +51,29 @@ Puppet::Type.type(:file_line).provide(:ruby) do
     end
   end
 
-  def handle_create_with_after
-    regex = Regexp.new(resource[:after])
+  def handle_create_with_position(position)
+    regex = resource[position] ? Regexp.new(resource[position]) : nil
 
     count = lines.count {|l| l.match(regex)}
 
     case count
-    when 1 # find the line to put our line after
+    when 1 # find the line to put our line before/after
       File.open(resource[:path], 'w') do |fh|
         lines.each do |l|
-          fh.puts(l)
+          fh.puts(l) if position == :after
           if regex.match(l) then
             fh.puts(resource[:line])
           end
+          fh.puts(l) if position == :before
         end
       end
     when 0 # append the line to the end of the file
       append_line
     else
-      raise Puppet::Error, "#{count} lines match pattern '#{resource[:after]}' in file '#{resource[:path]}'.  One or no line must match the pattern."
+      raise Puppet::Error, "#{count} lines match pattern '#{resource[position]}' in file '#{resource[:path]}'.  One or no line must match the pattern."
     end
   end
 
-  ##
   # append the line to the file.
   #
   # @api private
diff --git a/lib/puppet/type/file_line.rb b/lib/puppet/type/file_line.rb
index 323fc4c..bc6745f 100644
--- a/lib/puppet/type/file_line.rb
+++ b/lib/puppet/type/file_line.rb
@@ -46,6 +46,10 @@ Puppet::Type.newtype(:file_line) do
     desc 'An optional value used to specify the line after which we will add any new lines. (Existing lines are added in place)'
   end
 
+  newparam(:before) do
+    desc 'An optional value used to specify the line before which we will add any new lines. (Existing lines are added in place)'
+  end
+
   newparam(:line) do
     desc 'The line to be appended to the file located by the path parameter.'
   end
diff --git a/spec/unit/puppet/provider/file_line/ruby_spec.rb b/spec/unit/puppet/provider/file_line/ruby_spec.rb
index a016b68..d004af4 100755
--- a/spec/unit/puppet/provider/file_line/ruby_spec.rb
+++ b/spec/unit/puppet/provider/file_line/ruby_spec.rb
@@ -183,6 +183,65 @@ describe provider_class do
         end
       end
     end
+
+    describe 'using before' do
+      let :resource do
+        Puppet::Type::File_line.new(
+          {
+            :name  => 'foo',
+            :path  => @tmpfile,
+            :line  => 'inserted = line',
+            :before => '^foo1',
+          }
+        )
+      end
+
+      let :provider do
+        provider_class.new(resource)
+      end
+
+      context 'with one line matching the before expression' do
+        before :each do
+          File.open(@tmpfile, 'w') do |fh|
+            fh.write("foo1\nfoo = blah\nfoo2\nfoo = baz")
+          end
+        end
+
+        it 'inserts the specified line before the line matching the "before" expression' do
+          provider.create
+          File.read(@tmpfile).chomp.should eql("inserted = line\nfoo1\nfoo = blah\nfoo2\nfoo = baz")
+        end
+      end
+
+      context 'with two lines matching the before expression' do
+        before :each do
+          File.open(@tmpfile, 'w') do |fh|
+            fh.write("foo1\nfoo = blah\nfoo2\nfoo1\nfoo = baz")
+          end
+        end
+
+        it 'errors out stating "One or no line must match the pattern"' do
+          expect { provider.create }.to raise_error(Puppet::Error, /One or no line must match the pattern/)
+        end
+      end
+
+      context 'with no lines matching the after expression' do
+        let :content do
+          "foo3\nfoo = blah\nfoo2\nfoo = baz\n"
+        end
+
+        before :each do
+          File.open(@tmpfile, 'w') do |fh|
+            fh.write(content)
+          end
+        end
+
+        it 'appends the specified line to the file' do
+          provider.create
+          File.read(@tmpfile).should eq(content << resource[:line] << "\n")
+        end
+      end
+    end
   end
 
   context "when removing" do
diff --git a/spec/unit/puppet/type/file_line_spec.rb b/spec/unit/puppet/type/file_line_spec.rb
index ab5b81b..b85b9f4 100755
--- a/spec/unit/puppet/type/file_line_spec.rb
+++ b/spec/unit/puppet/type/file_line_spec.rb
@@ -15,6 +15,14 @@ describe Puppet::Type.type(:file_line) do
     file_line[:match] = '^foo.*$'
     file_line[:match].should == '^foo.*$'
   end
+  it 'should accept an after regex' do
+    file_line[:after] = '^foo.*$'
+    file_line[:after].should == '^foo.*$'
+  end
+  it 'should accept a before regex' do
+    file_line[:before] = '^foo.*$'
+    file_line[:before].should == '^foo.*$'
+  end
   it 'should not accept a match regex that does not match the specified line' do
     expect {
       Puppet::Type.type(:file_line).new(
-- 
cgit v1.2.3


From c5b06f9bbca7acc491560c92a73d7e2a153fe0a7 Mon Sep 17 00:00:00 2001
From: Ashley Penney <ashley.penney@puppetlabs.com>
Date: Thu, 15 May 2014 17:28:59 -0400
Subject: Revert "Merge pull request #256 from stbenjam/2571-before"

This reverts commit 8499ebdb7f892f2623295058649c67a5553d4732, reversing
changes made to 08b00d9229961d7b3c3cba997bfb35c8d47e4c4b.
---
 lib/puppet/provider/file_line/ruby.rb            | 16 +++----
 lib/puppet/type/file_line.rb                     |  4 --
 spec/unit/puppet/provider/file_line/ruby_spec.rb | 59 ------------------------
 spec/unit/puppet/type/file_line_spec.rb          |  8 ----
 4 files changed, 7 insertions(+), 80 deletions(-)

diff --git a/lib/puppet/provider/file_line/ruby.rb b/lib/puppet/provider/file_line/ruby.rb
index 2cbd172..94e7fac 100644
--- a/lib/puppet/provider/file_line/ruby.rb
+++ b/lib/puppet/provider/file_line/ruby.rb
@@ -9,9 +9,7 @@ Puppet::Type.type(:file_line).provide(:ruby) do
     if resource[:match]
       handle_create_with_match
     elsif resource[:after]
-      handle_create_with_position :after
-    elsif resource[:before]
-      handle_create_with_position :before
+      handle_create_with_after
     else
       append_line
     end
@@ -51,29 +49,29 @@ Puppet::Type.type(:file_line).provide(:ruby) do
     end
   end
 
-  def handle_create_with_position(position)
-    regex = resource[position] ? Regexp.new(resource[position]) : nil
+  def handle_create_with_after
+    regex = Regexp.new(resource[:after])
 
     count = lines.count {|l| l.match(regex)}
 
     case count
-    when 1 # find the line to put our line before/after
+    when 1 # find the line to put our line after
       File.open(resource[:path], 'w') do |fh|
         lines.each do |l|
-          fh.puts(l) if position == :after
+          fh.puts(l)
           if regex.match(l) then
             fh.puts(resource[:line])
           end
-          fh.puts(l) if position == :before
         end
       end
     when 0 # append the line to the end of the file
       append_line
     else
-      raise Puppet::Error, "#{count} lines match pattern '#{resource[position]}' in file '#{resource[:path]}'.  One or no line must match the pattern."
+      raise Puppet::Error, "#{count} lines match pattern '#{resource[:after]}' in file '#{resource[:path]}'.  One or no line must match the pattern."
     end
   end
 
+  ##
   # append the line to the file.
   #
   # @api private
diff --git a/lib/puppet/type/file_line.rb b/lib/puppet/type/file_line.rb
index bc6745f..323fc4c 100644
--- a/lib/puppet/type/file_line.rb
+++ b/lib/puppet/type/file_line.rb
@@ -46,10 +46,6 @@ Puppet::Type.newtype(:file_line) do
     desc 'An optional value used to specify the line after which we will add any new lines. (Existing lines are added in place)'
   end
 
-  newparam(:before) do
-    desc 'An optional value used to specify the line before which we will add any new lines. (Existing lines are added in place)'
-  end
-
   newparam(:line) do
     desc 'The line to be appended to the file located by the path parameter.'
   end
diff --git a/spec/unit/puppet/provider/file_line/ruby_spec.rb b/spec/unit/puppet/provider/file_line/ruby_spec.rb
index d004af4..a016b68 100755
--- a/spec/unit/puppet/provider/file_line/ruby_spec.rb
+++ b/spec/unit/puppet/provider/file_line/ruby_spec.rb
@@ -183,65 +183,6 @@ describe provider_class do
         end
       end
     end
-
-    describe 'using before' do
-      let :resource do
-        Puppet::Type::File_line.new(
-          {
-            :name  => 'foo',
-            :path  => @tmpfile,
-            :line  => 'inserted = line',
-            :before => '^foo1',
-          }
-        )
-      end
-
-      let :provider do
-        provider_class.new(resource)
-      end
-
-      context 'with one line matching the before expression' do
-        before :each do
-          File.open(@tmpfile, 'w') do |fh|
-            fh.write("foo1\nfoo = blah\nfoo2\nfoo = baz")
-          end
-        end
-
-        it 'inserts the specified line before the line matching the "before" expression' do
-          provider.create
-          File.read(@tmpfile).chomp.should eql("inserted = line\nfoo1\nfoo = blah\nfoo2\nfoo = baz")
-        end
-      end
-
-      context 'with two lines matching the before expression' do
-        before :each do
-          File.open(@tmpfile, 'w') do |fh|
-            fh.write("foo1\nfoo = blah\nfoo2\nfoo1\nfoo = baz")
-          end
-        end
-
-        it 'errors out stating "One or no line must match the pattern"' do
-          expect { provider.create }.to raise_error(Puppet::Error, /One or no line must match the pattern/)
-        end
-      end
-
-      context 'with no lines matching the after expression' do
-        let :content do
-          "foo3\nfoo = blah\nfoo2\nfoo = baz\n"
-        end
-
-        before :each do
-          File.open(@tmpfile, 'w') do |fh|
-            fh.write(content)
-          end
-        end
-
-        it 'appends the specified line to the file' do
-          provider.create
-          File.read(@tmpfile).should eq(content << resource[:line] << "\n")
-        end
-      end
-    end
   end
 
   context "when removing" do
diff --git a/spec/unit/puppet/type/file_line_spec.rb b/spec/unit/puppet/type/file_line_spec.rb
index b85b9f4..ab5b81b 100755
--- a/spec/unit/puppet/type/file_line_spec.rb
+++ b/spec/unit/puppet/type/file_line_spec.rb
@@ -15,14 +15,6 @@ describe Puppet::Type.type(:file_line) do
     file_line[:match] = '^foo.*$'
     file_line[:match].should == '^foo.*$'
   end
-  it 'should accept an after regex' do
-    file_line[:after] = '^foo.*$'
-    file_line[:after].should == '^foo.*$'
-  end
-  it 'should accept a before regex' do
-    file_line[:before] = '^foo.*$'
-    file_line[:before].should == '^foo.*$'
-  end
   it 'should not accept a match regex that does not match the specified line' do
     expect {
       Puppet::Type.type(:file_line).new(
-- 
cgit v1.2.3


From 93c4151edfedb28a0cafa60011c57eb6d76ca6be Mon Sep 17 00:00:00 2001
From: Ryan McKern <ryan.mckern@puppetlabs.com>
Date: Thu, 15 May 2014 15:01:14 -0700
Subject: (MODULES-905) Narrow the confinement in bool2str

Previously, bool2str() accepted a broad array of boolean values and
bare strings, without any attempt to validate that the strings in any
way resembled "true" or "false" (or any of the other values bool2num()
accepts). This commit narrows the input confinement to TrueClass and
FalseClass, which means that bool2str() will only interpolate
strict boolean values now.
---
 lib/puppet/parser/functions/bool2str.rb | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/lib/puppet/parser/functions/bool2str.rb b/lib/puppet/parser/functions/bool2str.rb
index a97d356..fcd3791 100644
--- a/lib/puppet/parser/functions/bool2str.rb
+++ b/lib/puppet/parser/functions/bool2str.rb
@@ -5,7 +5,7 @@
 module Puppet::Parser::Functions
   newfunction(:bool2str, :type => :rvalue, :doc => <<-EOS
     Converts a boolean to a string.
-    Requires a single boolean or string as an input.
+    Requires a single boolean as an input.
     EOS
   ) do |arguments|
 
@@ -15,15 +15,12 @@ module Puppet::Parser::Functions
     value = arguments[0]
     klass = value.class
 
-    # We can have either true or false, or string which resembles boolean ...
-    unless [FalseClass, TrueClass, String].include?(klass)
-      raise(Puppet::ParseError, 'bool2str(): Requires either ' +
-        'boolean or string to work with')
+    # We can have either true or false, and nothing else
+    unless [FalseClass, TrueClass].include?(klass)
+      raise(Puppet::ParseError, 'bool2str(): Requires a boolean to work with')
     end
 
-    result = value.is_a?(String) ? value : value.to_s
-
-    return result
+    return value.to_s
   end
 end
 
-- 
cgit v1.2.3


From 557d38bdc63b9b7d418f4bf0ce736406e71380b7 Mon Sep 17 00:00:00 2001
From: Ryan McKern <ryan.mckern@puppetlabs.com>
Date: Thu, 15 May 2014 16:45:02 -0700
Subject: (MODULES-905) Extend spec tests for bool2str

The extended spec tests validate that the common types of values
that could be passed to bool2str() are rejected.
---
 spec/unit/puppet/parser/functions/bool2str_spec.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/spec/unit/puppet/parser/functions/bool2str_spec.rb b/spec/unit/puppet/parser/functions/bool2str_spec.rb
index c73f7df..bed7e68 100755
--- a/spec/unit/puppet/parser/functions/bool2str_spec.rb
+++ b/spec/unit/puppet/parser/functions/bool2str_spec.rb
@@ -31,4 +31,16 @@ describe "the bool2str function" do
     result = scope.function_bool2str([false])
     result.class.should(eq(String))
   end
+
+  it "should not accept a string" do
+    lambda { scope.function_bool2str(["false"]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should not accept a nil value" do
+    lambda { scope.function_bool2str([nil]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should not accept an undef" do
+    lambda { scope.function_bool2str([:undef]) }.should( raise_error(Puppet::ParseError))
+  end
 end
-- 
cgit v1.2.3


From 08f7553fb66621fb816400609a034582c44c91e4 Mon Sep 17 00:00:00 2001
From: Ashley Penney <ashley.penney@puppetlabs.com>
Date: Tue, 3 Jun 2014 11:11:08 -0400
Subject: Fixes for PE3.3.

---
 spec/acceptance/fqdn_rotate_spec.rb | 1 +
 spec/acceptance/parseyaml_spec.rb   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/spec/acceptance/fqdn_rotate_spec.rb b/spec/acceptance/fqdn_rotate_spec.rb
index b7f8bf8..fc8bea2 100755
--- a/spec/acceptance/fqdn_rotate_spec.rb
+++ b/spec/acceptance/fqdn_rotate_spec.rb
@@ -14,6 +14,7 @@ describe 'fqdn_rotate function', :unless => UNSUPPORTED_PLATFORMS.include?(fact(
       shell("if [ -f #{facts_d}/fqdn.txt ] ; then rm #{facts_d}/fqdn.txt ; fi")
     end
     it 'fqdn_rotates floats' do
+      shell("mkdir -p #{facts_d}")
       shell("echo 'fqdn=fakehost.localdomain' > #{facts_d}/fqdn.txt")
       pp = <<-EOS
       $a = ['a','b','c','d']
diff --git a/spec/acceptance/parseyaml_spec.rb b/spec/acceptance/parseyaml_spec.rb
index 4b4bf3d..5819837 100755
--- a/spec/acceptance/parseyaml_spec.rb
+++ b/spec/acceptance/parseyaml_spec.rb
@@ -26,7 +26,7 @@ describe 'parseyaml function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('o
       EOS
 
       apply_manifest(pp, :expect_failures => true) do |r|
-        expect(r.stderr).to match(/syntax error/)
+        expect(r.stderr).to match(/(syntax error|did not find expected key)/)
       end
     end
 
-- 
cgit v1.2.3


From 6010e9bd932560a61ffb5f955af1e3226fb8d934 Mon Sep 17 00:00:00 2001
From: Ashley Penney <ashley.penney@puppetlabs.com>
Date: Tue, 3 Jun 2014 14:52:10 -0400
Subject: Further fixes to tests for 14.04.

---
 spec/acceptance/ensure_packages_spec.rb | 2 +-
 spec/acceptance/shuffle_spec.rb         | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/spec/acceptance/ensure_packages_spec.rb b/spec/acceptance/ensure_packages_spec.rb
index 145bdc5..aa7b14c 100755
--- a/spec/acceptance/ensure_packages_spec.rb
+++ b/spec/acceptance/ensure_packages_spec.rb
@@ -11,7 +11,7 @@ describe 'ensure_packages function', :unless => UNSUPPORTED_PLATFORMS.include?(f
       EOS
 
       apply_manifest(pp, :expect_changes => true) do |r|
-        expect(r.stdout).to match(/Package\[zsh\]\/ensure: created/)
+        expect(r.stdout).to match(/Package\[zsh\]\/ensure: (created|ensure changed 'purged' to 'present')/)
       end
     end
     it 'ensures a package already declared'
diff --git a/spec/acceptance/shuffle_spec.rb b/spec/acceptance/shuffle_spec.rb
index 02d1201..b840d1f 100755
--- a/spec/acceptance/shuffle_spec.rb
+++ b/spec/acceptance/shuffle_spec.rb
@@ -5,14 +5,14 @@ describe 'shuffle function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('ope
   describe 'success' do
     it 'shuffles arrays' do
       pp = <<-EOS
-      $a = ["the","public","art","galleries"]
+      $a = ["1", "2", "3", "4", "5", "6", "7", "8", "the","public","art","galleries"]
       # Anagram: Large picture halls, I bet
       $o = shuffle($a)
       notice(inline_template('shuffle is <%= @o.inspect %>'))
       EOS
 
       apply_manifest(pp, :catch_failures => true) do |r|
-        expect(r.stdout).to_not match(/shuffle is \["the", "public", "art", "galleries"\]/)
+        expect(r.stdout).to_not match(/shuffle is \["1", "2", "3", "4", "5", "6", "7", "8", "the", "public", "art", "galleries"\]/)
       end
     end
     it 'shuffles strings' do
-- 
cgit v1.2.3


From d65d2354a7458c3281386e7065bd1938d2c2adee Mon Sep 17 00:00:00 2001
From: Ashley Penney <ashley.penney@puppetlabs.com>
Date: Wed, 4 Jun 2014 14:37:45 -0400
Subject: Convert specs to RSpec 2.99.0 syntax with Transpec

This conversion is done by Transpec 2.2.1 with the following command:
    transpec spec/unit

* 53 conversions
    from: obj.should
      to: expect(obj).to

* 19 conversions
    from: == expected
      to: eq(expected)

* 5 conversions
    from: lambda { }.should
      to: expect { }.to

* 2 conversions
    from: be_true
      to: be_truthy

For more details: https://github.com/yujinakayama/transpec#supported-conversions
---
 spec/unit/facter/facter_dot_d_spec.rb              |  4 +--
 spec/unit/facter/pe_version_spec.rb                | 20 ++++++------
 spec/unit/facter/root_home_spec.rb                 |  8 ++---
 spec/unit/facter/util/puppet_settings_spec.rb      |  6 ++--
 spec/unit/puppet/parser/functions/bool2str_spec.rb | 18 +++++------
 .../unit/puppet/parser/functions/camelcase_spec.rb |  8 ++---
 spec/unit/puppet/provider/file_line/ruby_spec.rb   | 36 +++++++++++-----------
 spec/unit/puppet/type/anchor_spec.rb               |  2 +-
 spec/unit/puppet/type/file_line_spec.rb            | 14 ++++-----
 9 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/spec/unit/facter/facter_dot_d_spec.rb b/spec/unit/facter/facter_dot_d_spec.rb
index 2fb72b2..0afadb2 100755
--- a/spec/unit/facter/facter_dot_d_spec.rb
+++ b/spec/unit/facter/facter_dot_d_spec.rb
@@ -13,7 +13,7 @@ describe Facter::Util::DotD do
     end
 
     it 'should return successfully' do
-      Facter.fact(:fake_fact).value.should == 'fake fact'
+      expect(Facter.fact(:fake_fact).value).to eq('fake fact')
     end
   end
 
@@ -26,7 +26,7 @@ describe Facter::Util::DotD do
     end
 
     it 'should return successfully' do
-      Facter.fact(:foo).value.should == '1+1=2'
+      expect(Facter.fact(:foo).value).to eq('1+1=2')
     end
   end
 end
diff --git a/spec/unit/facter/pe_version_spec.rb b/spec/unit/facter/pe_version_spec.rb
index 931c6d4..4d0349e 100755
--- a/spec/unit/facter/pe_version_spec.rb
+++ b/spec/unit/facter/pe_version_spec.rb
@@ -26,23 +26,23 @@ describe "PE Version specs" do
         (major,minor,patch) = version.split(".")
 
         it "Should return true" do
-          Facter.fact(:is_pe).value.should == true
+          expect(Facter.fact(:is_pe).value).to eq(true)
         end
 
         it "Should have a version of #{version}" do
-          Facter.fact(:pe_version).value.should == version
+          expect(Facter.fact(:pe_version).value).to eq(version)
         end
 
         it "Should have a major version of #{major}" do
-          Facter.fact(:pe_major_version).value.should == major
+          expect(Facter.fact(:pe_major_version).value).to eq(major)
         end
 
         it "Should have a minor version of #{minor}" do
-          Facter.fact(:pe_minor_version).value.should == minor
+          expect(Facter.fact(:pe_minor_version).value).to eq(minor)
         end
 
         it "Should have a patch version of #{patch}" do
-          Facter.fact(:pe_patch_version).value.should == patch
+          expect(Facter.fact(:pe_patch_version).value).to eq(patch)
         end
       end
     end
@@ -54,23 +54,23 @@ describe "PE Version specs" do
     end
 
     it "is_pe is false" do
-      Facter.fact(:is_pe).value.should == false
+      expect(Facter.fact(:is_pe).value).to eq(false)
     end
 
     it "pe_version is nil" do
-      Facter.fact(:pe_version).value.should be_nil
+      expect(Facter.fact(:pe_version).value).to be_nil
     end
 
     it "pe_major_version is nil" do
-      Facter.fact(:pe_major_version).value.should be_nil
+      expect(Facter.fact(:pe_major_version).value).to be_nil
     end
 
     it "pe_minor_version is nil" do
-      Facter.fact(:pe_minor_version).value.should be_nil
+      expect(Facter.fact(:pe_minor_version).value).to be_nil
     end
 
     it "Should have a patch version" do
-      Facter.fact(:pe_patch_version).value.should be_nil
+      expect(Facter.fact(:pe_patch_version).value).to be_nil
     end
   end
 end
diff --git a/spec/unit/facter/root_home_spec.rb b/spec/unit/facter/root_home_spec.rb
index 73eb3ea..98fe141 100755
--- a/spec/unit/facter/root_home_spec.rb
+++ b/spec/unit/facter/root_home_spec.rb
@@ -9,7 +9,7 @@ describe Facter::Util::RootHome do
 
     it "should return /" do
       Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
-      Facter::Util::RootHome.get_root_home.should == expected_root_home
+      expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home)
     end
   end
   context "linux" do
@@ -18,7 +18,7 @@ describe Facter::Util::RootHome do
 
     it "should return /root" do
       Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
-      Facter::Util::RootHome.get_root_home.should == expected_root_home
+      expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home)
     end
   end
   context "windows" do
@@ -26,7 +26,7 @@ describe Facter::Util::RootHome do
       Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(nil)
     end
     it "should be nil on windows" do
-      Facter::Util::RootHome.get_root_home.should be_nil
+      expect(Facter::Util::RootHome.get_root_home).to be_nil
     end
   end
 end
@@ -45,7 +45,7 @@ describe 'root_home', :type => :fact do
 
     it "should return /var/root" do
       Facter::Util::Resolution.stubs(:exec).with("dscacheutil -q user -a name root").returns(sample_dscacheutil)
-      Facter.fact(:root_home).value.should == expected_root_home
+      expect(Facter.fact(:root_home).value).to eq(expected_root_home)
     end
   end
 
diff --git a/spec/unit/facter/util/puppet_settings_spec.rb b/spec/unit/facter/util/puppet_settings_spec.rb
index e77779b..c06137d 100755
--- a/spec/unit/facter/util/puppet_settings_spec.rb
+++ b/spec/unit/facter/util/puppet_settings_spec.rb
@@ -11,11 +11,11 @@ describe Facter::Util::PuppetSettings do
       end
 
       it 'should be nil' do
-        subject.with_puppet { Puppet[:vardir] }.should be_nil
+        expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
       end
       it 'should not yield to the block' do
         Puppet.expects(:[]).never
-        subject.with_puppet { Puppet[:vardir] }.should be_nil
+        expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
       end
     end
     context "With Puppet loaded" do
@@ -29,7 +29,7 @@ describe Facter::Util::PuppetSettings do
         subject.with_puppet { Puppet[:vardir] }
       end
       it 'should return the nodes vardir' do
-        subject.with_puppet { Puppet[:vardir] }.should eq vardir
+        expect(subject.with_puppet { Puppet[:vardir] }).to eq vardir
       end
     end
   end
diff --git a/spec/unit/puppet/parser/functions/bool2str_spec.rb b/spec/unit/puppet/parser/functions/bool2str_spec.rb
index bed7e68..b878891 100755
--- a/spec/unit/puppet/parser/functions/bool2str_spec.rb
+++ b/spec/unit/puppet/parser/functions/bool2str_spec.rb
@@ -5,42 +5,42 @@ describe "the bool2str function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("bool2str").should == "function_bool2str"
+    expect(Puppet::Parser::Functions.function("bool2str")).to eq("function_bool2str")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_bool2str([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_bool2str([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert true to 'true'" do
     result = scope.function_bool2str([true])
-    result.should(eq('true'))
+    expect(result).to(eq('true'))
   end
 
   it "should convert true to a string" do
     result = scope.function_bool2str([true])
-    result.class.should(eq(String))
+    expect(result.class).to(eq(String))
   end
 
   it "should convert false to 'false'" do
     result = scope.function_bool2str([false])
-    result.should(eq('false'))
+    expect(result).to(eq('false'))
   end
 
   it "should convert false to a string" do
     result = scope.function_bool2str([false])
-    result.class.should(eq(String))
+    expect(result.class).to(eq(String))
   end
 
   it "should not accept a string" do
-    lambda { scope.function_bool2str(["false"]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_bool2str(["false"]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should not accept a nil value" do
-    lambda { scope.function_bool2str([nil]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_bool2str([nil]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should not accept an undef" do
-    lambda { scope.function_bool2str([:undef]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_bool2str([:undef]) }.to( raise_error(Puppet::ParseError))
   end
 end
diff --git a/spec/unit/puppet/parser/functions/camelcase_spec.rb b/spec/unit/puppet/parser/functions/camelcase_spec.rb
index 3b1f1d0..70382ad 100755
--- a/spec/unit/puppet/parser/functions/camelcase_spec.rb
+++ b/spec/unit/puppet/parser/functions/camelcase_spec.rb
@@ -5,20 +5,20 @@ describe "the camelcase function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("camelcase").should == "function_camelcase"
+    expect(Puppet::Parser::Functions.function("camelcase")).to eq("function_camelcase")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_camelcase([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_camelcase([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should capitalize the beginning of a normal string" do
     result = scope.function_camelcase(["abc"])
-    result.should(eq("Abc"))
+    expect(result).to(eq("Abc"))
   end
 
   it "should camelcase an underscore-delimited string" do
     result = scope.function_camelcase(["aa_bb_cc"])
-    result.should(eq("AaBbCc"))
+    expect(result).to(eq("AaBbCc"))
   end
 end
diff --git a/spec/unit/puppet/provider/file_line/ruby_spec.rb b/spec/unit/puppet/provider/file_line/ruby_spec.rb
index a016b68..d2a129c 100755
--- a/spec/unit/puppet/provider/file_line/ruby_spec.rb
+++ b/spec/unit/puppet/provider/file_line/ruby_spec.rb
@@ -23,17 +23,17 @@ describe provider_class do
       File.open(tmpfile, 'w') do |fh|
         fh.write('foo')
       end
-      provider.exists?.should be_true
+      expect(provider.exists?).to be_truthy
     end
     it 'should detect if the line does not exist in the file' do
       File.open(tmpfile, 'w') do |fh|
         fh.write('foo1')
       end
-      provider.exists?.should be_nil
+      expect(provider.exists?).to be_nil
     end
     it 'should append to an existing file when creating' do
       provider.create
-      File.read(tmpfile).chomp.should == 'foo'
+      expect(File.read(tmpfile).chomp).to eq('foo')
     end
   end
 
@@ -61,9 +61,9 @@ describe provider_class do
         File.open(@tmpfile, 'w') do |fh|
           fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz")
         end
-        @provider.exists?.should be_nil
+        expect(@provider.exists?).to be_nil
         expect { @provider.create }.to raise_error(Puppet::Error, /More than one line.*matches/)
-        File.read(@tmpfile).should eql("foo1\nfoo=blah\nfoo2\nfoo=baz")
+        expect(File.read(@tmpfile)).to eql("foo1\nfoo=blah\nfoo2\nfoo=baz")
       end
 
       it 'should replace all lines that matches' do
@@ -80,9 +80,9 @@ describe provider_class do
         File.open(@tmpfile, 'w') do |fh|
           fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz")
         end
-        @provider.exists?.should be_nil
+        expect(@provider.exists?).to be_nil
         @provider.create
-        File.read(@tmpfile).chomp.should eql("foo1\nfoo = bar\nfoo2\nfoo = bar")
+        expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2\nfoo = bar")
       end
 
       it 'should raise an error with invalid values' do
@@ -103,25 +103,25 @@ describe provider_class do
         File.open(@tmpfile, 'w') do |fh|
           fh.write("foo1\nfoo=blah\nfoo2")
         end
-        @provider.exists?.should be_nil
+        expect(@provider.exists?).to be_nil
         @provider.create
-        File.read(@tmpfile).chomp.should eql("foo1\nfoo = bar\nfoo2")
+        expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2")
       end
       it 'should add a new line if no lines match' do
         File.open(@tmpfile, 'w') do |fh|
           fh.write("foo1\nfoo2")
         end
-        @provider.exists?.should be_nil
+        expect(@provider.exists?).to be_nil
         @provider.create
-        File.read(@tmpfile).should eql("foo1\nfoo2\nfoo = bar\n")
+        expect(File.read(@tmpfile)).to eql("foo1\nfoo2\nfoo = bar\n")
       end
       it 'should do nothing if the exact line already exists' do
         File.open(@tmpfile, 'w') do |fh|
           fh.write("foo1\nfoo = bar\nfoo2")
         end
-        @provider.exists?.should be_true
+        expect(@provider.exists?).to be_truthy
         @provider.create
-        File.read(@tmpfile).chomp.should eql("foo1\nfoo = bar\nfoo2")
+        expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2")
       end
     end
 
@@ -150,7 +150,7 @@ describe provider_class do
 
         it 'inserts the specified line after the line matching the "after" expression' do
           provider.create
-          File.read(@tmpfile).chomp.should eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo = baz")
+          expect(File.read(@tmpfile).chomp).to eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo = baz")
         end
       end
 
@@ -179,7 +179,7 @@ describe provider_class do
 
         it 'appends the specified line to the file' do
           provider.create
-          File.read(@tmpfile).should eq(content << resource[:line] << "\n")
+          expect(File.read(@tmpfile)).to eq(content << resource[:line] << "\n")
         end
       end
     end
@@ -203,7 +203,7 @@ describe provider_class do
         fh.write("foo1\nfoo\nfoo2")
       end
       @provider.destroy
-      File.read(@tmpfile).should eql("foo1\nfoo2")
+      expect(File.read(@tmpfile)).to eql("foo1\nfoo2")
     end
 
     it 'should remove the line without touching the last new line' do
@@ -211,7 +211,7 @@ describe provider_class do
         fh.write("foo1\nfoo\nfoo2\n")
       end
       @provider.destroy
-      File.read(@tmpfile).should eql("foo1\nfoo2\n")
+      expect(File.read(@tmpfile)).to eql("foo1\nfoo2\n")
     end
 
     it 'should remove any occurence of the line' do
@@ -219,7 +219,7 @@ describe provider_class do
         fh.write("foo1\nfoo\nfoo2\nfoo\nfoo")
       end
       @provider.destroy
-      File.read(@tmpfile).should eql("foo1\nfoo2\n")
+      expect(File.read(@tmpfile)).to eql("foo1\nfoo2\n")
     end
   end
 end
diff --git a/spec/unit/puppet/type/anchor_spec.rb b/spec/unit/puppet/type/anchor_spec.rb
index f92065f..c738a27 100755
--- a/spec/unit/puppet/type/anchor_spec.rb
+++ b/spec/unit/puppet/type/anchor_spec.rb
@@ -6,6 +6,6 @@ anchor = Puppet::Type.type(:anchor).new(:name => "ntp::begin")
 
 describe anchor do
   it "should stringify normally" do
-    anchor.to_s.should == "Anchor[ntp::begin]"
+    expect(anchor.to_s).to eq("Anchor[ntp::begin]")
   end
 end
diff --git a/spec/unit/puppet/type/file_line_spec.rb b/spec/unit/puppet/type/file_line_spec.rb
index ab5b81b..9ef49ef 100755
--- a/spec/unit/puppet/type/file_line_spec.rb
+++ b/spec/unit/puppet/type/file_line_spec.rb
@@ -7,13 +7,13 @@ describe Puppet::Type.type(:file_line) do
   end
   it 'should accept a line and path' do
     file_line[:line] = 'my_line'
-    file_line[:line].should == 'my_line'
+    expect(file_line[:line]).to eq('my_line')
     file_line[:path] = '/my/path'
-    file_line[:path].should == '/my/path'
+    expect(file_line[:path]).to eq('/my/path')
   end
   it 'should accept a match regex' do
     file_line[:match] = '^foo.*$'
-    file_line[:match].should == '^foo.*$'
+    expect(file_line[:match]).to eq('^foo.*$')
   end
   it 'should not accept a match regex that does not match the specified line' do
     expect {
@@ -35,7 +35,7 @@ describe Puppet::Type.type(:file_line) do
   end
   it 'should accept posix filenames' do
     file_line[:path] = '/tmp/path'
-    file_line[:path].should == '/tmp/path'
+    expect(file_line[:path]).to eq('/tmp/path')
   end
   it 'should not accept unqualified path' do
     expect { file_line[:path] = 'file' }.to raise_error(Puppet::Error, /File paths must be fully qualified/)
@@ -47,7 +47,7 @@ describe Puppet::Type.type(:file_line) do
     expect { Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'path') }.to raise_error(Puppet::Error, /Both line and path are required attributes/)
   end
   it 'should default to ensure => present' do
-    file_line[:ensure].should eq :present
+    expect(file_line[:ensure]).to eq :present
   end
 
   it "should autorequire the file it manages" do
@@ -59,12 +59,12 @@ describe Puppet::Type.type(:file_line) do
     relationship = file_line.autorequire.find do |rel|
       (rel.source.to_s == "File[/tmp/path]") and (rel.target.to_s == file_line.to_s)
     end
-    relationship.should be_a Puppet::Relationship
+    expect(relationship).to be_a Puppet::Relationship
   end
 
   it "should not autorequire the file it manages if it is not managed" do
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource file_line
-    file_line.autorequire.should be_empty
+    expect(file_line.autorequire).to be_empty
   end
 end
-- 
cgit v1.2.3


From 6287a200af558d277f83b919e8409f6c798eef39 Mon Sep 17 00:00:00 2001
From: Ashley Penney <ashley.penney@puppetlabs.com>
Date: Wed, 4 Jun 2014 14:38:37 -0400
Subject: Convert specs to RSpec 2.99.0 syntax with Transpec

This conversion is done by Transpec 2.2.1 with the following command:
    transpec spec/functions

* 345 conversions
    from: obj.should
      to: expect(obj).to

* 122 conversions
    from: == expected
      to: eq(expected)

* 85 conversions
    from: lambda { }.should
      to: expect { }.to

* 22 conversions
    from: be_true
      to: be_truthy

* 16 conversions
    from: be_false
      to: be_falsey

* 11 conversions
    from: pending
      to: skip

* 9 conversions
    from: it { should ... }
      to: it { is_expected.to ... }

* 5 conversions
    from: =~ [1, 2]
      to: match_array([1, 2])

* 2 conversions
    from: =~ /pattern/
      to: match(/pattern/)

* 2 conversions
    from: obj.should_not
      to: expect(obj).not_to

For more details: https://github.com/yujinakayama/transpec#supported-conversions
---
 spec/functions/abs_spec.rb                 |  8 ++---
 spec/functions/any2array_spec.rb           | 20 ++++++------
 spec/functions/base64_spec.rb              |  6 ++--
 spec/functions/bool2num_spec.rb            |  8 ++---
 spec/functions/capitalize_spec.rb          |  6 ++--
 spec/functions/chomp_spec.rb               |  6 ++--
 spec/functions/chop_spec.rb                |  6 ++--
 spec/functions/concat_spec.rb              | 10 +++---
 spec/functions/count_spec.rb               | 10 +++---
 spec/functions/deep_merge_spec.rb          | 52 +++++++++++++++---------------
 spec/functions/defined_with_params_spec.rb | 18 +++++------
 spec/functions/delete_at_spec.rb           |  8 ++---
 spec/functions/delete_spec.rb              | 20 ++++++------
 spec/functions/delete_undef_values_spec.rb | 16 ++++-----
 spec/functions/delete_values_spec.rb       | 16 ++++-----
 spec/functions/difference_spec.rb          |  6 ++--
 spec/functions/dirname_spec.rb             |  8 ++---
 spec/functions/downcase_spec.rb            |  8 ++---
 spec/functions/empty_spec.rb               |  8 ++---
 spec/functions/flatten_spec.rb             | 10 +++---
 spec/functions/floor_spec.rb               | 14 ++++----
 spec/functions/fqdn_rotate_spec.rb         | 10 +++---
 spec/functions/get_module_path_spec.rb     |  8 ++---
 spec/functions/getparam_spec.rb            |  2 +-
 spec/functions/getvar_spec.rb              |  6 ++--
 spec/functions/grep_spec.rb                |  6 ++--
 spec/functions/has_interface_with_spec.rb  | 20 ++++++------
 spec/functions/has_ip_address_spec.rb      |  8 ++---
 spec/functions/has_ip_network_spec.rb      |  6 ++--
 spec/functions/has_key_spec.rb             | 10 +++---
 spec/functions/hash_spec.rb                |  6 ++--
 spec/functions/intersection_spec.rb        |  6 ++--
 spec/functions/is_array_spec.rb            | 10 +++---
 spec/functions/is_bool_spec.rb             | 16 ++++-----
 spec/functions/is_domain_name_spec.rb      | 24 +++++++-------
 spec/functions/is_float_spec.rb            | 12 +++----
 spec/functions/is_function_available.rb    |  8 ++---
 spec/functions/is_hash_spec.rb             | 10 +++---
 spec/functions/is_integer_spec.rb          | 26 +++++++--------
 spec/functions/is_ip_address_spec.rb       | 14 ++++----
 spec/functions/is_mac_address_spec.rb      | 10 +++---
 spec/functions/is_numeric_spec.rb          | 28 ++++++++--------
 spec/functions/is_string_spec.rb           | 12 +++----
 spec/functions/join_keys_to_values_spec.rb | 16 ++++-----
 spec/functions/join_spec.rb                |  6 ++--
 spec/functions/keys_spec.rb                |  6 ++--
 spec/functions/loadyaml_spec.rb            |  4 +--
 spec/functions/lstrip_spec.rb              |  6 ++--
 spec/functions/max_spec.rb                 | 10 +++---
 spec/functions/member_spec.rb              |  8 ++---
 spec/functions/merge_spec.rb               | 14 ++++----
 spec/functions/min_spec.rb                 | 10 +++---
 spec/functions/num2bool_spec.rb            | 26 +++++++--------
 spec/functions/parsejson_spec.rb           |  6 ++--
 spec/functions/parseyaml_spec.rb           |  6 ++--
 spec/functions/pick_default_spec.rb        | 24 +++++++-------
 spec/functions/pick_spec.rb                | 12 +++----
 spec/functions/prefix_spec.rb              |  2 +-
 spec/functions/range_spec.rb               | 22 ++++++-------
 spec/functions/reject_spec.rb              |  6 ++--
 spec/functions/reverse_spec.rb             |  6 ++--
 spec/functions/rstrip_spec.rb              |  8 ++---
 spec/functions/shuffle_spec.rb             |  8 ++---
 spec/functions/size_spec.rb                |  8 ++---
 spec/functions/sort_spec.rb                |  8 ++---
 spec/functions/squeeze_spec.rb             |  8 ++---
 spec/functions/str2bool_spec.rb            | 12 +++----
 spec/functions/str2saltedsha512_spec.rb    |  6 ++--
 spec/functions/strftime_spec.rb            | 10 +++---
 spec/functions/strip_spec.rb               |  6 ++--
 spec/functions/suffix_spec.rb              |  2 +-
 spec/functions/swapcase_spec.rb            |  6 ++--
 spec/functions/time_spec.rb                | 10 +++---
 spec/functions/to_bytes_spec.rb            | 22 ++++++-------
 spec/functions/type_spec.rb                | 16 ++++-----
 spec/functions/union_spec.rb               |  6 ++--
 spec/functions/unique_spec.rb              |  8 ++---
 spec/functions/upcase_spec.rb              |  8 ++---
 spec/functions/uriescape_spec.rb           |  8 ++---
 spec/functions/validate_slength_spec.rb    |  2 +-
 spec/functions/values_at_spec.rb           | 14 ++++----
 spec/functions/values_spec.rb              | 12 +++----
 spec/functions/zip_spec.rb                 |  4 +--
 83 files changed, 452 insertions(+), 452 deletions(-)

diff --git a/spec/functions/abs_spec.rb b/spec/functions/abs_spec.rb
index c0b4297..3c25ce2 100755
--- a/spec/functions/abs_spec.rb
+++ b/spec/functions/abs_spec.rb
@@ -6,20 +6,20 @@ describe "the abs function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("abs").should == "function_abs"
+    expect(Puppet::Parser::Functions.function("abs")).to eq("function_abs")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_abs([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert a negative number into a positive" do
     result = scope.function_abs(["-34"])
-    result.should(eq(34))
+    expect(result).to(eq(34))
   end
 
   it "should do nothing with a positive number" do
     result = scope.function_abs(["5678"])
-    result.should(eq(5678))
+    expect(result).to(eq(5678))
   end
 end
diff --git a/spec/functions/any2array_spec.rb b/spec/functions/any2array_spec.rb
index b266e84..87cd04b 100755
--- a/spec/functions/any2array_spec.rb
+++ b/spec/functions/any2array_spec.rb
@@ -5,51 +5,51 @@ describe "the any2array function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("any2array").should == "function_any2array"
+    expect(Puppet::Parser::Functions.function("any2array")).to eq("function_any2array")
   end
 
   it "should return an empty array if there is less than 1 argument" do
     result = scope.function_any2array([])
-    result.should(eq([]))
+    expect(result).to(eq([]))
   end
 
   it "should convert boolean true to [ true ] " do
     result = scope.function_any2array([true])
-    result.should(eq([true]))
+    expect(result).to(eq([true]))
   end
 
   it "should convert one object to [object]" do
     result = scope.function_any2array(['one'])
-    result.should(eq(['one']))
+    expect(result).to(eq(['one']))
   end
 
   it "should convert multiple objects to [objects]" do
     result = scope.function_any2array(['one', 'two'])
-    result.should(eq(['one', 'two']))
+    expect(result).to(eq(['one', 'two']))
   end
 
   it "should return empty array it was called with" do
     result = scope.function_any2array([[]])
-    result.should(eq([]))
+    expect(result).to(eq([]))
   end
 
   it "should return one-member array it was called with" do
     result = scope.function_any2array([['string']])
-    result.should(eq(['string']))
+    expect(result).to(eq(['string']))
   end
 
   it "should return multi-member array it was called with" do
     result = scope.function_any2array([['one', 'two']])
-    result.should(eq(['one', 'two']))
+    expect(result).to(eq(['one', 'two']))
   end
 
   it "should return members of a hash it was called with" do
     result = scope.function_any2array([{ 'key' => 'value' }])
-    result.should(eq(['key', 'value']))
+    expect(result).to(eq(['key', 'value']))
   end
 
   it "should return an empty array if it was called with an empty hash" do
     result = scope.function_any2array([{ }])
-    result.should(eq([]))
+    expect(result).to(eq([]))
   end
 end
diff --git a/spec/functions/base64_spec.rb b/spec/functions/base64_spec.rb
index 5faa5e6..e93fafc 100755
--- a/spec/functions/base64_spec.rb
+++ b/spec/functions/base64_spec.rb
@@ -6,7 +6,7 @@ describe "the base64 function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("base64").should == "function_base64"
+    expect(Puppet::Parser::Functions.function("base64")).to eq("function_base64")
   end
 
   it "should raise a ParseError if there are other than 2 arguments" do
@@ -25,10 +25,10 @@ describe "the base64 function" do
 
   it "should encode a encoded string" do
     result = scope.function_base64(["encode",'thestring'])
-    result.should =~ /\AdGhlc3RyaW5n\n\Z/
+    expect(result).to match(/\AdGhlc3RyaW5n\n\Z/)
   end
   it "should decode a base64 encoded string" do
     result = scope.function_base64(["decode",'dGhlc3RyaW5n'])
-    result.should == 'thestring'
+    expect(result).to eq('thestring')
   end
 end
diff --git a/spec/functions/bool2num_spec.rb b/spec/functions/bool2num_spec.rb
index 518ac85..fbf461b 100755
--- a/spec/functions/bool2num_spec.rb
+++ b/spec/functions/bool2num_spec.rb
@@ -5,20 +5,20 @@ describe "the bool2num function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("bool2num").should == "function_bool2num"
+    expect(Puppet::Parser::Functions.function("bool2num")).to eq("function_bool2num")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_bool2num([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert true to 1" do
     result = scope.function_bool2num([true])
-    result.should(eq(1))
+    expect(result).to(eq(1))
   end
 
   it "should convert false to 0" do
     result = scope.function_bool2num([false])
-    result.should(eq(0))
+    expect(result).to(eq(0))
   end
 end
diff --git a/spec/functions/capitalize_spec.rb b/spec/functions/capitalize_spec.rb
index 69c9758..0cc2d76 100755
--- a/spec/functions/capitalize_spec.rb
+++ b/spec/functions/capitalize_spec.rb
@@ -5,15 +5,15 @@ describe "the capitalize function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("capitalize").should == "function_capitalize"
+    expect(Puppet::Parser::Functions.function("capitalize")).to eq("function_capitalize")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_capitalize([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should capitalize the beginning of a string" do
     result = scope.function_capitalize(["abc"])
-    result.should(eq("Abc"))
+    expect(result).to(eq("Abc"))
   end
 end
diff --git a/spec/functions/chomp_spec.rb b/spec/functions/chomp_spec.rb
index e425365..d2ae287 100755
--- a/spec/functions/chomp_spec.rb
+++ b/spec/functions/chomp_spec.rb
@@ -5,15 +5,15 @@ describe "the chomp function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("chomp").should == "function_chomp"
+    expect(Puppet::Parser::Functions.function("chomp")).to eq("function_chomp")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_chomp([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should chomp the end of a string" do
     result = scope.function_chomp(["abc\n"])
-    result.should(eq("abc"))
+    expect(result).to(eq("abc"))
   end
 end
diff --git a/spec/functions/chop_spec.rb b/spec/functions/chop_spec.rb
index 9e466de..d9dbb88 100755
--- a/spec/functions/chop_spec.rb
+++ b/spec/functions/chop_spec.rb
@@ -5,15 +5,15 @@ describe "the chop function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("chop").should == "function_chop"
+    expect(Puppet::Parser::Functions.function("chop")).to eq("function_chop")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_chop([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should chop the end of a string" do
     result = scope.function_chop(["asdf\n"])
-    result.should(eq("asdf"))
+    expect(result).to(eq("asdf"))
   end
 end
diff --git a/spec/functions/concat_spec.rb b/spec/functions/concat_spec.rb
index 6e67620..b853b4c 100755
--- a/spec/functions/concat_spec.rb
+++ b/spec/functions/concat_spec.rb
@@ -5,26 +5,26 @@ describe "the concat function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should raise a ParseError if the client does not provide two arguments" do
-    lambda { scope.function_concat([]) }.should(raise_error(Puppet::ParseError))
+    expect { scope.function_concat([]) }.to(raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if the first parameter is not an array" do
-    lambda { scope.function_concat([1, []])}.should(raise_error(Puppet::ParseError))
+    expect { scope.function_concat([1, []])}.to(raise_error(Puppet::ParseError))
   end
 
   it "should be able to concat an array" do
     result = scope.function_concat([['1','2','3'],['4','5','6']])
-    result.should(eq(['1','2','3','4','5','6']))
+    expect(result).to(eq(['1','2','3','4','5','6']))
   end
 
   it "should be able to concat a primitive to an array" do
     result = scope.function_concat([['1','2','3'],'4'])
-    result.should(eq(['1','2','3','4']))
+    expect(result).to(eq(['1','2','3','4']))
   end
 
   it "should not accidentally flatten nested arrays" do
     result = scope.function_concat([['1','2','3'],[['4','5'],'6']])
-    result.should(eq(['1','2','3',['4','5'],'6']))
+    expect(result).to(eq(['1','2','3',['4','5'],'6']))
   end
 
 end
diff --git a/spec/functions/count_spec.rb b/spec/functions/count_spec.rb
index 2453815..f8f1d48 100755
--- a/spec/functions/count_spec.rb
+++ b/spec/functions/count_spec.rb
@@ -6,23 +6,23 @@ describe "the count function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("count").should == "function_count"
+    expect(Puppet::Parser::Functions.function("count")).to eq("function_count")
   end
 
   it "should raise a ArgumentError if there is more than 2 arguments" do
-    lambda { scope.function_count(['foo', 'bar', 'baz']) }.should( raise_error(ArgumentError))
+    expect { scope.function_count(['foo', 'bar', 'baz']) }.to( raise_error(ArgumentError))
   end
 
   it "should be able to count arrays" do
-    scope.function_count([["1","2","3"]]).should(eq(3))
+    expect(scope.function_count([["1","2","3"]])).to(eq(3))
   end
 
   it "should be able to count matching elements in arrays" do
-    scope.function_count([["1", "2", "2"], "2"]).should(eq(2))
+    expect(scope.function_count([["1", "2", "2"], "2"])).to(eq(2))
   end
 
   it "should not count nil or empty strings" do
-    scope.function_count([["foo","bar",nil,""]]).should(eq(2))
+    expect(scope.function_count([["foo","bar",nil,""]])).to(eq(2))
   end
 
   it 'does not count an undefined hash key or an out of bound array index (which are both :undef)' do
diff --git a/spec/functions/deep_merge_spec.rb b/spec/functions/deep_merge_spec.rb
index f134701..7087904 100755
--- a/spec/functions/deep_merge_spec.rb
+++ b/spec/functions/deep_merge_spec.rb
@@ -7,7 +7,7 @@ describe Puppet::Parser::Functions.function(:deep_merge) do
 
   describe 'when calling deep_merge from puppet' do
     it "should not compile when no arguments are passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = '$x = deep_merge()'
       expect {
         scope.compiler.compile
@@ -15,7 +15,7 @@ describe Puppet::Parser::Functions.function(:deep_merge) do
     end
 
     it "should not compile when 1 argument is passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = "$my_hash={'one' => 1}\n$x = deep_merge($my_hash)"
       expect {
         scope.compiler.compile
@@ -35,71 +35,71 @@ describe Puppet::Parser::Functions.function(:deep_merge) do
 
     it 'should be able to deep_merge two hashes' do
       new_hash = scope.function_deep_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
-      new_hash['one'].should   == '1'
-      new_hash['two'].should   == '2'
-      new_hash['three'].should == '2'
+      expect(new_hash['one']).to   eq('1')
+      expect(new_hash['two']).to   eq('2')
+      expect(new_hash['three']).to eq('2')
     end
 
     it 'should deep_merge multiple hashes' do
       hash = scope.function_deep_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
-      hash['one'].should == '3'
+      expect(hash['one']).to eq('3')
     end
 
     it 'should accept empty hashes' do
-      scope.function_deep_merge([{},{},{}]).should == {}
+      expect(scope.function_deep_merge([{},{},{}])).to eq({})
     end
 
     it 'should deep_merge subhashes' do
       hash = scope.function_deep_merge([{'one' => 1}, {'two' => 2, 'three' => { 'four' => 4 } }])
-      hash['one'].should == 1
-      hash['two'].should == 2
-      hash['three'].should == { 'four' => 4 }
+      expect(hash['one']).to eq(1)
+      expect(hash['two']).to eq(2)
+      expect(hash['three']).to eq({ 'four' => 4 })
     end
 
     it 'should append to subhashes' do
       hash = scope.function_deep_merge([{'one' => { 'two' => 2 } }, { 'one' => { 'three' => 3 } }])
-      hash['one'].should == { 'two' => 2, 'three' => 3 }
+      expect(hash['one']).to eq({ 'two' => 2, 'three' => 3 })
     end
 
     it 'should append to subhashes 2' do
       hash = scope.function_deep_merge([{'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }, {'two' => 'dos', 'three' => { 'five' => 5 } }])
-      hash['one'].should == 1
-      hash['two'].should == 'dos'
-      hash['three'].should == { 'four' => 4, 'five' => 5 }
+      expect(hash['one']).to eq(1)
+      expect(hash['two']).to eq('dos')
+      expect(hash['three']).to eq({ 'four' => 4, 'five' => 5 })
     end
 
     it 'should append to subhashes 3' do
       hash = scope.function_deep_merge([{ 'key1' => { 'a' => 1, 'b' => 2 }, 'key2' => { 'c' => 3 } }, { 'key1' => { 'b' => 99 } }])
-      hash['key1'].should == { 'a' => 1, 'b' => 99 }
-      hash['key2'].should == { 'c' => 3 }
+      expect(hash['key1']).to eq({ 'a' => 1, 'b' => 99 })
+      expect(hash['key2']).to eq({ 'c' => 3 })
     end
 
     it 'should not change the original hashes' do
       hash1 = {'one' => { 'two' => 2 } }
       hash2 = { 'one' => { 'three' => 3 } }
       hash = scope.function_deep_merge([hash1, hash2])
-      hash1.should == {'one' => { 'two' => 2 } }
-      hash2.should == { 'one' => { 'three' => 3 } }
-      hash['one'].should == { 'two' => 2, 'three' => 3 }
+      expect(hash1).to eq({'one' => { 'two' => 2 } })
+      expect(hash2).to eq({ 'one' => { 'three' => 3 } })
+      expect(hash['one']).to eq({ 'two' => 2, 'three' => 3 })
     end
 
     it 'should not change the original hashes 2' do
       hash1 = {'one' => { 'two' => [1,2] } }
       hash2 = { 'one' => { 'three' => 3 } }
       hash = scope.function_deep_merge([hash1, hash2])
-      hash1.should == {'one' => { 'two' => [1,2] } }
-      hash2.should == { 'one' => { 'three' => 3 } }
-      hash['one'].should == { 'two' => [1,2], 'three' => 3 }
+      expect(hash1).to eq({'one' => { 'two' => [1,2] } })
+      expect(hash2).to eq({ 'one' => { 'three' => 3 } })
+      expect(hash['one']).to eq({ 'two' => [1,2], 'three' => 3 })
     end
 
     it 'should not change the original hashes 3' do
       hash1 = {'one' => { 'two' => [1,2, {'two' => 2} ] } }
       hash2 = { 'one' => { 'three' => 3 } }
       hash = scope.function_deep_merge([hash1, hash2])
-      hash1.should == {'one' => { 'two' => [1,2, {'two' => 2}] } }
-      hash2.should == { 'one' => { 'three' => 3 } }
-      hash['one'].should == { 'two' => [1,2, {'two' => 2} ], 'three' => 3 }
-      hash['one']['two'].should == [1,2, {'two' => 2}]
+      expect(hash1).to eq({'one' => { 'two' => [1,2, {'two' => 2}] } })
+      expect(hash2).to eq({ 'one' => { 'three' => 3 } })
+      expect(hash['one']).to eq({ 'two' => [1,2, {'two' => 2} ], 'three' => 3 })
+      expect(hash['one']['two']).to eq([1,2, {'two' => 2}])
     end
   end
 end
diff --git a/spec/functions/defined_with_params_spec.rb b/spec/functions/defined_with_params_spec.rb
index 28dbab3..3590304 100755
--- a/spec/functions/defined_with_params_spec.rb
+++ b/spec/functions/defined_with_params_spec.rb
@@ -4,16 +4,16 @@ require 'spec_helper'
 require 'rspec-puppet'
 describe 'defined_with_params' do
   describe 'when a resource is not specified' do
-    it { should run.with_params().and_raise_error(ArgumentError) }
+    it { is_expected.to run.with_params().and_raise_error(ArgumentError) }
   end
   describe 'when compared against a resource with no attributes' do
     let :pre_condition do
       'user { "dan": }'
     end
     it do
-      should run.with_params('User[dan]', {}).and_return(true)
-      should run.with_params('User[bob]', {}).and_return(false)
-      should run.with_params('User[dan]', {'foo' => 'bar'}).and_return(false)
+      is_expected.to run.with_params('User[dan]', {}).and_return(true)
+      is_expected.to run.with_params('User[bob]', {}).and_return(false)
+      is_expected.to run.with_params('User[dan]', {'foo' => 'bar'}).and_return(false)
     end
   end
 
@@ -22,14 +22,14 @@ describe 'defined_with_params' do
       'user { "dan": ensure => present, shell => "/bin/csh", managehome => false}'
     end
     it do
-      should run.with_params('User[dan]', {}).and_return(true)
-      should run.with_params('User[dan]', '').and_return(true)
-      should run.with_params('User[dan]', {'ensure' => 'present'}
+      is_expected.to run.with_params('User[dan]', {}).and_return(true)
+      is_expected.to run.with_params('User[dan]', '').and_return(true)
+      is_expected.to run.with_params('User[dan]', {'ensure' => 'present'}
                             ).and_return(true)
-      should run.with_params('User[dan]',
+      is_expected.to run.with_params('User[dan]',
                              {'ensure' => 'present', 'managehome' => false}
                             ).and_return(true)
-      should run.with_params('User[dan]',
+      is_expected.to run.with_params('User[dan]',
                              {'ensure' => 'absent', 'managehome' => false}
                             ).and_return(false)
     end
diff --git a/spec/functions/delete_at_spec.rb b/spec/functions/delete_at_spec.rb
index 593cf45..7c20aec 100755
--- a/spec/functions/delete_at_spec.rb
+++ b/spec/functions/delete_at_spec.rb
@@ -5,21 +5,21 @@ describe "the delete_at function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("delete_at").should == "function_delete_at"
+    expect(Puppet::Parser::Functions.function("delete_at")).to eq("function_delete_at")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete_at([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should delete an item at specified location from an array" do
     result = scope.function_delete_at([['a','b','c'],1])
-    result.should(eq(['a','c']))
+    expect(result).to(eq(['a','c']))
   end
 
   it "should not change origin array passed as argument" do
     origin_array = ['a','b','c','d']
     result = scope.function_delete_at([origin_array, 1])
-    origin_array.should(eq(['a','b','c','d']))
+    expect(origin_array).to(eq(['a','b','c','d']))
   end
 end
diff --git a/spec/functions/delete_spec.rb b/spec/functions/delete_spec.rb
index 1508a63..39b3176 100755
--- a/spec/functions/delete_spec.rb
+++ b/spec/functions/delete_spec.rb
@@ -5,52 +5,52 @@ describe "the delete function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("delete").should == "function_delete"
+    expect(Puppet::Parser::Functions.function("delete")).to eq("function_delete")
   end
 
   it "should raise a ParseError if there are fewer than 2 arguments" do
-    lambda { scope.function_delete([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there are greater than 2 arguments" do
-    lambda { scope.function_delete([[], 'foo', 'bar']) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete([[], 'foo', 'bar']) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a TypeError if a number is passed as the first argument" do
-    lambda { scope.function_delete([1, 'bar']) }.should( raise_error(TypeError))
+    expect { scope.function_delete([1, 'bar']) }.to( raise_error(TypeError))
   end
 
   it "should delete all instances of an element from an array" do
     result = scope.function_delete([['a','b','c','b'],'b'])
-    result.should(eq(['a','c']))
+    expect(result).to(eq(['a','c']))
   end
 
   it "should delete all instances of a substring from a string" do
     result = scope.function_delete(['foobarbabarz','bar'])
-    result.should(eq('foobaz'))
+    expect(result).to(eq('foobaz'))
   end
 
   it "should delete a key from a hash" do
     result = scope.function_delete([{ 'a' => 1, 'b' => 2, 'c' => 3 },'b'])
-    result.should(eq({ 'a' => 1, 'c' => 3 }))
+    expect(result).to(eq({ 'a' => 1, 'c' => 3 }))
   end
 
   it "should not change origin array passed as argument" do
     origin_array = ['a','b','c','d']
     result = scope.function_delete([origin_array, 'b'])
-    origin_array.should(eq(['a','b','c','d']))
+    expect(origin_array).to(eq(['a','b','c','d']))
   end
 
   it "should not change the origin string passed as argument" do
     origin_string = 'foobarbabarz'
     result = scope.function_delete([origin_string,'bar'])
-    origin_string.should(eq('foobarbabarz'))
+    expect(origin_string).to(eq('foobarbabarz'))
   end
 
   it "should not change origin hash passed as argument" do
     origin_hash = { 'a' => 1, 'b' => 2, 'c' => 3 }
     result = scope.function_delete([origin_hash, 'b'])
-    origin_hash.should(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
+    expect(origin_hash).to(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
   end
 
 end
diff --git a/spec/functions/delete_undef_values_spec.rb b/spec/functions/delete_undef_values_spec.rb
index b341d88..dc67953 100755
--- a/spec/functions/delete_undef_values_spec.rb
+++ b/spec/functions/delete_undef_values_spec.rb
@@ -5,37 +5,37 @@ describe "the delete_undef_values function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("delete_undef_values").should == "function_delete_undef_values"
+    expect(Puppet::Parser::Functions.function("delete_undef_values")).to eq("function_delete_undef_values")
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
-    lambda { scope.function_delete_undef_values([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete_undef_values([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if the argument is not Array nor Hash" do
-    lambda { scope.function_delete_undef_values(['']) }.should( raise_error(Puppet::ParseError))
-    lambda { scope.function_delete_undef_values([nil]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete_undef_values(['']) }.to( raise_error(Puppet::ParseError))
+    expect { scope.function_delete_undef_values([nil]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should delete all undef items from Array and only these" do
     result = scope.function_delete_undef_values([['a',:undef,'c','undef']])
-    result.should(eq(['a','c','undef']))
+    expect(result).to(eq(['a','c','undef']))
   end
 
   it "should delete all undef items from Hash and only these" do
     result = scope.function_delete_undef_values([{'a'=>'A','b'=>:undef,'c'=>'C','d'=>'undef'}])
-    result.should(eq({'a'=>'A','c'=>'C','d'=>'undef'}))
+    expect(result).to(eq({'a'=>'A','c'=>'C','d'=>'undef'}))
   end
 
   it "should not change origin array passed as argument" do
     origin_array = ['a',:undef,'c','undef']
     result = scope.function_delete_undef_values([origin_array])
-    origin_array.should(eq(['a',:undef,'c','undef']))
+    expect(origin_array).to(eq(['a',:undef,'c','undef']))
   end
 
   it "should not change origin hash passed as argument" do
     origin_hash = { 'a' => 1, 'b' => :undef, 'c' => 'undef' }
     result = scope.function_delete_undef_values([origin_hash])
-    origin_hash.should(eq({ 'a' => 1, 'b' => :undef, 'c' => 'undef' }))
+    expect(origin_hash).to(eq({ 'a' => 1, 'b' => :undef, 'c' => 'undef' }))
   end
 end
diff --git a/spec/functions/delete_values_spec.rb b/spec/functions/delete_values_spec.rb
index 8d7f231..4f4d411 100755
--- a/spec/functions/delete_values_spec.rb
+++ b/spec/functions/delete_values_spec.rb
@@ -5,32 +5,32 @@ describe "the delete_values function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("delete_values").should == "function_delete_values"
+    expect(Puppet::Parser::Functions.function("delete_values")).to eq("function_delete_values")
   end
 
   it "should raise a ParseError if there are fewer than 2 arguments" do
-    lambda { scope.function_delete_values([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete_values([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there are greater than 2 arguments" do
-    lambda { scope.function_delete_values([[], 'foo', 'bar']) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_delete_values([[], 'foo', 'bar']) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a TypeError if the argument is not a hash" do
-    lambda { scope.function_delete_values([1,'bar']) }.should( raise_error(TypeError))
-    lambda { scope.function_delete_values(['foo','bar']) }.should( raise_error(TypeError))
-    lambda { scope.function_delete_values([[],'bar']) }.should( raise_error(TypeError))
+    expect { scope.function_delete_values([1,'bar']) }.to( raise_error(TypeError))
+    expect { scope.function_delete_values(['foo','bar']) }.to( raise_error(TypeError))
+    expect { scope.function_delete_values([[],'bar']) }.to( raise_error(TypeError))
   end
 
   it "should delete all instances of a value from a hash" do
     result = scope.function_delete_values([{ 'a'=>'A', 'b'=>'B', 'B'=>'C', 'd'=>'B' },'B'])
-    result.should(eq({ 'a'=>'A', 'B'=>'C' }))
+    expect(result).to(eq({ 'a'=>'A', 'B'=>'C' }))
   end
 
   it "should not change origin hash passed as argument" do
     origin_hash = { 'a' => 1, 'b' => 2, 'c' => 3 }
     result = scope.function_delete_values([origin_hash, 2])
-    origin_hash.should(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
+    expect(origin_hash).to(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
   end
 
 end
diff --git a/spec/functions/difference_spec.rb b/spec/functions/difference_spec.rb
index 9feff09..24b2b1b 100755
--- a/spec/functions/difference_spec.rb
+++ b/spec/functions/difference_spec.rb
@@ -5,15 +5,15 @@ describe "the difference function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("difference").should == "function_difference"
+    expect(Puppet::Parser::Functions.function("difference")).to eq("function_difference")
   end
 
   it "should raise a ParseError if there are fewer than 2 arguments" do
-    lambda { scope.function_difference([]) }.should( raise_error(Puppet::ParseError) )
+    expect { scope.function_difference([]) }.to( raise_error(Puppet::ParseError) )
   end
 
   it "should return the difference between two arrays" do
     result = scope.function_difference([["a","b","c"],["b","c","d"]])
-    result.should(eq(["a"]))
+    expect(result).to(eq(["a"]))
   end
 end
diff --git a/spec/functions/dirname_spec.rb b/spec/functions/dirname_spec.rb
index fb3b4fe..8a3bcab 100755
--- a/spec/functions/dirname_spec.rb
+++ b/spec/functions/dirname_spec.rb
@@ -5,20 +5,20 @@ describe "the dirname function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("dirname").should == "function_dirname"
+    expect(Puppet::Parser::Functions.function("dirname")).to eq("function_dirname")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_dirname([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_dirname([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return dirname for an absolute path" do
     result = scope.function_dirname(['/path/to/a/file.ext'])
-    result.should(eq('/path/to/a'))
+    expect(result).to(eq('/path/to/a'))
   end
 
   it "should return dirname for a relative path" do
     result = scope.function_dirname(['path/to/a/file.ext'])
-    result.should(eq('path/to/a'))
+    expect(result).to(eq('path/to/a'))
   end
 end
diff --git a/spec/functions/downcase_spec.rb b/spec/functions/downcase_spec.rb
index acef1f0..a844780 100755
--- a/spec/functions/downcase_spec.rb
+++ b/spec/functions/downcase_spec.rb
@@ -5,20 +5,20 @@ describe "the downcase function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("downcase").should == "function_downcase"
+    expect(Puppet::Parser::Functions.function("downcase")).to eq("function_downcase")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_downcase([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_downcase([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should downcase a string" do
     result = scope.function_downcase(["ASFD"])
-    result.should(eq("asfd"))
+    expect(result).to(eq("asfd"))
   end
 
   it "should do nothing to a string that is already downcase" do
     result = scope.function_downcase(["asdf asdf"])
-    result.should(eq("asdf asdf"))
+    expect(result).to(eq("asdf asdf"))
   end
 end
diff --git a/spec/functions/empty_spec.rb b/spec/functions/empty_spec.rb
index 7745875..1f2ace4 100755
--- a/spec/functions/empty_spec.rb
+++ b/spec/functions/empty_spec.rb
@@ -4,20 +4,20 @@ require 'spec_helper'
 describe "the empty function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
-    Puppet::Parser::Functions.function("empty").should == "function_empty"
+    expect(Puppet::Parser::Functions.function("empty")).to eq("function_empty")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_empty([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_empty([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return a true for an empty string" do
     result = scope.function_empty([''])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return a false for a non-empty string" do
     result = scope.function_empty(['asdf'])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/flatten_spec.rb b/spec/functions/flatten_spec.rb
index dba7a6b..de8c66d 100755
--- a/spec/functions/flatten_spec.rb
+++ b/spec/functions/flatten_spec.rb
@@ -4,24 +4,24 @@ require 'spec_helper'
 describe "the flatten function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
-    Puppet::Parser::Functions.function("flatten").should == "function_flatten"
+    expect(Puppet::Parser::Functions.function("flatten")).to eq("function_flatten")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_flatten([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there is more than 1 argument" do
-    lambda { scope.function_flatten([[], []]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_flatten([[], []]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should flatten a complex data structure" do
     result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
-    result.should(eq(["a","b","c","d","e","f","g"]))
+    expect(result).to(eq(["a","b","c","d","e","f","g"]))
   end
 
   it "should do nothing to a structure that is already flat" do
     result = scope.function_flatten([["a","b","c","d"]])
-    result.should(eq(["a","b","c","d"]))
+    expect(result).to(eq(["a","b","c","d"]))
   end
 end
diff --git a/spec/functions/floor_spec.rb b/spec/functions/floor_spec.rb
index dbc8c77..12a6917 100755
--- a/spec/functions/floor_spec.rb
+++ b/spec/functions/floor_spec.rb
@@ -6,34 +6,34 @@ describe "the floor function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("floor").should == "function_floor"
+    expect(Puppet::Parser::Functions.function("floor")).to eq("function_floor")
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
-    lambda { scope.function_floor([]) }.should( raise_error(Puppet::ParseError, /Wrong number of arguments/))
+    expect { scope.function_floor([]) }.to( raise_error(Puppet::ParseError, /Wrong number of arguments/))
   end
 
   it "should should raise a ParseError if input isn't numeric (eg. String)" do
-    lambda { scope.function_floor(["foo"]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/))
+    expect { scope.function_floor(["foo"]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
   end
 
   it "should should raise a ParseError if input isn't numeric (eg. Boolean)" do
-    lambda { scope.function_floor([true]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/))
+    expect { scope.function_floor([true]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
   end
 
   it "should return an integer when a numeric type is passed" do
     result = scope.function_floor([12.4])
-    result.is_a?(Integer).should(eq(true))
+    expect(result.is_a?(Integer)).to(eq(true))
   end
 
   it "should return the input when an integer is passed" do
     result = scope.function_floor([7])
-    result.should(eq(7))
+    expect(result).to(eq(7))
   end
 
   it "should return the largest integer less than or equal to the input" do
     result = scope.function_floor([3.8])
-    result.should(eq(3))
+    expect(result).to(eq(3))
   end
 end
 
diff --git a/spec/functions/fqdn_rotate_spec.rb b/spec/functions/fqdn_rotate_spec.rb
index 2577723..b2dc1f5 100755
--- a/spec/functions/fqdn_rotate_spec.rb
+++ b/spec/functions/fqdn_rotate_spec.rb
@@ -5,22 +5,22 @@ describe "the fqdn_rotate function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("fqdn_rotate").should == "function_fqdn_rotate"
+    expect(Puppet::Parser::Functions.function("fqdn_rotate")).to eq("function_fqdn_rotate")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_fqdn_rotate([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_fqdn_rotate([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should rotate a string and the result should be the same size" do
     scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     result = scope.function_fqdn_rotate(["asdf"])
-    result.size.should(eq(4))
+    expect(result.size).to(eq(4))
   end
 
   it "should rotate a string to give the same results for one host" do
     scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1").twice
-    scope.function_fqdn_rotate(["abcdefg"]).should eql(scope.function_fqdn_rotate(["abcdefg"]))
+    expect(scope.function_fqdn_rotate(["abcdefg"])).to eql(scope.function_fqdn_rotate(["abcdefg"]))
   end
 
   it "should rotate a string to give different values on different hosts" do
@@ -28,6 +28,6 @@ describe "the fqdn_rotate function" do
      val1 = scope.function_fqdn_rotate(["abcdefghijklmnopqrstuvwxyz01234567890987654321"])
      scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.2")
      val2 = scope.function_fqdn_rotate(["abcdefghijklmnopqrstuvwxyz01234567890987654321"])
-     val1.should_not eql(val2)
+     expect(val1).not_to eql(val2)
   end
 end
diff --git a/spec/functions/get_module_path_spec.rb b/spec/functions/get_module_path_spec.rb
index 486bef6..38ce645 100755
--- a/spec/functions/get_module_path_spec.rb
+++ b/spec/functions/get_module_path_spec.rb
@@ -29,18 +29,18 @@ describe Puppet::Parser::Functions.function(:get_module_path) do
 
     it 'should be able to find module paths from the modulepath setting' do
       Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
-      scope.function_get_module_path(['foo']).should == path_of_module_foo.path
+      expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
     end
     it 'should be able to find module paths when the modulepath is a list' do
       Puppet[:modulepath] = modulepath + ":/tmp"
       Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
-      scope.function_get_module_path(['foo']).should == path_of_module_foo.path
+      expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
     end
     it 'should respect the environment' do
-      pending("Disabled on Puppet 2.6.x") if Puppet.version =~ /^2\.6\b/
+      skip("Disabled on Puppet 2.6.x") if Puppet.version =~ /^2\.6\b/
       Puppet.settings[:environment] = 'danstestenv'
       Puppet::Module.expects(:find).with('foo', 'danstestenv').returns(path_of_module_foo)
-      scope('danstestenv').function_get_module_path(['foo']).should == path_of_module_foo.path
+      expect(scope('danstestenv').function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
     end
   end
 end
diff --git a/spec/functions/getparam_spec.rb b/spec/functions/getparam_spec.rb
index bf024af..833c4d4 100755
--- a/spec/functions/getparam_spec.rb
+++ b/spec/functions/getparam_spec.rb
@@ -25,7 +25,7 @@ describe 'getparam' do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("getparam").should == "function_getparam"
+    expect(Puppet::Parser::Functions.function("getparam")).to eq("function_getparam")
   end
 
   describe 'when a resource is not specified' do
diff --git a/spec/functions/getvar_spec.rb b/spec/functions/getvar_spec.rb
index 5ff834e..87ab9b5 100755
--- a/spec/functions/getvar_spec.rb
+++ b/spec/functions/getvar_spec.rb
@@ -6,7 +6,7 @@ describe Puppet::Parser::Functions.function(:getvar) do
   describe 'when calling getvar from puppet' do
 
     it "should not compile when no arguments are passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = '$foo = getvar()'
       expect {
         scope.compiler.compile
@@ -14,7 +14,7 @@ describe Puppet::Parser::Functions.function(:getvar) do
     end
 
     it "should not compile when too many arguments are passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = '$foo = getvar("foo::bar", "baz")'
       expect {
         scope.compiler.compile
@@ -22,7 +22,7 @@ describe Puppet::Parser::Functions.function(:getvar) do
     end
 
     it "should lookup variables in other namespaces" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = <<-'ENDofPUPPETcode'
         class site::data { $foo = 'baz' }
         include site::data
diff --git a/spec/functions/grep_spec.rb b/spec/functions/grep_spec.rb
index a93b842..9c671dd 100755
--- a/spec/functions/grep_spec.rb
+++ b/spec/functions/grep_spec.rb
@@ -5,15 +5,15 @@ describe "the grep function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("grep").should == "function_grep"
+    expect(Puppet::Parser::Functions.function("grep")).to eq("function_grep")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_grep([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_grep([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should grep contents from an array" do
     result = scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
-    result.should(eq(["aaabbb","bbbccc"]))
+    expect(result).to(eq(["aaabbb","bbbccc"]))
   end
 end
diff --git a/spec/functions/has_interface_with_spec.rb b/spec/functions/has_interface_with_spec.rb
index c5264e4..23e09a9 100755
--- a/spec/functions/has_interface_with_spec.rb
+++ b/spec/functions/has_interface_with_spec.rb
@@ -20,10 +20,10 @@ describe Puppet::Parser::Functions.function(:has_interface_with) do
       scope.stubs(:lookupvar).with("interfaces").returns('lo0,gif0,stf0,en1,p2p0,fw0,en0,vmnet1,vmnet8,utun0')
     end
     it 'should have loopback (lo0)' do
-      subject.call(['lo0']).should be_true
+      expect(subject.call(['lo0'])).to be_truthy
     end
     it 'should not have loopback (lo)' do
-      subject.call(['lo']).should be_false
+      expect(subject.call(['lo'])).to be_falsey
     end
   end
   context "On Linux Systems" do
@@ -37,28 +37,28 @@ describe Puppet::Parser::Functions.function(:has_interface_with) do
       scope.stubs(:lookupvar).with('muppet_eth0').returns('kermit')
     end
     it 'should have loopback (lo)' do
-      subject.call(['lo']).should be_true
+      expect(subject.call(['lo'])).to be_truthy
     end
     it 'should not have loopback (lo0)' do
-      subject.call(['lo0']).should be_false
+      expect(subject.call(['lo0'])).to be_falsey
     end
     it 'should have ipaddress with 127.0.0.1' do
-      subject.call(['ipaddress', '127.0.0.1']).should be_true
+      expect(subject.call(['ipaddress', '127.0.0.1'])).to be_truthy
     end
     it 'should have ipaddress with 10.0.0.1' do
-      subject.call(['ipaddress', '10.0.0.1']).should be_true
+      expect(subject.call(['ipaddress', '10.0.0.1'])).to be_truthy
     end
     it 'should not have ipaddress with 10.0.0.2' do
-      subject.call(['ipaddress', '10.0.0.2']).should be_false
+      expect(subject.call(['ipaddress', '10.0.0.2'])).to be_falsey
     end
     it 'should have muppet named kermit' do
-      subject.call(['muppet', 'kermit']).should be_true
+      expect(subject.call(['muppet', 'kermit'])).to be_truthy
     end
     it 'should have muppet named mspiggy' do
-      subject.call(['muppet', 'mspiggy']).should be_true
+      expect(subject.call(['muppet', 'mspiggy'])).to be_truthy
     end
     it 'should not have muppet named bigbird' do
-      subject.call(['muppet', 'bigbird']).should be_false
+      expect(subject.call(['muppet', 'bigbird'])).to be_falsey
     end
   end
 end
diff --git a/spec/functions/has_ip_address_spec.rb b/spec/functions/has_ip_address_spec.rb
index 5a68460..0df12a7 100755
--- a/spec/functions/has_ip_address_spec.rb
+++ b/spec/functions/has_ip_address_spec.rb
@@ -21,19 +21,19 @@ describe Puppet::Parser::Functions.function(:has_ip_address) do
     end
 
     it 'should have primary address (10.0.2.15)' do
-      subject.call(['10.0.2.15']).should be_true
+      expect(subject.call(['10.0.2.15'])).to be_truthy
     end
 
     it 'should have lookupback address (127.0.0.1)' do
-      subject.call(['127.0.0.1']).should be_true
+      expect(subject.call(['127.0.0.1'])).to be_truthy
     end
 
     it 'should not have other address' do
-      subject.call(['192.1681.1.1']).should be_false
+      expect(subject.call(['192.1681.1.1'])).to be_falsey
     end
 
     it 'should not have "mspiggy" on an interface' do
-      subject.call(['mspiggy']).should be_false
+      expect(subject.call(['mspiggy'])).to be_falsey
     end
   end
 end
diff --git a/spec/functions/has_ip_network_spec.rb b/spec/functions/has_ip_network_spec.rb
index c3a289e..2a2578e 100755
--- a/spec/functions/has_ip_network_spec.rb
+++ b/spec/functions/has_ip_network_spec.rb
@@ -21,15 +21,15 @@ describe Puppet::Parser::Functions.function(:has_ip_network) do
     end
 
     it 'should have primary network (10.0.2.0)' do
-      subject.call(['10.0.2.0']).should be_true
+      expect(subject.call(['10.0.2.0'])).to be_truthy
     end
 
     it 'should have loopback network (127.0.0.0)' do
-      subject.call(['127.0.0.1']).should be_true
+      expect(subject.call(['127.0.0.1'])).to be_truthy
     end
 
     it 'should not have other network' do
-      subject.call(['192.168.1.0']).should be_false
+      expect(subject.call(['192.168.1.0'])).to be_falsey
     end
   end
 end
diff --git a/spec/functions/has_key_spec.rb b/spec/functions/has_key_spec.rb
index 490daea..6b71800 100755
--- a/spec/functions/has_key_spec.rb
+++ b/spec/functions/has_key_spec.rb
@@ -6,7 +6,7 @@ describe Puppet::Parser::Functions.function(:has_key) do
 
   describe 'when calling has_key from puppet' do
     it "should not compile when no arguments are passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = '$x = has_key()'
       expect {
         scope.compiler.compile
@@ -14,7 +14,7 @@ describe Puppet::Parser::Functions.function(:has_key) do
     end
 
     it "should not compile when 1 argument is passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = "$x = has_key('foo')"
       expect {
         scope.compiler.compile
@@ -22,7 +22,7 @@ describe Puppet::Parser::Functions.function(:has_key) do
     end
 
     it "should require the first value to be a Hash" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = "$x = has_key('foo', 'bar')"
       expect {
         scope.compiler.compile
@@ -32,11 +32,11 @@ describe Puppet::Parser::Functions.function(:has_key) do
 
   describe 'when calling the function has_key from a scope instance' do
     it 'should detect existing keys' do
-      scope.function_has_key([{'one' => 1}, 'one']).should be_true
+      expect(scope.function_has_key([{'one' => 1}, 'one'])).to be_truthy
     end
 
     it 'should detect existing keys' do
-      scope.function_has_key([{'one' => 1}, 'two']).should be_false
+      expect(scope.function_has_key([{'one' => 1}, 'two'])).to be_falsey
     end
   end
 end
diff --git a/spec/functions/hash_spec.rb b/spec/functions/hash_spec.rb
index 7c91be9..ec2988b 100755
--- a/spec/functions/hash_spec.rb
+++ b/spec/functions/hash_spec.rb
@@ -5,15 +5,15 @@ describe "the hash function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("hash").should == "function_hash"
+    expect(Puppet::Parser::Functions.function("hash")).to eq("function_hash")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_hash([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_hash([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert an array to a hash" do
     result = scope.function_hash([['a',1,'b',2,'c',3]])
-    result.should(eq({'a'=>1,'b'=>2,'c'=>3}))
+    expect(result).to(eq({'a'=>1,'b'=>2,'c'=>3}))
   end
 end
diff --git a/spec/functions/intersection_spec.rb b/spec/functions/intersection_spec.rb
index fd44f7f..6361304 100755
--- a/spec/functions/intersection_spec.rb
+++ b/spec/functions/intersection_spec.rb
@@ -5,15 +5,15 @@ describe "the intersection function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("intersection").should == "function_intersection"
+    expect(Puppet::Parser::Functions.function("intersection")).to eq("function_intersection")
   end
 
   it "should raise a ParseError if there are fewer than 2 arguments" do
-    lambda { scope.function_intersection([]) }.should( raise_error(Puppet::ParseError) )
+    expect { scope.function_intersection([]) }.to( raise_error(Puppet::ParseError) )
   end
 
   it "should return the intersection of two arrays" do
     result = scope.function_intersection([["a","b","c"],["b","c","d"]])
-    result.should(eq(["b","c"]))
+    expect(result).to(eq(["b","c"]))
   end
 end
diff --git a/spec/functions/is_array_spec.rb b/spec/functions/is_array_spec.rb
index e7f4bcd..94920a4 100755
--- a/spec/functions/is_array_spec.rb
+++ b/spec/functions/is_array_spec.rb
@@ -5,25 +5,25 @@ describe "the is_array function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_array").should == "function_is_array"
+    expect(Puppet::Parser::Functions.function("is_array")).to eq("function_is_array")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_array([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_array([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if passed an array" do
     result = scope.function_is_array([[1,2,3]])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if passed a hash" do
     result = scope.function_is_array([{'a'=>1}])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if passed a string" do
     result = scope.function_is_array(["asdf"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/is_bool_spec.rb b/spec/functions/is_bool_spec.rb
index c94e83a..4a342ba 100755
--- a/spec/functions/is_bool_spec.rb
+++ b/spec/functions/is_bool_spec.rb
@@ -5,40 +5,40 @@ describe "the is_bool function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_bool").should == "function_is_bool"
+    expect(Puppet::Parser::Functions.function("is_bool")).to eq("function_is_bool")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_bool([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_bool([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if passed a TrueClass" do
     result = scope.function_is_bool([true])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if passed a FalseClass" do
     result = scope.function_is_bool([false])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if passed the string 'true'" do
     result = scope.function_is_bool(['true'])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if passed the string 'false'" do
     result = scope.function_is_bool(['false'])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if passed an array" do
     result = scope.function_is_bool([["a","b"]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if passed a hash" do
     result = scope.function_is_bool([{"a" => "b"}])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/is_domain_name_spec.rb b/spec/functions/is_domain_name_spec.rb
index f2ea76d..4d05f5c 100755
--- a/spec/functions/is_domain_name_spec.rb
+++ b/spec/functions/is_domain_name_spec.rb
@@ -5,60 +5,60 @@ describe "the is_domain_name function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_domain_name").should == "function_is_domain_name"
+    expect(Puppet::Parser::Functions.function("is_domain_name")).to eq("function_is_domain_name")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_domain_name([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_domain_name([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a valid short domain name" do
     result = scope.function_is_domain_name(["x.com"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return true if the domain is ." do
     result = scope.function_is_domain_name(["."])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return true if the domain is x.com." do
     result = scope.function_is_domain_name(["x.com."])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return true if a valid domain name" do
     result = scope.function_is_domain_name(["foo.bar.com"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should allow domain parts to start with numbers" do
     result = scope.function_is_domain_name(["3foo.2bar.com"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should allow domain to end with a dot" do
     result = scope.function_is_domain_name(["3foo.2bar.com."])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should allow a single part domain" do
     result = scope.function_is_domain_name(["orange"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return false if domain parts start with hyphens" do
     result = scope.function_is_domain_name(["-3foo.2bar.com"])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 
   it "should return true if domain contains hyphens" do
     result = scope.function_is_domain_name(["3foo-bar.2bar-fuzz.com"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return false if domain name contains spaces" do
     result = scope.function_is_domain_name(["not valid"])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 end
diff --git a/spec/functions/is_float_spec.rb b/spec/functions/is_float_spec.rb
index b7d73b0..d926634 100755
--- a/spec/functions/is_float_spec.rb
+++ b/spec/functions/is_float_spec.rb
@@ -5,29 +5,29 @@ describe "the is_float function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_float").should == "function_is_float"
+    expect(Puppet::Parser::Functions.function("is_float")).to eq("function_is_float")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_float([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_float([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a float" do
     result = scope.function_is_float(["0.12"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if a string" do
     result = scope.function_is_float(["asdf"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if an integer" do
     result = scope.function_is_float(["3"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
   it "should return true if a float is created from an arithmetical operation" do
     result = scope.function_is_float([3.2*2])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 end
diff --git a/spec/functions/is_function_available.rb b/spec/functions/is_function_available.rb
index d5669a7..3a9aa1b 100755
--- a/spec/functions/is_function_available.rb
+++ b/spec/functions/is_function_available.rb
@@ -11,21 +11,21 @@ describe "the is_function_available function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_function_available").should == "function_is_function_available"
+    expect(Puppet::Parser::Functions.function("is_function_available")).to eq("function_is_function_available")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_function_available([]) }.should( raise_error(Puppet::ParseError))
+    expect { @scope.function_is_function_available([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return false if a nonexistent function is passed" do
     result = @scope.function_is_function_available(['jeff_mccunes_left_sock'])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return true if an available function is passed" do
     result = @scope.function_is_function_available(['require'])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
 end
diff --git a/spec/functions/is_hash_spec.rb b/spec/functions/is_hash_spec.rb
index bbebf39..a849411 100755
--- a/spec/functions/is_hash_spec.rb
+++ b/spec/functions/is_hash_spec.rb
@@ -5,25 +5,25 @@ describe "the is_hash function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_hash").should == "function_is_hash"
+    expect(Puppet::Parser::Functions.function("is_hash")).to eq("function_is_hash")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_hash([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if passed a hash" do
     result = scope.function_is_hash([{"a"=>1,"b"=>2}])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if passed an array" do
     result = scope.function_is_hash([["a","b"]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if passed a string" do
     result = scope.function_is_hash(["asdf"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/is_integer_spec.rb b/spec/functions/is_integer_spec.rb
index 24141cc..f0cbca8 100755
--- a/spec/functions/is_integer_spec.rb
+++ b/spec/functions/is_integer_spec.rb
@@ -5,65 +5,65 @@ describe "the is_integer function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_integer").should == "function_is_integer"
+    expect(Puppet::Parser::Functions.function("is_integer")).to eq("function_is_integer")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_integer([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if an integer" do
     result = scope.function_is_integer(["3"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if a negative integer" do
     result = scope.function_is_integer(["-7"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if a float" do
     result = scope.function_is_integer(["3.2"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a string" do
     result = scope.function_is_integer(["asdf"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return true if an integer is created from an arithmetical operation" do
     result = scope.function_is_integer([3*2])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if an array" do
     result = scope.function_is_numeric([["asdf"]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a hash" do
     result = scope.function_is_numeric([{"asdf" => false}])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a boolean" do
     result = scope.function_is_numeric([true])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a whitespace is in the string" do
     result = scope.function_is_numeric([" -1324"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if it is zero prefixed" do
     result = scope.function_is_numeric(["0001234"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if it is wrapped inside an array" do
     result = scope.function_is_numeric([[1234]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/is_ip_address_spec.rb b/spec/functions/is_ip_address_spec.rb
index c0debb3..c16d12b 100755
--- a/spec/functions/is_ip_address_spec.rb
+++ b/spec/functions/is_ip_address_spec.rb
@@ -5,35 +5,35 @@ describe "the is_ip_address function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_ip_address").should == "function_is_ip_address"
+    expect(Puppet::Parser::Functions.function("is_ip_address")).to eq("function_is_ip_address")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_ip_address([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if an IPv4 address" do
     result = scope.function_is_ip_address(["1.2.3.4"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if a full IPv6 address" do
     result = scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if a compressed IPv6 address" do
     result = scope.function_is_ip_address(["fe00::1"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if not valid" do
     result = scope.function_is_ip_address(["asdf"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if IP octets out of range" do
     result = scope.function_is_ip_address(["1.1.1.300"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/is_mac_address_spec.rb b/spec/functions/is_mac_address_spec.rb
index ca9c590..66edd19 100755
--- a/spec/functions/is_mac_address_spec.rb
+++ b/spec/functions/is_mac_address_spec.rb
@@ -5,25 +5,25 @@ describe "the is_mac_address function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_mac_address").should == "function_is_mac_address"
+    expect(Puppet::Parser::Functions.function("is_mac_address")).to eq("function_is_mac_address")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_mac_address([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a valid mac address" do
     result = scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if octets are out of range" do
     result = scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if not valid" do
     result = scope.function_is_mac_address(["not valid"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/is_numeric_spec.rb b/spec/functions/is_numeric_spec.rb
index 1df1497..4176961 100755
--- a/spec/functions/is_numeric_spec.rb
+++ b/spec/functions/is_numeric_spec.rb
@@ -5,71 +5,71 @@ describe "the is_numeric function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_numeric").should == "function_is_numeric"
+    expect(Puppet::Parser::Functions.function("is_numeric")).to eq("function_is_numeric")
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
-    lambda { scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_numeric([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if an integer" do
     result = scope.function_is_numeric(["3"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if a float" do
     result = scope.function_is_numeric(["3.2"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if an integer is created from an arithmetical operation" do
     result = scope.function_is_numeric([3*2])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return true if a float is created from an arithmetical operation" do
     result = scope.function_is_numeric([3.2*2])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if a string" do
     result = scope.function_is_numeric(["asdf"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if an array" do
     result = scope.function_is_numeric([["asdf"]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if an array of integers" do
     result = scope.function_is_numeric([[1,2,3,4]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a hash" do
     result = scope.function_is_numeric([{"asdf" => false}])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a hash with numbers in it" do
     result = scope.function_is_numeric([{1 => 2}])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a boolean" do
     result = scope.function_is_numeric([true])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return true if a negative float with exponent" do
     result = scope.function_is_numeric(["-342.2315e-12"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if a negative integer with whitespaces before/after the dash" do
     result = scope.function_is_numeric([" -  751"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
 #  it "should return true if a hexadecimal" do
diff --git a/spec/functions/is_string_spec.rb b/spec/functions/is_string_spec.rb
index 3756bea..6a0801a 100755
--- a/spec/functions/is_string_spec.rb
+++ b/spec/functions/is_string_spec.rb
@@ -5,30 +5,30 @@ describe "the is_string function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("is_string").should == "function_is_string"
+    expect(Puppet::Parser::Functions.function("is_string")).to eq("function_is_string")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_is_string([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a string" do
     result = scope.function_is_string(["asdf"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if an integer" do
     result = scope.function_is_string(["3"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if a float" do
     result = scope.function_is_string(["3.23"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return false if an array" do
     result = scope.function_is_string([["a","b","c"]])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/join_keys_to_values_spec.rb b/spec/functions/join_keys_to_values_spec.rb
index a52fb71..4a9ae87 100755
--- a/spec/functions/join_keys_to_values_spec.rb
+++ b/spec/functions/join_keys_to_values_spec.rb
@@ -5,36 +5,36 @@ describe "the join_keys_to_values function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("join_keys_to_values").should == "function_join_keys_to_values"
+    expect(Puppet::Parser::Functions.function("join_keys_to_values")).to eq("function_join_keys_to_values")
   end
 
   it "should raise a ParseError if there are fewer than two arguments" do
-    lambda { scope.function_join_keys_to_values([{}]) }.should raise_error Puppet::ParseError
+    expect { scope.function_join_keys_to_values([{}]) }.to raise_error Puppet::ParseError
   end
 
   it "should raise a ParseError if there are greater than two arguments" do
-    lambda { scope.function_join_keys_to_values([{}, 'foo', 'bar']) }.should raise_error Puppet::ParseError
+    expect { scope.function_join_keys_to_values([{}, 'foo', 'bar']) }.to raise_error Puppet::ParseError
   end
 
   it "should raise a TypeError if the first argument is an array" do
-    lambda { scope.function_join_keys_to_values([[1,2], ',']) }.should raise_error TypeError
+    expect { scope.function_join_keys_to_values([[1,2], ',']) }.to raise_error TypeError
   end
 
   it "should raise a TypeError if the second argument is an array" do
-    lambda { scope.function_join_keys_to_values([{}, [1,2]]) }.should raise_error TypeError
+    expect { scope.function_join_keys_to_values([{}, [1,2]]) }.to raise_error TypeError
   end
 
   it "should raise a TypeError if the second argument is a number" do
-    lambda { scope.function_join_keys_to_values([{}, 1]) }.should raise_error TypeError
+    expect { scope.function_join_keys_to_values([{}, 1]) }.to raise_error TypeError
   end
 
   it "should return an empty array given an empty hash" do
     result = scope.function_join_keys_to_values([{}, ":"])
-    result.should == []
+    expect(result).to eq([])
   end
 
   it "should join hash's keys to its values" do
     result = scope.function_join_keys_to_values([{'a'=>1,2=>'foo',:b=>nil}, ":"])
-    result.should =~ ['a:1','2:foo','b:']
+    expect(result).to match_array(['a:1','2:foo','b:'])
   end
 end
diff --git a/spec/functions/join_spec.rb b/spec/functions/join_spec.rb
index aafa1a7..793c36f 100755
--- a/spec/functions/join_spec.rb
+++ b/spec/functions/join_spec.rb
@@ -5,15 +5,15 @@ describe "the join function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("join").should == "function_join"
+    expect(Puppet::Parser::Functions.function("join")).to eq("function_join")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_join([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_join([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should join an array into a string" do
     result = scope.function_join([["a","b","c"], ":"])
-    result.should(eq("a:b:c"))
+    expect(result).to(eq("a:b:c"))
   end
 end
diff --git a/spec/functions/keys_spec.rb b/spec/functions/keys_spec.rb
index fdd7a70..f2e7d42 100755
--- a/spec/functions/keys_spec.rb
+++ b/spec/functions/keys_spec.rb
@@ -5,17 +5,17 @@ describe "the keys function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("keys").should == "function_keys"
+    expect(Puppet::Parser::Functions.function("keys")).to eq("function_keys")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_keys([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_keys([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return an array of keys when given a hash" do
     result = scope.function_keys([{'a'=>1, 'b'=>2}])
     # =~ performs 'array with same elements' (set) matching
     # For more info see RSpec::Matchers::MatchArray
-    result.should =~ ['a','b']
+    expect(result).to match_array(['a','b'])
   end
 end
diff --git a/spec/functions/loadyaml_spec.rb b/spec/functions/loadyaml_spec.rb
index fe16318..cdc3d6f 100755
--- a/spec/functions/loadyaml_spec.rb
+++ b/spec/functions/loadyaml_spec.rb
@@ -7,7 +7,7 @@ describe "the loadyaml function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("loadyaml").should == "function_loadyaml"
+    expect(Puppet::Parser::Functions.function("loadyaml")).to eq("function_loadyaml")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
@@ -20,6 +20,6 @@ describe "the loadyaml function" do
       fh.write("---\n aaa: 1\n bbb: 2\n ccc: 3\n ddd: 4\n")
     end
     result = scope.function_loadyaml([yaml_file])
-    result.should == {"aaa" => 1, "bbb" => 2, "ccc" => 3, "ddd" => 4 }
+    expect(result).to eq({"aaa" => 1, "bbb" => 2, "ccc" => 3, "ddd" => 4 })
   end
 end
diff --git a/spec/functions/lstrip_spec.rb b/spec/functions/lstrip_spec.rb
index b280ae7..7025f97 100755
--- a/spec/functions/lstrip_spec.rb
+++ b/spec/functions/lstrip_spec.rb
@@ -5,15 +5,15 @@ describe "the lstrip function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("lstrip").should == "function_lstrip"
+    expect(Puppet::Parser::Functions.function("lstrip")).to eq("function_lstrip")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_lstrip([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should lstrip a string" do
     result = scope.function_lstrip(["  asdf"])
-    result.should(eq('asdf'))
+    expect(result).to(eq('asdf'))
   end
 end
diff --git a/spec/functions/max_spec.rb b/spec/functions/max_spec.rb
index ff6f2b3..c3d8a13 100755
--- a/spec/functions/max_spec.rb
+++ b/spec/functions/max_spec.rb
@@ -6,22 +6,22 @@ describe "the max function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("max").should == "function_max"
+    expect(Puppet::Parser::Functions.function("max")).to eq("function_max")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_max([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_max([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should be able to compare strings" do
-    scope.function_max(["albatross","dog","horse"]).should(eq("horse"))
+    expect(scope.function_max(["albatross","dog","horse"])).to(eq("horse"))
   end
 
   it "should be able to compare numbers" do
-    scope.function_max([6,8,4]).should(eq(8))
+    expect(scope.function_max([6,8,4])).to(eq(8))
   end
 
   it "should be able to compare a number with a stringified number" do
-    scope.function_max([1,"2"]).should(eq("2"))
+    expect(scope.function_max([1,"2"])).to(eq("2"))
   end
 end
diff --git a/spec/functions/member_spec.rb b/spec/functions/member_spec.rb
index 6e9a023..cee6110 100755
--- a/spec/functions/member_spec.rb
+++ b/spec/functions/member_spec.rb
@@ -5,20 +5,20 @@ describe "the member function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("member").should == "function_member"
+    expect(Puppet::Parser::Functions.function("member")).to eq("function_member")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_member([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_member([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a member is in an array" do
     result = scope.function_member([["a","b","c"], "a"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should return false if a member is not in an array" do
     result = scope.function_member([["a","b","c"], "d"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/merge_spec.rb b/spec/functions/merge_spec.rb
index 15a5d94..2abf976 100755
--- a/spec/functions/merge_spec.rb
+++ b/spec/functions/merge_spec.rb
@@ -7,7 +7,7 @@ describe Puppet::Parser::Functions.function(:merge) do
 
   describe 'when calling merge from puppet' do
     it "should not compile when no arguments are passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = '$x = merge()'
       expect {
         scope.compiler.compile
@@ -15,7 +15,7 @@ describe Puppet::Parser::Functions.function(:merge) do
     end
 
     it "should not compile when 1 argument is passed" do
-      pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
       Puppet[:code] = "$my_hash={'one' => 1}\n$x = merge($my_hash)"
       expect {
         scope.compiler.compile
@@ -35,18 +35,18 @@ describe Puppet::Parser::Functions.function(:merge) do
 
     it 'should be able to merge two hashes' do
       new_hash = scope.function_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
-      new_hash['one'].should   == '1'
-      new_hash['two'].should   == '2'
-      new_hash['three'].should == '2'
+      expect(new_hash['one']).to   eq('1')
+      expect(new_hash['two']).to   eq('2')
+      expect(new_hash['three']).to eq('2')
     end
 
     it 'should merge multiple hashes' do
       hash = scope.function_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
-      hash['one'].should == '3'
+      expect(hash['one']).to eq('3')
     end
 
     it 'should accept empty hashes' do
-      scope.function_merge([{},{},{}]).should == {}
+      expect(scope.function_merge([{},{},{}])).to eq({})
     end
   end
 end
diff --git a/spec/functions/min_spec.rb b/spec/functions/min_spec.rb
index 71d593e..35a0890 100755
--- a/spec/functions/min_spec.rb
+++ b/spec/functions/min_spec.rb
@@ -6,22 +6,22 @@ describe "the min function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("min").should == "function_min"
+    expect(Puppet::Parser::Functions.function("min")).to eq("function_min")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_min([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_min([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should be able to compare strings" do
-    scope.function_min(["albatross","dog","horse"]).should(eq("albatross"))
+    expect(scope.function_min(["albatross","dog","horse"])).to(eq("albatross"))
   end
 
   it "should be able to compare numbers" do
-    scope.function_min([6,8,4]).should(eq(4))
+    expect(scope.function_min([6,8,4])).to(eq(4))
   end
 
   it "should be able to compare a number with a stringified number" do
-    scope.function_min([1,"2"]).should(eq(1))
+    expect(scope.function_min([1,"2"])).to(eq(1))
   end
 end
diff --git a/spec/functions/num2bool_spec.rb b/spec/functions/num2bool_spec.rb
index b56196d..d0ba935 100755
--- a/spec/functions/num2bool_spec.rb
+++ b/spec/functions/num2bool_spec.rb
@@ -5,63 +5,63 @@ describe "the num2bool function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("num2bool").should == "function_num2bool"
+    expect(Puppet::Parser::Functions.function("num2bool")).to eq("function_num2bool")
   end
 
   it "should raise a ParseError if there are no arguments" do
-    lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_num2bool([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there are more than 1 arguments" do
-    lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_num2bool(["foo","bar"]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if passed something non-numeric" do
-    lambda { scope.function_num2bool(["xyzzy"]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_num2bool(["xyzzy"]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return true if passed string 1" do
     result = scope.function_num2bool(["1"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return true if passed string 1.5" do
     result = scope.function_num2bool(["1.5"])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return true if passed number 1" do
     result = scope.function_num2bool([1])
-    result.should(be_true)
+    expect(result).to(be_truthy)
   end
 
   it "should return false if passed string 0" do
     result = scope.function_num2bool(["0"])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 
   it "should return false if passed number 0" do
     result = scope.function_num2bool([0])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 
   it "should return false if passed string -1" do
     result = scope.function_num2bool(["-1"])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 
   it "should return false if passed string -1.5" do
     result = scope.function_num2bool(["-1.5"])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 
   it "should return false if passed number -1" do
     result = scope.function_num2bool([-1])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 
   it "should return false if passed float -1.5" do
     result = scope.function_num2bool([-1.5])
-    result.should(be_false)
+    expect(result).to(be_falsey)
   end
 end
diff --git a/spec/functions/parsejson_spec.rb b/spec/functions/parsejson_spec.rb
index f179ac1..1dd41b9 100755
--- a/spec/functions/parsejson_spec.rb
+++ b/spec/functions/parsejson_spec.rb
@@ -5,11 +5,11 @@ describe "the parsejson function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("parsejson").should == "function_parsejson"
+    expect(Puppet::Parser::Functions.function("parsejson")).to eq("function_parsejson")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_parsejson([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert JSON to a data structure" do
@@ -17,6 +17,6 @@ describe "the parsejson function" do
 ["aaa","bbb","ccc"]
 EOS
     result = scope.function_parsejson([json])
-    result.should(eq(['aaa','bbb','ccc']))
+    expect(result).to(eq(['aaa','bbb','ccc']))
   end
 end
diff --git a/spec/functions/parseyaml_spec.rb b/spec/functions/parseyaml_spec.rb
index 0c7aea8..e5f145b 100755
--- a/spec/functions/parseyaml_spec.rb
+++ b/spec/functions/parseyaml_spec.rb
@@ -5,11 +5,11 @@ describe "the parseyaml function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("parseyaml").should == "function_parseyaml"
+    expect(Puppet::Parser::Functions.function("parseyaml")).to eq("function_parseyaml")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_parseyaml([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert YAML to a data structure" do
@@ -19,6 +19,6 @@ describe "the parseyaml function" do
 - ccc
 EOS
     result = scope.function_parseyaml([yaml])
-    result.should(eq(['aaa','bbb','ccc']))
+    expect(result).to(eq(['aaa','bbb','ccc']))
   end
 end
diff --git a/spec/functions/pick_default_spec.rb b/spec/functions/pick_default_spec.rb
index c9235b5..db10cc3 100755
--- a/spec/functions/pick_default_spec.rb
+++ b/spec/functions/pick_default_spec.rb
@@ -5,51 +5,51 @@ describe "the pick_default function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("pick_default").should == "function_pick_default"
+    expect(Puppet::Parser::Functions.function("pick_default")).to eq("function_pick_default")
   end
 
   it 'should return the correct value' do
-    scope.function_pick_default(['first', 'second']).should == 'first'
+    expect(scope.function_pick_default(['first', 'second'])).to eq('first')
   end
 
   it 'should return the correct value if the first value is empty' do
-    scope.function_pick_default(['', 'second']).should == 'second'
+    expect(scope.function_pick_default(['', 'second'])).to eq('second')
   end
 
   it 'should skip empty string values' do
-    scope.function_pick_default(['', 'first']).should == 'first'
+    expect(scope.function_pick_default(['', 'first'])).to eq('first')
   end
 
   it 'should skip :undef values' do
-    scope.function_pick_default([:undef, 'first']).should == 'first'
+    expect(scope.function_pick_default([:undef, 'first'])).to eq('first')
   end
 
   it 'should skip :undefined values' do
-    scope.function_pick_default([:undefined, 'first']).should == 'first'
+    expect(scope.function_pick_default([:undefined, 'first'])).to eq('first')
   end
 
   it 'should return the empty string if it is the last possibility' do
-    scope.function_pick_default([:undef, :undefined, '']).should == ''
+    expect(scope.function_pick_default([:undef, :undefined, ''])).to eq('')
   end
 
   it 'should return :undef if it is the last possibility' do
-    scope.function_pick_default(['', :undefined, :undef]).should == :undef
+    expect(scope.function_pick_default(['', :undefined, :undef])).to eq(:undef)
   end
 
   it 'should return :undefined if it is the last possibility' do
-    scope.function_pick_default([:undef, '', :undefined]).should == :undefined
+    expect(scope.function_pick_default([:undef, '', :undefined])).to eq(:undefined)
   end
 
   it 'should return the empty string if it is the only possibility' do
-    scope.function_pick_default(['']).should == ''
+    expect(scope.function_pick_default([''])).to eq('')
   end
 
   it 'should return :undef if it is the only possibility' do
-    scope.function_pick_default([:undef]).should == :undef
+    expect(scope.function_pick_default([:undef])).to eq(:undef)
   end
 
   it 'should return :undefined if it is the only possibility' do
-    scope.function_pick_default([:undefined]).should == :undefined
+    expect(scope.function_pick_default([:undefined])).to eq(:undefined)
   end
 
   it 'should error if no values are passed' do
diff --git a/spec/functions/pick_spec.rb b/spec/functions/pick_spec.rb
index f53fa80..8be8f58 100755
--- a/spec/functions/pick_spec.rb
+++ b/spec/functions/pick_spec.rb
@@ -5,27 +5,27 @@ describe "the pick function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("pick").should == "function_pick"
+    expect(Puppet::Parser::Functions.function("pick")).to eq("function_pick")
   end
 
   it 'should return the correct value' do
-    scope.function_pick(['first', 'second']).should == 'first'
+    expect(scope.function_pick(['first', 'second'])).to eq('first')
   end
 
   it 'should return the correct value if the first value is empty' do
-    scope.function_pick(['', 'second']).should == 'second'
+    expect(scope.function_pick(['', 'second'])).to eq('second')
   end
 
   it 'should remove empty string values' do
-    scope.function_pick(['', 'first']).should == 'first'
+    expect(scope.function_pick(['', 'first'])).to eq('first')
   end
 
   it 'should remove :undef values' do
-    scope.function_pick([:undef, 'first']).should == 'first'
+    expect(scope.function_pick([:undef, 'first'])).to eq('first')
   end
 
   it 'should remove :undefined values' do
-    scope.function_pick([:undefined, 'first']).should == 'first'
+    expect(scope.function_pick([:undefined, 'first'])).to eq('first')
   end
 
   it 'should error if no values are passed' do
diff --git a/spec/functions/prefix_spec.rb b/spec/functions/prefix_spec.rb
index 6e8ddc5..34cac53 100755
--- a/spec/functions/prefix_spec.rb
+++ b/spec/functions/prefix_spec.rb
@@ -23,6 +23,6 @@ describe "the prefix function" do
 
   it "returns a prefixed array" do
     result = scope.function_prefix([['a','b','c'], 'p'])
-    result.should(eq(['pa','pb','pc']))
+    expect(result).to(eq(['pa','pb','pc']))
   end
 end
diff --git a/spec/functions/range_spec.rb b/spec/functions/range_spec.rb
index 0e1ad37..9b9ece0 100755
--- a/spec/functions/range_spec.rb
+++ b/spec/functions/range_spec.rb
@@ -5,7 +5,7 @@ describe "the range function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "exists" do
-    Puppet::Parser::Functions.function("range").should == "function_range"
+    expect(Puppet::Parser::Functions.function("range")).to eq("function_range")
   end
 
   it "raises a ParseError if there is less than 1 arguments" do
@@ -15,56 +15,56 @@ describe "the range function" do
   describe 'with a letter range' do
     it "returns a letter range" do
       result = scope.function_range(["a","d"])
-      result.should eq ['a','b','c','d']
+      expect(result).to eq ['a','b','c','d']
     end
 
     it "returns a letter range given a step of 1" do
       result = scope.function_range(["a","d","1"])
-      result.should eq ['a','b','c','d']
+      expect(result).to eq ['a','b','c','d']
     end
 
     it "returns a stepped letter range" do
       result = scope.function_range(["a","d","2"])
-      result.should eq ['a','c']
+      expect(result).to eq ['a','c']
     end
 
     it "returns a stepped letter range given a negative step" do
       result = scope.function_range(["a","d","-2"])
-      result.should eq ['a','c']
+      expect(result).to eq ['a','c']
     end
   end
 
   describe 'with a number range' do
     it "returns a number range" do
       result = scope.function_range(["1","4"])
-      result.should eq [1,2,3,4]
+      expect(result).to eq [1,2,3,4]
     end
 
     it "returns a number range given a step of 1" do
       result = scope.function_range(["1","4","1"])
-      result.should eq [1,2,3,4]
+      expect(result).to eq [1,2,3,4]
     end
 
     it "returns a stepped number range" do
       result = scope.function_range(["1","4","2"])
-      result.should eq [1,3]
+      expect(result).to eq [1,3]
     end
 
     it "returns a stepped number range given a negative step" do
       result = scope.function_range(["1","4","-2"])
-      result.should eq [1,3]
+      expect(result).to eq [1,3]
     end
   end
 
   describe 'with a numeric-like string range' do
     it "works with padded hostname like strings" do
       expected = ("host01".."host10").to_a
-      scope.function_range(["host01","host10"]).should eq expected
+      expect(scope.function_range(["host01","host10"])).to eq expected
     end
 
     it "coerces zero padded digits to integers" do
       expected = (0..10).to_a
-      scope.function_range(["00", "10"]).should eq expected
+      expect(scope.function_range(["00", "10"])).to eq expected
     end
   end
 end
diff --git a/spec/functions/reject_spec.rb b/spec/functions/reject_spec.rb
index f2cb741..88a992e 100755
--- a/spec/functions/reject_spec.rb
+++ b/spec/functions/reject_spec.rb
@@ -6,15 +6,15 @@ describe "the reject function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("reject").should == "function_reject"
+    expect(Puppet::Parser::Functions.function("reject")).to eq("function_reject")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_reject([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_reject([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should reject contents from an array" do
     result = scope.function_reject([["1111", "aaabbb","bbbccc","dddeee"], "bbb"])
-    result.should(eq(["1111", "dddeee"]))
+    expect(result).to(eq(["1111", "dddeee"]))
   end
 end
diff --git a/spec/functions/reverse_spec.rb b/spec/functions/reverse_spec.rb
index 1b59206..bfeabfb 100755
--- a/spec/functions/reverse_spec.rb
+++ b/spec/functions/reverse_spec.rb
@@ -5,15 +5,15 @@ describe "the reverse function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("reverse").should == "function_reverse"
+    expect(Puppet::Parser::Functions.function("reverse")).to eq("function_reverse")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_reverse([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_reverse([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should reverse a string" do
     result = scope.function_reverse(["asdfghijkl"])
-    result.should(eq('lkjihgfdsa'))
+    expect(result).to(eq('lkjihgfdsa'))
   end
 end
diff --git a/spec/functions/rstrip_spec.rb b/spec/functions/rstrip_spec.rb
index d90de1d..81321d7 100755
--- a/spec/functions/rstrip_spec.rb
+++ b/spec/functions/rstrip_spec.rb
@@ -5,20 +5,20 @@ describe "the rstrip function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("rstrip").should == "function_rstrip"
+    expect(Puppet::Parser::Functions.function("rstrip")).to eq("function_rstrip")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_rstrip([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should rstrip a string" do
     result = scope.function_rstrip(["asdf  "])
-    result.should(eq('asdf'))
+    expect(result).to(eq('asdf'))
   end
 
   it "should rstrip each element in an array" do
     result = scope.function_rstrip([["a ","b ", "c "]])
-    result.should(eq(['a','b','c']))
+    expect(result).to(eq(['a','b','c']))
   end
 end
diff --git a/spec/functions/shuffle_spec.rb b/spec/functions/shuffle_spec.rb
index 93346d5..ee0e2ff 100755
--- a/spec/functions/shuffle_spec.rb
+++ b/spec/functions/shuffle_spec.rb
@@ -5,20 +5,20 @@ describe "the shuffle function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("shuffle").should == "function_shuffle"
+    expect(Puppet::Parser::Functions.function("shuffle")).to eq("function_shuffle")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_shuffle([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_shuffle([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should shuffle a string and the result should be the same size" do
     result = scope.function_shuffle(["asdf"])
-    result.size.should(eq(4))
+    expect(result.size).to(eq(4))
   end
 
   it "should shuffle a string but the sorted contents should still be the same" do
     result = scope.function_shuffle(["adfs"])
-    result.split("").sort.join("").should(eq("adfs"))
+    expect(result.split("").sort.join("")).to(eq("adfs"))
   end
 end
diff --git a/spec/functions/size_spec.rb b/spec/functions/size_spec.rb
index b1c435a..18eb48f 100755
--- a/spec/functions/size_spec.rb
+++ b/spec/functions/size_spec.rb
@@ -5,20 +5,20 @@ describe "the size function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("size").should == "function_size"
+    expect(Puppet::Parser::Functions.function("size")).to eq("function_size")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_size([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_size([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return the size of a string" do
     result = scope.function_size(["asdf"])
-    result.should(eq(4))
+    expect(result).to(eq(4))
   end
 
   it "should return the size of an array" do
     result = scope.function_size([["a","b","c"]])
-    result.should(eq(3))
+    expect(result).to(eq(3))
   end
 end
diff --git a/spec/functions/sort_spec.rb b/spec/functions/sort_spec.rb
index 3187a5a..4c2a66c 100755
--- a/spec/functions/sort_spec.rb
+++ b/spec/functions/sort_spec.rb
@@ -5,20 +5,20 @@ describe "the sort function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("sort").should == "function_sort"
+    expect(Puppet::Parser::Functions.function("sort")).to eq("function_sort")
   end
 
   it "should raise a ParseError if there is not 1 arguments" do
-    lambda { scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_sort(['','']) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should sort an array" do
     result = scope.function_sort([["a","c","b"]])
-    result.should(eq(['a','b','c']))
+    expect(result).to(eq(['a','b','c']))
   end
 
   it "should sort a string" do
     result = scope.function_sort(["acb"])
-    result.should(eq('abc'))
+    expect(result).to(eq('abc'))
   end
 end
diff --git a/spec/functions/squeeze_spec.rb b/spec/functions/squeeze_spec.rb
index 60e5a30..cd0eb37 100755
--- a/spec/functions/squeeze_spec.rb
+++ b/spec/functions/squeeze_spec.rb
@@ -5,20 +5,20 @@ describe "the squeeze function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("squeeze").should == "function_squeeze"
+    expect(Puppet::Parser::Functions.function("squeeze")).to eq("function_squeeze")
   end
 
   it "should raise a ParseError if there is less than 2 arguments" do
-    lambda { scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_squeeze([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should squeeze a string" do
     result = scope.function_squeeze(["aaabbbbcccc"])
-    result.should(eq('abc'))
+    expect(result).to(eq('abc'))
   end
 
   it "should squeeze all elements in an array" do
     result = scope.function_squeeze([["aaabbbbcccc","dddfff"]])
-    result.should(eq(['abc','df']))
+    expect(result).to(eq(['abc','df']))
   end
 end
diff --git a/spec/functions/str2bool_spec.rb b/spec/functions/str2bool_spec.rb
index 73c09c7..1d205d7 100755
--- a/spec/functions/str2bool_spec.rb
+++ b/spec/functions/str2bool_spec.rb
@@ -5,27 +5,27 @@ describe "the str2bool function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("str2bool").should == "function_str2bool"
+    expect(Puppet::Parser::Functions.function("str2bool")).to eq("function_str2bool")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_str2bool([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert string 'true' to true" do
     result = scope.function_str2bool(["true"])
-    result.should(eq(true))
+    expect(result).to(eq(true))
   end
 
   it "should convert string 'undef' to false" do
     result = scope.function_str2bool(["undef"])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 
   it "should return the boolean it was called with" do
     result = scope.function_str2bool([true])
-    result.should(eq(true))
+    expect(result).to(eq(true))
     result = scope.function_str2bool([false])
-    result.should(eq(false))
+    expect(result).to(eq(false))
   end
 end
diff --git a/spec/functions/str2saltedsha512_spec.rb b/spec/functions/str2saltedsha512_spec.rb
index df8fb8e..ab7f57f 100755
--- a/spec/functions/str2saltedsha512_spec.rb
+++ b/spec/functions/str2saltedsha512_spec.rb
@@ -5,7 +5,7 @@ describe "the str2saltedsha512 function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("str2saltedsha512").should == "function_str2saltedsha512"
+    expect(Puppet::Parser::Functions.function("str2saltedsha512")).to eq("function_str2saltedsha512")
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
@@ -18,7 +18,7 @@ describe "the str2saltedsha512 function" do
 
   it "should return a salted-sha512 password hash 136 characters in length" do
     result = scope.function_str2saltedsha512(["password"])
-    result.length.should(eq(136))
+    expect(result.length).to(eq(136))
   end
 
   it "should raise an error if you pass a non-string password" do
@@ -40,6 +40,6 @@ describe "the str2saltedsha512 function" do
     # Combine the Binary Salt with 'password' and compare the end result
     saltedpass    = Digest::SHA512.digest(str_salt + 'password')
     result        = (str_salt + saltedpass).unpack('H*')[0]
-    result.should == password_hash
+    expect(result).to eq(password_hash)
   end
 end
diff --git a/spec/functions/strftime_spec.rb b/spec/functions/strftime_spec.rb
index df42b6f..ebec54b 100755
--- a/spec/functions/strftime_spec.rb
+++ b/spec/functions/strftime_spec.rb
@@ -5,25 +5,25 @@ describe "the strftime function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("strftime").should == "function_strftime"
+    expect(Puppet::Parser::Functions.function("strftime")).to eq("function_strftime")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_strftime([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_strftime([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "using %s should be higher then when I wrote this test" do
     result = scope.function_strftime(["%s"])
-    result.to_i.should(be > 1311953157)
+    expect(result.to_i).to(be > 1311953157)
   end
 
   it "using %s should be lower then 1.5 trillion" do
     result = scope.function_strftime(["%s"])
-    result.to_i.should(be < 1500000000)
+    expect(result.to_i).to(be < 1500000000)
   end
 
   it "should return a date when given %Y-%m-%d" do
     result = scope.function_strftime(["%Y-%m-%d"])
-    result.should =~ /^\d{4}-\d{2}-\d{2}$/
+    expect(result).to match(/^\d{4}-\d{2}-\d{2}$/)
   end
 end
diff --git a/spec/functions/strip_spec.rb b/spec/functions/strip_spec.rb
index fccdd26..e228761 100755
--- a/spec/functions/strip_spec.rb
+++ b/spec/functions/strip_spec.rb
@@ -4,15 +4,15 @@ require 'spec_helper'
 describe "the strip function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
-    Puppet::Parser::Functions.function("strip").should == "function_strip"
+    expect(Puppet::Parser::Functions.function("strip")).to eq("function_strip")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_strip([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_strip([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should strip a string" do
     result = scope.function_strip([" ab cd "])
-    result.should(eq('ab cd'))
+    expect(result).to(eq('ab cd'))
   end
 end
diff --git a/spec/functions/suffix_spec.rb b/spec/functions/suffix_spec.rb
index 89ba3b8..c7783c6 100755
--- a/spec/functions/suffix_spec.rb
+++ b/spec/functions/suffix_spec.rb
@@ -22,6 +22,6 @@ describe "the suffix function" do
 
   it "returns a suffixed array" do
     result = scope.function_suffix([['a','b','c'], 'p'])
-    result.should(eq(['ap','bp','cp']))
+    expect(result).to(eq(['ap','bp','cp']))
   end
 end
diff --git a/spec/functions/swapcase_spec.rb b/spec/functions/swapcase_spec.rb
index 808b415..c6838ab 100755
--- a/spec/functions/swapcase_spec.rb
+++ b/spec/functions/swapcase_spec.rb
@@ -5,15 +5,15 @@ describe "the swapcase function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("swapcase").should == "function_swapcase"
+    expect(Puppet::Parser::Functions.function("swapcase")).to eq("function_swapcase")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_swapcase([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should swapcase a string" do
     result = scope.function_swapcase(["aaBBccDD"])
-    result.should(eq('AAbbCCdd'))
+    expect(result).to(eq('AAbbCCdd'))
   end
 end
diff --git a/spec/functions/time_spec.rb b/spec/functions/time_spec.rb
index e9fb76e..6e22515 100755
--- a/spec/functions/time_spec.rb
+++ b/spec/functions/time_spec.rb
@@ -5,25 +5,25 @@ describe "the time function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("time").should == "function_time"
+    expect(Puppet::Parser::Functions.function("time")).to eq("function_time")
   end
 
   it "should raise a ParseError if there is more than 2 arguments" do
-    lambda { scope.function_time(['','']) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_time(['','']) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return a number" do
     result = scope.function_time([])
-    result.should be_an(Integer)
+    expect(result).to be_an(Integer)
   end
 
   it "should be higher then when I wrote this test" do
     result = scope.function_time([])
-    result.should(be > 1311953157)
+    expect(result).to(be > 1311953157)
   end
 
   it "should be lower then 1.5 trillion" do
     result = scope.function_time([])
-    result.should(be < 1500000000)
+    expect(result).to(be < 1500000000)
   end
 end
diff --git a/spec/functions/to_bytes_spec.rb b/spec/functions/to_bytes_spec.rb
index d1ea4c8..68a1eb8 100755
--- a/spec/functions/to_bytes_spec.rb
+++ b/spec/functions/to_bytes_spec.rb
@@ -6,53 +6,53 @@ describe "the to_bytes function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("to_bytes").should == "function_to_bytes"
+    expect(Puppet::Parser::Functions.function("to_bytes")).to eq("function_to_bytes")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_to_bytes([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_to_bytes([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should convert kB to B" do
     result = scope.function_to_bytes(["4 kB"])
-    result.should(eq(4096))
+    expect(result).to(eq(4096))
   end
 
   it "should work without B in unit" do
     result = scope.function_to_bytes(["4 k"])
-    result.should(eq(4096))
+    expect(result).to(eq(4096))
   end
 
   it "should work without a space before unit" do
     result = scope.function_to_bytes(["4k"])
-    result.should(eq(4096))
+    expect(result).to(eq(4096))
   end
 
   it "should work without a unit" do
     result = scope.function_to_bytes(["5678"])
-    result.should(eq(5678))
+    expect(result).to(eq(5678))
   end
 
   it "should convert fractions" do
     result = scope.function_to_bytes(["1.5 kB"])
-    result.should(eq(1536))
+    expect(result).to(eq(1536))
   end
 
   it "should convert scientific notation" do
     result = scope.function_to_bytes(["1.5e2 B"])
-    result.should(eq(150))
+    expect(result).to(eq(150))
   end
 
   it "should do nothing with a positive number" do
     result = scope.function_to_bytes([5678])
-    result.should(eq(5678))
+    expect(result).to(eq(5678))
   end
 
   it "should should raise a ParseError if input isn't a number" do
-    lambda { scope.function_to_bytes(["foo"]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_to_bytes(["foo"]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should should raise a ParseError if prefix is unknown" do
-    lambda { scope.function_to_bytes(["5 uB"]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_to_bytes(["5 uB"]) }.to( raise_error(Puppet::ParseError))
   end
 end
diff --git a/spec/functions/type_spec.rb b/spec/functions/type_spec.rb
index 8fec88f..9dfe9d7 100755
--- a/spec/functions/type_spec.rb
+++ b/spec/functions/type_spec.rb
@@ -4,40 +4,40 @@ require 'spec_helper'
 describe "the type function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
-    Puppet::Parser::Functions.function("type").should == "function_type"
+    expect(Puppet::Parser::Functions.function("type")).to eq("function_type")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_type([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_type([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return string when given a string" do
     result = scope.function_type(["aaabbbbcccc"])
-    result.should(eq('string'))
+    expect(result).to(eq('string'))
   end
 
   it "should return array when given an array" do
     result = scope.function_type([["aaabbbbcccc","asdf"]])
-    result.should(eq('array'))
+    expect(result).to(eq('array'))
   end
 
   it "should return hash when given a hash" do
     result = scope.function_type([{"a"=>1,"b"=>2}])
-    result.should(eq('hash'))
+    expect(result).to(eq('hash'))
   end
 
   it "should return integer when given an integer" do
     result = scope.function_type(["1"])
-    result.should(eq('integer'))
+    expect(result).to(eq('integer'))
   end
 
   it "should return float when given a float" do
     result = scope.function_type(["1.34"])
-    result.should(eq('float'))
+    expect(result).to(eq('float'))
   end
 
   it "should return boolean when given a boolean" do
     result = scope.function_type([true])
-    result.should(eq('boolean'))
+    expect(result).to(eq('boolean'))
   end
 end
diff --git a/spec/functions/union_spec.rb b/spec/functions/union_spec.rb
index 0d282ca..706f4cb 100755
--- a/spec/functions/union_spec.rb
+++ b/spec/functions/union_spec.rb
@@ -5,15 +5,15 @@ describe "the union function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("union").should == "function_union"
+    expect(Puppet::Parser::Functions.function("union")).to eq("function_union")
   end
 
   it "should raise a ParseError if there are fewer than 2 arguments" do
-    lambda { scope.function_union([]) }.should( raise_error(Puppet::ParseError) )
+    expect { scope.function_union([]) }.to( raise_error(Puppet::ParseError) )
   end
 
   it "should join two arrays together" do
     result = scope.function_union([["a","b","c"],["b","c","d"]])
-    result.should(eq(["a","b","c","d"]))
+    expect(result).to(eq(["a","b","c","d"]))
   end
 end
diff --git a/spec/functions/unique_spec.rb b/spec/functions/unique_spec.rb
index 5d48d49..8ec1464 100755
--- a/spec/functions/unique_spec.rb
+++ b/spec/functions/unique_spec.rb
@@ -5,20 +5,20 @@ describe "the unique function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("unique").should == "function_unique"
+    expect(Puppet::Parser::Functions.function("unique")).to eq("function_unique")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_unique([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_unique([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should remove duplicate elements in a string" do
     result = scope.function_unique(["aabbc"])
-    result.should(eq('abc'))
+    expect(result).to(eq('abc'))
   end
 
   it "should remove duplicate elements in an array" do
     result = scope.function_unique([["a","a","b","b","c"]])
-    result.should(eq(['a','b','c']))
+    expect(result).to(eq(['a','b','c']))
   end
 end
diff --git a/spec/functions/upcase_spec.rb b/spec/functions/upcase_spec.rb
index 5db5513..78e55dd 100755
--- a/spec/functions/upcase_spec.rb
+++ b/spec/functions/upcase_spec.rb
@@ -5,20 +5,20 @@ describe "the upcase function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("upcase").should == "function_upcase"
+    expect(Puppet::Parser::Functions.function("upcase")).to eq("function_upcase")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_upcase([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_upcase([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should upcase a string" do
     result = scope.function_upcase(["abc"])
-    result.should(eq('ABC'))
+    expect(result).to(eq('ABC'))
   end
 
   it "should do nothing if a string is already upcase" do
     result = scope.function_upcase(["ABC"])
-    result.should(eq('ABC'))
+    expect(result).to(eq('ABC'))
   end
 end
diff --git a/spec/functions/uriescape_spec.rb b/spec/functions/uriescape_spec.rb
index 7211c88..c44e9c1 100755
--- a/spec/functions/uriescape_spec.rb
+++ b/spec/functions/uriescape_spec.rb
@@ -5,20 +5,20 @@ describe "the uriescape function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("uriescape").should == "function_uriescape"
+    expect(Puppet::Parser::Functions.function("uriescape")).to eq("function_uriescape")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_uriescape([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_uriescape([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should uriescape a string" do
     result = scope.function_uriescape([":/?#[]@!$&'()*+,;= \"{}"])
-    result.should(eq(':/?%23[]@!$&\'()*+,;=%20%22%7B%7D'))
+    expect(result).to(eq(':/?%23[]@!$&\'()*+,;=%20%22%7B%7D'))
   end
 
   it "should do nothing if a string is already safe" do
     result = scope.function_uriescape(["ABCdef"])
-    result.should(eq('ABCdef'))
+    expect(result).to(eq('ABCdef'))
   end
 end
diff --git a/spec/functions/validate_slength_spec.rb b/spec/functions/validate_slength_spec.rb
index 851835f..e23f61a 100755
--- a/spec/functions/validate_slength_spec.rb
+++ b/spec/functions/validate_slength_spec.rb
@@ -6,7 +6,7 @@ describe "the validate_slength function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("validate_slength").should == "function_validate_slength"
+    expect(Puppet::Parser::Functions.function("validate_slength")).to eq("function_validate_slength")
   end
 
   describe "validating the input argument types" do
diff --git a/spec/functions/values_at_spec.rb b/spec/functions/values_at_spec.rb
index 08e95a5..86e3c31 100755
--- a/spec/functions/values_at_spec.rb
+++ b/spec/functions/values_at_spec.rb
@@ -5,34 +5,34 @@ describe "the values_at function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("values_at").should == "function_values_at"
+    expect(Puppet::Parser::Functions.function("values_at")).to eq("function_values_at")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_values_at([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_values_at([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if you try to use a range where stop is greater then start" do
-    lambda { scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_values_at([['a','b'],["3-1"]]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return a value at from an array" do
     result = scope.function_values_at([['a','b','c'],"1"])
-    result.should(eq(['b']))
+    expect(result).to(eq(['b']))
   end
 
   it "should return a value at from an array when passed a range" do
     result = scope.function_values_at([['a','b','c'],"0-1"])
-    result.should(eq(['a','b']))
+    expect(result).to(eq(['a','b']))
   end
 
   it "should return chosen values from an array when passed number of indexes" do
     result = scope.function_values_at([['a','b','c'],["0","2"]])
-    result.should(eq(['a','c']))
+    expect(result).to(eq(['a','c']))
   end
 
   it "should return chosen values from an array when passed ranges and multiple indexes" do
     result = scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
-    result.should(eq(['a','c','e','f']))
+    expect(result).to(eq(['a','c','e','f']))
   end
 end
diff --git a/spec/functions/values_spec.rb b/spec/functions/values_spec.rb
index 14ae417..08d21b0 100755
--- a/spec/functions/values_spec.rb
+++ b/spec/functions/values_spec.rb
@@ -5,27 +5,27 @@ describe "the values function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
-    Puppet::Parser::Functions.function("values").should == "function_values"
+    expect(Puppet::Parser::Functions.function("values")).to eq("function_values")
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_values([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_values([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should return values from a hash" do
     result = scope.function_values([{'a'=>'1','b'=>'2','c'=>'3'}])
     # =~ is the RSpec::Matchers::MatchArray matcher.
     # A.K.A. "array with same elements" (multiset) matching
-    result.should =~ %w{ 1 2 3 }
+    expect(result).to match_array(%w{ 1 2 3 })
   end
 
   it "should return a multiset" do
     result = scope.function_values([{'a'=>'1','b'=>'3','c'=>'3'}])
-    result.should     =~ %w{ 1 3 3 }
-    result.should_not =~ %w{ 1 3 }
+    expect(result).to     match_array(%w{ 1 3 3 })
+    expect(result).not_to match_array(%w{ 1 3 })
   end
 
   it "should raise a ParseError unless a Hash is provided" do
-    lambda { scope.function_values([['a','b','c']]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_values([['a','b','c']]) }.to( raise_error(Puppet::ParseError))
   end
 end
diff --git a/spec/functions/zip_spec.rb b/spec/functions/zip_spec.rb
index f45ab17..744bdd7 100755
--- a/spec/functions/zip_spec.rb
+++ b/spec/functions/zip_spec.rb
@@ -5,11 +5,11 @@ describe "the zip function" do
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_zip([]) }.should( raise_error(Puppet::ParseError))
+    expect { scope.function_zip([]) }.to( raise_error(Puppet::ParseError))
   end
 
   it "should be able to zip an array" do
     result = scope.function_zip([['1','2','3'],['4','5','6']])
-    result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
+    expect(result).to(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
   end
 end
-- 
cgit v1.2.3