diff --git a/lib/puppet/indirector/node/exec.rb b/lib/puppet/indirector/node/exec.rb
index d4faf74f4..2535ffac5 100644
--- a/lib/puppet/indirector/node/exec.rb
+++ b/lib/puppet/indirector/node/exec.rb
@@ -1,69 +1,69 @@
 require 'puppet/node'
 require 'puppet/indirector/exec'
 
 class Puppet::Node::Exec < Puppet::Indirector::Exec
   desc "Call an external program to get node information.  See
   the [External Nodes](http://docs.puppetlabs.com/guides/external_nodes.html) page for more information."
   include Puppet::Util
 
   def command
     command = Puppet[:external_nodes]
     raise ArgumentError, "You must set the 'external_nodes' parameter to use the external node terminus" unless command != "none"
     command.split
   end
 
   # Look for external node definitions.
   def find(request)
     output = super or return nil
 
     # Translate the output to ruby.
     result = translate(request.key, output)
 
     # Set the requested environment if it wasn't overridden
     # If we don't do this it gets set to the local default
-    result[:environment] ||= request.environment.name
+    result[:environment] ||= request.environment
 
     create_node(request.key, result)
   end
 
   private
 
   # Proxy the execution, so it's easier to test.
   def execute(command, arguments)
     Puppet::Util::Execution.execute(command,arguments)
   end
 
   # Turn our outputted objects into a Puppet::Node instance.
   def create_node(name, result)
     node = Puppet::Node.new(name)
     set = false
     [:parameters, :classes, :environment].each do |param|
       if value = result[param]
         node.send(param.to_s + "=", value)
         set = true
       end
     end
 
     node.fact_merge
     node
   end
 
   # Translate the yaml string into Ruby objects.
   def translate(name, output)
     YAML.load(output).inject({}) do |hash, data|
       case data[0]
       when String
         hash[data[0].intern] = data[1]
       when Symbol
         hash[data[0]] = data[1]
       else
         raise Puppet::Error, "key is a #{data[0].class}, not a string or symbol"
       end
 
       hash
     end
 
   rescue => detail
       raise Puppet::Error, "Could not load external node results for #{name}: #{detail}", detail.backtrace
   end
 end
diff --git a/spec/integration/application/apply_spec.rb b/spec/integration/application/apply_spec.rb
index e48808120..3ce1277d3 100755
--- a/spec/integration/application/apply_spec.rb
+++ b/spec/integration/application/apply_spec.rb
@@ -1,109 +1,115 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
-require 'puppet/application/apply'
 
 describe "apply" do
   include PuppetSpec::Files
 
   before :each do
     Puppet[:reports] = "none"
   end
 
   describe "when applying provided catalogs" do
     it "can apply catalogs provided in a file in pson" do
       file_to_create = tmpfile("pson_catalog")
       catalog = Puppet::Resource::Catalog.new('mine', Puppet.lookup(:environments).get(Puppet[:environment]))
       resource = Puppet::Resource.new(:file, file_to_create, :parameters => {:content => "my stuff"})
       catalog.add_resource resource
 
-      manifest = tmpfile("manifest")
+      manifest = file_containing("manifest", catalog.to_pson)
 
-      File.open(manifest, "w") { |f| f.print catalog.to_pson }
       puppet = Puppet::Application[:apply]
       puppet.options[:catalog] = manifest
 
       puppet.apply
 
       expect(Puppet::FileSystem.exist?(file_to_create)).to be_true
       expect(File.read(file_to_create)).to eq("my stuff")
     end
   end
 
   it "applies a given file even when a directory environment is specified" do
-    manifest = tmpfile("manifest.pp")
-    File.open(manifest, "w") do |f|
-      f.puts <<-EOF
-      notice('it was applied')
-      EOF
-    end
+    manifest = file_containing("manifest.pp", "notice('it was applied')")
 
     special = Puppet::Node::Environment.create(:special, [])
     Puppet.override(:current_environment => special) do
       Puppet[:environment] = 'special'
       puppet = Puppet::Application[:apply]
       puppet.stubs(:command_line).returns(stub('command_line', :args => [manifest]))
       expect { puppet.run_command }.to exit_with(0)
     end
 
     expect(@logs.map(&:to_s)).to include('it was applied')
   end
 
+  it "applies a given file even when an ENC is configured", :if => !Puppet.features.microsoft_windows? do
+    manifest = file_containing("manifest.pp", "notice('specific manifest applied')")
+    site_manifest = file_containing("site_manifest.pp", "notice('the site manifest was applied instead')")
+    enc = file_containing("enc_script", "#!/bin/sh\necho 'classes: []'")
+    File.chmod(0755, enc)
+
+    special = Puppet::Node::Environment.create(:special, [])
+    Puppet.override(:current_environment => special) do
+      Puppet[:environment] = 'special'
+      Puppet[:node_terminus] = 'exec'
+      Puppet[:external_nodes] = enc
+      Puppet[:manifest] = site_manifest
+      puppet = Puppet::Application[:apply]
+      puppet.stubs(:command_line).returns(stub('command_line', :args => [manifest]))
+      expect { puppet.run_command }.to exit_with(0)
+    end
+
+    expect(@logs.map(&:to_s)).to include('specific manifest applied')
+  end
+
   context "with a module" do
     let(:modulepath) { tmpdir('modulepath') }
     let(:execute) { 'include amod' }
     let(:args) { ['-e', execute, '--modulepath', modulepath] }
 
     before(:each) do
-      Puppet::FileSystem.mkpath("#{modulepath}/amod/manifests")
-      File.open("#{modulepath}/amod/manifests/init.pp", "w") do |f|
-        f.puts <<-EOF
-        class amod{
-          notice('amod class included')
+      dir_contained_in(modulepath, {
+        "amod" => {
+          "manifests" => {
+            "init.pp" => "class amod{ notice('amod class included') }"
+          }
         }
-        EOF
-      end
-      environmentdir = Dir.mktmpdir('environments')
-      Puppet[:environmentpath] = environmentdir
-      create_default_directory_environment
-    end
+      })
 
-    def create_default_directory_environment
-      Puppet::FileSystem.mkpath("#{Puppet[:environmentpath]}/#{Puppet[:environment]}")
+      Puppet[:environmentpath] = dir_containing("environments", { Puppet[:environment] => {} })
     end
 
     def init_cli_args_and_apply_app(args, execute)
       Puppet.initialize_settings(args)
       puppet = Puppet::Application.find(:apply).new(stub('command_line', :subcommand_name => :apply, :args => args))
       puppet.options[:code] = execute
       return puppet
     end
 
     it "looks in --modulepath even when the default directory environment exists" do
       apply = init_cli_args_and_apply_app(args, execute)
 
       expect do
         expect { apply.run }.to exit_with(0)
       end.to have_printed('amod class included')
     end
 
     it "looks in --modulepath even when given a specific directory --environment" do
       args << '--environment' << 'production'
       apply = init_cli_args_and_apply_app(args, execute)
 
       expect do
         expect { apply.run }.to exit_with(0)
       end.to have_printed('amod class included')
     end
 
     it "looks in --modulepath when given multiple paths in --modulepath" do
       args = ['-e', execute, '--modulepath', [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)]
       apply = init_cli_args_and_apply_app(args, execute)
 
       expect do
         expect { apply.run }.to exit_with(0)
       end.to have_printed('amod class included')
     end
   end
 
 end
diff --git a/spec/lib/puppet_spec/files.rb b/spec/lib/puppet_spec/files.rb
index 312c4fc95..2d0d95275 100755
--- a/spec/lib/puppet_spec/files.rb
+++ b/spec/lib/puppet_spec/files.rb
@@ -1,88 +1,89 @@
 require 'fileutils'
 require 'tempfile'
 require 'tmpdir'
 require 'pathname'
 
 # A support module for testing files.
 module PuppetSpec::Files
   def self.cleanup
     $global_tempfiles ||= []
     while path = $global_tempfiles.pop do
       begin
         Dir.unstub(:entries)
         FileUtils.rm_rf path, :secure => true
       rescue Errno::ENOENT
         # nothing to do
       end
     end
   end
 
   def make_absolute(path) PuppetSpec::Files.make_absolute(path) end
   def self.make_absolute(path)
     path = File.expand_path(path)
     path[0] = 'c' if Puppet.features.microsoft_windows?
     path
   end
 
   def tmpfile(name, dir = nil) PuppetSpec::Files.tmpfile(name, dir) end
   def self.tmpfile(name, dir = nil)
     # Generate a temporary file, just for the name...
     source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
     path = source.path
     source.close!
 
     record_tmp(File.expand_path(path))
 
     path
   end
 
   def file_containing(name, contents) PuppetSpec::Files.file_containing(name, contents) end
   def self.file_containing(name, contents)
     file = tmpfile(name)
     File.open(file, 'wb') { |f| f.write(contents) }
     file
   end
 
   def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
   def self.tmpdir(name)
     dir = Dir.mktmpdir(name)
 
     record_tmp(dir)
 
     dir
   end
 
   def dir_containing(name, contents_hash) PuppetSpec::Files.dir_containing(name, contents_hash) end
   def self.dir_containing(name, contents_hash)
     dir_contained_in(tmpdir(name), contents_hash)
   end
 
+  def dir_contained_in(dir, contents_hash) PuppetSpec::Files.dir_contained_in(dir, contents_hash) end
   def self.dir_contained_in(dir, contents_hash)
     contents_hash.each do |k,v|
       if v.is_a?(Hash)
         Dir.mkdir(tmp = File.join(dir,k))
         dir_contained_in(tmp, v)
       else
         file = File.join(dir, k)
         File.open(file, 'wb') {|f| f.write(v) }
       end
     end
     dir
   end
 
   def self.record_tmp(tmp)
     # ...record it for cleanup,
     $global_tempfiles ||= []
     $global_tempfiles << tmp
   end
 
   def expect_file_mode(file, mode)
     actual_mode = "%o" % Puppet::FileSystem.stat(file).mode
     target_mode = if Puppet.features.microsoft_windows?
       mode
     else
       "10" + "%04i" % mode.to_i
     end
     actual_mode.should == target_mode
   end
 end