puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/resource_spec.rb

@@ -11,13 +11,13 @@ describe Puppet::Resource do
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
       resource = Puppet::Resource.new("file", "/my/file")
-      resource.should respond_to(attr)
-      resource.should respond_to(attr.to_s + "=")
+      expect(resource).to respond_to(attr)
+      expect(resource).to respond_to(attr.to_s + "=")
     end
   end
 
   it "should have a :title attribute" do
-    Puppet::Resource.new(:user, "foo").title.should == "foo"
+    expect(Puppet::Resource.new(:user, "foo").title).to eq("foo")
   end
 
   it "should require the type and title" do
@@ -25,77 +25,77 @@ describe Puppet::Resource do
   end
 
   it "should canonize types to capitalized strings" do
-    Puppet::Resource.new(:user, "foo").type.should == "User"
+    expect(Puppet::Resource.new(:user, "foo").type).to eq("User")
   end
 
   it "should canonize qualified types so all strings are capitalized" do
-    Puppet::Resource.new("foo::bar", "foo").type.should == "Foo::Bar"
+    expect(Puppet::Resource.new("foo::bar", "foo").type).to eq("Foo::Bar")
   end
 
   it "should tag itself with its type" do
-    Puppet::Resource.new("file", "/f").should be_tagged("file")
+    expect(Puppet::Resource.new("file", "/f")).to be_tagged("file")
   end
 
   it "should tag itself with its title if the title is a valid tag" do
-    Puppet::Resource.new("user", "bar").should be_tagged("bar")
+    expect(Puppet::Resource.new("user", "bar")).to be_tagged("bar")
   end
 
   it "should not tag itself with its title if the title is a not valid tag" do
-    Puppet::Resource.new("file", "/bar").should_not be_tagged("/bar")
+    expect(Puppet::Resource.new("file", "/bar")).not_to be_tagged("/bar")
   end
 
   it "should allow setting of attributes" do
-    Puppet::Resource.new("file", "/bar", :file => "/foo").file.should == "/foo"
-    Puppet::Resource.new("file", "/bar", :exported => true).should be_exported
+    expect(Puppet::Resource.new("file", "/bar", :file => "/foo").file).to eq("/foo")
+    expect(Puppet::Resource.new("file", "/bar", :exported => true)).to be_exported
   end
 
   it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
     ref = Puppet::Resource.new(:component, "foo")
-    ref.type.should == "Class"
-    ref.title.should == "Foo"
+    expect(ref.type).to eq("Class")
+    expect(ref.title).to eq("Foo")
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
     ref = Puppet::Resource.new(:component, "foo::bar[yay]")
-    ref.type.should == "Foo::Bar"
-    ref.title.should == "yay"
+    expect(ref.type).to eq("Foo::Bar")
+    expect(ref.title).to eq("yay")
   end
 
   it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
     ref = Puppet::Resource.new(nil, "yay")
-    ref.type.should == "Class"
-    ref.title.should == "Yay"
+    expect(ref.type).to eq("Class")
+    expect(ref.title).to eq("Yay")
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[yay]")
-    ref.type.should == "Foo::Bar"
-    ref.title.should == "yay"
+    expect(ref.type).to eq("Foo::Bar")
+    expect(ref.title).to eq("yay")
   end
 
   it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
     ref = Puppet::Resource.new(nil, "foo::bar[baz[yay]]")
-    ref.type.should == "Foo::Bar"
-    ref.title.should =="baz[yay]"
+    expect(ref.type).to eq("Foo::Bar")
+    expect(ref.title).to eq("baz[yay]")
   end
 
   it "should interpret the type as a reference and assign appropriately if the title is nil and the type contains square brackets" do
     ref = Puppet::Resource.new("foo::bar[baz]")
-    ref.type.should == "Foo::Bar"
-    ref.title.should =="baz"
+    expect(ref.type).to eq("Foo::Bar")
+    expect(ref.title).to eq("baz")
   end
 
   it "should not interpret the title as a reference if the type is a non component or whit reference" do
     ref = Puppet::Resource.new("Notify", "foo::bar[baz]")
