puppet 6.15.0-x64-mingw32 → 6.19.1-x64-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
@@ -315,6 +319,14 @@ 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
@@ -421,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

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

@@ -72,6 +72,88 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
     end
   end
 
+  describe "when setting roles" do
+    context "when role_membership => minimum" do
+      before :each do
+        resource[:role_membership] = :minimum
+      end
+
+      it "should set the given role when user has no roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole1']).and_return(nil)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should set only the misssing role when user already has other roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole2']).and_return(nil)
+        provider.roles = 'givenRole1,givenRole2'
+      end
+
+      it "should never remove any roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1')
+        allow(Puppet::Util::Windows::User).to receive(:set_rights).and_return(nil)
+
+        expect(Puppet::Util::Windows::User).not_to receive(:remove_rights)
+        provider.roles = 'givenRole1,givenRole2'
+      end
+    end
+
+    context "when role_membership => inclusive" do
+      before :each do
+        resource[:role_membership] = :inclusive
+      end
+
+      it "should remove the unwanted role" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+
+        expect(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole2']).and_return(nil)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should add the missing role and remove the unwanted one" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole3']).and_return(nil)
+        expect(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole2']).and_return(nil)
+        provider.roles = 'givenRole1,givenRole3'
+      end
+
+      it "should not set any roles when the user already has given role" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+        allow(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole2']).and_return(nil)
+
+        expect(Puppet::Util::Windows::User).not_to receive(:set_rights)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should set the given role when user has no roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('')
+
+        expect(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole1']).and_return(nil)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should not remove any roles when user has no roles" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('')
+        allow(Puppet::Util::Windows::User).to receive(:set_rights).with('testuser', ['givenRole1']).and_return(nil)
+
+        expect(Puppet::Util::Windows::User).not_to receive(:remove_rights)
+        provider.roles = 'givenRole1'
+      end
+
+      it "should remove all roles when none given" do
+        allow(Puppet::Util::Windows::User).to receive(:get_rights).and_return('givenRole1,givenRole2')
+
+        expect(Puppet::Util::Windows::User).not_to receive(:set_rights)
+        expect(Puppet::Util::Windows::User).to receive(:remove_rights).with('testuser', ['givenRole1', 'givenRole2']).and_return(nil)
+        provider.roles = ''
+      end
+    end
+  end
+
   describe "#groups_insync?" do
     let(:group1) { double(:account => 'group1', :domain => '.', :sid => 'group1sid') }
     let(:group2) { double(:account => 'group2', :domain => '.', :sid => 'group2sid') }

data/spec/unit/puppet_pal_2pec.rb

@@ -708,6 +708,46 @@ describe 'Puppet Pal' do
         end
       end
 
+      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_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
+
+        it 'can be disabled with the :set_local_facts option' do
+          Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: { 'myfact' => 42}) do |ctx|
+            ctx.with_script_compiler(facts: { 'myfact' => 42 }, set_local_facts: false) do |compiler|
+              expect { compiler.evaluate_string('$facts') }.to raise_error(
+                Puppet::PreformattedError,
+                /Unknown variable: 'facts'/
+              )
+            end
+          end
+        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
         }
       }
     }
@@ -749,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

@@ -83,4 +83,37 @@ describe Puppet do
       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

@@ -64,7 +64,7 @@ describe Puppet::Reports.report(:http) do
     it "passes metric_id options" do
       stub_request(:post, url)
 
-      expect(Puppet.runtime['http']).to receive(:post).with(anything, anything, hash_including(options: hash_including(metric_id: [:puppet, :report, :http]))).and_call_original
+      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

data/spec/unit/reports/store_spec.rb

@@ -6,53 +6,57 @@ require 'pathname'
 require 'tempfile'
 require 'fileutils'
 
-processor = Puppet::Reports.report(:store)
-
-describe processor do
+describe Puppet::Reports.report(:store) do
   describe "#process" do
     include PuppetSpec::Files
+
     before :each do
       Puppet[:reportdir] = File.join(tmpdir('reports'), 'reports')
