puppet 7.0.0-universal-darwin → 7.5.0-universal-darwin

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

@@ -240,20 +240,9 @@ describe Puppet::Parser::Compiler do
   end
 
   describe "when compiling" do
-    def compile_methods
-      [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
-        :finish, :store, :extract, :evaluate_relationships]
-    end
-
-    # Stub all of the main compile methods except the ones we're specifically interested in.
-    def compile_stub(*except)
-      (compile_methods - except).each { |m| allow(@compiler).to receive(m) }
-    end
-
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.topscope['a']).to eq("b")
       expect(@compiler.topscope['c']).to eq("d")
@@ -262,13 +251,11 @@ describe Puppet::Parser::Compiler do
     it "should set node parameters that are of Symbol type as String variables in the top scope" do
       params = {"a" => :b}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.topscope['a']).to eq("b")
     end
 
     it "should set the node's environment as a string variable in top scope" do
-      compile_stub(:set_node_parameters)
       @node.merge({'wat' => 'this is how the sausage is made'})
       @compiler.compile
       expect(@compiler.topscope['environment']).to eq("testing")
@@ -276,7 +263,6 @@ describe Puppet::Parser::Compiler do
     end
 
     it "sets the environment based on node.environment instead of the parameters" do
-      compile_stub(:set_node_parameters)
       @node.parameters['environment'] = "Not actually #{@node.environment.name}"
 
       @compiler.compile
@@ -286,23 +272,21 @@ describe Puppet::Parser::Compiler do
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.catalog.client_version).to eq("2")
       expect(@compiler.catalog.server_version).to eq("3")
     end
 
     it "should evaluate the main class if it exists" do
-      compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
+      @compiler.topscope.source = main_class
+
       expect(main_class).to receive(:evaluate_code).with(be_a(Puppet::Parser::Resource))
-      expect(@compiler.topscope).to receive(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
-      compile_stub(:evaluate_main)
       @compiler.compile
       expect(@known_resource_types.find_hostclass("")).to be_instance_of(Puppet::Resource::Type)
     end
@@ -325,7 +309,7 @@ describe Puppet::Parser::Compiler do
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
-      compile_stub(:evaluate_generators)
+      allow(@compiler).to receive(:fail_on_unevaluated)
       @compiler.compile
     end
 

data/spec/unit/parser/resource_spec.rb

@@ -418,22 +418,27 @@ describe Puppet::Parser::Resource do
   end
 
   describe "when merging overrides" do
+    def resource_type(name)
+      double(name, :child_of? => false)
+    end
+
     before do
-      @source = "source1"
+      @source = resource_type("source1")
       @resource = mkresource :source => @source
       @override = mkresource :source => @source
     end
 
     it "should fail when the override was not created by a parent class" do
-      @override.source = "source2"
-      expect(@override.source).to receive(:child_of?).with("source1").and_return(false)
+      @override.source = resource_type("source2")
+      expect(@override.source).to receive(:child_of?).with(@source).and_return(false)
       expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
-      @resource.source = "source3"
+      @source3 = resource_type("source3")
+      @resource.source = @source3
       @override.source = @resource.source
-      expect(@override.source).not_to receive(:child_of?).with("source3")
+      expect(@override.source).not_to receive(:child_of?).with(@source3)
       params = {:a => :b, :c => :d}
       expect(@override).to receive(:parameters).and_return(params)
       expect(@resource).to receive(:override_parameter).with(:b)
@@ -442,9 +447,10 @@ describe Puppet::Parser::Resource do
     end
 
     it "should succeed when a parent class created the override" do
-      @resource.source = "source3"
-      @override.source = "source4"
-      expect(@override.source).to receive(:child_of?).with("source3").and_return(true)
+      @source3 = resource_type("source3")
+      @resource.source = @source3
+      @override.source = resource_type("source4")
+      expect(@override.source).to receive(:child_of?).with(@source3).and_return(true)
       params = {:a => :b, :c => :d}
       expect(@override).to receive(:parameters).and_return(params)
       expect(@resource).to receive(:override_parameter).with(:b)

data/spec/unit/parser/templatewrapper_spec.rb

@@ -57,9 +57,10 @@ describe Puppet::Parser::TemplateWrapper do
     expect(tw.all_tags).to eq(["tag1","tag2"])
   end
 
-  it "provides the tags defined in the current scope with #tags" do
-    expect(scope).to receive(:tags).and_return(["tag1", "tag2"])
-    expect(tw.tags).to eq(["tag1","tag2"])
+  it "raises not implemented error" do
+    expect {
+      tw.tags
+    }.to raise_error(NotImplementedError, /Call 'all_tags' instead/)
   end
 
   it "raises error on access to removed in-scope variables via method calls" do

data/spec/unit/pops/evaluator/deferred_resolver_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe Puppet::Pops::Evaluator::DeferredResolver do
+  include PuppetSpec::Compiler
+
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:facts) { Puppet::Node::Facts.new('node.example.com') }
+
+  it 'resolves deferred values in a catalog' do
+    catalog = compile_to_catalog(<<~END)
+      notify { "deferred":
+        message => Deferred("join", [[1,2,3], ":"])
+      }
+    END
+    described_class.resolve_and_replace(facts, catalog)
+
+    expect(catalog.resource(:notify, 'deferred')[:message]).to eq('1:2:3')
+  end
+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/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