puppet 0.16.0 → 0.18.4

data/test/types/file.rb

@@ -489,36 +489,39 @@ class TestFile < Test::Unit::TestCase
         FileUtils.mkdir_p(subdir)
 
         dir = nil
-        assert_nothing_raised {
-            dir = Puppet.type(:file).create(
-                :path => basedir,
-                :recurse => true,
-                :check => %w{owner mode group}
-            )
-        }
-
-        assert_nothing_raised {
-            dir.evaluate
-        }
+        [true, "true", "inf", 50].each do |value|
+            assert_nothing_raised {
+                dir = Puppet.type(:file).create(
+                    :path => basedir,
+                    :recurse => value,
+                    :check => %w{owner mode group}
+                )
+            }
 
-        subobj = nil
-        assert_nothing_raised {
-            subobj = Puppet.type(:file)[subdir]
-        }
+            assert_nothing_raised {
+                dir.evaluate
+            }
 
-        assert(subobj, "Could not retrieve %s object" % subdir)
+            subobj = nil
+            assert_nothing_raised {
+                subobj = Puppet.type(:file)[subdir]
+            }
 
-        File.open(tmpfile, "w") { |f| f.puts "yayness" }
+            assert(subobj, "Could not retrieve %s object" % subdir)
 
-        dir.evaluate
+            File.open(tmpfile, "w") { |f| f.puts "yayness" }
 
-        file = nil
-        assert_nothing_raised {
-            file = Puppet.type(:file)[tmpfile]
-        }
+            dir.evaluate
 
-        assert(file, "Could not retrieve %s object" % tmpfile)
+            file = nil
+            assert_nothing_raised {
+                file = Puppet.type(:file)[tmpfile]
+            }
 
+            assert(file, "Could not retrieve %s object" % tmpfile)
+            #system("rm -rf %s" % basedir)
+            Puppet.type(:file).clear
+        end
     end
 
 =begin
@@ -1077,6 +1080,235 @@ class TestFile < Test::Unit::TestCase
         assert(FileTest.symlink?(link), "Did not make link")
         assert_equal(File.join(source, "file"), File.readlink(link))
     end
