puppet 0.18.4 → 0.22.4

data/test/{types → ral/types}/exec.rb

@@ -1,16 +1,11 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
 require 'puppettest'
-require 'test/unit'
-require 'facter'
 
 class TestExec < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
     def test_execution
         command = nil
         output = nil
@@ -44,13 +39,11 @@ class TestExec < Test::Unit::TestCase
     def test_path_or_qualified
         command = nil
         output = nil
-        assert_nothing_raised {
+        assert_raise(Puppet::Error) {
             command = Puppet.type(:exec).create(
                 :command => "echo"
             )
-            assert_nil(command)
         }
-        Puppet.type(:exec).clear
         assert_nothing_raised {
             command = Puppet.type(:exec).create(
                 :command => "echo",
@@ -114,65 +107,64 @@ class TestExec < Test::Unit::TestCase
         assert_equal(wd,command.output.chomp)
     end
 
-    def test_refreshonly
+    def test_refreshonly_functional
         file = nil
         cmd = nil
         tmpfile = tempfile()
         @@tmpfiles.push tmpfile
         trans = nil
-        File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
-            of.puts rand(100)
-        }
         file = Puppet.type(:file).create(
             :path => tmpfile,
-            :checksum => "md5"
+            :content => "yay"
         )
-        assert_instance_of(Puppet.type(:file), file)
+        # Get the file in sync
+        assert_apply(file)
+
+        # Now make an exec
+        maker = tempfile()
         assert_nothing_raised {
             cmd = Puppet.type(:exec).create(
-                :command => "pwd",
+                :command => "touch %s" % maker,
                 :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-                :subscribe => [[file.class.name,file.name]],
+                :subscribe => file,
                 :refreshonly => true
             )
         }
 
-        assert_instance_of(Puppet.type(:exec), cmd)
+        assert(cmd, "did not make exec")
 
-        comp = Puppet.type(:component).create(:name => "RefreshTest")
-        [file,cmd].each { |obj|
-            comp.push obj
-        }
-        events = nil
-        assert_nothing_raised {
-            trans = comp.evaluate
-            file.retrieve
+        assert_nothing_raised do
+            assert(! cmd.check, "Check passed when refreshonly is set")
+        end
 
-            sum = file.state(:checksum)
-            assert_equal(sum.is, sum.should)
-            events = trans.evaluate.collect { |event|
-                event.event
-            }
-        }
-        # the first checksum shouldn't result in a changed file
-        assert_equal([],events)
-        File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
-            of.puts rand(100)
-            of.puts rand(100)
-            of.puts rand(100)
-        }
+        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([:file_changed, :triggered], file, cmd)
+        assert(FileTest.exists?(maker), "file was not made in refresh")
+    end
+
+    def test_refreshonly
+        cmd = true
         assert_nothing_raised {
-            trans = comp.evaluate
-            sum = file.state(:checksum)
-            events = trans.evaluate.collect { |event| event.event }
+            cmd = Puppet.type(:exec).create(
+                :command => "pwd",
+                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+                :refreshonly => true
+            )
         }
-        
-        # verify that only the file_changed event was kicked off, not the
-        # command_executed
-        assert_equal(
-            [:file_changed],
-            events
-        )
+
+        # 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
@@ -200,13 +192,13 @@ class TestExec < Test::Unit::TestCase
         File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
         file = Puppet.type(:file).create(
-            :name => oexe,
+            :path => oexe,
             :source => exe,
             :mode => 0755
         )
 
         exec = Puppet.type(:exec).create(
-            :name => oexe,
+            :command => oexe,
             :require => [:file, oexe]
         )
 
@@ -216,57 +208,62 @@ class TestExec < Test::Unit::TestCase
     end
 
     # Verify that we auto-require any managed scripts.
-    def test_autorequire
+    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(:file).create(
-            :name => oexe,
+            :path => oexe,
             :source => exe,
             :mode => 755
         )
 
         basedir = File.dirname(oexe)
         baseobj = Puppet.type(:file).create(
-            :name => basedir,
+            :path => basedir,
             :source => exe,
             :mode => 755
         )
 
         ofile = Puppet.type(:file).create(
-            :name => exe,
+            :path => exe,
             :mode => 755
         )
 
         exec = Puppet.type(:exec).create(
-            :name => oexe,
+            :command => oexe,
             :path => ENV["PATH"],
             :cwd => basedir
         )
 
         cat = Puppet.type(:exec).create(
-            :name => "cat %s %s" % [exe, oexe],
+            :command => "cat %s %s" % [exe, oexe],
             :path => ENV["PATH"]
         )
-
-        comp = newcomp(ofile, exec, cat, file, baseobj)
-        comp.finalize
+        
+        rels = nil
+        assert_nothing_raised do
+            rels = exec.autorequire
+        end
 
         # Verify we get the script itself
-        assert(exec.requires?(file), "Exec did not autorequire %s" % file)
+        assert(rels.detect { |r| r.source == file }, "Exec did not autorequire its command")
 
         # Verify we catch the cwd
-        assert(exec.requires?(baseobj), "Exec did not autorequire 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")
         assert(!exec.requires?(ofile), "Exec incorrectly required file")
 
-        # Verify that we catch inline files
         # We not longer autorequire inline files
-        assert(! cat.requires?(ofile), "Exec required second inline file")
-        assert(! cat.requires?(file), "Exec required inline file")
+        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
@@ -302,20 +299,23 @@ class TestExec < Test::Unit::TestCase
                 :path => ENV['PATH']
             )
         }
