puppet 0.13.6 → 0.16.0

data/test/types/basic.rb

@@ -41,7 +41,7 @@ class TestBasic < Test::Unit::TestCase
                 :type => "init",
                 :path => File.join($puppetbase,"examples/root/etc/init.d"),
                 :hasstatus => true,
-                :running => 1
+                :ensure => :running
             )
         }
         assert_nothing_raised() {
@@ -95,7 +95,7 @@ class TestBasic < Test::Unit::TestCase
             transaction.evaluate
         }
         assert_nothing_raised() {
-            @sleeper[:running] = 0
+            @sleeper[:ensure] = :running
         }
         assert_nothing_raised() {
             transaction = @component.evaluate
@@ -114,4 +114,4 @@ class TestBasic < Test::Unit::TestCase
     end
 end
 
-# $Id: basic.rb 873 2006-02-07 23:12:33Z luke $
+# $Id: basic.rb 1113 2006-04-17 16:15:33Z luke $

data/test/types/cron.rb

@@ -382,6 +382,29 @@ class TestCron < Test::Unit::TestCase
         }
         assert_equal(:absent, cron.is(:minute))
     end
+
+    def test_listing
+        @crontype.filetype = @oldfiletype
+
+        crons = []
+        assert_nothing_raised {
+            Puppet::Type.type(:cron).list.each do |cron|
+                crons << cron
+            end
+        }
+
+        crons.each do |cron|
+            assert(cron, "Did not receive a real cron object")
+            assert_instance_of(String, cron[:user],
+                "Cron user is not a string")
+        end
+    end
+
+    def verify_failonnouser
+        assert_raise(Puppet::Error) do
+            @crontype.retrieve("nosuchuser")
+        end
+    end
 end
 
-# $Id: cron.rb 910 2006-02-15 07:20:36Z luke $
+# $Id: cron.rb 1125 2006-04-20 19:38:48Z luke $

data/test/types/exec.rb

@@ -432,6 +432,104 @@ class TestExec < Test::Unit::TestCase
         assert(FileTest.exists?(path), "Exec ran first")
         assert(File.stat(path).mode & 007777 == 0755)
     end
