diff --git a/lib/puppet/type/exec.rb b/lib/puppet/type/exec.rb
index daa49e223..033183ae7 100755
--- a/lib/puppet/type/exec.rb
+++ b/lib/puppet/type/exec.rb
@@ -1,649 +1,640 @@
 module Puppet
   newtype(:exec) do
     include Puppet::Util::Execution
     require 'timeout'
 
     @doc = "Executes external commands.  It is critical that all commands
       executed using this mechanism can be run multiple times without
       harm, i.e., they are *idempotent*.  One useful way to create idempotent
       commands is to use the checks like `creates` to avoid running the
       command unless some condition is met.
 
       Note that you can restrict an `exec` to only run when it receives
       events by using the `refreshonly` parameter; this is a useful way to
       have your configuration respond to events with arbitrary commands.
 
       Note also that if an `exec` receives an event from another resource,
       it will get executed again (or execute the command specified in `refresh`, if there is one).
 
       There is a strong tendency to use `exec` to do whatever work Puppet
       can't already do; while this is obviously acceptable (and unavoidable)
       in the short term, it is highly recommended to migrate work from `exec`
       to native Puppet types as quickly as possible.  If you find that
       you are doing a lot of work with `exec`, please at least notify
       us at Puppet Labs what you are doing, and hopefully we can work with
       you to get a native resource type for the work you are doing."
 
     require 'open3'
 
     # Create a new check mechanism.  It's basically just a parameter that
     # provides one extra 'check' method.
     def self.newcheck(name, &block)
       @checks ||= {}
 
       check = newparam(name, &block)
       @checks[name] = check
     end
 
     def self.checks
       @checks.keys
     end
 
     newproperty(:returns, :array_matching => :all, :event => :executed_command) do |property|
       include Puppet::Util::Execution
       munge do |value|
         value.to_s
       end
 
       def event_name
         :executed_command
       end
 
       defaultto "0"
 
       attr_reader :output
       desc "The expected return code(s).  An error will be returned if the
         executed command returns something else.  Defaults to 0. Can be
         specified as an array of acceptable return codes or a single value."
 
       # Make output a bit prettier
       def change_to_s(currentvalue, newvalue)
         "executed successfully"
       end
 
       # First verify that all of our checks pass.
       def retrieve
         # Default to somethinng
 
         if @resource.check
           return :notrun
         else
           return self.should
         end
       end
 
       # Actually execute the command.
       def sync
         olddir = nil
 
         # We need a dir to change to, even if it's just the cwd
         dir = self.resource[:cwd] || Dir.pwd
 
         event = :executed_command
         tries = self.resource[:tries]
         try_sleep = self.resource[:try_sleep]
 
         begin
           tries.times do |try|
             # Only add debug messages for tries > 1 to reduce log spam.
             debug("Exec try #{try+1}/#{tries}") if tries > 1
             @output, @status = @resource.run(self.resource[:command])
             break if self.should.include?(@status.exitstatus.to_s)
             if try_sleep > 0 and tries > 1
               debug("Sleeping for #{try_sleep} seconds between tries")
               sleep try_sleep
             end
           end
         rescue Timeout::Error
           self.fail "Command exceeded timeout" % value.inspect
         end
 
         if log = @resource[:logoutput]
           case log
           when :true
             log = @resource[:loglevel]
           when :on_failure
             unless self.should.include?(@status.exitstatus.to_s)
               log = @resource[:loglevel]
             else
               log = :false
             end
           end
           unless log == :false
             @output.split(/\n/).each { |line|
               self.send(log, line)
             }
           end
         end
 
         unless self.should.include?(@status.exitstatus.to_s)
           self.fail("#{self.resource[:command]} returned #{@status.exitstatus} instead of one of [#{self.should.join(",")}]")
         end
 
         event
       end
     end
 
     newparam(:command) do
       isnamevar
       desc "The actual command to execute.  Must either be fully qualified
         or a search path for the command must be provided.  If the command
         succeeds, any output produced will be logged at the instance's
         normal log level (usually `notice`), but if the command fails
         (meaning its return code does not match the specified code) then
         any output is logged at the `err` log level."
     end
 
     newparam(:path) do
       desc "The search path used for command execution.
         Commands must be fully qualified if no path is specified.  Paths
         can be specified as an array or as a colon-separated list."
 
       # Support both arrays and colon-separated fields.
       def value=(*values)
         @value = values.flatten.collect { |val|
           if val =~ /;/ # recognize semi-colon separated paths
             val.split(";")
           elsif val =~ /^\w:[^:]*$/ # heuristic to avoid splitting a driveletter away
             val
           else
             val.split(":")
           end
         }.flatten
       end
     end
 
     newparam(:user) do
       desc "The user to run the command as.  Note that if you
         use this then any error output is not currently captured.  This
         is because of a bug within Ruby.  If you are using Puppet to
         create this user, the exec will automatically require the user,
         as long as it is specified by name."
 
       # Most validation is handled by the SUIDManager class.
       validate do |user|
         self.fail "Only root can execute commands as other users" unless Puppet.features.root?
       end
     end
 
     newparam(:group) do
       desc "The group to run the command as.  This seems to work quite
         haphazardly on different platforms -- it is a platform issue
         not a Ruby or Puppet one, since the same variety exists when
         running commnands as different users in the shell."
       # Validation is handled by the SUIDManager class.
     end
 
     newparam(:cwd) do
       desc "The directory from which to run the command.  If
         this directory does not exist, the command will fail."
 
       validate do |dir|
         unless dir =~ /^#{File::SEPARATOR}/
           self.fail("CWD must be a fully qualified path")
         end
       end
 
       munge do |dir|
         dir = dir[0] if dir.is_a?(Array)
 
         dir
       end
     end
 
     newparam(:logoutput) do
       desc "Whether to log output.  Defaults to logging output at the
         loglevel for the `exec` resource. Use *on_failure* to only
         log the output when the command reports an error.  Values are
         **true**, *false*, *on_failure*, and any legal log level."
 
       newvalues(:true, :false, :on_failure)
     end
 
     newparam(:refresh) do
       desc "How to refresh this command.  By default, the exec is just
         called again when it receives an event from another resource,
         but this parameter allows you to define a different command
         for refreshing."
 
       validate do |command|
         @resource.validatecmd(command)
       end
     end
 
