puppet 6.19.1-universal-darwin → 7.0.0-universal-darwin

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

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 require 'puppet_spec/handler'
 require 'puppet/indirector_testing'
-require 'puppet/network/authorization'
 require 'puppet/network/http'
 
 describe Puppet::Network::HTTP::Handler do
@@ -102,11 +101,6 @@ describe Puppet::Network::HTTP::Handler do
       { :status => 200 }
     end
 
-    before do
-      allow(handler).to receive(:check_authorization)
-      allow(handler).to receive(:warn_if_near_expiration)
-    end
-
     it "should setup a profiler when the puppet-profiling header exists" do
       request = a_request
       request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"

data/spec/unit/network/http_pool_spec.rb

@@ -69,10 +69,6 @@ describe Puppet::Network::HttpPool do
       expect(Puppet::Network::HttpPool.http_instance("me", 54321, true)).to be_use_ssl
     end
 
-    it 'has an http_ssl_instance method' do
-      expect(Puppet::Network::HttpPool.http_ssl_instance("me", 54321)).to be_use_ssl
-    end
-
     context "when calling 'connection'" do
       it 'requires an ssl_context' do
         expect {

data/spec/unit/node/environment_spec.rb

@@ -526,34 +526,46 @@ describe Puppet::Node::Environment do
   end
 
   describe "managing module translations" do
-    it "creates a new text domain the first time we try to use the text domain" do
-      expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
-      expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
-      expect(Puppet::GettextConfig).to receive(:clear_text_domain)
+    context "when i18n is enabled" do
+      before(:each) do
+        Puppet[:disable_i18n] = false
+      end
 
-      env.with_text_domain do; end
-    end
+      it "yields block results" do
+        ran = false
+        expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+        expect(ran).to eq(true)
+      end
 
-    it "uses the existing text domain once it has been created" do
-      env.with_text_domain do; end
+      it "creates a new text domain the first time we try to use the text domain" do
+        expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
+        expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
+        expect(Puppet::GettextConfig).to receive(:clear_text_domain)
 
-      expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
-      env.with_text_domain do; end
-    end
+        env.with_text_domain do; end
+      end
 
-    it "yields block results" do
-      ran = false
-      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
-      expect(ran).to eq(true)
+      it "uses the existing text domain once it has been created" do
+        env.with_text_domain do; end
+
+        expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
+        env.with_text_domain do; end
+      end
     end
 
-    it "yields block results when i18n is disabled" do
-      Puppet[:disable_i18n] = true
+    context "when i18n is disabled" do
+      it "yields block results" do
+        ran = false
+        expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+        expect(ran).to eq(true)
+      end
+
+      it "does not create a new text domain the first time we try to use the text domain" do
+        expect(Puppet::GettextConfig).not_to receive(:reset_text_domain)
+        expect(Puppet::ModuleTranslations).not_to receive(:load_from_modulepath)
 
-      ran = false
-      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
-      expect(ran).to eq(true)
+        env.with_text_domain do; end
+      end
     end
   end
-
 end

data/spec/unit/node_spec.rb

@@ -417,64 +417,12 @@ end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
-    Puppet[:strict_hostname_checking] = false
     @node = Puppet::Node.new("foo.domain.com",
                              :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
-  it "returns an array of names" do
+  it "returns an array of one name" do
     expect(@node.names).to be_instance_of(Array)
-  end
-
-  describe "and the node name is fully qualified" do
-    it "contains an entry for each part of the node name" do
-      expect(@node.names).to include("foo.domain.com")
-      expect(@node.names).to include("foo.domain")
-      expect(@node.names).to include("foo")
-    end
-  end
-
-  it "includes the node's fqdn" do
-    expect(@node.names).to include("yay.domain.com")
-  end
-
-  it "combines and include the node's hostname and domain if no fqdn is available" do
-    expect(@node.names).to include("yay.domain.com")
-  end
-
-  it "contains an entry for each name available by stripping a segment of the fqdn" do
-    @node.parameters["fqdn"] = "foo.deep.sub.domain.com"
-    expect(@node.names).to include("foo.deep.sub.domain")
-    expect(@node.names).to include("foo.deep.sub")
-  end
-
-  describe "and :node_name is set to 'cert'" do
-    before do
-      Puppet[:node_name] = "cert"
-    end
-
-    it "uses the passed-in key as the first value" do
-      expect(@node.names[0]).to eq("foo.domain.com")
-    end
-
-    describe "and strict hostname checking is enabled" do
-      before do
-        Puppet[:strict_hostname_checking] = true
-      end
-
-      it "only uses the passed-in key" do
-        expect(@node.names).to eq(["foo.domain.com"])
-      end
-    end
-  end
-
-  describe "and :node_name is set to 'facter'" do
-    before do
-      Puppet[:node_name] = "facter"
-    end
-
-    it "uses the node's 'hostname' fact as the first value" do
-      expect(@node.names[0]).to eq("yay")
-    end
+    expect(@node.names).to eq ["foo.domain.com"]
   end
 end

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

@@ -257,31 +257,13 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:class, "bar")).not_to be_nil
     end
 
