puppet 5.0.0 → 6.0.0

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

@@ -10,12 +10,25 @@ describe "validating 4x" do
 
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
   let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
+  let(:environment) { Puppet::Node::Environment.create(:bar, ['path']) }
 
   def validate(factory)
     validator.validate(factory.model)
     acceptor
   end
 
+  def deprecation_count(acceptor)
+    acceptor.diagnostics.select {|d| d.severity == :deprecation }.count
+  end
+
+  def with_environment(environment, env_params = {})
+    override_env = environment
+    override_env = environment.override_with(env_params) if env_params.count > 0
+    Puppet.override(current_environment: override_env) do
+      yield
+    end
+  end
+
   it 'should raise error for illegal class names' do
     expect(validate(parse('class aaa::_bbb {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
     expect(validate(parse('class Aaa {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
@@ -34,6 +47,72 @@ describe "validating 4x" do
     expect(validate(parse('function ::aaa() {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end
 
+  it 'should raise error for illegal definition locations' do
+    with_environment(environment) do
+      expect(validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class bbb() {}', 'path/aaa/manifests/init.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('define aaa::bbb::ccc::eee() {}', 'path/aaa/manifests/bbb/ddd.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for legal definition locations' do
+    with_environment(environment) 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 class locations when not parsing a file' do
+    #nil/'' file means eval or some other way to get puppet language source code into the catalog
+    with_environment(environment) do
+      expect(validate(parse('function aaa::ccc() {}', nil))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::ccc() {}', ''))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    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)
+    end
+  end
+
+  it 'should not raise error for definitions inside initial --manifest directory' do
+    with_environment(environment, :manifest => 'a/manifest/dir') do
+      expect(validate(parse('class aaa() {}', 'a/manifest/dir/file1.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class bbb::ccc::ddd() {}', 'a/manifest/dir/and/more/stuff.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for definitions not inside initial --manifest but also not in modulepath' do
+    with_environment(environment, :manifest => 'a/manifest/somewhere/else') do
+      expect(validate(parse('class aaa() {}', 'a/random/dir/file1.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_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)
+      expect(validate(parse('class aaa::bbb::ccc() {}', 'path/aaa/bbb/manifest/ccc.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for definitions not inside initial --manifest but also not in modulepath because of only a case difference' do
+    with_environment(environment) do
+        expect(validate(parse('class aaa::bb() {}', 'Path/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
@@ -56,6 +135,26 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
+
+    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(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 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(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
   end
 
   context 'with --strict set to warning' do
@@ -74,12 +173,32 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a  warning for exported class resource' do
+    it 'produces a warning 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).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
+
+    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(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 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(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
   end
 
   context 'with --strict set to error' do
@@ -111,6 +230,26 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
+
+    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(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 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(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
   end
 
   context 'with --strict set to off' do
@@ -121,6 +260,26 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
+
+    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(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 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(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
   end
 
   context 'irrespective of --strict' do
@@ -145,7 +304,7 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a  warning for exported class resource' do
+    it 'produces a warning for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
       expect(acceptor.warning_count).to eql(1)
       expect(acceptor.error_count).to eql(0)
@@ -153,6 +312,198 @@ describe "validating 4x" do
     end
   end
 
+  context 'with --tasks set' do
+    before(:each) { Puppet[:tasks] = true }
+
+    it 'raises an error for illegal plan names' do
+      with_environment(environment) do
+        expect(validate(parse('plan aaa::ccc::eee() {}', 'path/aaa/plans/bbb/ccc/eee.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa() {}', 'path/aaa/plans/aaa.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa::bbb() {}', 'path/aaa/plans/bbb/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
+
+    it 'accepts legal plan names' do
+      with_environment(environment) do
+        expect(validate(parse('plan aaa::ccc::eee() {}', 'path/aaa/plans/ccc/eee.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa() {}', 'path/aaa/plans/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa::bbb() {}', 'path/aaa/plans/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      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)
+    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)
+    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::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::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::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::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::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::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::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::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::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)
+    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
+
   context 'for non productive expressions' do
     [ '1',
       '3.14',
@@ -207,7 +558,9 @@ describe "validating 4x" do
       'Foo[a] -> Foo[b]',
       '($a=1)',
       'foo()',
-      '$a.foo()'
+      '$a.foo()',
+      '"foo" =~ /foo/', # may produce or modify $n vars
+      '"foo" !~ /foo/', # may produce or modify $n vars
       ].each do |expr|
 
       it "does not produce error when for productive: #{expr}" do
@@ -472,12 +825,12 @@ describe "validating 4x" do
     context 'that are type aliases' do
       it 'raises errors when RHS is a name that is an invalid reference' do
         source = 'type MyInt = integer'
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+        expect { parse(source) }.to raise_error(/Syntax error at 'integer'/)
       end
 
       it 'raises errors when RHS is an AccessExpression with a name that is an invalid reference on LHS' do
         source = 'type IntegerArray = array[Integer]'
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+        expect { parse(source) }.to raise_error(/Syntax error at 'array'/)
       end
     end
 
@@ -547,6 +900,71 @@ describe "validating 4x" do
     end
   end
 
+  context 'top level constructs' do
+    {
+      'a class' => 'class x{}',
+      'a define' => 'define x{}',
+      'a function' => 'function x() {}',
+      'a type alias' => 'type A = Data',
+      'a type alias for a complex type' => 'type C = Hash[String[1],Integer]',
+      'a type definition' => 'type A {}',
+    }.each_pair do |word, source|
+      it "will not have an issue with #{word} at the top level in a module" do
+        with_environment(environment) do
+          expect(validate(parse(source, 'path/x/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+        end
+      end
+    end
+  end
+
+  context 'non-top level constructs' do
+    {
+      'an assignment' => '$foo = 1',
+      'a resource' => 'notify { nope: }',
+      'a resource default' => "Notify { message => 'yo' }",
+      'a function call' => "include 'foo'",
+      'a node definition' => 'node default {}',
+      'an expression' => '1+1',
+      'a conditional' => 'if true {42}',
+      'a literal value' => '42',
+      'a virtual collector' => 'User <| tag == web |>',
+      'an exported collector' => 'Sshkey <<| |>>',
+    }.each_pair do |word, source|
+      it "will have an issue with #{word} at the top level in a module" do
+        with_environment(environment) do
+          expect(validate(parse(source, 'path/x/manifests/init.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+        end
+      end
+
+      it "will not have an issue with #{word} at top level not in a module" do
+        with_environment(environment) do
+          expect(validate(parse(source))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+        end
+      end
+    end
+
+    it "will give multiple errors in one file with multiple issues" do
+      source = <<-SOURCE
+      class foo {}
+      notify { nope: }
+      node bar {}
+
+      $a = 7
+      SOURCE
+
+      with_environment(environment) do
+        acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
+        expect(deprecation_count(acceptor)).to eql(0)
+        expect(acceptor.warning_count).to eql(0)
+        expect(acceptor.error_count).to eql(3)
+
+        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
+
   context "capability annotations" do
     ['produces', 'consumes'].each do |word|
       it "rejects illegal resource types in #{word} clauses" do
@@ -574,7 +992,17 @@ describe "validating 4x" do
     end
   end
 
-  def parse(source)
-    Puppet::Pops::Parser::Parser.new.parse_string(source)
+  context 'uses a var pattern that is performant' do
+    it 'such that illegal VAR_NAME is not too slow' do
+      t = Time.now.nsec
+      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 
+    end
+  end
+
+  def parse(source, path=nil)
+    Puppet::Pops::Parser::Parser.new.parse_string(source, path)
   end
 end

data/spec/unit/property/keyvalue_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 
 require 'puppet/property/keyvalue'
 
-klass = Puppet::Property::KeyValue
 
-describe klass do
+describe 'Puppet::Property::KeyValue' do 
+  let(:klass) { Puppet::Property::KeyValue }
 
   it "should be a subclass of Property" do
     expect(klass.superclass).to eq(Puppet::Property)
@@ -17,6 +17,7 @@ describe klass do
       klass.initvars
       @resource = stub 'resource', :[]= => nil, :property => nil
       @property = klass.new(:resource => @resource)
+      klass.log_only_changed_or_new_keys = false
     end
 
     it "should have a , as default delimiter" do
@@ -42,6 +43,26 @@ describe klass do
       expect(["foo=baz;bar=boo", "bar=boo;foo=baz"]).to be_include s
     end
 
+    describe "when calling hash_to_key_value_s" do
+      let(:input) do
+        {
+          :key1 => "value1",
+          :key2 => "value2",
+          :key3 => "value3"
+        }
+      end
+
+      before(:each) do
+        @property.instance_variable_set(:@changed_or_new_keys, [:key1, :key2])
+      end
+
+      it "returns only the changed or new keys if log_only_changed_or_new_keys is set" do
+        klass.log_only_changed_or_new_keys = true
+
+        expect(@property.hash_to_key_value_s(input)).to eql("key1=value1;key2=value2")
+      end
+    end
+
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
         @property.expects(:membership).returns(:key_value_membership)
@@ -103,6 +124,26 @@ describe klass do
         @property.expects(:inclusive?).returns(false)
         expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" })
       end
+
+      it "should mark the keys that will change or be added as a result of our Puppet run" do
+        @property.should = {
+          :key1 => "new_value1",
+          :key2 => "value2",
+          :key3 => "new_value3",
+          :key4 => "value4"
+        }
+        @property.stubs(:retrieve).returns(
+          {
+            :key1 => "value1",
+            :key2 => "value2",
+            :key3 => "value3"
+          }
+        )
+        @property.stubs(:inclusive?).returns(false)
+
+        @property.should
+        expect(@property.instance_variable_get(:@changed_or_new_keys)).to eql([:key1, :key3, :key4])
+      end
     end
 
     describe "when calling retrieve" do
@@ -130,9 +171,15 @@ describe klass do
       end
     end
 
-    describe "when calling hashify" do
-      it "should return the array hashified" do
-        expect(@property.hashify(["foo=baz", "bar=boo"])).to eq({ :foo => "baz", :bar => "boo" })
+    describe "when calling hashify_should" do
+      it "should return the underlying hash if the user passed in a hash" do
+        @property.should = { "foo" => "bar" }
+        expect(@property.hashify_should).to eql({ :foo => "bar" })
+      end
+
+      it "should hashify the array of key/value pairs if that is what our user passed in" do
+        @property.should = [ "foo=baz", "bar=boo" ]
+        expect(@property.hashify_should).to eq({ :foo => "baz", :bar => "boo" })
       end
     end
 
@@ -148,7 +195,6 @@ describe klass do
       end
 
       it "should return true if the passed in values is nil" do
-        @property.should = "foo"
         @property.safe_insync?(nil) == true
       end
 
@@ -166,5 +212,50 @@ describe klass do
         expect(@property.safe_insync?({ "foo" => "bee", "bar" => "boo" })).to eq(false)
       end
     end
+
+    describe 'when validating a passed-in property value' do
+      it 'should raise a Puppet::Error if the property value is anything but a Hash or a String' do
+        expect { @property.validate(5) }.to raise_error do |error|
+          expect(error).to be_a(Puppet::Error)
+          expect(error.message).to match("specified as a hash or an array")
+        end
+      end
+
+      it 'should accept a Hash property value' do
+        @property.validate({ 'foo' => 'bar' })
+      end
+
+      it "should raise a Puppet::Error if the property value isn't a key/value pair" do
+        expect { @property.validate('foo') }.to raise_error do |error|
+          expect(error).to be_a(Puppet::Error)
+          expect(error.message).to match("separated by '='")
+        end
+      end
+
+      it 'should accept a valid key/value pair property value' do
+        @property.validate('foo=bar')
+      end
+    end
+
+    describe 'when munging a passed-in property value' do
+      it 'should return the value as-is if it is a string' do
+        expect(@property.munge('foo=bar')).to eql('foo=bar')
+      end
+
+      it 'should stringify + symbolize the keys and stringify the values if it is a hash' do
+        input = {
+          1     => 2,
+          true  => false,
+          '   foo   ' => 'bar'
+        }
+        expected_output = {
+          :'1'    => '2',
+          :true => 'false',
+          :foo  => 'bar'
+        }
+
+        expect(@property.munge(input)).to eql(expected_output)
+      end
+    end
   end
 end