puppet 7.3.0-x86-mingw32 → 7.7.0-x86-mingw32

data/spec/unit/network/http/api_spec.rb

@@ -36,12 +36,12 @@ describe Puppet::Network::HTTP::API do
   end
 
   describe "Puppet API" do
-    let(:handler) { PuppetSpec::Handler.new(Puppet::Network::HTTP::API.master_routes,
+    let(:handler) { PuppetSpec::Handler.new(Puppet::Network::HTTP::API.server_routes,
                                             Puppet::Network::HTTP::API.not_found_upgrade) }
 
-    let(:master_prefix) { Puppet::Network::HTTP::MASTER_URL_PREFIX }
+    let(:server_prefix) { Puppet::Network::HTTP::SERVER_URL_PREFIX }
 
-    it "raises a not-found error for non-CA or master routes and suggests an upgrade" do
+    it "raises a not-found error for non-CA or server routes and suggests an upgrade" do
       req = Puppet::Network::HTTP::Request.from_hash(:path => "/unknown")
       res = {}
       handler.process(req, res)
@@ -50,13 +50,13 @@ describe Puppet::Network::HTTP::API do
     end
 
     describe "when processing Puppet 3 routes" do
-      it "gives an upgrade message for master routes" do
+      it "gives an upgrade message for server routes" do
         req = Puppet::Network::HTTP::Request.from_hash(:path => "/production/node/foo")
         res = {}
         handler.process(req, res)
         expect(res[:status]).to eq(404)
         expect(res[:body]).to include("Puppet version: #{Puppet.version}")
-        expect(res[:body]).to include("Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}")
+        expect(res[:body]).to include("Supported /puppet API versions: #{Puppet::Network::HTTP::SERVER_URL_VERSIONS}")
       end
 
       it "gives an upgrade message for CA routes" do
@@ -65,11 +65,11 @@ describe Puppet::Network::HTTP::API do
         handler.process(req, res)
         expect(res[:status]).to eq(404)
         expect(res[:body]).to include("Puppet version: #{Puppet.version}")
-        expect(res[:body]).to include("Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}")
+        expect(res[:body]).to include("Supported /puppet API versions: #{Puppet::Network::HTTP::SERVER_URL_VERSIONS}")
       end
     end
 
-    describe "when processing master routes" do
+    describe "when processing server routes" do
       # simulate puppetserver registering its authconfigloader class
       around :each do |example|
         Puppet::Network::Authorization.authconfigloader_class = Object
@@ -81,7 +81,7 @@ describe Puppet::Network::HTTP::API do
       end
 
       it "responds to v3 indirector requests" do
-        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/node/foo",
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_prefix}/v3/node/foo",
                                                        :params => {:environment => "production"},
                                                        :headers => {'accept' => "application/json"})
         res = {}
@@ -90,18 +90,18 @@ describe Puppet::Network::HTTP::API do
       end
 
       it "responds to v3 environments requests" do
-        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/environments")
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_prefix}/v3/environments")
         res = {}
         handler.process(req, res)
         expect(res[:status]).to eq(200)
       end
 
       it "responds with a not found error to non-v3 requests and does not suggest an upgrade" do
-        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/unknown")
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_prefix}/unknown")
         res = {}
         handler.process(req, res)
         expect(res[:status]).to eq(404)
-        expect(res[:body]).to include("No route for GET #{master_prefix}/unknown")
+        expect(res[:body]).to include("No route for GET #{server_prefix}/unknown")
         expect(res[:body]).not_to include("Puppet version: #{Puppet.version}")
       end
     end

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -61,12 +61,26 @@ describe "the fqdn_rand function" do
     expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(2389)
   end
 
+  it "returns the same value if only host differs by case" do
+    val1 = fqdn_rand(1000000000, :host => "host.example.com", :extra_identifier => [nil, true])
+    val2 = fqdn_rand(1000000000, :host => "HOST.example.com", :extra_identifier => [nil, true])
+
+    expect(val1).to eql(val2)
+  end
+
+  it "returns the same value if only host differs by case and an initial seed is given" do
+    val1 = fqdn_rand(1000000000, :host => "host.example.com", :extra_identifier => ['a seed', true])
+    val2 = fqdn_rand(1000000000, :host => "HOST.example.com", :extra_identifier => ['a seed', true])
+
+    expect(val1).to eql(val2)
+  end
+
   def fqdn_rand(max, args = {})
     host = args[:host] || '127.0.0.1'
     extra = args[:extra_identifier] || []
 
     scope = create_test_scope_for_node('localhost')
-    allow(scope).to receive(:[]).with("::fqdn").and_return(host)
+    scope.compiler.topscope['fqdn'] = host.freeze
 
     scope.function_fqdn_rand([max] + extra)
   end

data/spec/unit/pops/loaders/dependency_loader_spec.rb

@@ -122,7 +122,7 @@ Puppet::Functions.create_function('testmodule::foo') {
 
   def loader_for(name, dir)
       module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, name, dir)
-      Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
+      Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader], loaders.environment)
   end
 
   def typed_name(type, name)

