puppet 6.12.0-x86-mingw32 → 6.17.0-x86-mingw32

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

@@ -45,6 +45,7 @@ describe Puppet::Type.type(:user).provider(:openbsd) do
   describe "#addcmd" do
     it "should return an array with the full command and expiry as MM/DD/YY" do
       allow(Facter).to receive(:value).with(:osfamily).and_return('OpenBSD')
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
       resource[:expiry] = "1997-06-01"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', 'June 01 1997', 'myuser'])
     end

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

@@ -72,20 +72,24 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       provider.create
     end
 
-    it "should use -G to set groups" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('Not RedHat')
-      resource[:ensure] = :present
-      resource[:groups] = ['group1', 'group2']
-      expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
-      provider.create
-    end
+    context "when setting groups" do
+      it "uses -G to set groups" do
+        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+        resource[:ensure] = :present
+        resource[:groups] = ['group1', 'group2']
+        expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
+        provider.create
+      end
 
-    it "should use -G to set groups without -M on RedHat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-      resource[:ensure] = :present
-      resource[:groups] = ['group1', 'group2']
-      expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
-      provider.create
+      it "uses -G to set groups with -M on supported systems" do
+        allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
+        resource[:ensure] = :present
+        resource[:groups] = ['group1', 'group2']
+        expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
+        provider.create
+      end
     end
 
     it "should add -o when allowdupe is enabled and the user is being created" do
@@ -124,7 +128,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     describe "on systems with the libuser and forcelocal=true" do
       before do
-         described_class.has_feature :libuser
+         described_class.has_feature :manages_local_users_and_groups
          resource[:forcelocal] = true
       end
 
@@ -188,7 +192,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
   describe 'when modifying the password' do
     before do
-      described_class.has_feature :libuser
+      described_class.has_feature :manages_local_users_and_groups
       described_class.has_feature :manages_passwords
       #Setting any resource value here initializes needed variables and methods in the resource and provider
       #Setting a password value here initializes the existence and management of the password parameter itself
@@ -210,7 +214,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
   describe '#modify' do
     describe "on systems with the libuser and forcelocal=false" do
       before do
-         described_class.has_feature :libuser
+         described_class.has_feature :manages_local_users_and_groups
          resource[:forcelocal] = false
       end
 
@@ -315,16 +319,24 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], hash_including(custom_environment: {}))
       provider.expiry = :absent
     end
+
+    it "should use -e with -1 when the expiry property is removed on SLES11" do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('SLES')
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('11')
+      resource[:expiry] = :absent
+      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', -1, 'myuser'], hash_including(custom_environment: {}))
+      provider.expiry = :absent
+    end
   end
 
   describe "#comment" do
-    before { described_class.has_feature :libuser }
+    before { described_class.has_feature :manages_local_users_and_groups }
 
     let(:content) { "myuser:x:x:x:local comment:x:x" }
 
     it "should return the local comment string when forcelocal is true" do
       resource[:forcelocal] = true
-      allow(File).to receive(:open).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
 
@@ -337,7 +349,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
   end
 
   describe "#finduser" do
-    before { allow(File).to receive(:open).with('/etc/passwd').and_yield(content) }
+    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
@@ -361,6 +373,11 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     it "returns false when specified key/value pair is not found" do
       expect(provider.finduser(:account, 'invalid_account')).to eq(false)
     end
+
+    it "reads the user file only once per resource" do
+      expect(File).to receive(:read).with('/etc/passwd').once
+      5.times { provider.finduser(:account, 'sample_account') }
+    end
   end
 
   describe "#check_allow_dup" do
@@ -416,15 +433,17 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       provider.delete
     end
 
-    it "should use -M flag if home is not managed and on Redhat" do
+    it "should use -M flag if home is not managed on a supported system" do
       allow(Facter).to receive(:value).with(:osfamily).and_return("RedHat")
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease)
       resource[:managehome] = :false
       expect(provider).to receive(:execute).with(include('-M'), kind_of(Hash))
       provider.create
     end
 
-    it "should not use -M flag if home is not managed and not on Redhat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return("not RedHat")
+    it "should not use -M flag if home is not managed on an unsupported system" do
+      allow(Facter).to receive(:value).with(:osfamily).and_return("Suse")
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
       resource[:managehome] = :false
       expect(provider).to receive(:execute).with(excluding('-M'), kind_of(Hash))
       provider.create
