Merge branch 'ticket/next/5027' into next

9 files changed, 94 insertions, 241 deletions

diff --git a/spec/unit/parser/ast/arithmetic_operator_spec.rb b/spec/unit/parser/ast/arithmetic_operator_spec.rb
index 6f57fd9b6..9b54f09d8 100755
--- a/spec/unit/parser/ast/arithmetic_operator_spec.rb
+++ b/spec/unit/parser/ast/arithmetic_operator_spec.rb
@@ -60,14 +60,4 @@ describe Puppet::Parser::AST::ArithmeticOperator do
     operator.evaluate(@scope).should == 4.33
   end
 
-  it "should work for variables too" do
-    @scope.expects(:lookupvar).with("one", false).returns(1)
-    @scope.expects(:lookupvar).with("two", false).returns(2)
-    one = ast::Variable.new( :value => "one" )
-    two = ast::Variable.new( :value => "two" )
-
-    operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-    operator.evaluate(@scope).should == 3
-  end
-
 end
diff --git a/spec/unit/parser/ast/comparison_operator_spec.rb b/spec/unit/parser/ast/comparison_operator_spec.rb
index 169d92d0a..060827390 100755
--- a/spec/unit/parser/ast/comparison_operator_spec.rb
+++ b/spec/unit/parser/ast/comparison_operator_spec.rb
@@ -95,8 +95,8 @@ describe Puppet::Parser::AST::ComparisonOperator do
     one = Puppet::Parser::AST::Variable.new( :value => "one" )
     two = Puppet::Parser::AST::Variable.new( :value => "two" )
 
-    @scope.expects(:lookupvar).with("one", false).returns(1)
-    @scope.expects(:lookupvar).with("two", false).returns(2)
+    one.expects(:safeevaluate).with(@scope).returns(1)
+    two.expects(:safeevaluate).with(@scope).returns(2)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => one, :operator => "<", :rval => two
     operator.evaluate(@scope).should == true
diff --git a/spec/unit/parser/ast/leaf_spec.rb b/spec/unit/parser/ast/leaf_spec.rb
index 3b8c14efa..cd09eaf94 100755
--- a/spec/unit/parser/ast/leaf_spec.rb
+++ b/spec/unit/parser/ast/leaf_spec.rb
@@ -107,7 +107,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
 
   describe "when evaluating" do
     it "should evaluate the variable part if necessary" do
-      @scope.stubs(:lookupvar).with("a").returns(["b"])
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["b"])
 
       variable = stub 'variable', :evaluate => "a"
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => variable, :key => 0 )
@@ -118,7 +118,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should evaluate the access key part if necessary" do
-      @scope.stubs(:lookupvar).with("a").returns(["b"])
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["b"])
 
       index = stub 'index', :evaluate => 0
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => index )
@@ -129,7 +129,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should be able to return an array member" do
-      @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
 
@@ -137,7 +137,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should be able to return an array member when index is a stringified number" do
-      @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
+      @scope.stubs(:lookupvar).with { |name,options| name == "a" }.returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "1" )
 
@@ -145,7 +145,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should raise an error when accessing an array with a key" do
-      @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
+      @scope.stubs(:lookupvar).with { |name,options| name == "a"}.returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
@@ -153,7 +153,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should be able to return an hash value" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
@@ -161,7 +161,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should be able to return an hash value with a numerical key" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
+      @scope.stubs(:lookupvar).with { |name,options| name == "a"}.returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
 
@@ -169,7 +169,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should raise an error if the variable lookup didn't return an hash or an array" do
-      @scope.stubs(:lookupvar).with("a").returns("I'm a string")
+      @scope.stubs(:lookupvar).with { |name,options| name == "a"}.returns("I'm a string")
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
@@ -177,7 +177,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should raise an error if the variable wasn't in the scope" do
-      @scope.stubs(:lookupvar).with("a").returns(nil)
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(nil)
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
@@ -190,7 +190,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should work with recursive hash access" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key" => { "subkey" => "b" }})
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key" => { "subkey" => "b" }})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
@@ -199,7 +199,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should work with interleaved array and hash access" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key" => [ "a" , "b" ]})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => 1)
@@ -220,7 +220,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should raise an error when assigning an array element with a key" do
-      @scope.stubs(:lookupvar).with("a").returns([])
+      @scope.stubs(:lookupvar).with { |name,options| name == "a"}.returns([])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
@@ -238,7 +238,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should raise an error when trying to overwrite an hash value" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
+      @scope.stubs(:lookupvar).with { |name,options| name == "a" }.returns({ "key" => [ "a" , "b" ]})
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
 
       lambda { access.assign(@scope, "test") }.should raise_error
