puppet 6.25.0-x64-mingw32 → 7.0.0-x64-mingw32

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_containers_spec.rb

@@ -95,7 +95,18 @@ describe "egrammar parsing containers" do
         expect(dump(parse("class foo::default {}"))).to eq("(class foo::default ())")
       end
 
+      it "class class inherits default {} # inherits default", :broken => true do
+        expect {
+          parse("class class inherits default {}")
+        }.to raise_error(/not a valid classname/)
+      end
+
       it "class class inherits default {} # inherits default" do
+        # TODO: See previous test marked as :broken=>true, it is actually this test (result) that is wacky,
+        # this because a class is named at parse time (since class evaluation is lazy, the model must have the
+        # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
+        # I think it is wrong.)
+        #
         expect { parse("class class inherits default {}") }.to raise_error(/'class' keyword not allowed at this location/)
       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

@@ -559,29 +559,6 @@ module Serialization
         expect(warnings).to eql(["['key'] contains the special value default. It will be converted to the String 'default'"])
       end
     end
-    context 'and force_symbol set to true' do
-      let(:to_converter) { ToDataConverter.new(:rich_data => false, :force_symbol => true) }
-
-      it 'A Hash with Symbol values is converted to hash with Symbol values' do
-        val = { 'one' => :one, 'two' => :two }
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-
-          # write and read methods does not work here as we cannot force Symbols in Json.
-          # and a hash with symbol values cannot be an instance of Types::TypeFactory.data.
-          # Using YAML for this instead
-          io.reopen
-          value = to_converter.convert(val)
-          io << [value].to_yaml
-          io.rewind
-
-          val2 = from_converter.convert(YAML::load(io.read)[0])
-
-          expect(val2).to be_a(Hash)
-          expect(val2).to eql({ 'one' => :one, 'two' => :two })
-        end
-        expect(warnings).to be_empty
-      end
-    end
   end
 
   context 'with rich_data is set to true' do
@@ -652,42 +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
-  end
-
-  context 'when data is unknown' do
-    let(:to_converter) { ToDataConverter.new(:message_prefix => 'Test Hash') }
-    let(:logs) { [] }
-    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
-    let(:val) { Class.new }
-
-    context 'and :silence_warnings undefined or set to false' do
-      it 'convert the unknown data to string with warnings' do
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          write(val)
-          val2 = read
-          expect(val2).to be_a(String)
-          expect(val2).to match(/Class/)
-        end
-        expect(warnings).to eql([
-          "Test Hash contains a #{val.class} value. It will be converted to the String '#{val.to_s}'"])
-      end
-    end
-
-    context 'and :silence_warnings undefined or set to true' do
-      let(:to_converter) { ToDataConverter.new(:message_prefix => 'Test Hash', :silence_warnings => true) }
-
-      it 'convert the unknown data to string without warnings if silence_warnings set to true' do
-        val = Class.new
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          write(val)
-          val2 = read
-          expect(val2).to be_a(String)
-          expect(val2).to match(/Class/)
-        end
-        expect(warnings).to be_empty
-      end
+      end.to raise_error(/Cannot create a Pcore::TimestampType from a Integer/)
     end
   end
 end

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

@@ -154,9 +154,4 @@ describe 'ToStringifiedConverter' do
     unassigned = [243, 176, 128, 128].pack("C*").force_encoding(Encoding::UTF_8) 
     expect(transform(unassigned)).to eq("󰀀")
   end
-
-  it 'converts ProcessOutput objects to string' do
-    object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
-    expect(transform(object)).to be_instance_of(String)
-  end
 end

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

@@ -125,24 +125,6 @@ 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,24 +113,6 @@ 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_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
 
@@ -1980,12 +1980,6 @@ describe 'The type calculator' do
       expect(calculator.instance?(tuple, [1, 'a', 1])).to          eq(false)
     end
 
-    it 'should not consider ProcessOutput objects as instanceof PScalarDataType' do
-      object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
-      
-      expect(calculator.instance?(PScalarDataType::DEFAULT, object)).to eq(false)
-    end
-
     context 'and t is Struct' do
       it 'should consider hash[cont] as instance of Struct[cont-t]' do
         struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})

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

data/spec/unit/property_spec.rb

@@ -5,7 +5,6 @@ Puppet::Type.newtype(:property_test) do
   newparam(:name, isnamevar: true)
 end
 Puppet::Type.type(:property_test).provide(:property_test) do
-  attr_accessor :foo
 end
 
 describe Puppet::Property do