-    ref.type.should == "Notify"
-    ref.title.should =="foo::bar[baz]"
+    expect(ref.type).to eq("Notify")
+    expect(ref.title).to eq("foo::bar[baz]")
   end
 
   it "should be able to extract its information from a Puppet::Type instance" do
     ral = Puppet::Type.type(:file).new :path => basepath+"/foo"
     ref = Puppet::Resource.new(ral)
-    ref.type.should == "File"
-    ref.title.should == basepath+"/foo"
+    expect(ref.type).to eq("File")
+    expect(ref.title).to eq(basepath+"/foo")
   end
 
 
@@ -117,24 +117,24 @@ describe Puppet::Resource do
   end
 
   it "should be taggable" do
-    Puppet::Resource.ancestors.should be_include(Puppet::Util::Tagging)
+    expect(Puppet::Resource.ancestors).to be_include(Puppet::Util::Tagging)
   end
 
   it "should have an 'exported' attribute" do
     resource = Puppet::Resource.new("file", "/f")
     resource.exported = true
-    resource.exported.should == true
-    resource.should be_exported
+    expect(resource.exported).to eq(true)
+    expect(resource).to be_exported
   end
 
   describe "and munging its type and title" do
     describe "when modeling a builtin resource" do
       it "should be able to find the resource type" do
-        Puppet::Resource.new("file", "/my/file").resource_type.should equal(Puppet::Type.type(:file))
+        expect(Puppet::Resource.new("file", "/my/file").resource_type).to equal(Puppet::Type.type(:file))
       end
 
       it "should set its type to the capitalized type name" do
-        Puppet::Resource.new("file", "/my/file").type.should == "File"
+        expect(Puppet::Resource.new("file", "/my/file").type).to eq("File")
       end
     end
 
@@ -146,21 +146,21 @@ describe Puppet::Resource do
         end
 
         it "should set its type to the capitalized type name" do
-          Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).type.should == "Foo::Bar"
+          expect(Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).type).to eq("Foo::Bar")
         end
 
         it "should be able to find the resource type" do
-          Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).resource_type.should equal(@type)
+          expect(Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).resource_type).to equal(@type)
         end
 
         it "should set its title to the provided title" do
-          Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).title.should == "/my/file"
+          expect(Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).title).to eq("/my/file")
         end
       end
 
       describe "that does not exist" do
         it "should set its resource type to the capitalized resource type name" do
-          Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
+          expect(Puppet::Resource.new("foo::bar", "/my/file").type).to eq("Foo::Bar")
         end
       end
     end
@@ -169,14 +169,14 @@ describe Puppet::Resource do
       # Life's easier with nodes, because they can't be qualified.
       it "should set its type to 'Node' and its title to the provided title" do
         node = Puppet::Resource.new("node", "foo")
-        node.type.should == "Node"
-        node.title.should == "foo"
+        expect(node.type).to eq("Node")
+        expect(node.title).to eq("foo")
       end
     end
 
     describe "when modeling a class" do
       it "should set its type to 'Class'" do
-        Puppet::Resource.new("class", "foo").type.should == "Class"
+        expect(Puppet::Resource.new("class", "foo").type).to eq("Class")
       end
 
       describe "that exists" do
@@ -186,25 +186,25 @@ describe Puppet::Resource do
         end
 
         it "should set its title to the capitalized, fully qualified resource type" do
-          Puppet::Resource.new("class", "foo::bar", :environment => environment).title.should == "Foo::Bar"
+          expect(Puppet::Resource.new("class", "foo::bar", :environment => environment).title).to eq("Foo::Bar")
         end
 
         it "should be able to find the resource type" do
-          Puppet::Resource.new("class", "foo::bar", :environment => environment).resource_type.should equal(@type)
+          expect(Puppet::Resource.new("class", "foo::bar", :environment => environment).resource_type).to equal(@type)
         end
       end
 
       describe "that does not exist" do
         it "should set its type to 'Class' and its title to the capitalized provided name" do
           klass = Puppet::Resource.new("class", "foo::bar")
-          klass.type.should == "Class"
-          klass.title.should == "Foo::Bar"
+          expect(klass.type).to eq("Class")
+          expect(klass.title).to eq("Foo::Bar")
         end
       end
 
       describe "and its name is set to the empty string" do
         it "should set its title to :main" do