@@ -696,7 +715,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     describe "on systems with the libuser and forcelocal=false" do
       before do
-         described_class.has_feature :libuser
+         described_class.has_feature :manages_local_users_and_groups
          resource[:forcelocal] = false
       end
 
@@ -708,7 +727,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     describe "on systems with the libuser and forcelocal=true" do
       before do
-         described_class.has_feature :libuser
+         described_class.has_feature :manages_local_users_and_groups
          resource[:forcelocal] = true
       end
 

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

@@ -78,9 +78,9 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
     let(:group3) { double(:account => 'group3', :domain => '.', :sid => 'group3sid') }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group1').and_return(group1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group2').and_return(group2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group3').and_return(group3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group1', any_args).and_return(group1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group2', any_args).and_return(group2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group3', any_args).and_return(group3)
     end
 
     it "should return true for same lists of members" do

data/spec/unit/puppet_pal_2pec.rb

@@ -708,32 +708,6 @@ describe 'Puppet Pal' do
         end
       end
 
-      context 'facts are supported such that' do
-        it 'they are obtained if they are not given' do
-          testing_env_dir # creates the structure
-          result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath ) do |ctx|
-            ctx.with_script_compiler {|c| c.evaluate_string("$facts =~ Hash and $facts[puppetversion] == '#{Puppet.version}'") }
-          end
-          expect(result).to eq(true)
-        end
-
-        it 'can be given as a hash when creating the environment' do
-          testing_env_dir # creates the structure
-          result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: { 'myfact' => 42 }) do |ctx|
-            ctx.with_script_compiler {|c| c.evaluate_string("$facts =~ Hash and $facts[myfact] == 42") }
-          end
-          expect(result).to eq(true)
-        end
-
-        it 'can be overridden with a hash when creating a script compiler' do
-          testing_env_dir # creates the structure
-          result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: { 'myfact' => 42 }) do |ctx|
-            ctx.with_script_compiler(facts: { 'myfact' => 43 }) {|c| c.evaluate_string("$facts =~ Hash and $facts[myfact] == 43") }
-          end
-          expect(result).to eq(true)
-        end
-      end
-
       context 'supports tasks such that' do
         it '"task_signature" returns the signatures of a generic task' do
           result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do |ctx|

data/spec/unit/puppet_pal_catalog_spec.rb

@@ -533,6 +533,19 @@ describe 'Puppet Pal' do
         end.to raise_error(Puppet::Error, /Could not find resource 'Bar\[nope\]'/)
       end
 
+      it 'an "evaluate" followed by "evaluate_ast_node" will correctly parse a node definition' do
+        Puppet[:node_name_value] = 'testing_node'
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string("node 'testing_node' { notify {'PASSED': } }"))
+            c.evaluate_ast_node
+            c.compile_additions
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to include(include('type' => 'Notify'))
+      end
     end
   end
 
@@ -632,6 +645,25 @@ describe 'Puppet Pal' do
               end
               RUBY
           }
+        },
+        'datatypes' => {
+          'mytype.rb' => <<-RUBY.unindent,
+            Puppet::DataTypes.create_type('Mytype') do
+              interface <<-PUPPET
+                attributes => {
+                  name => { type => String },
+                  year_of_birth => { type => Integer },
+                  age => { type => Integer, kind => derived },
+                }
+                PUPPET
+
+              implementation do
+                def age
+                  DateTime.now.year - @year_of_birth
+                end
+              end
+            end
+            RUBY
         }
       }
     }
@@ -722,6 +754,9 @@ describe 'Puppet Pal' do
 
       context 'facts are supported such that' do
         it 'they are obtained if they are not given' do
+          facts = Puppet::Node::Facts.new(Puppet[:certname], 'puppetversion' => Puppet.version)
+          Puppet::Node::Facts.indirection.save(facts)
+
           testing_env_dir # creates the structure
           result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath ) do |ctx|
             ctx.with_catalog_compiler {|c| c.evaluate_string("$facts =~ Hash and $facts[puppetversion] == '#{Puppet.version}'") }
@@ -746,6 +781,17 @@ describe 'Puppet Pal' do
         end
       end
 