data/spec/unit/pops/lookup/context_spec.rb

@@ -243,7 +243,7 @@ describe 'Puppet::Pops::Lookup::Context' do
             File.write(data_path, "a: value b\n")
 
             # Ensure mtime is at least 1 second ahead
-            FileUtils.touch(data_path, :mtime => old_mtime + 1)
+            FileUtils.touch(data_path, mtime: old_mtime + 1)
 
             Puppet::Parser::Compiler.compile(node)
           end

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -94,10 +94,6 @@ describe 'Lexer2' do
     "private"  => :PRIVATE,
     "type"     => :TYPE,
     "attr"     => :ATTR,
-    "application"  => :APPLICATION,
-    "consumes"     => :CONSUMES,
-    "produces"     => :PRODUCES,
-    "site"         => :SITE,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       expect(tokens_scanned_from(string)).to match_tokens2(name)

data/spec/unit/pops/types/type_parser_spec.rb

@@ -210,7 +210,8 @@ describe TypeParser do
   end
 
   context 'with loader context' do
-    let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader") }
+    let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+    let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader", environment) }
 
     it 'interprets anything that is not found by the loader to be a type reference' do
       expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)

data/spec/unit/pops/validator/validator_spec.rb

@@ -344,18 +344,6 @@ describe "validating 4x" do
       end
     end
 