-          Puppet::Resource.new("class", "").title.should == :main
+          expect(Puppet::Resource.new("class", "").title).to eq(:main)
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
@@ -212,14 +212,14 @@ describe Puppet::Resource do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             environment.known_resource_types.add @type
 
-            Puppet::Resource.new("class", "", :environment => environment).title.should == :main
+            expect(Puppet::Resource.new("class", "", :environment => environment).title).to eq(:main)
           end
         end
       end
 
       describe "and its name is set to :main" do
         it "should set its title to :main" do
-          Puppet::Resource.new("class", :main).title.should == :main
+          expect(Puppet::Resource.new("class", :main).title).to eq(:main)
         end
 
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
@@ -227,7 +227,7 @@ describe Puppet::Resource do
             @type = Puppet::Resource::Type.new(:hostclass, "")
             environment.known_resource_types.add @type
 
-            Puppet::Resource.new("class", :main, :environment => environment).title.should == :main
+            expect(Puppet::Resource.new("class", :main, :environment => environment).title).to eq(:main)
           end
         end
       end
@@ -235,7 +235,7 @@ describe Puppet::Resource do
   end
 
   it "should return nil when looking up resource types that don't exist" do
-    Puppet::Resource.new("foobar", "bar").resource_type.should be_nil
+    expect(Puppet::Resource.new("foobar", "bar").resource_type).to be_nil
   end
 
   it "should not fail when an invalid parameter is used and strict mode is disabled" do
@@ -246,27 +246,27 @@ describe Puppet::Resource do
   end
 
   it "should be considered equivalent to another resource if their type and title match and no parameters are set" do
-    Puppet::Resource.new("file", "/f").should == Puppet::Resource.new("file", "/f")
+    expect(Puppet::Resource.new("file", "/f")).to eq(Puppet::Resource.new("file", "/f"))
   end
 
   it "should be considered equivalent to another resource if their type, title, and parameters are equal" do
-    Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}).should == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
+    expect(Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})).to eq(Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}))
   end
 
   it "should not be considered equivalent to another resource if their type and title match but parameters are different" do
-    Puppet::Resource.new("file", "/f", :parameters => {:fee => "baz"}).should_not == Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"})
+    expect(Puppet::Resource.new("file", "/f", :parameters => {:fee => "baz"})).not_to eq(Puppet::Resource.new("file", "/f", :parameters => {:foo => "bar"}))
   end
 
   it "should not be considered equivalent to a non-resource" do
-    Puppet::Resource.new("file", "/f").should_not == "foo"
+    expect(Puppet::Resource.new("file", "/f")).not_to eq("foo")
   end
 
   it "should not be considered equivalent to another resource if their types do not match" do
-    Puppet::Resource.new("file", "/f").should_not == Puppet::Resource.new("exec", "/f")
+    expect(Puppet::Resource.new("file", "/f")).not_to eq(Puppet::Resource.new("exec", "/f"))
   end
 
   it "should not be considered equivalent to another resource if their titles do not match" do
-    Puppet::Resource.new("file", "/foo").should_not == Puppet::Resource.new("file", "/f")
+    expect(Puppet::Resource.new("file", "/foo")).not_to eq(Puppet::Resource.new("file", "/f"))
   end
 
   describe "when setting default parameters" do
@@ -274,47 +274,47 @@ describe Puppet::Resource do
     let(:compiler) { Puppet::Parser::Compiler.new(foo_node) }
     let(:scope)    { Puppet::Parser::Scope.new(compiler) }
 
-    def ast_string(value)
-      Puppet::Parser::AST::String.new({:value => value})
+    def ast_leaf(value)
+      Puppet::Parser::AST::Leaf.new({:value => value})
     end
 
     it "should fail when asked to set default values and it is not a parser resource" do
       environment.known_resource_types.add(
-      Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("default")})
+      Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
       )
       resource = Puppet::Resource.new("default_param", "name", :environment => environment)
-      lambda { resource.set_default_parameters(scope) }.should raise_error(Puppet::DevError)
+      expect { resource.set_default_parameters(scope) }.to raise_error(Puppet::DevError)
     end
 
     it "should evaluate and set any default values when no value is provided" do
       environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
       resource.set_default_parameters(scope)
