puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

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
@@ -980,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
@@ -992,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'})
@@ -1086,6 +1082,18 @@ describe Puppet::Resource do
         newparam(:admits_to_age)
         newparam(:name)
       end
+
+      Puppet::Type.newtype('brown') do
+        newproperty(:ensure)
+        newparam(:admits_to_dying_hair)
+        newparam(:admits_to_age)
+        newparam(:hair_length)
+        newparam(:name)
+
+        def self.parameters_to_include
+          [:admits_to_dying_hair, :admits_to_age]
+        end
+      end
     end
 
     it "should strip all parameters and strip properties that are nil, empty or absent except for ensure" do
@@ -1128,5 +1136,24 @@ describe Puppet::Resource do
       })
       )
     end
+
+    context "when the resource type has a default set of parameters it wants to include" do
+      it "should leave those parameters alone" do
+        resource = Puppet::Resource.new("brown", "Esmeralda", :parameters => {
+          :admits_to_age        => true,
+          :admits_to_dying_hair => false,
+          :hair_length          => 10
+        })
+
+        pruned_resource = resource.prune_parameters
+        expected_resource = Puppet::Resource.new(
+          "brown",
+          "Esmeralda",
+          :parameters => { :admits_to_age => true, :admits_to_dying_hair => false }
+        )
+  
+        expect(pruned_resource).to eq(expected_resource)
+      end
+    end
   end
 end