puppet 6.19.0-x86-mingw32 → 7.3.0-x86-mingw32

data/spec/unit/face/node_spec.rb

@@ -15,13 +15,6 @@ describe Puppet::Face[:node, '0.0.1'] do
   end
 
   describe 'when running #clean' do
-    before :each do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
-      allow(Puppet::Node).to receive(:terminus_class=)
-      allow(Puppet::Node).to receive(:cache_class=)
-    end
-
     it 'should invoke #cleanup' do
       expect(subject).to receive(:cleanup).with('hostname')
       subject.clean('hostname')
@@ -30,10 +23,6 @@ describe Puppet::Face[:node, '0.0.1'] do
 
   describe "clean action" do
     before :each do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
-      allow(Puppet::Node).to receive(:terminus_class=)
-      allow(Puppet::Node).to receive(:cache_class=)
       allow(subject).to receive(:cleanup)
     end
 
@@ -89,8 +78,20 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning certificate", :if => Puppet.features.puppetserver_ca? do
         it "should call the CA CLI gem's clean action" do
-          expect_any_instance_of(Puppetserver::Ca::Action::Clean).to receive(:run).with({ 'certnames' => ['hostname'] }).and_return(0)
-          subject.clean_cert('hostname')
+          expect_any_instance_of(Puppetserver::Ca::Action::Clean).
+            to receive(:clean_certs).
+            with(['hostname'], anything).
+            and_return(:success)
+
+          if Puppet[:cadir].start_with?(Puppet[:ssldir])
+            expect_any_instance_of(LoggerIO).
+              to receive(:warn).
+              with(/cadir is currently configured to be inside/)
+          end
+
+          expect(Puppet).not_to receive(:warning)
+          result = subject.clean_cert('hostname')
+          expect(result).to eq(0)
         end
 
         it "should not call the CA CLI gem's clean action if the gem is missing" do

data/spec/unit/face/plugin_spec.rb

@@ -16,48 +16,88 @@ describe Puppet::Face[:plugin, :current] do
       end
     end
 
-    it "downloads plugins, external facts, and locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+    context "when i18n is enabled" do
+      before(:each) do
+        Puppet[:disable_i18n] = false
+      end
 
-      pluginface.download
-      expect(receive_count).to eq(3)
-    end
+      it "downloads plugins, external facts, and locales" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
-    it "renders 'No plugins downloaded' if nothing was downloaded" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+        pluginface.download
+        expect(receive_count).to eq(3)
+      end
 
-      result = pluginface.download
-      expect(receive_count).to eq(3)
-      expect(render(result)).to eq('No plugins downloaded.')
-    end
+      it "renders 'No plugins downloaded' if nothing was downloaded" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
-    it "renders comma separate list of downloaded file names" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        case receive_count
-        when 1
-          %w[/a]
-        when 2
-          %w[/b]
-        when 3
-          %w[/c]
-        end
+        result = pluginface.download
+        expect(receive_count).to eq(3)
+        expect(render(result)).to eq('No plugins downloaded.')
       end
 
-      result = pluginface.download
-      expect(receive_count).to eq(3)
-      expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
+      it "renders comma separate list of downloaded file names" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+          receive_count += 1
+          case receive_count
+          when 1
+            %w[/a]
+          when 2
+            %w[/b]
+          when 3
+            %w[/c]
+          end
+        end
+
+        result = pluginface.download
+        expect(receive_count).to eq(3)
+        expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
+      end
     end
 
-    it "uses persistent HTTP pool" do
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        expect(Puppet.lookup(:http_pool)).to be_instance_of(Puppet::Network::HTTP::Pool)
-      end.and_return([])
+    context "when i18n is enabled" do
+      before(:each) do
+        Puppet[:disable_i18n] = true
+      end
 