@@ -332,16 +332,21 @@ end
 describe Puppet::Parser::AST::Variable do
   before :each do
     @scope = stub 'scope'
-    @var = Puppet::Parser::AST::Variable.new(:value => "myvar")
+    @var = Puppet::Parser::AST::Variable.new(:value => "myvar", :file => 'my.pp', :line => 222)
   end
 
   it "should lookup the variable in scope" do
-    @scope.expects(:lookupvar).with("myvar", false).returns(:myvalue)
+    @scope.expects(:lookupvar).with { |name,options| name == "myvar" }.returns(:myvalue)
+    @var.safeevaluate(@scope).should == :myvalue
+  end
+
+  it "should pass the source location to lookupvar" do
+    @scope.expects(:lookupvar).with { |name,options| name == "myvar" and options[:file] == 'my.pp' and options[:line] == 222 }.returns(:myvalue)
     @var.safeevaluate(@scope).should == :myvalue
   end
 
   it "should return undef if the variable wasn't set" do
-    @scope.expects(:lookupvar).with("myvar", false).returns(:undefined)
+    @scope.expects(:lookupvar).with { |name,options| name == "myvar" }.returns(:undefined)
     @var.safeevaluate(@scope).should == :undef
   end
 
diff --git a/spec/unit/parser/ast/vardef_spec.rb b/spec/unit/parser/ast/vardef_spec.rb
index a462e8ef5..5a851bb13 100755
--- a/spec/unit/parser/ast/vardef_spec.rb
+++ b/spec/unit/parser/ast/vardef_spec.rb
@@ -16,8 +16,7 @@ describe Puppet::Parser::AST::VarDef do
       name.expects(:safeevaluate).with(@scope)
       value.expects(:safeevaluate).with(@scope)
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)
     end
 
@@ -27,8 +26,7 @@ describe Puppet::Parser::AST::VarDef do
 
       @scope.expects(:setvar).with { |name,value,options| options[:append] == nil }
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)
     end
 
@@ -38,8 +36,17 @@ describe Puppet::Parser::AST::VarDef do
 
       @scope.expects(:setvar).with { |name,value,options| options[:append] == true }
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil, :append => true
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil, :append => true
+      vardef.evaluate(@scope)
+    end
+
+    it "should call pass the source location to setvar" do
+      name = stub 'name', :safeevaluate => "var"
+      value = stub 'value', :safeevaluate => "1"
+
+      @scope.expects(:setvar).with { |name,value,options| options[:file] == 'setvar.pp' and options[:line] == 917 }
+
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => 'setvar.pp', :line => 917
       vardef.evaluate(@scope)
     end
 
diff --git a/spec/unit/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index 0c896a4e3..de4bee3e9 100755
--- a/spec/unit/parser/compiler_spec.rb
+++ b/spec/unit/parser/compiler_spec.rb
@@ -131,10 +131,6 @@ describe Puppet::Parser::Compiler do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
-    it "should correctly set the level of newly created scopes" do
-      @compiler.newscope(@compiler.topscope, :level => 5).level.should == 5
-    end
-
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
diff --git a/spec/unit/parser/functions/extlookup_spec.rb b/spec/unit/parser/functions/extlookup_spec.rb
index f2560d3d9..ad89f6575 100755
--- a/spec/unit/parser/functions/extlookup_spec.rb
+++ b/spec/unit/parser/functions/extlookup_spec.rb
@@ -65,7 +65,7 @@ describe "the extlookup function" do
 
   describe "should look in $extlookup_datadir for data files listed by $extlookup_precedence" do
     before do