-      resource["a"].should == "a_default_value"
+      expect(resource["a"]).to eq("a_default_value")
     end
 
     it "should skip attributes with no default value" do
       environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_string("a_default_value")})
+        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_leaf("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => scope)
-      lambda { resource.set_default_parameters(scope) }.should_not raise_error
+      expect { resource.set_default_parameters(scope) }.not_to raise_error
     end
 
     it "should return the list of default parameters set" do
       environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
-      resource.set_default_parameters(scope).should == ["a"]
+      expect(resource.set_default_parameters(scope)).to eq(["a"])
     end
 
     describe "when the resource type is :hostclass" do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
-      let(:port) { Puppet::Parser::AST::String.new(:value => '80') }
+      let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
       let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
       before do
@@ -326,10 +326,6 @@ describe Puppet::Resource do
       end
 
       context "when no value is provided" do
-        before(:each) do
-          Puppet[:binder] = true
-        end
-
         let(:resource) do
           Puppet::Parser::Resource.new("class", "apache", :scope => scope)
         end
@@ -345,7 +341,7 @@ describe Puppet::Resource do
 
           resource.set_default_parameters(scope)
 
-          resource[:port].should == '443'
+          expect(resource[:port]).to eq('443')
         end
 
         it "should use the default value if the data_binding terminus returns nil" do
@@ -353,7 +349,7 @@ describe Puppet::Resource do
 
           resource.set_default_parameters(scope)
 
-          resource[:port].should == '80'
+          expect(resource[:port]).to eq('80')
         end
 
         it "should fail with error message about data binding on a hiera failure" do
@@ -383,16 +379,14 @@ describe Puppet::Resource do
         end
 
         it "should not query the injector" do
-          # enable the injector
-          Puppet[:binder] = true
           compiler.injector.expects(:find).never
           resource.set_default_parameters(scope)
         end
 
         it "should use the value provided" do
           Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(scope).should == []
-          resource[:port].should == '8080'
+          expect(resource.set_default_parameters(scope)).to eq([])
+          expect(resource[:port]).to eq('8080')
         end
       end
     end
@@ -403,7 +397,7 @@ describe Puppet::Resource do
       environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "required_param", :arguments => {"a" => nil})
       )
-      lambda { Puppet::Resource.new("required_param", "name", :environment => environment).validate_complete }.should raise_error(Puppet::ParseError)
+      expect { Puppet::Resource.new("required_param", "name", :environment => environment).validate_complete }.to raise_error(Puppet::ParseError)
     end
 
     it "should not fail when all required parameters are present" do
@@ -412,25 +406,25 @@ describe Puppet::Resource do
       )
       resource = Puppet::Resource.new("no_required_param", "name", :environment => environment)
       resource["a"] = "meh"
-      lambda { resource.validate_complete }.should_not raise_error
+      expect { resource.validate_complete }.not_to raise_error
     end
 
     it "should not validate against builtin types" do
-      lambda { Puppet::Resource.new("file", "/bar").validate_complete }.should_not raise_error
+      expect { Puppet::Resource.new("file", "/bar").validate_complete }.not_to raise_error
     end
   end
 
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
-      res.uniqueness_key.should == ["/path"]
-      res.ref.should == "File[/path/]"
+      expect(res.uniqueness_key).to eq(["/path"])
+      expect(res.ref).to eq("File[/path/]")
     end
   end
 
   describe "when running in strict mode" do
     it "should be strict" do
-      Puppet::Resource.new("file", "/path", :strict => true).should be_strict
+      expect(Puppet::Resource.new("file", "/path", :strict => true)).to be_strict
     end
 
     it "should fail if invalid parameters are used" do
@@ -448,56 +442,56 @@ describe Puppet::Resource do
     end
 
     it "should correctly detect when provided parameters are not valid for builtin types" do
-      Puppet::Resource.new("file", "/my/file").should_not be_valid_parameter("foobar")
+      expect(Puppet::Resource.new("file", "/my/file")).not_to be_valid_parameter("foobar")
     end
 
     it "should correctly detect when provided parameters are valid for builtin types" do