+        comp = newcomp(exec)
 
-        assert_events([:executed_command], exec)
-        assert_events([:executed_command], exec)
+        assert_events([:executed_command], comp)
+        assert_events([:executed_command], comp)
         system("touch %s" % afile)
-        assert_events([], exec)
-        assert_events([], exec)
+        assert_events([], comp)
+        assert_events([], comp)
         system("rm %s" % afile)
-        assert_events([:executed_command], exec)
-        assert_events([:executed_command], exec)
+        assert_events([:executed_command], comp)
+        assert_events([:executed_command], comp)
     end
 
-    if Process.uid == 0
+    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",
@@ -377,7 +377,7 @@ class TestExec < Test::Unit::TestCase
         exec = nil
         assert_nothing_raised {
             exec = Puppet.type(:exec).create(
-                :name => "logoutputesting",
+                :title => "logoutputesting",
                 :path => "/usr/bin:/bin",
                 :command => "echo logoutput is false",
                 :logoutput => false
@@ -408,7 +408,7 @@ class TestExec < Test::Unit::TestCase
         path = File.join(basedir, "subfile")
         assert_nothing_raised {
             exec = Puppet.type(:exec).create(
-                :name => "mkdir",
+                :title => "mkdir",
                 :path => "/usr/bin:/bin",
                 :creates => basedir,
                 :command => "mkdir %s; touch %s" % [basedir, path]
@@ -433,6 +433,7 @@ class TestExec < Test::Unit::TestCase
         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
@@ -444,7 +445,7 @@ class TestExec < Test::Unit::TestCase
         Puppet.type(:exec).checks.each do |check|
             klass = Puppet.type(:exec).paramclass(check)
             next if klass.values.include? :false
-            assert_raise(Puppet::Error, "Check %s did not fail on false" % check) do
+            assert_raise(Puppet::Error, "Check '%s' did not fail on false" % check) do
                 exec[check] = false
             end
         end
@@ -457,6 +458,7 @@ class TestExec < Test::Unit::TestCase
 
         assert_nothing_raised {
             exec1 = Puppet.type(:exec).create(
+                :title => "one",
                 :path => ENV["PATH"],
                 :command => "mkdir #{dir}"
             )
@@ -464,6 +466,7 @@ class TestExec < Test::Unit::TestCase
 
         assert_nothing_raised("Could not create exec w/out existing cwd") {
             exec2 = Puppet.type(:exec).create(
+                :title => "two",
                 :path => ENV["PATH"],
                 :command => "touch #{file}",
                 :cwd => dir
@@ -477,12 +480,11 @@ class TestExec < Test::Unit::TestCase
         end
 
         assert_raise(Puppet::Error) do
-            exec2.state(:returns).sync
+            exec2.property(:returns).sync
         end
 
         assert_nothing_raised do
-            exec2[:require] = ["exec", exec1.name]
-            exec2.finish
+            exec2[:require] = exec1
         end
 
         assert_apply(exec1, exec2)
@@ -530,6 +532,200 @@ class TestExec < Test::Unit::TestCase
             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).create(
+                                    :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_timeout
+        exec = Puppet::Type.type(:exec).create(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
+        time = Time.now
+        
+        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]]
+        
+        
+        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).create(
+                    :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).create(
+                :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).create(: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).create(: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).create(: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).create(
+            :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).create(
+            :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).create(:name => "yay")
+            exec = Puppet::Type.type(:exec).create(: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
 
-# $Id: exec.rb 1089 2006-04-05 23:38:33Z luke $
+# $Id: exec.rb 2442 2007-04-30 19:42:58Z luke $