Completely refactoring the tidy type.

This was necessary because of how I changed file recursion.

The type works much more intelligently now -- files to
be removed have a file resource generated for them, and that
resource handles deletion.

Also fixes #1717; neither age nor size is required now.

Signed-off-by: Luke Kanies <luke@madstop.com>

1 files changed, 0 insertions, 289 deletions

diff --git a/test/ral/type/tidy.rb b/test/ral/type/tidy.rb
deleted file mode 100755
index a3a3b4b01..000000000
--- a/test/ral/type/tidy.rb
+++ /dev/null
@@ -1,289 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/support/utils'
-
-class TestTidy < Test::Unit::TestCase
-    include PuppetTest::Support::Utils
-    include PuppetTest::FileTesting
-    def mktmpfile
-        # because luke's home directory is on nfs, it can't be used for testing
-        # as root
-        tmpfile = tempfile()
-        File.open(tmpfile, "w") { |f| f.puts rand(100) }
-        @@tmpfiles.push tmpfile
-        return tmpfile
-    end
-
-    def mktmpdir
-        dir = File.join(tmpdir(), "puppetlinkdir")
-        unless FileTest.exists?(dir)
-            Dir.mkdir(dir)
-        end
-        @@tmpfiles.push dir
-        return dir
-    end
-
-    def test_tidydirs
-        dir = mktmpdir
-        file = File.join(dir, "file")
-        File.open(file, "w") { |f|
-            f.puts "some stuff"
-        }
-
-        tidy = Puppet.type(:tidy).create(
-            :name => dir,
-            :size => "1b",
-            :rmdirs => true,
-            :recurse => true
-        )
-
-        assert_events([:file_tidied, :file_tidied], tidy)
-
-        assert(!FileTest.exists?(file), "Tidied %s still exists" % file)
-        assert(!FileTest.exists?(dir), "Tidied %s still exists" % dir)
-
-    end
-
-    def disabled_test_recursion
-        source = mktmpdir()
-        FileUtils.cd(source) {
-            mkranddirsandfiles()
-        }
-
-        link = nil
-        assert_nothing_raised {
-            link = newlink(:target => source, :recurse => true)
-        }
-        comp = mk_catalog("linktest",link)
-        cycle(comp)
-
-        path = link.name
-        list = file_list(path)
-        FileUtils.cd(path) {
-            list.each { |file|
-                unless FileTest.directory?(file)
-                    assert(FileTest.symlink?(file))
-                    target = File.readlink(file)
-                    assert_equal(target,File.join(source,file.sub(/^\.\//,'')))
-                end
-            }
-        }
-    end
-
-    # Test the different age iterations.
-    def test_age_conversions
-        tidy = Puppet::Type.type(:tidy).create :path => tempfile(), :age => "1m"
-
-        convertors = {
-            :second => 1,
-            :minute => 60
-        }
-
-        convertors[:hour] = convertors[:minute] * 60
-        convertors[:day] = convertors[:hour] * 24
-        convertors[:week] = convertors[:day] * 7
-
-        # First make sure we default to days
-        assert_nothing_raised do
-            tidy[:age] = "2"
-        end
-
-        assert_equal(2 * convertors[:day], tidy.should(:age),
-            "Converted 2 wrong")
-
-        convertors.each do |name, number|
-            init = name.to_s[0..0] # The first letter
-            [0, 1, 5].each do |multi|
-                [init, init.upcase].each do |letter|
-                    age = multi.to_s + letter.to_s
-                    assert_nothing_raised do
-                        tidy[:age] = age
-                    end
-
-                    assert_equal(multi * convertors[name], tidy.should(:age),
-                        "Converted %s wrong" % age)
-                end
-            end
-        end
-    end
-
-    def test_size_conversions
-        convertors = {
-            :b => 0,
-            :kb => 1,
-            :mb => 2,
-            :gb => 3
-        }
-
-        tidy = Puppet::Type.type(:tidy).create :path => tempfile(), :age => "1m"
-
-        # First make sure we default to kb
-        assert_nothing_raised do
-            tidy[:size] = "2"
-        end
-
-        assert_equal(2048, tidy.should(:size),
-            "Converted 2 wrong")
-
-        convertors.each do |name, number|
-            init = name.to_s[0..0] # The first letter
-            [0, 1, 5].each do |multi|
-                [init, init.upcase].each do |letter|
-                    size = multi.to_s + letter.to_s
-                    assert_nothing_raised do
-                        tidy[:size] = size
-                    end
-
-                    total = multi
-                    number.times do total *= 1024 end
-
-                    assert_equal(total, tidy.should(:size),
-                        "Converted %s wrong" % size)
-                end
-            end
-        end
-    end
-
-    def test_agetest
-        tidy = Puppet::Type.type(:tidy).create :path => tempfile(), :age => "1m"
-
-        age = tidy.property(:age)
-
-        # Set it to something that should be fine
-        assert(age.insync?(Time.now.to_i - 5), "Tried to tidy a low age")
-
-        # Now to something that should fail
-        assert(! age.insync?(Time.now.to_i - 120), "Incorrectly skipped tidy")
-    end
-
-    def test_sizetest
-        tidy = Puppet::Type.type(:tidy).create :path => tempfile(), :size => "1k"
-
-        size = tidy.property(:size)
-
-        # Set it to something that should be fine
-        assert(size.insync?(50), "Tried to tidy a low size")
-
-        # Now to something that should fail
-        assert(! size.insync?(2048), "Incorrectly skipped tidy")
-    end
-
-    # Make sure we can remove different types of files
-    def test_tidytypes
-        path = tempfile()
-        tidy = Puppet::Type.type(:tidy).create :path => path, :size => "1b", :age => "1s"
-
-        # Start with a file
-        File.open(path, "w") { |f| f.puts "this is a test" }
-        assert_events([:file_tidied], tidy)
-        assert(! FileTest.exists?(path), "File was not removed")
-
-        # Then a link
-        dest = tempfile
-        File.open(dest, "w") { |f| f.puts "this is a test" }
-        File.symlink(dest, path)
-        assert_events([:file_tidied], tidy)
-        assert(! FileTest.exists?(path), "Link was not removed")
-        assert(FileTest.exists?(dest), "Destination was removed")
-
-        # And a directory
-        Dir.mkdir(path)
-        tidy[:rmdirs] = true
-        assert_events([:file_tidied], tidy)
-        assert(! FileTest.exists?(path), "File was not removed")
-    end
-    
-    # Make sure we can specify either attribute and get appropriate behaviour.
-    # I found that the original implementation of this did not work unless both
-    # size and age were specified.
-    def test_one_attribute
-        path = tempfile()
-        File.open(path, "w") { |f| 10.times { f.puts "yayness " } }
-        tidy = Puppet::Type.type(:tidy).create :path => path, :size => "1b"
-        
-        assert_apply(tidy)
-        assert(! FileTest.exists?(path), "file did not get tidied")
-        
-        # Now try one with just an age attribute.
-        time = Time.now - 10
-        stat = stub 'stat', :mtime => time, :atime => time, :ftype => "file"
-        File.stubs(:lstat)
-        File.stubs(:lstat).with(path).returns(stat)
-
-        File.open(path, "w") { |f| 10.times { f.puts "yayness " } }
-        tidy = Puppet::Type.type(:tidy).create :path => path, :age => "5s"
-        
-
-        assert_apply(tidy)
-        assert(! FileTest.exists?(path), "file did not get tidied")
-    end
-    
-    # Testing #355.
-    def test_remove_dead_links
-        dir = tempfile()
-        link = File.join(dir, "link")
-        target = tempfile()
-        Dir.mkdir(dir)
-        File.symlink(target, link)
-        
-        tidy = Puppet::Type.type(:tidy).create :path => dir, :size => "1b", :recurse => true
-        assert_apply(tidy)
-        assert(! FileTest.symlink?(link), "link was not tidied")
-    end
-
-    def test_glob_matches_single
-        dir = mktmpdir
-        files = {
-          :remove => File.join(dir, "01-foo"),
-          :keep   => File.join(dir, "default")
-        }
-        files.each do |tag, file|
-          File.open(file, "w") { |f|
-              f.puts "some stuff"
-          }
-        end
-
-        tidy = Puppet.type(:tidy).create(
-            :name => dir,
-            :size => "1b",
-            :rmdirs => true,
-            :recurse => true,
-            :matches => "01-*"
-        )
-        assert_apply(tidy)
-
-        assert(FileTest.exists?(files[:keep]), "%s was tidied" % files[:keep])
-        assert(!FileTest.exists?(files[:remove]), "Tidied %s still exists" % files[:remove])
-    end
-
-    def test_glob_matches_multiple
-        dir = mktmpdir
-        files = {
-          :remove1 => File.join(dir, "01-foo"),
-          :remove2 => File.join(dir, "02-bar"),
-          :keep1   => File.join(dir, "default")
-        }
-        files.each do |tag, file|
-          File.open(file, "w") { |f|
-              f.puts "some stuff"
-          }
-        end
-
-        tidy = Puppet.type(:tidy).create(
-            :name => dir,
-            :size => "1b",
-            :rmdirs => true,
-            :recurse => true,
-            :matches => ["01-*", "02-*"]
-        )
-        assert_apply(tidy)
-
-        assert(FileTest.exists?(files[:keep1]), "%s was tidied" % files[:keep1])
-        assert(!FileTest.exists?(files[:remove1]), "Tidied %s still exists" % files[:remove1])
-        assert(!FileTest.exists?(files[:remove2]), "Tidied %s still exists" % files[:remove2])
-    end
-end
-