puppet 7.7.0-universal-darwin → 7.11.0-universal-darwin

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

@@ -13,6 +13,7 @@ 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
@@ -62,7 +63,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))
+      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true)).twice
       provider.create
     end
 
@@ -208,7 +209,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))
+      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true)).and_return('')
       provider.password = 'bird bird bird'
     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 => Facter.value(:operatingsystem) } => true,
+      { :operatingsystem => Puppet.runtime[: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 => Facter.value(:operatingsystem),
+      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
         :exists => Puppet::Util.which(existing_command) } => true,
       { :operatingsystem => :yayness,
         :exists => Puppet::Util.which(existing_command) } => false,
-      { :operatingsystem => Facter.value(:operatingsystem),
+      { :operatingsystem => Puppet.runtime[: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 Facter.value(:operatingsystem) end
+    let :os do Puppet.runtime[:facter].value(:operatingsystem) end
 
     it { is_expected.to respond_to :specificity }
 

data/spec/unit/puppet_spec.rb

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

data/spec/unit/resource/type_collection_spec.rb

@@ -43,6 +43,14 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot redefine/)
   end
 
+  it "should fail if a hostclass duplicates a node" do
+    @code.add(Puppet::Resource::Type.new(:node, "foo"))
+
+    expect do
+      @code.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+    end.to raise_error(Puppet::ParseError, /Node 'foo' is already defined; cannot be redefined as a class/)
+  end
+
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
@@ -60,6 +68,14 @@ describe Puppet::Resource::TypeCollection do
     }.to raise_error(/.*is already defined; cannot redefine/)
   end
 
+  it "should fail if a node duplicates a hostclass" do
+    @code.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+
+    expect do
+      @code.add(Puppet::Resource::Type.new(:node, "foo"))
+    end.to raise_error(Puppet::ParseError, /Class 'foo' is already defined; cannot be redefined as a node/)
+  end
+
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 

data/spec/unit/resource/type_spec.rb

@@ -462,9 +462,9 @@ describe Puppet::Resource::Type do
     end
 
     it "should be able to find parent nodes" do
-      parent = Puppet::Resource::Type.new(:node, "bar")
+      parent = Puppet::Resource::Type.new(:node, "node_bar")
       @krt.add parent
-      child = Puppet::Resource::Type.new(:node, "foo", :parent => "bar")
+      child = Puppet::Resource::Type.new(:node, "node_foo", :parent => "node_bar")
       @krt.add child
 
       expect(child.parent_type(@scope)).to equal(parent)

data/spec/unit/settings/config_file_spec.rb

@@ -135,16 +135,6 @@ badline
                                          with_setting(:var, "value changed", NO_META)))
   end
 
-  it "does not try to transform an entry named 'mode'" do
-    config = Puppet::Settings::ConfigFile.new(Proc.new { raise "Should not transform" })
-
-    result = config.parse_file(filename, "mode = value")
-
-    expect(result).to eq(Conf.new.
-                            with_section(Section.new(:main).
-                                         with_setting(:mode, "value", NO_META)))
-  end
-
   it "accepts non-UTF8 encoded text" do
     result = the_parse_of("var = value".encode("UTF-16LE"))
 
@@ -152,6 +142,6 @@ badline
                            with_section(Section.new(:main).
                                           with_setting(:var, "value", NO_META)))
 
-    end
+  end
 end
 

data/spec/unit/settings/file_setting_spec.rb

@@ -125,9 +125,10 @@ describe Puppet::Settings::FileSetting do
   describe "when being converted to a resource" do
     before do
       @basepath = make_absolute("/somepath")