-      Puppet::Resource.new("file", "/my/file").should be_valid_parameter("mode")
+      expect(Puppet::Resource.new("file", "/my/file")).to be_valid_parameter("mode")
     end
 
     it "should correctly detect when provided parameters are not valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar")
       environment.known_resource_types.add type
-      Puppet::Resource.new("foobar", "/my/file", :environment => environment).should_not be_valid_parameter("myparam")
+      expect(Puppet::Resource.new("foobar", "/my/file", :environment => environment)).not_to be_valid_parameter("myparam")
     end
 
     it "should correctly detect when provided parameters are valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar", :arguments => {"myparam" => nil})
       environment.known_resource_types.add type
-      Puppet::Resource.new("foobar", "/my/file", :environment => environment).should be_valid_parameter("myparam")
+      expect(Puppet::Resource.new("foobar", "/my/file", :environment => environment)).to be_valid_parameter("myparam")
     end
 
     it "should allow setting and retrieving of parameters" do
       @resource[:foo] = "bar"
-      @resource[:foo].should == "bar"
+      expect(@resource[:foo]).to eq("bar")
     end
 
     it "should allow setting of parameters at initialization" do
-      Puppet::Resource.new("file", "/my/file", :parameters => {:foo => "bar"})[:foo].should == "bar"
+      expect(Puppet::Resource.new("file", "/my/file", :parameters => {:foo => "bar"})[:foo]).to eq("bar")
     end
 
     it "should canonicalize retrieved parameter names to treat symbols and strings equivalently" do
       @resource[:foo] = "bar"
-      @resource["foo"].should == "bar"
+      expect(@resource["foo"]).to eq("bar")
     end
 
     it "should canonicalize set parameter names to treat symbols and strings equivalently" do
       @resource["foo"] = "bar"
-      @resource[:foo].should == "bar"
+      expect(@resource[:foo]).to eq("bar")
     end
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:name] = "bob"
-      resource[:myvar].should == "bob"
+      expect(resource[:myvar]).to eq("bob")
     end
 
     it "should return the namevar when asked to return the name" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:myvar] = "test"
-      resource[:name].should == "test"
+      expect(resource[:name]).to eq("test")
     end
 
     it "should be able to set the name for non-builtin types" do
@@ -509,7 +503,7 @@ describe Puppet::Resource do
     it "should be able to return the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
-      resource[:name].should == "eh"
+      expect(resource[:name]).to eq("eh")
     end
 
     it "should be able to iterate over parameters" do
@@ -519,42 +513,42 @@ describe Puppet::Resource do
       @resource.each do |key, value|
         params[key] = value
       end
-      params.should == {:foo => "bar", :fee => "bare"}
+      expect(params).to eq({:foo => "bar", :fee => "bare"})
     end
 
     it "should include Enumerable" do
-      @resource.class.ancestors.should be_include(Enumerable)
+      expect(@resource.class.ancestors).to be_include(Enumerable)
     end
 
     it "should have a method for testing whether a parameter is included" do
       @resource[:foo] = "bar"
-      @resource.should be_has_key(:foo)
-      @resource.should_not be_has_key(:eh)
+      expect(@resource).to be_has_key(:foo)
+      expect(@resource).not_to be_has_key(:eh)
     end
 
     it "should have a method for providing the list of parameters" do
       @resource[:foo] = "bar"
       @resource[:bar] = "foo"
       keys = @resource.keys
-      keys.should be_include(:foo)
-      keys.should be_include(:bar)
+      expect(keys).to be_include(:foo)
+      expect(keys).to be_include(:bar)
     end
 
     it "should have a method for providing the number of parameters" do
       @resource[:foo] = "bar"
-      @resource.length.should == 1
+      expect(@resource.length).to eq(1)
     end
 
     it "should have a method for deleting parameters" do
       @resource[:foo] = "bar"
       @resource.delete(:foo)
-      @resource[:foo].should be_nil
+      expect(@resource[:foo]).to be_nil
     end
 
     it "should have a method for testing whether the parameter list is empty" do
-      @resource.should be_empty
+      expect(@resource).to be_empty
       @resource[:foo] = "bar"
