puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/parser/functions/split_spec.rb

@@ -12,42 +12,7 @@ describe "the split function" do
     @scope   = Puppet::Parser::Scope.new(compiler)
   end
 
-  it "should exist" do
-    Puppet::Parser::Functions.function("split").should == "function_split"
+  it 'should raise a ParseError' do
+    expect { @scope.function_split([ '130;236;254;10', ';']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
-
-  it "should raise an ArgumentError if there is less than 2 arguments" do
-    lambda { @scope.function_split(["foo"]) }.should( raise_error(ArgumentError))
-  end
-
-  it "should raise an ArgumentError if there is more than 2 arguments" do
-    lambda { @scope.function_split(["foo", "bar", "gazonk"]) }.should( raise_error(ArgumentError))
-  end
-
-  it "should raise a RegexpError if the regexp is malformed" do
-    lambda { @scope.function_split(["foo", "("]) }.should(
-        raise_error(RegexpError))
-  end
-
-
-  it "should handle simple string without metacharacters" do
-    result = @scope.function_split([ "130;236;254;10", ";"])
-    result.should(eql(["130", "236", "254", "10"]))
-  end
-
-  it "should handle simple regexps" do
-    result = @scope.function_split([ "130.236;254.;10", "[.;]+"])
-    result.should(eql(["130", "236", "254", "10"]))
-  end
-
-  it "should handle groups" do
-    result = @scope.function_split([ "130.236;254.;10", "([.;]+)"])
-    result.should(eql(["130", ".", "236", ";", "254", ".;", "10"]))
-  end
-
-  it "should handle simple string without metacharacters" do
-    result = @scope.function_split([ "130.236.254.10", ";"])
-    result.should(eql(["130.236.254.10"]))
-  end
-
 end

data/spec/unit/parser/functions/sprintf_spec.rb

@@ -13,39 +13,35 @@ describe "the sprintf function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("sprintf").should == "function_sprintf"
+    expect(Puppet::Parser::Functions.function("sprintf")).to eq("function_sprintf")
   end
 
   it "should raise an ArgumentError if there is less than 1 argument" do
-    lambda { @scope.function_sprintf([]) }.should( raise_error(ArgumentError))
+    expect { @scope.function_sprintf([]) }.to( raise_error(ArgumentError))
   end
 
   it "should format integers" do
     result = @scope.function_sprintf(["%+05d", "23"])
-    result.should(eql("+0023"))
+    expect(result).to(eql("+0023"))
   end
 
   it "should format floats" do
     result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
-    result.should(eql("+2.72"))
+    expect(result).to(eql("+2.72"))
   end
 
   it "should format large floats" do
     result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
     str =
-      if Puppet.features.microsoft_windows? && RUBY_VERSION[0,3] == '1.8'
-        "+2.72e+016"
-      else
-        "+2.72e+16"
-      end
-    result.should(eql(str))
+      "+2.72e+16"
+    expect(result).to(eql(str))
   end
 
   it "should perform more complex formatting" do
     result = @scope.function_sprintf(
       [ "<%.8s:%#5o %#8X (%-8s)>",
         "overlongstring", "23", "48879", "foo" ])
-    result.should(eql("<overlong:  027   0XBEEF (foo     )>"))
+    expect(result).to(eql("<overlong:  027   0XBEEF (foo     )>"))
   end
 
 end

data/spec/unit/parser/functions/tag_spec.rb

@@ -13,7 +13,7 @@ describe "the 'tag' function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function(:tag).should == "function_tag"
+    expect(Puppet::Parser::Functions.function(:tag)).to eq("function_tag")
   end
 
   it "should tag the resource with any provided tags" do
@@ -22,7 +22,7 @@ describe "the 'tag' function" do
 
     @scope.function_tag ["one", "two"]
 
-    resource.should be_tagged("one")
-    resource.should be_tagged("two")
+    expect(resource).to be_tagged("one")
+    expect(resource).to be_tagged("two")
   end
 end

data/spec/unit/parser/functions/template_spec.rb

@@ -19,7 +19,7 @@ describe "the template function" do
     tw1.stubs(:result).returns("result1")
     tw2.stubs(:result).returns("result2")
 
-    scope.function_template(["1","2"]).should == "result1result2"
+    expect(scope.function_template(["1","2"])).to eq("result1result2")
   end
 
   it "raises an error if the template raises an error" do
@@ -36,12 +36,12 @@ describe "the template function" do
     it "raises an error when accessing an undefined variable" do
       expect {
         eval_template("template <%= deprecated %>")
-      }.to raise_error(Puppet::ParseError, /Could not find value for 'deprecated'/)
+      }.to raise_error(Puppet::ParseError, /undefined local variable or method `deprecated'/)
     end
 
     it "looks up the value from the scope" do
       scope["deprecated"] = "deprecated value"
-      eval_template("template <%= deprecated %>").should == "template deprecated value"
+      expect { eval_template("template <%= deprecated %>")}.to raise_error(/undefined local variable or method `deprecated'/)
     end
 
     it "still has access to Kernel methods" do
@@ -52,37 +52,37 @@ describe "the template function" do
   context "when accessing scope variables as instance variables" do
     it "has access to values" do
       scope['scope_var'] = "value"
-      eval_template("<%= @scope_var %>").should == "value"
+      expect(eval_template("<%= @scope_var %>")).to eq("value")
     end
 
     it "get nil accessing a variable that does not exist" do
-      eval_template("<%= @not_defined.nil? %>").should == "true"
+      expect(eval_template("<%= @not_defined.nil? %>")).to eq("true")
     end
 
     it "get nil accessing a variable that is undef" do
       scope['undef_var'] = :undef
-      eval_template("<%= @undef_var.nil? %>").should == "true"
+      expect(eval_template("<%= @undef_var.nil? %>")).to eq("true")
     end
   end
 
   it "is not interfered with by having a variable named 'string' (#14093)" do
     scope['string'] = "this output should not be seen"
-    eval_template("some text that is static").should == "some text that is static"
+    expect(eval_template("some text that is static")).to eq("some text that is static")
   end
 
   it "has access to a variable named 'string' (#14093)" do
     scope['string'] = "the string value"
-    eval_template("string was: <%= @string %>").should == "string was: the string value"
+    expect(eval_template("string was: <%= @string %>")).to eq("string was: the string value")
   end
 
   it "does not have direct access to Scope#lookupvar" do
     expect {
       eval_template("<%= lookupvar('myvar') %>")
-    }.to raise_error(Puppet::ParseError, /Could not find value for 'lookupvar'/)
+    }.to raise_error(Puppet::ParseError, /undefined method `lookupvar'/)
   end
 
   def eval_template(content)
-    Puppet::FileSystem.stubs(:read_preserve_line_endings).with("template").returns(content)
+    File.stubs(:read).with("template").returns(content)
     Puppet::Parser::Files.stubs(:find_template).returns("template")
     scope.function_template(['template'])
   end

data/spec/unit/parser/functions/versioncmp_spec.rb

@@ -13,15 +13,15 @@ describe "the versioncmp function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("versioncmp").should == "function_versioncmp"
+    expect(Puppet::Parser::Functions.function("versioncmp")).to eq("function_versioncmp")
   end
 
   it "should raise an ArgumentError if there is less than 2 arguments" do
-    lambda { @scope.function_versioncmp(["1.2"]) }.should raise_error(ArgumentError)
+    expect { @scope.function_versioncmp(["1.2"]) }.to raise_error(ArgumentError)
   end
 
   it "should raise an ArgumentError if there is more than 2 arguments" do
-    lambda { @scope.function_versioncmp(["1.2", "2.4.5", "3.5.6"]) }.should raise_error(ArgumentError)
+    expect { @scope.function_versioncmp(["1.2", "2.4.5", "3.5.6"]) }.to raise_error(ArgumentError)
   end
 
   it "should call Puppet::Util::Package.versioncmp (included in scope)" do

data/spec/unit/parser/functions_spec.rb

@@ -15,14 +15,14 @@ describe Puppet::Parser::Functions do
   end
 
   it "should have a method for returning an environment-specific module" do
-    Puppet::Parser::Functions.environment_module(environment).should be_instance_of(Module)
+    expect(Puppet::Parser::Functions.environment_module(environment)).to be_instance_of(Module)
   end
 
   describe "when calling newfunction" do
     it "should create the function in the environment module" do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
 
-      function_module.should be_method_defined :function_name
+      expect(function_module).to be_method_defined :function_name
     end
 
     it "should warn if the function already exists" do
@@ -43,7 +43,7 @@ describe Puppet::Parser::Functions do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
       callable_functions_from(function_module).function_name([])
 
-      messages.first.should =~ /Called name/
+      expect(messages.first).to match(/Called name/)
     end
   end
 
@@ -51,13 +51,13 @@ describe Puppet::Parser::Functions do
     it "should return false if the function doesn't exist" do
       Puppet::Parser::Functions.autoloader.stubs(:load)
 
-      Puppet::Parser::Functions.function("name").should be_false
+      expect(Puppet::Parser::Functions.function("name")).to be_falsey
     end
 
     it "should return its name if the function exists" do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
 
-      Puppet::Parser::Functions.function("name").should == "function_name"
+      expect(Puppet::Parser::Functions.function("name")).to eq("function_name")
     end
 
     it "should try to autoload the function if it doesn't exist yet" do
@@ -80,7 +80,7 @@ describe Puppet::Parser::Functions do
         expect(Puppet::Parser::Functions.function("other_env")).to eq("function_other_env")
       end
 
-      expect(Puppet::Parser::Functions.function("other_env")).to be_false
+      expect(Puppet::Parser::Functions.function("other_env")).to be_falsey
     end
   end
 
@@ -121,12 +121,12 @@ describe Puppet::Parser::Functions do
   describe "::arity" do
     it "returns the given arity of a function" do
       Puppet::Parser::Functions.newfunction("name", :arity => 4) { |args| }
-      Puppet::Parser::Functions.arity(:name).should == 4
+      expect(Puppet::Parser::Functions.arity(:name)).to eq(4)
     end
 
     it "returns -1 if no arity is given" do
       Puppet::Parser::Functions.newfunction("name") { |args| }
-      Puppet::Parser::Functions.arity(:name).should == -1
+      expect(Puppet::Parser::Functions.arity(:name)).to eq(-1)
     end
   end
 end

data/spec/unit/parser/relationship_spec.rb

@@ -24,25 +24,25 @@ describe Puppet::Parser::Relationship do
     it "should fail if the source resource cannot be found" do
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @target
-      lambda { @dep.evaluate(@catalog) }.should raise_error(ArgumentError)
+      expect { @dep.evaluate(@catalog) }.to raise_error(ArgumentError)
     end
 
     it "should fail if the target resource cannot be found" do
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @source
-      lambda { @dep.evaluate(@catalog) }.should raise_error(ArgumentError)
+      expect { @dep.evaluate(@catalog) }.to raise_error(ArgumentError)
     end
 
     it "should add the target as a 'before' value if the type is 'relationship'" do
       @dep.type = :relationship
       @dep.evaluate(@catalog)
-      @source[:before].should be_include("Mytype[target]")
+      expect(@source[:before]).to be_include("Mytype[target]")
     end
 
     it "should add the target as a 'notify' value if the type is 'subscription'" do
       @dep.type = :subscription
       @dep.evaluate(@catalog)
-      @source[:notify].should be_include("Mytype[target]")
+      expect(@source[:notify]).to be_include("Mytype[target]")
     end
 
     it "should supplement rather than clobber existing relationship values" do
@@ -50,44 +50,26 @@ describe Puppet::Parser::Relationship do
       @dep.evaluate(@catalog)
       # this test did not work before. It was appending the resources
       # together as a string
-      (@source[:before].class == Array).should be_true
-      @source[:before].should be_include("Mytype[target]")
-      @source[:before].should be_include("File[/bar]")
+      expect(@source[:before].class == Array).to be_truthy
+      expect(@source[:before]).to be_include("Mytype[target]")
+      expect(@source[:before]).to be_include("File[/bar]")
     end
 
     it "should supplement rather than clobber existing resource relationships" do
       @source[:before] = @extra_resource
       @dep.evaluate(@catalog)
-      (@source[:before].class == Array).should be_true
-      @source[:before].should be_include("Mytype[target]")
-      @source[:before].should be_include(@extra_resource)
+      expect(@source[:before].class == Array).to be_truthy
+      expect(@source[:before]).to be_include("Mytype[target]")
+      expect(@source[:before]).to be_include(@extra_resource)
     end
 
     it "should supplement rather than clobber multiple existing resource relationships" do
       @source[:before] = [@extra_resource, @extra_resource2]
       @dep.evaluate(@catalog)
-      (@source[:before].class == Array).should be_true
-      @source[:before].should be_include("Mytype[target]")
-      @source[:before].should be_include(@extra_resource)
-      @source[:before].should be_include(@extra_resource2)
-    end
-
-    it "should use the collected retargets if the target is a Collector" do
-      orig_target = @target
-      @target = Puppet::Parser::Collector.new(stub("scope"), :file, "equery", "vquery", :virtual)
-      @target.collected[:foo] = @target
-      @dep.evaluate(@catalog)
-
-      @source[:before].should be_include("Mytype[target]")
-    end
-
-    it "should use the collected resources if the source is a Collector" do
-      orig_source = @source
-      @source = Puppet::Parser::Collector.new(stub("scope"), :file, "equery", "vquery", :virtual)
-      @source.collected[:foo] = @source
-      @dep.evaluate(@catalog)
-
-      orig_source[:before].should be_include("Mytype[target]")
+      expect(@source[:before].class == Array).to be_truthy
+      expect(@source[:before]).to be_include("Mytype[target]")
+      expect(@source[:before]).to be_include(@extra_resource)
+      expect(@source[:before]).to be_include(@extra_resource2)
     end
   end
 end

data/spec/unit/parser/resource_spec.rb

@@ -51,53 +51,53 @@ describe Puppet::Parser::Resource do
   it "should get its environment from its scope" do
     scope = stub 'scope', :source => stub("source"), :namespaces => nil
     scope.expects(:environment).returns("foo").at_least_once
-    Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment.should == "foo"
+    expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
   it "should use the resource type collection helper module" do
-    Puppet::Parser::Resource.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
+    expect(Puppet::Parser::Resource.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should use the scope's environment as its environment" do
     @scope.expects(:environment).returns("myenv").at_least_once
-    Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment.should == "myenv"
+    expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment).to eq("myenv")
   end
 
   it "should be isomorphic if it is builtin and models an isomorphic type" do
     Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
-    @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
+    @resource = expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_truthy
   end
 
   it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
     Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
-    @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
+    @resource = expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_falsey
   end
 
   it "should be isomorphic if it is not builtin" do
     newdefine "whatever"
-    @resource = Puppet::Parser::Resource.new("whatever", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
+    @resource = expect(Puppet::Parser::Resource.new("whatever", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_truthy
   end
 
   it "should have an array-indexing method for retrieving parameter values" do
     @resource = mkresource
-    @resource[:one].should == "yay"
+    expect(@resource[:one]).to eq("yay")
   end
 
   it "should use a Puppet::Resource for converting to a ral resource" do
     trans = mock 'resource', :to_ral => "yay"
     @resource = mkresource
     @resource.expects(:copy_as_resource).returns trans
-    @resource.to_ral.should == "yay"
+    expect(@resource.to_ral).to eq("yay")
   end
 
   it "should be able to use the indexing operator to access parameters" do
     resource = Puppet::Parser::Resource.new("resource", "testing", :source => "source", :scope => @scope)
     resource["foo"] = "bar"
-    resource["foo"].should == "bar"
+    expect(resource["foo"]).to eq("bar")
   end
 
   it "should return the title when asked for a parameter named 'title'" do
-    Puppet::Parser::Resource.new("resource", "testing", :source => @source, :scope => @scope)[:title].should == "testing"
+    expect(Puppet::Parser::Resource.new("resource", "testing", :source => @source, :scope => @scope)[:title]).to eq("testing")
   end
 
   describe "when initializing" do
@@ -113,15 +113,15 @@ describe Puppet::Parser::Resource do
 
     it "should set the reference correctly" do
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
-      res.ref.should == "Resource[testing]"
+      expect(res.ref).to eq("Resource[testing]")
     end
 
     it "should be tagged with user tags" do
       tags = [ "tag1", "tag2" ]
       @arguments[:parameters] = [ param(:tag, tags , :source) ]
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
-      res.should be_tagged("tag1")
-      res.should be_tagged("tag2")
+      expect(res).to be_tagged("tag1")
+      expect(res).to be_tagged("tag2")
     end
   end
 
@@ -167,7 +167,7 @@ describe Puppet::Parser::Resource do
 
       resource.evaluate
 
-      @compiler.catalog.edge?(other_stage, resource).should be_true
+      expect(@compiler.catalog.edge?(other_stage, resource)).to be_truthy
     end
 
     it "should fail if an unknown stage is specified" do
@@ -190,7 +190,7 @@ describe Puppet::Parser::Resource do
 
       resource.evaluate
 
-      @compiler.catalog.should be_edge(foo_stage, resource)
+      expect(@compiler.catalog).to be_edge(foo_stage, resource)
     end
 
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
@@ -212,9 +212,9 @@ describe Puppet::Parser::Resource do
       # Stringify them to make for easier lookup
       edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
 
-      edges.should include(["Stage[before]", "Class[Alpha]"])
-      edges.should include(["Stage[before]", "Class[Beta]"])
-      edges.should include(["Stage[before]", "Class[Gamma]"])
+      expect(edges).to include(["Stage[before]", "Class[Alpha]"])
+      expect(edges).to include(["Stage[before]", "Class[Beta]"])
+      expect(edges).to include(["Stage[before]", "Class[Gamma]"])
     end
 
     it "should use the specified stage even if the parent scope specifies one" do
@@ -233,8 +233,8 @@ describe Puppet::Parser::Resource do
 
       edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
 
-      edges.should include(["Stage[before]", "Class[Alpha]"])
-      edges.should include(["Stage[after]", "Class[Beta]"])
+      expect(edges).to include(["Stage[before]", "Class[Alpha]"])
+      expect(edges).to include(["Stage[after]", "Class[Beta]"])
     end
 
     it "should add edges from top-level class resources to the main stage if no stage is specified" do
@@ -245,7 +245,7 @@ describe Puppet::Parser::Resource do
 
       resource.evaluate
 
-      @compiler.catalog.should be_edge(main, resource)
+      expect(@compiler.catalog).to be_edge(main, resource)
     end
   end
 
@@ -267,7 +267,7 @@ describe Puppet::Parser::Resource do
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
       @resource.finish
 
-      @resource[:owner].should == "default"
+      expect(@resource[:owner]).to eq("default")
     end
 
     it "should not replace existing parameters with defaults" do
@@ -275,7 +275,7 @@ describe Puppet::Parser::Resource do
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
       @resource.finish
 
-      @resource[:owner].should == "oldvalue"
+      expect(@resource[:owner]).to eq("oldvalue")
     end
 
     it "should add a copy of each default, rather than the actual default parameter instance" do
@@ -286,7 +286,7 @@ describe Puppet::Parser::Resource do
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
       @resource.finish
 
-      @resource[:owner].should == "other"
+      expect(@resource[:owner]).to eq("other")
     end
   end
 
@@ -298,28 +298,28 @@ describe Puppet::Parser::Resource do
     end
 
     it "should get tagged with the resource type" do
-      @resource.tags.should be_include("file")
+      expect(@resource.tags).to be_include("file")
     end
 
     it "should get tagged with the title" do
-      @resource.tags.should be_include("yay")
+      expect(@resource.tags).to be_include("yay")
     end
 
     it "should get tagged with each name in the title if the title is a qualified class name" do
       resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => mock('source'))
-      resource.tags.should be_include("one")
-      resource.tags.should be_include("two")
+      expect(resource.tags).to be_include("one")
+      expect(resource.tags).to be_include("two")
     end
 
     it "should get tagged with each name in the type if the type is a qualified class name" do
       resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => mock('source'))
-      resource.tags.should be_include("one")
-      resource.tags.should be_include("two")
+      expect(resource.tags).to be_include("one")
+      expect(resource.tags).to be_include("two")
     end
 
     it "should not get tagged with non-alphanumeric titles" do
       resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => mock('source'))
-      resource.tags.should_not be_include("this is a test")
+      expect(resource.tags).not_to be_include("this is a test")
     end
 
     it "should fail on tags containing '*' characters" do
@@ -379,7 +379,7 @@ describe Puppet::Parser::Resource do
       @override.set_parameter(:testing, "value")
       @resource.merge(@override)
 
-      @resource[:testing].should == "value"
+      expect(@resource[:testing]).to eq("value")
     end
 
     it "should replace existing parameter values" do
@@ -389,7 +389,7 @@ describe Puppet::Parser::Resource do
 
       @resource.merge(@override)
 
-      @resource[:testing].should == "value"
+      expect(@resource[:testing]).to eq("value")
     end
 
     it "should add values to the parameter when the override was created with the '+>' syntax" do
@@ -403,7 +403,7 @@ describe Puppet::Parser::Resource do
 
       @resource.merge(@override)
 
-      @resource[:testing].should == %w{other testing}
+      expect(@resource[:testing]).to eq(%w{other testing})
     end
 
     it "should not merge parameter values when multiple resources are overriden with '+>' at once " do
@@ -420,8 +420,8 @@ describe Puppet::Parser::Resource do
       @resource.  merge(@override)
       @resource_2.merge(@override)
 
-      @resource  [:testing].should == %w{old_val_1 new_val}
-      @resource_2[:testing].should == %w{old_val_2 new_val}
+      expect(@resource  [:testing]).to eq(%w{old_val_1 new_val})
+      expect(@resource_2[:testing]).to eq(%w{old_val_2 new_val})
     end
 
     it "should promote tag overrides to real tags" do
@@ -432,7 +432,7 @@ describe Puppet::Parser::Resource do
 
       @resource.merge(@override)
 
-      @resource.tagged?("testing").should be_true
+      expect(@resource.tagged?("testing")).to be_truthy
     end
 
   end
@@ -440,7 +440,7 @@ describe Puppet::Parser::Resource do
   it "should be able to be converted to a normal resource" do
     @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
-    @resource.should respond_to(:copy_as_resource)
+    expect(@resource).to respond_to(:copy_as_resource)
   end
 
   describe "when being converted to a resource" do
@@ -449,64 +449,64 @@ describe Puppet::Parser::Resource do
     end
 
     it "should create an instance of Puppet::Resource" do
-      @parser_resource.copy_as_resource.should be_instance_of(Puppet::Resource)
+      expect(@parser_resource.copy_as_resource).to be_instance_of(Puppet::Resource)
     end
 
     it "should set the type correctly on the Puppet::Resource" do
-      @parser_resource.copy_as_resource.type.should == @parser_resource.type
+      expect(@parser_resource.copy_as_resource.type).to eq(@parser_resource.type)
     end
 
     it "should set the title correctly on the Puppet::Resource" do
-      @parser_resource.copy_as_resource.title.should == @parser_resource.title
+      expect(@parser_resource.copy_as_resource.title).to eq(@parser_resource.title)
     end
 
     it "should copy over all of the parameters" do
       result = @parser_resource.copy_as_resource.to_hash
 
       # The name will be in here, also.
-      result[:foo].should == "bar"
-      result[:fee].should == "fum"
+      expect(result[:foo]).to eq("bar")
+      expect(result[:fee]).to eq("fum")
     end
 
     it "should copy over the tags" do
       @parser_resource.tag "foo"
       @parser_resource.tag "bar"
 
-      @parser_resource.copy_as_resource.tags.should == @parser_resource.tags
+      expect(@parser_resource.copy_as_resource.tags).to eq(@parser_resource.tags)
     end
 
     it "should copy over the line" do
       @parser_resource.line = 40
-      @parser_resource.copy_as_resource.line.should == 40
+      expect(@parser_resource.copy_as_resource.line).to eq(40)
     end
 
     it "should copy over the file" do
       @parser_resource.file = "/my/file"
-      @parser_resource.copy_as_resource.file.should == "/my/file"
+      expect(@parser_resource.copy_as_resource.file).to eq("/my/file")
     end
 
     it "should copy over the 'exported' value" do
       @parser_resource.exported = true
-      @parser_resource.copy_as_resource.exported.should be_true
+      expect(@parser_resource.copy_as_resource.exported).to be_truthy
     end
 
     it "should copy over the 'virtual' value" do
       @parser_resource.virtual = true
-      @parser_resource.copy_as_resource.virtual.should be_true
+      expect(@parser_resource.copy_as_resource.virtual).to be_truthy
     end
 
     it "should convert any parser resource references to Puppet::Resource instances" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ref}
       result = @parser_resource.copy_as_resource
-      result[:fee].should == Puppet::Resource.new(:file, "/my/file")
+      expect(result[:fee]).to eq(Puppet::Resource.new(:file, "/my/file"))
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", ref]}
       result = @parser_resource.copy_as_resource
-      result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file")]
+      expect(result[:fee]).to eq(["a", Puppet::Resource.new(:file, "/my/file")])
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array of array, and even deeper" do
@@ -514,11 +514,11 @@ describe Puppet::Parser::Resource do
       ref2 = Puppet::Resource.new("file", "/my/file2")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
       result = @parser_resource.copy_as_resource
-      result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file1"), Puppet::Resource.new(:file, "/my/file2")]
+      expect(result[:fee]).to eq(["a", Puppet::Resource.new(:file, "/my/file1"), Puppet::Resource.new(:file, "/my/file2")])
     end
 
     it "should fail if the same param is declared twice" do
-      lambda do
+      expect do
         @parser_resource = mkresource :source => @source, :parameters => [
           Puppet::Parser::Resource::Param.new(
             :name => :foo, :value => "bar", :source => @source
@@ -527,7 +527,7 @@ describe Puppet::Parser::Resource do
             :name => :foo, :value => "baz", :source => @source
           )
         ]
-      end.should raise_error(Puppet::ParseError)
+      end.to raise_error(Puppet::ParseError)
     end
   end
 
@@ -558,17 +558,17 @@ describe Puppet::Parser::Resource do
     it "should accept Param instances and add them to the parameter list" do
       param = Puppet::Parser::Resource::Param.new :name => "foo", :value => "bar", :source => @source
       @resource.set_parameter(param)
-      @resource["foo"].should == "bar"
+      expect(@resource["foo"]).to eq("bar")
     end
 
     it "should allow parameters to be set to 'false'" do
       @resource.set_parameter("myparam", false)
-      @resource["myparam"].should be_false
+      expect(@resource["myparam"]).to be_falsey
     end
 
     it "should use its source when provided a parameter name and value" do
       @resource.set_parameter("myparam", "myvalue")
-      @resource["myparam"].should == "myvalue"
+      expect(@resource["myparam"]).to eq("myvalue")
     end
   end
 
@@ -577,6 +577,6 @@ describe Puppet::Parser::Resource do
     resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
     resource[:owner] = :undef
     resource[:mode] = "755"
-    resource.to_hash[:owner].should be_nil
+    expect(resource.to_hash[:owner]).to be_nil
   end
 end