puppet 5.5.22 → 6.0.0

data/spec/unit/resource/status_spec.rb

@@ -1,4 +1,6 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
+
 require 'puppet/resource/status'
 
 describe Puppet::Resource::Status do
@@ -9,7 +11,7 @@ describe Puppet::Resource::Status do
   let(:status) { Puppet::Resource::Status.new(resource) }
 
   before do
-    allow(resource).to receive(:pathbuilder).and_return(containment_path)
+    resource.stubs(:pathbuilder).returns(containment_path)
   end
 
   it "should compute type and title correctly" do
@@ -41,7 +43,7 @@ describe Puppet::Resource::Status do
   end
 
   it "should set its source description to the resource's path" do
-    expect(resource).to receive(:path).and_return("/my/path")
+    resource.expects(:path).returns "/my/path"
     expect(Puppet::Resource::Status.new(resource).source_description).to eq("/my/path")
   end
 
@@ -51,7 +53,7 @@ describe Puppet::Resource::Status do
 
   [:file, :line].each do |attr|
     it "should copy the resource's #{attr}" do
-      expect(resource).to receive(attr).and_return("foo")
+      resource.expects(attr).returns "foo"
       expect(Puppet::Resource::Status.new(resource).send(attr)).to eq("foo")
     end
   end
@@ -64,7 +66,7 @@ describe Puppet::Resource::Status do
   end
 
   it "should always convert the resource to a string" do
-    expect(resource).to receive(:to_s).and_return("foo")
+    resource.expects(:to_s).returns "foo"
     expect(Puppet::Resource::Status.new(resource).resource).to eq("foo")
   end
 
@@ -109,8 +111,8 @@ describe Puppet::Resource::Status do
 
   it "fails and records a failure event with a given exception" do
     error = StandardError.new("the message")
-    expect(resource).to receive(:log_exception).with(error, "Could not evaluate: the message")
-    expect(status).to receive(:fail_with_event).with("the message")
+    resource.expects(:log_exception).with(error, "Could not evaluate: the message")
+    status.expects(:fail_with_event).with("the message")
 
     status.failed_because(error)
   end

data/spec/unit/resource/type_collection_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
@@ -14,8 +15,8 @@ describe Puppet::Resource::TypeCollection do
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
-    expect(@code).to receive(:add).with("foo")
-    expect(@code).to receive(:add).with("bar")
+    @code.expects(:add).with "foo"
+    @code.expects(:add).with "bar"
     @code << "foo" << "bar"
   end
 
@@ -96,40 +97,39 @@ describe Puppet::Resource::TypeCollection do
 
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
-      expect(@code.loader).not_to receive(:import)
+      @code.loader.expects(:import).never
       expect(@code.find_hostclass("ns::klass")).to equal(@type)
     end
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "klass")
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass("klass")
       end
-
       it "should use the loader to load the files" do
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass")
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.find_hostclass("ns::klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass")
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.find_hostclass("ns::klass")
       end
 
       it "should use the class returned by the loader" do
-        expect(@code.loader).to receive(:try_load_fqname).and_return(:klass)
-        expect(@code).to receive(:hostclass).with("ns::klass").and_return(false)
+        @code.loader.expects(:try_load_fqname).returns(:klass)
+        @code.expects(:hostclass).with("ns::klass").returns(false)
         expect(@code.find_hostclass("ns::klass")).to eq(:klass)
       end
 
       it "should return nil if the name isn't found" do
-        allow(@code.loader).to receive(:try_load_fqname).and_return(nil)
+        @code.loader.stubs(:try_load_fqname).returns(nil)
         expect(@code.find_hostclass("Ns::Klass")).to be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
-        expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "foo::bar").and_return(:foobar)
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
         expect(@code.find_hostclass("foo::bar")).to eq(:foobar)
       end
 
@@ -146,9 +146,9 @@ describe Puppet::Resource::TypeCollection do
 
         it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
           Puppet[:ignoremissingtypes] = true