-      pluginface.download
+      it "downloads only plugins and external facts, no locales" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+
+        pluginface.download
+        expect(receive_count).to eq(2)
+      end
+
+      it "renders 'No plugins downloaded' if nothing was downloaded, without checking for locales" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+
+        result = pluginface.download
+        expect(receive_count).to eq(2)
+        expect(render(result)).to eq('No plugins downloaded.')
+      end
+
+      it "renders comma separate list of downloaded file names" do
+        receive_count = 0
+        allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+          receive_count += 1
+          case receive_count
+          when 1
+            %w[/a]
+          when 2
+            %w[/b]
+          when 3
+            %w[/c]
+          end
+        end
+
+        result = pluginface.download
+        expect(receive_count).to eq(2)
+        expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+      end
     end
   end
 

data/spec/unit/file_bucket/file_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::FileBucket::File, :uses_checksums => true do
   end
 
   it "should require contents to be a string" do
-    expect { Puppet::FileBucket::File.new(5) }.to raise_error(ArgumentError, /contents must be a String or Pathname, got a (?:Fixnum|Integer)$/)
+    expect { Puppet::FileBucket::File.new(5) }.to raise_error(ArgumentError, /contents must be a String or Pathname, got a Integer$/)
   end
 
   it "should complain about options other than :bucket_path" do

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -49,7 +49,7 @@ describe Puppet::FileServing::Configuration::Parser do
       expect { @parser.parse }.to raise_error(ArgumentError)
     end
 
-    it "should fail if the value for path/allow/deny starts with an equals sign" do
+    it "should fail if the value for path starts with an equals sign" do
       write_config_file "[one]\npath = /testing"
       expect { @parser.parse }.to raise_error(ArgumentError)
     end
@@ -87,7 +87,6 @@ describe Puppet::FileServing::Configuration::Parser do
     before do
       @mount = double('testmount', :name => "one", :validate => true)
       expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(@mount)
-      allow(@parser).to receive(:add_modules_mount)
     end
 
     it "should set the mount path to the path attribute from that section" do
@@ -98,34 +97,38 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     [:allow,:deny].each { |acl_type|
-      it "should support inline comments in #{acl_type}" do
+      it "should ignore inline comments in #{acl_type}" do
         write_config_file "[one]\n#{acl_type} something \# will it work?\n"
 
-      expect(@mount).to receive(:info)
-      expect(@mount).to receive(acl_type).with("something")
-      @parser.parse
+        expect(@parser.parse).to eq('one' => @mount)
       end
 
-      it "should tell the mount to #{acl_type} from ACLs with varying spacing around commas" do
+      it "should ignore #{acl_type} from ACLs with varying spacing around commas" do
         write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
 
-        expect(@mount).to receive(:info).exactly(5).times
-        expect(@mount).to receive(acl_type).exactly(5).times.with(eq('someone').or eq('sometwo').or eq('somethree').or eq('somefour').or eq('somefive'))
-        @parser.parse
+        expect(@parser.parse).to eq('one' => @mount)
       end
 
-      # each ip, with glob in the various octet positions
-      ['100','4','42','*'].permutation.map {|permutes| permutes.join('.') }.each { |ip_pattern|
-        it "should tell the mount to #{acl_type} from ACLs with glob at #{ip_pattern}" do
-          write_config_file "[one]\n#{acl_type} #{ip_pattern}\n"
+      it "should log an error and print the location of the #{acl_type} rule" do
+        write_config_file(<<~CONFIG)
+        [one]
+        #{acl_type} one
+        CONFIG
+
+        expect(Puppet).to receive(:err).with(/Entry '#{acl_type} one' is unsupported and will be ignored at \(file: .*, line: 2\)/)
 
-          expect(@mount).to receive(:info)
-          expect(@mount).to receive(acl_type).with(ip_pattern)
-          @parser.parse
-        end
-      }
+        @parser.parse
+      end
     }
 
+    it "should not generate an error when parsing 'allow *'" do
+      write_config_file "[one]\nallow *\n"
+
+      expect(Puppet).to receive(:err).never
+
+      @parser.parse
+    end
+
     it "should return comprehensible error message, if failed on invalid attribute" do
       write_config_file "[one]\ndo something\n"
 

data/spec/unit/file_serving/configuration_spec.rb

@@ -90,17 +90,14 @@ describe Puppet::FileServing::Configuration do
 
     it "should allow all access to modules, plugins, and tasks if no fileserver.conf exists" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      modules = double('modules', :empty? => true)