-    newparam(:env) do
-      desc "This parameter is deprecated. Use 'environment' instead."
-
-      munge do |value|
-        warning "'env' is deprecated on exec; use 'environment' instead."
-        resource[:environment] = value
-      end
-    end
-
     newparam(:environment) do
       desc "Any additional environment variables you want to set for a
         command.  Note that if you use this to set PATH, it will override
         the `path` attribute.  Multiple environment variables should be
         specified as an array."
 
       validate do |values|
         values = [values] unless values.is_a? Array
         values.each do |value|
           unless value =~ /\w+=/
             raise ArgumentError, "Invalid environment setting '#{value}'"
           end
         end
       end
     end
 
     newparam(:timeout) do
       desc "The maximum time the command should take.  If the command takes
         longer than the timeout, the command is considered to have failed
         and will be stopped.  Use any negative number to disable the timeout.
         The time is specified in seconds."
 
       munge do |value|
         value = value.shift if value.is_a?(Array)
         if value.is_a?(String)
           unless value =~ /^[-\d.]+$/
             raise ArgumentError, "The timeout must be a number."
           end
           Float(value)
         else
           value
         end
       end
 
       defaultto 300
     end
 
     newparam(:tries) do
       desc "The number of times execution of the command should be tried.
         Defaults to '1'. This many attempts will be made to execute
         the command until an acceptable return code is returned.
         Note that the timeout paramater applies to each try rather than
         to the complete set of tries."
 
       munge do |value|
         if value.is_a?(String)
           unless value =~ /^[\d]+$/
             raise ArgumentError, "Tries must be an integer"
           end
           value = Integer(value)
         end
         raise ArgumentError, "Tries must be an integer >= 1" if value < 1
         value
       end
 
       defaultto 1
     end
 
     newparam(:try_sleep) do
       desc "The time to sleep in seconds between 'tries'."
 
       munge do |value|
         if value.is_a?(String)
           unless value =~ /^[-\d.]+$/
             raise ArgumentError, "try_sleep must be a number"
           end
           value = Float(value)
         end
         raise ArgumentError, "try_sleep cannot be a negative number" if value < 0
         value
       end
 
       defaultto 0
     end
 
 
     newcheck(:refreshonly) do
       desc "The command should only be run as a
         refresh mechanism for when a dependent object is changed.  It only
         makes sense to use this option when this command depends on some
         other object; it is useful for triggering an action:
 
             # Pull down the main aliases file
             file { \"/etc/aliases\":
               source => \"puppet://server/module/aliases\"
             }
 
             # Rebuild the database, but only when the file changes
             exec { newaliases:
               path => [\"/usr/bin\", \"/usr/sbin\"],
               subscribe => File[\"/etc/aliases\"],
               refreshonly => true
             }
 
         Note that only `subscribe` and `notify` can trigger actions, not `require`,
         so it only makes sense to use `refreshonly` with `subscribe` or `notify`."
 
       newvalues(:true, :false)
 
       # We always fail this test, because we're only supposed to run
       # on refresh.
       def check(value)
         # We have to invert the values.
         if value == :true
           false
         else
           true
         end
       end
     end
 
     newcheck(:creates) do
       desc "A file that this command creates.  If this
         parameter is provided, then the command will only be run
         if the specified file does not exist:
 
             exec { \"tar xf /my/tar/file.tar\":
               cwd => \"/var/tmp\",
               creates => \"/var/tmp/myfile\",
               path => [\"/usr/bin\", \"/usr/sbin\"]
             }
 
         "
 
       # FIXME if they try to set this and fail, then we should probably
       # fail the entire exec, right?
       validate do |files|
         files = [files] unless files.is_a? Array
 
         files.each do |file|
           self.fail("'creates' must be set to a fully qualified path") unless file
 
           unless file =~ %r{^#{File::SEPARATOR}}
             self.fail "'creates' files must be fully qualified."
           end
         end
       end
 
       # If the file exists, return false (i.e., don't run the command),
       # else return true
       def check(value)
         ! FileTest.exists?(value)
       end
     end
 
     newcheck(:unless) do
       desc "If this parameter is set, then this `exec` will run unless
         the command returns 0.  For example:
 
             exec { \"/bin/echo root >> /usr/lib/cron/cron.allow\":
               path => \"/usr/bin:/usr/sbin:/bin\",
               unless => \"grep root /usr/lib/cron/cron.allow 2>/dev/null\"
             }
 
         This would add `root` to the cron.allow file (on Solaris) unless
         `grep` determines it's already there.
 
         Note that this command follows the same rules as the main command,
         which is to say that it must be fully qualified if the path is not set.
         "
 
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
 
         cmds.each do |cmd|
           @resource.validatecmd(cmd)
         end
       end
 
       # Return true if the command does not return 0.
       def check(value)
         begin
           output, status = @resource.run(value, true)
         rescue Timeout::Error
           err "Check #{value.inspect} exceeded timeout"
           return false
         end
 
         status.exitstatus != 0
       end
     end
 
     newcheck(:onlyif) do
       desc "If this parameter is set, then this `exec` will only run if
         the command returns 0.  For example:
 
             exec { \"logrotate\":
               path => \"/usr/bin:/usr/sbin:/bin\",
               onlyif => \"test `du /var/log/messages | cut -f1` -gt 100000\"
             }
 
         This would run `logrotate` only if that test returned true.
 
         Note that this command follows the same rules as the main command,
         which is to say that it must be fully qualified if the path is not set.
 
         Also note that onlyif can take an array as its value, e.g.:
 
             onlyif => [\"test -f /tmp/file1\", \"test -f /tmp/file2\"]
 
         This will only run the exec if /all/ conditions in the array return true.
         "
 
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
 
         cmds.each do |cmd|
           @resource.validatecmd(cmd)
         end
       end
 
       # Return true if the command returns 0.
       def check(value)
         begin
           output, status = @resource.run(value, true)
         rescue Timeout::Error
           err "Check #{value.inspect} exceeded timeout"
           return false
         end
 
         status.exitstatus == 0
       end
     end
 
     # Exec names are not isomorphic with the objects.
     @isomorphic = false
 
     validate do
       validatecmd(self[:command])
     end
 
     # FIXME exec should autorequire any exec that 'creates' our cwd
     autorequire(:file) do
       reqs = []
 
       # Stick the cwd in there if we have it
       reqs << self[:cwd] if self[:cwd]
 
       self[:command].scan(/^(#{File::SEPARATOR}\S+)/) { |str|
         reqs << str
       }
 
       self[:command].scan(/^"([^"]+)"/) { |str|
         reqs << str
       }
 
       [:onlyif, :unless].each { |param|
         next unless tmp = self[param]
 
         tmp = [tmp] unless tmp.is_a? Array
 
         tmp.each do |line|
           # And search the command line for files, adding any we
           # find.  This will also catch the command itself if it's
           # fully qualified.  It might not be a bad idea to add
           # unqualified files, but, well, that's a bit more annoying
           # to do.
           reqs += line.scan(%r{(#{File::SEPARATOR}\S+)})
         end
       }
 
       # For some reason, the += isn't causing a flattening
       reqs.flatten!
 
       reqs
     end
 
     autorequire(:user) do
       # Autorequire users if they are specified by name
       if user = self[:user] and user !~ /^\d+$/
         user
       end
     end
 
     def self.instances
       []
     end
 
     # Verify that we pass all of the checks.  The argument determines whether
     # we skip the :refreshonly check, which is necessary because we now check
     # within refresh
     def check(refreshing = false)
       self.class.checks.each { |check|
         next if refreshing and check == :refreshonly
         if @parameters.include?(check)
           val = @parameters[check].value
           val = [val] unless val.is_a? Array
           val.each do |value|
             return false unless @parameters[check].check(value)
           end
         end
       }
 
       true
     end
 
     # Verify that we have the executable
     def checkexe(cmd)
       exe = extractexe(cmd)
 
       if self[:path]
         if Puppet.features.posix? and !File.exists?(exe)
           withenv :PATH => self[:path].join(File::PATH_SEPARATOR) do
             exe = which(exe) || raise(ArgumentError,"Could not find command '#{exe}'")
           end
         elsif Puppet.features.microsoft_windows? and !File.exists?(exe)
           self[:path].each do |path|
             [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
               file = File.join(path, exe+extension)
               return if File.exists?(file)
             end
           end
         end
       end
 
       raise ArgumentError, "Could not find executable '#{exe}'" unless FileTest.exists?(exe)
       unless FileTest.executable?(exe)
         raise ArgumentError,
           "'#{exe}' is not executable"
       end
     end
 
     def output
       if self.property(:returns).nil?
         return nil
       else
         return self.property(:returns).output
       end
     end
 
     # Run the command, or optionally run a separately-specified command.
     def refresh
       if self.check(true)
         if cmd = self[:refresh]
           self.run(cmd)
         else
           self.property(:returns).sync
         end
       end
     end
 
     # Run a command.
     def run(command, check = false)
       output = nil
       status = nil
 
       dir = nil
 
       checkexe(command)
 
       if dir = self[:cwd]
         unless File.directory?(dir)
           if check
             dir = nil
           else
             self.fail "Working directory '#{dir}' does not exist"
           end
         end
       end
 
       dir ||= Dir.pwd
 
       if check
         debug "Executing check '#{command}'"
       else
         debug "Executing '#{command}'"
       end
       begin
         # Do our chdir
         Dir.chdir(dir) do
           environment = {}
 
           environment[:PATH] = self[:path].join(":") if self[:path]
 
           if envlist = self[:environment]
             envlist = [envlist] unless envlist.is_a? Array
             envlist.each do |setting|
               if setting =~ /^(\w+)=((.|\n)+)$/
                 name = $1
                 value = $2
                 if environment.include? name
                   warning(
                   "Overriding environment setting '#{name}' with '#{value}'"
                   )
                 end
                 environment[name] = value
               else
                 warning "Cannot understand environment setting #{setting.inspect}"
               end
             end
           end
 
           withenv environment do
             Timeout::timeout(self[:timeout]) do
               output, status = Puppet::Util::SUIDManager.run_and_capture(
                 [command], self[:user], self[:group]
               )
             end
             # The shell returns 127 if the command is missing.
             if status.exitstatus == 127
               raise ArgumentError, output
             end
           end
         end
       rescue Errno::ENOENT => detail
         self.fail detail.to_s
       end
 
       return output, status
     end
 
     def validatecmd(cmd)
       exe = extractexe(cmd)
       # if we're not fully qualified, require a path
       self.fail "'#{cmd}' is not qualified and no path was specified. Please qualify the command or specify a path." if File.expand_path(exe) != exe and self[:path].nil?
     end
 
     def extractexe(cmd)
       # easy case: command was quoted
       if cmd =~ /^"([^"]+)"/
         $1
       else
         cmd.split(/ /)[0]
       end
     end
   end
 end
diff --git a/test/ral/type/exec.rb b/test/ral/type/exec.rb
index 933994b88..829b1a068 100755
--- a/test/ral/type/exec.rb
+++ b/test/ral/type/exec.rb
@@ -1,847 +1,804 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
 
 require 'puppettest'
 
 class TestExec < Test::Unit::TestCase
   include PuppetTest
   def test_numvsstring
     [0, "0"].each { |val|
       command = nil
       output = nil
       assert_nothing_raised {
 
         command = Puppet::Type.type(:exec).new(
 
           :command => "/bin/echo",
 
           :returns => val
         )
       }
       assert_events([:executed_command], command)
     }
   end
 
   def test_path_or_qualified
     command = nil
     output = nil
     assert_raise(Puppet::Error) {
       command = Puppet::Type.type(:exec).new(
         :command => "echo"
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
 
         :command => "echo",
 
         :path => "/usr/bin:/bin:/usr/sbin:/sbin"
       )
     }
     assert_nothing_raised {
       command = Puppet::Type.type(:exec).new(
         :command => "/bin/echo"
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
 
         :command => "/bin/echo",
 
         :path => "/usr/bin:/bin:/usr/sbin:/sbin"
       )
     }
   end
 
   def test_nonzero_returns
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
 
         :command => "mkdir /this/directory/does/not/exist",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
         :returns => 1
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
 
         :command => "touch /etc",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
         :returns => 1
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
 
         :command => "thiscommanddoesnotexist",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
         :returns => 127
       )
     }
   end
 
   def test_cwdsettings
     command = nil
     dir = "/tmp"
     wd = Dir.chdir(dir) {
       Dir.getwd
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
 
         :command => "pwd",
         :cwd => dir,
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
         :returns => 0
       )
     }
     assert_events([:executed_command], command)
     assert_equal(wd,command.output.chomp)
   end
 
   def test_refreshonly_functional
     file = nil
     cmd = nil
     tmpfile = tempfile
     @@tmpfiles.push tmpfile
     trans = nil
 
       file = Puppet::Type.type(:file).new(
 
         :path => tmpfile,
 
         :content => "yay"
     )
     # Get the file in sync
     assert_apply(file)
 
     # Now make an exec
     maker = tempfile
     assert_nothing_raised {
 
       cmd = Puppet::Type.type(:exec).new(
 
         :command => "touch #{maker}",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
         :subscribe => file,
 
         :refreshonly => true
       )
     }
 
     assert(cmd, "did not make exec")
 
     assert_nothing_raised do
       assert(! cmd.check, "Check passed when refreshonly is set")
     end
 
     assert_events([], file, cmd)
     assert(! FileTest.exists?(maker), "made file without refreshing")
 
     # Now change our content, so we throw a refresh
     file[:content] = "yayness"
     assert_events([:content_changed, :restarted], file, cmd)
     assert(FileTest.exists?(maker), "file was not made in refresh")
   end
 
   def test_refreshonly
     cmd = true
     assert_nothing_raised {
 
       cmd = Puppet::Type.type(:exec).new(
 
         :command => "pwd",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
         :refreshonly => true
       )
     }
 
     # Checks should always fail when refreshonly is enabled
     assert(!cmd.check, "Check passed with refreshonly true")
 
     # Now make sure it passes if we pass in "true"
     assert(cmd.check(true), "Check failed with refreshonly true while refreshing")
 
     # Now set it to false
     cmd[:refreshonly] = false
     assert(cmd.check, "Check failed with refreshonly false")
   end
 
   def test_creates
     file = tempfile
     exec = nil
     assert(! FileTest.exists?(file), "File already exists")
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => "touch #{file}",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
         :creates => file
       )
     }
 
     comp = mk_catalog("createstest", exec)
     assert_events([:executed_command], comp, "creates")
     assert_events([], comp, "creates")
   end
 
   # Verify that we can download the file that we're going to execute.
   def test_retrievethenmkexe
     exe = tempfile
     oexe = tempfile
     sh = %x{which sh}
     File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
 
       file = Puppet::Type.type(:file).new(
 
         :path => oexe,
         :source => exe,
 
         :mode => 0755
     )
 
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => oexe,
 
         :require => Puppet::Resource.new(:file, oexe)
     )
 
     comp = mk_catalog("Testing", file, exec)
 
     assert_events([:file_created, :executed_command], comp)
   end
 
   # Verify that we auto-require any managed scripts.
   def test_autorequire_files
     exe = tempfile
     oexe = tempfile
     sh = %x{which sh}
     File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
 
       file = Puppet::Type.type(:file).new(
 
         :path => oexe,
         :source => exe,
 
         :mode => 755
     )
 
     basedir = File.dirname(oexe)
 
       baseobj = Puppet::Type.type(:file).new(
 
         :path => basedir,
         :source => exe,
 
         :mode => 755
     )
 
 
       ofile = Puppet::Type.type(:file).new(
 
         :path => exe,
 
         :mode => 755
     )
 
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => oexe,
         :path => ENV["PATH"],
 
         :cwd => basedir
     )
 
 
       cat = Puppet::Type.type(:exec).new(
 
         :command => "cat #{exe} #{oexe}",
 
         :path => ENV["PATH"]
     )
 
     catalog = mk_catalog(file, baseobj, ofile, exec, cat)
 
     rels = nil
     assert_nothing_raised do
       rels = exec.autorequire
     end
 
     # Verify we get the script itself
     assert(rels.detect { |r| r.source == file }, "Exec did not autorequire its command")
 
     # Verify we catch the cwd
     assert(rels.detect { |r| r.source == baseobj }, "Exec did not autorequire its cwd")
 
     # Verify we don't require ourselves
     assert(! rels.detect { |r| r.source == ofile }, "Exec incorrectly required mentioned file")
 
     # We not longer autorequire inline files
     assert_nothing_raised do
       rels = cat.autorequire
     end
     assert(! rels.detect { |r| r.source == ofile }, "Exec required second inline file")
     assert(! rels.detect { |r| r.source == file }, "Exec required inline file")
   end
 
   def test_ifonly
     afile = tempfile
     bfile = tempfile
 
     exec = nil
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => "touch #{bfile}",
         :onlyif => "test -f #{afile}",
 
         :path => ENV['PATH']
       )
     }
 
     assert_events([], exec)
     system("touch #{afile}")
     assert_events([:executed_command], exec)
     assert_events([:executed_command], exec)
     system("rm #{afile}")
     assert_events([], exec)
   end
 
   def test_unless
     afile = tempfile
     bfile = tempfile
 
     exec = nil
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => "touch #{bfile}",
         :unless => "test -f #{afile}",
 
         :path => ENV['PATH']
       )
     }
     comp = mk_catalog(exec)
 
     assert_events([:executed_command], comp)
     assert_events([:executed_command], comp)
     system("touch #{afile}")
     assert_events([], comp)
     assert_events([], comp)
     system("rm #{afile}")
     assert_events([:executed_command], comp)
     assert_events([:executed_command], comp)
   end
 
   if Puppet.features.root?
     # Verify that we can execute commands as a special user
     def mknverify(file, user, group = nil, id = true)
       File.umask(0022)
 
       args = {
         :command => "touch #{file}",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
       }
 
       if user
         #Puppet.warning "Using user #{user.name}"
         if id
           # convert to a string, because that's what the object expects
           args[:user] = user.uid.to_s
         else
           args[:user] = user.name
         end
       end
 
       if group
         #Puppet.warning "Using group #{group.name}"
         if id
           args[:group] = group.gid.to_s
         else
           args[:group] = group.name
         end
       end
       exec = nil
       assert_nothing_raised {
         exec = Puppet::Type.type(:exec).new(args)
       }
 
       comp = mk_catalog("usertest", exec)
       assert_events([:executed_command], comp, "usertest")
 
       assert(FileTest.exists?(file), "File does not exist")
       assert_equal(user.uid, File.stat(file).uid, "File UIDs do not match") if user
 
       # We can't actually test group ownership, unfortunately, because
       # behaviour changes wildlly based on platform.
       Puppet::Type.allclear
     end
 
     def test_userngroup
       file = tempfile
       [
         [nonrootuser], # just user, by name
         [nonrootuser, nil, true], # user, by uid
         [nil, nonrootgroup], # just group
         [nil, nonrootgroup, true], # just group, by id
         [nonrootuser, nonrootgroup], # user and group, by name
         [nonrootuser, nonrootgroup, true], # user and group, by id
       ].each { |ary|
         mknverify(file, *ary) {
         }
       }
     end
   end
 
   def test_logoutput
     exec = nil
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
 
         :title => "logoutputesting",
         :path => "/usr/bin:/bin",
         :command => "echo logoutput is false",
 
         :logoutput => false
       )
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
       exec[:command] = "echo logoutput is true"
       exec[:logoutput] = true
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
       exec[:command] = "echo logoutput is on_failure"
       exec[:logoutput] = "on_failure"
     }
 
     assert_apply(exec)
   end
 
   def test_execthenfile
     exec = nil
     file = nil
     basedir = tempfile
     path = File.join(basedir, "subfile")
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
 
         :title => "mkdir",
         :path => "/usr/bin:/bin",
         :creates => basedir,
 
         :command => "mkdir #{basedir}; touch #{path}"
 
       )
     }
 
     assert_nothing_raised {
 
       file = Puppet::Type.type(:file).new(
 
         :path => basedir,
         :recurse => true,
         :mode => "755",
 
         :require => Puppet::Resource.new("exec", "mkdir")
       )
     }
 
     comp = mk_catalog(file, exec)
     comp.finalize
     assert_events([:executed_command, :mode_changed], comp)
 
     assert(FileTest.exists?(path), "Exec ran first")
     assert(File.stat(path).mode & 007777 == 0755)
   end
 
   # Make sure all checks need to be fully qualified.
   def test_falsevals
     exec = nil
     assert_nothing_raised do
       exec = Puppet::Type.type(:exec).new(
         :command => "/bin/touch yayness"
       )
     end
 
     Puppet::Type.type(:exec).checks.each do |check|
       klass = Puppet::Type.type(:exec).paramclass(check)
       next if klass.value_collection.values.include? :false
       assert_raise(Puppet::Error, "Check '#{check}' did not fail on false") do
         exec[check] = false
       end
     end
   end
 
   def test_createcwdandexe
     exec1 = exec2 = nil
     dir = tempfile
     file = tempfile
 
     assert_nothing_raised {
 
       exec1 = Puppet::Type.type(:exec).new(
 
         :title => "one",
         :path => ENV["PATH"],
 
         :command => "mkdir #{dir}"
       )
     }
 
     assert_nothing_raised("Could not create exec w/out existing cwd") {
 
       exec2 = Puppet::Type.type(:exec).new(
 
         :title => "two",
         :path => ENV["PATH"],
         :command => "touch #{file}",
 
         :cwd => dir
       )
     }
 
     # Throw a check in there with our cwd and make sure it works
     assert_nothing_raised("Could not check with a missing cwd") do
       exec2[:unless] = "test -f /this/file/does/not/exist"
       exec2.retrieve
     end
 
     assert_raise(Puppet::Error) do
       exec2.property(:returns).sync
     end
 
     assert_nothing_raised do
       exec2[:require] = exec1
     end
 
     assert_apply(exec1, exec2)
 
     assert(FileTest.exists?(file))
   end
 
   def test_checkarrays
     exec = nil
     file = tempfile
 
     test = "test -f #{file}"
 
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
 
         :path => ENV["PATH"],
 
         :command => "touch #{file}"
       )
     }
 
     assert_nothing_raised {
       exec[:unless] = test
     }
 
     assert_nothing_raised {
       assert(exec.check, "Check did not pass")
     }
 
     assert_nothing_raised {
       exec[:unless] = [test, test]
     }
 
 
     assert_nothing_raised {
       exec.finish
     }
 
     assert_nothing_raised {
       assert(exec.check, "Check did not pass")
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
       assert(! exec.check, "Check passed")
     }
   end
 
   def test_missing_checks_cause_failures
     # Solaris's sh exits with 1 here instead of 127
     return if Facter.value(:operatingsystem) == "Solaris"
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => "echo true",
         :path => ENV["PATH"],
 
         :onlyif => "/bin/nosuchthingexists"
           )
 
     assert_raise(ArgumentError, "Missing command did not raise error") {
       exec.run("/bin/nosuchthingexists")
     }
   end
 