-          expect(@code.loader).to receive(:try_load_fqname).with(:hostclass, "ns::klass").and_return(nil)
+          @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
           expect(@code.find_hostclass("ns::klass")).to be_nil
-          expect(Puppet).to receive(:debug).at_least(:once).with(/Not attempting to load hostclass/)
+          Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
           expect(@code.find_hostclass("ns::klass")).to be_nil
         end
       end
@@ -255,6 +255,7 @@ describe Puppet::Resource::TypeCollection do
 
         expect(@loader.find_hostclass("::bar")).to eq(nil)
     end
+
   end
 
   it "should be able to find nodes" do
@@ -311,7 +312,7 @@ describe Puppet::Resource::TypeCollection do
     it "should default to the current time" do
       time = Time.now
 
-      allow(Time).to receive(:now).and_return(time)
+      Time.stubs(:now).returns time
       expect(@code.version).to eq(time.to_i)
     end
 
@@ -319,15 +320,15 @@ describe Puppet::Resource::TypeCollection do
       let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
       it "should use the output of the environment's config_version setting if one is provided" do
-        expect(Puppet::Util::Execution).to receive(:execute)
+        Puppet::Util::Execution.expects(:execute)
           .with(["/my/foo"])
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("output\n", 0))
+          .returns Puppet::Util::Execution::ProcessOutput.new("output\n", 0)
         expect(@code.version).to be_instance_of(String)
         expect(@code.version).to eq("output")
       end
 
       it "should raise a puppet parser error if executing config_version fails" do
-        expect(Puppet::Util::Execution).to receive(:execute).and_raise(Puppet::ExecutionFailure.new("msg"))
+        Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
         expect { @code.version }.to raise_error(Puppet::ParseError)
       end

data/spec/unit/resource/type_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource/type'
 require 'puppet/pops'
@@ -196,7 +197,7 @@ describe Puppet::Resource::Type do
 
     before(:each) do
       compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-      @scope = Puppet::Parser::Scope.new(compiler, :source => double("source"))
+      @scope = Puppet::Parser::Scope.new(compiler, :source => stub("source"))
       @resource = Puppet::Parser::Resource.new(:foo, "bar", :scope => @scope)
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @resource.environment.known_resource_types.add @type
@@ -432,7 +433,7 @@ describe Puppet::Resource::Type do
     end
 
     it "should set its caller module name in the scope if available" do
-      expect(@scope).to receive(:parent_module_name).and_return("mycaller")
+      @scope.expects(:parent_module_name).returns "mycaller"
 
       @type.set_resource_parameters(@resource, @scope)
 
@@ -471,8 +472,8 @@ describe Puppet::Resource::Type do
     end
 
     it "should cache a reference to the parent type" do
-      allow(@krt).to receive(:hostclass).with("foo::bar").and_return(nil)
-      expect(@krt).to receive(:hostclass).with("bar").once.and_return(@parent)
+      @krt.stubs(:hostclass).with("foo::bar").returns nil
+      @krt.expects(:hostclass).with("bar").once.returns @parent
       @child.parent_type(@scope)
       @child.parent_type
     end
@@ -517,18 +518,18 @@ describe Puppet::Resource::Type do
       @type = Puppet::Resource::Type.new(:node, /f(\w)o(.*)$/)
       match = @type.match('foo')
 
-      code = double('code')
-      allow(@type).to receive(:code).and_return(code)
+      code = stub 'code'
+      @type.stubs(:code).returns code
 
-      subscope = double('subscope', :compiler => @compiler)
-      expect(@scope).to receive(:newscope).with(:source => @type, :resource => @resource).and_return(subscope)
+      subscope = stub 'subscope', :compiler => @compiler
+      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
 
