puppet 6.29.0 → 7.0.0

data/spec/unit/provider/user/useradd_spec.rb

@@ -4,7 +4,6 @@ RSpec::Matchers.define_negated_matcher :excluding, :include
 
 describe Puppet::Type.type(:user).provider(:useradd) do
   before :each do
-    allow(Puppet::Util::POSIX).to receive(:groups_of).and_return([])
     allow(described_class).to receive(:command).with(:password).and_return('/usr/bin/chage')
     allow(described_class).to receive(:command).with(:localpassword).and_return('/usr/sbin/lchage')
     allow(described_class).to receive(:command).with(:add).and_return('/usr/sbin/useradd')
@@ -13,7 +12,6 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     allow(described_class).to receive(:command).with(:localmodify).and_return('/usr/sbin/lusermod')
     allow(described_class).to receive(:command).with(:delete).and_return('/usr/sbin/userdel')
     allow(described_class).to receive(:command).with(:localdelete).and_return('/usr/sbin/luserdel')
-    allow(described_class).to receive(:command).with(:chpasswd).and_return('/usr/sbin/chpasswd')
   end
 
   let(:resource) do
@@ -63,7 +61,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         :provider   => provider,
       )
       resource2[:ensure] = :present
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true)).twice
+      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true))
       provider.create
     end
 
@@ -153,7 +151,6 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
       it "should not use -G for luseradd and should call usermod with -G after luseradd when groups property is set" do
         resource[:groups] = ['group1', 'group2']
-        allow(provider).to receive(:localgroups)
         expect(provider).to receive(:execute).with(include('/usr/sbin/luseradd').and(excluding('-G')), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
         expect(provider).to receive(:execute).with(include('/usr/sbin/usermod').and(include('-G')), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
         provider.create
@@ -209,7 +206,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should call execute with sensitive if sensitive data is changed" do
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true)).and_return('')
+      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true))
       provider.password = 'bird bird bird'
     end
   end
@@ -339,8 +336,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     it "should return the local comment string when forcelocal is true" do
       resource[:forcelocal] = true
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
-      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
+      allow(File).to receive(:read).with('/etc/passwd').and_return(content)
       expect(provider.comment).to eq('local comment')
     end
 
@@ -352,113 +348,8 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
   end
 
-  describe "#shell" do
-    before { described_class.has_feature :manages_local_users_and_groups }
-
-    let(:content) { "myuser:x:x:x:x:x:/bin/local_shell" }
-
-    it "should return the local shell string when forcelocal is true" do
-      resource[:forcelocal] = true
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
-      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
-      expect(provider.shell).to eq('/bin/local_shell')
-    end
-
-    it "should fall back to nameservice shell string when forcelocal is false" do
-      resource[:forcelocal] = false
-      allow(provider).to receive(:get).with(:shell).and_return('/bin/remote_shell')
-      expect(provider).not_to receive(:localshell)
-      expect(provider.shell).to eq('/bin/remote_shell')
-    end
-  end
-
-  describe "#home" do
-    before { described_class.has_feature :manages_local_users_and_groups }
-
-    let(:content) { "myuser:x:x:x:x:/opt/local_home:x" }
-
-    it "should return the local home string when forcelocal is true" do
-      resource[:forcelocal] = true
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
-      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
-      expect(provider.home).to eq('/opt/local_home')
-    end
-
-    it "should fall back to nameservice home string when forcelocal is false" do
-      resource[:forcelocal] = false
-      allow(provider).to receive(:get).with(:home).and_return('/opt/remote_home')
-      expect(provider).not_to receive(:localhome)
-      expect(provider.home).to eq('/opt/remote_home')
-    end
-  end
-
-  describe "#gid" do
-    before { described_class.has_feature :manages_local_users_and_groups }
-
-    let(:content) { "myuser:x:x:999:x:x:x" }
-
-    it "should return the local GID when forcelocal is true" do
-      resource[:forcelocal] = true
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
-      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
-      expect(provider.gid).to eq(999)
-    end
-
-    it "should fall back to nameservice GID when forcelocal is false" do
-      resource[:forcelocal] = false
-      allow(provider).to receive(:get).with(:gid).and_return(1234)
-      expect(provider).not_to receive(:localgid)
-      expect(provider.gid).to eq(1234)
-    end
-  end
-
-  describe "#groups" do
-    before { described_class.has_feature :manages_local_users_and_groups }
-
-    let(:content) do
-      StringIO.new(<<~EOF)
-      group1:x:0:myuser
-      group2:x:999:
-      group3:x:998:myuser
-      EOF
-    end
-
-    let(:content_with_empty_line) do
-      StringIO.new(<<~EOF)
-      group1:x:0:myuser
-      group2:x:999:
-      group3:x:998:myuser
-
-      EOF
-    end
-
-    it "should return the local groups string when forcelocal is true" do
-      resource[:forcelocal] = true
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/group').and_return(true)
-      allow(File).to receive(:open).with(Pathname.new('/etc/group')).and_yield(content)
-      expect(provider.groups).to eq(['group1', 'group3'])
-    end
-
-    it "does not raise when parsing empty lines in /etc/group" do
-      resource[:forcelocal] = true
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/group').and_return(true)
-      allow(File).to receive(:open).with(Pathname.new('/etc/group')).and_yield(content_with_empty_line)
-      expect { provider.groups }.not_to raise_error
-    end
-
-    it "should fall back to nameservice groups when forcelocal is false" do
-      resource[:forcelocal] = false
-      allow(Puppet::Util::POSIX).to receive(:groups_of).with('myuser').and_return(['remote groups'])
-      expect(provider).not_to receive(:localgroups)
-      expect(provider.groups).to eq('remote groups')
-    end
-  end
-
   describe "#finduser" do
