puppet 0.16.0 → 0.18.4

data/test/server/ca.rb

@@ -11,7 +11,7 @@ require 'openssl'
 require 'test/unit'
 require 'puppettest.rb'
 
-# $Id: ca.rb 747 2005-11-22 03:54:30Z luke $
+# $Id: ca.rb 1304 2006-06-20 18:10:06Z luke $
 
 if ARGV.length > 0 and ARGV[0] == "short"
     $short = true
@@ -21,11 +21,6 @@ end
 
 class TestCA < Test::Unit::TestCase
 	include ServerTest
-    def teardown
-        super
-        #print "\n\n" if Puppet[:debug]
-    end
-
     # Verify that we're autosigning.  We have to autosign a "different" machine,
     # since we always autosign the CA server's certificate.
     def test_autocertgeneration
@@ -147,6 +142,13 @@ class TestCA < Test::Unit::TestCase
         assert_nothing_raised {
             OpenSSL::X509::Certificate.new(newtext)
         }
+
+        # Now verify that we can clean a given host's certs
+        assert_nothing_raised {
+            ca.clean("anothertest.domain.com")
+        }
+
+        assert(!File.exists?(cert.certfile), "Cert still exists after clean")
     end
 
     # and now test the autosign file
@@ -198,4 +200,40 @@ class TestCA < Test::Unit::TestCase
             )
         }
     end
+
+    # Make sure true/false causes the file to be ignored.
+    def test_autosign_true_beats_file
+        caserv = nil
+        assert_nothing_raised {
+            caserv = Puppet::Server::CA.new()
+        }
+
+        host = "hostname.domain.com"
+
+        # Create an autosign file
+        file = tempfile()
+        Puppet[:autosign] = file
+
+        File.open(file, "w") { |f|
+            f.puts host
+        }
+
+        # Start with "false"
+        Puppet[:autosign] = false
+
+        assert(! caserv.autosign?(host), "Host was incorrectly autosigned")
+
+        # Then set it to true
+        Puppet[:autosign] = true
+        assert(caserv.autosign?(host), "Host was not autosigned")
+        # And try a different host
+        assert(caserv.autosign?("other.yay.com"), "Host was not autosigned")
+
+        # And lastly the file
+        Puppet[:autosign] = file
+        assert(caserv.autosign?(host), "Host was not autosigned")
+
+        # And try a different host
+        assert(! caserv.autosign?("other.yay.com"), "Host was autosigned")
+    end
 end

data/test/server/master.rb

@@ -102,6 +102,8 @@ class TestMaster < Test::Unit::TestCase
     end
 
     def test_filereread
+        # Start with a normal setting
+        Puppet[:filetimeout] = 15
         manifest = mktestmanifest()
 
         file2 = @createdfile + "2"
