Merge pull request #80 from jeffmccune/fix/2.3.x/go_green

Fix up 2.3.x for new scope

59 files changed, 322 insertions, 813 deletions

diff --git a/spec/unit/puppet/parser/functions/abs_spec.rb b/spec/unit/puppet/parser/functions/abs_spec.rb
index 65ba2e8..c0b4297 100755
--- a/spec/unit/puppet/parser/functions/abs_spec.rb
+++ b/spec/unit/puppet/parser/functions/abs_spec.rb
@@ -1,31 +1,25 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
+
 require 'spec_helper'
 
 describe "the abs function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("abs").should == "function_abs"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should convert a negative number into a positive" do
-    result = @scope.function_abs(["-34"])
+    result = scope.function_abs(["-34"])
     result.should(eq(34))
   end
 
   it "should do nothing with a positive number" do
-    result = @scope.function_abs(["5678"])
+    result = scope.function_abs(["5678"])
     result.should(eq(5678))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/bool2num_spec.rb b/spec/unit/puppet/parser/functions/bool2num_spec.rb
index d5da18c..518ac85 100755
--- a/spec/unit/puppet/parser/functions/bool2num_spec.rb
+++ b/spec/unit/puppet/parser/functions/bool2num_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the bool2num function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("bool2num").should == "function_bool2num"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should convert true to 1" do
-    result = @scope.function_bool2num([true])
+    result = scope.function_bool2num([true])
     result.should(eq(1))
   end
 
   it "should convert false to 0" do
-    result = @scope.function_bool2num([false])
+    result = scope.function_bool2num([false])
     result.should(eq(0))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/capitalize_spec.rb b/spec/unit/puppet/parser/functions/capitalize_spec.rb
index 1c45821..69c9758 100755
--- a/spec/unit/puppet/parser/functions/capitalize_spec.rb
+++ b/spec/unit/puppet/parser/functions/capitalize_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the capitalize function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("capitalize").should == "function_capitalize"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should capitalize the beginning of a string" do
-    result = @scope.function_capitalize(["abc"])
+    result = scope.function_capitalize(["abc"])
     result.should(eq("Abc"))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/chomp_spec.rb b/spec/unit/puppet/parser/functions/chomp_spec.rb
index 0592115..e425365 100755
--- a/spec/unit/puppet/parser/functions/chomp_spec.rb
+++ b/spec/unit/puppet/parser/functions/chomp_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the chomp function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("chomp").should == "function_chomp"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should chomp the end of a string" do
-    result = @scope.function_chomp(["abc\n"])
+    result = scope.function_chomp(["abc\n"])
     result.should(eq("abc"))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/chop_spec.rb b/spec/unit/puppet/parser/functions/chop_spec.rb
index 0c456a8..9e466de 100755
--- a/spec/unit/puppet/parser/functions/chop_spec.rb
+++ b/spec/unit/puppet/parser/functions/chop_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the chop function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("chop").should == "function_chop"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should chop the end of a string" do
-    result = @scope.function_chop(["asdf\n"])
+    result = scope.function_chop(["asdf\n"])
     result.should(eq("asdf"))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/delete_at_spec.rb b/spec/unit/puppet/parser/functions/delete_at_spec.rb
