puppet 6.17.0-x86-mingw32 → 7.1.0-x86-mingw32

data/spec/unit/provider/service/src_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Src',
-         unless: Puppet::Util::Platform.jruby? do
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:src) }
 
-  if Puppet::Util::Platform.windows?
-    # Get a pid for $CHILD_STATUS to latch on to
-    command = "cmd.exe /c \"exit 0\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  before :all do
+    `exit 0`
   end
 
   before :each do

data/spec/unit/provider/service/systemd_spec.rb

@@ -1,12 +1,9 @@
 require 'spec_helper'
 
-describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platform.jruby? do
+describe 'Puppet::Type::Service::Provider::Systemd',
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
+
   let(:provider_class) { Puppet::Type.type(:service).provider(:systemd) }
-  if Puppet::Util::Platform.windows?
-    # Get a pid for $CHILD_STATUS to latch on to
-    command = "cmd.exe /c \"exit 0\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
-  end
 
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)

data/spec/unit/provider/service/upstart_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
-describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platform.jruby? do
+describe 'Puppet::Type::Service::Provider::Upstart',
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:manual) { "\nmanual" }
   let(:start_on_default_runlevels) {  "\nstart on runlevel [2,3,4,5]" }
   let!(:provider_class) { Puppet::Type.type(:service).provider(:upstart) }
 
-  if Puppet::Util::Platform.windows?
-    # Get a pid for $CHILD_STATUS to latch on to
-    command = "cmd.exe /c \"exit 0\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  before :each do
+    `exit 0`
   end
 
   def given_contents_of(file, content)

data/spec/unit/provider/service/windows_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'win32/service' if Puppet::Util::Platform.windows?
 
 describe 'Puppet::Type::Service::Provider::Windows',
     :if => Puppet::Util::Platform.windows? && !Puppet::Util::Platform.jruby? do
@@ -127,6 +126,34 @@ describe 'Puppet::Type::Service::Provider::Windows',
         expect(provider.status).to eq(:running)
       end
     end
+
+    context 'when querying lmhosts', if: Puppet::Util::Platform.windows? do
+      # This service should be ubiquitous across all supported Windows platforms
+      let(:service) { Puppet::Type.type(:service).new(:name => 'lmhosts') }
+
+      before :each do
+        allow(service_util).to receive(:exists?).with(service.name).and_call_original
+      end
+
+      it "reports if the service is enabled" do
+        expect([:true, :false, :manual]).to include(service.provider.enabled?)
+      end
+
+      it "reports on the service status" do
+        expect(
+          [
+            :running,
+            :'continue pending',
+            :'pause pending',
+            :paused,
+            :running,
+            :'start pending',
+            :'stop pending',
+            :stopped
+          ]
+        ).to include(service.provider.status)
+      end
+    end
   end
 
   describe "#restart" do

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

@@ -143,6 +143,11 @@ describe 'Puppet::Type::User::Provider::Aix' do
     it "returns the user's password" do
       expect(call_parse_password).to eql('some_password')
     end
+
+    it "returns the user's password with tabs" do
+      resource[:name] = 'tab_password_user'
+      expect(call_parse_password).to eql('some_password')
+    end
   end
 
   # TODO: If we move from using Mocha to rspec's mocks,

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

@@ -53,12 +53,14 @@ describe Puppet::Type.type(:user).provider(:pw) do
 
     it "should use -G with the correct argument when the groups property is set" do
       resource[:groups] = "group1"
+      allow(Puppet::Util::POSIX).to receive(:groups_of).with('testuser').and_return([])
       expect(provider).to receive(:execute).with(include("-G").and(include("group1")), kind_of(Hash))
       provider.create
     end
 
     it "should use -G with all the given groups when the groups property is set to an array" do
       resource[:groups] = ["group1", "group2"]
+      allow(Puppet::Util::POSIX).to receive(:groups_of).with('testuser').and_return([])
       expect(provider).to receive(:execute).with(include("-G").and(include("group1,group2")), kind_of(Hash))
       provider.create
     end

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

@@ -4,6 +4,7 @@ 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')

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/provider_spec.rb

@@ -670,18 +670,6 @@ describe Puppet::Provider do
 
       provider.send(:execpipe, "a_command", true, block)
     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.send(: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.send(:execfail, "a_command", "an exception to raise")
-    end
   end
 
   context "mk_resource_methods" do

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

@@ -69,6 +69,51 @@ describe 'Puppet Pal' do
         }.to raise_error(/manifest_file or code_string cannot be given when configured_by_env is true/)
       end
 
+      it 'shadows target variables that collide with plan variables' do
+        facts       = { 'var' => 'fact' }
+        target_vars = { 'var' => 'target' }
+
+        expect(Puppet).to receive(:warning).with(/Target variable \$var will be overridden by fact of the same name/)
+
+        result = Puppet::Pal.in_tmp_environment('pal_env', facts: {}) do |ctx|
+          ctx.with_catalog_compiler(facts: facts, target_variables: target_vars ) do |c|
+            c.evaluate_string('$var')
+          end
+        end
+
+        expect(result).to eq('fact')
+      end
+
+      it 'shadows target variables that collide with facts' do
+        plan_vars   = { 'var' => 'plan' }
+        target_vars = { 'var' => 'target' }
+
+        expect(Puppet).to receive(:warning).with(/Target variable \$var will be overridden by plan variable of the same name/)
+        
+        result = Puppet::Pal.in_tmp_environment('pal_env', facts: {}) do |ctx|
+          ctx.with_catalog_compiler(variables: plan_vars, target_variables: target_vars ) do |c|
+            c.evaluate_string('$var')
+          end
+        end
+
+        expect(result).to eq('plan')
+      end
+
+      it 'shadows plan variables that collide with facts' do
+        facts     = { 'var' => 'fact' }
+        plan_vars = { 'var' => 'plan' }
+
+        expect(Puppet).to receive(:warning).with(/Plan variable \$var will be overridden by fact of the same name/)
+        
+        result = Puppet::Pal.in_tmp_environment('pal_env', facts: {}) do |ctx|
+          ctx.with_catalog_compiler(facts: facts, variables: plan_vars ) do |c|
+            c.evaluate_string('$var')
+          end
+        end
+
+        expect(result).to eq('fact')
+      end
+
       context "evaluate_string method" do
         it 'evaluates code string in a given tmp environment' do
           result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do |ctx|

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/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