-      @scope.stubs(:lookupvar).with('extlookup_datadir').returns("/tmp")
+      @scope.stubs(:lookupvar).with('::extlookup_datadir').returns("/tmp")
       File.open("/tmp/one.csv","w"){|one| one.puts "key,value1" }
       File.open("/tmp/two.csv","w") do |two|
         two.puts "key,value2"
@@ -74,21 +74,21 @@ describe "the extlookup function" do
     end
 
     it "when the key is in the first file" do
-      @scope.stubs(:lookupvar).with('extlookup_precedence').returns(["one","two"])
+      @scope.stubs(:lookupvar).with('::extlookup_precedence').returns(["one","two"])
       result = @scope.function_extlookup([ "key" ])
       result.should == "value1"
     end
 
     it "when the key is in the second file" do
-      @scope.stubs(:lookupvar).with('extlookup_precedence').returns(["one","two"])
+      @scope.stubs(:lookupvar).with('::extlookup_precedence').returns(["one","two"])
       result = @scope.function_extlookup([ "key2" ])
       result.should == "value_two"
     end
 
     it "should not modify extlookup_precedence data" do
       variable = '%{fqdn}'
-      @scope.stubs(:lookupvar).with('extlookup_precedence').returns([variable,"one"])
-      @scope.stubs(:lookupvar).with('fqdn').returns('myfqdn')
+      @scope.stubs(:lookupvar).with('::extlookup_precedence').returns([variable,"one"])
+      @scope.stubs(:lookupvar).with('::fqdn').returns('myfqdn')
       result = @scope.function_extlookup([ "key" ])
       variable.should == '%{fqdn}'
     end
diff --git a/spec/unit/parser/functions/fqdn_rand_spec.rb b/spec/unit/parser/functions/fqdn_rand_spec.rb
index d810741c5..90792e182 100755
--- a/spec/unit/parser/functions/fqdn_rand_spec.rb
+++ b/spec/unit/parser/functions/fqdn_rand_spec.rb
@@ -16,49 +16,49 @@ describe "the fqdn_rand function" do
   end
 
   it "should handle 0 arguments" do
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     lambda { @scope.function_fqdn_rand([]) }.should_not raise_error(Puppet::ParseError)
   end
 
   it "should handle 1 argument'}" do
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     lambda { @scope.function_fqdn_rand([3]) }.should_not raise_error(Puppet::ParseError)
   end
 
 
   (1..10).each { |n|
     it "should handle #{n} additional arguments" do
-      @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+      @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
       lambda { @scope.function_fqdn_rand([3,1,2,3,4,5,6,7,8,9,10][0..n]) }.should_not raise_error(Puppet::ParseError)
     end
     it "should handle #{n} additional string arguments" do
-      @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+      @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
       lambda { @scope.function_fqdn_rand([3,%w{ 1 2 3 4 5 6 7 8 9 10}].flatten[0..n]) }.should_not raise_error(Puppet::ParseError)
     end
   }
 
   it "should return a value less than max" do
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     @scope.function_fqdn_rand([3]).should satisfy {|n| n.to_i < 3 }
   end
 
   it "should return the same values on subsequent invocations for the same host" do
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1").twice
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1").twice
     @scope.function_fqdn_rand([3,4]).should eql(@scope.function_fqdn_rand([3, 4]))
   end
 
   it "should return different sequences of value for different hosts" do
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     val1 = @scope.function_fqdn_rand([10000000,4])
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.2")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.2")
     val2 = @scope.function_fqdn_rand([10000000,4])
     val1.should_not eql(val2)
   end
 
   it "should return different values for the same hosts with different seeds" do
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     val1 = @scope.function_fqdn_rand([10000000,4])
-    @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+    @scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
     val2 = @scope.function_fqdn_rand([10000000,42])
     val1.should_not eql(val2)
   end
diff --git a/spec/unit/parser/scope_spec.rb b/spec/unit/parser/scope_spec.rb
index 44e255956..8215535dd 100755
--- a/spec/unit/parser/scope_spec.rb
+++ b/spec/unit/parser/scope_spec.rb
@@ -73,19 +73,19 @@ describe Puppet::Parser::Scope do
 
       Puppet::Parser::Scope.new.singleton_class.ancestors.should be_include(mod)
     end
-  end
 
