puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -24,13 +24,13 @@ describe 'the type asserter' do
   end
 
   it 'does not produce a string unless the assertion fails' do
-    expect(TypeAsserter).not_to receive(:report_type_mismatch)
+    TypeAsserter.expects(:report_type_mismatch).never
     asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 1)
   end
 
   it 'does not format string unless the assertion fails' do
     fmt_string = 'The %s in the %s'
-    expect(fmt_string).not_to receive(:'%')
+    fmt_string.expects(:'%').never
     asserter.assert_instance_of([fmt_string, 'gizmo', 'gadget'], PIntegerType::DEFAULT, 1)
   end
 

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

@@ -1723,13 +1723,13 @@ describe 'The type calculator' do
       end
 
       it 'a recursive alias can be assignable from a conformant type with any depth' do
-        scope = double
+        scope = {}
 
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'tree').and_return(t)
+        loader = mock
+        loader.expects(:load).with(:type, 'tree').returns t
 
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t.resolve(scope)
         expect(calculator.assignable?(t, parser.parse('Hash[String,Variant[String,Hash[String,Variant[String,String]]]]'))).to be_truthy
@@ -1737,15 +1737,15 @@ describe 'The type calculator' do
 
 
       it 'similar recursive aliases are assignable' do
-        scope = double
+        scope = {}
 
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree1]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree2]]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'tree1').and_return(t1)
-        expect(loader).to receive(:load).with(:type, 'tree2').and_return(t2)
+        loader = mock
+        loader.expects(:load).with(:type, 'tree1').returns t1
+        loader.expects(:load).with(:type, 'tree2').returns t2
 
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1.resolve(scope)
         t2.resolve(scope)
@@ -1755,11 +1755,11 @@ describe 'The type calculator' do
       it 'crossing recursive aliases are assignable' do
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree2]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree1]]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'tree1').and_return(t1)
-        expect(loader).to receive(:load).with(:type, 'tree2').and_return(t2)
+        loader = mock
+        loader.expects(:load).with(:type, 'tree1').returns t1
+        loader.expects(:load).with(:type, 'tree2').returns t2
 
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1.resolve(loader)
         t2.resolve(loader)
@@ -1767,12 +1767,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[T] is assignable to Type[AT] when AT is an alias for T' do
-        scope = double
+        scope = {}
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'positiveinteger').and_return(ta)
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveinteger').returns ta
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1 = type_t(range_t(0, :default))
         t2 = parser.parse('Type[PositiveInteger]', scope)
@@ -1780,12 +1780,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[T] is assignable to AT when AT is an alias for Type[T]' do
-        scope = double
+        scope = {}
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'positiveintegertype').and_return(ta)
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1 = type_t(range_t(0, :default))
         t2 = parser.parse('PositiveIntegerType', scope)
@@ -1793,12 +1793,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[Type[T]] is assignable to Type[Type[AT]] when AT is an alias for T' do
-        scope = double
+        scope = {}
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'positiveinteger').and_return(ta)
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveinteger').returns ta
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1 = type_t(type_t(range_t(0, :default)))
         t2 = parser.parse('Type[Type[PositiveInteger]]', scope)
@@ -1806,12 +1806,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[Type[T]] is assignable to Type[AT] when AT is an alias for Type[T]' do
-        scope = double
+        scope = {}
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'positiveintegertype').and_return(ta)
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1 = type_t(type_t(range_t(0, :default)))
         t2 = parser.parse('Type[PositiveIntegerType]', scope)