-    before do
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/passwd').and_return(true)
-      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').and_yield(content)
-    end
+    before { allow(File).to receive(:read).with('/etc/passwd').and_return(content) }
 
     let(:content) { "sample_account:sample_password:sample_uid:sample_gid:sample_gecos:sample_directory:sample_shell" }
     let(:output) do
@@ -484,7 +375,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "reads the user file only once per resource" do
-      expect(Puppet::FileSystem).to receive(:each_line).with('/etc/passwd').once
+      expect(File).to receive(:read).with('/etc/passwd').once
       5.times { provider.finduser(:account, 'sample_account') }
     end
   end

data/spec/unit/provider_spec.rb

@@ -222,18 +222,18 @@ describe Puppet::Provider do
       { :true => false } => false,
       { :false => false } => true,
       { :false => true } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem) } => true,
+      { :operatingsystem => Facter.value(:operatingsystem) } => true,
       { :operatingsystem => :yayness } => false,
       { :nothing => :yayness } => false,
       { :exists => Puppet::Util.which(existing_command) } => true,
       { :exists => "/this/file/does/not/exist" } => false,
       { :true => true, :exists => Puppet::Util.which(existing_command) } => true,
       { :true => true, :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
+      { :operatingsystem => Facter.value(:operatingsystem),
         :exists => Puppet::Util.which(existing_command) } => true,
       { :operatingsystem => :yayness,
         :exists => Puppet::Util.which(existing_command) } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
+      { :operatingsystem => Facter.value(:operatingsystem),
         :exists => "/this/file/does/not/exist" } => false,
       { :operatingsystem => :yayness,
         :exists => "/this/file/does/not/exist" } => false,
@@ -269,7 +269,7 @@ describe Puppet::Provider do
   end
 
   context "default providers" do
-    let :os do Puppet.runtime[:facter].value(:operatingsystem) end
+    let :os do Facter.value(:operatingsystem) end
 
     it { is_expected.to respond_to :specificity }
 
@@ -648,37 +648,27 @@ describe Puppet::Provider do
     it "delegates instance execute to Puppet::Util::Execution" do
       expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
 
-      provider.new.execute("a_command", { :option => "value" })
+      provider.new.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates class execute to Puppet::Util::Execution" do
       expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
 
-      provider.execute("a_command", { :option => "value" })
+      provider.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates instance execpipe to Puppet::Util::Execution" do
-      allow(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true).and_yield('some output')
+      block = Proc.new { }
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
 
-      expect { |b| provider.new.execpipe("a_command", true, &b) }.to yield_with_args('some output')
+      provider.new.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates class execpipe to Puppet::Util::Execution" do
-      allow(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true).and_yield('some output')
+      block = Proc.new { }
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
 
-      expect { |b| provider.execpipe("a_command", true, &b) }.to yield_with_args('some output')
-    end
-
-    it "delegates instance execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
-
-      provider.new.execfail("a_command", "an exception to raise")
-    end
-
-    it "delegates class execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
-
-      provider.execfail("a_command", "an exception to raise")
+      provider.send(:execpipe, "a_command", true, block)
     end
   end
 

data/spec/unit/puppet_spec.rb

@@ -91,20 +91,12 @@ describe Puppet do
       expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::Client)
     end
 
