puppet 0.25.5 → 2.6.0

data/test/ral/type/exec.rb

@@ -5,763 +5,843 @@ require File.dirname(__FILE__) + '/../../lib/puppettest'
 require 'puppettest'
 
 class TestExec < Test::Unit::TestCase
-    include PuppetTest
-    def test_execution
-        command = nil
-        output = nil
-        assert_nothing_raised {
-            command = Puppet::Type.type(:exec).new(
-                :command => "/bin/echo"
-            )
-        }
-        assert_nothing_raised {
-            command.evaluate
-        }
-        assert_events([:executed_command], command)
-    end
+  include PuppetTest
+  def test_numvsstring
+    [0, "0"].each { |val|
+      command = nil
+      output = nil
+      assert_nothing_raised {
 
-    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
+        command = Puppet::Type.type(:exec).new(
 
-    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
+          :command => "/bin/echo",
 
-    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
+          :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 {
 
-    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
+      command = Puppet::Type.type(:exec).new(
+
+        :command => "echo",
 
-    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 %s" % maker,
-                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-                :subscribe => file,
-                :refreshonly => true
-            )
-        }
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin"
+      )
+    }
+    assert_nothing_raised {
+      command = Puppet::Type.type(:exec).new(
+        :command => "/bin/echo"
+      )
+    }
+    assert_nothing_raised {
 
-        assert(cmd, "did not make exec")
+      command = Puppet::Type.type(:exec).new(
 
-        assert_nothing_raised do
-            assert(! cmd.check, "Check passed when refreshonly is set")
-        end
+        :command => "/bin/echo",
 
-        assert_events([], file, cmd)
-        assert(! FileTest.exists?(maker), "made file without refreshing")
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin"
+      )
+    }
+  end
 
-        # Now change our content, so we throw a refresh
-        file[:content] = "yayness"
-        assert_events([:file_changed, :triggered], file, cmd)
-        assert(FileTest.exists?(maker), "file was not made in refresh")
-    end
+  def test_nonzero_returns
+    assert_nothing_raised {
 
-    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
-            )
-        }
+      command = Puppet::Type.type(:exec).new(
 
-        # Checks should always fail when refreshonly is enabled
-        assert(!cmd.check, "Check passed with refreshonly true")
+        :command => "mkdir /this/directory/does/not/exist",
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
-        # Now make sure it passes if we pass in "true"
-        assert(cmd.check(true), "Check failed with refreshonly true while refreshing")
+        :returns => 1
+      )
+    }
+    assert_nothing_raised {
 
-        # Now set it to false
-        cmd[:refreshonly] = false
-        assert(cmd.check, "Check failed with refreshonly false")
-    end
+      command = Puppet::Type.type(:exec).new(
 
-    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 %s" % file,
-                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-                :creates => file
-            )
-        }
+        :command => "touch /etc",
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
-        comp = mk_catalog("createstest", exec)
-        assert_events([:executed_command], comp, "creates")
-        assert_events([], comp, "creates")
-    end
+        :returns => 1
+      )
+    }
+    assert_nothing_raised {
 
-    # 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
-        )
+      command = Puppet::Type.type(:exec).new(
 
-        exec = Puppet::Type.type(:exec).new(
-            :command => oexe,
-            :require => Puppet::Resource::Reference.new(:file, oexe)
-        )
+        :command => "thiscommanddoesnotexist",
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
-        comp = mk_catalog("Testing", file, exec)
+        :returns => 127
+      )
+    }
+  end
 
-        assert_events([:file_created, :executed_command], comp)
-    end
+  def test_cwdsettings
+    command = nil
+    dir = "/tmp"
+    wd = Dir.chdir(dir) {
+      Dir.getwd
+    }
+    assert_nothing_raised {
 
-    # 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
-        )
+      command = Puppet::Type.type(:exec).new(
 
-        basedir = File.dirname(oexe)
-        baseobj = Puppet::Type.type(:file).new(
-            :path => basedir,
-            :source => exe,
-            :mode => 755
-        )
+        :command => "pwd",
+        :cwd => dir,
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
-        ofile = Puppet::Type.type(:file).new(
-            :path => exe,
-            :mode => 755
-        )
+        :returns => 0
+      )
+    }
+    assert_events([:executed_command], command)
+    assert_equal(wd,command.output.chomp)
+  end
 
-        exec = Puppet::Type.type(:exec).new(
-            :command => oexe,
-            :path => ENV["PATH"],
-            :cwd => basedir
-        )
+  def test_refreshonly_functional
+    file = nil
+    cmd = nil
+    tmpfile = tempfile
+    @@tmpfiles.push tmpfile
+    trans = nil
 