+      allow(Puppet::FileSystem).to receive(:exist?).and_call_original
+      allow(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
       @settings = double('settings')
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
-      allow(@file).to receive(:create_files?).and_return(true)
       allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(@basepath)
     end
 
@@ -135,18 +136,19 @@ describe Puppet::Settings::FileSetting do
       expect(@file.type).to eq(:file)
     end
 
-    it "should skip non-existent files if 'create_files' is not enabled" do
-      expect(@file).to receive(:create_files?).and_return(false)
+    it "skips non-existent files" do
       expect(@file).to receive(:type).and_return(:file)
       expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(false)
       expect(@file.to_resource).to be_nil
     end
 
-    it "should manage existent files even if 'create_files' is not enabled" do
-      expect(@file).to receive(:create_files?).and_return(false)
+    it "manages existing files" do
       expect(@file).to receive(:type).and_return(:file)
-      allow(Puppet::FileSystem).to receive(:exist?)
-      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
+      expect(@file.to_resource).to be_instance_of(Puppet::Resource)
+    end
+
+    it "always manages directories" do
+      expect(@file).to receive(:type).and_return(:directory)
       expect(@file.to_resource).to be_instance_of(Puppet::Resource)
     end
 
@@ -177,6 +179,7 @@ describe Puppet::Settings::FileSetting do
     it "should fully qualified returned files if necessary (#795)" do
       allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("myfile")
       path = File.expand_path('myfile')
+      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
       expect(@file.to_resource.title).to eq(path)
     end
 

data/spec/unit/settings/value_translator_spec.rb

@@ -25,13 +25,12 @@ describe Puppet::Settings::ValueTranslator do
   end
 
   context "numbers" do
-    it "translates integer strings to integers" do
-      expect(translator["1"]).to eq(1)
-      expect(translator["2"]).to eq(2)
+    it "leaves integer strings" do
+      expect(translator["1"]).to eq("1")
     end
 
-    it "translates numbers starting with a 0 as octal" do
-      expect(translator["011"]).to eq(9)
+    it "leaves octal numbers as strings" do
+      expect(translator["011"]).to eq("011")
     end
 
     it "leaves hex numbers as strings" do

data/spec/unit/settings_spec.rb

@@ -29,6 +29,17 @@ describe Puppet::Settings do
     end
   end
 
+  def stub_config_with(content)
+    allow(Puppet.features).to receive(:root?).and_return(false)
+    expect(Puppet::FileSystem).to receive(:exist?).
+      with(user_config_file_default_location).
+      and_return(true).ordered
+    expect(@settings).to receive(:read_file).
+      with(user_config_file_default_location).
+      and_return(content).ordered
+    @settings.send(:parse_config_files)
+  end
+
   describe "when specifying defaults" do
     before do
       @settings = Puppet::Settings.new
@@ -264,23 +275,31 @@ describe Puppet::Settings do
       expect(@settings[:myval]).to eq("")
     end
 
-    it "should flag string settings from the CLI" do
+    it "should retrieve numeric settings from the CLI" do
       @settings.handlearg("--myval", "12")
-      expect(@settings.set_by_cli?(:myval)).to be_truthy
+      expect(@settings.set_by_cli(:myval)).to eq("12")
+      expect(@settings.set_by_cli?(:myval)).to be true
     end
 
-    it "should flag bool settings from the CLI" do
+    it "should retrieve string settings from the CLI" do
+      @settings.handlearg("--myval", "something")
+      expect(@settings.set_by_cli(:myval)).to eq("something")
+      expect(@settings.set_by_cli?(:myval)).to be true
+    end
+
+    it "should retrieve bool settings from the CLI" do
       @settings.handlearg("--bool")
-      expect(@settings.set_by_cli?(:bool)).to be_truthy
+      expect(@settings.set_by_cli(:bool)).to be true
+      expect(@settings.set_by_cli?(:bool)).to be true
     end
 
-    it "should not flag settings memory as from CLI" do
+    it "should not retrieve settings set in memory as from CLI" do
       @settings[:myval] = "12"
-      expect(@settings.set_by_cli?(:myval)).to be_falsey
+      expect(@settings.set_by_cli?(:myval)).to be false
     end
 
     it "should find no configured settings by default" do
-      expect(@settings.set_by_config?(:myval)).to be_falsey
+      expect(@settings.set_by_config?(:myval)).to be false
     end
 
     it "should identify configured settings in memory" do
@@ -304,64 +323,66 @@ describe Puppet::Settings do
       expect(@settings.set_by_config?(:manifest, Puppet[:environment])).to be_truthy
     end
 
-    it "should identify configured settings from the preferred run mode" do
-      user_config_text = "[#{@settings.preferred_run_mode}]\nmyval = foo"
+    context "when handling puppet.conf" do
+      describe "#set_by_config?" do
+        it "should identify configured settings from the preferred run mode" do
+          stub_config_with(<<~CONFIG)
+          [#{@settings.preferred_run_mode}]
+          myval = foo
+          CONFIG
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
-        with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
-        with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+          expect(@settings.set_by_config?(:myval)).to be_truthy
+        end
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval)).to be_truthy
-    end
+        it "should identify configured settings from the specified run mode" do
+          stub_config_with(<<~CONFIG)
+          [server]
+          myval = foo
+          CONFIG
 