+
+    def test_falsevals
+        exec = nil
+        assert_nothing_raised do
+            exec = Puppet.type(:exec).create(
+                :command => "/bin/touch yayness"
+            )
+        end
+
+        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
+                exec[check] = false
+            end
+        end
+    end
+
+    def test_createcwdandexe
+        exec1 = exec2 = nil
+        dir = tempfile()
+        file = tempfile()
+
+        assert_nothing_raised {
+            exec1 = Puppet.type(:exec).create(
+                :path => ENV["PATH"],
+                :command => "mkdir #{dir}"
+            )
+        }
+
+        assert_nothing_raised("Could not create exec w/out existing cwd") {
+            exec2 = Puppet.type(:exec).create(
+                :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.state(:returns).sync
+        end
+
+        assert_nothing_raised do
+            exec2[:require] = ["exec", exec1.name]
+            exec2.finish
+        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(:exec).create(
+                :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
 end
 
-# $Id: exec.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: exec.rb 1089 2006-04-05 23:38:33Z luke $

data/test/types/file.rb

@@ -41,7 +41,6 @@ class TestFile < Test::Unit::TestCase
     end
 
     def teardown
-        clearstorage
         Puppet::Storage.clear
         system("rm -rf %s" % Puppet[:statefile])
         super
@@ -134,6 +133,78 @@ class TestFile < Test::Unit::TestCase
             assert_events([:file_created], comp)
         end
 
+        def test_nofollowlinks
+            basedir = tempfile()
+            Dir.mkdir(basedir)
+            file = File.join(basedir, "file")
+            link = File.join(basedir, "link")
+
+            File.open(file, "w", 0644) { |f| f.puts "yayness"; f.flush }
+            File.symlink(file, link)
+
+            # First test 'user'
+            user = nonrootuser()
+
+            inituser = File.lstat(link).uid
+            File.lchown(inituser, nil, link)
+
+            obj = nil
+            assert_nothing_raised {
+                obj = Puppet.type(:file).create(
+                    :name => link,
+                    :owner => user.name
+                )
+            }
+            obj.retrieve
+
+            # Make sure it defaults to managing the link
+            assert_events([:file_changed], obj)
+            assert_equal(user.uid, File.lstat(link).uid)
+            assert_equal(inituser, File.stat(file).uid)
+            File.chown(inituser, nil, file)
+            File.lchown(inituser, nil, link)
+
+            # Try following
+            obj[:links] = :follow
+            assert_events([:file_changed], obj)
+            assert_equal(user.uid, File.stat(file).uid)
+            assert_equal(inituser, File.lstat(link).uid)
+
+            # And then explicitly managing
+            File.chown(inituser, nil, file)
+            File.lchown(inituser, nil, link)
+            obj[:links] = :manage
+            assert_events([:file_changed], obj)
+            assert_equal(user.uid, File.lstat(link).uid)
+            assert_equal(inituser, File.stat(file).uid)
+
+            obj.delete(:owner)
+            obj[:links] = :ignore
+
+            # And then test 'group'
+            group = nonrootgroup
+
+            initgroup = File.stat(file).gid
+            obj[:group] = group.name
+
+            assert_events([:file_changed], obj)
+            assert_equal(initgroup, File.stat(file).gid)
+            assert_equal(group.gid, File.lstat(link).gid)
+            File.chown(nil, initgroup, file)
+            File.lchown(nil, initgroup, link)
+
+            obj[:links] = :follow
+            assert_events([:file_changed], obj)
+            assert_equal(group.gid, File.stat(file).gid)
+            File.chown(nil, initgroup, file)
+            File.lchown(nil, initgroup, link)
+
+            obj[:links] = :manage
+            assert_events([:file_changed], obj)
+            assert_equal(group.gid, File.lstat(link).gid)
+            assert_equal(initgroup, File.stat(file).gid)
+        end
+
         def test_ownerasroot
             file = mktestfile()
 
@@ -781,6 +852,231 @@ class TestFile < Test::Unit::TestCase
         assert_apply(file)
         assert_equal(0777, File.stat(path).mode & 007777)
     end
+
+    def test_followlinks
+        basedir = tempfile()
+        Dir.mkdir(basedir)
+        file = File.join(basedir, "file")
+        link = File.join(basedir, "link")
+
+        File.open(file, "w", 0644) { |f| f.puts "yayness"; f.flush }
+        File.symlink(file, link)
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet.type(:file).create(
+                :name => link,
+                :mode => "755"
+            )
+        }
+        obj.retrieve
+
+        assert_events([], obj)
+
+        # Assert that we default to not following links
+        assert_equal("%o" % 0644, "%o" % (File.stat(file).mode & 007777))
+
+        # Assert that we can manage the link directly, but modes still don't change
+        obj[:links] = :manage
+        assert_events([], obj)
+
+        assert_equal("%o" % 0644, "%o" % (File.stat(file).mode & 007777))
+
+        obj[:links] = :follow
+        assert_events([:file_changed], obj)
+
+        assert_equal("%o" % 0755, "%o" % (File.stat(file).mode & 007777))
+
+        # Now verify that content and checksum don't update, either
+        obj.delete(:mode)
+        obj[:checksum] = "md5"
+        obj[:links] = :ignore
+
+        assert_events([], obj)
+        File.open(file, "w") { |f| f.puts "more text" }
+        assert_events([], obj)
+        obj[:links] = :follow
+        assert_events([], obj)
+        File.open(file, "w") { |f| f.puts "even more text" }
+        assert_events([:file_changed], obj)
+
+        obj.delete(:checksum)
+        obj[:content] = "this is some content"
+        obj[:links] = :ignore
+
+        assert_events([], obj)
+        File.open(file, "w") { |f| f.puts "more text" }
+        assert_events([], obj)
+        obj[:links] = :follow
+        assert_events([:file_changed], obj)
+    end
+
+    # If both 'ensure' and 'content' are used, make sure that all of the other
+    # states are handled correctly.
+    def test_contentwithmode
+        path = tempfile()
+
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :path => path,
+                :ensure => "file",
+                :content => "some text\n",
+                :mode => 0755
+            )
+        }
+
+        assert_apply(file)
+        assert_equal("%o" % 0755, "%o" % (File.stat(path).mode & 007777))
+    end
+
+    # Make sure we can create symlinks
+    def test_symlinks
+        path = tempfile()
+        link = tempfile()
+
+        File.open(path, "w") { |f| f.puts "yay" }
+
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :ensure => path,
+                :path => link
+            )
+        }
+
+        assert_events([:link_created], file)
+
+        assert(FileTest.symlink?(link), "Link was not created")
+
+        assert_equal(path, File.readlink(link), "Link was created incorrectly")
+
+        # Make sure running it again works
+        assert_events([], file)
+    end
+
+    def test_simplerecursivelinking
+        source = tempfile()
+        dest = tempfile()
+        subdir = File.join(source, "subdir")
+        file = File.join(subdir, "file")
+
+        system("mkdir -p %s" % subdir)
+        system("touch %s" % file)
+
+        link = nil
+        assert_nothing_raised {
+            link = Puppet.type(:file).create(
+                :ensure => source,
+                :path => dest,
+                :recurse => true
+            )
+        }
+
+        assert_apply(link)
+
+        subdest = File.join(dest, "subdir")
+        linkpath = File.join(subdest, "file")
+        assert(File.directory?(dest), "dest is not a dir")
+        assert(File.directory?(subdest), "subdest is not a dir")
+        assert(File.symlink?(linkpath), "path is not a link")
+        assert_equal(file, File.readlink(linkpath))
+
+        assert_events([], link)
+    end
+
+    def test_recursivelinking
+        source = tempfile()
+        dest = tempfile()
+
+        files = []
+        dirs = []
+
+        # Make a bunch of files and dirs
+        Dir.mkdir(source)
+        Dir.chdir(source) do
+            system("mkdir -p %s" % "some/path/of/dirs")
+            system("mkdir -p %s" % "other/path/of/dirs")
+            system("touch %s" % "file")
+            system("touch %s" % "other/file")
+            system("touch %s" % "some/path/of/file")
+            system("touch %s" % "some/path/of/dirs/file")
+            system("touch %s" % "other/path/of/file")
+
+            files = %x{find . -type f}.chomp.split(/\n/)
+            dirs = %x{find . -type d}.chomp.split(/\n/).reject{|d| d =~ /^\.+$/ }
+        end
+
+        link = nil
+        assert_nothing_raised {
+            link = Puppet.type(:file).create(
+                :ensure => source,
+                :path => dest,
+                :recurse => true
+            )
+        }
+
+        assert_apply(link)
+
+        files.each do |f|
+            f.sub!(/^\.#{File::SEPARATOR}/, '')
+            path = File.join(dest, f)
+            assert(FileTest.exists?(path), "Link %s was not created" % path)
+            assert(FileTest.symlink?(path), "%s is not a link" % f)
+            target = File.readlink(path)
+            assert_equal(File.join(source, f), target)
+        end
+
+        dirs.each do |d|
+            d.sub!(/^\.#{File::SEPARATOR}/, '')
+            path = File.join(dest, d)
+            assert(FileTest.exists?(path), "Dir %s was not created" % path)
+            assert(FileTest.directory?(path), "%s is not a directory" % d)
+        end
+    end
+
+    def test_localrelativelinks
+        dir = tempfile()
+        Dir.mkdir(dir)
+        source = File.join(dir, "source")
+        File.open(source, "w") { |f| f.puts "yay" }
+        dest = File.join(dir, "link")
+
+        link = nil
+        assert_nothing_raised {
+            link = Puppet.type(:file).create(
+                :path => dest,
+                :ensure => "source"
+            )
+        }
+
+        assert_events([:link_created], link)
+        assert(FileTest.symlink?(dest), "Did not create link")
+        assert_equal("source", File.readlink(dest))
+        assert_equal("yay\n", File.read(dest))
+    end
+
+    def test_recursivelinkingmissingtarget
+        source = tempfile()
+        dest = tempfile()
+
+        objects = []
+        objects << Puppet.type(:exec).create(
+            :command => "mkdir %s; touch %s/file" % [source, source],
+            :path => ENV["PATH"]
+        )
+        objects << Puppet.type(:file).create(
+            :ensure => source,
+            :path => dest,
+            :recurse => true
+        )
+
+        assert_apply(*objects)
+
+        link = File.join(dest, "file")
+        assert(FileTest.symlink?(link), "Did not make link")
+        assert_equal(File.join(source, "file"), File.readlink(link))
+    end
 end
 
-# $Id: file.rb 966 2006-03-02 17:12:26Z luke $
+# $Id: file.rb 1001 2006-03-10 21:46:00Z luke $