puppet 6.4.5-universal-darwin → 6.5.0-universal-darwin

data/spec/unit/defaults_spec.rb

@@ -139,7 +139,7 @@ describe "Defaults" do
       let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
 
       it 'includes user and system modules' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
+        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(installdir)
 
         expect(
           Puppet.default_basemodulepath
@@ -147,7 +147,7 @@ describe "Defaults" do
       end
 
       it 'includes user modules if installdir fact is missing' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
+        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(nil)
 
         expect(
           Puppet.default_basemodulepath
@@ -167,7 +167,7 @@ describe "Defaults" do
       let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
 
       it 'includes the default vendormoduledir' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
+        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(installdir)
 
         expect(
           Puppet.default_vendormoduledir
@@ -175,7 +175,7 @@ describe "Defaults" do
       end
 
       it 'is nil if installdir fact is missing' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
+        allow(Facter).to receive(:value).with(:env_windows_installdir).and_return(nil)
 
         expect(Puppet.default_vendormoduledir).to be_nil
       end

data/spec/unit/face/facts_spec.rb

@@ -45,15 +45,6 @@ CONF
       subject.upload
     end
 
-    it "passes the current environment" do
-      env = Puppet::Node::Environment.remote('qa')
-      expect(model.indirection).to receive(:save).with(anything, nil, :environment => env)
-
-      Puppet.override(:current_environment => env) do
-        subject.upload
-      end
-    end
-
     it "uses settings from the agent section of puppet.conf" do
       expect(facter_terminus).to receive(:find).with(have_attributes(key: 'puppet.node.test')).and_return(test_data)
 

data/spec/unit/face/parser_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet_spec/files'
 
 require 'puppet/face'
+require 'puppet/application/parser'
 
 describe Puppet::Face[:parser, :current] do
   include PuppetSpec::Files
@@ -9,6 +10,12 @@ describe Puppet::Face[:parser, :current] do
   let(:parser) { Puppet::Face[:parser, :current] }
 
   context "validate" do
+    let(:validate_app) do
+      Puppet::Application::Parser.new.tap do |app|
+        allow(app).to receive(:action).and_return(parser.get_action(:validate))
+      end
+    end
+
     context "from an interactive terminal" do
       before :each do
         from_an_interactive_terminal
@@ -25,14 +32,17 @@ describe Puppet::Face[:parser, :current] do
 
         configured_environment = Puppet::Node::Environment.create(:default, [], manifest)
         Puppet.override(:current_environment => configured_environment) do
-          expect { parser.validate() }.to exit_with(1)
+          parse_errors = parser.validate()
+
+          expect(parse_errors[manifest]).to be_a_kind_of(Puppet::ParseErrorWithIssue)
         end
       end
 
       it "validates the given file" do
         manifest = file_containing('site.pp', "{ invalid =>")
+        parse_errors = parser.validate(manifest)
 
-        expect { parser.validate(manifest) }.to exit_with(1)
+        expect(parse_errors[manifest]).to be_a_kind_of(Puppet::ParseErrorWithIssue)
       end
 
       it "validates static heredoc with specified syntax" do
@@ -40,36 +50,40 @@ describe Puppet::Face[:parser, :current] do
           { invalid =>
           EOT
         ")
-        expect { parser.validate(manifest) }.to exit_with(1)
+        parse_errors = parser.validate(manifest)
+
+        expect(parse_errors[manifest]).to be_a_kind_of(Puppet::ParseErrorWithIssue)
       end
 
       it "does not validates dynamic heredoc with specified syntax" do
         manifest = file_containing('site.pp', "@(\"EOT\":pp)
         {invalid => ${1+1}
         EOT")
-        expect { parser.validate(manifest) }.to_not exit_with(1)
+        parse_errors = parser.validate(manifest)
+
+        expect(parse_errors).to be_empty
       end
 
       it "runs error free when there are no validation errors" do
-        expect {
-            manifest = file_containing('site.pp', "notify { valid: }")
-            parser.validate(manifest)
-        }.to_not raise_error
+        manifest = file_containing('site.pp', "notify { valid: }")
+        parse_errors = parser.validate(manifest)
+
+        expect(parse_errors).to be_empty
       end
 
       it "runs error free when there is a puppet function in manifest being validated" do
-        expect {
-          manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
-          parser.validate(manifest)
-        }.to_not raise_error
+        manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+        parse_errors = parser.validate(manifest)
+
+        expect(parse_errors).to be_empty
       end
 
       it "runs error free when there is a type alias in a manifest that requires type resolution" do
-        expect {
-          manifest = file_containing('site.pp',
-            "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
-          parser.validate(manifest)
-        }.to_not raise_error
+        manifest = file_containing('site.pp',
+                                   "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+        parse_errors = parser.validate(manifest)
+
+        expect(parse_errors).to be_empty
       end
 
       it "reports missing files" do
@@ -84,19 +98,52 @@ describe Puppet::Face[:parser, :current] do
         env = Puppet::Node::Environment.create(:special, [])
         env_loader = Puppet::Environments::Static.new(env)
         Puppet.override({:environments => env_loader, :current_environment => env}) do
-          expect { parser.validate(manifest) }.to exit_with(1)
-        end
+          parse_errors = parser.validate(manifest)
 
-        expect(@logs.join).to match(/environment special.*Syntax error at end of input/)
+          expect(parse_errors[manifest]).to be_a_kind_of(Puppet::ParseErrorWithIssue)
+        end
       end
-
     end
 
     it "validates the contents of STDIN when no files given and STDIN is not a tty" do
       from_a_piped_input_of("{ invalid =>")
 
       Puppet.override(:current_environment => Puppet::Node::Environment.create(:special, [])) do
-        expect { parser.validate() }.to exit_with(1)
+        parse_errors = parser.validate()
+
+        expect(parse_errors['STDIN']).to be_a_kind_of(Puppet::ParseErrorWithIssue)
+      end
+    end
+
+    context "when invoked with console output renderer" do
+      before(:each) do
+        validate_app.render_as = :console
+      end
+
+      it "logs errors using Puppet.log_exception" do
+        manifest = file_containing('test.pp', "{ invalid =>")
+        results = parser.validate(manifest)
+
+        results.each do |_, error|
+          expect(Puppet).to receive(:log_exception).with(error)
+        end
+
+        expect { validate_app.render(results, nil) }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when invoked with --render-as=json" do
+      before(:each) do
+        validate_app.render_as = :json
+      end
+
+      it "outputs errors in a JSON document to stdout" do
+        manifest = file_containing('test.pp', "{ invalid =>")
+        results = parser.validate(manifest)
+
+        expected_json = /\A{.*#{Regexp.escape('"message":')}\s*#{Regexp.escape('"Syntax error at end of input"')}.*}\Z/m
+
+        expect { validate_app.render(results, nil) }.to output(expected_json).to_stdout.and raise_error(SystemExit)
       end
     end
   end

data/spec/unit/face/plugin_spec.rb

@@ -50,14 +50,6 @@ describe Puppet::Face[:plugin, :current] do
       expect(receive_count).to eq(3)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
     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([])
-
-      pluginface.download
-    end
   end
 
   context "download when server_agent_version is 5.3.3" do

data/spec/unit/file_system_spec.rb

@@ -223,7 +223,7 @@ describe "Puppet::FileSystem" do
       expect do
         Puppet::FileSystem.exclusive_open(file, 0666, 'a', 0.1) do |f|
         end
-      end.to raise_error(Timeout::Error)
+      end.to raise_error(Timeout::Error, /Timeout waiting for exclusive lock on #{file}/)
 
       Process.kill(9, child)
     end
@@ -1089,4 +1089,33 @@ describe "Puppet::FileSystem" do
       end
     end
   end
+
+  context '#touch' do
+    let(:dest) { tmpfile('touch_file') }
+
+    it 'creates a file' do
+      Puppet::FileSystem.touch(dest)
+
+      expect(File).to be_file(dest)
+    end
+
+    it 'updates the mtime for an existing file' do
+      Puppet::FileSystem.touch(dest)
+
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      Puppet::FileSystem.touch(dest)
+
+      expect(File.mtime(dest)).to be_within(1).of(now)
+    end
+
+    it 'allows the mtime to be passed in' do
+      tomorrow = Time.now + (24 * 60 * 60)
+
+      Puppet::FileSystem.touch(dest, mtime: tomorrow)
+
+      expect(File.mtime(dest)).to be_within(1).of(tomorrow)
+    end
+  end
 end

data/spec/unit/forge/forge_spec.rb

@@ -97,8 +97,10 @@ describe Puppet::Forge do
   def mock_proxy(port, proxy_args, result, &block)
     http = double("http client")
     proxy = double("http proxy")
+    proxy_class = double("http proxy class")
 
-    expect(Net::HTTP).to receive(:new).with(host, port, *proxy_args).and_return(proxy)
+    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
+    expect(proxy_class).to receive(:new).with(host, port).and_return(proxy)
 
     expect(proxy).to receive(:open_timeout=)
     expect(proxy).to receive(:read_timeout=)

data/spec/unit/forge/repository_spec.rb

@@ -234,8 +234,10 @@ describe Puppet::Forge::Repository do
   def mock_proxy(port, proxy_args, result, &block)
     http = double("http client")
     proxy = double("http proxy")
+    proxy_class = double("http proxy class")
 
-    expect(Net::HTTP).to receive(:new).with("fake.com", port, *proxy_args).and_return(proxy)
+    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
+    expect(proxy_class).to receive(:new).with("fake.com", port).and_return(proxy)
 
     expect(proxy).to receive(:open_timeout=)
     expect(proxy).to receive(:read_timeout=)

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -4,12 +4,6 @@ require 'matchers/resource'
 
 require 'puppet/indirector/catalog/compiler'
 
-def set_facts(fact_hash)
-  fact_hash.each do |key, value|
-    allow(Facter).to receive(:value).with(key).and_return(value)
-  end
-end
-
 describe Puppet::Resource::Catalog::Compiler do
   let(:compiler) { described_class.new }
   let(:node_name) { "foo" }
@@ -22,11 +16,8 @@ describe Puppet::Resource::Catalog::Compiler do
   describe "when initializing" do
     before do
       expect(Puppet).to receive(:version).and_return(1)
-      set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => "my.ip.address",
-        'ipaddress6' => nil
-        })
+      expect(Facter).to receive(:value).with('fqdn').and_return("my.server.com")
+      expect(Facter).to receive(:value).with('ipaddress').and_return("my.ip.address")
     end
 
     it "should gather data about itself" do
@@ -399,12 +390,9 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "after finding nodes" do
     before do
-      allow(Puppet).to receive(:version).and_return(1)
-      set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => "my.ip.address",
-        'ipaddress6' => nil
-        })
+      expect(Puppet).to receive(:version).and_return(1)
+      expect(Facter).to receive(:value).with('fqdn').and_return("my.server.com")
+      expect(Facter).to receive(:value).with('ipaddress').and_return("my.ip.address")
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
       allow(compiler).to receive(:compile)
       allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
@@ -424,51 +412,6 @@ describe Puppet::Resource::Catalog::Compiler do
       expect(node).to receive(:merge).with(hash_including("serverip" => "my.ip.address"))
       compiler.find(@request)
     end
-
-    it "shouldn't warn if there is at least one ip fact" do
-      expect(node).to receive(:merge).with(hash_including("serverip" => "my.ip.address"))
-      compiler.find(@request)
-      expect(@logs).not_to be_any {|log| log.level == :warning and log.message =~ /Could not retrieve either serverip or serverip6 fact/}
-    end
-  end
-
-  describe "in an IPv6 only environment" do
-    before do |example|
-      allow(Puppet).to receive(:version).and_return(1)
-      set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => nil,
-      })
-      if example.metadata[:nil_ipv6]
-        set_facts({
-          'ipaddress6' => nil
-        })
-      else
-        set_facts({
-          'ipaddress6' => "my.ipv6.address"
-        })
-      end
-      @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
-      allow(compiler).to receive(:compile)
-      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-    end
-
-    it "should populate the :serverip6 fact" do
-      expect(node).to receive(:merge).with(hash_including("serverip6" => "my.ipv6.address"))
-      compiler.find(@request)
-    end
-
-    it "shouldn't warn if there is at least one ip fact" do
-      expect(node).to receive(:merge).with(hash_including("serverip6" => "my.ipv6.address"))
-      compiler.find(@request)
-      expect(@logs).not_to be_any {|log| log.level == :warning and log.message =~ /Could not retrieve either serverip or serverip6 fact/}
-    end
-
-    it "should warn if there are no ip facts", :nil_ipv6 do
-      expect(node).to receive(:merge)
-      compiler.find(@request)
-      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Could not retrieve either serverip or serverip6 fact/}
-    end
   end
 
   describe "when filtering resources" do

data/spec/unit/indirector/resource/ral_spec.rb

@@ -48,7 +48,7 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should convert ral resources into regular resources" do
-      my_resource = double("my user resource", :title => "my user resource")
+      my_resource = double("my user resource")
       my_instance = double("my user", :name => "root", :to_resource => my_resource)
 
       expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance ])
@@ -56,7 +56,7 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource = double("my user resource", title: "my user resource")
+      my_resource = double("my user resource")
       allow(my_resource).to receive(:to_resource).and_return(my_resource)
       allow(my_resource).to receive(:[]).with(:name).and_return("root")
 
@@ -74,11 +74,11 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = double("my user resource", title: "my user resource")
+      wrong_resource = double("my user resource")
       allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
       allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
 
-      my_resource = double("wrong resource", title: "wrong resource")
+      my_resource = double("wrong resource")
       allow(my_resource).to receive(:to_resource).and_return(my_resource)
       allow(my_resource).to receive(:[]).with(:name).and_return("bob")
 

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
     expect(minitar).to receive(:find_valid_files).with(reader).and_return([name])
     entry = MockFileStatEntry.new(mode)
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name], :fsync => false).
+    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name]).
         and_yield(type, name, {:entry => entry})
     entry
   end

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -40,27 +40,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if there is no environment specified" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {})
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the environment is not alphanumeric" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"})
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not match the prefix" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not have the correct version" do
-      expect {
-        handler.uri2indirection("GET", "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v1/node/bar", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v1/node/bar", params) }).to raise_error(bad_request_error)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
@@ -84,9 +76,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(bad_request_error)
     end
 
     it "should use the remainder of the URI as the indirection key" do
@@ -98,9 +88,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if no indirection key is specified" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/node", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(bad_request_error)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
@@ -140,9 +128,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if an indirection method cannot be picked" do
-      expect {
-        handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params)
-      }.to raise_error(method_not_allowed_error)
+      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(method_not_allowed_error)
     end
 
     it "should not URI unescape the indirection key" do
@@ -162,10 +148,9 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(handler).to receive(:check_authorization).with(anything,
                                                             anything,
                                                             excluding(:environment))
-      expect { handler.uri2indirection("GET",
-                                       "#{master_url_prefix}/node/bar",
-                                       {:environment => 'bogus'})
-      }.to raise_error(not_found_error)
+      expect(lambda { handler.uri2indirection("GET",
+                                              "#{master_url_prefix}/node/bar",
+                                              {:environment => 'bogus'}) }).to raise_error(not_found_error)
     end
 
     it "should not URI unescape the indirection key as passed through to a call to check_authorization" do