-      expect(subscope).to receive(:with_guarded_scope).and_yield
-      expect(subscope).to receive(:ephemeral_from).with(match, nil, nil).and_return(subscope)
-      expect(code).to receive(:safeevaluate).with(subscope)
+      subscope.expects(:with_guarded_scope).yields
+      subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
+      code.expects(:safeevaluate).with(subscope)
 
       # Just to keep the stub quiet about intermediate calls
-      expect(@type).to receive(:set_resource_parameters).with(@resource, subscope)
+      @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
@@ -545,17 +546,17 @@ describe Puppet::Resource::Type do
     end
 
     it "should set all of its parameters in a subscope" do
-      subscope = double('subscope', :compiler => @compiler)
-      expect(@scope).to receive(:newscope).with(:source => @type, :resource => @resource).and_return(subscope)
-      expect(@type).to receive(:set_resource_parameters).with(@resource, subscope)
+      subscope = stub 'subscope', :compiler => @compiler
+      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
+      @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should not create a subscope for the :main class" do
-      allow(@resource).to receive(:title).and_return(:main)
-      expect(@type).not_to receive(:subscope)
-      expect(@type).to receive(:set_resource_parameters).with(@resource, @scope)
+      @resource.stubs(:title).returns(:main)
+      @type.expects(:subscope).never
+      @type.expects(:set_resource_parameters).with(@resource, @scope)
 
       @type.evaluate_code(@resource)
     end
@@ -572,15 +573,15 @@ describe Puppet::Resource::Type do
     end
 
     it "should evaluate the AST code if any is provided" do
-      code = double('code')
-      allow(@type).to receive(:code).and_return(code)
-      expect(code).to receive(:safeevaluate).with(kind_of(Puppet::Parser::Scope))
+      code = stub 'code'
+      @type.stubs(:code).returns code
+      code.expects(:safeevaluate).with kind_of(Puppet::Parser::Scope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should noop if there is no code" do
-      expect(@type).to receive(:code).and_return(nil)
+      @type.expects(:code).returns nil
 
       @type.evaluate_code(@resource)
     end
@@ -610,7 +611,7 @@ describe Puppet::Resource::Type do
 
         @type.parent_type(@scope)
 
-        expect(@parent_resource).not_to receive(:evaluate)
+        @parent_resource.expects(:evaluate).never
 
         @type.evaluate_code(@resource)
       end
@@ -650,7 +651,7 @@ describe Puppet::Resource::Type do
 
         @type.parent_type(@scope)
 
-        expect(@parent_resource).not_to receive(:evaluate)
+        @parent_resource.expects(:evaluate).never
 
         @type.evaluate_code(@resource)
       end
@@ -739,14 +740,14 @@ describe Puppet::Resource::Type do
     end
 
     it "should not create a new resource if one already exists" do
-      expect(@compiler.catalog).to receive(:resource).with(:class, "top").and_return("something")
-      expect(@compiler.catalog).not_to receive(:add_resource)
+      @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
+      @compiler.catalog.expects(:add_resource).never
       @top.ensure_in_catalog(@scope)
     end
 
     it "should return the existing resource when not creating a new one" do
-      expect(@compiler.catalog).to receive(:resource).with(:class, "top").and_return("something")
-      expect(@compiler.catalog).not_to receive(:add_resource)
+      @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
+      @compiler.catalog.expects(:add_resource).never
       expect(@top.ensure_in_catalog(@scope)).to eq("something")
     end
 
@@ -804,9 +805,9 @@ describe Puppet::Resource::Type do
         code = Puppet::Resource::TypeCollection.new("env")
         code.add Puppet::Resource::Type.new(:hostclass, "")
         other = Puppet::Resource::Type.new(:hostclass, "")
-        mock = double()
-        expect(mock).to receive(:is_definitions_only?).and_return(false)
-        expect(other).to receive(:code).and_return(mock)
+        mock = stub
+        mock.expects(:is_definitions_only?).returns(false)
+        other.expects(:code).returns(mock)
         expect { code.hostclass("").merge(other) }.to raise_error(Puppet::Error)
       end
 
@@ -815,9 +816,9 @@ describe Puppet::Resource::Type do
         code = Puppet::Resource::TypeCollection.new("env")
         code.add Puppet::Resource::Type.new(:hostclass, "")
         other = Puppet::Resource::Type.new(:hostclass, "")
-        mock = double()
-        expect(mock).to receive(:is_definitions_only?).and_return(true)
-        expect(other).to receive(:code).at_least(:once).and_return(mock)
+        mock = stub
+        mock.expects(:is_definitions_only?).returns(true)
+        other.expects(:code).at_least_once.returns(mock)
         expect { code.hostclass("").merge(other) }.not_to raise_error
       end
     end

data/spec/unit/resource_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource'
 
@@ -7,13 +8,8 @@ describe Puppet::Resource do
   let(:basepath) { make_absolute("/somepath") }
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
-  def expect_lookup(key, options = {})
-    expectation = receive(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_args)
-    expectation = expectation.and_throw(options[:throws]) if options[:throws]
-    expectation = expectation.and_raise(*options[:raises]) if options[:raises]
-    expectation = expectation.and_return(options[:returns]) if options[:returns]
-
-    expect_any_instance_of(Puppet::Pops::Lookup::GlobalDataProvider).to expectation
+  def expect_lookup(key)
+    Puppet::Pops::Lookup::GlobalDataProvider.any_instance.expects(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_parameters)
   end
 
   [:catalog, :file, :line].each do |attr|
@@ -288,7 +284,7 @@ describe Puppet::Resource do
 
     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_leaf("default")})