@@ -113,8 +115,7 @@ class TestMaster < Test::Unit::TestCase
             master = Puppet::Server::Master.new(
                 :Manifest => manifest,
                 :UseNodes => false,
-                :Local => true,
-                :FileTimeout => 15
+                :Local => true
             )
         }
         assert_nothing_raised() {
@@ -153,10 +154,8 @@ class TestMaster < Test::Unit::TestCase
         assert_equal(parse1, master.freshness, "Master did not wait through timeout")
         assert(client.fresh?, "Client is not up to date")
 
-        assert_nothing_raised("Could not resent the file timeout") {
-            master.filetimeout = 0
-        }
-        assert_equal(0, master.filetimeout)
+        # Then eliminate it
+        Puppet[:filetimeout] = 0
 
         # Now make sure the master does reparse
         #Puppet.notice "%s vs %s" % [parse1, master.freshness]
@@ -198,5 +197,5 @@ class TestMaster < Test::Unit::TestCase
     end
 end
 
-# $Id: master.rb 1102 2006-04-11 16:12:38Z luke $
+# $Id: master.rb 1421 2006-07-21 23:12:51Z luke $
 

data/test/server/pelement.rb

@@ -196,7 +196,7 @@ class TestPElementServer < Test::Unit::TestCase
                 Puppet.warning "%s does not respond to :list" % type.name
                 next
             end
-            #next unless type.name == :port
+            next unless type.name == :package
             Puppet.info "Describing each %s" % type.name
 
             # First do a listing from the server
@@ -220,6 +220,7 @@ class TestPElementServer < Test::Unit::TestCase
 
             count = 0
             described = {}
+            Puppet.info "listing again"
             type.list.each do |obj|
                 assert_instance_of(type, obj)
 
@@ -259,33 +260,42 @@ class TestPElementServer < Test::Unit::TestCase
 
         Puppet::Type.type(:file).clear
 
+        Puppet.err filetrans[:parent].inspect
+
+        #p filetrans
+
         bucket = Puppet::TransBucket.new
         bucket.type = "file"
         bucket.push filetrans
 
+        #p bucket
+
+        oldbucket = bucket.dup
         File.unlink(file)
         assert_nothing_raised {
             server.apply(bucket)
         }
 
+
         assert(FileTest.exists?(file), "File did not get recreated")
 
         # Now try it as a "nonlocal" server
         server.local = false
         yaml = nil
         assert_nothing_raised {
-            yaml = CGI.escape(YAML::dump(bucket))
+            yaml = Base64.encode64(YAML::dump(bucket))
         }
 
         Puppet::Type.type(:file).clear
         File.unlink(file)
 
-        if yaml =~ /(.{20}Loglevel.{20})/
+        if Base64.decode64(yaml) =~ /(.{20}Loglevel.{20})/
             Puppet.warning "YAML is broken on this machine"
             return
         end
+        #puts Base64.decode64(yaml)
         assert_nothing_raised("Could not reload yaml") {
-            YAML::load(CGI.unescape(yaml))
+            YAML::load(Base64.decode64(yaml))
         }
 
         assert_nothing_raised {
@@ -295,4 +305,4 @@ class TestPElementServer < Test::Unit::TestCase
     end
 end
 
-# $Id: pelement.rb 1129 2006-04-21 19:14:59Z luke $
+# $Id: pelement.rb 1224 2006-05-25 06:24:44Z luke $

data/test/server/report.rb

@@ -0,0 +1,93 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server/report'
+require 'puppet/client/reporter'
+require 'test/unit'
+require 'puppettest.rb'
+
+class TestReportServer < Test::Unit::TestCase
+	include TestPuppet
+	Puppet::Util.logmethods(self)
+
+    def mkserver
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Server::Report.new()
+        }
+        server
+    end
+
+    def mkclient(server = nil)
+        server ||= mkserver()
+        client = nil
+        assert_nothing_raised {
+            client = Puppet::Client::Reporter.new(:Report => server)
+        }
+
+        client
+    end
+
+    def test_report
+        # Create a bunch of log messages in an array.
+        report = Puppet::Transaction::Report.new
+
+        10.times { |i|
+            log = warning("Report test message %s" % i)
+            log.tags = %w{a list of tags}
+            log.tags << "tag%s" % i
+
+            report.newlog(log)
+        }
+
+        # Now make our reporting client
+        client = mkclient()
+
+        # Now send the report
+        file = nil
+        assert_nothing_raised("Reporting failed") {
+            file = client.report(report)
+        }
+
+        # And make sure our YAML file exists.
+        assert(FileTest.exists?(file),
+            "Report file did not get created")
+
+        # And then try to reconstitute the report.
+        newreport = nil
+        assert_nothing_raised("Failed to load report file") {
+            newreport = YAML.load(File.read(file))
+        }
+
+        # Make sure our report is valid and stuff.
+        report.logs.zip(newreport.logs).each do |ol,nl|
+            %w{level message time tags source}.each do |method|
+                assert_equal(ol.send(method), nl.send(method),
+                    "%s got changed" % method)
+            end
+        end
+    end
+
+    # Make sure we don't have problems with calling mkclientdir multiple
+    # times.
+    def test_multiple_clients
+        server ||= mkserver()
+
+        %w{hostA hostB hostC}.each do |host|
+            dir = tempfile()
+            assert_nothing_raised("Could not create multiple host report dirs") {
+                server.send(:mkclientdir, host, dir)
+            }
+
+            assert(FileTest.directory?(dir),
+                "Directory was not created")
+        end
+    end
+end
+
+# $Id: report.rb 1390 2006-07-11 20:22:27Z luke $
+

data/test/server/runner.rb

@@ -0,0 +1,107 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server/runner'
+require 'test/unit'
+require 'puppettest.rb'
+
+class TestServerRunner < Test::Unit::TestCase
+	include TestPuppet
+
+    def mkclient(file)
+        master = nil
+        client = nil
+        # create our master
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Server::Master.new(
+                :Manifest => file,
+                :UseNodes => false,
+                :Local => true
+            )
+        }
+
+        # and our client
+        assert_nothing_raised() {
+            client = Puppet::Client::MasterClient.new(
+                :Master => master
+            )
+        }
+
+        client
+    end
+
+    def test_runner
+        Puppet[:ignoreschedules] = false
+        # Okay, make our manifest
+        file = tempfile()
+        created = tempfile()
+        File.open(file, "w") do |f|
+            f.puts %{
+                class yayness {
+                    file { "#{created}": ensure => file, schedule => weekly }
+                }
+
+                include yayness
+            }
+        end
+
+        client = mkclient(file)
+
+        runner = nil
+        assert_nothing_raised {
+            runner = Puppet::Server::Runner.new
+        }
+        # First: tags
+        # Second: ignore schedules true/false
+        # Third: background true/false
+        # Fourth: whether file should exist true/false
+        [
+            ["with no backgrounding",
+                nil, true, true, true],
+            ["in the background",
+                nil, true, false, true],
+            ["with a bad tag",
+                ["coolness"], true, false, false],
+            ["with another bad tag",
+                "coolness", true, false, false],
+            ["with a good tag",
+                ["coolness", "yayness"], true, false, true],
+            ["with another good tag",
+                ["yayness"], true, false, true],
+            ["with a third good tag",
+                "yayness", true, false, true],
+            ["not ignoring schedules",
+                nil, false, false, false],
+            ["ignoring schedules",
+                nil, true, false, true],
+        ].each do |msg, tags, ignore, fg, shouldexist|
+            if FileTest.exists?(created)
+                File.unlink(created)
+            end
+            assert_nothing_raised {
+                # Try it without backgrounding
+                runner.run(tags, ignore, fg)
+            }
+
+            unless fg
+                Puppet.join
+            end
+
+            if shouldexist
+                assert(FileTest.exists?(created), "File did not get created " +
+                    msg)
+            else
+                assert(!FileTest.exists?(created), "File got created incorrectly " +
+                    msg)
+            end
+        end
+    end
+end
+
+# $Id: runner.rb 1325 2006-06-28 15:17:56Z luke $
+