-      @resource.should_not be_empty
+      expect(@resource).not_to be_empty
     end
 
     it "should be able to produce a hash of all existing parameters" do
@@ -562,20 +556,20 @@ describe Puppet::Resource do
       @resource[:fee] = "yay"
 
       hash = @resource.to_hash
-      hash[:foo].should == "bar"
-      hash[:fee].should == "yay"
+      expect(hash[:foo]).to eq("bar")
+      expect(hash[:fee]).to eq("yay")
     end
 
     it "should not provide direct access to the internal parameters hash when producing a hash" do
       hash = @resource.to_hash
       hash[:foo] = "bar"
-      @resource[:foo].should be_nil
+      expect(@resource[:foo]).to be_nil
     end
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
       Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
-      resource.to_hash[:myvar].should == "bob"
+      expect(resource.to_hash[:myvar]).to eq("bob")
     end
 
     it "should set :name to the title if :name is not present for non-builtin types" do
@@ -583,7 +577,7 @@ describe Puppet::Resource do
       krt.add Puppet::Resource::Type.new(:definition, :foo)
       resource = Puppet::Resource.new :foo, "bar"
       resource.stubs(:known_resource_types).returns krt
-      resource.to_hash[:name].should == "bar"
+      expect(resource.to_hash[:name]).to eq("bar")
     end
   end
 
@@ -594,11 +588,21 @@ describe Puppet::Resource do
       @resource["two"] = "other"
     end
 
+    # PUP-3272, needs to work becuse serialization is not only to network
+    #
     it "should produce an equivalent yaml object" do
       text = @resource.render('yaml')
 
       newresource = Puppet::Resource.convert_from('yaml', text)
-      newresource.should equal_resource_attributes_of @resource
+      expect(newresource).to equal_resource_attributes_of(@resource)
+    end
+
+    # PUP-3272, since serialization to network is done in pson, not yaml
+    it "should produce an equivalent pson object" do
+      text = @resource.render('pson')
+
+      newresource = Puppet::Resource.convert_from('pson', text)
+      expect(newresource).to equal_resource_attributes_of(@resource)
     end
   end
 
@@ -614,14 +618,14 @@ describe Puppet::Resource do
     end
 
     it "doesn't include transient instance variables (#4506)" do
-      expect(@resource.to_yaml_properties).to_not include :@rstype
+      expect(@resource.to_yaml_properties).to_not include(:@rstype)
     end
 
-    it "produces an equivalent yaml object" do
-      text = @resource.render('yaml')
+    it "produces an equivalent pson object" do
+      text = @resource.render('pson')
 
-      newresource = Puppet::Resource.convert_from('yaml', text)
-      newresource.should equal_resource_attributes_of @resource
+      newresource = Puppet::Resource.convert_from('pson', text)
+      expect(newresource).to equal_resource_attributes_of(@resource)
     end
   end
 
@@ -629,16 +633,16 @@ describe Puppet::Resource do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
-      result.must be_instance_of(Puppet::Type.type(:file))
-      result[:path].should == basepath+"/my/file"
+      expect(result).to be_instance_of(Puppet::Type.type(:file))
+      expect(result[:path]).to eq(basepath+"/my/file")
     end
 
     it "should convert to a component instance if the resource type is not of a builtin type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
-      result.must be_instance_of(Puppet::Type.type(:component))
-      result.title.should == "Foobar[somename]"
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+      expect(result.title).to eq("Foobar[somename]")
     end
   end
 
@@ -654,7 +658,7 @@ describe Puppet::Resource do
     end
 
     it "should align, sort and add trailing commas to attributes with ensure first" do