-        cat = Puppet::Type.type(:exec).new(
-            :command => "cat %s %s" % [exe, oexe],
-            :path => ENV["PATH"]
-        )
+      file = Puppet::Type.type(:file).new(
 
-        catalog = mk_catalog(file, baseobj, ofile, exec, cat)
+        :path => tmpfile,
 
-        rels = nil
-        assert_nothing_raised do
-            rels = exec.autorequire
-        end
+        :content => "yay"
+    )
+    # Get the file in sync
+    assert_apply(file)
 
-        # Verify we get the script itself
-        assert(rels.detect { |r| r.source == file }, "Exec did not autorequire its command")
+    # Now make an exec
+    maker = tempfile
+    assert_nothing_raised {
 
-        # Verify we catch the cwd
-        assert(rels.detect { |r| r.source == baseobj }, "Exec did not autorequire its cwd")
+      cmd = Puppet::Type.type(:exec).new(
 
-        # Verify we don't require ourselves
-        assert(! rels.detect { |r| r.source == ofile }, "Exec incorrectly required mentioned file")
+        :command => "touch #{maker}",
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+        :subscribe => 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
+        :refreshonly => true
+      )
+    }
 
-    def test_ifonly
-        afile = tempfile()
-        bfile = tempfile()
-
-        exec = nil
-        assert_nothing_raised {
-            exec = Puppet::Type.type(:exec).new(
-                :command => "touch %s" % bfile,
-                :onlyif => "test -f %s" % afile,
-                :path => ENV['PATH']
-            )
-        }
+    assert(cmd, "did not make exec")
 
-        assert_events([], exec)
-        system("touch %s" % afile)
-        assert_events([:executed_command], exec)
-        assert_events([:executed_command], exec)
-        system("rm %s" % afile)
-        assert_events([], exec)
+    assert_nothing_raised do
+      assert(! cmd.check, "Check passed when refreshonly is set")
     end
 
-    def test_unless
-        afile = tempfile()
-        bfile = tempfile()
-
-        exec = nil
-        assert_nothing_raised {
-            exec = Puppet::Type.type(:exec).new(
-                :command => "touch %s" % bfile,
-                :unless => "test -f %s" % afile,
-                :path => ENV['PATH']
-            )
-        }
-        comp = mk_catalog(exec)
-
-        assert_events([:executed_command], comp)
-        assert_events([:executed_command], comp)
-        system("touch %s" % afile)
-        assert_events([], comp)
-        assert_events([], comp)
-        system("rm %s" % afile)
-        assert_events([:executed_command], comp)
-        assert_events([:executed_command], comp)
-    end
+    assert_events([], file, cmd)
+    assert(! FileTest.exists?(maker), "made file without refreshing")
 
-    if Puppet::Util::SUIDManager.uid == 0
-        # Verify that we can execute commands as a special user
-        def mknverify(file, user, group = nil, id = true)
-            File.umask(0022)
-
-            args = {
-                :command => "touch %s" % file,
-                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-            }
-
-            if user
-                #Puppet.warning "Using user %s" % 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 %s" % 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")
-            if user
-                assert_equal(user.uid, File.stat(file).uid, "File UIDs do not match")
-            end
-
-            # We can't actually test group ownership, unfortunately, because
-            # behaviour changes wildlly based on platform.
-            Puppet::Type.allclear
-        end
+    # 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_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_refreshonly
+    cmd = true
+    assert_nothing_raised {
 
-    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
-            )
-        }
+      cmd = Puppet::Type.type(:exec).new(
 
-        assert_apply(exec)
+        :command => "pwd",
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
-        assert_nothing_raised {
-            exec[:command] = "echo logoutput is true"
-            exec[:logoutput] = true
-        }
+        :refreshonly => true
+      )
+    }
 
-        assert_apply(exec)
+    # Checks should always fail when refreshonly is enabled
+    assert(!cmd.check, "Check passed with refreshonly true")
 
-        assert_nothing_raised {
-            exec[:command] = "echo logoutput is on_failure"
-            exec[:logoutput] = "on_failure"
-        }
+    # Now make sure it passes if we pass in "true"
+    assert(cmd.check(true), "Check failed with refreshonly true while refreshing")
 
-        assert_apply(exec)
-    end
+    # Now set it to false
+    cmd[:refreshonly] = false
+    assert(cmd.check, "Check failed with refreshonly false")
+  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 %s; touch %s" % [basedir, path]
-
-            )
-        }
+  def test_creates
+    file = tempfile
+    exec = nil
+    assert(! FileTest.exists?(file), "File already exists")
+    assert_nothing_raised {
 
-        assert_nothing_raised {
-            file = Puppet::Type.type(:file).new(
-                :path => basedir,
-                :recurse => true,
-                :mode => "755",
-                :require => Puppet::Resource::Reference.new("exec", "mkdir")
-            )
-        }
+      exec = Puppet::Type.type(:exec).new(
+
+        :command => "touch #{file}",
+        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
 
-        comp = mk_catalog(file, exec)
-        comp.finalize
-        assert_events([:executed_command, :file_changed], comp)
+        :creates => file
+      )
+    }
 