+      context 'datatypes are supported such that' do
+        it 'datatypes defined as pcore in a module are deserialized' do
+          testing_env_dir
+          vars = {"bobs_age"=>{"__ptype"=>"Mytype", "name"=>"Bob", "year_of_birth"=>1984}}
+          result = Puppet::Pal.in_environment('pal_env', envpath: environments_dir, facts: node_facts, variables: vars) do |ctx|
+            ctx.with_catalog_compiler {|c| c.evaluate_string("$bobs_age.age") }
+          end
+          expect(result).to eq(DateTime.now.year - 1984)
+        end
+      end
+
       context 'configured as an existing given environment directory such that' do
         it 'modules in it are available from its "modules" directory' do
           result = Puppet::Pal.in_environment('pal_env', env_dir: testing_env_dir, facts: node_facts) do |ctx|

data/spec/unit/puppet_spec.rb

@@ -69,4 +69,51 @@ describe Puppet do
       expect(SemanticPuppet::Version).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
     end
   end
+
+  context "Settings" do
+    before(:each) do
+      @old_settings = Puppet.settings
+    end
+    after(:each) do
+      Puppet.replace_settings_object(@old_settings)
+    end
+    it "should allow for settings to be redefined with a custom object" do
+      new_settings = double()
+      Puppet.replace_settings_object(new_settings)
+      expect(Puppet.settings).to eq(new_settings)
+    end
+  end
+
+  context 'when registering implementations' do
+    it 'does not register an implementation by default' do
+      Puppet.initialize_settings
+
+      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)
+
+
+      expect(Puppet.runtime[:http]).to eq(impl)
+    end
+  end
+
+  context "initializing $LOAD_PATH" do
+    it "should add libdir and module paths to the load path" do
+      libdir = tmpdir('libdir_test')
+      vendor_dir = tmpdir('vendor_modules')
+      module_libdir = File.join(vendor_dir, 'amodule_core', 'lib')
+      FileUtils.mkdir_p(module_libdir)
+
+      Puppet[:libdir] = libdir
+      Puppet[:vendormoduledir] = vendor_dir
+      Puppet.initialize_settings
+
+      expect($LOAD_PATH).to include(libdir)
+      expect($LOAD_PATH).to include(module_libdir)
+    end
+
+  end
 end

data/spec/unit/reports/http_spec.rb

@@ -1,101 +1,119 @@
 require 'spec_helper'
 require 'puppet/reports'
 
-processor = Puppet::Reports.report(:http)
+describe Puppet::Reports.report(:http) do
+  subject { Puppet::Transaction::Report.new.extend(described_class) }
 
-describe processor do
-  subject { Puppet::Transaction::Report.new.extend(processor) }
+  let(:url) { "https://puppet.example.com/report/upload" }
+
+  before :each do
+    Puppet[:reporturl] = url
+  end
 
   describe "when setting up the connection" do
-    let(:http) { double("http") }
-    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+    it "raises if the connection fails" do
+      stub_request(:post, url).to_raise(Errno::ECONNREFUSED.new('Connection refused - connect(2)'))
 
