puppet 5.3.4 → 6.29.0

data/spec/unit/type_spec.rb

@@ -1,11 +1,44 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'puppet/property/boolean'
+
+Puppet::Type.newtype(:type_test) do
+  ensurable
+  newparam(:name, isnamevar: true)
+  newproperty(:device)
+  newproperty(:blockdevice)
+  newproperty(:fstype)
+  newproperty(:options)
+  newproperty(:pass)
+  newproperty(:atboot, parent: Puppet::Property::Boolean) do
+    def munge(value)
+      munged = super
+      if munged
+        :yes
+      else
+        :no
+      end
+    end
+  end
+  newparam(:remounts) do
+    newvalues(:true, :false)
+    defaultto do
+      true
+    end
+  end
+end
+Puppet::Type.type(:type_test).provide(:type_test) do
+  mk_resource_methods
+end
 
-describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
   include PuppetSpec::Compiler
 
+  let(:resource_type) { :type_test }
+  let(:klass) { Puppet::Type.type(resource_type) }
+  let(:ref_type) { klass.name.to_s.capitalize }
+
   it "should be Comparable" do
     a = Puppet::Type.type(:notify).new(:name => "a")
     b = Puppet::Type.type(:notify).new(:name => "b")
@@ -29,34 +62,34 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   end
 
   it "should consider a parameter to be valid if it is a valid parameter" do
-    expect(Puppet::Type.type(:mount)).to be_valid_parameter(:name)
+    expect(klass).to be_valid_parameter(:name)
   end
 
   it "should consider a parameter to be valid if it is a valid property" do
-    expect(Puppet::Type.type(:mount)).to be_valid_parameter(:fstype)
+    expect(klass).to be_valid_parameter(:fstype)
   end
 
   it "should consider a parameter to be valid if it is a valid metaparam" do
-    expect(Puppet::Type.type(:mount)).to be_valid_parameter(:noop)
+    expect(klass).to be_valid_parameter(:noop)
   end
 
   it "should be able to retrieve a property by name" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-    expect(resource.property(:fstype)).to be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
+    resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+    expect(resource.property(:fstype)).to be_instance_of(klass.attrclass(:fstype))
   end
 
   it "should be able to retrieve a parameter by name" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-    expect(resource.parameter(:name)).to be_instance_of(Puppet::Type.type(:mount).attrclass(:name))
+    resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+    expect(resource.parameter(:name)).to be_instance_of(klass.attrclass(:name))
   end
 
   it "should be able to retrieve a property by name using the :parameter method" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-    expect(resource.parameter(:fstype)).to be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
+    resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+    expect(resource.parameter(:fstype)).to be_instance_of(klass.attrclass(:fstype))
   end
 
   it "should be able to retrieve all set properties" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+    resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     props = resource.properties
     expect(props).not_to be_include(nil)
     [:fstype, :ensure, :pass].each do |name|
@@ -65,15 +98,15 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   end
 
   it "can retrieve all set parameters" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
+    resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
     params = resource.parameters_with_value
-    [:name, :provider, :ensure, :fstype, :pass, :dump, :target, :loglevel, :tag].each do |name|
+    [:name, :provider, :ensure, :fstype, :pass, :loglevel, :tag].each do |name|
       expect(params).to be_include(resource.parameter(name))
     end
   end
 
   it "can not return any `nil` values when retrieving all set parameters" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
+    resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
     params = resource.parameters_with_value
     expect(params).not_to be_include(nil)
   end
@@ -87,49 +120,49 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   end
 
   it "should have a method for setting default values for resources" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo")).to respond_to(:set_default)
+    expect(klass.new(:name => "foo")).to respond_to(:set_default)
   end
 
   it "should do nothing for attributes that have no defaults and no specified value" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo").parameter(:noop)).to be_nil
+    expect(klass.new(:name => "foo").parameter(:noop)).to be_nil
   end
 
   it "should have a method for adding tags" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo")).to respond_to(:tags)
+    expect(klass.new(:name => "foo")).to respond_to(:tags)
   end
 
   it "should use the tagging module" do
-    expect(Puppet::Type.type(:mount).ancestors).to be_include(Puppet::Util::Tagging)
+    expect(klass.ancestors).to be_include(Puppet::Util::Tagging)
   end
 
   it "should delegate to the tagging module when tags are added" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo")
-    resource.stubs(:tag).with(:mount)
+    resource = klass.new(:name => "foo")
+    allow(resource).to receive(:tag).with(resource_type)
 