-    it 'allows a http implementation to be registered' do
-      http_impl = double('http')
-      Puppet.initialize_settings([], true, true, http: http_impl)
+    it 'allows an implementation to be registered' do
+      impl = double('http')
+      Puppet.initialize_settings([], true, true, http: impl)
 
 
-      expect(Puppet.runtime[:http]).to eq(http_impl)
-    end
-
-    it 'allows a facter implementation to be registered' do
-      facter_impl = double('facter')
-      Puppet.initialize_settings([], true, true, facter: facter_impl)
-
-
-      expect(Puppet.runtime[:facter]).to eq(facter_impl)
+      expect(Puppet.runtime[:http]).to eq(impl)
     end
   end
 

data/spec/unit/resource/catalog_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
   it "should include the current catalog_format" do
     catalog = Puppet::Resource::Catalog.new("host")
-    expect(catalog.catalog_format).to eq(2)
+    expect(catalog.catalog_format).to eq(1)
   end
 
   describe "when compiling" do
@@ -178,7 +178,6 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @original.add_edge(@middle, @bottom)
       @original.add_edge(@bottom, @bottomobject)
 
-      @original.catalog_format = 1
       @catalog = @original.to_ral
     end
 
@@ -191,18 +190,6 @@ describe Puppet::Resource::Catalog, "when compiling" do
       end
     end
 
-    it "should raise if an unknown resource is being converted" do
-      @new_res = Puppet::Resource.new "Unknown", "type", :kind => 'compilable_type'
-      @resource_array = [@new_res]
-
-      @original.add_resource(*@resource_array)
-      @original.add_edge(@bottomobject, @new_res)
-
-      @original.catalog_format = 2
-
-      expect { @original.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
-    end
-
     it "should copy the tag list to the new catalog" do
       expect(@catalog.tags.sort).to eq(@original.tags.sort)
     end
@@ -218,7 +205,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should set itself as the catalog for each converted resource" do
-      @catalog.vertices.each { |v| expect(v.catalog.object_id).to eql(@catalog.object_id) }
+      @catalog.vertices.each { |v| expect(v.catalog.object_id).to equal(@catalog.object_id) }
     end
 
     # This tests #931.

data/spec/unit/resource/type_collection_spec.rb

@@ -75,18 +75,16 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
-  it "should remove all nodes, classes, definitions, and applications when cleared" do
+  it "should remove all nodes, classes and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
-    loader.add Puppet::Resource::Type.new(:application, "application")
 
     loader.clear
     expect(loader.hostclass("class")).to be_nil
     expect(loader.definition("define")).to be_nil
     expect(loader.node("node")).to be_nil
-    expect(loader.node("application")).to be_nil
   end
 
   describe "when looking up names" do
@@ -155,7 +153,7 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  KINDS = %w{hostclass node definition application}
+  KINDS = %w{hostclass node definition}
   KINDS.each do |data|
     describe "behavior of add for #{data}" do
 
@@ -178,24 +176,6 @@ describe Puppet::Resource::TypeCollection do
       it "should return nil when asked for a #{data} that has not been added" do
         expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
-
-      if data != "node"
-        it "should fail if an application with the same name is added" do
-          loader = Puppet::Resource::TypeCollection.new(environment)
-          instance = Puppet::Resource::Type.new(data, "foo")
-          application = Puppet::Resource::Type.new(:application, "foo")
-          loader.add(instance)
-          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
-        end
-
-        it "should fail if there is an application with the same name" do
-          loader = Puppet::Resource::TypeCollection.new(environment)
-          application = Puppet::Resource::Type.new(:application, "foo")
-          instance = Puppet::Resource::Type.new(data, "foo")
-          loader.add(instance)
-          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
-        end
-      end
     end
   end
 

data/spec/unit/resource/type_spec.rb

@@ -554,7 +554,7 @@ describe Puppet::Resource::Type do
 
     it "should not create a subscope for the :main class" do
       allow(@resource).to receive(:title).and_return(:main)
-      expect(@scope).not_to receive(:newscope)
+      expect(@type).not_to receive(:subscope)
       expect(@type).to receive(:set_resource_parameters).with(@resource, @scope)
 
       @type.evaluate_code(@resource)

data/spec/unit/resource_spec.rb

@@ -286,42 +286,9 @@ describe Puppet::Resource do
       Puppet::Parser::AST::Leaf.new(value: value)
     end
 
-    it "should fail when asked to set default values and it is not a parser resource" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
-      )
-      resource = Puppet::Resource.new("default_param", "name", :environment => environment)
-      expect { resource.set_default_parameters(scope) }.to raise_error(Puppet::DevError)
-    end
-
-    it "should evaluate and set any default values when no value is provided" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("a_default_value")})
-      )
-      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
-      resource.set_default_parameters(scope)
-      expect(resource["a"]).to eq("a_default_value")
-    end
-
-    it "should skip attributes with no default value" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_leaf("a_default_value")})
-      )
-      resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => scope)
-      expect { resource.set_default_parameters(scope) }.not_to raise_error
-    end
-
-    it "should return the list of default parameters set" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("a_default_value")})
-      )
-      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
-      expect(resource.set_default_parameters(scope)).to eq(["a"])
-    end
-
     describe "when the resource type is :hostclass" do
       let(:environment_name) { "testing env" }