-  describe "when looking up a variable" do
-    it "should default to an empty string" do
-      @scope.lookupvar("var").should == ""
+    it "should remember if it is dynamic" do
+      (!!Puppet::Parser::Scope.new(:dynamic => true).dynamic).should == true
     end
 
-    it "should return an string when asked for a string" do
-      @scope.lookupvar("var", true).should == ""
+    it "should assume it is not dynamic" do
+      (!Puppet::Parser::Scope.new.dynamic).should == true
     end
+  end
 
-    it "should return ':undefined' for unset variables when asked not to return a string" do
-      @scope.lookupvar("var", false).should == :undefined
+  describe "when looking up a variable" do
+    it "should return ':undefined' for unset variables" do
+      @scope.lookupvar("var").should == :undefined
     end
 
     it "should be able to look up values" do
@@ -151,32 +151,32 @@ describe Puppet::Parser::Scope do
         @scope.lookupvar("other::deep::klass::var").should == "otherval"
       end
 
-      it "should return an empty string for qualified variables that cannot be found in other classes" do
+      it "should return ':undefined' for qualified variables that cannot be found in other classes" do
         other_scope = create_class_scope("other::deep::klass")
 
-        @scope.lookupvar("other::deep::klass::var").should == ""
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
-      it "should warn and return an empty string for qualified variables whose classes have not been evaluated" do
+      it "should warn and return ':undefined' for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
         @scope.expects(:warning)
-        @scope.lookupvar("other::deep::klass::var").should == ""
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
-      it "should warn and return an empty string for qualified variables whose classes do not exist" do
+      it "should warn and return ':undefined' for qualified variables whose classes do not exist" do
         @scope.expects(:warning)
-        @scope.lookupvar("other::deep::klass::var").should == ""
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should return ':undefined' when asked for a non-string qualified variable from a class that does not exist" do
         @scope.stubs(:warning)
-        @scope.lookupvar("other::deep::klass::var", false).should == :undefined
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should return ':undefined' when asked for a non-string qualified variable from a class that has not been evaluated" do
         @scope.stubs(:warning)
         klass = newclass("other::deep::klass")
-        @scope.lookupvar("other::deep::klass::var", false).should == :undefined
+        @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
     end
   end
@@ -291,7 +291,7 @@ describe Puppet::Parser::Scope do
 
       @scope.unset_ephemeral_var
 
-      @scope.lookupvar("1", false).should == :undefined
+      @scope.lookupvar("1").should == :undefined
     end
 
     it "should not remove classic variables when unset_ephemeral_var is called" do
@@ -301,7 +301,7 @@ describe Puppet::Parser::Scope do
 
       @scope.unset_ephemeral_var
 
-      @scope.lookupvar("myvar", false).should == :value1
+      @scope.lookupvar("myvar").should == :value1
     end
 
     it "should raise an error when setting it again" do
@@ -322,7 +322,7 @@ describe Puppet::Parser::Scope do
         @scope.setvar("0", :earliest, :ephemeral => true)
         @scope.new_ephemeral
         @scope.setvar("0", :latest, :ephemeral => true)
-        @scope.lookupvar("0", false).should == :latest
+        @scope.lookupvar("0").should == :latest
       end
 
       it "should be able to report the current level" do
@@ -353,7 +353,7 @@ describe Puppet::Parser::Scope do
         @scope.setvar("1", :value1, :ephemeral => true)
         @scope.new_ephemeral
         @scope.setvar("0", :value2, :ephemeral => true)
-        @scope.lookupvar("1", false).should == :value1
+        @scope.lookupvar("1").should == :value1
       end
 
       describe "when calling unset_ephemeral_var without a level" do
@@ -364,7 +364,7 @@ describe Puppet::Parser::Scope do
 
           @scope.unset_ephemeral_var
 
-          @scope.lookupvar("1", false).should == :undefined
+          @scope.lookupvar("1").should == :undefined
         end
       end
 
@@ -378,152 +378,9 @@ describe Puppet::Parser::Scope do
 
           @scope.unset_ephemeral_var(2)
 