+      Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
       )
       resource = Puppet::Resource.new("default_param", "name", :environment => environment)
       expect { resource.set_default_parameters(scope) }.to raise_error(Puppet::DevError)
@@ -331,9 +327,9 @@ describe Puppet::Resource do
       before do
         environment.known_resource_types.add(apache)
 
-        allow(scope).to receive(:host).and_return('host')
-        allow(scope).to receive(:environment).and_return(environment)
-        allow(scope).to receive(:facts).and_return(Puppet::Node::Facts.new("facts", fact_values))
+        scope.stubs(:host).returns('host')
+        scope.stubs(:environment).returns(environment)
+        scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
       context 'with a default value expression' do
@@ -345,14 +341,14 @@ describe Puppet::Resource do
           end
 
           it "should query the data_binding terminus using a namespaced key" do
-            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('lookup_options').throws(:no_such_key)
             expect_lookup('apache::port')
             inject_and_set_defaults(resource, scope)
           end
 
           it "should use the value from the data_binding terminus" do
-            expect_lookup('lookup_options', throws: :no_such_key)
-            expect_lookup('apache::port', returns: '443')
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').returns('443')
 
             inject_and_set_defaults(resource, scope)
 
@@ -360,8 +356,8 @@ describe Puppet::Resource do
           end
 
           it 'should use the default value if no value is found using the data_binding terminus' do
-            expect_lookup('lookup_options', throws: :no_such_key)
-            expect_lookup('apache::port', throws: :no_such_key)
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').throws(:no_such_key)
 
             inject_and_set_defaults(resource, scope)
 
@@ -369,8 +365,8 @@ describe Puppet::Resource do
           end
 
           it 'should use the default value if an undef value is found using the data_binding terminus' do
-            expect_lookup('lookup_options', throws: :no_such_key)
-            expect_lookup('apache::port', returns: nil)
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').returns(nil)
 
             inject_and_set_defaults(resource, scope)
 
@@ -378,8 +374,8 @@ describe Puppet::Resource do
           end
 
           it "should fail with error message about data binding on a hiera failure" do
-            expect_lookup('lookup_options', throws: :no_such_key)
-            expect_lookup('apache::port', raises: [Puppet::DataBinding::LookupError, 'Forgettabotit'])
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
             expect {
               inject_and_set_defaults(resource, scope)
             }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
@@ -399,19 +395,19 @@ describe Puppet::Resource do
           end
 
           it "should not query the data_binding terminus" do
