puppet 0.9.2 → 0.13.0

data/test/types/file.rb

@@ -17,7 +17,7 @@ class TestFile < Test::Unit::TestCase
     def mkfile(hash)
         file = nil
         assert_nothing_raised {
-            file = Puppet::Type::PFile.create(hash)
+            file = Puppet.type(:file).create(hash)
         }
         return file
     end
@@ -36,13 +36,14 @@ class TestFile < Test::Unit::TestCase
         begin
             initstorage
         rescue
-            system("rm -rf %s" % Puppet[:checksumfile])
+            system("rm -rf %s" % Puppet[:statefile])
         end
     end
 
     def teardown
         clearstorage
         Puppet::Storage.clear
+        system("rm -rf %s" % Puppet[:statefile])
         super
     end
 
@@ -88,19 +89,14 @@ class TestFile < Test::Unit::TestCase
         us = {}
         us[uid] = name
         users.each { |uid, name|
-            # just make sure we don't try to manage users
-            assert_nothing_raised() {
-                file.sync
-            }
+            assert_apply(file)
             assert_nothing_raised() {
                 file[:owner] = name
             }
             assert_nothing_raised() {
                 file.retrieve
             }
-            assert_nothing_raised() {
-                file.sync
-            }
+            assert_apply(file)
         }
     end
 
@@ -125,17 +121,17 @@ class TestFile < Test::Unit::TestCase
 
             file = nil
             assert_nothing_raised {
-                file = Puppet::Type::PFile.create(
+                file = Puppet.type(:file).create(
                     :path => path,
                     :owner => user.name,
-                    :create => true,
+                    :ensure => "file",
                     :mode => "755"
                 )
             }
 
             comp = newcomp("createusertest", file)
 
-            assert_events(comp, [:file_created])
+            assert_events([:file_created], comp)
         end
 
         def test_ownerasroot
@@ -151,6 +147,7 @@ class TestFile < Test::Unit::TestCase
                 else
                     count += 1
                 end
+                next if passwd.uid < 0
                 users[passwd.uid] = passwd.name
             }
 
@@ -175,19 +172,14 @@ class TestFile < Test::Unit::TestCase
                     changes << file.evaluate
                 }
                 assert(changes.length > 0)
-                assert_nothing_raised() {
-                    file.sync
-                }
-                assert_nothing_raised() {
-                    file.evaluate
-                }
+                assert_apply(file)
+                file.retrieve
                 assert(file.insync?())
                 assert_nothing_raised() {
                     file[:owner] = uid
                 }
-                assert_nothing_raised() {
-                    file.evaluate
-                }
+                assert_apply(file)
+                file.retrieve
                 # make sure changing to number doesn't cause a sync
                 assert(file.insync?())
             }
@@ -211,15 +203,8 @@ class TestFile < Test::Unit::TestCase
                 }
                 assert(file.state(:group))
                 assert(file.state(:group).should)