-      let(:fact_values) { { 'a' => 1 } }
+      let(:fact_values) { { :a => 1 } }
       let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
 
       def inject_and_set_defaults(resource, scope)
@@ -330,7 +297,10 @@ describe Puppet::Resource do
 
       before do
         environment.known_resource_types.add(apache)
-        scope.set_facts(fact_values)
+
+        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))
       end
 
       context 'with a default value expression' do
@@ -402,7 +372,6 @@ describe Puppet::Resource do
 
           it "should use the value provided" do
             expect(Puppet::DataBinding.indirection).not_to receive(:find)
-            expect(resource.set_default_parameters(scope)).to eq([])
             expect(resource[:port]).to eq('8080')
           end
 
@@ -444,28 +413,6 @@ describe Puppet::Resource do
     end
   end
 
-  describe "when validating all required parameters are present" do
-    it "should be able to validate that all required parameters are present" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "required_param", :arguments => {"a" => nil})
-      )
-      expect { Puppet::Resource.new("required_param", "name", :environment => environment).validate_complete }.to raise_error(Puppet::ParseError)
-    end
-
-    it "should not fail when all required parameters are present" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "no_required_param")
-      )
-      resource = Puppet::Resource.new("no_required_param", "name", :environment => environment)
-      resource["a"] = "meh"
-      expect { resource.validate_complete }.not_to raise_error
-    end
-
-    it "should not validate against builtin types" do
-      expect { Puppet::Resource.new("file", "/bar").validate_complete }.not_to raise_error
-    end
-  end
-
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
@@ -624,15 +571,11 @@ describe Puppet::Resource do
       expect(resource.to_hash[:myvar]).to eq("bob")
     end
 
-    it "should set :name to the title if :name is not present for non-existent types" do
-      resource = Puppet::Resource.new :doesnotexist, "bar"
-      expect(resource.to_hash[:name]).to eq("bar")
-    end
-
-    it "should set :name to the title if :name is not present for a definition" do
-      type = Puppet::Resource::Type.new(:definition, :foo)
-      environment.known_resource_types.add(type)
-      resource = Puppet::Resource.new :foo, "bar", :environment => environment
+    it "should set :name to the title if :name is not present for non-builtin types" 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)
       expect(resource.to_hash[:name]).to eq("bar")
     end
   end
@@ -694,68 +637,19 @@ describe Puppet::Resource do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
-
       expect(result).to be_instance_of(Puppet::Type.type(:file))
       expect(result[:path]).to eq(basepath+"/my/file")
     end
 
-    it "should convert to a component instance if the resource is not a compilable_type" do
+    it "should convert to a component instance if the resource type is not of a builtin type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       expect(result).to be_instance_of(Puppet::Type.type(:component))
       expect(result.title).to eq("Foobar[somename]")
     end