-    resource.expects(:tag).with(:tag1, :tag2)
+    expect(resource).to receive(:tag).with(:tag1, :tag2)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should add the current type as tag" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo")
-    resource.stubs(:tag)
+    resource = klass.new(:name => "foo")
+    allow(resource).to receive(:tag)
 
-    resource.expects(:tag).with(:mount)
+    expect(resource).to receive(:tag).with(resource_type)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should have a method to know if the resource is exported" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo")).to respond_to(:exported?)
+    expect(klass.new(:name => "foo")).to respond_to(:exported?)
   end
 
   it "should have a method to know if the resource is virtual" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo")).to respond_to(:virtual?)
+    expect(klass.new(:name => "foo")).to respond_to(:virtual?)
   end
 
   it "should consider its version to be zero if it has no catalog" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo").version).to eq(0)
+    expect(klass.new(:name => "foo").version).to eq(0)
   end
 
   it "reports the correct path even after path is used during setup of the type" do
@@ -164,7 +197,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
   context "resource attributes" do
     let(:resource) {
-      resource = Puppet::Type.type(:mount).new(:name => "foo")
+      resource = klass.new(:name => "foo")
       catalog = Puppet::Resource::Catalog.new
       catalog.version = 50
       catalog.add_resource resource
@@ -176,30 +209,30 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should have tags" do
-      expect(resource).to be_tagged("mount")
+      expect(resource).to be_tagged(resource_type.to_s)
       expect(resource).to be_tagged("foo")
     end
 
     it "should have a path" do
-      expect(resource.path).to eq("/Mount[foo]")
+      expect(resource.path).to eq("/#{ref_type}[foo]")
     end
   end
 
   it "should consider its type to be the name of its class" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo").type).to eq(:mount)
+    expect(klass.new(:name => "foo").type).to eq(resource_type)
   end
 
   it "should use any provided noop value" do
-    expect(Puppet::Type.type(:mount).new(:name => "foo", :noop => true)).to be_noop
+    expect(klass.new(:name => "foo", :noop => true)).to be_noop
   end
 
   it "should use the global noop value if none is provided" do
     Puppet[:noop] = true
-    expect(Puppet::Type.type(:mount).new(:name => "foo")).to be_noop
+    expect(klass.new(:name => "foo")).to be_noop
   end
 
   it "should not be noop if in a non-host_config catalog" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo")
+    resource = klass.new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource resource
     expect(resource).not_to be_noop
@@ -207,11 +240,11 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
   describe "when creating an event" do
     before do
-      @resource = Puppet::Type.type(:mount).new :name => "foo"
+      @resource = klass.new :name => "foo"
     end
 
     it "should have the resource's reference as the resource" do
-      expect(@resource.event.resource).to eq("Mount[foo]")
+      expect(@resource.event.resource).to eq("#{ref_type}[foo]")
     end
 
     it "should have the resource's log level as the default log level" do
@@ -221,7 +254,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
     {:file => "/my/file", :line => 50}.each do |attr, value|
       it "should set the #{attr}" do
-        @resource.stubs(attr).returns value
+        allow(@resource).to receive(attr).and_return(value)
         expect(@resource.event.send(attr)).to eq(value)
       end
     end
@@ -266,7 +299,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
     it "should have documentation for the 'provider' parameter if there are providers" do
       @type.provide(:test_provider)
-      expect(@type.paramdoc(:provider)).to match(/`provider_test_type`[\s\r]+resource/)
+      expect(@type.paramdoc(:provider)).to match(/`provider_test_type`[\s]+resource/)
     end
 
     it "should not have documentation for the 'provider' parameter if there are no providers" do
@@ -343,7 +376,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should be registered as a provider of the child type" do
-        child_provider = @type.provide(:child_provider, :parent => @parent_provider)
+        @type.provide(:child_provider, :parent => @parent_provider)
         expect(@type.providers).to include(:child_provider)
         expect(@parent_type.providers).not_to include(:child_provider)
       end
@@ -360,8 +393,8 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       basic = type.provide(:basic) {}
       greater = type.provide(:greater) {}
 
-      basic.stubs(:specificity).returns 1
-      greater.stubs(:specificity).returns 2
+      allow(basic).to receive(:specificity).and_return(1)
+      allow(greater).to receive(:specificity).and_return(2)
 
       expect(type.defaultprovider).to equal(greater)
     end
@@ -369,14 +402,32 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
   context "autorelations" do
     before :each do
-      type = Puppet::Type.newtype(:autorelation_one) do
+      Puppet::Type.newtype(:autorelation_one) do
         newparam(:name) { isnamevar }
       end
     end
 
     describe "when building autorelations" do
+      it "should be able to autorequire puppet resources" do
+        Puppet::Type.newtype(:autorelation_two) do
+          newparam(:name) { isnamevar }
+          autorequire(:autorelation_one) { Puppet::Type.type(:notify).new(name: 'test') }
+        end
+
+        relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+          autorelation_one { 'Notify[test]': }
+          autorelation_two { 'bar': }
+        MANIFEST
+
+        src = relationship_graph.vertices.select{ |x| x.ref.to_s == 'Notify[test]' }.first
+        dst = relationship_graph.vertices.select{ |x| x.ref.to_s == 'Autorelation_two[bar]' }.first
+
+        expect(relationship_graph.edge?(src,dst)).to be_truthy
+        expect(relationship_graph.edges_between(src,dst).first.event).to eq(:NONE)
+      end
+
       it "should be able to autorequire resources" do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autorequire(:autorelation_one) { ['foo'] }
         end
@@ -394,7 +445,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it 'should not fail autorequire contains undef entries' do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autorequire(:autorelation_one) { [nil, 'foo'] }
         end
@@ -412,7 +463,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should be able to autosubscribe resources" do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autosubscribe(:autorelation_one) { ['foo'] }
         end
@@ -430,7 +481,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it 'should not fail if autosubscribe contains undef entries' do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autosubscribe(:autorelation_one) { [nil, 'foo'] }
         end
@@ -448,7 +499,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should be able to autobefore resources" do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autobefore(:autorelation_one) { ['foo'] }
         end
@@ -466,7 +517,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should not fail when autobefore contains undef entries" do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autobefore(:autorelation_one) { [nil, 'foo'] }
         end
@@ -484,7 +535,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should be able to autonotify resources" do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autonotify(:autorelation_one) { ['foo'] }
         end
@@ -502,7 +553,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it 'should not fail if autonotify contains undef entries' do
-        type = Puppet::Type.newtype(:autorelation_two) do
+        Puppet::Type.newtype(:autorelation_two) do
           newparam(:name) { isnamevar }
           autonotify(:autorelation_one) { [nil, 'foo'] }
         end
@@ -524,87 +575,87 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   describe "when initializing" do
     describe "and passed a Puppet::Resource instance" do
       it "should set its title to the title of the resource if the resource type is equal to the current type" do
-        resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "/other"})
-        expect(Puppet::Type.type(:mount).new(resource).title).to eq("/foo")
+        resource = Puppet::Resource.new(resource_type, "/foo", :parameters => {:name => "/other"})
+        expect(klass.new(resource).title).to eq("/foo")
       end
 
       it "should set its title to the resource reference if the resource type is not equal to the current type" do
         resource = Puppet::Resource.new(:user, "foo")