-                assert_nothing_raised() {
-                    file.evaluate
-                }
-                assert_nothing_raised() {
-                    file.sync
-                }
-                assert_nothing_raised() {
-                    file.evaluate
-                }
+                assert_apply(file)
+                file.retrieve
                 assert(file.insync?())
                 assert_nothing_raised() {
                     file.delete(:group)
@@ -231,47 +216,37 @@ class TestFile < Test::Unit::TestCase
     end
 
     def test_create
-        %w{a b c d}.collect { |name| "/tmp/createst%s" % name }.each { |path|
+        %w{a b c d}.collect { |name| tempfile() + name.to_s }.each { |path|
             file =nil
             assert_nothing_raised() {
-                file = Puppet::Type::PFile.create(
+                file = Puppet.type(:file).create(
                     :name => path,
-                    :create => true
+                    :ensure => "file"
                 )
             }
-            assert_nothing_raised() {
-                file.evaluate
-            }
-            assert_nothing_raised() {
-                file.sync
-            }
-            assert_nothing_raised() {
-                file.evaluate
-            }
+            assert_events([:file_created], file)
+            assert_events([], file)
+            assert(FileTest.file?(path), "File does not exist")
             assert(file.insync?())
-            assert(FileTest.file?(path))
             @@tmpfiles.push path
         }
     end
 
     def test_create_dir
-        %w{a b c d}.collect { |name| "/tmp/createst%s" % name }.each { |path|
+        basedir = tempfile()
+        Dir.mkdir(basedir)
+        %w{a b c d}.collect { |name| "#{basedir}/%s" % name }.each { |path|
             file = nil
             assert_nothing_raised() {
-                file = Puppet::Type::PFile.create(
+                file = Puppet.type(:file).create(
                     :name => path,
-                    :create => "directory"
+                    :ensure => "directory"
                 )
             }
-            assert_nothing_raised() {
-                file.evaluate
-            }
-            assert_nothing_raised() {
-                file.sync
-            }
-            assert_nothing_raised() {
-                file.evaluate
-            }
+            assert(! FileTest.directory?(path), "Directory %s already exists" %
+                [path])
+            assert_events([:directory_created], file)
+            assert_events([], file)
             assert(file.insync?())
             assert(FileTest.directory?(path))
             @@tmpfiles.push path
@@ -280,20 +255,17 @@ class TestFile < Test::Unit::TestCase
 
     def test_modes
         file = mktestfile
+        # Set it to something else initially
+        File.chmod(0775, file.name)
         [0644,0755,0777,0641].each { |mode|
             assert_nothing_raised() {
                 file[:mode] = mode
             }
-            assert_nothing_raised() {
-                file.evaluate
-            }
-            assert_nothing_raised() {
-                file.sync
-            }
-            assert_nothing_raised() {
-                file.evaluate
-            }
+            assert_events([:file_changed], file)
+            assert_events([], file)
+
             assert(file.insync?())
+
             assert_nothing_raised() {
                 file.delete(:mode)
             }
@@ -311,34 +283,31 @@ class TestFile < Test::Unit::TestCase
         # try it both with files that exist and ones that don't
         files = [exists, nonexists]
         initstorage
-        File.open(exists,"w") { |of|
-            10.times { 
-                of.puts rand(100)
-            }
+        File.open(exists,File::CREAT|File::TRUNC|File::WRONLY) { |of|
+            of.puts "initial text"
         }
         types.each { |type|
             files.each { |path|
                 if Puppet[:debug]
-                    Puppet.info "Testing %s on %s" % [type,path]
+                    Puppet.warning "Testing %s on %s" % [type,path]
                 end
                 file = nil
                 events = nil
                 # okay, we now know that we have a file...
                 assert_nothing_raised() {
-                    file = Puppet::Type::PFile.create(
+                    file = Puppet.type(:file).create(
                         :name => path,
-                        :create => true,
+                        :ensure => "file",
                         :checksum => type
                     )
                 }
-                comp = Puppet::Type::Component.create(
-                    :name => "componentfile"
+                comp = Puppet.type(:component).create(
+                    :name => "checksum %s" % type
                 )
                 comp.push file
                 trans = nil
-                assert_nothing_raised() {
-                    trans = comp.evaluate
-                }
+
+                file.retrieve
 
                 if file.name !~ /nonexists/
                     sum = file.state(:checksum)
@@ -346,52 +315,67 @@ class TestFile < Test::Unit::TestCase
                     assert(sum.insync?)
                 end
 
+                events = assert_apply(comp)
+
+                assert(! events.include?(:file_changed),
+                    "File incorrectly changed")
+                assert_events([], comp)
+
+                # We have to sleep because the time resolution of the time-based
+                # mechanisms is greater than one second
+                sleep 1
+
                 assert_nothing_raised() {
-                    events = trans.evaluate.collect { |e| e.event }
-                }
-                # we don't want to kick off an event the first time we
-                # come across a file
-                assert(
-                    ! events.include?(:file_modified)
-                )
-                assert_nothing_raised() {
-                    File.open(path,"w") { |of|
-                        of.puts rand(100)
+                    File.open(path,File::CREAT|File::TRUNC|File::WRONLY) { |of|
+                        of.puts "some more text, yo"
                     }
                 }
-                Puppet::Type::PFile.clear
-                Puppet::Type::Component.clear
-                sleep 1
+                Puppet.type(:file).clear
+                Puppet.type(:component).clear
 
                 # now recreate the file
                 assert_nothing_raised() {
-                    file = Puppet::Type::PFile.create(
+                    file = Puppet.type(:file).create(
                         :name => path,
                         :checksum => type
                     )
                 }
-                comp = Puppet::Type::Component.create(
-                    :name => "componentfile"
+                comp = Puppet.type(:component).create(
+                    :name => "checksum, take 2, %s" % type
                 )
                 comp.push file
                 trans = nil
+
+                # If the file was missing, it should not generate an event
+                # when it gets created.
+                #if path =~ /nonexists/
+                #    assert_events([], comp)
+                #else
+                    assert_events([:file_changed], comp)
+                #end
                 assert_nothing_raised() {
-                    trans = comp.evaluate
-                }
-                assert_nothing_raised() {
-                    events = trans.evaluate.collect { |e| e.event }
+                    File.unlink(path)
+                    File.open(path,File::CREAT|File::TRUNC|File::WRONLY) { |of|
+                        # We have to put a certain amount of text in here or
+                        # the md5-lite test fails
+                        2.times {
+                            of.puts rand(100)
+                        }
+                        of.flush
+                    }
                 }
-
-                sum = file.state(:checksum)
+                #assert_apply(comp)
+                assert_events([:file_changed], comp)
 
                 # verify that we're actually getting notified when a file changes
-                assert(
-                    events.include?(:file_modified)
-                )
                 assert_nothing_raised() {
-                    Puppet::Type::PFile.clear
-                    Puppet::Type::Component.clear
+                    Puppet.type(:file).clear
+                    Puppet.type(:component).clear
                 }
+
+                if path =~ /nonexists/
+                    File.unlink(path)
+                end
             }
         }
     end
@@ -406,13 +390,13 @@ class TestFile < Test::Unit::TestCase
 
             initstorage
             assert_nothing_raised {
-                file = Puppet::Type::PFile.create(
+                file = Puppet.type(:file).create(
                     param => path,
                     :recurse => true,
                     :checksum => "md5"
                 )
             }
-            comp = Puppet::Type::Component.create(
+            comp = Puppet.type(:component).create(
                 :name => "component"
             )
             comp.push file
@@ -422,9 +406,6 @@ class TestFile < Test::Unit::TestCase
             assert_nothing_raised {
                 trans.evaluate
             }
-            #assert_nothing_raised {
-            #    file.sync
-            #}
             clearstorage
             Puppet::Type.allclear
         }
@@ -438,7 +419,7 @@ class TestFile < Test::Unit::TestCase
 
         dir = nil
         assert_nothing_raised {
-            dir = Puppet::Type::PFile.create(
+            dir = Puppet.type(:file).create(
                 :path => basedir,
                 :recurse => true,
                 :check => %w{owner mode group}
@@ -446,26 +427,26 @@ class TestFile < Test::Unit::TestCase
         }
 
         assert_nothing_raised {
-            dir.retrieve
+            dir.evaluate
         }
 
         subobj = nil
         assert_nothing_raised {
-            subobj = Puppet::Type::PFile[subdir]
+            subobj = Puppet.type(:file)[subdir]
         }
 
-        assert(subobj, "Could not retrieve subdir object")
+        assert(subobj, "Could not retrieve %s object" % subdir)
 
         File.open(tmpfile, "w") { |f| f.puts "yayness" }
 
-        dir.retrieve
+        dir.evaluate
 
         file = nil
         assert_nothing_raised {
-            file = Puppet::Type::PFile[tmpfile]
+            file = Puppet.type(:file)[tmpfile]
         }
 
-        assert(file, "Could not retrieve file object")
+        assert(file, "Could not retrieve %s object" % tmpfile)
 
     end
 
@@ -485,7 +466,7 @@ class TestFile < Test::Unit::TestCase
             file = mkfile(
                 :name => path,
                 :recurse => true,
-                :create => true
+                :ensure => "file"
             )
         }
 
@@ -506,8 +487,9 @@ class TestFile < Test::Unit::TestCase
     def test_filetype_retrieval
         file = nil
 
+        # Verify it retrieves files of type directory
         assert_nothing_raised {
-            file = Puppet::Type::PFile.create(
+            file = Puppet.type(:file).create(
                 :name => tmpdir(),
                 :check => :type
             )
@@ -519,28 +501,27 @@ class TestFile < Test::Unit::TestCase
 
         assert_equal("directory", file.state(:type).is)
 
+        # And then check files
         assert_nothing_raised {
-            file = Puppet::Type::PFile.create(
-                :name => "/etc/passwd",
-                :check => :type
+            file = Puppet.type(:file).create(
+                :name => tempfile(),
+                :ensure => "file"
             )
         }
 
-        assert_nothing_raised {
-            file.evaluate
-        }
+        assert_apply(file)
+        file[:check] = "type"
+        assert_apply(file)
 
         assert_equal("file", file.state(:type).is)
 
-        assert_raise(Puppet::Error) {
-            file[:type] = "directory"
-        }
+        file[:type] = "directory"
 
-        assert(file.insync?)
+        assert_nothing_raised { file.retrieve }
 
-        assert_raise(Puppet::Error) {
-            file.sync
-        }
+        # The 'retrieve' method sets @should to @is, so they're never
+        # out of sync.  It's a read-only class.
+        assert(file.insync?)
     end
 
     def test_remove
@@ -550,7 +531,7 @@ class TestFile < Test::Unit::TestCase
 
         dir = nil
         assert_nothing_raised {
-            dir = Puppet::Type::PFile.create(
+            dir = Puppet.type(:file).create(
                 :path => basedir,
                 :recurse => true,
                 :check => %w{owner mode group}
@@ -563,7 +544,7 @@ class TestFile < Test::Unit::TestCase
 
         obj = nil
         assert_nothing_raised {
-            obj = Puppet::Type::PFile[subdir]
+            obj = Puppet.type(:file)[subdir]
         }
 
         assert(obj, "Could not retrieve subdir object")
@@ -573,13 +554,13 @@ class TestFile < Test::Unit::TestCase
         }
 
         assert_nothing_raised {
-            obj = Puppet::Type::PFile[subdir]
+            obj = Puppet.type(:file)[subdir]
         }
 
         assert_nil(obj, "Retrieved removed object")
     end
 
-    def test_zpath
+    def test_path
         dir = tempfile()
 
         path = File.join(dir, "and", "a", "sub", "dir")
@@ -592,7 +573,7 @@ class TestFile < Test::Unit::TestCase
         file = nil
         dirobj = nil
         assert_nothing_raised("Could not make file object") {
-            dirobj = Puppet::Type::PFile.create(
+            dirobj = Puppet.type(:file).create(
                 :path => dir,
                 :recurse => true,
                 :check => %w{mode owner group}
@@ -600,7 +581,7 @@ class TestFile < Test::Unit::TestCase
         }
 
         assert_nothing_raised {
-            dirobj.retrieve
+            dirobj.evaluate
         }
 
         assert_nothing_raised {
@@ -611,6 +592,150 @@ class TestFile < Test::Unit::TestCase
 
         assert_equal("file=%s" % file.name, file.path)
     end
+
+    def test_autorequire
+        basedir = tempfile()
+        subfile = File.join(basedir, "subfile")
+
+        baseobj = Puppet.type(:file).create(
+            :name => basedir,
+            :ensure => "directory"
+        )
+
+        subobj = Puppet.type(:file).create(
+            :name => subfile,
+            :ensure => "file"
+        )
+
+        Puppet::Type.finalize
+        assert(subobj.requires?(baseobj), "File did not require basedir")
+        assert(!subobj.requires?(subobj), "File required itself")
+        comp = newcomp(subobj, baseobj)
+        assert_events([:directory_created, :file_created], comp)
+    end
+
+    def test_content
+        file = tempfile()
+        str = "This is some content"
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet.type(:file).create(
+                :name => file,
+                :content => str
+            )
+        }
+
+        assert(!obj.insync?, "Object is incorrectly in sync")
+
+        assert_events([:file_created], obj)
+
+        obj.retrieve
+
+        assert(obj.insync?, "Object is not in sync")
+
+        text = File.read(file)
+
+        assert_equal(str, text, "Content did not copy correctly")
+
+        newstr = "Another string, yo"
+
+        obj[:content] = newstr
+
+        assert(!obj.insync?, "Object is incorrectly in sync")
+
+        assert_events([:file_changed], obj)
+
+        text = File.read(file)
+
+        assert_equal(newstr, text, "Content did not copy correctly")
+
+        obj.retrieve
+        assert(obj.insync?, "Object is not in sync")
+    end
+
+    # Unfortunately, I know this fails
+    def disabled_test_recursivemkdir
+        path = tempfile()
+        subpath = File.join(path, "this", "is", "a", "dir")
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :name => subpath,
+                :ensure => "directory",
+                :recurse => true
+            )
+        }
+
+        comp = newcomp("yay", file)
+        Puppet::Type.finalize
+        assert_apply(comp)
+        #assert_events([:directory_created], comp)
+
+        assert(FileTest.directory?(subpath), "Did not create directory")
+    end
+
+    # Make sure that content updates the checksum on the same run
+    def test_checksumchange_for_content
+        dest = tempfile()
+        File.open(dest, "w") { |f| f.puts "yayness" }
+
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :name => dest,
+                :checksum => "md5",
+                :content => "This is some content"
+            )
+        }
+
+        file.retrieve
+
+        assert_events([:file_changed], file)
+        file.retrieve
+        assert_events([], file)
+    end
+
+    # Make sure that content updates the checksum on the same run
+    def test_checksumchange_for_ensure
+        dest = tempfile()
+
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :name => dest,
+                :checksum => "md5",
+                :ensure => "file"
+            )
+        }
+
+        file.retrieve
+
+        assert_events([:file_created], file)
+        file.retrieve
+        assert_events([], file)
+    end
+
+    # Make sure that content gets used before ensure
+    def test_contentbeatsensure
+        dest = tempfile()
+
+        file = nil
+        assert_nothing_raised {
+            file = Puppet.type(:file).create(
+                :name => dest,
+                :ensure => "file",
+                :content => "this is some content, yo"
+            )
+        }
+
+        file.retrieve
+
+        assert_events([:file_created], file)
+        file.retrieve
+        assert_events([], file)
+        assert_events([], file)
+    end
 end
 
-# $Id: file.rb 740 2005-11-01 20:22:19Z luke $
+# $Id: file.rb 884 2006-02-08 17:11:54Z luke $