data/test/server/server.rb

@@ -13,7 +13,7 @@ require 'xmlrpc/client'
 require 'test/unit'
 require 'puppettest.rb'
 
-# $Id: server.rb 1068 2006-04-04 23:13:55Z luke $
+# $Id: server.rb 1306 2006-06-20 18:38:48Z luke $
 
 if ARGV.length > 0 and ARGV[0] == "short"
     $short = true
@@ -122,4 +122,31 @@ class TestServer < Test::Unit::TestCase
             retval = client.getconfig
         }
     end
+
+    def test_setpidfile_setting
+        Puppet[:setpidfile] = false
+        server = nil
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Status => nil
+                }
+            )
+
+        }
+
+        assert_nothing_raised {
+            server.setpidfile
+        }
+
+        assert(! FileTest.exists?(server.pidfile), "PID file was created")
+        Puppet[:setpidfile] = true
+
+        assert_nothing_raised {
+            server.setpidfile
+        }
+        assert(FileTest.exists?(server.pidfile), "PID file was not created")
+    end
 end

data/test/types/cron.rb

@@ -2,8 +2,8 @@
 
 if __FILE__ == $0
     $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../../../../language/trunk"
+    $:.unshift '../lib'
+    $puppetbase = "../.."
 end
 
 require 'puppettest'
@@ -11,14 +11,6 @@ require 'puppet'
 require 'test/unit'
 require 'facter'
 
-
-# Here we just want to unit-test our cron type, to verify that 
-#class TestCronType < Test::Unit::TestCase
-#	include TestPuppet
-#
-#
-#end
-
 class TestCron < Test::Unit::TestCase
 	include TestPuppet
     def setup
@@ -43,6 +35,7 @@ class TestCron < Test::Unit::TestCase
 
     def teardown
         @crontype.filetype = @oldfiletype
+        Puppet::FileType.filetype(:ram).clear
         super
     end
 