-          @scope.lookupvar("1", false).should == :value2
-        end
-      end
-    end
-  end
-
-  describe "when interpolating string" do
-    (0..9).each do |n|
-      it "should allow $#{n} to match" do
-        @scope.setvar(n.to_s, "value", :ephemeral => true)
-
-        @scope.strinterp("$#{n}").should == "value"
-      end
-    end
-
-    (0..9).each do |n|
-      it "should not allow $#{n} to match if not ephemeral" do
-        @scope.setvar(n.to_s, "value", :ephemeral => false)
-
-        @scope.strinterp("$#{n}").should_not == "value"
-      end
-    end
-
-    it "should not allow $10 to match" do
-      @scope.setvar("10", "value", :ephemeral => true)
-
-      @scope.strinterp('==$10==').should_not == "==value=="
-    end
-
-    it "should not allow ${10} to match" do
-      @scope.setvar("10", "value", :ephemeral => true)
-
-      @scope.strinterp('==${10}==').should == "==value=="
-    end
-
-    describe "with qualified variables" do
-      before do
-        @scopes = {}
-        klass = @scope.known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
-        Puppet::Parser::Resource.new("class", :main, :scope => @scope, :source => mock('source')).evaluate
-        @scopes[""] = @scope.class_scope(klass)
-        @scopes[""].setvar("test", "value")
-
-        %w{one one::two one::two::three}.each do |name|
-          klass = @scope.known_resource_types.add(Puppet::Resource::Type.new(:hostclass, name))
-          Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source')).evaluate
-          @scopes[name] = @scope.class_scope(klass)
-          @scopes[name].setvar("test", "value-#{name.sub(/.+::/,'')}")
+          @scope.lookupvar("1").should == :value2
         end
       end
-      {
-        "===${one::two::three::test}===" => "===value-three===",
-        "===$one::two::three::test===" => "===value-three===",
-        "===${one::two::test}===" => "===value-two===",
-        "===$one::two::test===" => "===value-two===",
-        "===${one::test}===" => "===value-one===",
-        "===$one::test===" => "===value-one===",
-        "===${::test}===" => "===value===",
-        "===$::test===" => "===value==="
-      }.each do |input, output|
-        it "should parse '#{input}' correctly" do
-          @scope.strinterp(input).should == output
-        end
-      end
-    end
-
-    tests = {
-      "===${test}===" => "===value===",
-      "===${test} ${test} ${test}===" => "===value value value===",
-      "===$test ${test} $test===" => "===value value value===",
-      "===\\$test===" => "===$test===",
-      '===\\$test string===' => "===$test string===",
-      '===$test string===' => "===value string===",
-      '===a testing $===' => "===a testing $===",
-      '===a testing \$===' => "===a testing $===",
-      "===an escaped \\\n carriage return===" => "===an escaped  carriage return===",
-      '\$' => "$",
-      '\s' => "\s",
-      '\t' => "\t",
-      '\n' => "\n"
-    }
-
-    tests.each do |input, output|
-      it "should parse '#{input}' correctly" do
-        @scope.setvar("test", "value")
-        @scope.strinterp(input).should == output
-      end
-    end
-
-    # #523
-    %w{d f h l w z}.each do |l|
-      it "should parse '#{l}' when escaped" do
-        string = "\\#{l}"
-        @scope.strinterp(string).should == string
-      end
-    end
-  end
-
-  def test_strinterp
-    # Make and evaluate our classes so the qualified lookups work
-    parser = mkparser
-    klass = parser.newclass("")
-    scope = mkscope(:parser => parser)
-    Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => scope, :source => mock('source')).evaluate
-
-    assert_nothing_raised {
-      scope.setvar("test","value")
-    }
-
-    scopes = {"" => scope}
-
-    %w{one one::two one::two::three}.each do |name|
-      klass = parser.newclass(name)
-      Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
-      scopes[name] = scope.class_scope(klass)
-      scopes[name].setvar("test", "value-#{name.sub(/.+::/,'')}")
-    end
-
-    assert_equal("value", scope.lookupvar("::test"), "did not look up qualified value correctly")
-    tests.each do |input, output|
-      assert_nothing_raised("Failed to scan #{input.inspect}") do
-        assert_equal(output, scope.strinterp(input), 'did not parserret %s correctly' % input.inspect)
-      end
-    end
-
-    logs = []
-    Puppet::Util::Log.close
-    Puppet::Util::Log.newdestination(logs)
-
-    # #523
-    %w{d f h l w z}.each do |l|
-      string = "\\#{l}"
-      assert_nothing_raised do
-
-              assert_equal(
-        string, scope.strinterp(string),
-        
-          'did not parserret %s correctly' % string)
-      end
-
-
-            assert(
-        logs.detect { |m| m.message =~ /Unrecognised escape/ },
-        
-        "Did not get warning about escape sequence with #{string}")
-      logs.clear
     end
   end
 
