tpkg 2.3.3 → 2.3.4

data/pkginfo

@@ -0,0 +1,8 @@
+PKG="OSStpkg"
+NAME="tpkg client"
+ARCH="sparc,i386"
+VERSION="%VER%"
+CATEGORY="application"
+CLASSES="none"
+PSTAMP="none"
+

data/postinstall.solaris

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+# Add a hook to /etc/profile that sources profile scripts installed by
+# packages.
+echo "# BEGIN TPKG HOOK
+for i in /etc/profile.d/*.sh ; do
+    if [ -r \"\$i\" ]; then
+        . \$i
+    fi
+done
+# END TPKG HOOK" >> /etc/profile

data/postremove.solaris

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+# Remove the hook from /etc/profile
+start_line=`grep -n "BEGIN TPKG" /etc/profile | awk -F: '{print $1}'`
+end_line=`grep -n "END TPKG" /etc/profile | awk -F: '{print $1}'`
+# Check that we actually got valid start and end line
+if [ $start_line ] && [ $end_line ] && [ $start_line -lt $end_line ]
+then
+  tmpfile=`mktemp -t etc.profile.XXXXXX`
+  # yank out those lines
+  sed -e "$start_line,$end_line d" /etc/profile > $tmpfile
+  chmod 644 $tmpfile
+  if [ -s $tmpfile ]; then
+    mv $tmpfile /etc/profile
+  fi
+fi

data/test/TODO

@@ -0,0 +1,30 @@
+# Test that a package with no OS specified will install
+# Test that a package with one matching OS will install
+# Test that a package with a matching OS in a list of OSs will install
+# Test that a package with one non-matching OS will not install
+# Test that a package with a list of non-matching OSs will not install
+
+# Test that a package with no architecture specified will install
+# Test that a package with one matching architecture will install
+# Test that a package with a matching architecture in a list of architectures will install
+# Test that a package with one non-matching architecture will not install
+# Test that a package with a list of non-matching architectures will not install
+
+# Test that preinstall/postinstall/preremove/postremove are run at the right points
+
+# Test that a package with an available dependency in version range will install
+# Test that a package with an unavailable dependency won't install - dep doesn't exist
+# Test that a package with an unavailable dependency won't install - dep below min version
+# Test that a package with an unavailable dependency won't install - dep above max version
+# Test that a package with an unavailable dependency won't install - dep doesn't match on OS
+#  This tests that we properly handle a dependency that matches name and version but not other characteristics
+
+
+# Test that a package which conflicts in name with an already installed package will not install
+# Test that a package which conflicts in files with an already installed package will not install
+
+# Upgrade with no existing install works
+# Upgrade with older install works
+# Upgrade with current install fails
+# Upgrade with newer version fails
+# Upgrade with older version and rollback flag works

data/test/test_checksum.rb

@@ -0,0 +1,53 @@
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+#
+# Test tpkg's ability to handle package checksums
+#
+
+class TpkgChecksumTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # Make up our regular test package
+    @pkgfile = make_package(:remove => ['operatingsystem', 'architecture'])
+  end
+  
+  # The processing of creating and storing checksums during the package
+  # creation process is tested in make.rb
+  
+  def test_verify_package_checksum
+    assert_nothing_raised('verify good checksum') { Tpkg::verify_package_checksum(@pkgfile) }
+    
+    # Add a few characters to the inner checksummed tarball and test that
+    # it now fails the checksum verification
+    tar = Tpkg::find_tar
+    Dir.mktmpdir('workdir') do |workdir|
+      system("#{tar} -C #{workdir} -xf #{@pkgfile}") || abort
+      File.open(File.join(workdir, 'testpkg-1.0-1', 'tpkg.tar'), 'a') do |file|
+        file.write('xxxxxx')
+      end
+      badpkg = Tempfile.new('tpkgtest')
+      system("#{tar} -C #{workdir} -cf #{badpkg.path} testpkg-1.0-1") || abort
+      assert_raise(RuntimeError, 'verify bad checksum') { Tpkg::verify_package_checksum(badpkg.path) }
+    end
+    
+    # Confirm that checksum verification also fails on something that isn't a valid package
+    puts '#'
+    puts '# Errors expected here'
+    puts '#'
+    boguspkg = Tempfile.new('tpkgtest')
+    boguspkg.puts('xxxxxx')
+    boguspkg.close
+    assert_raise(RuntimeError, NoMethodError, 'verify bogus non-tarball') { Tpkg::verify_package_checksum(boguspkg.path) }
+    # And for completeness how about something that is a tarball but not a valid package
+    boguspkg2 = Tempfile.new('tpkgtest')
+    system("#{tar} -cf #{boguspkg2.path} #{boguspkg.path}")
+    assert_raise(RuntimeError, NoMethodError, 'verify bogus tarball') { Tpkg::verify_package_checksum(boguspkg2.path) }
+  end
+  
+  def teardown
+    FileUtils.rm_f(@pkgfile)
+  end
+end

data/test/test_compress.rb

@@ -0,0 +1,55 @@
+
+
+#
+# Test tpkg's compression feature
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgCompressTests < Test::Unit::TestCase
+  include TpkgTests
+  def setup
+    Tpkg::set_prompt(false)
+    # Make up our regular test package
+    @pkgfile = make_package(:remove => ['operatingsystem', 'architecture'])
+    @gzip_pkgfile = make_package(:change => {'name' => 'gzip_pkg'}, :remove => ['operatingsystem', 'architecture'], :compress => 'gzip')
+    @bz2_pkgfile = make_package(:change => {'name' => 'bz2_pkg'}, :remove => ['operatingsystem', 'architecture'], :compress => 'bz2')
+    @default_compression_pkgfile = make_package(:change => {'name' => 'default_compression_pkg'}, :remove => ['operatingsystem', 'architecture'], :compress => true)
+    @uncompressed_pkgfile = make_package(:change => {'name' => 'uncompressed_pkg'}, :remove => ['operatingsystem', 'architecture'], :compress => false)
+  end
+
+  # Given a .tpkg file, verify that we can figure out how the inner level archive tpkg.tar 
+  # was compressed 
+  def test_get_compression
+    assert(Tpkg::get_compression(@pkgfile).nil?)
+    assert_equal('gzip', Tpkg::get_compression(@gzip_pkgfile))
+    assert_equal('bz2', Tpkg::get_compression(@bz2_pkgfile))
+    assert(['bz2', 'gzip'].include?(Tpkg::get_compression(@default_compression_pkgfile)))
+    assert(Tpkg::get_compression(@uncompressed_pkgfile).nil?)
+  end 
+
+  def test_install_compressed_pkg
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [@gzip_pkgfile, @bz2_pkgfile])
+      assert_nothing_raised { tpkg.install([@gzip_pkgfile], PASSPHRASE) }
+      assert_nothing_raised { tpkg.install([@bz2_pkgfile], PASSPHRASE) }
+      assert_nothing_raised { tpkg.install([@default_compression_pkgfile], PASSPHRASE) }
+      assert_nothing_raised { tpkg.install([@uncompressed_pkgfile], PASSPHRASE) }
+    end
+  end
+
+  def test_bad_compression_type
+    assert_raise(RuntimeError, 'verify bad compression type')  { 
+      make_package(:change => {'name' => 'bogus_compression_pkg'}, 
+                   :remove => ['operatingsystem', 'architecture'], :compress => 'bogus')
+    }
+  end
+
+  def teardown
+    FileUtils.rm_f(@pkgfile)
+    FileUtils.rm_f(@gzip_pkgfile)
+    FileUtils.rm_f(@bz2_pkgfile)
+    FileUtils.rm_f(@default_compression_pkgfile)
+    FileUtils.rm_f(@uncompressed_pkgfile)
+  end 
+end 

data/test/test_conflict.rb

@@ -0,0 +1,41 @@
+#
+# Test tpkg's ability to resolve dependencies
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgConflictTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+  end
+
+  def test_conflict
+    Dir.mktmpdir('srcdir') do |srcdir|
+      pkgfiles = []
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      
+      pkgfiles <<  make_package(:change => { 'name' => 'pkgA', 'version' => '1.0' }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'], :conflicts => {'pkgB' => {}})
+      pkgfiles <<  make_package(:change => { 'name' => 'pkgB', 'version' => '1.0' }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      pkgfiles <<  make_package(:change => { 'name' => 'pkgC', 'version' => '1.0' }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      pkgfiles <<  make_package(:change => { 'name' => 'pkgC', 'version' => '2.0' }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'], :conflicts => {'pkgD' => {}})
+      pkgfiles <<  make_package(:change => { 'name' => 'pkgD', 'version' => '1.0' }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      
+      # Should not be able to install both pkgA and B since A conflicts with B
+      Dir.mktmpdir('testroot') do |testroot|
+        tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => pkgfiles)
+        assert_raise(RuntimeError) { tpkg.install(['pkgA', 'pkgB'], PASSPHRASE) }
+        assert_nothing_raised { tpkg.install(['pkgA'], PASSPHRASE)}
+        assert(!tpkg.install(['pkgB'], PASSPHRASE))
+        assert(tpkg.install(['pkgB'], PASSPHRASE, {:force_replace => true}))
+        assert_nothing_raised { tpkg.install(['pkgC=1.0', 'pkgD'], PASSPHRASE)}
+        # Should not be able to upgrade pgkC because new version
+        # of pkgC conflicts with pkgD
+        assert(!tpkg.upgrade(['pkgC'], PASSPHRASE))
+        assert(tpkg.upgrade(['pkgC'], PASSPHRASE, {:force_replace => true}))
+      end
+    end
+  end
+  
+end

data/test/test_crontabs.rb

@@ -0,0 +1,398 @@
+#
+# Test tpkg's crontab handling methods
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgCrontabTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # Pretend to be an OS with cron.d support
+    fact = Facter::Util::Fact.new('operatingsystem')
+    fact.stubs(:value).returns('RedHat')
+    Facter.stubs(:[]).returns(fact)
+  end
+  
+  def test_crontabs
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'nobody'} },
+          'etc/cron.d/crontab' => { 'crontab' => {} } })
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot)
+      assert_equal(
+        {
+          "#{testroot}/opt/tpkg/etc/crontab_user" =>
+            {'path'=>'etc/crontab_user', 'crontab'=>{'user'=>'nobody'}},
+          "#{testroot}/opt/tpkg/etc/cron.d/crontab" =>
+            {'path'=>'etc/cron.d/crontab', 'crontab'=>{}}
+        },
+        tpkg.crontabs(metadata))
+      
+      assert_equal({}, tpkg.crontabs({}))
+      assert_equal({}, tpkg.crontabs({:files => {}}))
+      assert_equal({}, tpkg.crontabs({:files => {:files => {}}}))
+    end
+  end
+  def test_crontab_destinations
+    pkg = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      FileUtils.mkdir_p("#{srcdir}/reloc/etc/cron.d")
+      File.open("#{srcdir}/reloc/etc/crontab_user", 'w') do |file|
+        file.puts('user crontab')
+      end
+      File.open("#{srcdir}/reloc/etc/cron.d/crontab", 'w') do |file|
+        file.puts('cron.d crontab')
+      end
+      pkg = make_package(
+        :change => { 'name' => 'cronpkg' },
+        :source_directory => srcdir,
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'nobody'} },
+          'etc/cron.d/crontab' => { 'crontab' => {} } },
+        :remove => ['operatingsystem', 'architecture'])
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :sources => [pkg])
+      metadata = Tpkg::metadata_from_package(pkg)
+      assert_equal(
+        {
+          "#{testroot}/opt/tpkg/etc/crontab_user" => {:type=>:file, :user=>'nobody'},
+          "#{testroot}/opt/tpkg/etc/cron.d/crontab" => {:type=>:link, :path=>'/etc/cron.d/crontab'},
+        },
+        tpkg.crontab_destinations(metadata))
+    end
+    FileUtils.rm_f(pkg)
+  end
+  def test_crontab_destination
+    tpkg = Tpkg.new
+    assert_equal(
+      {:type=>:file, :user=>'nobody'},
+      tpkg.crontab_destination(
+        '/opt/tpkg/etc/crontab_user', {:crontab => {:user => 'nobody'}}))
+    assert_equal(
+      {:type=>:link, :path=>'/etc/cron.d/crontab'},
+      tpkg.crontab_destination(
+        '/opt/tpkg/etc/cron.d/crontab', {:crontab => {}}))
+  end
+  
+  def test_install_crontabs
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'nobody'} },
+          'etc/cron.d/crontab' => { 'crontab' => {} } })
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot)
+      tpkg.expects(:install_crontab_link).with(metadata, "#{testroot}/opt/tpkg/etc/cron.d/crontab", '/etc/cron.d/crontab')
+      tpkg.expects(:install_crontab_file).with(metadata, "#{testroot}/opt/tpkg/etc/crontab_user", 'nobody')
+      tpkg.install_crontabs(metadata)
+    end
+  end
+  def test_install_crontab_link
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg'  },
+        :files => { 'etc/cron.d/crontab' => { 'crontab' => {} } })
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot)
+      crontab = "#{testroot}/opt/tpkg/etc/cron.d/crontab"
+      destination = "#{testroot}/etc/cron.d/crontab"
+      
+      # Directory for link doesn't exist, directory and link are created
+      tpkg.install_crontab_link(metadata, crontab, destination)
+      assert(File.symlink?(destination))
+      assert_equal(crontab, File.readlink(destination))
+      
+      # Link already exists, nothing is done
+      sleep 2
+      beforetime = File.lstat(destination).mtime
+      tpkg.install_crontab_link(metadata, crontab, destination)
+      assert(File.symlink?(destination))
+      assert_equal(crontab, File.readlink(destination))
+      assert_equal(beforetime, File.lstat(destination).mtime)
+      
+      # Existing files or links up to 8 already exist, link created with appropriate suffix
+      File.delete(destination)
+      File.symlink('somethingelse', destination)
+      0.upto(8) do |i|
+        File.delete(destination + i.to_s) if (i != 0)
+        File.symlink('somethingelse', destination + i.to_s)
+        tpkg.install_crontab_link(metadata, crontab, destination)
+        assert(File.symlink?(destination + (i + 1).to_s))
+        assert_equal(crontab, File.readlink(destination + (i + 1).to_s))
+      end
+      
+      # Existing files or links up to 9 already exist, exception raised
+      File.delete(destination + '9')
+      File.symlink('somethingelse', destination + '9')
+      assert_raise(RuntimeError) { tpkg.install_crontab_link(metadata, crontab, destination) }
+    end
+  end
+  def test_crontab_uoption
+    current_user = Etc.getpwuid.name
+    tpkg = Tpkg.new
+    assert_equal '', tpkg.crontab_uoption('ANY')
+    assert_equal '', tpkg.crontab_uoption(current_user)
+    assert_equal '-u nobody', tpkg.crontab_uoption('nobody')
+  end
+  # Test that install_crontab_file calls the crontab command with the -u
+  # option if the package request that the crontab be installed for a user
+  # other than the current user
+  def test_install_crontab_file_with_uoption
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'BoguS'} }})
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    tpkg = Tpkg.new
+    tpkg.expects(:`).with('crontab -u nobody -l').returns('')
+    crontab = Tempfile.new('tpkgtest_cron')
+    tpkg.expects(:system).with(regexp_matches(/\Acrontab -u nobody [^-]/))
+    tpkg.install_crontab_file(metadata, crontab, 'nobody')
+  end
+  # And test that it omits the -u option if the crontab is for the current
+  # user
+  def test_install_crontab_file_without_uoption
+    current_user = Etc.getpwuid.name
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => current_user} }})
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    tpkg = Tpkg.new
+    tpkg.expects(:`).with('crontab  -l').returns('')
+    crontab = Tempfile.new('tpkgtest_cron')
+    tpkg.expects(:system).with(regexp_matches(/\Acrontab [^-]/))
+    tpkg.install_crontab_file(metadata, crontab, current_user)
+  end
+  # And finally, test that it properly adds the given crontab to the user's
+  # crontab
+  def test_install_crontab_file_operation
+    current_user = Etc.getpwuid.name
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'BoguS'} }})
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    fake_filename = '/path/to/cronpkg-1.0.tpkg'
+    metadata[:filename] = fake_filename
+    Dir.mktmpdir('testroot') do |testroot|
+      existing_contents = "* * * * *  /existing/job\n"
+      user_crontab = Tempfile.new('tpkgtest_cron')
+      user_crontab.write existing_contents
+      user_crontab.close
+      package_crontab = "#{testroot}/opt/tpkg/etc/crontab_user"
+      FileUtils.mkdir_p(File.dirname(package_crontab))
+      new_contents = "1 2 * * *  /new/job\n"
+      File.open(package_crontab, 'w') do |file|
+        file.write new_contents
+      end
+      tpkg = Tpkg.new(
+        :file_system_root => testroot,
+        :cmd_crontab => File.join(TESTCMDDIR, "crontab -f #{user_crontab.path}"))
+      tpkg.install_crontab_file(metadata, package_crontab, current_user)
+      user_crontab.open
+      assert_equal(
+        existing_contents +
+          "### TPKG START - #{testroot}/opt/tpkg - #{File.basename(fake_filename)}\n" +
+          new_contents +
+          "### TPKG END - #{testroot}/opt/tpkg - #{File.basename(fake_filename)}\n",
+        user_crontab.read)
+    end
+  end
+  def test_remove_crontabs
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'nobody'} },
+          'etc/cron.d/crontab' => { 'crontab' => {} } })
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot)
+      tpkg.expects(:remove_crontab_file).with(metadata, 'nobody')
+      tpkg.expects(:remove_crontab_link).with(metadata, "#{testroot}/opt/tpkg/etc/cron.d/crontab", '/etc/cron.d/crontab')
+      tpkg.remove_crontabs(metadata)
+    end
+  end
+  def test_remove_crontab_link
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => { 'etc/cron.d/crontab' => { 'crontab' => {} } })
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot)
+      crontab = File.join(testroot, '/opt/tpkg/etc/cron.d/crontab')
+      destination = File.join(testroot, '/etc/cron.d/crontab')
+      
+      # Standard symlink using the base name is removed
+      FileUtils.mkdir_p(File.dirname(destination))
+      File.symlink(crontab, destination)
+      tpkg.remove_crontab_link(metadata, crontab, destination)
+      refute File.symlink?(destination)
+      refute File.exist?(destination)
+      
+      # Links with suffixes from 1..9 are removed
+      1.upto(9) do |i|
+        FileUtils.rm(Dir.glob(destination + '*'))
+        File.symlink(crontab, destination + i.to_s)
+        File.symlink(crontab, destination + '1') if (i != 1)
+        2.upto(i-1) do |j|
+          File.symlink('somethingelse', destination + j.to_s)
+        end
+        tpkg.remove_crontab_link(metadata, crontab, destination)
+        refute File.exist?(destination)
+        refute File.symlink?(destination)
+        refute File.exist?(destination + '1')
+        refute File.symlink?(destination + '1')
+        2.upto(i-1) do |j|
+          assert(File.symlink?(destination + j.to_s))
+          assert_equal('somethingelse', File.readlink(destination + j.to_s))
+        end
+      end
+      
+      # Links with suffixes of 0 or 10 are left alone
+      File.symlink(crontab, destination + '0')
+      File.symlink(crontab, destination + '10')
+      tpkg.remove_crontab_link(metadata, crontab, destination)
+      assert File.symlink?(destination + '0')
+      assert_equal crontab, File.readlink(destination + '0')
+      assert File.symlink?(destination + '10')
+      assert_equal crontab, File.readlink(destination + '10')
+    end
+  end
+  def test_remove_crontab_file_with_uoption
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'BoguS'} }})
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    tpkg = Tpkg.new
+    tpkg.expects(:`).with('crontab -u nobody -l').returns('')
+    crontab = Tempfile.new('tpkgtest_cron')
+    tpkg.expects(:system).with(regexp_matches(/\Acrontab -u nobody [^-]/))
+    tpkg.remove_crontab_file(metadata, 'nobody')
+  end
+  def test_remove_crontab_file_without_uoption
+    current_user = Etc.getpwuid.name
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => current_user} }})
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    tpkg = Tpkg.new
+    tpkg.expects(:`).with('crontab  -l').returns('')
+    crontab = Tempfile.new('tpkgtest_cron')
+    tpkg.expects(:system).with(regexp_matches(/\Acrontab [^-]/))
+    tpkg.remove_crontab_file(metadata, current_user)
+  end
+  def test_remove_crontab_file_operation
+    current_user = Etc.getpwuid.name
+    metadata = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      create_metadata_file(
+        File.join(srcdir, 'tpkg.xml'),
+        :change => { 'name' => 'cronpkg' },
+        :files => {
+          'etc/crontab_user' => { 'crontab' => {'user' => 'BoguS'} }})
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    fake_filename = '/path/to/cronpkg-1.0.tpkg'
+    metadata[:filename] = fake_filename
+    Dir.mktmpdir('testroot') do |testroot|
+      testbase = "#{testroot}/opt/tpkg"
+      not_my_part_one = <<-EOF.gsub(/^\s+/, '')
+        * * * * * /this/is/not/a/tpkg/cronjob
+        EOF
+      my_part_one = <<-EOF.gsub(/^\s+/, '')
+        ### TPKG START - #{testbase} - #{File.basename(metadata[:filename])}
+        * * * * * /this/is/my/crontab
+        ### TPKG END - #{testbase} - #{File.basename(metadata[:filename])}
+        EOF
+      not_my_part_two = <<-EOF.gsub(/^\s+/, '')
+        ### TPKG START - #{testbase} - someotherpkg-2.34.tpkg
+        * * * * * /this/is/not/my/crontab
+        ### TPKG END - #{testbase} - someotherpkg-2.34.tpkg
+        ### TPKG START - /path/to/other/base - #{File.basename(metadata[:filename])}
+        * * * * * /this/is/not/my/crontab
+        ### TPKG END - /path/to/other/base - #{File.basename(metadata[:filename])}
+        EOF
+      my_part_two = <<-EOF.gsub(/^\s+/, '')
+        ### TPKG START - #{testbase} - #{File.basename(metadata[:filename])}
+        * * * * * /this/is/my/crontab
+        ### TPKG END - #{testbase} - #{File.basename(metadata[:filename])}
+        EOF
+      user_crontab = Tempfile.new('tpkgtest_cron')
+      user_crontab.write not_my_part_one + my_part_one + not_my_part_two + my_part_two
+      user_crontab.close
+      tpkg = Tpkg.new(
+        :file_system_root => testroot,
+        :cmd_crontab => File.join(TESTCMDDIR, "crontab -f #{user_crontab.path}"))
+      tpkg.remove_crontab_file(metadata, current_user)
+      user_crontab.open
+      assert_equal(not_my_part_one + not_my_part_two, user_crontab.read)
+    end
+  end
+
+  def teardown
+    Facter.unstub(:[])
+  end
+end