-        assert(FileTest.exists?(path), "Exec ran first")
-        assert(File.stat(path).mode & 007777 == 0755)
+    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
 
-    # 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
+    # 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")
 
-        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 '%s' did not fail on false" % check) do
-                exec[check] = false
-            end
+    # 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_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}"
-            )
-        }
+    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
 
-        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
-            )
-        }
+  def test_logoutput
+    exec = nil
+    assert_nothing_raised {
 
-        # 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
+      exec = Puppet::Type.type(:exec).new(
 
-        assert_raise(Puppet::Error) do
-            exec2.property(:returns).sync
-        end
+        :title => "logoutputesting",
+        :path => "/usr/bin:/bin",
+        :command => "echo logoutput is false",
 
-        assert_nothing_raised do
-            exec2[:require] = exec1
-        end
+        :logoutput => false
+      )
+    }
+
+    assert_apply(exec)
+
+    assert_nothing_raised {
+      exec[:command] = "echo logoutput is true"
+      exec[:logoutput] = true
+    }
+
+    assert_apply(exec)
 
-        assert_apply(exec1, exec2)
+    assert_nothing_raised {
+      exec[:command] = "echo logoutput is on_failure"
+      exec[:logoutput] = "on_failure"
+    }
 
-        assert(FileTest.exists?(file))
+    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
 
-    def test_checkarrays
-        exec = nil
-        file = tempfile()
+    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
 
-        test = "test -f #{file}"
+  def test_createcwdandexe
+    exec1 = exec2 = nil
+    dir = tempfile
+    file = tempfile
 
-        assert_nothing_raised {
-            exec = Puppet::Type.type(:exec).new(
-                :path => ENV["PATH"],
-                :command => "touch #{file}"
-            )
-        }
+    assert_nothing_raised {
 
-        assert_nothing_raised {
-            exec[:unless] = test
-        }
+      exec1 = Puppet::Type.type(:exec).new(
 
-        assert_nothing_raised {
-            assert(exec.check, "Check did not pass")
-        }
+        :title => "one",
+        :path => ENV["PATH"],
 
-        assert_nothing_raised {
-            exec[:unless] = [test, test]
-        }
+        :command => "mkdir #{dir}"
+      )
+    }
 
+    assert_nothing_raised("Could not create exec w/out existing cwd") {
 
-        assert_nothing_raised {
-            exec.finish
-        }
+      exec2 = Puppet::Type.type(:exec).new(
 
-        assert_nothing_raised {
-            assert(exec.check, "Check did not pass")
-        }
+        :title => "two",
+        :path => ENV["PATH"],
+        :command => "touch #{file}",
 
-        assert_apply(exec)
+        :cwd => dir
+      )
+    }
 
-        assert_nothing_raised {
-            assert(! exec.check, "Check passed")
-        }
+    # 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
 
-    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(Puppet::Error) do
+      exec2.property(:returns).sync
+    end
 
-        assert_raise(ArgumentError, "Missing command did not raise error") {
-            exec.run("/bin/nosuchthingexists")
-        }
+    assert_nothing_raised do
+      exec2[:require] = exec1
     end
 
-    def test_envparam
-        exec = Puppet::Type.newexec(
-            :command => "echo $envtest",
-            :path => ENV["PATH"],
-            :env => "envtest=yayness"
-        )
+    assert_apply(exec1, exec2)
 
-        assert(exec, "Could not make exec")
+    assert(FileTest.exists?(file))
+  end
 
-        output = status = nil
-        assert_nothing_raised {
-            output, status = exec.run("echo $envtest")
-        }
+  def test_checkarrays
+    exec = nil
+    file = tempfile
 
-        assert_equal("yayness\n", output)
+    test = "test -f #{file}"
 
-        # Now check whether we can do multiline settings
-        assert_nothing_raised do
-            exec[:env] = "envtest=a list of things
-and stuff"
-        end
+    assert_nothing_raised {
 
-        output = status = nil
-        assert_nothing_raised {
-            output, status = exec.run('echo "$envtest"')
-        }
-        assert_equal("a list of things\nand stuff\n", output)
+      exec = Puppet::Type.type(:exec).new(
 
-        # Now test arrays
-        assert_nothing_raised do
-            exec[:env] = ["funtest=A", "yaytest=B"]
-        end
+        :path => ENV["PATH"],
 
-        output = status = nil
-        assert_nothing_raised {
-            output, status = exec.run('echo "$funtest" "$yaytest"')
-        }
-        assert_equal("A B\n", output)
-    end
+        :command => "touch #{file}"
+      )
+    }
 