-    before :each do
-      expect(http).to receive(:post).and_return(httpok)
+      expect {
+        subject.process
+      }.to raise_error(Puppet::HTTP::HTTPError, /Request to #{url} failed after .* seconds: .*Connection refused/)
     end
 
     it "configures the connection for ssl when using https" do
-      Puppet[:reporturl] = 'https://testing:8080/the/path'
+      stub_request(:post, url)
 
-      expect(Puppet::Network::HttpPool).to receive(:connection).with(
-        'testing', 8080, hash_including(ssl_context: instance_of(Puppet::SSL::SSLContext))
-      ).and_return(http)
+      expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
+        expect(http).to be_use_ssl
+        expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+      end
 
       subject.process
     end
 
     it "does not configure the connection for ssl when using http" do
-      Puppet[:reporturl] = 'http://testing:8080/the/path'
+      Puppet[:reporturl] = 'http://puppet.example.com:8080/the/path'
+      stub_request(:post, Puppet[:reporturl])
 
-      expect(Puppet::Network::HttpPool).to receive(:connection).with(
-        'testing', 8080, use_ssl: false, ssl_context: nil
-      ).and_return(http)
+      expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
+        expect(http).to_not be_use_ssl
+      end
 
       subject.process
     end
   end
 
   describe "when making a request" do
-    let(:connection) { double("connection") }
-    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
-    let(:options) { {:metric_id => [:puppet, :report, :http]} }
+    it "uses the path specified by the 'reporturl' setting" do
+      req = stub_request(:post, url)
+
+      subject.process
 
-    before :each do
-      expect(Puppet::Network::HttpPool).to receive(:connection).and_return(connection)
+      expect(req).to have_been_requested
     end
 
-    it "should use the path specified by the 'reporturl' setting" do
-      report_path = URI.parse(Puppet[:reporturl]).path
-      expect(connection).to receive(:post).with(report_path, anything, anything, options).and_return(httpok)
+    it "uses the username and password specified by the 'reporturl' setting" do
+      Puppet[:reporturl] = "https://user:pass@puppet.example.com/report/upload"
+
+      req = stub_request(:post, %r{/report/upload}).with(basic_auth: ['user', 'pass'])
 
       subject.process
+
+      expect(req).to have_been_requested
     end
 
-    it "should use the username and password specified by the 'reporturl' setting" do
-      Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
+    it "passes metric_id options" do
+      stub_request(:post, url)
 
-      expect(connection).to receive(:post).with(anything, anything, anything,
-                                                {:metric_id => [:puppet, :report, :http],
-                                                 :basic_auth => {
-                                                   :user => 'user',
-                                                   :password => 'pass'
-                                                 }}).and_return(httpok)
+      expect(Puppet.runtime[:http]).to receive(:post).with(anything, anything, hash_including(options: hash_including(metric_id: [:puppet, :report, :http]))).and_call_original
 
       subject.process
     end
 
-    it "should give the body as the report as YAML" do
-      expect(connection).to receive(:post).with(anything, subject.to_yaml, anything, options).and_return(httpok)
+    it "passes the report as YAML" do
+      req = stub_request(:post, url).with(body: subject.to_yaml)
 
       subject.process
+
+      expect(req).to have_been_requested
     end
 
-    it "should set content-type to 'application/x-yaml'" do
-      expect(connection).to receive(:post).with(anything, anything, hash_including("Content-Type" => "application/x-yaml"), options).and_return(httpok)
+    it "sets content-type to 'application/x-yaml'" do
+      req = stub_request(:post, url).with(headers: {'Content-Type' => 'application/x-yaml'})
 
       subject.process
+
+      expect(req).to have_been_requested
     end
 
-    Net::HTTPResponse::CODE_TO_OBJ.each do |code, klass|
-      if code.to_i >= 200 and code.to_i < 300
-        it "should succeed on http code #{code}" do
-          response = klass.new('1.1', code, '')
-          expect(connection).to receive(:post).and_return(response)
+    it "doesn't log anything if the request succeeds" do
+      req = stub_request(:post, url).to_return(status: [200, "OK"])
 
-          expect(Puppet).not_to receive(:err)
-          subject.process
-        end
-      end
+      subject.process
 
-      if code.to_i >= 300 && ![301, 302, 307].include?(code.to_i)
-        it "should log error on http code #{code}" do
-          response = klass.new('1.1', code, '')
-          expect(connection).to receive(:post).and_return(response)
+      expect(req).to have_been_requested
+      expect(@logs).to eq([])
+    end
 
-          expect(Puppet).to receive(:err)
-          subject.process
-        end
-      end
+    it "follows redirects" do
+      location = {headers: {'Location' => url}}
+
+      req = stub_request(:post, url)
+              .to_return(**location, status: [301, "Moved Permanently"]).then
+              .to_return(**location, status: [302, "Found"]).then
+              .to_return(**location, status: [307, "Temporary Redirect"]).then
+              .to_return(status: [200, "OK"])
+
+      subject.process
+
+      expect(req).to have_been_requested.times(4)
+    end
+
+    it "logs an error if the request fails" do
+      stub_request(:post, url).to_return(status: [500, "Internal Server Error"])
+
+      subject.process
+
+      expect(@logs).to include(having_attributes(level: :err, message: "Unable to submit report to #{url} [500] Internal Server Error"))
     end
   end
 end