-    it "should identify configured settings from the specified run mode" do
-      user_config_text = "[server]\nmyval = foo"
+          expect(@settings.set_by_config?(:myval, nil, :server)).to be_truthy
+        end
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
-        with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
-        with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+        it "should not identify configured settings from an unspecified run mode" do
+          stub_config_with(<<~CONFIG)
+          [zaz]
+          myval = foo
+          CONFIG
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval, nil, :server)).to be_truthy
-    end
+          expect(@settings.set_by_config?(:myval)).to be_falsey
+        end
 
-    it "should not identify configured settings from an unspecified run mode" do
-      user_config_text = "[zaz]\nmyval = foo"
+        it "should identify configured settings from the main section" do
+          stub_config_with(<<~CONFIG)
+          [main]
+          myval = foo
+          CONFIG
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
-        with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
-        with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+          expect(@settings.set_by_config?(:myval)).to be_truthy
+        end
+      end
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval)).to be_falsey
-    end
+      describe "#set_in_section" do
+        it "should retrieve configured settings from the specified section" do
+          stub_config_with(<<~CONFIG)
+          [agent]
+          myval = foo
+          CONFIG
 
-    it "should identify configured settings from the main section" do
-      user_config_text = "[main]\nmyval = foo"
+          expect(@settings.set_in_section(:myval, :agent)).to eq("foo")
+          expect(@settings.set_in_section?(:myval, :agent)).to be true
+        end
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
-        with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
-        with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+        it "should not retrieve configured settings from a different section" do
+          stub_config_with(<<~CONFIG)
+          [main]
+          myval = foo
+          CONFIG
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval)).to be_truthy
+          expect(@settings.set_in_section(:myval, :agent)).to be nil
+          expect(@settings.set_in_section?(:myval, :agent)).to be false
+        end
+      end
     end
 
     it "should clear the cache when setting getopt-specific values" do
@@ -1024,7 +1045,7 @@ describe Puppet::Settings do
       expect(@settings[:two]).to eq(false)
     end
 
-    it "should convert integers in the configuration file into Ruby Integers" do
+    it "doesn't convert integers in the configuration file" do
       File.write(@file, <<~CONF)
         [main]
         one = 65
@@ -1032,7 +1053,7 @@ describe Puppet::Settings do
 
       @settings.initialize_global_settings
 
-      expect(@settings[:one]).to eq(65)
+      expect(@settings[:one]).to eq('65')
     end
 
     it "should support specifying all metadata (owner, group, mode) in the configuration file" do
@@ -1087,10 +1108,10 @@ describe Puppet::Settings do
     context "when setting serverport and masterport" do
       before(:each) do
         @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
-        @settings.define_settings :server, :masterport => { :desc => "a", :default => 1000 }
+        @settings.define_settings :server, :masterport => { :desc => "a", :default => 1000, :type => :port }
         @settings.define_settings :server, :serverport => { :type => :alias, :alias_for => :masterport }