-  def test_envparam
-
-    exec = Puppet::Type.newexec(
-
-      :command => "echo $envtest",
-      :path => ENV["PATH"],
-
-      :env => "envtest=yayness"
-    )
-
-    assert(exec, "Could not make exec")
-
-    output = status = nil
-    assert_nothing_raised {
-      output, status = exec.run("echo $envtest")
-    }
-
-    assert_equal("yayness\n", output)
-
-    # Now check whether we can do multiline settings
-    assert_nothing_raised do
-      exec[:env] = "envtest=a list of things
-and stuff"
-  end
-
-  output = status = nil
-  assert_nothing_raised {
-    output, status = exec.run('echo "$envtest"')
-    }
-    assert_equal("a list of things\nand stuff\n", output)
-
-    # Now test arrays
-    assert_nothing_raised do
-      exec[:env] = ["funtest=A", "yaytest=B"]
-    end
-
-    output = status = nil
-    assert_nothing_raised {
-      output, status = exec.run('echo "$funtest" "$yaytest"')
-    }
-    assert_equal("A B\n", output)
-  end
-
   def test_environmentparam
 
     exec = Puppet::Type.newexec(
 
       :command => "echo $environmenttest",
       :path => ENV["PATH"],
 
       :environment => "environmenttest=yayness"
     )
 
     assert(exec, "Could not make exec")
 
     output = status = nil
     assert_nothing_raised {
       output, status = exec.run("echo $environmenttest")
     }
 
     assert_equal("yayness\n", output)
 
     # Now check whether we can do multiline settings
     assert_nothing_raised do
       exec[:environment] = "environmenttest=a list of things
 and stuff"
   end
 
   output = status = nil
   assert_nothing_raised {
     output, status = exec.run('echo "$environmenttest"')
     }
     assert_equal("a list of things\nand stuff\n", output)
 
     # Now test arrays
     assert_nothing_raised do
       exec[:environment] = ["funtest=A", "yaytest=B"]
     end
 
     output = status = nil
     assert_nothing_raised {
       output, status = exec.run('echo "$funtest" "$yaytest"')
     }
     assert_equal("A B\n", output)
   end
 
   def test_timeout
     exec = Puppet::Type.type(:exec).new(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
     time = Time.now
 
     assert_raise(Timeout::Error) {
       exec.run("sleep 1")
     }
     Puppet.info "#{Time.now.to_f - time.to_f} seconds, vs a timeout of #{exec[:timeout]}"
 
 
     assert_apply(exec)
   end
 
   # Testing #470
   def test_run_as_created_user
     exec = nil
     if Process.uid == 0
       user = "nosuchuser"
       assert_nothing_raised("Could not create exec with non-existent user") do
 
         exec = Puppet::Type.type(:exec).new(
 
           :command => "/bin/echo yay",
 
           :user => user
         )
       end
     end
 
     # Now try the group
     group = "nosuchgroup"
     assert_nothing_raised("Could not create exec with non-existent user") do
 
       exec = Puppet::Type.type(:exec).new(
 
         :command => "/bin/echo yay",
 
         :group => group
       )
     end
   end
 
   # make sure paths work both as arrays and strings
   def test_paths_as_arrays
     path = %w{/usr/bin /usr/sbin /sbin}
     exec = nil
     assert_nothing_raised("Could not use an array for the path") do
       exec = Puppet::Type.type(:exec).new(:command => "echo yay", :path => path)
     end
     assert_equal(path, exec[:path], "array-based path did not match")
     assert_nothing_raised("Could not use a string for the path") do
       exec = Puppet::Type.type(:exec).new(:command => "echo yay", :path => path.join(":"))
     end
     assert_equal(path, exec[:path], "string-based path did not match")
     assert_nothing_raised("Could not use a colon-separated strings in an array for the path") do
       exec = Puppet::Type.type(:exec).new(:command => "echo yay", :path => ["/usr/bin", "/usr/sbin:/sbin"])
     end
     assert_equal(path, exec[:path], "colon-separated array path did not match")
   end
 
   def test_checks_apply_to_refresh
     file = tempfile
     maker = tempfile
 
       exec = Puppet::Type.type(:exec).new(
 
         :title => "maker",
         :command => "touch #{maker}",
 
         :path => ENV["PATH"]
     )
 
     # Make sure it runs normally
     assert_apply(exec)
     assert(FileTest.exists?(maker), "exec did not run")
     File.unlink(maker)
 
     # Now make sure it refreshes
     assert_nothing_raised("Failed to refresh exec") do
       exec.refresh
     end
     assert(FileTest.exists?(maker), "exec did not run refresh")
     File.unlink(maker)
 
     # Now add the checks
     exec[:creates] = file
 
     # Make sure it runs when the file doesn't exist
     assert_nothing_raised("Failed to refresh exec") do
       exec.refresh
     end
     assert(FileTest.exists?(maker), "exec did not refresh when checks passed")
     File.unlink(maker)
 
     # Now create the file and make sure it doesn't refresh
     File.open(file, "w") { |f| f.puts "" }
     assert_nothing_raised("Failed to refresh exec") do
       exec.refresh
     end
     assert(! FileTest.exists?(maker), "exec refreshed with failing checks")
   end
 
   def test_explicit_refresh
     refresher = tempfile
     maker = tempfile
 
       exec = Puppet::Type.type(:exec).new(
 
         :title => "maker",
         :command => "touch #{maker}",
 
         :path => ENV["PATH"]
     )
 
     # Call refresh normally
     assert_nothing_raised do
       exec.refresh
     end
 
     # Make sure it created the normal file
     assert(FileTest.exists?(maker), "normal refresh did not work")
     File.unlink(maker)
 
     # Now reset refresh, and make sure it wins
     assert_nothing_raised("Could not set refresh parameter") do
       exec[:refresh] = "touch #{refresher}"
     end
     assert_nothing_raised do
       exec.refresh
     end
 
     # Make sure it created the normal file
     assert(FileTest.exists?(refresher), "refresh param was ignored")
     assert(! FileTest.exists?(maker), "refresh param also ran command")
   end
 
   if Puppet.features.root?
     def test_autorequire_user
       user = Puppet::Type.type(:user).new(:name => "yay")
       exec = Puppet::Type.type(:exec).new(:command => "/bin/echo fun", :user => "yay")
 
       rels = nil
       assert_nothing_raised("Could not evaluate autorequire") do
         rels = exec.autorequire
       end
       assert(rels.find { |r| r.source == user and r.target == exec }, "Exec did not autorequire user")
     end
   end
 end