-        expect(Puppet::Type.type(:mount).new(resource).title).to eq("User[foo]")
+        expect(klass.new(resource).title).to eq("User[foo]")
       end
 
       [:line, :file, :catalog, :exported, :virtual].each do |param|
         it "should copy '#{param}' from the resource if present" do
-          resource = Puppet::Resource.new(:mount, "/foo")
+          resource = Puppet::Resource.new(resource_type, "/foo")
           resource.send(param.to_s + "=", "foo")
           resource.send(param.to_s + "=", "foo")
-          expect(Puppet::Type.type(:mount).new(resource).send(param)).to eq("foo")
+          expect(klass.new(resource).send(param)).to eq("foo")
         end
       end
 
       it "should copy any tags from the resource" do
-        resource = Puppet::Resource.new(:mount, "/foo")
+        resource = Puppet::Resource.new(resource_type, "/foo")
         resource.tag "one", "two"
-        tags = Puppet::Type.type(:mount).new(resource).tags
+        tags = klass.new(resource).tags
         expect(tags).to be_include("one")
         expect(tags).to be_include("two")
       end
 
       it "should copy the resource's parameters as its own" do
-        resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:atboot => :yes, :fstype => "boo"})
-        params = Puppet::Type.type(:mount).new(resource).to_hash
+        resource = Puppet::Resource.new(resource_type, "/foo", :parameters => {:atboot => :yes, :fstype => "boo"})
+        params = klass.new(resource).to_hash
         expect(params[:fstype]).to eq("boo")
         expect(params[:atboot]).to eq(:yes)
       end
 
       it "copies sensitive parameters to the appropriate properties" do
