tpkg 2.3.3 → 2.3.4

data/test/test_os_redhat.rb

@@ -0,0 +1,124 @@
+#
+# Tests Red Hat OS abstraction code
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+# Make private methods public so that we can test them
+class Tpkg::OS::RedHat
+  public :create_rpm
+end
+
+class TpkgOSRedHatTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    @redhat = Tpkg::OS::RedHat.new(
+      :yumcmd => File.join(TESTCMDDIR, 'redhat/yum'),
+      )
+  end
+  
+  def test_supported
+    fact = Facter::Util::Fact.new('operatingsystem')
+    Facter.stubs(:[]).returns(fact)
+    fact.stubs(:value).returns('RedHat')
+    assert Tpkg::OS::RedHat.supported?
+    fact.stubs(:value).returns('CentOS')
+    assert Tpkg::OS::RedHat.supported?
+    fact.stubs(:value).returns('Fedora')
+    assert Tpkg::OS::RedHat.supported?
+    fact.stubs(:value).returns('Other')
+    refute Tpkg::OS::RedHat.supported?
+  end
+  def test_initialize
+    [:yumcmd, :rpmcmd, :rpmbuildcmd].each do |cmdvar|
+      redhat = Tpkg::OS::RedHat.new(cmdvar => TESTCMD)
+      assert_equal TESTCMD, redhat.instance_variable_get("@#{cmdvar}")
+      redhat = Tpkg::OS::RedHat.new(:testcmd => TESTCMD)
+      assert_equal TESTCMD, redhat.instance_variable_get("@#{cmdvar}")
+    end
+    [true, false].each do |quietval|
+      redhat = Tpkg::OS::RedHat.new(:quiet => quietval)
+      assert_equal quietval, redhat.instance_variable_get(:@quiet)
+    end
+    # Test that super is called
+    [true, false].each do |debugval|
+      redhat = Tpkg::OS::RedHat.new(:debug => debugval)
+      assert_equal debugval, redhat.instance_variable_get(:@debug)
+    end
+  end
+  def test_init_links
+    correct = (2..5).collect{|i| "/etc/rc.d/rc#{i}.d/S99script"}
+    assert_equal correct, @redhat.init_links('/path/to/init/script', {:init => {}})
+  end
+  def test_cron_dot_d_directory
+    assert_equal '/etc/cron.d', @redhat.cron_dot_d_directory
+  end
+  def test_available_native_packages
+    assert_equal(
+      [
+        {:metadata=>
+          {:name=>'curl', :version=>'7.19.7', :package_version=>'26.el6_2.4'},
+          :source=>:native_installed,
+          :prefer=>true},
+      ],
+      @redhat.available_native_packages('curl'))
+    assert_equal(
+      [
+        {:metadata=>
+          {:name=>'wget', :version=>'1.12', :package_version=>'1.4.el6'},
+          :source=>:native_available}
+      ],
+      @redhat.available_native_packages('wget'))
+    assert_equal [], @redhat.available_native_packages('bogus')
+  end
+  def test_install_native_package
+    redhat = Tpkg::OS::RedHat.new
+    redhat.expects(:system).with('yum -y install curl-7.19.7-26.el6_2.4')
+    redhat.install_native_package(
+      {:metadata => {:name => 'curl', :version => '7.19.7', :package_version => '26.el6_2.4'}})
+  end
+  def test_upgrade_native_package
+    redhat = Tpkg::OS::RedHat.new
+    redhat.expects(:system).with('yum -y install curl-7.19.7-26.el6_2.4')
+    redhat.install_native_package(
+      {:metadata => {:name => 'curl', :version => '7.19.7', :package_version => '26.el6_2.4'}})
+  end
+  def test_stub_native_pkg
+    metafile = File.join(TESTPKGDIR, 'tpkg-nativedeps.yml')
+    metatext = File.read(metafile)
+    metadata = Metadata.new(metatext, 'yml')
+    redhat = Tpkg::OS::RedHat.new(
+      :rpmbuildcmd => File.join(TESTCMDDIR, 'redhat/rpmbuild'))
+    redhat.expects(:create_rpm).returns('/path/to/rpm.rpm')
+    redhat.expects(:system).with('rpm -i /path/to/rpm.rpm')
+    redhat.stub_native_pkg({:metadata => metadata})
+  end
+  def test_remove_native_stub_pkg
+    metafile = File.join(TESTPKGDIR, 'tpkg-nativedeps.yml')
+    metatext = File.read(metafile)
+    metadata = Metadata.new(metatext, 'yml')
+    redhat = Tpkg::OS::RedHat.new
+    redhat.expects(:system).with('yum -y remove stub_for_testpkg')
+    redhat.remove_native_stub_pkg({:metadata => metadata})
+  end
+  def test_os_version
+    fact = Facter::Util::Fact.new('lsbmajdistrelease')
+    fact.stubs(:value).returns('6')
+    Facter.expects(:[]).with('lsbmajdistrelease').returns(fact).at_least_once
+    assert_equal '6', Tpkg::OS::RedHat.new.os_version
+  end
+  def test_create_rpm
+    # Test that rpmbuild is called with reasonable arguments
+    redhat = Tpkg::OS::RedHat.new(:quiet => true)
+    redhat.expects(:system).
+      with(regexp_matches(%r{rpmbuild -bb --define '_topdir .*' .*/SPECS/pkg.spec}))
+    redhat.create_rpm('test', [{:name => 'dep1'}, {:name => 'dep2'}])
+    # Test that, with a fake rpmbuild, the method produces the expected result
+    redhat = Tpkg::OS::RedHat.new(
+      :rpmbuildcmd => File.join(TESTCMDDIR, 'redhat/rpmbuild'))
+    fakerpm = redhat.create_rpm('test', [{:name => 'dep1'}, {:name => 'dep2'}])
+    assert_equal 'This is a fake rpm', File.read(fakerpm)
+    FileUtils.rm_f(fakerpm)
+  end
+end