-    it 'produces a syntax error for application' do
-      expect {
-        parse('application test {}')
-      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
-    end
-
-    it 'produces a syntax error for capability mapping' do
-      expect {
-        parse('Foo produces Sql {}')
-      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces'/)
-    end
-
     it 'produces an error for collect expressions with virtual query' do
       acceptor = validate(parse("User <| title == 'admin' |>"))
       expect(acceptor.error_count).to eql(1)
@@ -410,12 +398,6 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
-    it 'produces a syntax error for site definitions' do
-      expect {
-        parse('site {}')
-      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site'/)
-    end
-
     context 'validating apply() blocks' do
       it 'allows empty apply() blocks' do
         acceptor = validate(parse('apply("foo.example.com") { }'))
@@ -468,18 +450,6 @@ describe "validating 4x" do
         expect(acceptor.error_count).to eql(0)
       end
 
-      it 'produces a syntax error for application' do
-        expect {
-          parse('apply("foo.example.com") { application test {} }')
-        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
-      end
-
-      it 'produces a syntax error for capability mapping' do
-        expect {
-          parse('apply("foo.example.com") { Foo produces Sql {} }')
-        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces'/)
-      end
-
       it 'produces an error for class expressions' do
         acceptor = validate(parse('apply("foo.example.com") { class test {} }'))
         expect(acceptor.error_count).to eql(1)
@@ -503,12 +473,6 @@ describe "validating 4x" do
         expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
       end
 
-      it 'produces an error for site definitions' do
-        expect {
-          parse('apply("foo.example.com") { site {} }')
-        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site'/)
-      end
-
       it 'produces an error for apply() inside apply()' do
         acceptor = validate(parse('apply("foo.example.com") { apply("foo.example.com") { } }'))
         expect(acceptor.error_count).to eql(1)
@@ -1010,14 +974,27 @@ describe "validating 4x" do
         expect(acceptor.errors[2].source_pos.line).to eql(5)
       end
     end
-  end
+    [
+      "application",
+      "consumes",
+      "produces",
+      "site",
+    ].each do |kw|
+      it "allow usage of #{kw} keyword (it was reserved in puppet 6.x)" do
+        source = <<-SOURCE
+       class foo (
+         $#{kw},
+       ) {
+         notice $#{kw}
+       }
+
+       class { foo:
+         #{kw} => 'bar'
+       }
+     SOURCE
 
-  context "capability annotations" do
-    ['produces', 'consumes'].each do |word|
-      it "raises a syntax error in #{word} clauses" do
-        expect {
-          parse("foo #{word} Bar {}")
-        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{word}'/)
+        acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
+        expect(acceptor.error_count).to eql(0)
       end
     end
   end

data/spec/unit/provider/group/groupadd_spec.rb

@@ -198,7 +198,10 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
   end
 
   describe "#findgroup" do
-    before { allow(File).to receive(:read).with('/etc/group').and_return(content) }
+    before do
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/group').and_return(true)
+      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/group').and_yield(content)
+    end
 
     let(:content) { "sample_group_name:sample_password:sample_gid:sample_user_list" }
     let(:output) do
@@ -221,7 +224,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
     end
 
     it "reads the group file only once per resource" do
-      expect(File).to receive(:read).with('/etc/group').once
+      expect(Puppet::FileSystem).to receive(:each_line).with('/etc/group').once
       5.times { provider.send(:findgroup, :group_name, 'sample_group_name') }
     end
   end

data/spec/unit/provider/package/apt_spec.rb

@@ -115,24 +115,12 @@ Version table:
       allow(provider).to receive(:dpkgquery).and_return("name: #{resource.name}" )
     end
 
-    context "when package is manual marked" do
-      before do
-        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
-      end
-
-      it 'sets mark to manual' do
-        result = provider.query
-        expect(result[:mark]).to eql(:manual)
-      end
-    end
-
-    context 'when package is not manual marked ' do
-      before do
-        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
-      end
 
+    context 'when package is not installed on the system' do
       it 'does not set mark to manual' do
         result = provider.query
+
+        expect(described_class).not_to receive(:aptmark)
         expect(result[:mark]).to be_nil
       end
     end
@@ -289,5 +277,26 @@ Version table:
 
       provider.install
     end
+
+    it "should install using the source attribute if present" do
+      resource[:ensure] = :installed
+      resource[:source] = '/my/local/package/file'
+
+      expect(provider).to receive(:aptget).with(any_args, :install, resource[:source])
+      expect(provider).to receive(:properties).and_return({:mark => :none})
+
+      provider.install
+    end
+
+    it "should install specific version using the source attribute if present" do
+      resource[:ensure] = '1.2.3'
+      resource[:source] = '/my/local/package/file'
+
+      expect(provider).to receive(:aptget).with(any_args, :install, resource[:source])
+      expect(provider).to receive(:properties).and_return({:mark => :none})
+      expect(provider).to receive(:query).and_return({:ensure => '1.2.3'})
+
+      provider.install
+    end
   end
 end

data/spec/unit/provider/package/aptitude_spec.rb

@@ -13,7 +13,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
 
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
-      allow(described_class).to receive(:aptmark).with('showmanual').and_return("")
+      allow(described_class).to receive(:aptmark).with('showmanual', 'faff').and_return("")
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",

data/spec/unit/provider/package/dnfmodule_spec.rb

@@ -45,12 +45,14 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
     before(:each) do
       expect(Puppet::Type::Package::ProviderDnfmodule).to receive(:execute)
           .with(["/usr/bin/dnf", "--version"])
-          .and_return(dnf_version).at_most(:once)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(dnf_version, 0)).at_most(:once)
       expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/usr/bin/dnf", "--version"], execute_options)
           .and_return(Puppet::Util::Execution::ProcessOutput.new(dnf_version, 0))
     end
 
+    before(:each) { described_class.instance_variable_set("@current_version", nil) }
+
     describe "with a supported dnf version" do
       it "correctly parses the version" do
         expect(described_class.current_version).to eq('4.0.9')
@@ -69,8 +71,6 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         DNF_OUTPUT
       end
 
-      before(:each) { described_class.instance_variable_set("@current_version", nil) }
-
       it "correctly parses the version" do
         expect(described_class.current_version).to eq('2.7.5')
       end
@@ -123,7 +123,7 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         provider.install
       end
 
-      it "should just enable the module if it has no default profile" do
+      it "should just enable the module if it has no default profile(missing groups or modules)" do
         dnf_exception = Puppet::ExecutionFailure.new("Error: Problems in request:\nmissing groups or modules: #{resource[:name]}")
         allow(provider).to receive(:execute).with(array_including('install')).and_raise(dnf_exception)
         resource[:ensure] = :present
@@ -132,6 +132,15 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         provider.install
       end
 
+      it "should just enable the module if it has no default profile(broken groups or modules)" do
+        dnf_exception = Puppet::ExecutionFailure.new("Error: Problems in request:\nbroken groups or modules: #{resource[:name]}")
+        allow(provider).to receive(:execute).with(array_including('install')).and_raise(dnf_exception)
+        resource[:ensure] = :present
+        expect(provider).to receive(:execute).with(array_including('install')).ordered
+        expect(provider).to receive(:execute).with(array_including('enable')).ordered
+        provider.install
+      end
+
       it "should just enable the module if enable_only = true" do
         resource[:ensure] = :present
         resource[:enable_only] = true

data/spec/unit/provider/package/gem_spec.rb

@@ -468,13 +468,15 @@ context Puppet::Type.type(:package).provider(:gem) do
   end
 
   context 'calculated specificity' do
+    include_context 'provider specificity'
+
     context 'when is not defaultfor' do
       subject { described_class.specificity }
       it { is_expected.to eql 1 }
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) { Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip2_spec.rb

@@ -18,13 +18,15 @@ describe Puppet::Type.type(:package).provider(:pip2) do
   end
 
   context 'calculated specificity' do
+    include_context 'provider specificity'
+
     context 'when is not defaultfor' do
       subject { described_class.specificity }
       it { is_expected.to eql 1 }
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) { Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip3_spec.rb

@@ -18,13 +18,15 @@ describe Puppet::Type.type(:package).provider(:pip3) do
   end
 
   context 'calculated specificity' do
+    include_context 'provider specificity'
+
     context 'when is not defaultfor' do
       subject { described_class.specificity }
       it { is_expected.to eql 1 }
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) { Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip_spec.rb

@@ -448,13 +448,15 @@ describe Puppet::Type.type(:package).provider(:pip) do
   end
 
   context 'calculated specificity' do
+    include_context 'provider specificity'
+
     context 'when is not defaultfor' do
       subject { described_class.specificity }
       it { is_expected.to eql 1 }
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) { Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity