puppet 4.10.0 → 5.0.0

data/spec/unit/node/facts_spec.rb

@@ -160,27 +160,27 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
     end
 
-    describe "using pson" do
+    describe "using json" do
       before :each do
         @timestamp = Time.parse("Thu Oct 28 11:16:31 -0700 2010")
         @expiration = Time.parse("Thu Oct 28 11:21:31 -0700 2010")
       end
 
-      it "should accept properly formatted pson" do
-        pson = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
-        format = Puppet::Network::FormatHandler.format('pson')
-        facts = format.intern(Puppet::Node::Facts,pson)
+      it "should accept properly formatted json" do
+        json = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
+        format = Puppet::Network::FormatHandler.format('json')
+        facts = format.intern(Puppet::Node::Facts, json)
         expect(facts.name).to eq('foo')
         expect(facts.expiration).to eq(@expiration)
         expect(facts.timestamp).to eq(@timestamp)
         expect(facts.values).to eq({'a' => '1', 'b' => '2', 'c' => '3'})
       end
 
-      it "should generate properly formatted pson" do
+      it "should generate properly formatted json" do
         Time.stubs(:now).returns(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
-        result = PSON.parse(facts.to_pson)
+        result = JSON.parse(facts.to_json)
         expect(result['name']).to eq(facts.name)
         expect(result['values']).to eq(facts.values)
         expect(result['timestamp']).to eq(facts.timestamp.iso8601(9))
@@ -192,19 +192,19 @@ describe Puppet::Node::Facts, "when indirecting" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
 
-        expect(facts.to_pson).to validate_against('api/schemas/facts.json')
+        expect(facts.to_json).to validate_against('api/schemas/facts.json')
       end
 
       it "should not include nil values" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
-        pson = PSON.parse(facts.to_pson)
-        expect(pson).not_to be_include("expiration")
+        json= JSON.parse(facts.to_json)
+        expect(json).not_to be_include("expiration")
       end
 
       it "should be able to handle nil values" do
-        pson = %Q({"name": "foo", "values": {"a": "1", "b": "2", "c": "3"}})
-        format = Puppet::Network::FormatHandler.format('pson')
-        facts = format.intern(Puppet::Node::Facts,pson)
+        json = %Q({"name": "foo", "values": {"a": "1", "b": "2", "c": "3"}})
+        format = Puppet::Network::FormatHandler.format('json')
+        facts = format.intern(Puppet::Node::Facts, json)
         expect(facts.name).to eq('foo')
         expect(facts.expiration).to be_nil
       end

data/spec/unit/node_spec.rb

@@ -55,14 +55,14 @@ describe Puppet::Node do
       end
     end
 
-    it "can round-trip through pson" do
+    it "can round-trip through json" do
       facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
                               :classes => ['erth', 'aiu'],
                               :parameters => {"hostname"=>"food"}
                              )
-      new_node = Puppet::Node.convert_from('pson', node.render('pson'))
+      new_node = Puppet::Node.convert_from('json', node.render('json'))
       expect(new_node.environment).to eq(node.environment)
       expect(new_node.parameters).to eq(node.parameters)
       expect(new_node.classes).to eq(node.classes)
@@ -76,7 +76,7 @@ describe Puppet::Node do
                               :classes => ['erth', 'aiu'],
                               :parameters => {"hostname"=>"food"}
                              )
-      expect(node.to_pson).to validate_against('api/schemas/node.json')
+      expect(node.to_json).to validate_against('api/schemas/node.json')
     end
 
     it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
@@ -84,7 +84,7 @@ describe Puppet::Node do
       node = Puppet::Node.new("hello",
                               :environment => 'bar'
                              )
-      expect(node.to_pson).to validate_against('api/schemas/node.json')
+      expect(node.to_json).to validate_against('api/schemas/node.json')
     end
 
     it "should allow its environment parameter to be set by attribute after initialization" do
@@ -94,6 +94,15 @@ describe Puppet::Node do
       expect(node.environment_name).to eq(:bar)
       expect(node.parameters['environment']).to eq('bar')
     end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      node = Puppet::Node.new("hello",
+        :environment => 'bar',
+        :classes => ['erth', 'aiu'],
+        :parameters => {"hostname"=>"food"}
+      )
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(node.to_data_hash)).to be_truthy
+    end
   end
 
   describe "when serializing using yaml" do
@@ -159,7 +168,7 @@ describe Puppet::Node do
   describe "when converting from json" do
     before do
       @node = Puppet::Node.new("mynode")
-      @format = Puppet::Network::FormatHandler.format('pson')
+      @format = Puppet::Network::FormatHandler.format('json')
     end
 
     def from_json(json)
@@ -167,22 +176,22 @@ describe Puppet::Node do
     end
 
     it "sets its name" do
-      expect(Puppet::Node).to read_json_attribute('name').from(@node.to_pson).as("mynode")
+      expect(Puppet::Node).to read_json_attribute('name').from(@node.to_json).as("mynode")
     end
 
     it "includes the classes if set" do
       @node.classes = %w{a b c}
-      expect(Puppet::Node).to read_json_attribute('classes').from(@node.to_pson).as(%w{a b c})
+      expect(Puppet::Node).to read_json_attribute('classes').from(@node.to_json).as(%w{a b c})
     end
 
     it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
+      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_json).as({"a" => "b", "c" => "d"})
     end
 
-    it "deserializes environment to environment_name as a string" do
+    it "deserializes environment to environment_name as a symbol" do
       @node.environment = environment
-      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_pson).as('bar')
+      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_json).as(:bar)
     end
   end
 end
@@ -237,6 +246,20 @@ describe Puppet::Node, "when merging facts" do
     Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
   end
 
+  context "when supplied facts as a parameter" do
+    let(:facts) { Puppet::Node::Facts.new(@node.name, "foo" => "bar") }
+
+    it "accepts facts to merge with the node" do
+      @node.expects(:merge).with({ 'foo' => 'bar' })
+      @node.fact_merge(facts)
+    end
+
+    it "will not query the facts indirection if facts are supplied" do
+      Puppet::Node::Facts.indirection.expects(:find).never
+      @node.fact_merge(facts)
+    end
+  end
+
   it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
     Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
     expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)

data/spec/unit/parameter_spec.rb

@@ -161,7 +161,7 @@ describe Puppet::Parameter do
     end
 
     it 'should format numbers appropriately' do
-      expect(described_class.format_value_for_display(1)).to eq("'1'")
+      expect(described_class.format_value_for_display(1)).to eq('1')
     end
 
     it 'should format symbols appropriately' do
@@ -169,25 +169,93 @@ describe Puppet::Parameter do
     end
 
     it 'should format arrays appropriately' do
-      expect(described_class.format_value_for_display([1, 'foo', :bar])).to eq("['1', 'foo', 'bar']")
+      expect(described_class.format_value_for_display([1, 'foo', :bar])).to eq("[1, 'foo', 'bar']")
     end
 
     it 'should format hashes appropriately' do
       expect(described_class.format_value_for_display(
         {1 => 'foo', :bar => 2, 'baz' => :qux}
-      )).to eq("{'1' => 'foo', 'bar' => '2', 'baz' => 'qux'}")
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          1 => 'foo',
+          'bar' => 2,
+          'baz' => 'qux'
+        }
+      RUBY
     end
 
     it 'should format arrays with nested data appropriately' do
       expect(described_class.format_value_for_display(
         [1, 'foo', :bar, [1, 2, 3], {1 => 2, 3 => 4}]
-      )).to eq("['1', 'foo', 'bar', ['1', '2', '3'], {'1' => '2', '3' => '4'}]")
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        [1, 'foo', 'bar',
+          [1, 2, 3],
+          {
+            1 => 2,
+            3 => 4
+          }]
+      RUBY
     end
 
     it 'should format hashes with nested data appropriately' do
       expect(described_class.format_value_for_display(
         {1 => 'foo', :bar => [2, 3, 4], 'baz' => {:qux => 1, :quux => 'two'}}
-      )).to eq("{'1' => 'foo', 'bar' => ['2', '3', '4'], 'baz' => {'quux' => 'two', 'qux' => '1'}}")
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          1 => 'foo',
+          'bar' => [2, 3, 4],
+          'baz' => {
+            'qux' => 1,
+            'quux' => 'two'
+          }
+        }
+       RUBY
+    end
+
+    it 'should format hashes with nested Objects appropriately' do
+      tf = Puppet::Pops::Types::TypeFactory
+      type = tf.object({'name' => 'MyType', 'attributes' => { 'qux' => tf.integer, 'quux' => tf.string }})
+      expect(described_class.format_value_for_display(
+        {1 => 'foo', 'bar' => type.create(1, 'one'), 'baz' => type.create(2, 'two')}
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          1 => 'foo',
+          'bar' => MyType({
+            'qux' => 1,
+            'quux' => 'one'
+          }),
+          'baz' => MyType({
+            'qux' => 2,
+            'quux' => 'two'
+          })
+        }
+      RUBY
+    end
+
+    it 'should format Objects with nested Objects appropriately' do
+      tf = Puppet::Pops::Types::TypeFactory
+      inner_type = tf.object({'name' => 'MyInnerType', 'attributes' => { 'qux' => tf.integer, 'quux' => tf.string }})
+      outer_type = tf.object({'name' => 'MyOuterType', 'attributes' => { 'x' => tf.string, 'inner' => inner_type }})
+      expect(described_class.format_value_for_display(
+        {'bar' => outer_type.create('a', inner_type.create(1, 'one')), 'baz' => outer_type.create('b', inner_type.create(2, 'two'))}
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          'bar' => MyOuterType({
+            'x' => 'a',
+            'inner' => MyInnerType({
+              'qux' => 1,
+              'quux' => 'one'
+            })
+          }),
+          'baz' => MyOuterType({
+            'x' => 'b',
+            'inner' => MyInnerType({
+              'qux' => 2,
+              'quux' => 'two'
+            })
+          })
+        }
+      RUBY
     end
   end
 

data/spec/unit/parser/compiler_spec.rb

@@ -11,7 +11,7 @@ class CompilerTestResource
   end
 
   def [](attr)
-    return nil if attr == :stage
+    return nil if (attr == :stage || attr == :alias)
     :main
   end
 

data/spec/unit/parser/environment_compiler_spec.rb

@@ -16,7 +16,6 @@ describe "Application instantiation" do
   end
 
   around :each do |example|
-    Puppet[:app_management] = true
     Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet::Parser::EnvironmentCompiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet.override(:loaders => loaders, :current_environment => env) do
@@ -27,7 +26,6 @@ describe "Application instantiation" do
       example.run
       Puppet::Type.rmtype(:cap)
     end
-    Puppet[:app_management] = false
   end
 
   MANIFEST = <<-EOS

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -89,6 +89,15 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
+    it 'unrealized exported resources should not be added' do
+      # a compiled catalog is normally filtered on virtual resources
+      # here the compilation is performed unfiltered to be able to find the exported resource
+      # it is then asserted that the exported resource is also virtual (and therefore filtered out by a real compilation).
+      catalog = compile_to_catalog_unfiltered("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
+      expect(catalog.resource(:file, "/etc/foo").virtual).to eq(true)
+    end
+
     it 'should be able to add exported resources' do
       catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}}) realize(File['/etc/foo'])")
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
@@ -232,6 +241,9 @@ describe 'function for dynamically creating resources' do
   end
 
   describe 'when creating classes' do
+    let(:logs) { [] }
+    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
     it 'should be able to create classes' do
       catalog = compile_to_catalog(<<-MANIFEST)
         class bar($one) {
@@ -245,12 +257,34 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:class, "bar")).not_to be_nil
     end
 
-    it 'should fail to create non-existing classes' do
-      expect do
-        compile_to_catalog(<<-MANIFEST)
-          create_resources('class', {'blah'=>{'one'=>'two'}})
-        MANIFEST
-      end.to raise_error(/Could not find declared class blah at line 1:11 on node test/)
+    [:off, :warning].each do | strictness |
+      it "should warn if strict = #{strictness} and class is exported" do
+        Puppet[:strict] = strictness
+        collect_notices('class test{} create_resources("@@class", {test => {}})')
+        expect(warnings).to include(/Classes are not virtualizable/)
+      end
+    end
+
+    it 'should error if strict = error and class is exported' do
+      Puppet[:strict] = :error
+      expect{
+        compile_to_catalog('class test{} create_resources("@@class", {test => {}})')
+      }.to raise_error(/Classes are not virtualizable/)
+    end
+
+    [:off, :warning].each do | strictness |
+      it "should warn if strict = #{strictness} and class is virtual" do
+        Puppet[:strict] = strictness
+        collect_notices('class test{} create_resources("@class", {test => {}})')
+        expect(warnings).to include(/Classes are not virtualizable/)
+      end
+    end
+
+    it 'should error if strict = error and class is virtual' do
+      Puppet[:strict] = :error
+      expect{
+        compile_to_catalog('class test{} create_resources("@class", {test => {}})')
+      }.to raise_error(/Classes are not virtualizable/)
     end
 
     it 'should be able to add edges' do
@@ -291,4 +325,11 @@ describe 'function for dynamically creating resources' do
       }.to raise_error(Puppet::Error, /Syntax error at.*/)
     end
   end
+
+  def collect_notices(code)
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compile_to_catalog(code)
+    end
+  end
+
 end

data/spec/unit/parser/resource_spec.rb

@@ -49,8 +49,9 @@ describe Puppet::Parser::Resource do
   end
 
   it "should get its environment from its scope" do
-    scope = stub 'scope', :source => stub("source"), :namespaces => nil
+    scope = stub 'scope', :source => stub("source")
     scope.expects(:environment).returns("foo").at_least_once
+    scope.expects(:lookupdefaults).returns({})
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
@@ -260,43 +261,104 @@ describe Puppet::Parser::Resource do
 
       expect(@compiler.catalog).to be_edge(main, resource)
     end
-  end
 
-  describe "when finishing" do
-    before do
-      @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
-    end
+    it 'should assign default value to generated resource' do
+      Puppet[:code] = <<-PUPPET
+        define one($var) {
+          notify { "${var} says hello": }
+        }
+        
+        define two($x = $title) {
+          One {
+            var => $x
+          }
+          one { a: }
+          one { b: var => 'bill'}
+        }
+        two { 'bob': }
+      PUPPET
 
-    it "should do nothing if it has already been finished" do
-      @resource.finish
-      @resource.expects(:add_defaults).never
-      @resource.finish
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+
+      expect(edges).to include(['One[a]', 'Notify[bob says hello]'])
+      expect(edges).to include(['One[b]', 'Notify[bill says hello]'])
+    end
+
+    it 'should override default value with new value' do
+      Puppet[:code] = <<-PUPPET.unindent
+        class foo {
+          File {
+            ensure => file,
+            mode   => '644',
+            owner  => 'root',
+            group  => 'root',
+          }
+        
+          file { '/tmp/foo':
+            ensure  => directory
+          }
+        
+          File['/tmp/foo'] { mode => '0755' }
+        }
+        include foo
+        PUPPET
+
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      file = catalog.resource('File[/tmp/foo]')
+      expect(file).to be_a(Puppet::Resource)
+      expect(file['mode']).to eql('0755')
     end
+  end
 
-    it "should add all defaults available from the scope" do
-      @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
-      @resource.finish
+  describe 'when evaluating resource defaults' do
+    let(:resource) { Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source) }
+
+    it 'should add all defaults available from the scope' do
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'default', @source))
 
-      expect(@resource[:owner]).to eq("default")
+      expect(resource[:owner]).to eq('default')
     end
 
-    it "should not replace existing parameters with defaults" do
-      @resource.set_parameter :owner, "oldvalue"
-      @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
-      @resource.finish
+    it 'should not replace existing parameters with defaults' do
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
+      r = Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source, :parameters => [ param(:owner, 'oldvalue', @source) ])
+      expect(r[:owner]).to eq('oldvalue')
+    end
+
+    it 'should override defaults with new parameters' do
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
 
-      expect(@resource[:owner]).to eq("oldvalue")
+      resource.set_parameter(:owner, 'newvalue')
+      expect(resource[:owner]).to eq('newvalue')
     end
 
-    it "should add a copy of each default, rather than the actual default parameter instance" do
-      newparam = param(:owner, "default", @resource.source)
+    it 'should add a copy of each default, rather than the actual default parameter instance' do
+      newparam = param(:owner, 'default', @source)
       other = newparam.dup
       other.value = "other"
       newparam.expects(:dup).returns(other)
-      @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
-      @resource.finish
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => newparam)
+
+      expect(resource[:owner]).to eq('other')
+    end
+
+    it "should tag with value of default parameter named 'tag'" do
+      @scope.expects(:lookupdefaults).with('File').returns(:tag => param(:tag, 'the_tag', @source))
+
+      expect(resource.tags).to include('the_tag')
+    end
+  end
 
-      expect(@resource[:owner]).to eq("other")
+  describe "when finishing" do
+    before do
+      @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
+    end
+
+    it "should do nothing if it has already been finished" do
+      @resource.finish
+      @resource.expects(:add_scope_tags).never
+      @resource.finish
     end
 
     it "converts parameters with Sensitive values to unwrapped values and metadata" do

data/spec/unit/parser/scope_spec.rb

@@ -247,9 +247,9 @@ describe Puppet::Parser::Scope do
         @scope.class_scope(klass)
       end
 
-      it "should be able to look up explicitly fully qualified variables from main" do
+      it "should be able to look up explicitly fully qualified variables from compiler's top scope" do
         Puppet.expects(:deprecation_warning).never
-        other_scope = create_class_scope("")
+        other_scope = @scope.compiler.topscope
 
         other_scope["othervar"] = "otherval"
 
@@ -367,59 +367,13 @@ describe Puppet::Parser::Scope do
     end
   end
 
-  describe "when variables are set with append=true" do
-    it "should raise error if the variable is already defined in this scope" do
-      @scope.setvar("var", "1", :append => false)
-      expect {
-        @scope.setvar("var", "1", :append => true)
-      }.to raise_error(
-        Puppet::ParseError,
-        "Cannot append, variable '$var' is defined in this scope"
-      )
-    end
-
-    it "should lookup current variable value" do
-      @scope.expects(:[]).with("var").returns("2")
-      @scope.setvar("var", "1", :append => true)
-    end
-
-    it "should store the concatenated string '42'" do
-      @topscope.setvar("var", "4", :append => false)
-      @scope.setvar("var", "2", :append => true)
-      expect(@scope["var"]).to eq("42")
-    end
-
-    it "should store the concatenated array [4,2]" do
-      @topscope.setvar("var", [4], :append => false)
-      @scope.setvar("var", [2], :append => true)
-      expect(@scope["var"]).to eq([4,2])
-    end
-
-    it "should store the merged hash {a => b, c => d}" do
-      @topscope.setvar("var", {"a" => "b"}, :append => false)
-      @scope.setvar("var", {"c" => "d"}, :append => true)
-      expect(@scope["var"]).to eq({"a" => "b", "c" => "d"})
-    end
-
-    it "should raise an error when appending a hash with something other than another hash" do
-      @topscope.setvar("var", {"a" => "b"}, :append => false)
-
-      expect {
-        @scope.setvar("var", "not a hash", :append => true)
-      }.to raise_error(
-        ArgumentError,
-        "Trying to append to a hash with something which is not a hash is unsupported"
-      )
-    end
-  end
-
   describe "when calling number?" do
     it "should return nil if called with anything not a number" do
       expect(Puppet::Parser::Scope.number?([2])).to be_nil
     end
 
-    it "should return a Fixnum for a Fixnum" do
-      expect(Puppet::Parser::Scope.number?(2)).to be_an_instance_of(Fixnum)
+    it "should return a Integer for an Integer" do
+      expect(Puppet::Parser::Scope.number?(2)).to be_a(Integer)
     end
 
     it "should return a Float for a Float" do
@@ -477,31 +431,10 @@ describe Puppet::Parser::Scope do
 
   describe "when using ephemeral variables" do
     it "should store the variable value" do
-#      @scope.setvar("1", :value, :ephemeral => true)
       @scope.set_match_data({1 => :value})
       expect(@scope["1"]).to eq(:value)
     end
 
-    it "should remove the variable value when unset_ephemeral_var(:all) is called" do
-#      @scope.setvar("1", :value, :ephemeral => true)
-      @scope.set_match_data({1 => :value})
-      @scope.stubs(:parent).returns(nil)
-
-      @scope.unset_ephemeral_var(:all)
-
-      expect(@scope["1"]).to be_nil
-    end
-
-    it "should not remove classic variables when unset_ephemeral_var(:all) is called" do
-      @scope['myvar'] = :value1
-      @scope.set_match_data({1 => :value2})
-      @scope.stubs(:parent).returns(nil)
-
-      @scope.unset_ephemeral_var(:all)
-
-      expect(@scope["myvar"]).to eq(:value1)
-    end
-
     it "should raise an error when setting numerical variable" do
       expect {
         @scope.setvar("1", :value3, :ephemeral => true)
@@ -523,8 +456,6 @@ describe Puppet::Parser::Scope do
       end
 
       it "should not check presence of an ephemeral variable across multiple levels" do
-        # This test was testing that scope actuallys screwed up - making values from earlier matches show as if they
-        # where true for latest match - insanity !
         @scope.new_ephemeral
         @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
@@ -571,13 +502,13 @@ describe Puppet::Parser::Scope do
       expect(@scope["apple"]).to eq(:fruit)
     end
 
-    it "should remove all local scope variables on unset" do
-      @scope.new_ephemeral true
-      @scope.setvar("apple", :fruit)
-      expect(@scope["apple"]).to eq(:fruit)
-      @scope.unset_ephemeral_var
-      expect(@scope["apple"]).to eq(nil)
+    it 'should store an undef in local scope and let it override parent scope' do
+      @scope['cloaked'] = 'Cloak me please'
+      @scope.new_ephemeral(true)
+      @scope['cloaked'] = nil
+      expect(@scope['cloaked']).to eq(nil)
     end
+
     it "should be created from a hash" do
       @scope.ephemeral_from({ "apple" => :fruit, "strawberry" => :berry})
       expect(@scope["apple"]).to eq(:fruit)