+      modules = double('modules')
       allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).to receive(:allow).with('*')
 
-      plugins = double('plugins', :empty? => true)
+      plugins = double('plugins')
       allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).to receive(:allow).with('*')
 
-      tasks = double('tasks', :empty? => true)
+      tasks = double('tasks')
       allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).to receive(:allow).with('*')
 
       Puppet::FileServing::Configuration.configuration
     end
@@ -108,17 +105,14 @@ describe Puppet::FileServing::Configuration do
     it "should not allow access from all to modules, plugins, and tasks if the fileserver.conf provided some rules" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
 
-      modules = double('modules', :empty? => false)
+      modules = double('modules')
       allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).not_to receive(:allow).with('*')
 
-      plugins = double('plugins', :empty? => false)
+      plugins = double('plugins')
       allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).not_to receive(:allow).with('*')
 
-      tasks = double('tasks', :empty? => false)
+      tasks = double('tasks')
       allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).not_to receive(:allow).with('*')
 
       Puppet::FileServing::Configuration.configuration
     end

data/spec/unit/file_serving/metadata_spec.rb

@@ -266,9 +266,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('bar')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path, :use).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path).and_raise(invalid_error)
+      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path).and_raise(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -2,13 +2,20 @@ require 'spec_helper'
 
 require 'puppet/file_serving/terminus_helper'
 
+class Puppet::FileServing::TestHelper
+  include Puppet::FileServing::TerminusHelper
+
+  attr_reader :model
+
+  def initialize(model)
+    @model = model
+  end
+end
+
 describe Puppet::FileServing::TerminusHelper do
   before do
-    @helper = Object.new
-    @helper.extend(Puppet::FileServing::TerminusHelper)
-
     @model = double('model')
-    allow(@helper).to receive(:model).and_return(@model)
+    @helper = Puppet::FileServing::TestHelper.new(@model)
 
     @request = double('request', :key => "url", :options => {})
 

data/spec/unit/forge/module_release_spec.rb

@@ -22,13 +22,8 @@ describe Puppet::Forge::ModuleRelease do
   let(:uri) { " "}
   let(:release) { Puppet::Forge::ModuleRelease.new(ssl_repository, JSON.parse(release_json)) }
 
-  let(:mock_file) {
-    mock_io = StringIO.new
-    allow(mock_io).to receive(:path).and_return('/dev/null')
-    mock_io
-  }
-
-  let(:mock_dir) { '/tmp' }
+  let(:mock_file) { double('file', path: '/dev/null') }
+  let(:mock_dir) { tmpdir('dir') }
 
   let(:destination) { tmpfile('forge_module_release') }
 

data/spec/unit/functions/camelcase_spec.rb

@@ -15,7 +15,7 @@ describe 'the camelcase function' do
     expect(compile_to_catalog("notify { String(42.camelcase == 42): }")).to have_resource('Notify[true]')
   end
 
-  it 'performs capitalize of international UTF-8 characters', :if => RUBY_VERSION >= "2.4" do
+  it 'performs camelcase of international UTF-8 characters' do
     expect(compile_to_catalog("notify { 'åäö_äö'.camelcase: }")).to have_resource('Notify[ÅäöÄö]')
   end
 

data/spec/unit/functions/capitalize_spec.rb

@@ -15,7 +15,7 @@ describe 'the capitalize function' do
     expect(compile_to_catalog("notify { String(42.capitalize == 42): }")).to have_resource('Notify[true]')
   end
 
-  it 'performs capitalize of international UTF-8 characters', :if => RUBY_VERSION >= "2.4" do
+  it 'performs capitalize of international UTF-8 characters' do
     expect(compile_to_catalog("notify { 'åäö'.capitalize: }")).to have_resource('Notify[Åäö]')
   end
 

data/spec/unit/functions/downcase_spec.rb

@@ -15,7 +15,7 @@ describe 'the downcase function' do
     expect(compile_to_catalog("notify { String(42.downcase == 42): }")).to have_resource('Notify[true]')
   end
 
-  it 'performs capitalize of international UTF-8 characters', :if => RUBY_VERSION >= "2.4" do
+  it 'performs downcase of international UTF-8 characters' do
     expect(compile_to_catalog("notify { 'ÅÄÖ'.downcase: }")).to have_resource('Notify[åäö]')
   end
 

data/spec/unit/functions/inline_epp_spec.rb

@@ -1,8 +1,10 @@
-
 require 'spec_helper'
 
+require 'puppet_spec/compiler'
+
 describe "the inline_epp function" do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
@@ -73,6 +75,29 @@ describe "the inline_epp function" do
     expect(eval_template("string was: <%= $string %>")).to eq("string was: the string value")
   end
 
+  context "when using Sensitive" do
+    it "returns an unwrapped sensitive value as a String" do
+      expect(eval_and_collect_notices(<<~END)).to eq(["opensesame"])
+        notice(inline_epp("<%= Sensitive('opensesame').unwrap %>"))
+      END
+    end
+
+    it "rewraps a sensitive value" do
+      # note entire result is redacted, not just sensitive part
+      expect(eval_and_collect_notices(<<~END)).to eq(["Sensitive [value redacted]"])
+        notice(inline_epp("This is sensitive <%= Sensitive('opensesame') %>"))
+      END
+    end
+
+    it "can be double wrapped" do
+      catalog = compile_to_catalog(<<~END)
+        notify { 'title':
+          message => Sensitive(inline_epp("<%= Sensitive('opensesame') %>"))
+        }
+      END
+      expect(catalog.resource(:notify, 'title')['message']).to eq('opensesame')
+    end
+  end
 
   def eval_template_with_args(content, args_hash)
     epp_function.call(scope, content, args_hash)

data/spec/unit/functions/upcase_spec.rb

@@ -15,7 +15,7 @@ describe 'the upcase function' do
     expect(compile_to_catalog("notify { String(42.upcase == 42): }")).to have_resource('Notify[true]')
   end
 
-  it 'performs capitalize of international UTF-8 characters', :if => RUBY_VERSION >= "2.4" do
+  it 'performs upcase of international UTF-8 characters' do
     expect(compile_to_catalog("notify { 'åäö'.upcase: }")).to have_resource('Notify[ÅÄÖ]')
   end
 

data/spec/unit/http/client_spec.rb

@@ -154,7 +154,7 @@ describe Puppet::HTTP::Client do
       stub_request(:get, uri)
 
       response = client.get(uri)
-      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_a(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
     end
@@ -224,7 +224,7 @@ describe Puppet::HTTP::Client do
       stub_request(:head, uri)
 
       response = client.head(uri)
-      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_a(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
     end
@@ -284,7 +284,7 @@ describe Puppet::HTTP::Client do
       stub_request(:put, uri)
 
       response = client.put(uri, "", headers: {'Content-Type' => 'text/plain'})
-      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_a(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
     end
@@ -353,7 +353,7 @@ describe Puppet::HTTP::Client do
       stub_request(:post, uri)
 
       response = client.post(uri, "", headers: {'Content-Type' => 'text/plain'})
-      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_a(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
     end
@@ -435,7 +435,7 @@ describe Puppet::HTTP::Client do
       stub_request(:delete, uri)
 
       response = client.delete(uri)
-      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_a(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
     end
@@ -771,7 +771,7 @@ describe Puppet::HTTP::Client do
     it "should close the connection before sleeping" do
       retry_after('42')
 
-      site = Puppet::Network::HTTP::Site.from_uri(uri)
+      site = Puppet::HTTP::Site.from_uri(uri)
 
       http1 = Net::HTTP.new(site.host, site.port)
       http1.use_ssl = true
@@ -781,8 +781,7 @@ describe Puppet::HTTP::Client do
       http2.use_ssl = true
       allow(http2).to receive(:started?).and_return(true)
 
-
-      pool = Puppet::Network::HTTP::Pool.new(15)
+      pool = Puppet::HTTP::Pool.new(15)
       client = Puppet::HTTP::Client.new(pool: pool)
 
       # The "with_connection" method is required to yield started connections