-            expect(Puppet::DataBinding.indirection).not_to receive(:find)
+            Puppet::DataBinding.indirection.expects(:find).never
             inject_and_set_defaults(resource, scope)
           end
 
           it "should use the value provided" do
-            expect(Puppet::DataBinding.indirection).not_to receive(:find)
+            Puppet::DataBinding.indirection.expects(:find).never
             expect(resource.set_default_parameters(scope)).to eq([])
             expect(resource[:port]).to eq('8080')
           end
 
           it "should use the value from the data_binding terminus when provided value is undef" do
-            expect_lookup('lookup_options', throws: :no_such_key)
-            expect_lookup('apache::port', returns: '443')
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').returns('443')
 
             rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
               :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
@@ -427,8 +423,8 @@ describe Puppet::Resource do
         let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
 
         it "should use the value from the data_binding terminus" do
-          expect_lookup('lookup_options', throws: :no_such_key)
-          expect_lookup('apache::port', returns: '443')
+          expect_lookup('lookup_options').throws(:no_such_key)
+          expect_lookup('apache::port').returns('443')
 
           inject_and_set_defaults(resource, scope)
 
@@ -436,8 +432,8 @@ describe Puppet::Resource do
         end
 
         it "should use an undef value from the data_binding terminus" do
-          expect_lookup('lookup_options', throws: :no_such_key)
-          expect_lookup('apache::port', returns: nil)
+          expect_lookup('lookup_options').throws(:no_such_key)
+          expect_lookup('apache::port').returns(nil)
 
           inject_and_set_defaults(resource, scope)
 
@@ -537,14 +533,14 @@ describe Puppet::Resource do
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
-      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
+      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:name] = "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")
-      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
+      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       resource[:myvar] = "test"
       expect(resource[:name]).to eq("test")
     end
@@ -623,7 +619,7 @@ describe Puppet::Resource do
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
-      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
+      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
       expect(resource.to_hash[:myvar]).to eq("bob")
     end
 
@@ -631,7 +627,7 @@ describe Puppet::Resource do
       krt = Puppet::Resource::TypeCollection.new("myenv")
       krt.add Puppet::Resource::Type.new(:definition, :foo)
       resource = Puppet::Resource.new :foo, "bar"
-      allow(resource).to receive(:known_resource_types).and_return(krt)
+      resource.stubs(:known_resource_types).returns krt
       expect(resource.to_hash[:name]).to eq("bar")
     end
   end
@@ -683,7 +679,7 @@ describe Puppet::Resource do
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
 
-    it 'to_data_hash returns value that is instance of to Data' do
+    it 'to_data_hash returns value that is instance of Data' do
       Puppet::Pops::Types::TypeAsserter.assert_instance_of('', Puppet::Pops::Types::TypeFactory.data, @resource.to_data_hash)
       expect(Puppet::Pops::Types::TypeFactory.data.instance?(@resource.to_data_hash)).to be_truthy
     end
@@ -723,7 +719,7 @@ describe Puppet::Resource do
           :ensure => 'present',
         }
       )
-      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+      expect(singlequote_resource.to_manifest).to eq(<<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, ''))
         one::two { '/my/file\\'b\\'a\\'r':
           ensure => 'present',
         }
@@ -732,7 +728,7 @@ describe Puppet::Resource do
     end
 
     it "should align, sort and add trailing commas to attributes with ensure first" do
-      expect(@resource.to_manifest).to eq <<-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'],
@@ -747,46 +743,22 @@ describe Puppet::Resource do
       @resource = Puppet::Resource.new("one::two", "/my/file",
         :parameters => {
           :noop => true,
-          :foo => [:one, "two"],
-          :bar => 'a\'b',
+          :foo => %w{one two},
           :ensure => 'present',
         }
       )
     end
 
     it "should align and sort to attributes with ensure first" do