+
+    def test_backupmodes
+        file = tempfile()
+        newfile = tempfile()
+
+        File.open(file, "w", 0411) { |f| f.puts "yayness" }
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Type.type(:file).create(
+                :path => file, :content => "rahness\n"
+            )
+        }
+
+#        user = group = nil
+#        if Process.uid == 0
+#            user = nonrootuser
+#            group = nonrootgroup
+#            obj[:owner] = user.name
+#            obj[:group] = group.name
+#            File.chown(user.uid, group.gid, file)
+#        end
+
+        assert_apply(obj)
+
+        backupfile = file + obj[:backup]
+        @@tmpfiles << backupfile
+        assert(FileTest.exists?(backupfile),
+            "Backup file %s does not exist" % backupfile)
+
+        assert_equal(0411, filemode(backupfile),
+            "File mode is wrong for backupfile")
+
+#        if Process.uid == 0
+#            assert_equal(user.uid, File.stat(backupfile).uid)
+#            assert_equal(group.gid, File.stat(backupfile).gid)
+#        end
+
+        bucket = "bucket"
+        bpath = tempfile()
+        Dir.mkdir(bpath)
+        Puppet::Type.type(:filebucket).create(
+            :name => bucket, :path => bpath
+        )
+
+        obj[:backup] = bucket
+        obj[:content] = "New content"
+        assert_apply(obj)
+
+        bucketedpath = File.join(bpath, "18cc17fa3047fcc691fdf49c0a7f539a", "contents")
+
+        assert_equal(0440, filemode(bucketedpath))
+    end
+
+    def test_largefilechanges
+        source = tempfile()
+        dest = tempfile()
+
+        # Now make a large file
+        File.open(source, "w") { |f|
+            500.times { |i| f.puts "line %s" % i }
+        }
+
+        obj = Puppet::Type.type(:file).create(
+            :name => dest, :source => source
+        )
+
+        assert_events([:file_created], obj)
+
+        File.open(source, File::APPEND|File::WRONLY) { |f| f.puts "another line" }
+
+        assert_events([:file_changed], obj)
+
+        # Now modify the dest file
+        File.open(dest, File::APPEND|File::WRONLY) { |f| f.puts "one more line" }
+
+        assert_events([:file_changed, :file_changed], obj)
+
+    end
+
+    def test_replacefilewithlink
+        path = tempfile()
+        link = tempfile()
+
+        File.open(path, "w") { |f| f.puts "yay" }
+        File.open(link, "w") { |f| f.puts "a file" }
+
+        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")
+    end
+
+    def test_replacedirwithlink
+        path = tempfile()
+        link = tempfile()
+
+        File.open(path, "w") { |f| f.puts "yay" }
+        Dir.mkdir(link)
+        File.open(File.join(link, "yay"), "w") do |f| f.puts "boo" end
+
+        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")
+    end
+
+    def test_replace_links_with_files
+        base = tempfile()
+
+        Dir.mkdir(base)
+
+        file = File.join(base, "file")
+        link = File.join(base, "link")
+        File.open(file, "w") { |f| f.puts "yayness" }
+        File.symlink(file, link)
+
+        obj = Puppet::Type.type(:file).create(
+            :path => link,
+            :ensure => "file"
+        )
+
+        assert_apply(obj)
+
+        assert_equal("yayness\n", File.read(file),
+            "Original file got changed")
+        assert_equal("file", File.lstat(link).ftype, "File is still a link")
+    end
+
+    def test_no_erase_linkedto_files
+        base = tempfile()
+
+        Dir.mkdir(base)
+
+        dirs = {}
+        %w{other source target}.each do |d|
+            dirs[d] = File.join(base, d)
+            Dir.mkdir(dirs[d])
+        end
+
+        file = File.join(dirs["other"], "file")
+        sourcefile = File.join(dirs["source"], "sourcefile")
+        link = File.join(dirs["target"], "link")
+
+        File.open(file, "w") { |f| f.puts "other" }
+        File.open(sourcefile, "w") { |f| f.puts "source" }
+        File.symlink(file, link)
+
+        obj = Puppet::Type.type(:file).create(
+            :path => dirs["target"],
+            :ensure => "file",
+            :source => dirs["source"],
+            :recurse => true
+        )
+
+
+        trans = assert_events([:file_created, :file_created], obj)
+
+        newfile = File.join(dirs["target"], "sourcefile")
+
+        assert(File.exists?(newfile), "File did not get copied")
+
+        assert_equal(File.read(sourcefile), File.read(newfile),
+            "File did not get copied correctly.")
+
+        assert_equal("other\n", File.read(file),
+            "Original file got changed")
+        assert_equal("file", File.lstat(link).ftype, "File is still a link")
+    end
+
+    def test_replace_links
+        dest = tempfile()
+        otherdest = tempfile()
+        link = tempfile()
+
+        File.open(dest, "w") { |f| f.puts "boo" }
+        File.open(otherdest, "w") { |f| f.puts "yay" }
+
+        obj = Puppet::Type.type(:file).create(
+            :path => link,
+            :ensure => otherdest
+        )
+
+
+        assert_apply(obj)
+
+        assert_equal(otherdest, File.readlink(link), "Link did not get created")
+
+        obj[:ensure] = dest
+
+        assert_apply(obj)
+
+        assert_equal(dest, File.readlink(link), "Link did not get changed")
+    end
+
+    def test_file_with_spaces
+        dir = tempfile()
+        Dir.mkdir(dir)
+        source = File.join(dir, "file spaces")
+        dest = File.join(dir, "another space")
+
+        File.open(source, "w") { |f| f.puts :yay }
+        obj = Puppet::Type.type(:file).create(
+            :path => dest,
+            :source => source
+        )
+
+        assert_apply(obj)
+
+        assert(FileTest.exists?(dest), "File did not get created")
+    end
 end
 
-# $Id: file.rb 1001 2006-03-10 21:46:00Z luke $
+# $Id: file.rb 1307 2006-06-20 18:46:58Z luke $

data/test/types/filebucket.rb

@@ -9,7 +9,7 @@ require 'test/unit'
 require 'fileutils'
 require 'puppettest'
 
-# $Id: filebucket.rb 1012 2006-03-12 02:56:23Z luke $
+# $Id: filebucket.rb 1143 2006-04-27 16:59:10Z luke $
 
 class TestFileBucket < Test::Unit::TestCase
 	include FileTesting
@@ -68,7 +68,8 @@ class TestFileBucket < Test::Unit::TestCase
 
     def test_simplebucket
         name = "yayness"