@@ -2122,10 +2122,10 @@ describe 'The type calculator' do
 
       it 'should consider x an instance of the aliased type that uses self recursion' do
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'tree').and_return(t)
+        loader = mock
+        loader.expects(:load).with(:type, 'tree').returns t
 
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t.resolve(loader)
         expect(calculator.instance?(t, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy
@@ -2134,11 +2134,11 @@ describe 'The type calculator' do
       it 'should consider x an instance of the aliased type that uses contains an alias that causes self recursion' do
         t1 = type_alias_t('Tree', 'Hash[String,Variant[String,OtherTree]]')
         t2 = type_alias_t('OtherTree', 'Hash[String,Tree]')
-        loader = double
-        expect(loader).to receive(:load).with(:type, 'tree').and_return(t1)
-        expect(loader).to receive(:load).with(:type, 'othertree').and_return(t2)
+        loader = mock
+        loader.expects(:load).with(:type, 'tree').returns t1
+        loader.expects(:load).with(:type, 'othertree').returns t2
 
-        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
+        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
 
         t1.resolve(loader)
         expect(calculator.instance?(t1, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy

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

@@ -244,15 +244,6 @@ describe 'the type mismatch describer' do
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
       /Class\[Test\]: parameter 'opts' expects size to be 1, got 0/))
   end
-
-  it "treats Optional as Optional[Any]" do
-    code = <<-PUPPET
-      class test(Optional $var=undef) {}
-      class { 'test': var => 'hello' }
-    PUPPET
-    expect { eval_and_collect_notices(code) }.not_to raise_error
-  end
-
 end
 end
 end

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

@@ -172,39 +172,39 @@ describe TypeParser do
 
   context 'with scope context and loader' do
     let!(:scope) { {} }
-    let(:loader) { double() }
+    let(:loader) { mock }
 
     before :each do
-      expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(loader)
+      Adapters::LoaderAdapter.expects(:loader_for_model_object).returns loader
     end
 
     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)
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
       expect(parser.parse('Nonesuch', scope)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse('File', scope)).to be_the_type(types.resource('File'))
     end
 
     it "parses a resource type with title" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("File['/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File]", scope)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(nil)
+      loader.expects(:load).with(:type, 'file').returns nil
       expect(parser.parse("Resource[File, '/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type with title using 'Resource[Type[title]]'" do
-      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
       expect(parser.parse("Resource[Nonesuch['fife']]", scope)).to be_the_type(types.resource('nonesuch', 'fife'))
     end
   end
@@ -213,27 +213,27 @@ describe TypeParser do
     let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader") }
 
     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)
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
       expect(parser.parse('Nonesuch', loader)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse('File', loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("File['/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File]", loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File, '/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
   end

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

@@ -660,12 +660,15 @@ describe 'Puppet Type System' do
   end
 
   context 'instantiation via ruby create function' do
-    around(:each) do |example|
-      Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
-        example.run
+    before(:each) do
+      Puppet.push_context(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
       end
     end
 
+    after(:each) do
+      Puppet.pop_context()
+    end
+
     it 'is supported by Integer' do
       int = tf.integer.create('32')
       expect(int).to eq(32)
@@ -689,12 +692,15 @@ describe 'Puppet Type System' do
   end
 
   context 'creation of parameterized type via ruby create function on class' do
-    around(:each) do |example|
-      Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
-        example.run
+    before(:each) do
+      Puppet.push_context(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
       end
     end
 
+    after(:each) do
+      Puppet.pop_context()
+    end
+
     it 'is supported by Integer' do
       int_type = tf.integer.class.create(0, 32)
       expect(int_type).to eq(tf.range(0, 32))

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'
@@ -22,11 +23,7 @@ describe "validating 4x" do
 
   def with_environment(environment, env_params = {})
     override_env = environment
-    override_env = environment.override_with({
-      modulepath:     env_params[:modulepath]     || environment.full_modulepath,
-      manifest:       env_params[:manifest]       || environment.manifest,
-      config_version: env_params[:config_version] || environment.config_version
-    }) if env_params.count > 0
+    override_env = environment.override_with(env_params) if env_params.count > 0
     Puppet.override(current_environment: override_env) do
       yield
     end
@@ -75,6 +72,15 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error for legal definition locations' do
+    with_environment(environment, :manifest => 'a/manifest/file.pp') do
+      expect(validate(parse('function aaa::bbb() {}',      'path/aaa/manifests/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class aaa() {}',      'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::bbB::ccc() {}', 'path/aaa/manifests/bBb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::bbb::ccc() {}', 'path/aaa/manifests/bbb/CCC.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
   it 'should not raise error for definitions inside initial --manifest file' do
     with_environment(environment, :manifest => 'a/manifest/file.pp') do
       expect(validate(parse('class aaa() {}', 'a/manifest/file.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -94,13 +100,6 @@ describe "validating 4x" do
     end
   end
 
-  it 'should not raise error for empty files in modulepath' do
-    with_environment(environment) do
-      expect(validate(parse('', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
-      expect(validate(parse('#this is a comment', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
-    end
-  end
-
   it 'should raise error if the file is in the modulepath but is not well formed' do
     with_environment(environment) do
       expect(validate(parse('class aaa::bbb::ccc() {}', 'path/manifest/aaa/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -114,18 +113,6 @@ describe "validating 4x" do
     end
   end
 
-  it 'should not raise error when one modulepath is a substring of another' do
-    with_environment(environment, modulepath: ['path', 'pathplus']) do
-      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-    end
-  end
-
-  it 'should not raise error when a modulepath ends with a file separator' do
-    with_environment(environment, modulepath: ['path/']) do
-      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-    end
-  end
-
   it 'should raise error for illegal type names' do
     expect(validate(parse('type ::Aaa = Any'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end
@@ -149,22 +136,22 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a deprecation for illegal function locations' do
+    it 'produces an error for illegal function locations' do
       with_environment(environment) do
         acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_DEFINITION_LOCATION)
       end
     end
 
-    it 'produces a deprecation for illegal top level constructs' do
+    it 'produces an error for illegal top level constructs' do
       with_environment(environment) do
         acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_TOP_CONSTRUCT_LOCATION)
       end
     end
@@ -193,22 +180,22 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a deprecation for illegal function locations' do
+    it 'produces an error for illegal function locations' do
       with_environment(environment) do
         acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_DEFINITION_LOCATION)
       end
     end
 
-    it 'produces a deprecation for illegal top level constructs' do
+    it 'produces an error for illegal top level constructs' do
       with_environment(environment) do
         acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_TOP_CONSTRUCT_LOCATION)
       end
     end
@@ -244,22 +231,22 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a deprecation for illegal function locations' do
+    it 'produces an error for illegal function locations' do
       with_environment(environment) do
         acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_DEFINITION_LOCATION)
       end
     end
 
-    it 'produces a deprecation for illegal top level constructs' do
+    it 'produces an error for illegal top level constructs' do
       with_environment(environment) do
         acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_TOP_CONSTRUCT_LOCATION)
       end
     end
@@ -274,22 +261,22 @@ describe "validating 4x" do
       expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a deprecation for illegal function locations' do
+    it 'produces an error for illegal function locations' do
       with_environment(environment) do
         acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_DEFINITION_LOCATION)
       end
     end
 
-    it 'produces a deprecation for illegal top level constructs' do
+    it 'produces an error for illegal top level constructs' do
       with_environment(environment) do
         acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
-        expect(deprecation_count(acceptor)).to eql(1)
-        expect(acceptor.warning_count).to eql(1)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).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::ILLEGAL_TOP_CONSTRUCT_LOCATION)
       end
     end
@@ -347,73 +334,173 @@ describe "validating 4x" do
     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::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     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::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     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)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for collect expressions with exported query' do
       acceptor = validate(parse("User <<| title == 'admin' |>>"))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for class expressions' do
       acceptor = validate(parse('class test {}'))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for node expressions' do
       acceptor = validate(parse('node default {}'))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for relationship expressions' do
       acceptor = validate(parse('$x -> $y'))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for resource expressions' do
       acceptor = validate(parse('notify { nope: }'))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for resource default expressions' do
       acceptor = validate(parse("File { mode => '0644' }"))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for resource override expressions' do
       acceptor = validate(parse("File['/tmp/foo'] { mode => '0644' }"))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
     it 'produces an error for resource definitions' do
       acceptor = validate(parse('define foo($a) {}'))
       expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      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::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    end
+
+    context 'validating apply() blocks' do
+      it 'allows empty apply() blocks' do
+        acceptor = validate(parse('apply("foo.example.com") { }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'allows apply() with a single expression' do
+        acceptor = validate(parse('apply("foo.example.com") { include foo }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'allows apply() with multiple expressions' do
+        acceptor = validate(parse('apply("foo.example.com") { $message = "hello!"; notify { $message: } }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'accepts multiple arguments' do
+        acceptor = validate(parse('apply(["foo.example.com"], { "other" => "args" }) { }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'allows virtual resource collectors' do
+        acceptor = validate(parse("apply('foo.example.com') { @user { 'foo': }; User <| title == 'foo' |> }"))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'rejects exported resource collectors' do
+        acceptor = validate(parse("apply('foo.example.com') { @@user { 'foo': }; User <<| title == 'foo' |>> }"))
+        expect(acceptor.error_count).to eql(1)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING)
+      end
+
+      it 'allows relationship expressions' do
+        acceptor = validate(parse('apply("foo.example.com") { $x -> $y }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'allows resource default expressions' do
+        acceptor = validate(parse("apply('foo.example.com') { File { mode => '0644' } }"))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'allows resource override expressions' do
+        acceptor = validate(parse("apply('foo.example.com') { File['/tmp/foo'] { mode => '0644' } }"))
+        expect(acceptor.error_count).to eql(0)
+      end
+
+      it 'can be assigned' do
+        acceptor = validate(parse('$result = apply("foo.example.com") { notify { "hello!": } }'))
+        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)
+      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)
+      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)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      end
+
+      it 'produces an error for node expressions' do
+        acceptor = validate(parse('apply("foo.example.com") { node default {} }'))
+        expect(acceptor.error_count).to eql(1)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      end
+
+      it 'produces an error for resource definitions' do
+        acceptor = validate(parse('apply("foo.example.com") { define foo($a) {} }'))
+        expect(acceptor.error_count).to eql(1)
+        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('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)
+      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)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING)
+      end
+
+      it 'allows multiple consecutive apply() blocks' do
+        acceptor = validate(parse('apply("foo.example.com") { } apply("foo.example.com") { }'))
+        expect(acceptor.error_count).to eql(0)
+      end
     end
   end
 
@@ -599,13 +686,6 @@ describe "validating 4x" do
     end
   end
 
-  context 'for hash keys' do
-    it "should not allow reassignment of hash keys" do
-      source = "$my_hash = {'one' => '1', 'two' => '2' }; $my_hash['one']='1.5'"
-      expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_INDEXED_ASSIGNMENT)
-    end
-  end
-
   context 'for parameter names' do
     ['class', 'define'].each do |word|
       it "should require that #{word} parameter names are unique" do
@@ -874,13 +954,13 @@ describe "validating 4x" do
 
       with_environment(environment) do
         acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
-        expect(deprecation_count(acceptor)).to eql(3)
-        expect(acceptor.warning_count).to eql(3)
-        expect(acceptor.error_count).to eql(0)
+        expect(deprecation_count(acceptor)).to eql(0)
+        expect(acceptor.warning_count).to eql(0)
+        expect(acceptor.error_count).to eql(3)
 
-        expect(acceptor.warnings[0].source_pos.line).to eql(2)
-        expect(acceptor.warnings[1].source_pos.line).to eql(3)
-        expect(acceptor.warnings[2].source_pos.line).to eql(5)
+        expect(acceptor.errors[0].source_pos.line).to eql(2)
+        expect(acceptor.errors[1].source_pos.line).to eql(3)
+        expect(acceptor.errors[2].source_pos.line).to eql(5)
       end
     end
   end
@@ -918,7 +998,7 @@ describe "validating 4x" do
       result = '$hg_oais::archivematica::requirements::automation_tools::USER' =~ Puppet::Pops::Patterns::VAR_NAME
       t2 = Time.now.nsec
       expect(result).to be(nil)
-      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond
+      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond 
     end
   end