diff --git a/lib/puppet/parser/functions.rb b/lib/puppet/parser/functions.rb
index e19ac127f..df36e6349 100644
--- a/lib/puppet/parser/functions.rb
+++ b/lib/puppet/parser/functions.rb
@@ -1,119 +1,123 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
 require 'monitor'
 
 # A module for managing parser functions.  Each specified function
 # is added to a central module that then gets included into the Scope
 # class.
 module Puppet::Parser::Functions
-
-  (@functions = Hash.new { |h,k| h[k] = {} }).extend(MonitorMixin)
-  (@modules   = {}                          ).extend(MonitorMixin)
+  Environment = Puppet::Node::Environment
 
   class << self
     include Puppet::Util
   end
 
+  # This is used by tests
+  def self.reset
+    @functions = Hash.new { |h,k| h[k] = {} }.extend(MonitorMixin)
+    @modules = Hash.new.extend(MonitorMixin)
+  end
+
   def self.autoloader
     unless defined?(@autoloader)
       @autoloader = Puppet::Util::Autoload.new(
         self,
         "puppet/parser/functions",
         :wrap => false
       )
     end
 
     @autoloader
   end
 
-  Environment = Puppet::Node::Environment
-
   def self.environment_module(env = nil)
     @modules.synchronize {
       @modules[ env || Environment.current || Environment.root ] ||= Module.new
     }
   end
 
   # Create a new function type.
   def self.newfunction(name, options = {}, &block)
     name = symbolize(name)
 
     raise Puppet::DevError, "Function #{name} already defined" if functions.include?(name)
 
     ftype = options[:type] || :statement
 
     unless ftype == :statement or ftype == :rvalue
       raise Puppet::DevError, "Invalid statement type #{ftype.inspect}"
     end
 
     fname = "function_#{name}"
     environment_module.send(:define_method, fname, &block)
 
     # Someday we'll support specifying an arity, but for now, nope
     #functions[name] = {:arity => arity, :type => ftype}
     functions[name] = {:type => ftype, :name => fname}
     functions[name][:doc] = options[:doc] if options[:doc]
   end
 
   # Remove a function added by newfunction
   def self.rmfunction(name)
     name = symbolize(name)
 
     raise Puppet::DevError, "Function #{name} is not defined" unless functions.include? name
 
     functions.delete name
 
     fname = "function_#{name}"
     environment_module.send(:remove_method, fname)
   end
 
   # Determine if a given name is a function
   def self.function(name)
     name = symbolize(name)
 
     @functions.synchronize do
       unless functions.include?(name) or functions(Puppet::Node::Environment.root).include?(name)
         autoloader.load(name,Environment.current || Environment.root)
       end
     end
 
     ( functions(Environment.root)[name] || functions[name] || {:name => false} )[:name]
   end
 
   def self.functiondocs
     autoloader.loadall
 
     ret = ""
 
     functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
       ret += "#{name}\n#{"-" * name.to_s.length}\n"
       if hash[:doc]
         ret += Puppet::Util::Docs.scrub(hash[:doc])
       else
         ret += "Undocumented.\n"
       end
 
       ret += "\n\n- *Type*: #{hash[:type]}\n\n"
     end
 
     ret
   end
 
   def self.functions(env = nil)
     @functions.synchronize {
       @functions[ env || Environment.current || Environment.root ]
     }
   end
 
   # Determine if a given function returns a value or not.
   def self.rvalue?(name)
     (functions[symbolize(name)] || {})[:type] == :rvalue
   end
 