-    def test_environmentparam
-        exec = Puppet::Type.newexec(
-            :command => "echo $environmenttest",
-            :path => ENV["PATH"],
-            :environment => "environmenttest=yayness"
-        )
+    assert_nothing_raised {
+      exec[:unless] = test
+    }
 
-        assert(exec, "Could not make exec")
+    assert_nothing_raised {
+      assert(exec.check, "Check did not pass")
+    }
 
-        output = status = nil
-        assert_nothing_raised {
-            output, status = exec.run("echo $environmenttest")
-        }
+    assert_nothing_raised {
+      exec[:unless] = [test, test]
+    }
 
-        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
+    assert_nothing_raised {
+      exec.finish
+    }
 
-        output = status = nil
-        assert_nothing_raised {
-            output, status = exec.run('echo "$environmenttest"')
-        }
-        assert_equal("a list of things\nand stuff\n", output)
+    assert_nothing_raised {
+      assert(exec.check, "Check did not pass")
+    }
 
-        # Now test arrays
-        assert_nothing_raised do
-            exec[:environment] = ["funtest=A", "yaytest=B"]
-        end
+    assert_apply(exec)
 
-        output = status = nil
-        assert_nothing_raised {
-            output, status = exec.run('echo "$funtest" "$yaytest"')
-        }
-        assert_equal("A B\n", output)
-    end
+    assert_nothing_raised {
+      assert(! exec.check, "Check passed")
+    }
+  end
 
-    def test_timeout
-        exec = Puppet::Type.type(:exec).new(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
-        time = Time.now
+  def test_missing_checks_cause_failures
+    # Solaris's sh exits with 1 here instead of 127
+    return if Facter.value(:operatingsystem) == "Solaris"
 
-        assert_raise(Timeout::Error) {
-            exec.run("sleep 1")
-        }
-        Puppet.info "%s seconds, vs a timeout of %s" % [Time.now.to_f - time.to_f, exec[:timeout]]
+      exec = Puppet::Type.type(:exec).new(
 
+        :command => "echo true",
+        :path => ENV["PATH"],
 
-        assert_apply(exec)
-    end
+        :onlyif => "/bin/nosuchthingexists"
+          )
 
-    # 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
+    assert_raise(ArgumentError, "Missing command did not raise error") {
+      exec.run("/bin/nosuchthingexists")
+    }
+  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
+  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
 
-    # 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")
+    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
 
-    def test_checks_apply_to_refresh
-        file = tempfile()
-        maker = tempfile()
+    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(
-            :title => "maker",
-            :command => "touch #{maker}",
-            :path => ENV["PATH"]
+
+          :command => "/bin/echo yay",
+
+          :user => user
         )
+      end
+    end
 
-        # Make sure it runs normally
-        assert_apply(exec)
-        assert(FileTest.exists?(maker), "exec did not run")
-        File.unlink(maker)
+    # Now try the group
+    group = "nosuchgroup"
+    assert_nothing_raised("Could not create exec with non-existent user") do
 
-        # 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)
+      exec = Puppet::Type.type(:exec).new(
 
-        # Now add the checks
-        exec[:creates] = file
+        :command => "/bin/echo yay",
 
-        # 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)
+        :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
 
-        # 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")
+  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)
 
-    def test_explicit_refresh
-        refresher = tempfile()
-        maker = tempfile()
-        exec = Puppet::Type.type(:exec).new(
-            :title => "maker",
-            :command => "touch #{maker}",
-            :path => ENV["PATH"]
-        )
+    # Now add the checks
+    exec[:creates] = file
 
-        # Call refresh normally
-        assert_nothing_raised do
-            exec.refresh
-        end
+    # 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
 
-        # Make sure it created the normal file
-        assert(FileTest.exists?(maker), "normal refresh did not work")
-        File.unlink(maker)
+  def test_explicit_refresh
+    refresher = tempfile
+    maker = tempfile
 
-        # 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
+      exec = Puppet::Type.type(:exec).new(
 
-        # Make sure it created the normal file
-        assert(FileTest.exists?(refresher), "refresh param was ignored")
-        assert(! FileTest.exists?(maker), "refresh param also ran command")
+        :title => "maker",
+        :command => "touch #{maker}",
+
+        :path => ENV["PATH"]
+    )
+
+    # Call refresh normally
+    assert_nothing_raised do
+      exec.refresh
     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")
+    # Make sure it created the normal file
+    assert(FileTest.exists?(maker), "normal refresh did not work")
+    File.unlink(maker)
 
-            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
+    # 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