@@ -91,23 +84,32 @@ class TestCron < Test::Unit::TestCase
 
     # Run the cron through its paces -- install it then remove it.
     def cyclecron(cron)
+        obj = Puppet::Type::Cron.cronobj(@me)
+
+        text = obj.read
         name = cron.name
         comp = newcomp(name, cron)
 
         assert_events([:cron_created], comp)
         cron.retrieve
 
-        assert(cron.insync?)
+        assert(cron.insync?, "Cron is not in sync")
 
         assert_events([], comp)
 
+        curtext = obj.read
+        text.split("\n").each do |line|
+            assert(curtext.include?(line), "Missing '%s'" % line)
+        end
+        obj = Puppet::Type::Cron.cronobj(@me)
+
         cron[:ensure] = :absent
 
         assert_events([:cron_removed], comp)
 
         cron.retrieve
 
-        assert(cron.insync?)
+        assert(cron.insync?, "Cron is not in sync")
         assert_events([], comp)
     end
 
@@ -141,6 +143,29 @@ class TestCron < Test::Unit::TestCase
             "Cron did not generate correctly")
     end
 
+    def test_simpleparsing
+        @fakefiletype = Puppet::FileType.filetype(:ram)
+        @crontype.filetype = @fakefiletype
+
+        @crontype.retrieve(@me)
+        obj = Puppet::Type::Cron.cronobj(@me)
+
+        text = "5 1,2 * 1 0 /bin/echo funtest"
+
+        assert_nothing_raised {
+            @crontype.parse(@me, text)
+        }
+
+        @crontype.each do |obj|
+            assert_equal(["5"], obj.is(:minute), "Minute was not parsed correctly")
+            assert_equal(["1", "2"], obj.is(:hour), "Hour was not parsed correctly")
+            assert_equal([:absent], obj.is(:monthday), "Monthday was not parsed correctly")
+            assert_equal(["1"], obj.is(:month), "Month was not parsed correctly")
+            assert_equal(["0"], obj.is(:weekday), "Weekday was not parsed correctly")
+            assert_equal(["/bin/echo funtest"], obj.is(:command), "Command was not parsed correctly")
+        end
+    end
+
     # Test that changing any field results in the cron tab being rewritten.
     # it directly
     def test_any_field_changes
@@ -192,12 +217,13 @@ class TestCron < Test::Unit::TestCase
     def test_retain_comments
         str = "# this is a comment\n#and another comment\n"
         user = "fakeuser"
+        @crontype.retrieve(@me)
         assert_nothing_raised {
-            @crontype.parse(user, str)
+            @crontype.parse(@me, str)
         }
 
         assert_nothing_raised {
-            newstr = @crontype.tab(user)
+            newstr = @crontype.tab(@me)
             assert(newstr.include?(str), "Comments were lost")
         }
     end
@@ -207,10 +233,6 @@ class TestCron < Test::Unit::TestCase
     def test_matchcron
         str = "0,30 * * * * date\n"
 
-        assert_nothing_raised {
-            @crontype.parse(@me, str)
-        }
-
         assert_nothing_raised {
             cron = @crontype.create(
                 :name => "yaycron",
@@ -220,6 +242,16 @@ class TestCron < Test::Unit::TestCase
             )
         }
 
