diff --git a/spec/integration/environments/default_manifest_spec.rb b/spec/integration/environments/default_manifest_spec.rb
index e6d10f3b2..6d4564037 100644
--- a/spec/integration/environments/default_manifest_spec.rb
+++ b/spec/integration/environments/default_manifest_spec.rb
@@ -1,272 +1,274 @@
 require 'spec_helper'
 
+module EnvironmentsDefaultManifestsSpec
 describe "default manifests" do
+  FS = Puppet::FileSystem
+
   shared_examples_for "puppet with default_manifest settings" do
     let(:confdir) { Puppet[:confdir] }
     let(:environmentpath) { File.expand_path("envdir", confdir) }
 
-    FS = Puppet::FileSystem
-
     context "relative default" do
       let(:testingdir) { File.join(environmentpath, "testing") }
 
       before(:each) do
         FileUtils.mkdir_p(testingdir)
       end
 
       it "reads manifest from ./manifest of a basic directory environment" do
         manifestsdir = File.join(testingdir, "manifests")
         FileUtils.mkdir_p(manifestsdir)
 
         File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromRelativeDefault': }")
         end
 
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts("environmentpath=#{environmentpath}")
         end
 
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromRelativeDefault]')
         )
       end
     end
 
     context "set absolute" do
       let(:testingdir) { File.join(environmentpath, "testing") }
 
       before(:each) do
         FileUtils.mkdir_p(testingdir)
       end
 
       it "reads manifest from an absolute default_manifest" do
         manifestsdir = File.expand_path("manifests", confdir)
         FileUtils.mkdir_p(manifestsdir)
 
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=#{manifestsdir}
           EOF
         end
 
         File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
         end
 
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
         )
       end
 
       it "reads manifest from directory environment manifest when environment.conf manifest set" do
         default_manifestsdir = File.expand_path("manifests", confdir)
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=#{default_manifestsdir}
           EOF
         end
 
         manifestsdir = File.join(testingdir, "special_manifests")
         FileUtils.mkdir_p(manifestsdir)
 
         File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromEnvironmentConfManifest': }")
         end
 
         File.open(File.join(testingdir, "environment.conf"), "w") do |f|
           f.puts("manifest=./special_manifests")
         end
 
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromEnvironmentConfManifest]')
         )
         expect(Puppet[:default_manifest]).to eq(default_manifestsdir)
       end
 
       it "ignores manifests in the local ./manifests if default_manifest specifies another directory" do
         default_manifestsdir = File.expand_path("manifests", confdir)
         FileUtils.mkdir_p(default_manifestsdir)
 
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=#{default_manifestsdir}
           EOF
         end
 
         File.open(File.join(default_manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
         end
 
         implicit_manifestsdir = File.join(testingdir, "manifests")
         FileUtils.mkdir_p(implicit_manifestsdir)
 
         File.open(File.join(implicit_manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromImplicitRelativeEnvironmentManifestDirectory': }")
         end
 
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
         )
       end
 
       it "raises an exception if default_manifest has $environment in it" do
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=/foo/$environment
           EOF
         end
 
         expect { Puppet.initialize_settings }.to raise_error(Puppet::Settings::ValidationError, /cannot interpolate.*\$environment.*in.*default_manifest/)
       end
     end
 
     context "with disable_per_environment_manifest true" do
       let(:manifestsdir) { File.expand_path("manifests", confdir) }
       let(:testingdir) { File.join(environmentpath, "testing") }
 
       before(:each) do
         FileUtils.mkdir_p(testingdir)
       end
 
       before(:each) do
         FileUtils.mkdir_p(manifestsdir)
 
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=#{manifestsdir}
   disable_per_environment_manifest=true
           EOF
         end
 
         File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
         end
       end
 
       it "reads manifest from the default manifest setting" do
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
         )
       end
 
       it "refuses to compile if environment.conf specifies a different manifest" do
         File.open(File.join(testingdir, "environment.conf"), "w") do |f|
           f.puts("manifest=./special_manifests")
         end
 
         expect { a_catalog_compiled_for_environment('testing') }.to(
           raise_error(Puppet::Error, /disable_per_environment_manifest.*environment.conf.*manifest.*conflict/)
         )
       end
 
       it "reads manifest from default_manifest setting when environment.conf has manifest set if setting equals default_manifest setting" do
         File.open(File.join(testingdir, "environment.conf"), "w") do |f|
           f.puts("manifest=#{manifestsdir}")
         end
 
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromAbsoluteDefaultManifest]')
         )
       end
 
       it "logs errors if environment.conf specifies a different manifest" do
         File.open(File.join(testingdir, "environment.conf"), "w") do |f|
           f.puts("manifest=./special_manifests")
         end
 
         Puppet.initialize_settings
         expect(Puppet[:environmentpath]).to eq(environmentpath)
         environment = Puppet.lookup(:environments).get('testing')
         expect(environment.manifest).to eq(manifestsdir)
         expect(@logs.first.to_s).to match(%r{disable_per_environment_manifest.*is true, but.*environment.*at #{testingdir}.*has.*environment.conf.*manifest.*#{testingdir}/special_manifests})
       end
 
       it "raises an error if default_manifest is not absolute" do
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   environmentpath=#{environmentpath}
   default_manifest=./relative
   disable_per_environment_manifest=true
           EOF
         end
 
         expect { Puppet.initialize_settings }.to raise_error(Puppet::Settings::ValidationError, /default_manifest.*must be.*absolute.*when.*disable_per_environment_manifest.*true/)
       end
     end
 
     context "in legacy environments" do
       let(:environmentpath) { '' }
       let(:manifestsdir) { File.expand_path("default_manifests", confdir) }
       let(:legacy_manifestsdir) { File.expand_path('manifests', confdir) }
 
       before(:each) do
         FileUtils.mkdir_p(manifestsdir)
 
         File.open(File.join(confdir, "puppet.conf"), "w") do |f|
           f.puts(<<-EOF)
   default_manifest=#{manifestsdir}
   disable_per_environment_manifest=true
   manifest=#{legacy_manifestsdir}
           EOF
         end
 
         File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
         end
       end
 
       it "has no effect on compilation" do
         FileUtils.mkdir_p(legacy_manifestsdir)
 
         File.open(File.join(legacy_manifestsdir, "site.pp"), "w") do |f|
           f.puts("notify { 'ManifestFromLegacy': }")
         end
 
         expect(a_catalog_compiled_for_environment('testing')).to(
           include_resource('Notify[ManifestFromLegacy]')
         )
       end
     end
   end
 
   describe 'using future parser' do
     before :each do
       Puppet[:parser] = 'future'
     end
     it_behaves_like 'puppet with default_manifest settings'
   end
 
   describe 'using current parser' do
     before :each do
       Puppet[:parser] = 'current'
     end
     it_behaves_like 'puppet with default_manifest settings'
   end
 
   RSpec::Matchers.define :include_resource do |expected|
     match do |actual|
       actual.resources.map(&:ref).include?(expected)
     end
 
     def failure_message_for_should
       "expected #{@actual.resources.map(&:ref)} to include #{expected}"
     end
 
     def failure_message_for_should_not
       "expected #{@actual.resources.map(&:ref)} not to include #{expected}"
     end
   end
 
   def a_catalog_compiled_for_environment(envname)
     Puppet.initialize_settings
     expect(Puppet[:environmentpath]).to eq(environmentpath)
     node = Puppet::Node.new('testnode', :environment => 'testing')
     expect(node.environment).to eq(Puppet.lookup(:environments).get('testing'))
     Puppet::Parser::Compiler.compile(node)
   end
 end
+end
diff --git a/spec/unit/indirector/facts/facter_spec.rb b/spec/unit/indirector/facts/facter_spec.rb
index 3d4e21b7e..4417ede54 100755
--- a/spec/unit/indirector/facts/facter_spec.rb
+++ b/spec/unit/indirector/facts/facter_spec.rb
@@ -1,168 +1,170 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/facts/facter'
 
+module NodeFactsFacterSpec
 describe Puppet::Node::Facts::Facter do
   FS = Puppet::FileSystem
 
   it "should be a subclass of the Code terminus" do
     Puppet::Node::Facts::Facter.superclass.should equal(Puppet::Indirector::Code)
   end
 
   it "should have documentation" do
     Puppet::Node::Facts::Facter.doc.should_not be_nil
   end
 
   it "should be registered with the configuration store indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:facts)
     Puppet::Node::Facts::Facter.indirection.should equal(indirection)
   end
 
   it "should have its name set to :facter" do
     Puppet::Node::Facts::Facter.name.should == :facter
   end
 
   before :each do
     Puppet::Node::Facts::Facter.stubs(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
     Facter.stubs(:to_hash).returns({})
     @name = "me"
     @request = stub 'request', :key => @name
     @environment = stub 'environment'
     @request.stubs(:environment).returns(@environment)
     @request.environment.stubs(:modules).returns([])
     @request.environment.stubs(:modulepath).returns([])
   end
 
   describe 'when finding facts' do
     it 'should reset facts' do
       reset = sequence 'reset'
       Facter.expects(:reset).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
       @facter.find(@request)
     end
 
     it 'should include external facts when feature is present' do
       reset = sequence 'reset'
       Puppet.features.stubs(:external_facts?).returns true
       Facter.expects(:reset).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_external_search_paths).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
       @facter.find(@request)
     end
 
     it 'should not include external facts when feature is not present' do
       reset = sequence 'reset'
       Puppet.features.stubs(:external_facts?).returns false
       Facter.expects(:reset).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
       @facter.find(@request)
     end
 
     it "should return a Facts instance" do
       @facter.find(@request).should be_instance_of(Puppet::Node::Facts)
     end
 
     it "should return a Facts instance with the provided key as the name" do
       @facter.find(@request).name.should == @name
     end
 
     it "should return the Facter facts as the values in the Facts instance" do
       Facter.expects(:to_hash).returns("one" => "two")
       facts = @facter.find(@request)
       facts.values["one"].should == "two"
     end
 
     it "should add local facts" do
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:add_local_facts)
 
       @facter.find(@request)
     end
 
     it "should convert facts into strings when stringify_facts is true" do
       Puppet[:stringify_facts] = true
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:stringify)
 
       @facter.find(@request)
     end
 
     it "should sanitize facts when stringify_facts is false" do
       Puppet[:stringify_facts] = false
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:sanitize)
 
       @facter.find(@request)
     end
   end
 
   it 'should fail when saving facts' do
     proc { @facter.save(@facts) }.should raise_error(Puppet::DevError)
   end
 
   it 'should fail when destroying facts' do
     proc { @facter.destroy(@facts) }.should raise_error(Puppet::DevError)
   end
 
   describe 'when setting up search paths' do
     let(:factpath1) { File.expand_path 'one' }
     let(:factpath2) { File.expand_path 'two' }
     let(:factpath) { [factpath1, factpath2].join(File::PATH_SEPARATOR) }
     let(:modulepath) { File.expand_path 'module/foo' }
     let(:modulelibfacter) { File.expand_path 'module/foo/lib/facter' }
     let(:modulepluginsfacter) { File.expand_path 'module/foo/plugins/facter' }
 
     before :each do
       FileTest.expects(:directory?).with(factpath1).returns true
       FileTest.expects(:directory?).with(factpath2).returns true
       @request.environment.stubs(:modulepath).returns [modulepath]
       Dir.expects(:glob).with("#{modulepath}/*/lib/facter").returns [modulelibfacter]
       Dir.expects(:glob).with("#{modulepath}/*/plugins/facter").returns [modulepluginsfacter]
 
       Puppet[:factpath] = factpath
     end
 
     it 'should skip files' do
       FileTest.expects(:directory?).with(modulelibfacter).returns false
       FileTest.expects(:directory?).with(modulepluginsfacter).returns false
       Facter.expects(:search).with(factpath1, factpath2)
       Puppet::Node::Facts::Facter.setup_search_paths @request
     end
 
     it 'should add directories' do
       FileTest.expects(:directory?).with(modulelibfacter).returns true
       FileTest.expects(:directory?).with(modulepluginsfacter).returns true
       Facter.expects(:search).with(modulelibfacter, modulepluginsfacter, factpath1, factpath2)
       Puppet::Node::Facts::Facter.setup_search_paths @request
     end
   end
 
   describe 'when setting up external search paths', :if => Puppet.features.external_facts? do
     let(:pluginfactdest) { File.expand_path 'plugin/dest' }
     let(:modulepath) { File.expand_path 'module/foo' }
     let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }
 
     before :each do
       FileTest.expects(:directory?).with(pluginfactdest).returns true
       mod = Puppet::Module.new('foo', modulepath, @request.environment)
       @request.environment.stubs(:modules).returns [mod]
       Puppet[:pluginfactdest] = pluginfactdest
     end
 
     it 'should skip files' do
       File.expects(:directory?).with(modulefactsd).returns false
       Facter.expects(:search_external).with [pluginfactdest]
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
 
     it 'should add directories' do
       File.expects(:directory?).with(modulefactsd).returns true
       Facter.expects(:search_external).with [modulefactsd, pluginfactdest]
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
   end
 end
+end