-        resource = Puppet::Resource.new(:mount, "/foo",
+        resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo"},
                                         :sensitive_parameters => [:fstype])
-        type = Puppet::Type.type(:mount).new(resource)
+        type = klass.new(resource)
         expect(type.property(:fstype).sensitive).to eq true
       end
 
       it "logs a warning when a parameter is marked as sensitive" do
-        resource = Puppet::Resource.new(:mount, "/foo",
+        resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo", :remounts => true},
                                         :sensitive_parameters => [:remounts])
-        Puppet::Type.type(:mount).any_instance.expects(:warning).with(regexp_matches(/Unable to mark 'remounts' as sensitive: remounts is a parameter and not a property/))
-        Puppet::Type.type(:mount).new(resource)
+        expect_any_instance_of(klass).to receive(:warning).with(/Unable to mark 'remounts' as sensitive: remounts is a parameter and not a property/)
+        klass.new(resource)
       end
 
       it "logs a warning when a property is not set but is marked as sensitive" do
-        resource = Puppet::Resource.new(:mount, "/foo",
+        resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo"},
                                         :sensitive_parameters => [:device])
-        Puppet::Type.type(:mount).any_instance.expects(:warning).with("Unable to mark 'device' as sensitive: the property itself was not assigned a value.")
-        Puppet::Type.type(:mount).new(resource)
+        expect_any_instance_of(klass).to receive(:warning).with("Unable to mark 'device' as sensitive: the property itself was not assigned a value.")
+        klass.new(resource)
       end
 
       it "logs an error when a property is not defined on the type but is marked as sensitive" do
-        resource = Puppet::Resource.new(:mount, "/foo",
+        resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo"},
                                         :sensitive_parameters => [:content])
-        Puppet::Type.type(:mount).any_instance.expects(:err).with("Unable to mark 'content' as sensitive: the property itself is not defined on mount.")
-        Puppet::Type.type(:mount).new(resource)
+        expect_any_instance_of(klass).to receive(:err).with("Unable to mark 'content' as sensitive: the property itself is not defined on #{resource_type}.")
+        klass.new(resource)
       end
     end
 
     describe "and passed a Hash" do
       it "should extract the title from the hash" do
-        expect(Puppet::Type.type(:mount).new(:title => "/yay").title).to eq("/yay")
+        expect(klass.new(:title => "/yay").title).to eq("/yay")
       end
 
       it "should work when hash keys are provided as strings" do
-        expect(Puppet::Type.type(:mount).new("title" => "/yay").title).to eq("/yay")
+        expect(klass.new("title" => "/yay").title).to eq("/yay")
       end
 
       it "should work when hash keys are provided as symbols" do
-        expect(Puppet::Type.type(:mount).new(:title => "/yay").title).to eq("/yay")
+        expect(klass.new(:title => "/yay").title).to eq("/yay")
       end
 
       it "should use the name from the hash as the title if no explicit title is provided" do
-        expect(Puppet::Type.type(:mount).new(:name => "/yay").title).to eq("/yay")
+        expect(klass.new(:name => "/yay").title).to eq("/yay")
       end
 
       it "should use the Resource Type's namevar to determine how to find the name in the hash" do
@@ -614,19 +665,19 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
       [:catalog].each do |param|
         it "should extract '#{param}' from the hash if present" do
-          expect(Puppet::Type.type(:mount).new(:name => "/yay", param => "foo").send(param)).to eq("foo")
+          expect(klass.new(:name => "/yay", param => "foo").send(param)).to eq("foo")
         end
       end
 
       it "should use any remaining hash keys as its parameters" do
-        resource = Puppet::Type.type(:mount).new(:title => "/foo", :catalog => "foo", :atboot => :yes, :fstype => "boo")
+        resource = klass.new(:title => "/foo", :catalog => "foo", :atboot => :yes, :fstype => "boo")
         expect(resource[:fstype]).to eq("boo")
         expect(resource[:atboot]).to eq(:yes)
       end
     end
 
     it "should fail if any invalid attributes have been provided" do
-      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /no parameter named 'nosuchattr'/)
+      expect { klass.new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /no parameter named 'nosuchattr'/)
     end
 
     context "when an attribute fails validation" do