-        @settings.define_settings :server, :ca_port => { :desc => "a", :default => "$serverport" }
-        @settings.define_settings :server, :report_port => { :desc => "a", :default => "$serverport" }
+        @settings.define_settings :server, :ca_port => { :desc => "a", :default => "$serverport", :type => :port }
+        @settings.define_settings :server, :report_port => { :desc => "a", :default => "$serverport", :type => :port }
 
         config_file = tmpfile('config')
         @settings[:config] = config_file
@@ -1111,8 +1132,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(444) }
-        it { expect(@settings[:ca_port]).to eq("444") }
-        it { expect(@settings[:report_port]).to eq("444") }
+        it { expect(@settings[:ca_port]).to eq(444) }
+        it { expect(@settings[:report_port]).to eq(444) }
         it { expect(@settings[:masterport]).to eq(445) }
       end
 
@@ -1125,8 +1146,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(445) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(444) }
       end
 
@@ -1139,8 +1160,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(445) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(444) }
       end
 
@@ -1156,8 +1177,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(445) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(444) }
       end
 
@@ -1171,8 +1192,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(444) }
-        it { expect(@settings[:ca_port]).to eq("444") }
-        it { expect(@settings[:report_port]).to eq("444") }
+        it { expect(@settings[:ca_port]).to eq(444) }
+        it { expect(@settings[:report_port]).to eq(444) }
         it { expect(@settings[:masterport]).to eq(445) }
       end
 
@@ -1184,8 +1205,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(445) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(445) }
       end
 
@@ -1197,8 +1218,8 @@ describe Puppet::Settings do
         end
 
         it { expect(@settings[:serverport]).to eq(445) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(445) }
       end
 
@@ -1211,8 +1232,8 @@ describe Puppet::Settings do
 
         it { expect(@settings[:serverport]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(1000) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
       end
 
       context 'with serverport in main' do
@@ -1224,8 +1245,8 @@ describe Puppet::Settings do
 
         it { expect(@settings[:serverport]).to eq(445) }
         it { expect(@settings[:masterport]).to eq(1000) }
-        it { expect(@settings[:ca_port]).to eq("445") }
-        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:ca_port]).to eq(445) }
+        it { expect(@settings[:report_port]).to eq(445) }
       end
     end
 
@@ -2137,7 +2158,7 @@ describe Puppet::Settings do
     end
 
     def a_user_type_for(username)
-      user = double('user')
+      user = double('user', 'suitable?': true, to_s: "User[#{username}]")
       expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: username)).and_return(user)
       user
     end
@@ -2170,6 +2191,16 @@ describe Puppet::Settings do
 
       expect(settings).to be_service_user_available
     end
+
+    it "raises if the user is not suitable" do
+      settings[:user] = "foo"
+
+      expect(a_user_type_for("foo")).to receive(:suitable?).and_return(false)
+
+      expect {
+        settings.service_user_available?
+      }.to raise_error(Puppet::Error, /Cannot manage owner permissions, because the provider for 'User\[foo\]' is not functional/)
+    end
   end
 
   describe "when determining if the service group is available" do
@@ -2180,7 +2211,7 @@ describe Puppet::Settings do
     end
 
     def a_group_type_for(groupname)
-      group = double('group')
+      group = double('group', 'suitable?': true, to_s: "Group[#{groupname}]")
       expect(Puppet::Type.type(:group)).to receive(:new).with(hash_including(name: groupname)).and_return(group)
       group
     end
@@ -2213,6 +2244,16 @@ describe Puppet::Settings do
 
       expect(settings).to be_service_group_available
     end
+
+    it "raises if the group is not suitable" do
+      settings[:group] = "foo"
+
+      expect(a_group_type_for("foo")).to receive(:suitable?).and_return(false)
+
+      expect {
+        settings.service_group_available?
+      }.to raise_error(Puppet::Error, /Cannot manage group permissions, because the provider for 'Group\[foo\]' is not functional/)
+    end
   end
 
   describe "when dealing with command-line options" do