data/test/test_os_solaris.rb

@@ -0,0 +1,85 @@
+#
+# Tests Solaris OS abstraction code
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgOSSolarisTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    @pkginfo = File.join(TESTCMDDIR, 'solaris/pkginfo')
+    @pkgutil = File.join(TESTCMDDIR, 'solaris/pkgutil')
+    @solaris = Tpkg::OS::Solaris.new(
+      :pkginfocmd => @pkginfo,
+      :pkgutilcmd => @pkgutil,
+      )
+  end
+  
+  def test_supported
+    fact = Facter::Util::Fact.new('operatingsystem')
+    Facter.expects(:[]).with('operatingsystem').returns(fact).at_least_once
+    fact.stubs(:value).returns('Solaris')
+    assert Tpkg::OS::Solaris.supported?
+    fact.stubs(:value).returns('Other')
+    refute Tpkg::OS::Solaris.supported?
+  end
+  def test_initialize
+    [:pkginfocmd, :pkgutilcmd].each do |cmdvar|
+      solaris = Tpkg::OS::Solaris.new(cmdvar => TESTCMD)
+      assert_equal TESTCMD, solaris.instance_variable_get("@#{cmdvar}")
+      solaris = Tpkg::OS::Solaris.new(:testcmd => TESTCMD)
+      assert_equal TESTCMD, solaris.instance_variable_get("@#{cmdvar}")
+    end
+    # Test that super is called
+    [true, false].each do |debugval|
+      solaris = Tpkg::OS::Solaris.new(:debug => debugval)
+      assert_equal debugval, solaris.instance_variable_get(:@debug)
+    end
+  end
+  def test_init_links
+    correct = (2..3).collect{|i| "/etc/rc#{i}.d/S99script"}
+    assert_equal correct, @solaris.init_links('/path/to/init/script', {:init => {}})
+  end
+  def test_available_native_packages
+    assert_equal(
+      [
+        {:metadata=>
+          {:name=>'CSWcurl', :version => '7.25.0', :package_version => '2012.04.26'},
+          :source=>:native_installed,
+          :prefer=>true},
+        {:metadata=>
+          {:name=>'CSWcurl', :version => '7.25.0', :package_version => '2012.04.26'},
+          :source=>:native_available},
+      ],
+      @solaris.available_native_packages('CSWcurl'))
+    assert_equal(
+      [
+        {:metadata=>
+          {:name=>'CSWwget', :version=>'1.13.4', :package_version=>'2012.05.12'},
+          :source=>:native_available},
+      ],
+      @solaris.available_native_packages('CSWwget'))
+    assert_equal(
+      [
+        {:metadata=>
+          {:name=>'SUNWzfsu', :version=>'11.10.0', :package_version=>'2006.05.18.01.46'},
+          :source=>:native_installed,
+          :prefer=>true},
+      ],
+      @solaris.available_native_packages('SUNWzfsu'))
+    assert_equal [], @solaris.available_native_packages('bogus')
+  end
+  def test_native_pkg_to_install_string
+    assert_equal 'pkg-1.0,REV=1', @solaris.native_pkg_to_install_string({:metadata => {:name => 'pkg', :version => '1.0', :package_version => '1'}})
+    assert_equal 'pkg-1.0', @solaris.native_pkg_to_install_string({:metadata => {:name => 'pkg', :version => '1.0'}})
+  end
+  def test_install_native_package
+    @solaris.expects(:system).with("#{@pkgutil} -y -i CSWcurl-7.25.0,REV=2012.04.26")
+    @solaris.install_native_package({:metadata => {:name => 'CSWcurl', :version => '7.25.0', :package_version => '2012.04.26'}})
+  end
+  def test_upgrade_native_package
+    @solaris.expects(:system).with("#{@pkgutil} -y -u CSWcurl-7.25.0,REV=2012.04.26")
+    @solaris.upgrade_native_package({:metadata => {:name => 'CSWcurl', :version => '7.25.0', :package_version => '2012.04.26'}})
+  end
+end