-      @report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml')).extend processor
+    end
+
+    let(:report) do
+      report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      report.extend(described_class)
+      report
     end
 
     it "should create a report directory for the client if one doesn't exist" do
-      @report.process
+      report.process
 
-      expect(File).to be_directory(File.join(Puppet[:reportdir], @report.host))
+      expect(File).to be_directory(File.join(Puppet[:reportdir], report.host))
     end
 
     it "should write the report to the file in YAML" do
       allow(Time).to receive(:now).and_return(Time.utc(2011,01,06,12,00,00))
-      @report.process
+      report.process
 
-      expect(File.read(File.join(Puppet[:reportdir], @report.host, "201101061200.yaml"))).to eq(@report.to_yaml)
+      expect(File.read(File.join(Puppet[:reportdir], report.host, "201101061200.yaml"))).to eq(report.to_yaml)
     end
 
     it "rejects invalid hostnames" do
-      @report.host = ".."
+      report.host = ".."
       expect(Puppet::FileSystem).not_to receive(:exist?)
-      expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
+      expect { report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
   describe "::destroy" do
     it "rejects invalid hostnames" do
       expect(Puppet::FileSystem).not_to receive(:unlink)
-      expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
+      expect { described_class.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
   describe "::validate_host" do
     ['..', 'hello/', '/hello', 'he/llo', 'hello/..', '.'].each do |node|
       it "rejects #{node.inspect}" do
-        expect { processor.validate_host(node) }.to raise_error(ArgumentError, /Invalid node/)
+        expect { described_class.validate_host(node) }.to raise_error(ArgumentError, /Invalid node/)
       end
     end
 
     ['.hello', 'hello.', '..hi', 'hi..'].each do |node|
       it "accepts #{node.inspect}" do
-        processor.validate_host(node)
+        described_class.validate_host(node)
       end
     end
   end

data/spec/unit/resource_spec.rb

@@ -283,7 +283,7 @@ describe Puppet::Resource do
     let(:scope)    { Puppet::Parser::Scope.new(compiler) }
 
     def ast_leaf(value)
-      Puppet::Parser::AST::Leaf.new({:value => value})
+      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
@@ -389,7 +389,7 @@ describe Puppet::Resource do
         context "when a value is provided" do
           let(:port_parameter) do
             Puppet::Parser::Resource::Param.new(
-              { :name => 'port', :value => '8080' }
+              name: 'port', value: '8080'
             )
           end
 
@@ -414,7 +414,7 @@ describe Puppet::Resource do
             expect_lookup('apache::port', returns: '443')
 
             rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+              :parameters => [Puppet::Parser::Resource::Param.new(name: 'port', value: nil)])
 
             rs.resource_type.set_resource_parameters(rs, scope)
             expect(rs[:port]).to eq('443')

data/spec/unit/rest/route_spec.rb

@@ -30,7 +30,7 @@ describe Puppet::Rest::Route do
 
       it "yields a base URL with Puppet's configured server and port when no defaults are specified" do
         Puppet[:server] = 'configured.net'
-        Puppet[:masterport] = 8140
+        Puppet[:serverport] = 8140
         fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
         count = 0
         rval = fallback_route.with_base_url(dns_resolver) do |url|
@@ -55,9 +55,9 @@ describe Puppet::Rest::Route do
         expect(rval).to eq('Block return value')
       end
 
-      it 'falls back to :server and :masterport if nil is passed' do
+      it 'falls back to :server and :serverport if nil is passed' do
         Puppet[:server] = 'one.net'
-        Puppet[:masterport] = 111
+        Puppet[:serverport] = 111
         nil_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
                                             server_setting: nil,
                                             port_setting: nil)
@@ -109,7 +109,7 @@ describe Puppet::Rest::Route do
 
         it "should fall back to the default server when the block raises a SystemCallError" do
           Puppet[:server] = "testserver"
-          Puppet[:masterport] = 555
+          Puppet[:serverport] = 555
 
           count = 0
           rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|