@@ -639,59 +690,65 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should include the file/line in the error" do
-        Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
-        Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
+        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return("example.pp")
+        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(42)
         expect { Puppet::Type.type(:file).new(:title => "/foo", :source => "unknown:///") }.to raise_error(Puppet::ResourceError, /\(file: example\.pp, line: 42\)/)
       end
     end
 
     it "should set its name to the resource's title if the resource does not have a :name or namevar parameter set" do
-      resource = Puppet::Resource.new(:mount, "/foo")
+      resource = Puppet::Resource.new(resource_type, "/foo")
 
-      expect(Puppet::Type.type(:mount).new(resource).name).to eq("/foo")
+      expect(klass.new(resource).name).to eq("/foo")
     end
 
     it "should fail if no title, name, or namevar are provided" do
-      expect { Puppet::Type.type(:mount).new(:atboot => :yes) }.to raise_error(Puppet::Error)
+      expect { klass.new(:atboot => :yes) }.to raise_error(Puppet::Error)
     end
 
     it "should set the attributes in the order returned by the class's :allattrs method" do
-      Puppet::Type.type(:mount).stubs(:allattrs).returns([:name, :atboot, :noop])
-      resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "myname", :atboot => :yes, :noop => "whatever"})
+      allow(klass).to receive(:allattrs).and_return([:name, :atboot, :noop])
+      resource = Puppet::Resource.new(resource_type, "/foo", :parameters => {:name => "myname", :atboot => :yes, :noop => "whatever"})
 
       set = []
 
-      Puppet::Type.type(:mount).any_instance.stubs(:newattr).with do |param, hash|
+      allow_any_instance_of(klass).to receive(:newattr) do |_, param, hash|
         set << param
-        true
-      end.returns(stub_everything("a property"))
+        double("a property", :value= => nil, :default => nil, :name => nil)
+      end
 
-      Puppet::Type.type(:mount).new(resource)
+      klass.new(resource)
 
       expect(set[-1]).to eq(:noop)
       expect(set[-2]).to eq(:atboot)
     end
 
     it "should always set the name and then default provider before anything else" do
-      Puppet::Type.type(:mount).stubs(:allattrs).returns([:provider, :name, :atboot])
-      resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "myname", :atboot => :yes})
+      allow(klass).to receive(:allattrs).and_return([:provider, :name, :atboot])
+      resource = Puppet::Resource.new(resource_type, "/foo", :parameters => {:name => "myname", :atboot => :yes})
 
       set = []
 
-      Puppet::Type.type(:mount).any_instance.stubs(:newattr).with do |param, hash|
+      allow_any_instance_of(klass).to receive(:newattr) do |_, param, hash|
         set << param
-        true
-      end.returns(stub_everything("a property"))
+        double("a property", :value= => nil, :default => nil, :name => nil)
+      end
 
-      Puppet::Type.type(:mount).new(resource)
+      klass.new(resource)
       expect(set[0]).to eq(:name)
       expect(set[1]).to eq(:provider)
     end
 
     # This one is really hard to test :/
     it "should set each default immediately if no value is provided" do
+      # We have a :confine block that calls execute in our upstart provider, which fails
+      # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
+      # This is only an issue if you're running these unit tests on a platform where upstart
+      # is a default provider, like Ubuntu trusty.
+      allow(Puppet::Util::Execution).to receive(:execute)
+
       defaults = []
-      Puppet::Type.type(:service).any_instance.stubs(:set_default).with { |value| defaults << value; true }
+      allow_any_instance_of(Puppet::Type.type(:service)).to receive(:set_default) { |_, value| defaults << value }
 
       Puppet::Type.type(:service).new :name => "whatever"
 
@@ -699,7 +756,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should retain a copy of the originally provided parameters" do
-      expect(Puppet::Type.type(:mount).new(:name => "foo", :atboot => :yes, :noop => false).original_parameters).to eq({:atboot => :yes, :noop => false})
+      expect(klass.new(:name => "foo", :atboot => :yes, :noop => false).original_parameters).to eq({:atboot => :yes, :noop => false})
     end
 
     it "should delete the name via the namevar from the originally provided parameters" do
@@ -708,7 +765,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
     context "when validating the resource" do
       it "should call the type's validate method if present" do
-        Puppet::Type.type(:file).any_instance.expects(:validate)
+        expect_any_instance_of(Puppet::Type.type(:file)).to receive(:validate)
         Puppet::Type.type(:file).new(:name => make_absolute('/foo'))
       end
 