data/test/test_os_windows.rb

@@ -0,0 +1,26 @@
+#
+# Tests Windows OS abstraction code
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgOSWindowsTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    @windows = Tpkg::OS::Windows.new
+  end
+  
+  def test_supported
+    fact = Facter::Util::Fact.new('operatingsystem')
+    Facter.expects(:[]).with('operatingsystem').returns(fact).at_least_once
+    fact.stubs(:value).returns('windows')
+    assert Tpkg::OS::Windows.supported?
+    fact.stubs(:value).returns('Other')
+    refute Tpkg::OS::Windows.supported?
+  end
+  
+  def test_sudo_default
+    refute @windows.sudo_default?
+  end
+end

data/test/test_query.rb

@@ -0,0 +1,134 @@
+
+
+#
+# Test tpkg's query features
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgQueryTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # temp dir that will automatically get deleted at end of test run, can be
+    # used for storing packages
+    @tempoutdir = Dir.mktmpdir('tempoutdir')
+
+    # Make up our regular test package
+    @pkgfile = make_package(:output_directory => @tempoutdir)
+  end
+
+  def test_metadata_for_installed_packages
+    Dir.mktmpdir('testbase') do |testbase|
+      apkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'a', 'version' => '2.0' }, :remove => ['operatingsystem', 'architecture'])
+      tpkg = Tpkg.new(:base => testbase, :sources => [apkg])
+      tpkg.install(['a'], PASSPHRASE)
+      metadata = tpkg.metadata_for_installed_packages
+      assert_equal(1, metadata.length)
+      assert_equal('a', metadata.first[:name])
+      FileUtils.rm_f(apkg)
+    end
+  end
+  
+  def test_installed_packages
+    Dir.mktmpdir('testbase') do |testbase|
+      apkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'a', 'version' => '2.0' }, :remove => ['operatingsystem', 'architecture'])
+      bpkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'b', 'version' => '2.0' }, :remove => ['operatingsystem', 'architecture'])
+      tpkg = Tpkg.new(:base => testbase, :sources => [apkg, bpkg])
+      tpkg.install(['a', 'b'], PASSPHRASE)
+      
+      instpkgs = tpkg.installed_packages
+      assert_equal(2, instpkgs.length)
+      assert(instpkgs.any? {|instpkg| instpkg[:metadata][:name] == 'a'})
+      assert(instpkgs.any? {|instpkg| instpkg[:metadata][:name] == 'b'})
+      assert(instpkgs.all? {|instpkg| instpkg[:source] == :currently_installed})
+      assert(instpkgs.all? {|instpkg| instpkg[:prefer] == true})
+      
+      instpkgs = tpkg.installed_packages('b')
+      assert_equal(1, instpkgs.length)
+      assert_equal('b', instpkgs.first[:metadata][:name])
+      
+      FileUtils.rm_f(apkg)
+      FileUtils.rm_f(bpkg)
+    end
+  end
+  
+  def test_installed_packages_that_meet_requirement
+    Dir.mktmpdir('testbase') do |testbase|
+      tpkg = Tpkg.new(:base => testbase)
+      pkgfiles = []
+      ['1.0', '2.0'].each do |ver|
+        Dir.mktmpdir('srcdir') do |srcdir|
+          FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+          pkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'a', 'version' => ver }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+          tpkg.install([pkg], PASSPHRASE)
+          pkgfiles << pkg
+        end
+      end
+      result = tpkg.installed_packages_that_meet_requirement
+      assert_equal(2, result.length)
+      result = tpkg.installed_packages_that_meet_requirement({:name => 'a'})
+      assert_equal(2, result.length)
+      result = tpkg.installed_packages_that_meet_requirement({:name => 'a', :minimum_version => '2.0'})
+      assert_equal(1, result.length)
+      pkgfiles.each { |pkg| FileUtils.rm_f(pkg) }
+    end
+  end
+  
+  def test_files_for_installed_packages
+    pkgfiles = []
+    # Make up a couple of packages with different files in them so that
+    # they don't conflict
+    ['a', 'b'].each do |pkgname|
+      Dir.mktmpdir('srcdir') do |srcdir|
+        FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+        FileUtils.mkdir_p(File.join(srcdir, 'reloc', 'directory'))
+        File.open(File.join(srcdir, 'reloc', 'directory', pkgname), 'w') do |file|
+          file.puts pkgname
+        end
+        pkgfiles << make_package(:output_directory => @tempoutdir, :change => {'name' => pkgname}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      end
+    end
+    
+    Dir.mktmpdir('testbase') do |testbase|
+      tpkg = Tpkg.new(:base => testbase, :sources => pkgfiles)
+      tpkg.install(['a', 'b'], PASSPHRASE)
+      
+      files = tpkg.files_for_installed_packages
+      assert_equal(2, files.length)
+      files.each do |pkgfile, fip|
+        assert_equal(0, fip[:root].length)  # Neither package has non-relocatable files
+        assert_equal(2, fip[:reloc].length)  # Each package has two relocatable files (a directory and a file)
+        pkgname = fip[:metadata][:name]
+        assert_equal(File.join('directory', ''), fip[:reloc].first)
+        assert_equal(File.join('directory', pkgname), fip[:reloc].last)
+        assert_equal(File.join(testbase, 'directory', ''), fip[:normalized].first)
+        assert_equal(File.join(testbase, 'directory', pkgname), fip[:normalized].last)
+      end
+      
+      files = tpkg.files_for_installed_packages(pkgfiles.first)
+      assert_equal(1, files.length)
+    end
+    
+    pkgfiles.each { |pkg| FileUtils.rm_f(pkg) }
+  end
+  
+  def test_files_in_package
+    files = Tpkg::files_in_package(@pkgfile)
+    assert_equal(0, files[:root].length)
+    pwd = Dir.pwd
+    Dir.chdir(File.join(TESTPKGDIR, 'reloc'))
+    reloc_expected = Dir.glob('*')
+    Dir.chdir(pwd)
+    assert_equal(reloc_expected.length, files[:reloc].length)
+    reloc_expected.each { |r| assert(files[:reloc].include?(r)) }
+    files[:reloc].each { |r| assert(reloc_expected.include?(r)) }
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@tempoutdir)
+  end
+end
+

