puppet 7.4.0-x86-mingw32 → 7.8.0-x86-mingw32

data/spec/unit/network/http/api/{master → server}/v3/environments_spec.rb

@@ -4,12 +4,12 @@ require 'puppet/node/environment'
 require 'puppet/network/http'
 require 'matchers/json'
 
-describe Puppet::Network::HTTP::API::Master::V3::Environments do
+describe Puppet::Network::HTTP::API::Server::V3::Environments do
   include JSONMatchers
 
   let(:environment) { Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests') }
   let(:loader) { Puppet::Environments::Static.new(environment) }
-  let(:handler) { Puppet::Network::HTTP::API::Master::V3::Environments.new(loader) }
+  let(:handler) { Puppet::Network::HTTP::API::Server::V3::Environments.new(loader) }
   let(:request) { Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }) }
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 

data/spec/unit/network/http/api/{master → server}/v3_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet_spec/network'
 
-describe Puppet::Network::HTTP::API::Master::V3 do
+describe Puppet::Network::HTTP::API::Server::V3 do
   include PuppetSpec::Network
 
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
-  let(:master_url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3" }
-  let(:master_routes) {
+  let(:server_url_prefix) { "#{Puppet::Network::HTTP::SERVER_URL_PREFIX}/v3" }
+  let(:server_routes) {
     Puppet::Network::HTTP::Route.
-        path(Regexp.new("#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/")).
+        path(Regexp.new("#{Puppet::Network::HTTP::SERVER_URL_PREFIX}/")).
         any.
-        chain(Puppet::Network::HTTP::API::Master::V3.routes)
+        chain(Puppet::Network::HTTP::API::Server::V3.routes)
   }
 
   # simulate puppetserver registering its authconfigloader class
@@ -26,53 +26,53 @@ describe Puppet::Network::HTTP::API::Master::V3 do
   end
 
   it "mounts the environments endpoint" do
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/environments")
-    master_routes.process(request, response)
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_url_prefix}/environments")
+    server_routes.process(request, response)
 
     expect(response.code).to eq(200)
   end
 
   it "matches only complete routes" do
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/foo/environments")
-    expect { master_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_url_prefix}/foo/environments")
+    expect { server_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
 
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/foo/environment/production")
-    expect { master_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_url_prefix}/foo/environment/production")
+    expect { server_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
   end
 
   it "mounts indirected routes" do
     request = Puppet::Network::HTTP::Request.
-        from_hash(:path => "#{master_url_prefix}/node/foo",
+        from_hash(:path => "#{server_url_prefix}/node/foo",
                   :params => {:environment => "production"},
                   :headers => {"accept" => "application/json"})
-    master_routes.process(request, response)
+    server_routes.process(request, response)
 
     expect(response.code).to eq(200)
   end
 
   it "responds to unknown paths by raising not_found_error" do
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/unknown")
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_url_prefix}/unknown")
 
     expect {
-      master_routes.process(request, response)
+      server_routes.process(request, response)
     }.to raise_error(not_found_error)
   end
 
   it "checks authorization for indirected routes" do
     Puppet::Network::Authorization.authconfigloader_class = nil
 
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/catalog/foo")
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_url_prefix}/catalog/foo")
     expect {
-      master_routes.process(request, response)
+      server_routes.process(request, response)
     }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, %r{Not Authorized: Forbidden request: /puppet/v3/catalog/foo \(method GET\)})
   end
 
   it "checks authorization for environments" do
     Puppet::Network::Authorization.authconfigloader_class = nil
 
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/environments")
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{server_url_prefix}/environments")
     expect {
-      master_routes.process(request, response)
+      server_routes.process(request, response)
     }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, %r{Not Authorized: Forbidden request: /puppet/v3/environments \(method GET\)})
   end
 end

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

@@ -125,6 +125,24 @@ describe 'Semantic Versions' do
         expect(eval_and_collect_notices(code)).to eql(['true', 'false'])
       end
 
+      it 'can be compared to another instance created from arguments' do
+        code = <<-CODE
+          $x = SemVer('1.2.3-rc4+5')
+          $y = SemVer(1, 2, 3, 'rc4', '5')
+          notice($x == $y)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+
+      it 'can be compared to another instance created from a hash' do
+        code = <<-CODE
+          $x = SemVer('1.2.3-rc4+5')
+          $y = SemVer(major => 1, minor => 2, patch => 3, prerelease => 'rc4', build => '5')
+          notice($x == $y)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+
       it 'can be compared to another instance for magnitude' do
         code = <<-CODE
           $x = SemVer('1.1.1')

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

@@ -113,6 +113,24 @@ describe 'Sensitive Type' do
       expect(eval_and_collect_notices(code)).to eq(['Sensitive[Integer] != Sensitive[String]'])
     end
 
+    it 'equals another instance with the same value' do
+      code =<<-CODE
+        $i = Sensitive('secret')
+        $o = Sensitive('secret')
+        notice($i == $o)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
+    it 'has equal hash keys for same values' do
+      code =<<-CODE
+        $i = Sensitive('secret')
+        $o = Sensitive('secret')
+        notice({$i => 1} == {$o => 1})
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
     it 'can be created from another sensitive instance ' do
       code =<<-CODE
         $o = Sensitive("hunter2")

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