-    [:off, :warning].each do | strictness |
-      it "should warn if strict = #{strictness} and class is exported" do
-        Puppet[:strict] = strictness
-        collect_notices('class test{} create_resources("@@class", {test => {}})')
-        expect(warnings).to include(/Classes are not virtualizable/)
-      end
-    end
-
-    it 'should error if strict = error and class is exported' do
-      Puppet[:strict] = :error
+    it 'should error if class is exported' do
       expect{
         compile_to_catalog('class test{} create_resources("@@class", {test => {}})')
       }.to raise_error(/Classes are not virtualizable/)
     end
 
-    [:off, :warning].each do | strictness |
-      it "should warn if strict = #{strictness} and class is virtual" do
-        Puppet[:strict] = strictness
-        collect_notices('class test{} create_resources("@class", {test => {}})')
-        expect(warnings).to include(/Classes are not virtualizable/)
-      end
-    end
-
-    it 'should error if strict = error and class is virtual' do
-      Puppet[:strict] = :error
+    it 'should error if class is virtual' do
       expect{
         compile_to_catalog('class test{} create_resources("@class", {test => {}})')
       }.to raise_error(/Classes are not virtualizable/)

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

@@ -818,14 +818,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
     end
 
-    # Integer for >= 2.4.0, otherwise Fixnum
-    int_class_name = 0.class.name
-
     # Errors when wrong number/type of keys are used
     {
-      "Array[0]"                    => "Array-Type[] arguments must be types. Got #{int_class_name}",
-      "Hash[0]"                     => "Hash-Type[] arguments must be types. Got #{int_class_name}",
-      "Hash[Integer, 0]"            => "Hash-Type[] arguments must be types. Got #{int_class_name}",
+      "Array[0]"                    => "Array-Type[] arguments must be types. Got Integer",
+      "Hash[0]"                     => "Hash-Type[] arguments must be types. Got Integer",
+      "Hash[Integer, 0]"            => "Hash-Type[] arguments must be types. Got Integer",
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
@@ -833,7 +830,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'abc'[1.0]"                  => "A substring operation does not accept a Float as a character index. Expected an Integer",
       "'abc'[1, x]"                 => "A substring operation does not accept a String as a character index. Expected an Integer",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
-      "NotUndef[0]"                 => "NotUndef-Type[] argument must be a Type or a String. Got #{int_class_name}",
+      "NotUndef[0]"                 => "NotUndef-Type[] argument must be a Type or a String. Got Integer",
       "NotUndef[a,b]"               => 'NotUndef-Type[] accepts 0 to 1 arguments. Got 2',
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',

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

@@ -575,27 +575,6 @@ describe 'loaders' do
     end
   end
 
-context 'when a 3x load has illegal construct and --func3x_check is false' do
-  let(:env) { environment_for(mix_4x_and_3x_functions) }
-  let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
-  let(:scope) { compiler.topscope }
-  let(:loader) { compiler.loaders.private_loader_for_module('user') }
-
-  before(:each) do
-    Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
-    Puppet[:func3x_check] = false
-  end
-  after(:each) do
-    Puppet.pop_context
-    Puppet[:func3x_check] = true
-  end
-
-  it "an illegal function is loaded" do
-      f = loader.load_typed(typed_name(:function, 'bad_func_load3')).value
-      expect(f.call(scope)).to eql("some return value")
-  end
-end
-
   context 'when causing a 3x load followed by a 4x load' do
     let(:env) { environment_for(mix_4x_and_3x_functions) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
@@ -623,6 +602,12 @@ end
       function = loader.load_typed(typed_name(:function, 'callee_ws')).value
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
     end
+
+    it "an illegal function is loaded" do
+      expect {
+        loader.load_typed(typed_name(:function, 'bad_func_load3')).value
+      }.to raise_error(SecurityError, /Illegal method definition of method 'bad_func_load3_illegal_method' on line 8 in legacy function/)
+    end
   end
 
   context 'loading' do

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

@@ -5,27 +5,9 @@ require_relative 'parser_rspec_helper'
 describe "egrammar parsing of 'application'" do
   include ParserRspecHelper
 
-  it "an empty body" do
-    expect(dump(parse("application foo { }"))).to eq("(application foo () ())")
-  end
-
-  it "an empty body" do
-    prog = <<-EPROG
-application foo {
-  db { one:
-    password => 'secret'
-  }
-}
-EPROG
-    expect(dump(parse(prog))).to eq( [
-"(application foo () (block",
-"  (resource db",
-"    (one",
-"      (password => 'secret')))", "))" ].join("\n"))
-  end
-
-  it "accepts parameters" do
-    s = "application foo($p1 = 'yo', $p2) { }"
-    expect(dump(parse(s))).to eq("(application foo ((= p1 'yo') p2) ())")
+  it "raises a syntax error" do
+    expect {
+      parse("application foo { }")
+    }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application' \(line: 1, column: 1\)/)
   end
 end

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

@@ -191,7 +191,6 @@ describe "egrammar parsing basic expressions" do
 
     {
       'keyword' => %w(type function),
-      'reserved word' => %w(application site produces consumes)
     }.each_pair do |word_type, words|
       words.each do |word|
         it "allows the #{word_type} '#{word}' in a list" do

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

@@ -6,31 +6,18 @@ describe "egrammar parsing of capability mappings" do
   include ParserRspecHelper
 
   context "when parsing 'produces'" do
-    it "the ast contains produces and attributes" do
-      prog = "Foo produces Sql { name => value }"
-      ast = "(produces Foo Sql ((name => value)))"
-      expect(dump(parse(prog))).to eq(ast)
-    end
-
-    it "optional end comma is allowed" do
-      prog = "Foo produces Sql { name => value, }"
-      ast = "(produces Foo Sql ((name => value)))"
-      expect(dump(parse(prog))).to eq(ast)
+    it "raises syntax error" do
+      expect {
+        parse("Foo produces Sql { name => value }")
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces' \(line: 1, column: 5\)/)
     end
   end
 
   context "when parsing 'consumes'" do
-    it "the ast contains consumes and attributes" do
-      prog = "Foo consumes Sql { name => value }"
-      ast = "(consumes Foo Sql ((name => value)))"
-      expect(dump(parse(prog))).to eq(ast)
+    it "raises syntax error" do
+      expect {
+        parse("Foo consumes Sql { name => value }")
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'consumes' \(line: 1, column: 5\)/)
     end
-
-    it "optional end comma is allowed" do
-      prog = "Foo consumes Sql { name => value, }"
-      ast = "(consumes Foo Sql ((name => value)))"
-      expect(dump(parse(prog))).to eq(ast)
-    end
-
   end
 end

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

@@ -6,41 +6,37 @@ describe "egrammar parsing of site expression" do
   include ParserRspecHelper
 
   context "when parsing 'site'" do
-    it "an empty body is allowed" do
-      prog = "site { }"
-      ast = "(site ())"
-      expect(dump(parse(prog))).to eq(ast)
-    end
-
-    it "a body with one expression is allowed" do
-      prog = "site { $x = 1 }"
-      ast = "(site (block\n  (= $x 1)\n))"
-      expect(dump(parse(prog))).to eq(ast)
-    end
-
-    it "a body with more than one expression is allowed" do
-      prog = "site { $x = 1 $y = 2}"
-      ast = "(site (block\n  (= $x 1)\n  (= $y 2)\n))"
-      expect(dump(parse(prog))).to eq(ast)
+    it "raises a syntax error" do
+      expect {
+        parse("site { }")
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site' \(line: 1, column: 1\)/)
     end
   end
 
   context 'When parsing collections containing application management specific keywords' do
     %w(application site produces consumes).each do |keyword|
-      it "allows the keyword '#{keyword}' in a list" do
-        expect(dump(parse("$a = [#{keyword}]"))).to(eq("(= $a ([] '#{keyword}'))"))
+      it "disallows the keyword '#{keyword}' in a list" do
+        expect {
+          parse("$a = [#{keyword}]")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{keyword}' \(line: 1, column: 7\)/)
       end
 
-      it "allows the keyword '#{keyword}' as a key in a hash" do
-        expect(dump(parse("$a = {#{keyword}=>'x'}"))).to(eq("(= $a ({} ('#{keyword}' 'x')))"))
+      it "disallows the keyword '#{keyword}' as a key in a hash" do
+        expect {
+          parse("$a = {#{keyword}=>'x'}")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{keyword}' \(line: 1, column: 7\)/)
       end
 
-      it "allows the keyword '#{keyword}' as a value in a hash" do
-        expect(dump(parse("$a = {'x'=>#{keyword}}"))).to(eq("(= $a ({} ('x' '#{keyword}')))"))
+      it "disallows the keyword '#{keyword}' as a value in a hash" do
+        expect {
+          parse("$a = {'x'=>#{keyword}}")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{keyword}' \(line: 1, column: 12\)/)
       end
 
-      it "allows the keyword '#{keyword}' as an attribute name" do
-        expect(dump(parse("foo { 'x': #{keyword} => 'value' } "))).to eql("(resource foo\n  ('x'\n    (#{keyword} => 'value')))")
+      it "disallows the keyword '#{keyword}' as an attribute name" do
+        expect {
+          parse("foo { 'x': #{keyword} => 'value' } ")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{keyword}' \(line: 1, column: 12\)/)
       end
     end
   end

data/spec/unit/pops/resource/resource_type_impl_spec.rb

@@ -32,77 +32,6 @@ describe "Puppet::Pops::Resource" do
       expect(rt.valid_parameter?(:loglevel)).to be_truthy
     end
   end
-
-
-  context 'when used with capability resource with producers/consumers' do
-    include PuppetSpec::Files
-
-    let!(:env_name) { 'spec' }
-    let!(:env_dir) { tmpdir('environments') }
-    let!(:populated_env_dir) do
-      dir_contained_in(env_dir, env_name => {
-        '.resource_types' => {
-          'capability.pp' => <<-PUPPET
-            Puppet::Resource::ResourceType3.new(
-              'capability',
-              [],
-              [Puppet::Resource::Param(Any, 'name', true)],
-              { /(.*)/ => ['name'] },
-              true,
-              true)
-        PUPPET
-        },
-        'modules' => {
-          'test' => {
-            'lib' => {
-              'puppet' => {
-                'type' => { 'capability.rb' => <<-RUBY
-                  Puppet::Type.newtype(:capability, :is_capability => true) do
-                    newparam :name, :namevar => true
-                    raise Puppet::Error, 'Ruby resource was loaded'
-                  end
-                RUBY
-                }
-              }
-            }
-          }
-        }
-      })
-    end
-
-    let!(:code) { <<-PUPPET }
-      define producer() {
-        notify { "producer":}
-      }
-
-      define consumer() {
-        notify { $title:}
-      }
-
-      Producer produces Capability {}
-
-      Consumer consumes Capability {}
-
-      producer {x: export => Capability[cap]}
-      consumer {x: consume => Capability[cap]}
-      consumer {y: require => Capability[cap]}
-    PUPPET
-
-    let(:environments) { Puppet::Environments::Directories.new(populated_env_dir, []) }
-    let(:env) { Puppet::Node::Environment.create(:'spec', [File.join(env_dir, 'spec', 'modules')]) }
-    let(:node) { Puppet::Node.new('test', :environment => env) }
-    around(:each) do |example|
-      Puppet[:environment] = env_name
-      Puppet.override(:environments => environments, :current_environment => env) do
-        example.run
-      end
-      Puppet::Type.rmtype(:capability)
-    end
-
-    it 'does not load the Ruby resource' do
-      expect { compile_to_catalog(code, node) }.not_to raise_error
-    end
-  end
 end
 end
 end