@@ -723,8 +780,8 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should raise Puppet::ResourceError with manifest file and line on failure" do
-        Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
-        Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
+        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return("example.pp")
+        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(42)
         expect do
           Puppet::Type.type(:file).new(
             :name => make_absolute('/foo'),
@@ -736,6 +793,46 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
   end
 
+  describe "#set_sensitive_parameters" do
+    let(:sensitive_type) do
+      Puppet::Type.newtype(:sensitive_test) do
+        newparam(:name) { isnamevar }
+        newproperty(:secret) do
+          newvalues(/.*/)
+          sensitive true
+        end
+        newproperty(:transparency) do
+          newvalues(/.*/)
+          sensitive false
+        end
+        newproperty(:things) { newvalues(/.*/) }
+      end
+    end
+
+    it "should mark properties as sensitive" do
+      resource = sensitive_type.new(:name => 'foo', :secret => 'uber classified')
+      expect(resource.parameters[:secret].sensitive).to be true
+    end
+
+    it "should not have a sensitive flag when not set" do
+      resource = sensitive_type.new(:name => 'foo', :things => '1337')
+      expect(resource.parameters[:things].sensitive).to be_nil
+    end
+
+    it "should define things as not sensitive" do
+      resource = sensitive_type.new(:name => 'foo', :transparency => 'public knowledge')
+      expect(resource.parameters[:transparency].sensitive).to be false
+    end
+
+    it "should honor when sensitivity is set in a manifest" do
+      resource = sensitive_type.new(:name => 'foo',
+                                    :transparency => Puppet::Pops::Types::PSensitiveType::Sensitive.new('top secret'),
+                                    :sensitive_parameters => [:transparency]
+                                    )
+      expect(resource.parameters[:transparency].sensitive).to be true
+    end
+  end
+
   describe "when #finish is called on a type" do
     let(:post_hook_type) do
       Puppet::Type.newtype(:finish_test) do
@@ -759,12 +856,12 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   end
 
   it "should have a class method for converting a hash into a Puppet::Resource instance" do
-    expect(Puppet::Type.type(:mount)).to respond_to(:hash2resource)
+    expect(klass).to respond_to(:hash2resource)
   end
 
   describe "when converting a hash to a Puppet::Resource instance" do
     before do
-      @type = Puppet::Type.type(:mount)
+      @type = klass
     end
 
     it "should treat a :title key as the title of the resource" do
@@ -776,7 +873,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should use the Resource Type's namevar to determine how to find the name in the hash" do
-      @type.stubs(:key_attributes).returns([ :myname ])
+      allow(@type).to receive(:key_attributes).and_return([ :myname ])
 
       expect(@type.hash2resource(:myname => "foo").title).to eq("foo")
     end
@@ -809,34 +906,34 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
 
   describe "when retrieving current property values" do
     before do
-      @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-      @resource.property(:ensure).stubs(:retrieve).returns :absent
+      @resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+      allow(@resource.property(:ensure)).to receive(:retrieve).and_return(:absent)
     end
 
     it "should always retrieve the ensure value by default" do
       @ensurable_resource = Puppet::Type.type(:file).new(:name => "/not/existent", :mode => "0644")
-      Puppet::Type::File::Ensure.stubs(:ensure).returns :absent
-      Puppet::Type::File::Ensure.any_instance.expects(:retrieve).once
+      # the ensure property is lazily metaprogrammed...
+      allow_any_instance_of(Puppet::Type::File::Ensure).to receive(:retrieve).and_return(:absent)
       @ensurable_resource.retrieve_resource
     end
 
     it "should not retrieve the ensure value if specified" do
       @ensurable_resource = Puppet::Type.type(:service).new(:name => "DummyService", :enable => true)
-      @ensurable_resource.properties.each { |prop| prop.stubs(:retrieve) }
-      Puppet::Type::Service::Ensure.any_instance.expects(:retrieve).never
+      @ensurable_resource.properties.each { |prop| allow(prop).to receive(:retrieve) }
+      expect_any_instance_of(Puppet::Type::Service::Ensure).not_to receive(:retrieve)
       @ensurable_resource.retrieve_resource
     end
 
     it "should fail if its provider is unsuitable" do
-      @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-      @resource.provider.class.expects(:suitable?).returns false
+      @resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+      expect(@resource.provider.class).to receive(:suitable?).and_return(false)
       expect { @resource.retrieve_resource }.to raise_error(Puppet::Error)
     end
 
     it "should return a Puppet::Resource instance with its type and title set appropriately" do
       result = @resource.retrieve_resource
       expect(result).to be_instance_of(Puppet::Resource)
-      expect(result.type).to eq("Mount")
+      expect(result.type).to eq(ref_type)
       expect(result.title).to eq("foo")
     end
 
@@ -856,21 +953,21 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should not call retrieve on non-ensure properties if the resource is absent and should consider the property absent" do
-      @resource.property(:ensure).expects(:retrieve).returns :absent
-      @resource.property(:fstype).expects(:retrieve).never
+      expect(@resource.property(:ensure)).to receive(:retrieve).and_return(:absent)
+      expect(@resource.property(:fstype)).not_to receive(:retrieve)
       expect(@resource.retrieve_resource[:fstype]).to eq(:absent)
     end
 
     it "should include the result of retrieving each property's current value if the resource is present" do
-      @resource.property(:ensure).expects(:retrieve).returns :present
-      @resource.property(:fstype).expects(:retrieve).returns 15
+      expect(@resource.property(:ensure)).to receive(:retrieve).and_return(:present)
+      expect(@resource.property(:fstype)).to receive(:retrieve).and_return(15)
       @resource.retrieve_resource[:fstype] == 15
     end
   end
 
   describe "#to_resource" do
     it "should return a Puppet::Resource that includes properties, parameters and tags" do
-      type_resource = Puppet::Type.type(:mount).new(
+      type_resource = klass.new(
         :ensure   => :present,
         :name     => "foo",
         :fstype   => "bar",
@@ -882,15 +979,15 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       expect(type_resource.parameters[:remounts]).not_to be_a(Puppet::Property)
       expect(type_resource.parameters[:fstype].is_a?(Puppet::Property)).to be_truthy
 
-      type_resource.property(:ensure).expects(:retrieve).returns :present
-      type_resource.property(:fstype).expects(:retrieve).returns 15
+      expect(type_resource.property(:ensure)).to receive(:retrieve).and_return(:present)
+      expect(type_resource.property(:fstype)).to receive(:retrieve).and_return(15)
 
       resource = type_resource.to_resource
 
       expect(resource).to be_a Puppet::Resource
       expect(resource[:fstype]).to   eq(15)
       expect(resource[:remounts]).to eq(:true)
-      expect(resource.tags).to eq(Puppet::Util::TagSet.new(%w{foo bar baz mount}))
+      expect(resource.tags).to eq(Puppet::Util::TagSet.new(%w{foo bar baz} + [resource_type.to_s]))
     end
   end
 
@@ -898,7 +995,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     describe "when there's one namevar" do
       before do
         @type_class = Puppet::Type.type(:notify)
-        @type_class.stubs(:key_attributes).returns([:one])
+        allow(@type_class).to receive(:key_attributes).and_return([:one])
       end
 
       it "should have a default pattern for when there's one namevar" do
@@ -953,7 +1050,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     let(:provider) { resource.provider }
 
     it "should be suitable if its type doesn't use providers" do
-      type.stubs(:paramclass).with(:provider).returns nil
+      allow(type).to receive(:paramclass).with(:provider).and_return(nil)
       expect(resource).to be_suitable
     end
 
@@ -962,18 +1059,18 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should not be suitable if it has a provider which is not suitable" do
-      provider.class.stubs(:suitable?).returns false
+      allow(provider.class).to receive(:suitable?).and_return(false)
       expect(resource).not_to be_suitable
     end
 
     it "should be suitable if it does not have a provider and there is a default provider" do
-      resource.stubs(:provider).returns nil
+      allow(resource).to receive(:provider).and_return(nil)
       expect(resource).to be_suitable
     end
 
     it "should not be suitable if it doesn't have a provider and there is not default provider" do
-      resource.stubs(:provider).returns nil
-      type.stubs(:defaultprovider).returns nil
+      allow(resource).to receive(:provider).and_return(nil)
+      allow(type).to receive(:defaultprovider).and_return(nil)
 
       expect(resource).not_to be_suitable
     end
@@ -1002,10 +1099,60 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       expect { expect(type.instances).to eq([]) }.to_not raise_error
     end
 
+    context "with a composite namevar type" do
+      let :type do
+        Puppet::Type.newtype(:type_spec_fake_type) do
+          newparam(:name) do
+            isnamevar
+          end
+
+          newparam(:path) do
+            isnamevar
+          end
+
+          def self.title_patterns
+            [[%r{^(.*)@(.*)$}, [:name, :path]], [%r{^([^@]+)$}, [:name]]]
+          end
+
+          newproperty(:prop1) {}
+        end
+
+        Puppet::Type.type(:type_spec_fake_type)
+      end
+
+      before :each do
+        type.provide(:default) do
+          defaultfor :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem)
+          mk_resource_methods
+          class << self
+            attr_accessor :params
+          end
+
+          def title
+            "#{@property_hash[:name]}@#{@property_hash[:path]}"
+          end
+
+          def self.instance(name, path)
+            new(:name => name, :path => path, :ensure => :present)
+          end
+
+          def self.instances
+            @instances ||= params.collect { |param| instance(param.first.to_s, param.last.to_s) }
+          end
+
+          @params = [[:name_one, :path_one], [:name_two, :path_two]]
+        end
+      end
+
+      it "should return composite titles for the instances" do
+        expect(type.instances.map(&:title)).to eq(["name_one@path_one", "name_two@path_two"])
+      end
+    end
+
     context "with a default provider" do
       before :each do
         type.provide(:default) do
-          defaultfor :operatingsystem => Facter.value(:operatingsystem)
+          defaultfor :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem)
           mk_resource_methods
           class << self
             attr_accessor :names
@@ -1105,27 +1252,29 @@ describe Puppet::Type::RelationshipMetaparam do
   end
 
   it "should be able to validate relationships" do
-    expect(Puppet::Type.metaparamclass(:require).new(:resource => mock("resource"))).to respond_to(:validate_relationship)
+    expect(Puppet::Type.metaparamclass(:require).new(:resource => double("resource"))).to respond_to(:validate_relationship)
   end
 
   describe 'if any specified resource is not in the catalog' do
-    let(:catalog) { mock 'catalog' }
+    let(:catalog) { double('catalog') }
 
     let(:resource) do
-      stub 'resource',
+      double(
+        'resource',
         :catalog => catalog,
         :ref     => 'resource',
         :line=   => nil,
         :line    => nil,
         :file=   => nil,
         :file    => nil
+      )
     end
 
     let(:param) { Puppet::Type.metaparamclass(:require).new(:resource => resource, :value => %w{Foo[bar] Class[test]}) }
 
     before do
-      catalog.expects(:resource).with("Foo[bar]").returns "something"
-      catalog.expects(:resource).with("Class[Test]").returns nil
+      expect(catalog).to receive(:resource).with("Foo[bar]").and_return("something")
+      expect(catalog).to receive(:resource).with("Class[Test]").and_return(nil)
     end
 
     describe "and the resource doesn't have a file or line number" do
@@ -1139,8 +1288,8 @@ describe Puppet::Type::RelationshipMetaparam do
 
     describe "and the resource has a file or line number" do
       before do
-        resource.stubs(:line).returns '42'
-        resource.stubs(:file).returns '/hitchhikers/guide/to/the/galaxy'
+        allow(resource).to receive(:line).and_return('42')
+        allow(resource).to receive(:file).and_return('/hitchhikers/guide/to/the/galaxy')
       end
 
       it "raises an error with context" do
@@ -1200,8 +1349,8 @@ describe Puppet::Type.metaparamclass(:audit) do
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
-      Puppet::Type.type(:file).stubs(:key_attributes).returns [:path, :mode, :owner]
-      Puppet::Type.type(:file).stubs(:title_patterns).returns(
+      allow(Puppet::Type.type(:file)).to receive(:key_attributes).and_return([:path, :mode, :owner])
+      allow(Puppet::Type.type(:file)).to receive(:title_patterns).and_return(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       myfile = make_absolute('/my/file')
@@ -1249,7 +1398,6 @@ describe Puppet::Type.metaparamclass(:audit) do
 
     it "should handle proprieties correctly" do
       # Order of assignment is significant in this test.
-      props = {}
       [:one, :two, :three].each {|prop| type.newproperty(prop) {} }
       instance = type.new(:name => "test")
 
@@ -1272,9 +1420,9 @@ describe Puppet::Type.metaparamclass(:audit) do
       type.feature :feature1, "one"
       type.feature :feature2, "two"
 
-      none = type.newproperty(:none) {}
-      one  = type.newproperty(:one, :required_features => :feature1) {}
-      two  = type.newproperty(:two, :required_features => [:feature1, :feature2]) {}
+      type.newproperty(:none) {}
+      type.newproperty(:one, :required_features => :feature1) {}
+      type.newproperty(:two, :required_features => [:feature1, :feature2]) {}
 
       nope  = type.provide(:nope)  {}
       maybe = type.provide(:maybe) { has_features :feature1 }