-
-    it "should convert to a component instance if the resource is a class" do
-      resource = Puppet::Resource.new("Class", "somename")
-      result = resource.to_ral
-
-      expect(result).to be_instance_of(Puppet::Type.type(:component))
-      expect(result.title).to eq("Class[Somename]")
-    end
-
-    it "should convert to component when the resource is a defined_type" do
-      resource = Puppet::Resource.new("Unknown", "type", :kind => 'defined_type')
-
-      result = resource.to_ral
-      expect(result).to be_instance_of(Puppet::Type.type(:component))
-    end
-
-    it "should raise if a resource type is a compilable_type and it wasn't found" do
-      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
-
-      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
-    end
-
-    it "should use the old behaviour when the catalog_format is equal to 1" do
-      resource = Puppet::Resource.new("Unknown", "type")
-      catalog = Puppet::Resource::Catalog.new("mynode")
-
-      resource.catalog = catalog
-      resource.catalog.catalog_format = 1
-
-      result = resource.to_ral
-      expect(result).to be_instance_of(Puppet::Type.type(:component))
-    end
-
-    it "should use the new behaviour and fail when the catalog_format is greater than 1" do
-      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
-      catalog = Puppet::Resource::Catalog.new("mynode")
-
-      resource.catalog = catalog
-      resource.catalog.catalog_format = 2
-
-      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
-    end
-
-    it "should use the resource type when the resource doesn't respond to kind and the resource type can be found" do
-      resource = Puppet::Resource.new("file", basepath+"/my/file")
-
-      result = resource.to_ral
-      expect(result).to be_instance_of(Puppet::Type.type(:file))
-    end
   end
+
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file",
@@ -871,13 +765,6 @@ describe Puppet::Resource do
       expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).line).to eq(50)
     end
 
-    it "should include the kind if one is set" do
-      resource = Puppet::Resource.new("File", "/foo")
-      resource.kind = 'im_a_file'
-
-      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).kind).to eq('im_a_file')
-    end
-
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true

data/spec/unit/settings/http_extra_headers_spec.rb

@@ -46,18 +46,16 @@ describe Puppet::Settings::HttpExtraHeadersSetting do
     end
 
     describe 'raises an error when' do
-
-      # Ruby 2.3 reports the class of these objects as Fixnum, whereas later ruby versions report them as Integer
       it 'is given an unexpected object type' do
         expect {
           subject.munge(65)
-          }.to raise_error(ArgumentError, /^Expected an Array, String, or Hash, got a (Integer|Fixnum)/)
+          }.to raise_error(ArgumentError, /^Expected an Array, String, or Hash, got a Integer/)
       end
 
       it 'is given an array of unexpected object types' do
         expect {
           subject.munge([65, 82])
-          }.to raise_error(ArgumentError, /^Expected an Array or String, got a (Integer|Fixnum)/)
+          }.to raise_error(ArgumentError, /^Expected an Array or String, got a Integer/)
       end
     end
   end

data/spec/unit/settings/integer_setting_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'puppet/settings'
+require 'puppet/settings/integer_setting'
+
+describe Puppet::Settings::IntegerSetting do
+  let(:setting) { described_class.new(:settings => double('settings'), :desc => "test") }
+
+  it "is of type :integer" do
+    expect(setting.type).to eq(:integer)
+  end
+
+  describe "when munging the setting" do
+    it "returns the same value if given a positive integer" do
+      expect(setting.munge(5)).to eq(5)
+    end
+
+    it "returns the same value if given a negative integer" do
+      expect(setting.munge(-25)).to eq(-25)
+    end
+
+    it "returns an integer if given a valid integer as string" do
+      expect(setting.munge('12')).to eq(12)
+    end
+
+    it "returns an integer if given a valid negative integer as string" do
+      expect(setting.munge('-12')).to eq(-12)
+    end
+
+    it "returns an integer if given a valid positive integer as string" do
+      expect(setting.munge('+12')).to eq(12)
+    end
+
+    it "raises if given an invalid value" do
+      expect { setting.munge('a5') }.to raise_error(Puppet::Settings::ValidationError)
+    end
+
+    it "raises if given nil" do
+      expect { setting.munge(nil) }.to raise_error(Puppet::Settings::ValidationError)
+    end
+  end
+end