data/test/test_remove.rb

@@ -0,0 +1,539 @@
+#
+# Test tpkg's ability to remove packages
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgRemoveTests < Test::Unit::TestCase
+  include TpkgTests
+
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # temp dir that will automatically get deleted at end of test run, can be
+    # used for storing packages
+    @tempoutdir = Dir.mktmpdir('tempoutdir')
+    
+    # Pretend to be an OS with init script support
+    fact = Facter::Util::Fact.new('operatingsystem')
+    fact.stubs(:value).returns('RedHat')
+    Facter.stubs(:[]).returns(fact)
+  end
+
+  def test_remove_dep
+    # b and c depends on a
+    # d depends on b
+    pkgfiles = []
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'a' }, :remove => ['operatingsystem', 'architecture'])
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'b' }, :remove => ['operatingsystem', 'architecture'], :dependencies => {'a' => {}})
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'c' }, :remove => ['operatingsystem', 'architecture'], :dependencies => {'a' => {}})
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'd' }, :remove => ['operatingsystem', 'architecture'], :dependencies => {'b' => {}})
+    Dir.mktmpdir('testbase') do |testbase|
+      tpkg = Tpkg.new(:base => testbase, :sources => pkgfiles)
+      assert_nothing_raised { tpkg.install(pkgfiles, PASSPHRASE) }
+      
+      # a, b, c and d are installed
+      metadata = tpkg.metadata_for_installed_packages
+      assert_equal(4, metadata.length)
+      
+      # removing a with :remove_all_dep option should remove b, c and d as well
+      assert_nothing_raised { tpkg.remove(['a'], {:remove_all_dep => true})}
+      metadata = tpkg.metadata_for_installed_packages
+      assert_equal(0, metadata.length)
+    end
+  end
+
+  def test_remove_prereq
+    # e requires c
+    # d requires c and b
+    # c requires a
+    pkgfiles = []
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'a' }, :remove => ['operatingsystem', 'architecture'])
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'b' }, :remove => ['operatingsystem', 'architecture'])
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'c' }, :remove => ['operatingsystem', 'architecture'], :dependencies => {'a' => {}})
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'd' }, :remove => ['operatingsystem', 'architecture'], :dependencies => {'c' => {}, 'b' => {}})
+    pkgfiles << make_package(:output_directory => @tempoutdir, :change => { 'name' => 'e' }, :remove => ['operatingsystem', 'architecture'], :dependencies => {'c' => {}})
+    Dir.mktmpdir('testbase') do |testbase|
+      tpkg = Tpkg.new(:base => testbase, :sources => pkgfiles)
+      assert_nothing_raised { tpkg.install(pkgfiles, PASSPHRASE) }
+      
+      # a, b, c, d and e are installed
+      metadata = tpkg.metadata_for_installed_packages
+      assert_equal(5, metadata.length)
+      
+      # removing d with :remove_all_prereq option should remove d and b only and not c and a because
+      # e still depends on c
+      assert_nothing_raised { tpkg.remove(['d'], {:remove_all_prereq => true})}
+      metadata = tpkg.metadata_for_installed_packages
+      assert_equal(3, metadata.length)
+    end
+  end
+  
+  def test_remove
+    pkgfiles = []
+    # Make up a couple of packages with different files in them so that
+    # they don't conflict
+    ['a', 'b'].each do |pkgname|
+      Dir.mktmpdir('srcdir') do |srcdir|
+        FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+        FileUtils.mkdir_p(File.join(srcdir, 'reloc', 'directory'))
+        File.open(File.join(srcdir, 'reloc', 'directory', pkgname), 'w') do |file|
+          file.puts pkgname
+        end
+        File.open(File.join(srcdir, 'reloc', 'directory', "#{pkgname}.conf"), 'w') do |file|
+          file.puts pkgname
+        end
+        pkgfiles << make_package(:output_directory => @tempoutdir, :change => {'name' => pkgname}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'], :files => { "directory/#{pkgname}.conf" => { 'config' => true}})
+      end
+    end
+    
+    Dir.mktmpdir('testroot') do |testroot|
+      testbase = File.join(testroot, 'home', 'tpkg')
+      FileUtils.mkdir_p(testbase)
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => pkgfiles)
+      
+      tpkg.install(['a', 'b'], PASSPHRASE)
+      
+      assert_nothing_raised { tpkg.remove(['a']) }
+      
+      assert(!File.exist?(File.join(testbase, 'directory', 'a')))
+      assert(File.exist?(File.join(testbase, 'directory', 'b')))
+      
+      assert_nothing_raised { tpkg.remove(['b']) }
+      
+      assert(!File.exist?(File.join(testbase, 'directory', 'b')))
+      assert(!File.exist?(File.join(testbase, 'directory')))
+      assert(File.exist?(File.join(testbase)))
+      
+      # Test that we can use package filename for remove
+      tpkg.install(['a', 'b'], PASSPHRASE)
+      filenames = pkgfiles.collect{ |pkgfile| File.basename(pkgfile)}
+      assert_nothing_raised { tpkg.remove(filenames) }
+      assert(!File.exist?(File.join(testbase, 'directory', 'a')))
+      assert(!File.exist?(File.join(testbase, 'directory', 'b')))
+      assert(!File.exist?(File.join(testbase, 'directory')))
+      assert(File.exist?(File.join(testbase)))
+      
+      # Remove a file manually.  tpkg.remove should warn that the file
+      # is missing but not abort.
+      tpkg.install(['a'], PASSPHRASE)
+      File.delete(File.join(testbase, 'directory', 'a'))
+      puts "Missing file warning expected here:"
+      assert_nothing_raised { tpkg.remove(['a']) }
+      
+      # Insert another file into the directory.  tpkg.remove should warn
+      # that the directory isn't empty but not abort.
+      tpkg.install(['a'], PASSPHRASE)
+      File.open(File.join(testbase, 'directory', 'anotherfile'), 'w') do |file|
+        file.puts 'junk'
+      end
+      assert_nothing_raised { tpkg.remove(['a']) }
+      
+      # Test removing all packages by passing no arguments to remove
+      tpkg.install(['a', 'b'], PASSPHRASE)
+      assert_nothing_raised { tpkg.remove }
+      assert(!File.exist?(File.join(testbase, 'directory', 'a')))
+      assert(!File.exist?(File.join(testbase, 'directory', 'b')))
+      
+      # Test removing config files
+      # If config file has been modified, then tpkg should not remove it
+      tpkg.install(['a', 'b'], PASSPHRASE)
+      File.open(File.join(testbase, 'directory', "a.conf"), 'w') do |file|
+        file.puts "Modified"
+      end
+      assert_nothing_raised { tpkg.remove }
+      assert(File.exist?(File.join(testbase, 'directory', 'a.conf')))
+      assert(!File.exist?(File.join(testbase, 'directory', 'b.conf')))
+    end
+    
+    # Clean up
+    pkgfiles.each { |pkgfile| FileUtils.rm_f(pkgfile) }
+    
+    # Test that preremove/postremove are run at the right points
+    #   Make up a package with scripts that create files so we can check timestamps
+    # Also, test tpkg should chdir to package unpack directory before calling
+    # pre/post/install/remove scripts
+    scriptfiles = {}
+    pkgfile = nil
+    
+    Dir.mktmpdir('srcdir') do |srcdir|
+      # Include the stock test package contents
+      system("#{Tpkg::find_tar} -C #{TESTPKGDIR} --exclude .svn -cf - . | #{Tpkg::find_tar} -C #{srcdir} -xf -")
+      
+      # Add some dummy file for testing relative path
+      File.open(File.join(srcdir, "dummyfile"), 'w') do |file|
+        file.puts("hello world")
+      end
+      
+      # Then add scripts
+      ['preremove', 'postremove'].each do |script|
+        File.open(File.join(srcdir, script), 'w') do |scriptfile|
+          # We have each script write to a temporary file (so that we can
+          # check the timestamp of that file to ensure proper ordering) and
+          # print out the name of the file (just to aid debugging)
+          tmpfile = Tempfile.new('tpkgtest_script')
+          scriptfiles[script] = tmpfile
+          scriptfile.puts('#!/bin/sh')
+          # Test that tpkg set $TPKG_HOME before running the script
+          scriptfile.puts('echo TPKG_HOME: \"$TPKG_HOME\"')
+          # Test that we had chdir'ed to package unpack directory
+          scriptfile.puts('ls dummyfile || exit 1')
+          scriptfile.puts('test -n "$TPKG_HOME" || exit 1')
+          scriptfile.puts("echo #{script} > #{tmpfile.path}")
+          scriptfile.puts("echo #{script}: #{tmpfile.path}")
+          scriptfile.puts('sleep 1')
+        end
+        File.chmod(0755, File.join(srcdir, script))
+      end
+      # Change name of package so that the file doesn't conflict with @pkgfile
+      pkgfile = make_package(:output_directory => @tempoutdir, :source_directory => srcdir, :change => {'name' => 'scriptpkg'}, :remove => ['operatingsystem', 'architecture'])
+    end
+    
+    # Install the script package
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkgfile])
+      assert_nothing_raised { tpkg.install([pkgfile], PASSPHRASE) }
+      assert_nothing_raised { tpkg.remove(['scriptpkg']) }
+      # FIXME: Need a way to test that the package remove occurred between the two scripts
+      assert(File.stat(scriptfiles['preremove'].path).mtime < File.stat(scriptfiles['postremove'].path).mtime)
+    end
+    
+    # Test init script handling
+    pkg = nil
+    pkg2 = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      FileUtils.mkdir_p(File.join(srcdir, 'reloc'))
+      File.open(File.join(srcdir, 'reloc', 'myinit'), 'w') do |file|
+        file.puts('init script')
+      end
+      pkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'initpkg' }, :source_directory => srcdir, :files => { 'myinit' => { 'init' => {} } }, :remove => ['operatingsystem', 'architecture'])
+      pkg2 = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'initpkg2' }, :source_directory => srcdir, :files => { 'myinit' => { 'init' => {} } }, :remove => ['operatingsystem', 'architecture'])
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkg,pkg2])
+      tpkg2 = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg2'), :sources => [pkg,pkg2])
+      metadata = Tpkg::metadata_from_package(pkg)
+      metadata2 = Tpkg::metadata_from_package(pkg2)
+      tpkg.install([pkg], PASSPHRASE)
+      tpkg2.install([pkg2], PASSPHRASE)
+      tpkg.remove(['initpkg'])
+      tpkg.init_links(metadata).each do |link, init_script|
+        assert(!File.exist?(link) && !File.symlink?(link))
+      end
+      # Test the handling of packages with conflicting init scripts.
+      # The link should end up named with a '1' at the end.
+      # Make sure it is still there after the removal of 'initpkg'
+      tpkg2.init_links(metadata2).each do |link, init_script|
+        assert(File.symlink?(link + '1'))
+        assert_equal(init_script, File.readlink(link + '1'))
+      end
+      # Now remove 'initpkg2' and verify that it is gone
+      tpkg2.remove(['initpkg2'])
+      tpkg2.init_links(metadata2).each do |link, init_script|
+        assert(!File.exist?(link + '1') && !File.symlink?(link + '1'))
+      end
+    end
+    
+    # Test external handling
+    extname = 'testext'
+    extdata = "This is a test of an external hook\nwith multiple lines\nof data"
+    pkg = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      pkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'externalpkg' }, :externals => { extname => { 'data' => extdata } }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      externalsdir = File.join(testroot, 'usr', 'lib', 'tpkg', 'externals')
+      FileUtils.mkdir_p(externalsdir)
+      # Create an external script which puts the data into a file named after
+      # the package, and removes any files named after the package on removal.
+      Dir.mktmpdir('externaltest') do |externaltestdir|
+        extscript = File.join(externalsdir, extname)
+        File.open(extscript, 'w') do |file|
+          file.puts <<EOF
+#!/bin/sh
+set -e
+
+pkgfile=$1
+operation=$2
+
+requestfile=#{externaltestdir}/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+	# Dump in the data passed to us on stdin
+	cat >> $tmpfile
+	;;
+'remove')
+	rm -f "$requestfile".*
+	# Avoid generating SIGPIPE in tpkg
+	cat > /dev/null
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+EOF
+        end
+        File.chmod(0755, extscript)
+        # And run the test
+        tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkg])
+        tpkg.install([pkg], PASSPHRASE)
+        assert(Dir.entries(externaltestdir).length > 2)
+        assert_nothing_raised { tpkg.remove(['externalpkg']) }
+        # . and ..
+        assert_equal(2, Dir.entries(externaltestdir).length)
+      end
+    end
+    
+    # Test handling of external with datafile
+    # The datafile is only read at install, not at remove, so this really
+    # doesn't test a unique code path.  Rather it just serves to verify that
+    # nothing breaks on removal in the face of a datafile being defined.
+    extname = 'testext'
+    extdata = "This is a test of an external hook\nwith multiple lines\nof data from a datafile"
+    pkg = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      # Create the datafile
+      File.open(File.join(srcdir, 'datafile'), 'w') do |file|
+        file.print(extdata)
+      end
+      pkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'externalpkg' }, :externals => { extname => { 'datafile' => './datafile' } }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      externalsdir = File.join(testroot, 'usr', 'lib', 'tpkg', 'externals')
+      FileUtils.mkdir_p(externalsdir)
+      # Create an external script which puts the data into a file named after
+      # the package, and removes any files named after the package on removal.
+      Dir.mktmpdir('externaltest') do |externaltestdir|
+        extscript = File.join(externalsdir, extname)
+        File.open(extscript, 'w') do |file|
+          file.puts <<EOF
+#!/bin/sh
+set -e
+
+pkgfile=$1
+operation=$2
+
+requestfile=#{externaltestdir}/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+	# Dump in the data passed to us on stdin
+	cat >> $tmpfile
+	;;
+'remove')
+	rm -f "$requestfile".*
+	# Avoid generating SIGPIPE in tpkg
+	cat > /dev/null
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+EOF
+        end
+        File.chmod(0755, extscript)
+        # And run the test
+        tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkg])
+        tpkg.install([pkg], PASSPHRASE)
+        assert(Dir.entries(externaltestdir).length > 2)
+        assert_nothing_raised { tpkg.remove(['externalpkg']) }
+        # . and ..
+        assert_equal(2, Dir.entries(externaltestdir).length)
+      end
+    end
+
+    # Test handling of external with datascript
+    # The datascript is only run at install, not at remove, so this really
+    # doesn't test a unique code path.  Rather it just serves to verify that
+    # nothing breaks on removal in the face of a datascript being defined.
+    extname = 'testext'
+    extdata = "This is a test of an external hook\nwith multiple lines\nof data from a datascript"
+    pkg = nil
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      # Create the datascript
+      File.open(File.join(srcdir, 'datascript'), 'w') do |file|
+        file.puts('#!/bin/sh')
+        # echo may or may not add a trailing \n depending on which echo we end
+        # up, so use printf, which doesn't add things.
+        file.puts("printf \"#{extdata}\"")
+      end
+      File.chmod(0755, File.join(srcdir, 'datascript'))
+      pkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'externalpkg' }, :externals => { extname => { 'datascript' => './datascript' } }, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      externalsdir = File.join(testroot, 'usr', 'lib', 'tpkg', 'externals')
+      FileUtils.mkdir_p(externalsdir)
+      # Create an external script which puts the data into a file named after
+      # the package, and removes any files named after the package on removal.
+      Dir.mktmpdir('externaltest') do |externaltestdir|
+        extscript = File.join(externalsdir, extname)
+        File.open(extscript, 'w') do |file|
+          file.puts <<EOF
+#!/bin/sh
+set -e
+
+pkgfile=$1
+operation=$2
+
+requestfile=#{externaltestdir}/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+	# Dump in the data passed to us on stdin
+	cat >> $tmpfile
+	;;
+'remove')
+	rm -f "$requestfile".*
+	# Avoid generating SIGPIPE in tpkg
+	cat > /dev/null
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+EOF
+        end
+        File.chmod(0755, extscript)
+        # And run the test
+        tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkg])
+        tpkg.install([pkg], PASSPHRASE)
+        assert(Dir.entries(externaltestdir).length > 2)
+        assert_nothing_raised { tpkg.remove(['externalpkg']) }
+        # . and ..
+        assert_equal(2, Dir.entries(externaltestdir).length)
+      end
+    end
+  end
+  
+  def test_remove_init_scripts
+    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' => 'initpkg'  }, :files => { 'etc/init.d/initscript' => { 'init' => {} } })
+      metadata = Metadata.new(File.read(File.join(srcdir, 'tpkg.xml')), 'xml')
+    end
+    
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'))
+      
+      link = nil
+      init_script = nil
+      tpkg.init_links(metadata).each do |l, is|
+        link = l
+        init_script = is
+      end
+      
+      # init_links returns an empty list on platforms where tpkg doesn't have
+      # init script support
+      if link
+        # Standard symlink using the base name is removed
+        FileUtils.mkdir_p(File.dirname(link))
+        File.symlink(init_script, link)
+        tpkg.remove_init_scripts(metadata)
+        assert(!File.exist?(link) && !File.symlink?(link))
+        
+        # Links with suffixes from 1..9 are removed
+        1.upto(9) do |i|
+          FileUtils.rm(Dir.glob(link + '*'))
+          File.symlink(init_script, link + i.to_s)
+          File.symlink(init_script, link + '1') if (i != 1)
+          2.upto(i-1) do |j|
+            File.symlink('somethingelse', link + j.to_s)
+          end
+          tpkg.remove_init_scripts(metadata)
+          assert(!File.exist?(link) && !File.symlink?(link))
+          assert(!File.exist?(link + '1') && !File.symlink?(link + '1'))
+          2.upto(i-1) do |j|
+            assert(File.symlink?(link + j.to_s))
+            assert_equal('somethingelse', File.readlink(link + j.to_s))
+          end
+        end
+        
+        # Links with suffixes of 0 or 10 are left alone
+        File.symlink(init_script, link + '0')
+        File.symlink(init_script, link + '10')
+        tpkg.remove_init_scripts(metadata)
+        assert(File.symlink?(link + '0'))
+        assert_equal(init_script, File.readlink(link + '0'))
+        assert(File.symlink?(link + '10'))
+        assert_equal(init_script, File.readlink(link + '10'))
+        
+        # Running as non-root, permissions issues prevent link removal, warning
+        FileUtils.rm(Dir.glob(link + '*'))
+        File.symlink(init_script, link)
+        File.chmod(0000, File.dirname(link))
+        assert_nothing_raised { tpkg.remove_init_scripts(metadata) }
+        # FIXME: look for warning in stderr
+        File.chmod(0755, File.dirname(link))
+        assert(File.symlink?(link))
+        assert_equal(init_script, File.readlink(link))
+      end
+    end
+  end
+  
+  # Test that the remove method calls remove_crontabs as appropriate
+  def test_remove_remove_crontabs
+    # FIXME
+  end
+  
+  def test_skip_remove_stop
+    # Make a test package with an init script
+    pkg = nil
+    tmpfile = Tempfile.new('tpkgtest_script')
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      FileUtils.mkdir_p(File.join(srcdir, 'reloc'))
+      initscript = File.join(srcdir, 'reloc', 'myinit')
+      File.open(initscript, 'w') do |file|
+        file.puts('#!/bin/sh')
+        file.puts('case "$1" in')
+        file.puts("'stop')")
+        file.puts("  echo 'test_skip_remove_stop' > #{tmpfile.path}")
+        file.puts('  ;;')
+        file.puts('esac')
+      end
+      File.chmod(0755, initscript)
+      pkg = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'initpkg' }, :source_directory => srcdir, :files => { 'myinit' => { 'init' => {} } }, :remove => ['operatingsystem', 'architecture'])
+    end
+    
+    # Removing the package without skip_remove_stop should run the init script
+    # with a "stop" argument on package removal
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkg])
+      tpkg.install([pkg], PASSPHRASE)
+      tpkg.remove(['initpkg'])
+      assert_equal("test_skip_remove_stop\n", File.read(tmpfile.path))
+    end
+    
+    # Clear out the temp file to reset
+    File.open(tmpfile.path, 'w') {}
+    
+    # Removing the package with skip_remove_stop should not run the init
+    # script on package removal
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => [pkg])
+      tpkg.install([pkg], PASSPHRASE)
+      tpkg.remove(['initpkg'], :skip_remove_stop => true)
+      assert_equal("", File.read(tmpfile.path))
+    end
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@tempoutdir)
+  end
+end
+