-        mkbucket(name, tempfile())
+        bucketpath = tempfile()
+        mkbucket(name, bucketpath)
 
         bucket = nil
         assert_nothing_raised {
@@ -87,6 +88,9 @@ class TestFileBucket < Test::Unit::TestCase
 
         assert(md5)
 
+        assert(FileTest.directory?(File.join(bucketpath, md5)),
+            "MD5 directory does not exist")
+
         newmd5 = nil
 
         # Just in case the file isn't writable

data/test/types/filesources.rb

@@ -85,7 +85,7 @@ class TestFileSources < Test::Unit::TestCase
 
         assert_apply(tofile)
 
-        assert(FileTest.exists?(topath))
+        assert(FileTest.exists?(topath), "File #{topath} is missing")
         from = File.open(frompath) { |o| o.read }
         to = File.open(topath) { |o| o.read }
         assert_equal(from,to)
@@ -195,7 +195,7 @@ class TestFileSources < Test::Unit::TestCase
         fromtree = file_list(fromdir)
         totree = file_list(todir)
 
-        assert(fromtree != totree)
+        assert(fromtree != totree, "Trees are incorrectly equal")
 
         # then remove our new files
         FileUtils.cd(todir) {
@@ -263,91 +263,6 @@ class TestFileSources < Test::Unit::TestCase
         return file
     end
 
-    # test raw xmlrpc calls
-    # this test is disabled because it requires way too much setup to get
-    # the certificates correct
-    def disabled_test_SimpleNetworkSources
-        server = nil
-        basedir = tempfile()
-        @@tmpfiles << basedir
-
-        mounts = {
-            "/" => "root"
-        }
-
-        fileserverconf = mkfileserverconf(mounts)
-
-        if File.exists?(basedir)
-            system("rm -rf %s" % basedir)
-        end
-        Dir.mkdir(basedir)
-
-        Puppet[:confdir] = basedir
-        Puppet[:vardir] = basedir
-        Puppet[:autosign] = true
-
-        tmpname = "yaytesting"
-        tmpfile = File.join(basedir, tmpname)
-        File.open(tmpfile, "w") { |f| f.print rand(100) }
-
-        port = 8765
-        serverpid = nil
-        assert_nothing_raised() {
-            server = Puppet::Server.new(
-                :Port => port,
-                :Handlers => {
-                    :CA => {}, # so that certs autogenerate
-                    :FileServer => {
-                        :Config => fileserverconf
-                    }
-                }
-            )
-
-        }
-        serverpid = fork {
-            assert_nothing_raised() {
-                #trap(:INT) { server.shutdown; Kernel.exit! }
-                trap(:INT) { server.shutdown }
-                server.start
-            }
-        }
-        @@tmppids << serverpid
-
-        client = nil
-        assert_nothing_raised() {
-            client = XMLRPC::Client.new("localhost", "/RPC2", port, nil, nil,
-                nil, nil, true, 3)
-        }
-        retval = nil
-
-        sleep(1)
-
-        list = nil
-        rpath = "/root%s" % tmpfile
-        assert_nothing_raised {
-            list = client.call("fileserver.list", rpath, :skip, false, false)
-        }
-
-        assert_equal("/\tfile", list)
-
-        assert_nothing_raised {
-            list = client.call("fileserver.describe", rpath, :skip)
-        }
-
-        assert_match(/^\d+\tfile\t\d+\t\d+\t.+$/, list)
-
-        assert_nothing_raised {
-            list = client.call("fileserver.retrieve", rpath, :skip)
-        }
-
-        contents = File.read(tmpfile)
-        assert_equal(contents, CGI.unescape(list))
-
-        assert_nothing_raised {
-            system("kill -INT %s" % serverpid)
-        }
-    end
-
     def test_NetworkSources
         server = nil
         basedir = tempfile()
@@ -626,16 +541,50 @@ class TestFileSources < Test::Unit::TestCase
         assert(FileTest.file?(dest), "Destination is not a file")
 
         # Now copy the links
-        assert_raise(Puppet::FileServerError) {
+        #assert_raise(Puppet::FileServerError) {
+        trans = nil
+        assert_nothing_raised {
             file[:links] = :manage
             comp = newcomp(file)
             trans = comp.evaluate
             trans.evaluate
         }
-        #assert(FileTest.symlink?(dest), "Destination is not a symlink")
-        #assert_equal(File.readlink(link), File.readlink(dest),
-        #    "Link did not copy correctly")
+
+        assert(trans.failed?(file), "Object did not fail to copy links")
+    end
+
+    def test_changes
+        source = tempfile()
+        dest = tempfile()
+
+        File.open(source, "w") { |f| f.puts "yay" }
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet.type(:file).create(
+                :name => dest,
+                :source => source
+            )
+        }
+
+        assert_events([:file_created], obj)
+        assert_equal(File.read(source), File.read(dest), "Files are not equal")
+        assert_events([], obj)
+
+        File.open(source, "w") { |f| f.puts "boo" }
+
+        assert_events([:file_changed], obj)
+        assert_equal(File.read(source), File.read(dest), "Files are not equal")
+        assert_events([], obj)
+
+        File.open(dest, "w") { |f| f.puts "kaboom" }
+
+        # There are two changes, because first the checksum is noticed, and
+        # then the source causes a change
+        assert_events([:file_changed, :file_changed], obj)
+        assert_equal(File.read(source), File.read(dest), "Files are not equal")
+        assert_events([], obj)
     end
 end
 
-# $Id: filesources.rb 984 2006-03-06 18:07:41Z luke $
+# $Id: filesources.rb 1330 2006-06-28 19:47:36Z luke $