index 27db0c8..d8d9618 100755
--- a/spec/unit/puppet/parser/functions/delete_at_spec.rb
+++ b/spec/unit/puppet/parser/functions/delete_at_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the delete_at function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("delete_at").should == "function_delete_at"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should delete an item at specified location from an array" do
-    result = @scope.function_delete_at([['a','b','c'],1])
+    result = scope.function_delete_at([['a','b','c'],1])
     result.should(eq(['a','c']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/delete_spec.rb b/spec/unit/puppet/parser/functions/delete_spec.rb
index fab3230..0549232 100755
--- a/spec/unit/puppet/parser/functions/delete_spec.rb
+++ b/spec/unit/puppet/parser/functions/delete_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the delete function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("delete").should == "function_delete"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_delete([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_delete([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should delete an item from an array" do
-    result = @scope.function_delete([['a','b','c'],'b'])
+    result = scope.function_delete([['a','b','c'],'b'])
     result.should(eq(['a','c']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/downcase_spec.rb b/spec/unit/puppet/parser/functions/downcase_spec.rb
index 0bccd5f..acef1f0 100755
--- a/spec/unit/puppet/parser/functions/downcase_spec.rb
+++ b/spec/unit/puppet/parser/functions/downcase_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the downcase function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("downcase").should == "function_downcase"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_downcase([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_downcase([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should downcase a string" do
-    result = @scope.function_downcase(["ASFD"])
+    result = scope.function_downcase(["ASFD"])
     result.should(eq("asfd"))
   end
 
   it "should do nothing to a string that is already downcase" do
-    result = @scope.function_downcase(["asdf asdf"])
+    result = scope.function_downcase(["asdf asdf"])
     result.should(eq("asdf asdf"))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/empty_spec.rb b/spec/unit/puppet/parser/functions/empty_spec.rb
index cb0021f..7745875 100755
--- a/spec/unit/puppet/parser/functions/empty_spec.rb
+++ b/spec/unit/puppet/parser/functions/empty_spec.rb
@@ -1,31 +1,23 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the empty function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
     Puppet::Parser::Functions.function("empty").should == "function_empty"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_empty([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_empty([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return a true for an empty string" do
-    result = @scope.function_empty([''])
+    result = scope.function_empty([''])
     result.should(eq(true))
   end
 
   it "should return a false for a non-empty string" do
-    result = @scope.function_empty(['asdf'])
+    result = scope.function_empty(['asdf'])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/flatten_spec.rb b/spec/unit/puppet/parser/functions/flatten_spec.rb
index 7bedeb2..d4dfd20 100755
--- a/spec/unit/puppet/parser/functions/flatten_spec.rb
+++ b/spec/unit/puppet/parser/functions/flatten_spec.rb
@@ -1,31 +1,23 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the flatten function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
     Puppet::Parser::Functions.function("flatten").should == "function_flatten"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should flatten a complex data structure" do
-    result = @scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
+    result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
     result.should(eq(["a","b","c","d","e","f","g"]))
   end
 
   it "should do nothing to a structure that is already flat" do
-    result = @scope.function_flatten([["a","b","c","d"]])
+    result = scope.function_flatten([["a","b","c","d"]])
     result.should(eq(["a","b","c","d"]))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/get_module_path_spec.rb b/spec/unit/puppet/parser/functions/get_module_path_spec.rb
index d8340f4..0a769eb 100644
--- a/spec/unit/puppet/parser/functions/get_module_path_spec.rb
+++ b/spec/unit/puppet/parser/functions/get_module_path_spec.rb
@@ -1,42 +1,44 @@
-#!/usr/bin/env rspec
-require 'puppet'
-require 'fileutils'
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
+
 describe Puppet::Parser::Functions.function(:get_module_path) do
-  include PuppetSpec::Files
+  Internals = PuppetlabsSpec::PuppetInternals
 
-  def get_scope(environment = 'production')
-    scope = Puppet::Parser::Scope.new
-    scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => environment))
-    scope
+  def scope(environment = "production")
+    Internals.scope(:compiler => Internals.compiler(:node => Internals.node(:environment => environment)))
   end
+
   it 'should only allow one argument' do
-    expect { get_scope.function_get_module_path([]) }.should raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
-    expect { get_scope.function_get_module_path(['1','2','3']) }.should raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
+    expect { scope.function_get_module_path([]) }.should raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
+    expect { scope.function_get_module_path(['1','2','3']) }.should raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
   end
   it 'should raise an exception when the module cannot be found' do
-    expect { get_scope.function_get_module_path(['foo']) }.should raise_error(Puppet::ParseError, /Could not find module/)
+    expect { scope.function_get_module_path(['foo']) }.should raise_error(Puppet::ParseError, /Could not find module/)
   end
   describe 'when locating a module' do
-    let(:modulepath) { tmpdir('modulepath') }
-    let(:foo_path) { File.join(modulepath, 'foo') }
-    before(:each) { FileUtils.mkdir(foo_path) }
+    let(:modulepath) { "/tmp/does_not_exist" }
+    let(:path_of_module_foo) do
+      mod = mock("Puppet::Module")
+      mod.stubs(:path).returns("/tmp/does_not_exist/foo")
+      mod
+    end
+
+    before(:each) { Puppet[:modulepath] = modulepath }
+
     it 'should be able to find module paths from the modulepath setting' do
-      Puppet[:modulepath] = modulepath
-      get_scope.function_get_module_path(['foo']).should == foo_path
+      Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
+      scope.function_get_module_path(['foo']).should == path_of_module_foo.path
     end
     it 'should be able to find module paths when the modulepath is a list' do
       Puppet[:modulepath] = modulepath + ":/tmp"
-      get_scope.function_get_module_path(['foo']).should == foo_path
+      Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
+      scope.function_get_module_path(['foo']).should == path_of_module_foo.path
     end
-    it 'should be able to find module paths from the environment' do
-      conf_file = tmpfile('conffile')
-      File.open(conf_file, 'w') do |fh|
-        fh.write("[dansenvironment]\nmodulepath = #{modulepath}")
-      end
-      Puppet[:config] = conf_file
-      Puppet.parse_config
-      get_scope('dansenvironment').function_get_module_path(['foo']).should ==foo_path
+    it 'should respect the environment' do
+      pending("Disabled on Puppet 2.6.x") if Puppet.version =~ /^2\.6\b/
+      Puppet.settings[:environment] = 'danstestenv'
+      Puppet::Module.expects(:find).with('foo', 'danstestenv').returns(path_of_module_foo)
+      scope('danstestenv').function_get_module_path(['foo']).should == path_of_module_foo.path
     end
   end
 end
diff --git a/spec/unit/puppet/parser/functions/getvar_spec.rb b/spec/unit/puppet/parser/functions/getvar_spec.rb
index 16edd98..62ad192 100644
--- a/spec/unit/puppet/parser/functions/getvar_spec.rb
+++ b/spec/unit/puppet/parser/functions/getvar_spec.rb
@@ -1,36 +1,17 @@
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
 
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
 describe Puppet::Parser::Functions.function(:getvar) do
-
-  # Pulled from Dan's create_resources function
-  def get_scope
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
-    @scope = Puppet::Parser::Scope.new
-    @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @scope.parent = @topscope
-    @compiler = @scope.compiler
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   describe 'when calling getvar from puppet' do
 
     it "should not compile when no arguments are passed" do
       Puppet[:code] = 'getvar()'
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
     it "should not compile when too many arguments are passed" do
       Puppet[:code] = 'getvar("foo::bar", "baz")'
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
 
     it "should lookup variables in other namespaces" do
@@ -43,11 +24,7 @@ describe Puppet::Parser::Functions.function(:getvar) do
           fail('getvar did not return what we expect')
         }
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
-
   end
-
 end
-
diff --git a/spec/unit/puppet/parser/functions/grep_spec.rb b/spec/unit/puppet/parser/functions/grep_spec.rb
index b1f647c..a93b842 100755
--- a/spec/unit/puppet/parser/functions/grep_spec.rb
+++ b/spec/unit/puppet/parser/functions/grep_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the grep function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("grep").should == "function_grep"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_grep([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_grep([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should grep contents from an array" do
-    result = @scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
+    result = scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
     result.should(eq(["aaabbb","bbbccc"]))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/has_key_spec.rb b/spec/unit/puppet/parser/functions/has_key_spec.rb
index d1dcd15..ae5baf7 100644
--- a/spec/unit/puppet/parser/functions/has_key_spec.rb
+++ b/spec/unit/puppet/parser/functions/has_key_spec.rb
@@ -1,37 +1,21 @@
-require 'puppet'
-require 'mocha'
-describe Puppet::Parser::Functions.function(:has_key) do
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
 
-  # Pulled from Dan's create_resources function
-  # TODO - this should be moved to spec_helper since the
-  # logic is likely to be applied to multiple rspec files.
-  let(:compiler) {
-    topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    topscope.parent = nil
-    my_scope = Puppet::Parser::Scope.new
-    my_scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    my_scope.parent = topscope
-    compiler = my_scope.compiler
-  }
-  let(:scope) {
-    scope = Puppet::Parser::Scope.new
-    scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
-    scope
-  }
+describe Puppet::Parser::Functions.function(:has_key) do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   describe 'when calling has_key from puppet' do
     it "should not compile when no arguments are passed" do
       Puppet[:code] = 'has_key()'
-      expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
     it "should not compile when 1 argument is passed" do
       Puppet[:code] = "has_key('foo')"
-      expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
     it "should require the first value to be a Hash" do
       Puppet[:code] = "has_key('foo', 'bar')"
-      expect { compiler.compile }.should raise_error(Puppet::ParseError, /expects the first argument to be a hash/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /expects the first argument to be a hash/)
     end
   end
   describe 'when calling the function has_key from a scope instance' do
@@ -42,5 +26,4 @@ describe Puppet::Parser::Functions.function(:has_key) do
       scope.function_has_key([{'one' => 1}, 'two']).should be_false
     end
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/hash_spec.rb b/spec/unit/puppet/parser/functions/hash_spec.rb
index 6d3d48c..7c91be9 100644
--- a/spec/unit/puppet/parser/functions/hash_spec.rb
+++ b/spec/unit/puppet/parser/functions/hash_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the hash function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("hash").should == "function_hash"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_hash([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_hash([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should convert an array to a hash" do
-    result = @scope.function_hash([['a',1,'b',2,'c',3]])
+    result = scope.function_hash([['a',1,'b',2,'c',3]])
     result.should(eq({'a'=>1,'b'=>2,'c'=>3}))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_array_spec.rb b/spec/unit/puppet/parser/functions/is_array_spec.rb
index 537595c..e7f4bcd 100644
--- a/spec/unit/puppet/parser/functions/is_array_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_array_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_array function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_array").should == "function_is_array"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_array([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_array([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if passed an array" do
-    result = @scope.function_is_array([[1,2,3]])
+    result = scope.function_is_array([[1,2,3]])
     result.should(eq(true))
   end
 
   it "should return false if passed a hash" do
-    result = @scope.function_is_array([{'a'=>1}])
+    result = scope.function_is_array([{'a'=>1}])
     result.should(eq(false))
   end
 
   it "should return false if passed a string" do
-    result = @scope.function_is_array(["asdf"])
+    result = scope.function_is_array(["asdf"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_domain_name_spec.rb b/spec/unit/puppet/parser/functions/is_domain_name_spec.rb
index ccd3276..f2ea76d 100644
--- a/spec/unit/puppet/parser/functions/is_domain_name_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_domain_name_spec.rb
@@ -1,12 +1,8 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_domain_name function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  let(:scope) { Puppet::Parser::Scope.new }
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_domain_name").should == "function_is_domain_name"
diff --git a/spec/unit/puppet/parser/functions/is_float_spec.rb b/spec/unit/puppet/parser/functions/is_float_spec.rb
index 55ba8cf..2f527d9 100644
--- a/spec/unit/puppet/parser/functions/is_float_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_float_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_float function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_float").should == "function_is_float"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_float([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_float([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a float" do
-    result = @scope.function_is_float(["0.12"])
+    result = scope.function_is_float(["0.12"])
     result.should(eq(true))
   end
 
   it "should return false if a string" do
-    result = @scope.function_is_float(["asdf"])
+    result = scope.function_is_float(["asdf"])
     result.should(eq(false))
   end
 
   it "should return false if an integer" do
-    result = @scope.function_is_float(["3"])
+    result = scope.function_is_float(["3"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_hash_spec.rb b/spec/unit/puppet/parser/functions/is_hash_spec.rb
index 94364f5..bbebf39 100644
--- a/spec/unit/puppet/parser/functions/is_hash_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_hash_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_hash function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_hash").should == "function_is_hash"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if passed a hash" do
-    result = @scope.function_is_hash([{"a"=>1,"b"=>2}])
+    result = scope.function_is_hash([{"a"=>1,"b"=>2}])
     result.should(eq(true))
   end
 
   it "should return false if passed an array" do
-    result = @scope.function_is_hash([["a","b"]])
+    result = scope.function_is_hash([["a","b"]])
     result.should(eq(false))
   end
 
   it "should return false if passed a string" do
-    result = @scope.function_is_hash(["asdf"])
+    result = scope.function_is_hash(["asdf"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_integer_spec.rb b/spec/unit/puppet/parser/functions/is_integer_spec.rb
index faf6f2d..5afbba4 100644
--- a/spec/unit/puppet/parser/functions/is_integer_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_integer_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_integer function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_integer").should == "function_is_integer"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if an integer" do
-    result = @scope.function_is_integer(["3"])
+    result = scope.function_is_integer(["3"])
     result.should(eq(true))
   end
 
   it "should return false if a float" do
-    result = @scope.function_is_integer(["3.2"])
+    result = scope.function_is_integer(["3.2"])
     result.should(eq(false))
   end
 
   it "should return false if a string" do
-    result = @scope.function_is_integer(["asdf"])
+    result = scope.function_is_integer(["asdf"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_ip_address_spec.rb b/spec/unit/puppet/parser/functions/is_ip_address_spec.rb
index 98ce828..c0debb3 100644
--- a/spec/unit/puppet/parser/functions/is_ip_address_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_ip_address_spec.rb
@@ -1,45 +1,39 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_ip_address function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_ip_address").should == "function_is_ip_address"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if an IPv4 address" do
-    result = @scope.function_is_ip_address(["1.2.3.4"])
+    result = scope.function_is_ip_address(["1.2.3.4"])
     result.should(eq(true))
   end
 
   it "should return true if a full IPv6 address" do
-    result = @scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
+    result = scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
     result.should(eq(true))
   end
 
   it "should return true if a compressed IPv6 address" do
-    result = @scope.function_is_ip_address(["fe00::1"])
+    result = scope.function_is_ip_address(["fe00::1"])
     result.should(eq(true))
   end
 
   it "should return false if not valid" do
-    result = @scope.function_is_ip_address(["asdf"])
+    result = scope.function_is_ip_address(["asdf"])
     result.should(eq(false))
   end
 
   it "should return false if IP octets out of range" do
-    result = @scope.function_is_ip_address(["1.1.1.300"])
+    result = scope.function_is_ip_address(["1.1.1.300"])
     result.should(eq(false))
   end
 end
diff --git a/spec/unit/puppet/parser/functions/is_mac_address_spec.rb b/spec/unit/puppet/parser/functions/is_mac_address_spec.rb
index c9b9637..ca9c590 100644
--- a/spec/unit/puppet/parser/functions/is_mac_address_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_mac_address_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_mac_address function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_mac_address").should == "function_is_mac_address"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a valid mac address" do
-    result = @scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
+    result = scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
     result.should(eq(true))
   end
 
   it "should return false if octets are out of range" do
-    result = @scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
+    result = scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
     result.should(eq(false))
   end
 
   it "should return false if not valid" do
-    result = @scope.function_is_mac_address(["not valid"])
+    result = scope.function_is_mac_address(["not valid"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_numeric_spec.rb b/spec/unit/puppet/parser/functions/is_numeric_spec.rb
index 2191b7b..4078b37 100644
--- a/spec/unit/puppet/parser/functions/is_numeric_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_numeric_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_numeric function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_numeric").should == "function_is_numeric"
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
-    lambda { @scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if an integer" do
-    result = @scope.function_is_numeric(["3"])
+    result = scope.function_is_numeric(["3"])
     result.should(eq(true))
   end
 
   it "should return true if a float" do
-    result = @scope.function_is_numeric(["3.2"])
+    result = scope.function_is_numeric(["3.2"])
     result.should(eq(true))
   end
 
   it "should return false if a string" do
-    result = @scope.function_is_numeric(["asdf"])
+    result = scope.function_is_numeric(["asdf"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/is_string_spec.rb b/spec/unit/puppet/parser/functions/is_string_spec.rb
index 4f3f5fd..3756bea 100644
--- a/spec/unit/puppet/parser/functions/is_string_spec.rb
+++ b/spec/unit/puppet/parser/functions/is_string_spec.rb
@@ -1,41 +1,34 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the is_string function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("is_string").should == "function_is_string"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a string" do
-    result = @scope.function_is_string(["asdf"])
+    result = scope.function_is_string(["asdf"])
     result.should(eq(true))
   end
 
   it "should return false if an integer" do
-    result = @scope.function_is_string(["3"])
+    result = scope.function_is_string(["3"])
     result.should(eq(false))
   end
 
   it "should return false if a float" do
-    result = @scope.function_is_string(["3.23"])
+    result = scope.function_is_string(["3.23"])
     result.should(eq(false))
   end
 
   it "should return false if an array" do
-    result = @scope.function_is_string([["a","b","c"]])
+    result = scope.function_is_string([["a","b","c"]])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/join_spec.rb b/spec/unit/puppet/parser/functions/join_spec.rb
index 1b3dec8..aafa1a7 100644
--- a/spec/unit/puppet/parser/functions/join_spec.rb
+++ b/spec/unit/puppet/parser/functions/join_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the join function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("join").should == "function_join"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_join([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_join([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should join an array into a string" do
-    result = @scope.function_join([["a","b","c"], ":"])
+    result = scope.function_join([["a","b","c"], ":"])
     result.should(eq("a:b:c"))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/keys_spec.rb b/spec/unit/puppet/parser/functions/keys_spec.rb
index d928562..fdd7a70 100644
--- a/spec/unit/puppet/parser/functions/keys_spec.rb
+++ b/spec/unit/puppet/parser/functions/keys_spec.rb
@@ -1,12 +1,8 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the keys function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  let(:scope) { Puppet::Parser::Scope.new }
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("keys").should == "function_keys"
diff --git a/spec/unit/puppet/parser/functions/lstrip_spec.rb b/spec/unit/puppet/parser/functions/lstrip_spec.rb
index ac331fa..b280ae7 100644
--- a/spec/unit/puppet/parser/functions/lstrip_spec.rb
+++ b/spec/unit/puppet/parser/functions/lstrip_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the lstrip function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("lstrip").should == "function_lstrip"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should lstrip a string" do
-    result = @scope.function_lstrip(["  asdf"])
+    result = scope.function_lstrip(["  asdf"])
     result.should(eq('asdf'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/member_spec.rb b/spec/unit/puppet/parser/functions/member_spec.rb
index 2cebc0d..6e9a023 100644
--- a/spec/unit/puppet/parser/functions/member_spec.rb
+++ b/spec/unit/puppet/parser/functions/member_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the member function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("member").should == "function_member"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_member([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_member([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if a member is in an array" do
-    result = @scope.function_member([["a","b","c"], "a"])
+    result = scope.function_member([["a","b","c"], "a"])
     result.should(eq(true))
-  end  
+  end
 
   it "should return false if a member is not in an array" do
-    result = @scope.function_member([["a","b","c"], "d"])
+    result = scope.function_member([["a","b","c"], "d"])
     result.should(eq(false))
-  end  
-
+  end
 end
diff --git a/spec/unit/puppet/parser/functions/merge_spec.rb b/spec/unit/puppet/parser/functions/merge_spec.rb
index 71e1869..9e8a619 100644
--- a/spec/unit/puppet/parser/functions/merge_spec.rb
+++ b/spec/unit/puppet/parser/functions/merge_spec.rb
@@ -1,33 +1,18 @@
-require 'puppet'
-require 'mocha'
-describe Puppet::Parser::Functions.function(:merge) do
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
 
-  # Pulled from Dan's create_resources function
-  # TODO - these let statements should be moved somewhere
-  # where they can be resued
-  let(:compiler) {
-    topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    topscope.parent = nil
-    my_scope = Puppet::Parser::Scope.new
-    my_scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    my_scope.parent = topscope
-    compiler = my_scope.compiler
-  }
-  let(:scope) {
-    scope = Puppet::Parser::Scope.new
-    scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
-    scope
-  }
+describe Puppet::Parser::Functions.function(:merge) do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   describe 'when calling merge from puppet' do
     it "should not compile when no arguments are passed" do
       Puppet[:code] = 'merge()'
-      expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
     it "should not compile when 1 argument is passed" do
       Puppet[:code] = "$my_hash={'one' => 1}\nmerge($my_hash)"
-      expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
   end
   describe 'when calling merge on the scope instance' do
@@ -48,7 +33,5 @@ describe Puppet::Parser::Functions.function(:merge) do
     it 'should accept empty hashes' do
       scope.function_merge([{},{},{}]).should == {}
     end
-
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb
index 6585273..640c689 100644
--- a/spec/unit/puppet/parser/functions/num2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the num2bool function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("num2bool").should == "function_num2bool"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return true if 1" do
-    result = @scope.function_num2bool(["1"])
+    result = scope.function_num2bool(["1"])
     result.should(be_true)
   end
 
   it "should return false if 0" do
-    result = @scope.function_num2bool(["0"])
+    result = scope.function_num2bool(["0"])
     result.should(be_false)
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/parsejson_spec.rb b/spec/unit/puppet/parser/functions/parsejson_spec.rb
index 26eea36..f179ac1 100644
--- a/spec/unit/puppet/parser/functions/parsejson_spec.rb
+++ b/spec/unit/puppet/parser/functions/parsejson_spec.rb
@@ -1,29 +1,22 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the parsejson function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("parsejson").should == "function_parsejson"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should convert JSON to a data structure" do
     json = <<-EOS
 ["aaa","bbb","ccc"]
 EOS
-    result = @scope.function_parsejson([json])
+    result = scope.function_parsejson([json])
     result.should(eq(['aaa','bbb','ccc']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/parseyaml_spec.rb b/spec/unit/puppet/parser/functions/parseyaml_spec.rb
index f9cb049..0c7aea8 100644
--- a/spec/unit/puppet/parser/functions/parseyaml_spec.rb
+++ b/spec/unit/puppet/parser/functions/parseyaml_spec.rb
@@ -1,21 +1,15 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the parseyaml function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("parseyaml").should == "function_parseyaml"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should convert YAML to a data structure" do
@@ -24,8 +18,7 @@ describe "the parseyaml function" do
 - bbb
 - ccc
 EOS
-    result = @scope.function_parseyaml([yaml])
+    result = scope.function_parseyaml([yaml])
     result.should(eq(['aaa','bbb','ccc']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/prefix_spec.rb b/spec/unit/puppet/parser/functions/prefix_spec.rb
index a0cbcab..5cf592b 100644
--- a/spec/unit/puppet/parser/functions/prefix_spec.rb
+++ b/spec/unit/puppet/parser/functions/prefix_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the prefix function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("prefix").should == "function_prefix"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_prefix([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_prefix([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return a prefixed array" do
-    result = @scope.function_prefix([['a','b','c'], 'p'])
+    result = scope.function_prefix([['a','b','c'], 'p'])
     result.should(eq(['pa','pb','pc']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/range_spec.rb b/spec/unit/puppet/parser/functions/range_spec.rb
index 060423a..42751f4 100644
--- a/spec/unit/puppet/parser/functions/range_spec.rb
+++ b/spec/unit/puppet/parser/functions/range_spec.rb
@@ -1,14 +1,8 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the range function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  let :scope do
-    Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("range").should == "function_range"
diff --git a/spec/unit/puppet/parser/functions/reverse_spec.rb b/spec/unit/puppet/parser/functions/reverse_spec.rb
index 4fa50e4..1b59206 100644
--- a/spec/unit/puppet/parser/functions/reverse_spec.rb
+++ b/spec/unit/puppet/parser/functions/reverse_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the reverse function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("reverse").should == "function_reverse"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_reverse([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_reverse([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should reverse a string" do
-    result = @scope.function_reverse(["asdfghijkl"])
+    result = scope.function_reverse(["asdfghijkl"])
     result.should(eq('lkjihgfdsa'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/rstrip_spec.rb b/spec/unit/puppet/parser/functions/rstrip_spec.rb
index af8cc12..d90de1d 100644
--- a/spec/unit/puppet/parser/functions/rstrip_spec.rb
+++ b/spec/unit/puppet/parser/functions/rstrip_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the rstrip function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("rstrip").should == "function_rstrip"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should rstrip a string" do
-    result = @scope.function_rstrip(["asdf  "])
+    result = scope.function_rstrip(["asdf  "])
     result.should(eq('asdf'))
   end
 
   it "should rstrip each element in an array" do
-    result = @scope.function_rstrip([["a ","b ", "c "]])
+    result = scope.function_rstrip([["a ","b ", "c "]])
     result.should(eq(['a','b','c']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/shuffle_spec.rb b/spec/unit/puppet/parser/functions/shuffle_spec.rb
index f04fda5..93346d5 100644
--- a/spec/unit/puppet/parser/functions/shuffle_spec.rb
+++ b/spec/unit/puppet/parser/functions/shuffle_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the shuffle function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("shuffle").should == "function_shuffle"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_shuffle([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_shuffle([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should shuffle a string and the result should be the same size" do
-    result = @scope.function_shuffle(["asdf"])
+    result = scope.function_shuffle(["asdf"])
     result.size.should(eq(4))
   end
 
   it "should shuffle a string but the sorted contents should still be the same" do
-    result = @scope.function_shuffle(["adfs"])
+    result = scope.function_shuffle(["adfs"])
     result.split("").sort.join("").should(eq("adfs"))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/size_spec.rb b/spec/unit/puppet/parser/functions/size_spec.rb
index ccaa335..b1c435a 100644
--- a/spec/unit/puppet/parser/functions/size_spec.rb
+++ b/spec/unit/puppet/parser/functions/size_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the size function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("size").should == "function_size"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_size([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_size([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return the size of a string" do
-    result = @scope.function_size(["asdf"])
+    result = scope.function_size(["asdf"])
     result.should(eq(4))
   end
 
   it "should return the size of an array" do
-    result = @scope.function_size([["a","b","c"]])
+    result = scope.function_size([["a","b","c"]])
     result.should(eq(3))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/sort_spec.rb b/spec/unit/puppet/parser/functions/sort_spec.rb
index fbe3073..3187a5a 100644
--- a/spec/unit/puppet/parser/functions/sort_spec.rb
+++ b/spec/unit/puppet/parser/functions/sort_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the sort function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("sort").should == "function_sort"
   end
 
   it "should raise a ParseError if there is not 1 arguments" do
-    lambda { @scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should sort an array" do
-    result = @scope.function_sort([["a","c","b"]])
+    result = scope.function_sort([["a","c","b"]])
     result.should(eq(['a','b','c']))
   end
 
   it "should sort a string" do
-    result = @scope.function_sort(["acb"])
+    result = scope.function_sort(["acb"])
     result.should(eq('abc'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/squeeze_spec.rb b/spec/unit/puppet/parser/functions/squeeze_spec.rb
index 9355ad2..60e5a30 100644
--- a/spec/unit/puppet/parser/functions/squeeze_spec.rb
+++ b/spec/unit/puppet/parser/functions/squeeze_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the squeeze function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("squeeze").should == "function_squeeze"
   end
 
   it "should raise a ParseError if there is less than 2 arguments" do
-    lambda { @scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should squeeze a string" do
-    result = @scope.function_squeeze(["aaabbbbcccc"])
+    result = scope.function_squeeze(["aaabbbbcccc"])
     result.should(eq('abc'))
   end
 
   it "should squeeze all elements in an array" do
-    result = @scope.function_squeeze([["aaabbbbcccc","dddfff"]])
+    result = scope.function_squeeze([["aaabbbbcccc","dddfff"]])
     result.should(eq(['abc','df']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/str2bool_spec.rb b/spec/unit/puppet/parser/functions/str2bool_spec.rb
index d7f0ac9..2782bbe 100644
--- a/spec/unit/puppet/parser/functions/str2bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/str2bool_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the str2bool function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("str2bool").should == "function_str2bool"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should convert string 'true' to true" do
-    result = @scope.function_str2bool(["true"])
+    result = scope.function_str2bool(["true"])
     result.should(eq(true))
   end
 
   it "should convert string 'undef' to false" do
-    result = @scope.function_str2bool(["undef"])
+    result = scope.function_str2bool(["undef"])
     result.should(eq(false))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb b/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb
index 11485aa..a692c31 100644
--- a/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb
+++ b/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb
@@ -1,39 +1,33 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the str2saltedsha512 function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("str2saltedsha512").should == "function_str2saltedsha512"
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
-    expect { @scope.function_str2saltedsha512([]) }.should( raise_error(Puppet::ParseError) )
+    expect { scope.function_str2saltedsha512([]) }.should( raise_error(Puppet::ParseError) )
   end
 
   it "should raise a ParseError if there is more than 1 argument" do
-    expect { @scope.function_str2saltedsha512(['foo', 'bar', 'baz']) }.should( raise_error(Puppet::ParseError) )
+    expect { scope.function_str2saltedsha512(['foo', 'bar', 'baz']) }.should( raise_error(Puppet::ParseError) )
   end
 
   it "should return a salted-sha512 password hash 136 characters in length" do
-    result = @scope.function_str2saltedsha512(["password"])
+    result = scope.function_str2saltedsha512(["password"])
     result.length.should(eq(136))
   end
 
   it "should raise an error if you pass a non-string password" do
-    expect { @scope.function_str2saltedsha512([1234]) }.should( raise_error(Puppet::ParseError) )
+    expect { scope.function_str2saltedsha512([1234]) }.should( raise_error(Puppet::ParseError) )
   end
 
   it "should generate a valid password" do
     # Allow the function to generate a password based on the string 'password'
-    password_hash = @scope.function_str2saltedsha512(["password"])
+    password_hash = scope.function_str2saltedsha512(["password"])
 
     # Separate the Salt and Password from the Password Hash
     salt     = password_hash[0..7]
diff --git a/spec/unit/puppet/parser/functions/strftime_spec.rb b/spec/unit/puppet/parser/functions/strftime_spec.rb
index f7a2cd9..df42b6f 100644
--- a/spec/unit/puppet/parser/functions/strftime_spec.rb
+++ b/spec/unit/puppet/parser/functions/strftime_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the strftime function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("strftime").should == "function_strftime"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_strftime([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_strftime([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "using %s should be higher then when I wrote this test" do
-    result = @scope.function_strftime(["%s"])
+    result = scope.function_strftime(["%s"])
     result.to_i.should(be > 1311953157)
   end
 
   it "using %s should be lower then 1.5 trillion" do
-    result = @scope.function_strftime(["%s"])
+    result = scope.function_strftime(["%s"])
     result.to_i.should(be < 1500000000)
   end
 
   it "should return a date when given %Y-%m-%d" do
-    result = @scope.function_strftime(["%Y-%m-%d"])
+    result = scope.function_strftime(["%Y-%m-%d"])
     result.should =~ /^\d{4}-\d{2}-\d{2}$/
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/strip_spec.rb b/spec/unit/puppet/parser/functions/strip_spec.rb
index 48a52dd..fccdd26 100644
--- a/spec/unit/puppet/parser/functions/strip_spec.rb
+++ b/spec/unit/puppet/parser/functions/strip_spec.rb
@@ -1,26 +1,18 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the strip function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
     Puppet::Parser::Functions.function("strip").should == "function_strip"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_strip([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_strip([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should strip a string" do
-    result = @scope.function_strip([" ab cd "])
+    result = scope.function_strip([" ab cd "])
     result.should(eq('ab cd'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/swapcase_spec.rb b/spec/unit/puppet/parser/functions/swapcase_spec.rb
index 2686054..808b415 100644
--- a/spec/unit/puppet/parser/functions/swapcase_spec.rb
+++ b/spec/unit/puppet/parser/functions/swapcase_spec.rb
@@ -1,26 +1,19 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the swapcase function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("swapcase").should == "function_swapcase"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should swapcase a string" do
-    result = @scope.function_swapcase(["aaBBccDD"])
+    result = scope.function_swapcase(["aaBBccDD"])
     result.should(eq('AAbbCCdd'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/time_spec.rb b/spec/unit/puppet/parser/functions/time_spec.rb
index 5d6cd97..e9fb76e 100644
--- a/spec/unit/puppet/parser/functions/time_spec.rb
+++ b/spec/unit/puppet/parser/functions/time_spec.rb
@@ -1,36 +1,29 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the time function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("time").should == "function_time"
   end
 
   it "should raise a ParseError if there is more than 2 arguments" do
-    lambda { @scope.function_time(['','']) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_time(['','']) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return a number" do
-    result = @scope.function_time([])
+    result = scope.function_time([])
     result.should be_an(Integer)
   end
 
   it "should be higher then when I wrote this test" do
-    result = @scope.function_time([])
+    result = scope.function_time([])
     result.should(be > 1311953157)
   end
 
   it "should be lower then 1.5 trillion" do
-    result = @scope.function_time([])
+    result = scope.function_time([])
     result.should(be < 1500000000)
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/type_spec.rb b/spec/unit/puppet/parser/functions/type_spec.rb
index e3c28ed..8fec88f 100644
--- a/spec/unit/puppet/parser/functions/type_spec.rb
+++ b/spec/unit/puppet/parser/functions/type_spec.rb
@@ -1,51 +1,43 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the type function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   it "should exist" do
     Puppet::Parser::Functions.function("type").should == "function_type"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_type([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_type([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return string when given a string" do
-    result = @scope.function_type(["aaabbbbcccc"])
+    result = scope.function_type(["aaabbbbcccc"])
     result.should(eq('string'))
   end
 
   it "should return array when given an array" do
-    result = @scope.function_type([["aaabbbbcccc","asdf"]])
+    result = scope.function_type([["aaabbbbcccc","asdf"]])
     result.should(eq('array'))
   end
 
   it "should return hash when given a hash" do
-    result = @scope.function_type([{"a"=>1,"b"=>2}])
+    result = scope.function_type([{"a"=>1,"b"=>2}])
     result.should(eq('hash'))
   end
 
   it "should return integer when given an integer" do
-    result = @scope.function_type(["1"])
+    result = scope.function_type(["1"])
     result.should(eq('integer'))
   end
 
   it "should return float when given a float" do
-    result = @scope.function_type(["1.34"])
+    result = scope.function_type(["1.34"])
     result.should(eq('float'))
   end
 
   it "should return boolean when given a boolean" do
-    result = @scope.function_type([true])
+    result = scope.function_type([true])
     result.should(eq('boolean'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/unique_spec.rb b/spec/unit/puppet/parser/functions/unique_spec.rb
index 627dc33..5d48d49 100644
--- a/spec/unit/puppet/parser/functions/unique_spec.rb
+++ b/spec/unit/puppet/parser/functions/unique_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the unique function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("unique").should == "function_unique"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_unique([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_unique([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should remove duplicate elements in a string" do
-    result = @scope.function_unique(["aabbc"])
+    result = scope.function_unique(["aabbc"])
     result.should(eq('abc'))
   end
 
   it "should remove duplicate elements in an array" do
-    result = @scope.function_unique([["a","a","b","b","c"]])
+    result = scope.function_unique([["a","a","b","b","c"]])
     result.should(eq(['a','b','c']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/upcase_spec.rb b/spec/unit/puppet/parser/functions/upcase_spec.rb
index 5d18846..5db5513 100644
--- a/spec/unit/puppet/parser/functions/upcase_spec.rb
+++ b/spec/unit/puppet/parser/functions/upcase_spec.rb
@@ -1,31 +1,24 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the upcase function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("upcase").should == "function_upcase"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_upcase([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_upcase([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should upcase a string" do
-    result = @scope.function_upcase(["abc"])
+    result = scope.function_upcase(["abc"])
     result.should(eq('ABC'))
   end
 
   it "should do nothing if a string is already upcase" do
-    result = @scope.function_upcase(["ABC"])
+    result = scope.function_upcase(["ABC"])
     result.should(eq('ABC'))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb b/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb
index 1e0b5ac..9d66fcb 100644
--- a/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb
@@ -1,14 +1,10 @@
 require 'spec_helper'
 
 describe Puppet::Parser::Functions.function(:validate_absolute_path) do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   # The subject of these examplres is the method itself.
-  subject do
-    Puppet::Parser::Scope.new.method :function_validate_absolute_path
-  end
+  subject() { scope.method(:function_validate_absolute_path) }
 
   describe "Valid Paths" do
     def self.valid_paths
diff --git a/spec/unit/puppet/parser/functions/validate_array_spec.rb b/spec/unit/puppet/parser/functions/validate_array_spec.rb
index 37ae09d..8eee72a 100644
--- a/spec/unit/puppet/parser/functions/validate_array_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_array_spec.rb
@@ -1,41 +1,21 @@
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
 
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
 
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
 describe Puppet::Parser::Functions.function(:validate_array) do
-
-  # Pulled from Dan's create_resources function
-  def get_scope
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
-    @scope = Puppet::Parser::Scope.new
-    @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @scope.parent = @topscope
-    @compiler = @scope.compiler
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   describe 'when calling validate_array from puppet' do
 
     %w{ true false }.each do |the_string|
-
       it "should not compile when #{the_string} is a string" do
         Puppet[:code] = "validate_array('#{the_string}')"
-        get_scope
-        expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
+        expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
       end
 
       it "should not compile when #{the_string} is a bare word" do
         Puppet[:code] = "validate_array(#{the_string})"
-        get_scope
-        expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
+        expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
       end
-
     end
 
     it "should compile when multiple array arguments are passed" do
@@ -44,8 +24,7 @@ describe Puppet::Parser::Functions.function(:validate_array) do
         $bar = [ 'one', 'two' ]
         validate_array($foo, $bar)
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
 
     it "should not compile when an undef variable is passed" do
@@ -53,11 +32,7 @@ describe Puppet::Parser::Functions.function(:validate_array) do
         $foo = undef
         validate_array($foo)
       ENDofPUPPETcode
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
     end
-
   end
-
 end
-
diff --git a/spec/unit/puppet/parser/functions/validate_bool_spec.rb b/spec/unit/puppet/parser/functions/validate_bool_spec.rb
index e95c396..31ab8fb 100644
--- a/spec/unit/puppet/parser/functions/validate_bool_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_bool_spec.rb
@@ -1,53 +1,33 @@
-require 'puppet'
+#! /usr/bin/env/ruby -S rspec
 
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
 
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
 describe Puppet::Parser::Functions.function(:validate_bool) do
-
-  # Pulled from Dan's create_resources function
-  def get_scope
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
-    @scope = Puppet::Parser::Scope.new
-    @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @scope.parent = @topscope
-    @compiler = @scope.compiler
-  end
-
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
   describe 'when calling validate_bool from puppet' do
 
     %w{ true false }.each do |the_string|
 
       it "should not compile when #{the_string} is a string" do
         Puppet[:code] = "validate_bool('#{the_string}')"
-        get_scope
-        expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
+        expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
       end
 
       it "should compile when #{the_string} is a bare word" do
         Puppet[:code] = "validate_bool(#{the_string})"
-        get_scope
-        @scope.compiler.compile
+        scope.compiler.compile
       end
 
     end
 
     it "should not compile when an arbitrary string is passed" do
       Puppet[:code] = 'validate_bool("jeff and dan are awesome")'
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
     end
 
     it "should not compile when no arguments are passed" do
       Puppet[:code] = 'validate_bool()'
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
     end
 
     it "should compile when multiple boolean arguments are passed" do
@@ -56,8 +36,7 @@ describe Puppet::Parser::Functions.function(:validate_bool) do
         $bar = false
         validate_bool($foo, $bar, true, false)
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
 
     it "should compile when multiple boolean arguments are passed" do
@@ -66,11 +45,7 @@ describe Puppet::Parser::Functions.function(:validate_bool) do
         $bar = false
         validate_bool($foo, $bar, true, false, 'jeff')
       ENDofPUPPETcode
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
     end
-
   end
-
 end
-
diff --git a/spec/unit/puppet/parser/functions/validate_hash_spec.rb b/spec/unit/puppet/parser/functions/validate_hash_spec.rb
index 8cc0b3d..f63db1d 100644
--- a/spec/unit/puppet/parser/functions/validate_hash_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_hash_spec.rb
@@ -1,24 +1,9 @@
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
 
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
 
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
 describe Puppet::Parser::Functions.function(:validate_hash) do
-
-  # Pulled from Dan's create_resources function
-  def get_scope
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
-    @scope = Puppet::Parser::Scope.new
-    @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @scope.parent = @topscope
-    @compiler = @scope.compiler
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   describe 'when calling validate_hash from puppet' do
 
@@ -26,14 +11,12 @@ describe Puppet::Parser::Functions.function(:validate_hash) do
 
       it "should not compile when #{the_string} is a string" do
         Puppet[:code] = "validate_hash('#{the_string}')"
-        get_scope
-        expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
+        expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
       end
 
       it "should not compile when #{the_string} is a bare word" do
         Puppet[:code] = "validate_hash(#{the_string})"
-        get_scope
-        expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
+        expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
       end
 
     end
@@ -44,8 +27,7 @@ describe Puppet::Parser::Functions.function(:validate_hash) do
         $bar = { 'one' => 'two' }
         validate_hash($foo, $bar)
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
 
     it "should not compile when an undef variable is passed" do
@@ -53,8 +35,7 @@ describe Puppet::Parser::Functions.function(:validate_hash) do
         $foo = undef
         validate_hash($foo)
       ENDofPUPPETcode
-      get_scope
-      expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
+      expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
     end
 
   end
diff --git a/spec/unit/puppet/parser/functions/validate_re_spec.rb b/spec/unit/puppet/parser/functions/validate_re_spec.rb
index c35ae14..a07ad47 100644
--- a/spec/unit/puppet/parser/functions/validate_re_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_re_spec.rb
@@ -1,13 +1,7 @@
 require 'spec_helper'
 
 describe Puppet::Parser::Functions.function(:validate_re) do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  let(:scope) do
-    scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   # The subject of these examplres is the method itself.
   subject do
diff --git a/spec/unit/puppet/parser/functions/validate_slength_spec.rb b/spec/unit/puppet/parser/functions/validate_slength_spec.rb
index d2d4ca0..eccf908 100755
--- a/spec/unit/puppet/parser/functions/validate_slength_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_slength_spec.rb
@@ -1,13 +1,9 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 
 require 'spec_helper'
 
 describe "the validate_slength function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  let(:scope) { Puppet::Parser::Scope.new }
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("validate_slength").should == "function_validate_slength"
diff --git a/spec/unit/puppet/parser/functions/validate_string_spec.rb b/spec/unit/puppet/parser/functions/validate_string_spec.rb
index 92392da..f40bf2a 100644
--- a/spec/unit/puppet/parser/functions/validate_string_spec.rb
+++ b/spec/unit/puppet/parser/functions/validate_string_spec.rb
@@ -1,24 +1,9 @@
-require 'puppet'
+#! /usr/bin/env ruby -S rspec
 
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
+require 'spec_helper'
 
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
 describe Puppet::Parser::Functions.function(:validate_string) do
-
-  # Pulled from Dan's create_resources function
-  def get_scope
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
-    @scope = Puppet::Parser::Scope.new
-    @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @scope.parent = @topscope
-    @compiler = @scope.compiler
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   describe 'when calling validate_string from puppet' do
 
@@ -26,14 +11,12 @@ describe Puppet::Parser::Functions.function(:validate_string) do
 
       it "should compile when #{the_string} is a string" do
         Puppet[:code] = "validate_string('#{the_string}')"
-        get_scope
-        @scope.compiler.compile
+        scope.compiler.compile
       end
 
       it "should compile when #{the_string} is a bare word" do
         Puppet[:code] = "validate_string(#{the_string})"
-        get_scope
-        @scope.compiler.compile
+        scope.compiler.compile
       end
 
     end
@@ -41,14 +24,12 @@ describe Puppet::Parser::Functions.function(:validate_string) do
     %w{ true false }.each do |the_string|
       it "should compile when #{the_string} is a string" do
         Puppet[:code] = "validate_string('#{the_string}')"
-        get_scope
-        @scope.compiler.compile
+        scope.compiler.compile
       end
 
       it "should not compile when #{the_string} is a bare word" do
         Puppet[:code] = "validate_string(#{the_string})"
-        get_scope
-        expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a string/)
+        expect { scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a string/)
       end
     end
 
@@ -58,8 +39,7 @@ describe Puppet::Parser::Functions.function(:validate_string) do
         $bar = 'two'
         validate_string($foo, $bar)
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
 
     it "should compile when an explicitly undef variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
@@ -67,16 +47,14 @@ describe Puppet::Parser::Functions.function(:validate_string) do
         $foo = undef
         validate_string($foo)
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
 
     it "should compile when an undefined variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
       Puppet[:code] = <<-'ENDofPUPPETcode'
         validate_string($foobarbazishouldnotexist)
       ENDofPUPPETcode
-      get_scope
-      @scope.compiler.compile
+      scope.compiler.compile
     end
   end
 end
diff --git a/spec/unit/puppet/parser/functions/values_at_spec.rb b/spec/unit/puppet/parser/functions/values_at_spec.rb
index 6c45316..08e95a5 100644
--- a/spec/unit/puppet/parser/functions/values_at_spec.rb
+++ b/spec/unit/puppet/parser/functions/values_at_spec.rb
@@ -1,45 +1,38 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the values_at function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("values_at").should == "function_values_at"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_values_at([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_values_at([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if you try to use a range where stop is greater then start" do
-    lambda { @scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return a value at from an array" do
-    result = @scope.function_values_at([['a','b','c'],"1"])
+    result = scope.function_values_at([['a','b','c'],"1"])
     result.should(eq(['b']))
   end
 
   it "should return a value at from an array when passed a range" do
-    result = @scope.function_values_at([['a','b','c'],"0-1"])
+    result = scope.function_values_at([['a','b','c'],"0-1"])
     result.should(eq(['a','b']))
   end
 
   it "should return chosen values from an array when passed number of indexes" do
-    result = @scope.function_values_at([['a','b','c'],["0","2"]])
+    result = scope.function_values_at([['a','b','c'],["0","2"]])
     result.should(eq(['a','c']))
   end
 
   it "should return chosen values from an array when passed ranges and multiple indexes" do
-    result = @scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
+    result = scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
     result.should(eq(['a','c','e','f']))
   end
-
 end
diff --git a/spec/unit/puppet/parser/functions/values_spec.rb b/spec/unit/puppet/parser/functions/values_spec.rb
index a5fbbd8..14ae417 100644
--- a/spec/unit/puppet/parser/functions/values_spec.rb
+++ b/spec/unit/puppet/parser/functions/values_spec.rb
@@ -1,12 +1,8 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the values function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  let(:scope) { Puppet::Parser::Scope.new }
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should exist" do
     Puppet::Parser::Functions.function("values").should == "function_values"
diff --git a/spec/unit/puppet/parser/functions/zip_spec.rb b/spec/unit/puppet/parser/functions/zip_spec.rb
index 074f4df..f45ab17 100644
--- a/spec/unit/puppet/parser/functions/zip_spec.rb
+++ b/spec/unit/puppet/parser/functions/zip_spec.rb
@@ -1,26 +1,15 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the zip function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("zip").should == "function_zip"
-  end
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
   it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { @scope.function_zip([]) }.should( raise_error(Puppet::ParseError))
+    lambda { scope.function_zip([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should be able to zip an array" do
-    result = @scope.function_zip([['1','2','3'],['4','5','6']])
+    result = scope.function_zip([['1','2','3'],['4','5','6']])
     result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
   end
-
 end