-      @resource.to_manifest.should == <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+      expect(@resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
         one::two { '/my/file':
           ensure => 'present',
           foo    => ['one', 'two'],
@@ -664,58 +668,70 @@ describe Puppet::Resource do
     end
   end
 
-  describe "when converting to pson" do
-    def pson_output_should
-      @resource.class.expects(:pson_create).with { |hash| yield hash }
+  describe "when converting to Yaml for Hiera" do
+    before do
+      @resource = Puppet::Resource.new("one::two", "/my/file",
+        :parameters => {
+          :noop => true,
+          :foo => %w{one two},
+          :ensure => 'present',
+        }
+      )
     end
 
-    it "should include the pson util module" do
-      Puppet::Resource.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
+    it "should align and sort to attributes with ensure first" do
+      expect(@resource.to_hierayaml).to eq <<-HEREDOC.gsub(/^\s{8}/, '')
+          /my/file:
+            ensure: 'present'
+            foo   : ['one', 'two']
+            noop  : 'true'
+      HEREDOC
     end
-
+  end
+  describe "when converting to pson" do
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
-      Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
+      expect(Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type).to eq("File")
     end
 
     it "should set its title to the provided title" do
-      Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
+      expect(Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title).to eq("/foo")
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
-      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).tags.should == resource.tags
+      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).tags).to eq(resource.tags)
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
-      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).file.should == "/my/file"
+      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).file).to eq("/my/file")
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
-      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).line.should == 50
+      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).line).to eq(50)
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
-      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?.should be_true
+      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?).to be_truthy
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
-      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?.should be_false
+      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?).to be_falsey
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
@@ -724,22 +740,22 @@ describe Puppet::Resource do
       resource[:fee] = %w{baz}
 
       result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
-      result["foo"].should == %w{bar eh}
-      result["fee"].should == %w{baz}
+      expect(result["foo"]).to eq(%w{bar eh})
+      expect(result["fee"]).to eq(%w{baz})
     end
 
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
       result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
-      result[:requires].should == "File[/bar]"
+      expect(result[:requires]).to eq("File[/bar]")
     end
 
     it "should serialize multiple relationships as arrays of reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = [Puppet::Resource.new("File", "/bar"), Puppet::Resource.new("File", "/baz")]
       result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
-      result[:requires].should == [ "File[/bar]",  "File[/baz]" ]
+      expect(result[:requires]).to eq([ "File[/bar]",  "File[/baz]" ])
     end
   end
 
@@ -756,37 +772,37 @@ describe Puppet::Resource do
     end
 
     it "should set its type to the provided type" do
-      Puppet::Resource.from_data_hash(@data).type.should == "File"
+      expect(Puppet::Resource.from_data_hash(@data).type).to eq("File")
     end
 
     it "should set its title to the provided title" do
-      Puppet::Resource.from_data_hash(@data).title.should == basepath+"/yay"
+      expect(Puppet::Resource.from_data_hash(@data).title).to eq(basepath+"/yay")
     end
 
     it "should tag the resource with any provided tags" do
       @data['tags'] = %w{foo bar}
       resource = Puppet::Resource.from_data_hash(@data)
-      resource.tags.should be_include("foo")
-      resource.tags.should be_include("bar")
+      expect(resource.tags).to be_include("foo")
+      expect(resource.tags).to be_include("bar")
     end
 
     it "should set its file to the provided file" do
       @data['file'] = "/foo/bar"
-      Puppet::Resource.from_data_hash(@data).file.should == "/foo/bar"
+      expect(Puppet::Resource.from_data_hash(@data).file).to eq("/foo/bar")
     end
 
     it "should set its line to the provided line" do
       @data['line'] = 50
-      Puppet::Resource.from_data_hash(@data).line.should == 50
+      expect(Puppet::Resource.from_data_hash(@data).line).to eq(50)
     end
 
     it "should 'exported' to true if set in the pson data" do
       @data['exported'] = true
-      Puppet::Resource.from_data_hash(@data).exported.should be_true
+      expect(Puppet::Resource.from_data_hash(@data).exported).to be_truthy
     end
 
     it "should 'exported' to false if not set in the pson data" do
-      Puppet::Resource.from_data_hash(@data).exported.should be_false
+      expect(Puppet::Resource.from_data_hash(@data).exported).to be_falsey
     end
 
     it "should fail if no title is provided" do
@@ -802,33 +818,33 @@ describe Puppet::Resource do
     it "should set each of the provided parameters" do
       @data['parameters'] = {'foo' => %w{one two}, 'fee' => %w{three four}}
       resource = Puppet::Resource.from_data_hash(@data)