-      expect(@resource.to_hierayaml).to eq <<-HEREDOC.gsub(/^\s{8}/, '')
+      expect(@resource.to_hierayaml).to eq(<<-HEREDOC.gsub(/^\s{8}/, ''))
           /my/file:
             ensure: 'present'
-            bar   : 'a\\'b'
             foo   : ['one', 'two']
             noop  : true
       HEREDOC
     end
-
-    it "should convert some types to String" do
-      expect(@resource.to_hiera_hash).to eq(
-        "/my/file" => {
-          'ensure' => "present",
-          'bar'    => "a'b",
-          'foo'    => ["one", "two"],
-          'noop'   => true
-        }
-      )
-    end
-
-    it "accepts symbolic titles" do
-      res = Puppet::Resource.new(:file, "/my/file", :parameters => { 'ensure' => "present" })
-
-      expect(res.to_hiera_hash.keys).to eq(["/my/file"])
-    end
-
-    it "emits an empty parameters hash" do
-      res = Puppet::Resource.new(:file, "/my/file")
-
-      expect(res.to_hiera_hash).to eq({"/my/file" => {}})
-    end
   end
+
   describe "when converting to json" do
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
@@ -846,7 +818,7 @@ describe Puppet::Resource do
     it "should set sensitive parameters as an array of strings" do
       resource = Puppet::Resource.new("File", "/foo", :sensitive_parameters => [:foo, :fee])
       result = JSON.parse(resource.to_json)
-      expect(result["sensitive_parameters"]).to eq ["foo", "fee"]
+      expect(result["sensitive_parameters"]).to eq(["foo", "fee"])
     end
 
     it "should serialize relationships as reference strings" do
@@ -864,6 +836,46 @@ describe Puppet::Resource do
     end
   end
 
+  describe 'when converting to data_hash with stringified parameters' do
+    before(:each) do
+      Puppet.push_context({:stringify_rich => true}, 'resource_spec.rb')
+    end
+
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    let(:resource) do
+      type = Puppet::Resource::Type.new(:definition, "rich::thing")
+      environment.known_resource_types.add type
+
+      r = Puppet::Resource.new('rich::thing', 'stringified', :environment => environment)
+      r['binary'] = Puppet::Pops::Types::PBinaryType::Binary.from_binary_string('hello')
+      r['timestamp'] = Puppet::Pops::Time::Timestamp.parse('2018-09-03T19:45:33.697066000 UTC')
+      r['reference'] = Puppet::Resource.new('File', 'dummy', :environment => environment)
+      r.resource_type
+      r
+    end
+
+    let(:parameters) do
+      resource.to_data_hash['parameters']
+    end
+
+    it 'has Base64 string content for a binary' do
+      expect(parameters['binary']).to eq('aGVsbG8=')
+    end
+
+    it 'has string content for a timestamp' do
+      expect(parameters['timestamp']).to eq('2018-09-03T19:45:33.697066000 UTC')
+    end
+
+    it 'has string content for a Resource instance' do
+      expect(parameters['reference']).to eq('File[dummy]')
+    end
+
+    # Note: to_stringified_spec.rb has tests for all other data types
+  end
+
   describe "when converting from json" do
     before do
       @data = {
@@ -964,11 +976,11 @@ describe Puppet::Resource do
 
   describe "when resolving resources with a catalog" do
     it "should resolve all resources using the catalog" do
-      catalog = double('catalog')
+      catalog = mock 'catalog'
       resource = Puppet::Resource.new("foo::bar", "yay")
       resource.catalog = catalog
 
-      expect(catalog).to receive(:resource).with("Foo::Bar[yay]").and_return(:myresource)
+      catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
 
       expect(resource.resolve).to eq(:myresource)
     end
@@ -976,8 +988,8 @@ describe Puppet::Resource do
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
-      allow(Puppet::Type.type(:file)).to receive(:key_attributes).and_return([:myvar, :owner, :path])
-      allow(Puppet::Type.type(:file)).to receive(:title_patterns).and_return(
+      Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
+      Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})