+        assert_nothing_raised {
+            @crontype.parse(@me, str)
+        }
+
+        count = @crontype.inject(0) do |c, obj|
+            c + 1
+        end
+
+        assert_equal(1, count, "Did not match cron job")
+
         modstr = "# Puppet Name: yaycron\n%s" % str
 
         assert_nothing_raised {
@@ -234,14 +266,15 @@ class TestCron < Test::Unit::TestCase
         tab = @fakefiletype.new(@me)
         tab.remove
 
+        @crontype.retrieve(@me)
         cron = mkcron("testwithnotab")
         cyclecron(cron)
     end
 
     def test_mkcronwithtab
-        tab = @fakefiletype.new(@me)
-        tab.remove
-        tab.write(
+        @crontype.retrieve(@me)
+        obj = Puppet::Type::Cron.cronobj(@me)
+        obj.write(
 "1 1 1 1 * date > %s/crontesting\n" % tstdir()
         )
 
@@ -253,17 +286,18 @@ class TestCron < Test::Unit::TestCase
         tab = @fakefiletype.new(@me)
         tab.remove
 
-        name = "storeandretrieve"
-        cron = mkcron(name)
-        comp = newcomp(name, cron)
-        trans = assert_events([:cron_created], comp, name)
-        
-        cron = nil
+        %w{storeandretrieve a-name another-name more_naming SomeName}.each do |name|
+            cron = mkcron(name)
+            comp = newcomp(name, cron)
+            trans = assert_events([:cron_created], comp, name)
+            
+            cron = nil
 
-        Puppet.type(:cron).retrieve(@me)
+            Puppet.type(:cron).retrieve(@me)
 
-        assert(cron = Puppet.type(:cron)[name], "Could not retrieve named cron")
-        assert_instance_of(Puppet.type(:cron), cron)
+            assert(cron = Puppet.type(:cron)[name], "Could not retrieve named cron")
+            assert_instance_of(Puppet.type(:cron), cron)
+        end
     end
 
     # Do input validation testing on all of the parameters.
@@ -405,6 +439,280 @@ class TestCron < Test::Unit::TestCase
             @crontype.retrieve("nosuchuser")
         end
     end
+
+    def test_names
+        cron = mkcron("nametest")
+
+        ["bad name", "bad.name"].each do |name|
+            assert_raise(ArgumentError) do
+                cron[:name] = name
+            end
+        end
+
+        ["good-name", "good-name", "AGoodName"].each do |name|
+            assert_nothing_raised do
+                cron[:name] = name
+            end
+        end
+    end
+
+    # Make sure we don't puke on env settings
+    def test_envsettings
+        cron = mkcron("envtst")
+
+        assert_apply(cron)
+
+        obj = Puppet::Type::Cron.cronobj(@me)
+
+        assert(obj)
+
+        text = obj.read
+
+        text = "SHELL = /path/to/some/thing\n" + text
+
+        obj.write(text)
+
+        assert_nothing_raised {
+            cron.retrieve
+        }
+
+        cron[:command] = "/some/other/command"
+
+        assert_apply(cron)
+
+        assert(obj.read =~ /SHELL/, "lost env setting")
+
+        env1 = "TEST = /bin/true"
+        env2 = "YAY = fooness"
+        assert_nothing_raised {
+            cron[:environment] = [env1, env2]
+        }
+
+        assert_apply(cron)
+        cron.retrieve
+
+        vals = cron.is(:environment)
+        assert(vals, "Did not get environment settings")
+        assert(vals != :absent, "Env is incorrectly absent")
+        assert_instance_of(Array, vals)
+
+        assert(vals.include?(env1), "Missing first env setting")
+        assert(vals.include?(env2), "Missing second env setting")
+
+    end
+
+    def test_divisionnumbers
+        cron = mkcron("divtest")
+        cron[:minute] = "*/5"
+
+        assert_apply(cron)
+
+        cron.retrieve
+
+        assert_equal(["*/5"], cron.is(:minute))
+    end
+
+    def test_ranges
+        cron = mkcron("rangetest")
+        cron[:minute] = "2-4"
+
+        assert_apply(cron)
+
+        cron.retrieve
+
+        assert_equal(["2-4"], cron.is(:minute))
+    end
+
+    def test_data
+        @fakefiletype = Puppet::FileType.filetype(:ram)
+        @crontype.filetype = @fakefiletype
+
+        @crontype.retrieve(@me)
+        obj = Puppet::Type::Cron.cronobj(@me)
+
+        fakedata("data/types/cron").each do |file|
+            names = []
+            text = File.read(file)
+            obj.write(File.read(file))
+
+            @crontype.retrieve(@me)
+
+            @crontype.each do |cron|
+                names << cron.name
+            end
+
+            name = File.basename(file)
+            cron = mkcron("filetest-#{name}")
+
+            assert_apply(cron)
+
+            @crontype.retrieve(@me)
+
+            names.each do |name|
+                assert(@crontype[name], "Could not retrieve %s" % name)
+            end
+
+            tablines = @crontype.tab(@me).split("\n")
+
+            text.split("\n").each do |line|
+                assert(tablines.include?(line),
+                    "Did not get %s back out" % line.inspect)
+            end
+        end
+    end
+
+    def test_value
+        cron = mkcron("valuetesting")
+
+        # First, test the normal states
+        [:minute, :hour, :month].each do |param|
+            state = cron.state(param)
+
+            assert(state, "Did not get %s state" % param)
+
+            assert_nothing_raised {
+                state.should = :absent
+                state.is = :absent
+            }
+
+            # Make sure our minute default is 0, not *
+            val = if param == :minute
+                "*" # the "0" thing is disabled for now
+            else
+                "*"
+            end
+            assert_equal(val, cron.value(param))
+
+            # Make sure we correctly get the "is" value if that's all there is
+            cron.is = [param, "1"]
+            assert_equal("1", cron.value(param))
+
+            # Make sure arrays work, too
+            cron.is = [param, ["1"]]
+            assert_equal("1", cron.value(param))
+
+            # Make sure values get comma-joined
+            cron.is = [param, ["2", "3"]]
+            assert_equal("2,3", cron.value(param))
+
+            # Make sure "should" values work, too
+            cron[param] = "4"
+            assert_equal("4", cron.value(param))
+
+            cron[param] = ["4"]
+            assert_equal("4", cron.value(param))
+
+            cron[param] = ["4", "5"]
+            assert_equal("4,5", cron.value(param))
+
+            cron.is = [param, :absent]
+            assert_equal("4,5", cron.value(param))
+        end
+
+        # Now make sure that :command works correctly
+        state = cron.state(:command)
+
+        assert_nothing_raised {
+            state.should = :absent
+            state.is = :absent
+        }
+
+        assert(state, "Did not get command state")
+        assert_raise(Puppet::DevError) do
+            cron.value(:command)
+        end
+
+        param = :command
+        # Make sure we correctly get the "is" value if that's all there is
+        cron.is = [param, "1"]
+        assert_equal("1", cron.value(param))
+
+        # Make sure arrays work, too
+        cron.is = [param, ["1"]]
+        assert_equal("1", cron.value(param))
+
+        # Make sure values are not comma-joined
+        cron.is = [param, ["2", "3"]]
+        assert_equal("2", cron.value(param))
+
+        # Make sure "should" values work, too
+        cron[param] = "4"
+        assert_equal("4", cron.value(param))
+
+        cron[param] = ["4"]
+        assert_equal("4", cron.value(param))
+
+        cron[param] = ["4", "5"]
+        assert_equal("4", cron.value(param))
+
+        cron.is = [param, :absent]
+        assert_equal("4", cron.value(param))
+    end
+
+    # Make sure we can successfully list all cron jobs on all users
+    def test_cron_listing
+        crons = []
+        %w{fake1 fake2 fake3 fake4 fake5}.each do |user|
+            crons << @crontype.create(
+                :name => "#{user}-1",
+                :command => "/usr/bin/#{user}",
+                :minute => "0",
+                :user => user,
+                :hour => user.sub("fake",'')
+            )
+
+            crons << @crontype.create(
+                :name => "#{user}-2",
+                :command => "/usr/sbin/#{user}",
+                :minute => "0",
+                :user => user,
+                :weekday => user.sub("fake",'')
+            )
+
+            assert_apply(*crons)
+        end
+
+        list = @crontype.list.collect { |c| c.name }
+
+        crons.each do |cron|
+            assert(list.include?(cron.name), "Did not match cron %s" % name)
+        end
+    end
+
+    # Make sure we can create a cron in an empty tab
+    def test_mkcron_if_empty
+        @crontype.filetype = @oldfiletype
+
+        @crontype.retrieve(@me)
+
+        # Backup our tab
+        text = @crontype.tabobj(@me).read
+
+        cleanup do
+            if text == ""
+                @crontype.tabobj(@me).remove
+            else
+                @crontype.tabobj(@me).write(text)
+            end
+        end
+
+        # Now get rid of it
+        @crontype.tabobj(@me).remove
+        @crontype.clear
+
+        cron = mkcron("emptycron")
+
+        assert_apply(cron)
+
+        # Clear the type, but don't clear the filetype
+        @crontype.clear
+
+        # Get the stuff again
+        @crontype.retrieve(@me)
+
+        assert(@crontype["emptycron"],
+            "Did not retrieve cron")
+    end
 end
 
-# $Id: cron.rb 1125 2006-04-20 19:38:48Z luke $
+# $Id: cron.rb 1402 2006-07-18 15:35:15Z luke $