+  reset  # initialize the class instance variables
+
   # Runs a newfunction to create a function for each of the log levels
   Puppet::Util::Log.levels.each do |level|
     newfunction(level, :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
       send(level, vals.join(" "))
     end
   end
 end
diff --git a/lib/puppet/test/test_helper.rb b/lib/puppet/test/test_helper.rb
index d41e1ac82..f8fe15379 100644
--- a/lib/puppet/test/test_helper.rb
+++ b/lib/puppet/test/test_helper.rb
@@ -1,140 +1,141 @@
 module Puppet::Test
   # This class is intended to provide an API to be used by external projects
   #  when they are running tests that depend on puppet core.  This should
   #  allow us to vary the implementation details of managing puppet's state
   #  for testing, from one version of puppet to the next--without forcing
   #  the external projects to do any of that state management or be aware of
   #  the implementation details.
   #
   # For now, this consists of a few very simple signatures.  The plan is
   #  that it should be the responsibility of the puppetlabs_spec_helper
   #  to broker between external projects and this API; thus, if any
   #  hacks are required (e.g. to determine whether or not a particular)
   #  version of puppet supports this API, those hacks will be consolidated in
   #  one place and won't need to be duplicated in every external project.
   #
   # This should also alleviate the anti-pattern that we've been following,
   #  wherein each external project starts off with a copy of puppet core's
   #  test_helper.rb and is exposed to risk of that code getting out of
   #  sync with core.
   #
   # Since this class will be "library code" that ships with puppet, it does
   #  not use API from any existing test framework such as rspec.  This should
   #  theoretically allow it to be used with other unit test frameworks in the
   #  future, if desired.
   #
   # Note that in the future this API could potentially be expanded to handle
   #  other features such as "around_test", but we didn't see a compelling
   #  reason to deal with that right now.
   class TestHelper
     # Call this method once, when beginning a test run--prior to running
     #  any individual tests.
     # @return nil
     def self.before_all_tests()
 
     end
 
     # Call this method once, at the end of a test run, when no more tests
     #  will be run.
     # @return nil
     def self.after_all_tests()
 
     end
 
     # Call this method once per test, prior to execution of each invididual test.
     # @return nil
     def self.before_each_test()
       # We need to preserve the current state of all our indirection cache and
       # terminus classes.  This is pretty important, because changes to these
       # are global and lead to order dependencies in our testing.
       #
       # We go direct to the implementation because there is no safe, sane public
       # API to manage restoration of these to their default values.  This
       # should, once the value is proved, be moved to a standard API on the
       # indirector.
       #
       # To make things worse, a number of the tests stub parts of the
       # indirector.  These stubs have very specific expectations that what
       # little of the public API we could use is, well, likely to explode
       # randomly in some tests.  So, direct access.  --daniel 2011-08-30
       $saved_indirection_state = {}
       indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
       indirections.each do |indirector|
         $saved_indirection_state[indirector.name] = {
             :@terminus_class => indirector.instance_variable_get(:@terminus_class),
             :@cache_class    => indirector.instance_variable_get(:@cache_class)
         }
       end
 
       initialize_settings_before_each()
 
       # Longer keys are secure, but they sure make for some slow testing - both
       # in terms of generating keys, and in terms of anything the next step down
       # the line doing validation or whatever.  Most tests don't care how long
       # or secure it is, just that it exists, so these are better and faster
       # defaults, in testing only.
       #
       # I would make these even shorter, but OpenSSL doesn't support anything
       # below 512 bits.  Sad, really, because a 0 bit key would be just fine.
       Puppet[:req_bits]  = 512
       Puppet[:keylength] = 512
 
       Puppet::Node::Environment.clear
+      Puppet::Parser::Functions.reset
 
       Puppet.clear_deprecation_warnings
     end
 
     # Call this method once per test, after execution of each individual test.
     # @return nil
     def self.after_each_test()
       clear_settings_after_each()
 
       Puppet::Util::Storage.clear
       Puppet::Util::ExecutionStub.reset
 
       # Restore the indirector configuration.  See before hook.
       indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
       indirections.each do |indirector|
         $saved_indirection_state.fetch(indirector.name, {}).each do |variable, value|
           indirector.instance_variable_set(variable, value)
         end
       end
       $saved_indirection_state = nil
 
 
       # Some tests can cause us to connect, in which case the lingering
       # connection is a resource that can cause unexpected failure in later
       # tests, as well as sharing state accidentally.
       # We're testing if ActiveRecord::Base is defined because some test cases
       # may stub Puppet.features.rails? which is how we should normally
       # introspect for this functionality.
       ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
 
     end
 
 
     #########################################################################################
     # PRIVATE METHODS (not part of the public TestHelper API--do not call these from outside
     #  of this class!)
     #########################################################################################
 
     def self.initialize_settings_before_each()
       # these globals are set by Application
       $puppet_application_mode = nil
       $puppet_application_name = nil
       # Set the confdir and vardir to gibberish so that tests
       # have to be correctly mocked.
       Puppet[:confdir] = "/dev/null"
       Puppet[:vardir] = "/dev/null"
 
       # Avoid opening ports to the outside world
       Puppet[:bindaddress] = "127.0.0.1"
     end
     private_class_method :initialize_settings_before_each
 
     def self.clear_settings_after_each()
       Puppet.settings.clear
     end
     private_class_method :clear_settings_after_each
   end
 end
diff --git a/spec/unit/parser/functions/require_spec.rb b/spec/unit/parser/functions/require_spec.rb
index 692b35305..403392ff5 100755
--- a/spec/unit/parser/functions/require_spec.rb
+++ b/spec/unit/parser/functions/require_spec.rb
@@ -1,76 +1,70 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "the require function" do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   before :each do
     @catalog = stub 'catalog'
     @compiler = stub 'compiler', :catalog => @catalog, :environment => nil
 
     @scope = Puppet::Parser::Scope.new
     @scope.stubs(:findresource)
     @scope.stubs(:compiler).returns(@compiler)
     @klass = stub 'class', :name => "myclass"
     @scope.stubs(:find_hostclass).returns(@klass)
 
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
     @resource.stubs(:metaparam_compatibility_mode?).returns false
     @scope.stubs(:resource).returns @resource
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("require").should == "function_require"
   end
 
   it "should delegate to the 'include' puppet function" do
     @scope.expects(:function_include).with("myclass")
 
     @scope.function_require("myclass")
   end
 
   it "should set the 'require' prarameter on the resource to a resource reference" do
     @scope.stubs(:function_include)
     @scope.function_require("myclass")
 
     @resource["require"].should be_instance_of(Array)
     @resource["require"][0].should be_instance_of(Puppet::Resource)
   end
 
-  it "should verify the 'include' function is loaded" do
-    Puppet::Parser::Functions.expects(:function).with(:include).returns(:function_include)
-    @scope.stubs(:function_include)
-    @scope.function_require("myclass")
-  end
-
   it "should include the class but not add a dependency if used on a client not at least version 0.25" do
     @resource.expects(:metaparam_compatibility_mode?).returns true
     @scope.expects(:warning)
     @resource.expects(:set_parameter).never
     @scope.expects(:function_include)
 
     @scope.function_require("myclass")
   end
 
   it "should lookup the absolute class path" do
     @scope.stubs(:function_include)
 
     @scope.expects(:find_hostclass).with("myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
 
     @scope.function_require("myclass")
   end
 
   it "should append the required class to the require parameter" do
     @scope.stubs(:function_include)
 
     one = Puppet::Resource.new(:file, "/one")
     @resource[:require] = one
     @scope.function_require("myclass")
 
     @resource[:require].should be_include(one)
     @resource[:require].detect { |r| r.to_s == "Class[Myclass]" }.should be_instance_of(Puppet::Resource)
   end
 end