diff --git a/acceptance/tests/language/node_overrides_topscope_when_using_enc.rb b/acceptance/tests/language/node_overrides_topscope_when_using_enc.rb deleted file mode 100644 index 22c9e81cb..000000000 --- a/acceptance/tests/language/node_overrides_topscope_when_using_enc.rb +++ /dev/null @@ -1,66 +0,0 @@ -test_name "ENC still allows a node to override a topscope var" - -testdir = master.tmpdir('scoping_deprecation') - -on master, "mkdir -p #{testdir}/modules/a/manifests" - -create_remote_file(master, "#{testdir}/enc", <<-PP) -#!/usr/bin/env sh - -cat < $enc_var } - notify { "from site.pp": message => $top_scope } -} -PP - -on master, "chown -R #{master['user']}:#{master['group']} #{testdir}" -on master, "chmod -R g+rwX #{testdir}" -on master, "chmod -R a+x #{testdir}/enc" - -assert_log_on_master_contains = lambda do |string| - on master, "grep '#{string}' #{testdir}/log" -end - -assert_log_on_master_does_not_contain = lambda do |string| - on master, "grep -v '#{string}' #{testdir}/log" -end - -master_opts = { - 'master' => { - 'node_terminus' => 'exec', - 'external_nodes' => "#{testdir}/enc", - 'manifest' => "#{testdir}/site.pp", - 'modulepath' => "#{testdir}/modules" - } -} - -with_puppet_running_on master, master_opts, testdir do - agents.each do |agent| - run_agent_on(agent, "--no-daemonize --onetime --verbose --server #{master}") - - assert_match("top_scope overridden in agent node.", stdout) - assert_match("ENC overridden in default node.", stdout) - end -end diff --git a/lib/puppet/pops/validation/validator_factory_4_0.rb b/lib/puppet/pops/validation/validator_factory_4_0.rb index 3d6f550f6..7eae59351 100644 --- a/lib/puppet/pops/validation/validator_factory_4_0.rb +++ b/lib/puppet/pops/validation/validator_factory_4_0.rb @@ -1,32 +1,31 @@ # Configures validation suitable for 4.0 # class Puppet::Pops::Validation::ValidatorFactory_4_0 < Puppet::Pops::Validation::Factory Issues = Puppet::Pops::Issues # Produces the checker to use def checker diagnostic_producer Puppet::Pops::Validation::Checker4_0.new(diagnostic_producer) end # Produces the label provider to use def label_provider Puppet::Pops::Model::ModelLabelProvider.new() end # Produces the severity producer to use def severity_producer p = super # Configure each issue that should **not** be an error # # Validate as per the current runtime configuration p[Issues::RT_NO_STORECONFIGS_EXPORT] = Puppet[:storeconfigs] ? :ignore : :warning p[Issues::RT_NO_STORECONFIGS] = Puppet[:storeconfigs] ? :ignore : :warning p[Issues::NAME_WITH_HYPHEN] = :error p[Issues::DEPRECATED_NAME_AS_TYPE] = :error p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore - p[Issues::ILLEGAL_NODE_INHERITANCE] = :deprecation p end end diff --git a/spec/integration/parser/node_spec.rb b/spec/integration/parser/node_spec.rb index 9d4df4ac0..7ce58f152 100644 --- a/spec/integration/parser/node_spec.rb +++ b/spec/integration/parser/node_spec.rb @@ -1,186 +1,185 @@ require 'spec_helper' require 'puppet_spec/compiler' require 'matchers/resource' describe 'node statements' do include PuppetSpec::Compiler include Matchers::Resource shared_examples_for 'nodes' do it 'selects a node where the name is just a number' do # Future parser doesn't allow a number in this position catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("5")) node 5 { notify { 'matched': } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'selects the node with a matching name' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node noden {} node nodename { notify { matched: } } node name {} MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'prefers a node with a literal name over one with a regex' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node /noden.me/ { notify { ignored: } } node nodename { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end - it 'includes the inherited nodes of the matching node' do - catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) - node notmatched1 { notify { inherited: } } - node nodename inherits notmatched1 { notify { matched: } } - node notmatched2 { notify { ignored: } } - MANIFEST - - expect(catalog).to have_resource('Notify[matched]') - expect(catalog).to have_resource('Notify[inherited]') - end - it 'selects a node where one of the names matches' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node different, nodename, other { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'arbitrarily selects one of the matching nodes' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node /not/ { notify { 'is not matched': } } node /name.*/ { notify { 'could be matched': } } node /na.e/ { notify { 'could also be matched': } } MANIFEST expect([catalog.resource('Notify[could be matched]'), catalog.resource('Notify[could also be matched]')].compact).to_not be_empty end it 'selects a node where one of the names matches with a mixture of literals and regex' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node different, /name/, other { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'errors when two nodes with regexes collide after some regex syntax is removed' do expect do compile_to_catalog(<<-MANIFEST) node /a.*(c)?/ { } node 'a.c' { } MANIFEST end.to raise_error(Puppet::Error, /Node 'a.c' is already defined/) end it 'provides captures from the regex in the node body' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node /(.*)/ { notify { "$1": } } MANIFEST expect(catalog).to have_resource('Notify[nodename]') end it 'selects the node with the matching regex' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) node /node.*/ { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'selects a node that is a literal string' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("node.name")) node 'node.name' { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'selects a node that is a prefix of the agent name' do Puppet[:strict_hostname_checking] = false catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("node.name.com")) node 'node.name' { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'does not treat regex symbols as a regex inside a string literal' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodexname")) node 'node.name' { notify { 'not matched': } } node 'nodexname' { notify { 'matched': } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end it 'errors when two nodes have the same name' do expect do compile_to_catalog(<<-MANIFEST) node name { } node 'name' { } MANIFEST end.to raise_error(Puppet::Error, /Node 'name' is already defined/) end end describe 'using classic parser' do before :each do Puppet[:parser] = 'current' end it_behaves_like 'nodes' + it 'includes the inherited nodes of the matching node' do + catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) + node notmatched1 { notify { inherited: } } + node nodename inherits notmatched1 { notify { matched: } } + node notmatched2 { notify { ignored: } } + MANIFEST + + expect(catalog).to have_resource('Notify[matched]') + expect(catalog).to have_resource('Notify[inherited]') + end + it 'raises deprecation warning for node inheritance for 3x parser' do Puppet.expects(:warning).at_least_once Puppet.expects(:warning).with(regexp_matches(/Deprecation notice\: Node inheritance is not supported in Puppet >= 4\.0\.0/)) catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("1.2.3.4")) node default {} node '1.2.3.4' inherits default { } MANIFEST end - end describe 'using future parser' do before :each do Puppet[:parser] = 'future' end it_behaves_like 'nodes' it 'is unable to parse a name that is an invalid number' do expect do compile_to_catalog('node 5name {} ') end.to raise_error(Puppet::Error, /Illegal number/) end it 'parses a node name that is dotted numbers' do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("1.2.3.4")) node 1.2.3.4 { notify { matched: } } MANIFEST expect(catalog).to have_resource('Notify[matched]') end - it 'raises deprecation warning for node inheritance' do - Puppet.expects(:warning).at_least_once - Puppet.expects(:warning).with(regexp_matches(/Deprecation notice: Node inheritance is not supported in Puppet >= 4\.0\.0/)) - catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) - node default {} - node nodename inherits default { } - MANIFEST + it 'raises error for node inheritance' do + expect do + compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodename")) + node default {} + node nodename inherits default { } + MANIFEST + end.to raise_error(/Node inheritance is not supported in Puppet >= 4\.0\.0/) end end end diff --git a/spec/integration/parser/scope_spec.rb b/spec/integration/parser/scope_spec.rb index 1fd84f421..f3e51f678 100644 --- a/spec/integration/parser/scope_spec.rb +++ b/spec/integration/parser/scope_spec.rb @@ -1,798 +1,811 @@ require 'spec_helper' require 'puppet_spec/compiler' describe "Two step scoping for variables" do include PuppetSpec::Compiler def expect_the_message_to_be(message, node = Puppet::Node.new('the node')) catalog = compile_to_catalog(yield, node) catalog.resource('Notify', 'something')[:message].should == message end before :each do Puppet.expects(:deprecation_warning).never end context 'using current parser' do describe "using plussignment to change in a new scope" do it "does not change a string in the parent scope" do # Expects to be able to concatenate string using += expect_the_message_to_be('top_msg') do <<-MANIFEST $var = "top_msg" class override { $var += "override" include foo } class foo { notify { 'something': message => $var, } } include override MANIFEST end end end end context 'using future parser' do before(:each) do Puppet[:parser] = 'future' end describe "using plussignment to change in a new scope" do it "does not change a string in the parent scope" do # Expects to be able to concatenate string using += expect do catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new('the node')) $var = "top_msg" class override { $var += "override" include foo } class foo { notify { 'something': message => $var, } } include override MANIFEST end.to raise_error(/The value 'top_msg' cannot be converted to Numeric/) end end it "when using a template ignores the dynamic value of the var when using the @varname syntax" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include foo } class foo { $var = "foo_msg" include bar } class bar { notify { 'something': message => inline_template("<%= @var %>"), } } MANIFEST end end it "when using a template gets the var from an inherited class when using the @varname syntax" do expect_the_message_to_be('Barbamama') do <<-MANIFEST node default { $var = "node_msg" include bar_bamama include foo } class bar_bamama { $var = "Barbamama" } class foo { $var = "foo_msg" include bar } class bar inherits bar_bamama { notify { 'something': message => inline_template("<%= @var %>"), } } MANIFEST end end it "when using a template ignores the dynamic var when it is not present in an inherited class" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include bar_bamama include foo } class bar_bamama { } class foo { $var = "foo_msg" include bar } class bar inherits bar_bamama { notify { 'something': message => inline_template("<%= @var %>"), } } MANIFEST end end end shared_examples_for "the scope" do describe "fully qualified variable names" do it "keeps nodescope separate from topscope" do expect_the_message_to_be('topscope') do <<-MANIFEST $c = "topscope" node default { $c = "nodescope" notify { 'something': message => $::c } } MANIFEST end end end describe "when colliding class and variable names" do it "finds a topscope variable with the same name as a class" do expect_the_message_to_be('topscope') do <<-MANIFEST $c = "topscope" class c { } node default { include c notify { 'something': message => $c } } MANIFEST end end it "finds a node scope variable with the same name as a class" do expect_the_message_to_be('nodescope') do <<-MANIFEST class c { } node default { $c = "nodescope" include c notify { 'something': message => $c } } MANIFEST end end it "finds a class variable when the class collides with a nodescope variable" do expect_the_message_to_be('class') do <<-MANIFEST class c { $b = "class" } node default { $c = "nodescope" include c notify { 'something': message => $c::b } } MANIFEST end end it "finds a class variable when the class collides with a topscope variable" do expect_the_message_to_be('class') do <<-MANIFEST $c = "topscope" class c { $b = "class" } node default { include c notify { 'something': message => $::c::b } } MANIFEST end end end describe "when using shadowing and inheritance" do - it "finds value define in the inherited node" do - expect_the_message_to_be('parent_msg') do <<-MANIFEST - $var = "top_msg" - node parent { - $var = "parent_msg" - } - node default inherits parent { - include foo - } - class foo { - notify { 'something': message => $var, } - } - MANIFEST - end - end - - it "finds top scope when the class is included before the node defines the var" do - expect_the_message_to_be('top_msg') do <<-MANIFEST - $var = "top_msg" - node parent { - include foo - } - node default inherits parent { - $var = "default_msg" - } - class foo { - notify { 'something': message => $var, } - } - MANIFEST - end - end - - it "finds top scope when the class is included before the node defines the var" do - expect_the_message_to_be('top_msg') do <<-MANIFEST - $var = "top_msg" - node parent { - include foo - } - node default inherits parent { - $var = "default_msg" - } - class foo { - notify { 'something': message => $var, } - } - MANIFEST - end - end - it "finds values in its local scope" do expect_the_message_to_be('local_msg') do <<-MANIFEST node default { include baz } class foo { } class bar inherits foo { $var = "local_msg" notify { 'something': message => $var, } } class baz { include bar } MANIFEST end end it "finds values in its inherited scope" do expect_the_message_to_be('foo_msg') do <<-MANIFEST node default { include baz } class foo { $var = "foo_msg" } class bar inherits foo { notify { 'something': message => $var, } } class baz { include bar } MANIFEST end end it "prefers values in its local scope over values in the inherited scope" do expect_the_message_to_be('local_msg') do <<-MANIFEST include bar class foo { $var = "inherited" } class bar inherits foo { $var = "local_msg" notify { 'something': message => $var, } } MANIFEST end end it "finds a qualified variable by following parent scopes of the specified scope" do expect_the_message_to_be("from node") do <<-MANIFEST class c { notify { 'something': message => "$a::b" } } class a { } node default { $b = "from node" include a include c } MANIFEST end end it "finds values in its inherited scope when the inherited class is qualified to the top" do expect_the_message_to_be('foo_msg') do <<-MANIFEST node default { include baz } class foo { $var = "foo_msg" } class bar inherits ::foo { notify { 'something': message => $var, } } class baz { include bar } MANIFEST end end it "prefers values in its local scope over values in the inherited scope when the inherited class is fully qualified" do expect_the_message_to_be('local_msg') do <<-MANIFEST include bar class foo { $var = "inherited" } class bar inherits ::foo { $var = "local_msg" notify { 'something': message => $var, } } MANIFEST end end it "finds values in top scope when the inherited class is qualified to the top" do expect_the_message_to_be('top msg') do <<-MANIFEST $var = "top msg" class foo { } class bar inherits ::foo { notify { 'something': message => $var, } } include bar MANIFEST end end it "finds values in its inherited scope when the inherited class is a nested class that shadows another class at the top" do expect_the_message_to_be('inner baz') do <<-MANIFEST node default { include foo::bar } class baz { $var = "top baz" } class foo { class baz { $var = "inner baz" } class bar inherits baz { notify { 'something': message => $var, } } } MANIFEST end end it "finds values in its inherited scope when the inherited class is qualified to a nested class and qualified to the top" do expect_the_message_to_be('top baz') do <<-MANIFEST node default { include foo::bar } class baz { $var = "top baz" } class foo { class baz { $var = "inner baz" } class bar inherits ::baz { notify { 'something': message => $var, } } } MANIFEST end end it "finds values in its inherited scope when the inherited class is qualified" do expect_the_message_to_be('foo_msg') do <<-MANIFEST node default { include bar } class foo { class baz { $var = "foo_msg" } } class bar inherits foo::baz { notify { 'something': message => $var, } } MANIFEST end end it "prefers values in its inherited scope over those in the node (with intermediate inclusion)" do expect_the_message_to_be('foo_msg') do <<-MANIFEST node default { $var = "node_msg" include baz } class foo { $var = "foo_msg" } class bar inherits foo { notify { 'something': message => $var, } } class baz { include bar } MANIFEST end end it "prefers values in its inherited scope over those in the node (without intermediate inclusion)" do expect_the_message_to_be('foo_msg') do <<-MANIFEST node default { $var = "node_msg" include bar } class foo { $var = "foo_msg" } class bar inherits foo { notify { 'something': message => $var, } } MANIFEST end end it "prefers values in its inherited scope over those from where it is included" do expect_the_message_to_be('foo_msg') do <<-MANIFEST node default { include baz } class foo { $var = "foo_msg" } class bar inherits foo { notify { 'something': message => $var, } } class baz { $var = "baz_msg" include bar } MANIFEST end end it "does not used variables from classes included in the inherited scope" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include bar } class quux { $var = "quux_msg" } class foo inherits quux { } class baz { include foo } class bar inherits baz { notify { 'something': message => $var, } } MANIFEST end end it "does not use a variable from a scope lexically enclosing it" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include other::bar } class other { $var = "other_msg" class bar { notify { 'something': message => $var, } } } MANIFEST end end it "finds values in its node scope" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include baz } class foo { } class bar inherits foo { notify { 'something': message => $var, } } class baz { include bar } MANIFEST end end it "finds values in its top scope" do expect_the_message_to_be('top_msg') do <<-MANIFEST $var = "top_msg" node default { include baz } class foo { } class bar inherits foo { notify { 'something': message => $var, } } class baz { include bar } MANIFEST end end it "prefers variables from the node over those in the top scope" do expect_the_message_to_be('node_msg') do <<-MANIFEST $var = "top_msg" node default { $var = "node_msg" include foo } class foo { notify { 'something': message => $var, } } MANIFEST end end it "finds top scope variables referenced inside a defined type" do expect_the_message_to_be('top_msg') do <<-MANIFEST $var = "top_msg" node default { foo { "testing": } } define foo() { notify { 'something': message => $var, } } MANIFEST end end it "finds node scope variables referenced inside a defined type" do expect_the_message_to_be('node_msg') do <<-MANIFEST $var = "top_msg" node default { $var = "node_msg" foo { "testing": } } define foo() { notify { 'something': message => $var, } } MANIFEST end end end describe "in situations that used to have dynamic lookup" do it "ignores the dynamic value of the var" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include foo } class baz { $var = "baz_msg" include bar } class foo inherits baz { } class bar { notify { 'something': message => $var, } } MANIFEST end end it "finds nil when the only set variable is in the dynamic scope" do expect_the_message_to_be(nil) do <<-MANIFEST node default { include baz } class foo { } class bar inherits foo { notify { 'something': message => $var, } } class baz { $var = "baz_msg" include bar } MANIFEST end end it "ignores the value in the dynamic scope for a defined type" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include foo } class foo { $var = "foo_msg" bar { "testing": } } define bar() { notify { 'something': message => $var, } } MANIFEST end end it "when using a template ignores the dynamic value of the var when using scope.lookupvar" do expect_the_message_to_be('node_msg') do <<-MANIFEST node default { $var = "node_msg" include foo } class foo { $var = "foo_msg" include bar } class bar { notify { 'something': message => inline_template("<%= scope.lookupvar('var') %>"), } } MANIFEST end end end describe "using plussignment to change in a new scope" do it "does not change an array in the parent scope" do expect_the_message_to_be('top_msg') do <<-MANIFEST $var = ["top_msg"] class override { $var += ["override"] include foo } class foo { notify { 'something': message => $var, } } include override MANIFEST end end it "concatenates two arrays" do expect_the_message_to_be(['top_msg', 'override']) do <<-MANIFEST $var = ["top_msg"] class override { $var += ["override"] notify { 'something': message => $var, } } include override MANIFEST end end it "leaves an array of arrays unflattened" do expect_the_message_to_be([['top_msg'], ['override']]) do <<-MANIFEST $var = [["top_msg"]] class override { $var += [["override"]] notify { 'something': message => $var, } } include override MANIFEST end end it "does not change a hash in the parent scope" do expect_the_message_to_be({"key"=>"top_msg"}) do <<-MANIFEST $var = { "key" => "top_msg" } class override { $var += { "other" => "override" } include foo } class foo { notify { 'something': message => $var, } } include override MANIFEST end end it "replaces a value of a key in the hash instead of merging the values" do expect_the_message_to_be({"key"=>"override"}) do <<-MANIFEST $var = { "key" => "top_msg" } class override { $var += { "key" => "override" } notify { 'something': message => $var, } } include override MANIFEST end end end describe "when using an enc" do it "places enc parameters in top scope" do enc_node = Puppet::Node.new("the node", { :parameters => { "var" => 'from_enc' } }) expect_the_message_to_be('from_enc', enc_node) do <<-MANIFEST notify { 'something': message => $var, } MANIFEST end end it "does not allow the enc to specify an existing top scope var" do enc_node = Puppet::Node.new("the_node", { :parameters => { "var" => 'from_enc' } }) expect { compile_to_catalog("$var = 'top scope'", enc_node) }.to raise_error( Puppet::Error, /Cannot reassign variable var at line 1(\:6)? on node the_node/ ) end it "evaluates enc classes in top scope when there is no node" do enc_node = Puppet::Node.new("the node", { :classes => ['foo'], :parameters => { "var" => 'from_enc' } }) expect_the_message_to_be('from_enc', enc_node) do <<-MANIFEST class foo { notify { 'something': message => $var, } } MANIFEST end end - it "evaluates enc classes in the node scope when there is a matching node" do - enc_node = Puppet::Node.new("the_node", { :classes => ['foo'] }) - - expect_the_message_to_be('from matching node', enc_node) do <<-MANIFEST - node inherited { - $var = "from inherited" - } + it "overrides enc variables from a node scope var" do + enc_node = Puppet::Node.new("the_node", { :classes => ['foo'], :parameters => { 'enc_var' => 'Set from ENC.' } }) - node the_node inherits inherited { - $var = "from matching node" + expect_the_message_to_be('ENC overridden in node', enc_node) do <<-MANIFEST + node the_node { + $enc_var = "ENC overridden in node" } class foo { - notify { 'something': message => $var, } + notify { 'something': message => $enc_var, } } MANIFEST end end end end describe 'using classic parser' do before :each do Puppet[:parser] = 'current' end - it_behaves_like 'the scope' do + + it_behaves_like 'the scope' + + it "finds value define in the inherited node" do + expect_the_message_to_be('parent_msg') do <<-MANIFEST + $var = "top_msg" + node parent { + $var = "parent_msg" + } + node default inherits parent { + include foo + } + class foo { + notify { 'something': message => $var, } + } + MANIFEST + end + end + + it "finds top scope when the class is included before the node defines the var" do + expect_the_message_to_be('top_msg') do <<-MANIFEST + $var = "top_msg" + node parent { + include foo + } + node default inherits parent { + $var = "default_msg" + } + class foo { + notify { 'something': message => $var, } + } + MANIFEST + end + end + + it "finds top scope when the class is included before the node defines the var" do + expect_the_message_to_be('top_msg') do <<-MANIFEST + $var = "top_msg" + node parent { + include foo + } + node default inherits parent { + $var = "default_msg" + } + class foo { + notify { 'something': message => $var, } + } + MANIFEST + end + end + + it "evaluates enc classes in the node scope when there is a matching node" do + enc_node = Puppet::Node.new("the_node", { :classes => ['foo'] }) + + expect_the_message_to_be('from matching node', enc_node) do <<-MANIFEST + node inherited { + $var = "from inherited" + } + + node the_node inherits inherited { + $var = "from matching node" + } + + class foo { + notify { 'something': message => $var, } + } + MANIFEST + end end end describe 'using future parser' do before :each do Puppet[:parser] = 'future' end - it_behaves_like 'the scope' do - end - end + it_behaves_like 'the scope' + end end -