puppet 6.20.0-x86-mingw32 → 7.4.0-x86-mingw32

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

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -629,7 +629,7 @@ module Serialization
     it 'the value of a type description is something other than a String or a Hash' do
       expect do
         from_converter.convert({ '__ptype' => { '__ptype' => 'Pcore::TimestampType', '__pvalue' => 12345 }})
-      end.to raise_error(/Cannot create a Pcore::TimestampType from a (Fixnum|Integer)/)
+      end.to raise_error(/Cannot create a Pcore::TimestampType from a Integer/)
     end
   end
 end

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

@@ -141,11 +141,11 @@ describe 'The type calculator' do
 
   context 'when inferring ruby' do
 
-    it 'fixnum translates to PIntegerType' do
+    it 'integer translates to PIntegerType' do
       expect(calculator.infer(1).class).to eq(PIntegerType)
     end
 
-    it 'large fixnum (or bignum depending on architecture) translates to PIntegerType' do
+    it 'large integer translates to PIntegerType' do
       expect(calculator.infer(2**33).class).to eq(PIntegerType)
     end
 
@@ -329,7 +329,7 @@ describe 'The type calculator' do
         expect(object_t('name' => 'DerivedObjectArray')).to be_instance(derived_object)
       end
 
-      it 'with fixnum values translates to PArrayType[PIntegerType]' do
+      it 'with integer values translates to PArrayType[PIntegerType]' do
         expect(calculator.infer([1,2]).element_type.class).to eq(PIntegerType)
       end
 
@@ -407,7 +407,7 @@ describe 'The type calculator' do
         expect(et.class).to eq(PEnumType)
       end
 
-      it 'with array of string values and array of fixnums translates to PArrayType[PArrayType[PScalarDataType]]' do
+      it 'with array of string values and array of integers translates to PArrayType[PArrayType[PScalarDataType]]' do
         et = calculator.infer([['first', 'array'], [1,2]])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
@@ -425,7 +425,7 @@ describe 'The type calculator' do
         expect(et.class).to eq(PEnumType)
       end
 
-      it 'with hash of string values and hash of fixnums translates to PArrayType[PHashType[PScalarDataType]]' do
+      it 'with hash of string values and hash of integers translates to PArrayType[PHashType[PScalarDataType]]' do
         et = calculator.infer([{:first => 'first', :second => 'second' }, {:first => 1, :second => 2 }])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
@@ -489,7 +489,7 @@ describe 'The type calculator' do
         expect(calculator.infer({'first' => 1, 'second' => 2}).key_type.class).to eq(PEnumType)
       end
 
-      it 'with fixnum values translates to PHashType[key, PIntegerType]' do
+      it 'with integer values translates to PHashType[key, PIntegerType]' do
         expect(calculator.infer({:first => 1, :second => 2}).value_type.class).to eq(PIntegerType)
       end
 

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

@@ -151,7 +151,7 @@ describe 'The type factory' do
       expect(hc.class_name).to eq('x')
     end
 
-    it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
+    it 'array_of(integer) returns PArrayType[PIntegerType]' do
       at = TypeFactory.array_of(1)
       expect(at.class()).to eq(PArrayType)
       expect(at.element_type.class).to eq(PIntegerType)

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

@@ -179,17 +179,17 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a warning for virtual class resource' do
+    it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for exported class resource' do
+    it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
@@ -310,17 +310,17 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
 
-    it 'produces a warning for virtual class resource' do
+    it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for exported class resource' do
+    it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
   end
@@ -344,16 +344,16 @@ describe "validating 4x" do
       end
     end
 
-    it 'produces an error for application' do
-      acceptor = validate(parse('application test {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for application' do
+      expect {
+        parse('application test {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
     end
 
-    it 'produces an error for capability mapping' do
-      acceptor = validate(parse('Foo produces Sql {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    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
@@ -410,10 +410,10 @@ 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
-      acceptor = validate(parse('site {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    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
@@ -468,16 +468,16 @@ describe "validating 4x" do
         expect(acceptor.error_count).to eql(0)
       end
 
-      it 'produces an error for application' do
-        acceptor = validate(parse('apply("foo.example.com") { application test {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      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 an error for capability mapping' do
-        acceptor = validate(parse('apply("foo.example.com") { Foo produces Sql {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      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
@@ -504,9 +504,9 @@ describe "validating 4x" do
       end
 
       it 'produces an error for site definitions' do
-        acceptor = validate(parse('apply("foo.example.com") { site {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+        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
@@ -669,6 +669,15 @@ describe "validating 4x" do
     'regexp',
     'pattern',
     'runtime',
+    'init',
+    'object',
+    'sensitive',
+    'semver',
+    'semverrange',
+    'string',
+    'timestamp',
+    'timespan',
+    'typeset',
     ].each do |name|
 
       it "produces an error for 'class #{name}'" do
@@ -693,6 +702,7 @@ describe "validating 4x" do
       source = "type('a', 'b')"
       expect(validate(parse(source))).not_to have_any_issues
     end
+
     it "should allow using the 'type' as the name of a function with no parameters and a block" do
       source = "type() |$x| { $x }"
       expect(validate(parse(source))).not_to have_any_issues
@@ -968,6 +978,18 @@ describe "validating 4x" do
       end
     end
 
+    it "allows a reserved type name" do
+      source = <<-SOURCE
+      class foo {
+        define string() {}
+        foo::string { 'a': }
+      }
+      SOURCE
+
+      acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
+      expect(acceptor.error_count).to eql(0)
+    end
+
     it "will give multiple errors in one file with multiple issues" do
       source = <<-SOURCE
       class foo {}
@@ -992,17 +1014,10 @@ describe "validating 4x" do
 
   context "capability annotations" do
     ['produces', 'consumes'].each do |word|
-      it "rejects illegal resource types in #{word} clauses" do
-        expect(validate(parse("foo produces Bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-      end
-
-      it "accepts legal resource and capability types in #{word} clauses" do
-        expect(validate(parse("Foo produces Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-        expect(validate(parse("Mod::Foo produces ::Mod2::Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-      end
-
-      it "rejects illegal capability types in #{word} clauses" do
-        expect(validate(parse("Foo produces bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+      it "raises a syntax error in #{word} clauses" do
+        expect {
+          parse("foo #{word} Bar {}")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{word}'/)
       end
     end
   end

data/spec/unit/pops/visitor_spec.rb

@@ -39,7 +39,7 @@ describe Puppet::Pops::Visitor do
 
     it "should select method for superclass" do
       duck_processor = DuckProcessor.new
-      expect(duck_processor.hi(42)).to match(/Howdy (?:Fixnum|Integer)/)
+      expect(duck_processor.hi(42)).to match(/Howdy Integer/)
     end
 
     it "should select method for superclass" do