-      resource['foo'].should == %w{one two}
-      resource['fee'].should == %w{three four}
+      expect(resource['foo']).to eq(%w{one two})
+      expect(resource['fee']).to eq(%w{three four})
     end
 
     it "should convert single-value array parameters to normal values" do
       @data['parameters'] = {'foo' => %w{one}}
       resource = Puppet::Resource.from_data_hash(@data)
-      resource['foo'].should == %w{one}
+      expect(resource['foo']).to eq(%w{one})
     end
   end
 
   it "implements copy_as_resource" do
     resource = Puppet::Resource.new("file", "/my/file")
-    resource.copy_as_resource.should == resource
+    expect(resource.copy_as_resource).to eq(resource)
   end
 
   describe "because it is an indirector model" do
     it "should include Puppet::Indirector" do
-      Puppet::Resource.should be_is_a(Puppet::Indirector)
+      expect(Puppet::Resource).to be_is_a(Puppet::Indirector)
     end
 
     it "should have a default terminus" do
-      Puppet::Resource.indirection.terminus_class.should be
+      expect(Puppet::Resource.indirection.terminus_class).to be
     end
 
     it "should have a name" do
-      Puppet::Resource.new("file", "/my/file").name.should == "File//my/file"
+      expect(Puppet::Resource.new("file", "/my/file").name).to eq("File//my/file")
     end
   end
 
@@ -840,7 +856,7 @@ describe Puppet::Resource do
 
       catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
 
-      resource.resolve.should == :myresource
+      expect(resource.resolve).to eq(:myresource)
     end
   end
 
@@ -851,7 +867,7 @@ describe Puppet::Resource do
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
-      res.uniqueness_key.should == [ nil, 'root', '/my/file']
+      expect(res.uniqueness_key).to eq([ nil, 'root', '/my/file'])
     end
   end
 
@@ -911,8 +927,8 @@ describe Puppet::Resource do
 
         it "should set the resource parameters from the parsed title values" do
           h = subject.to_hash
-          h[:name].should == 'matching'
-          h[:value].should == 'title'
+          expect(h[:name]).to eq('matching')
+          expect(h[:value]).to eq('title')
         end
       end
 
@@ -921,8 +937,8 @@ describe Puppet::Resource do
 
         it "should use the first title pattern that matches" do
           h = subject.to_hash
-          h[:name].should == 'gnihctam'
-          h[:value].should == 'eltit'
+          expect(h[:name]).to eq('gnihctam')
+          expect(h[:value]).to eq('eltit')
         end
       end
     end
@@ -930,7 +946,7 @@ describe Puppet::Resource do
 
   describe "#prune_parameters" do
     before do
-      Puppet.newtype('blond') do
+      Puppet::Type.newtype('blond') do
         newproperty(:ensure)
         newproperty(:height)
         newproperty(:weight)
@@ -953,7 +969,7 @@ describe Puppet::Resource do
       })
 
       pruned_resource = resource.prune_parameters
-      pruned_resource.should == Puppet::Resource.new("blond", "Bambi", :parameters => {:ensure => 'absent'})
+      expect(pruned_resource).to eq(Puppet::Resource.new("blond", "Bambi", :parameters => {:ensure => 'absent'}))
     end
 
     it "should leave parameters alone if in parameters_to_include" do
@@ -963,7 +979,7 @@ describe Puppet::Resource do
       })
 
       pruned_resource = resource.prune_parameters(:parameters_to_include => [:admits_to_dying_hair])
-      pruned_resource.should == Puppet::Resource.new("blond", "Bambi", :parameters => {:admits_to_dying_hair => false})
+      expect(pruned_resource).to eq(Puppet::Resource.new("blond", "Bambi", :parameters => {:admits_to_dying_hair => false}))
     end
 
     it "should leave properties if not nil, absent or empty" do
@@ -974,12 +990,13 @@ describe Puppet::Resource do
       })
 
       pruned_resource = resource.prune_parameters
-      pruned_resource.should ==
+      expect(pruned_resource).to eq(
       resource = Puppet::Resource.new("blond", "Bambi", :parameters => {
         :ensure          => 'silly',
         :height          => '7 ft 5 in',
         :friends         => ['Oprah'],
       })
+      )
     end
   end
 end