@@ -563,13 +420,13 @@ describe Puppet::Parser::Scope do
     it "should be able to unset normal variables" do
       @scope.setvar("foo", "bar")
       @scope.unsetvar("foo")
-      @scope.lookupvar("foo").should == ""
+      @scope.lookupvar("foo").should == :undefined
     end
 
     it "should be able to unset ephemeral variables" do
       @scope.setvar("0", "bar", :ephemeral => true)
       @scope.unsetvar("0")
-      @scope.lookupvar("0").should == ""
+      @scope.lookupvar("0").should == :undefined
     end
 
     it "should not unset ephemeral variables in previous ephemeral scope" do
diff --git a/spec/unit/parser/templatewrapper_spec.rb b/spec/unit/parser/templatewrapper_spec.rb
index afb0032fd..0c7199ba1 100755
--- a/spec/unit/parser/templatewrapper_spec.rb
+++ b/spec/unit/parser/templatewrapper_spec.rb
@@ -17,6 +17,12 @@ describe Puppet::Parser::TemplateWrapper do
     @tw = Puppet::Parser::TemplateWrapper.new(@scope)
   end
 
+  def mock_template(source=nil)
+    template_mock = mock("template", :result => "woot!")
+    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+    template_mock.expects(:filename=).with(source)
+  end
+
   it "should create a new object TemplateWrapper from a scope" do
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
 
@@ -54,41 +60,38 @@ describe Puppet::Parser::TemplateWrapper do
   end
 
   it "should return the processed template contents with a call to result" do
-    template_mock = mock("template", :result => "woot!")
+    mock_template("/tmp/fake_template")
     File.expects(:read).with("/tmp/fake_template").returns("template contents")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @tw.file = @file
     @tw.result.should eql("woot!")
   end
 
   it "should return the processed template contents with a call to result and a string" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
-
+    mock_template
     @tw.result("template contents").should eql("woot!")
   end
 
   it "should return the contents of a variable if called via method_missing" do
-    @scope.expects(:lookupvar).with("chicken", false).returns("is good")
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.chicken.should eql("is good")
   end
 
   it "should throw an exception if a variable is called via method_missing and it does not exist" do
-    @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     lambda { tw.chicken }.should raise_error(Puppet::ParseError)
   end
 
   it "should allow you to check whether a variable is defined with has_variable?" do
-    @scope.expects(:lookupvar).with("chicken", false).returns("is good")
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(true)
   end
 
   it "should allow you to check whether a variable is not defined with has_variable?" do
-    @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(false)
   end
@@ -114,9 +117,7 @@ describe Puppet::Parser::TemplateWrapper do
   end
 
   it "should set all of the scope's variables as instance variables" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
-
+    mock_template
     @scope.expects(:to_hash).returns("one" => "foo")
     @tw.result("template contents")
 
@@ -124,8 +125,7 @@ describe Puppet::Parser::TemplateWrapper do
   end
 
   it "should not error out if one of the variables is a symbol" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+    mock_template
 
     @scope.expects(:to_hash).returns(:_timestamp => "1234")
     @tw.result("template contents")
@@ -133,13 +133,11 @@ describe Puppet::Parser::TemplateWrapper do
 
   %w{! . ; :}.each do |badchar|
     it "should translate #{badchar} to _ when setting the instance variables" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
-
-    @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
-    @tw.result("template contents")
+      mock_template
+      @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
+      @tw.result("template contents")
 
-    @tw.instance_variable_get("@one_").should == "foo"
-  end
+      @tw.instance_variable_get("@one_").should == "foo"
+    end
   end
 end