tpkg 2.3.3 → 2.3.4

data/test/test_install.rb

@@ -0,0 +1,186 @@
+
+
+#
+# Test tpkg's ability to install packages
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgInstallTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # Make up our regular test package
+    @pkgfile = make_package(:remove => ['operatingsystem', 'architecture'])
+    @testroot = Dir.mktmpdir('testroot')
+  end
+  
+  def test_install_by_filename
+    testbase = File.join(@testroot, 'home', 'tpkg')
+    FileUtils.mkdir_p(testbase)
+    tpkg = Tpkg.new(:file_system_root => @testroot, :base => File.join('home', 'tpkg'), :sources => [@pkgfile])
+    
+    assert_nothing_raised { tpkg.install([@pkgfile], PASSPHRASE) }
+    
+    # Check that the files from the package ended up in the right place
+    assert(File.exist?(File.join(testbase, 'file')))
+    assert_equal(IO.read(File.join(TESTPKGDIR, 'reloc', 'file')), IO.read(File.join(testbase, 'file')))
+    assert(File.exist?(File.join(testbase, 'encfile')))
+    assert_equal(IO.read(File.join(TESTPKGDIR, 'reloc', 'encfile')), IO.read(File.join(testbase, 'encfile')))
+  end
+  
+  def test_install_by_pkg_name
+    testbase = File.join(@testroot, 'home', 'tpkg')
+    FileUtils.mkdir_p(testbase)
+    tpkg = Tpkg.new(:file_system_root => @testroot, :base => File.join('home', 'tpkg'), :sources => [@pkgfile])
+    
+    assert_nothing_raised { tpkg.install(['testpkg'], PASSPHRASE) }
+    
+    # Check that the files from the package ended up in the right place
+    assert(File.exist?(File.join(testbase, 'file')))
+    assert_equal(IO.read(File.join(TESTPKGDIR, 'reloc', 'file')), IO.read(File.join(testbase, 'file')))
+    assert(File.exist?(File.join(testbase, 'encfile')))
+    assert_equal(IO.read(File.join(TESTPKGDIR, 'reloc', 'encfile')), IO.read(File.join(testbase, 'encfile')))
+    
+  end
+  
+  # Test that if packages have dependencies on each others, then they
+  # should installed in the correct order
+  def test_install_order
+
+    @pkgfiles = []
+    ['a', 'b', 'c'].each do |pkgname|
+      Dir.mktmpdir('srcdir') do |srcdir|
+        FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+        FileUtils.mkdir(File.join(srcdir, 'reloc'))
+        File.open(File.join(srcdir, 'reloc', pkgname), 'w') do |file|
+          file.puts pkgname
+        end
+        
+        # make a depends on c and c depends on b
+        deps = {}
+        if pkgname == 'a'
+          deps['c'] = {}
+        elsif pkgname == 'c'
+          deps['b'] = {}
+        end
+        
+        # make a postinstall script that sleeps for 1 second. That way we
+        # have enough time between each installation to determine the order of how they 
+        # were installed
+        File.open(File.join(srcdir, 'postinstall'), 'w') do | file |
+          file.puts "#!/bin/bash\nsleep 1"
+        end
+        File.chmod(0755, File.join(srcdir, 'postinstall'))
+        
+        @pkgfiles << make_package(:change => {'name' => pkgname}, :source_directory => srcdir, :dependencies => deps, :remove => ['operatingsystem', 'architecture'])
+      end
+    end
+
+    tpkg = Tpkg.new(:file_system_root => @testroot, :base => File.join('home', 'tpkg'), :sources => @pkgfiles)
+    tpkg.install(['a'], PASSPHRASE)
+
+    actime = File.new(File.join(File.join(@testroot,'home','tpkg', 'a'))).ctime
+    bctime = File.new(File.join(File.join(@testroot,'home','tpkg', 'b'))).ctime
+    cctime = File.new(File.join(File.join(@testroot,'home','tpkg', 'c'))).ctime
+    assert(actime > cctime)
+    assert(cctime > bctime)
+
+  end
+
+  # Verify that we can install multiple versions of the same package
+  def test_install_multiple_versions
+    pkgfiles = []
+    ['1', '2'].each do |pkgver|
+      pkgfiles << make_package(:change => {'version' => pkgver, 'name' => 'versiontest'}, :remove => ['operatingsystem', 'architecture'])
+    end
+    
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => pkgfiles)
+      assert_nothing_raised { tpkg.install(['versiontest=1'], PASSPHRASE) }
+      assert_nothing_raised { tpkg.install(['versiontest=2'], PASSPHRASE) }
+      metadata = tpkg.metadata_for_installed_packages
+      # verify that both of them are installed
+      assert_equal(metadata.size, 2)
+    end
+    
+    # verify we can install in reverse order
+    Dir.mktmpdir('testroot') do |testroot|
+      tpkg = Tpkg.new(:file_system_root => testroot, :base => File.join('home', 'tpkg'), :sources => pkgfiles)
+      assert_nothing_raised { tpkg.install(['versiontest=2'], PASSPHRASE) }
+      assert_nothing_raised { tpkg.install(['versiontest=1'], PASSPHRASE) }
+      metadata = tpkg.metadata_for_installed_packages
+      # verify that both of them are installed
+      assert_equal(metadata.size, 2)
+    end
+    
+    pkgfiles.each { |pkgfile| FileUtils.rm_f(pkgfile) }
+  end
+  
+  def test_install_with_externals
+    externalspkg = nil
+    extname1 = 'testext1'
+    extdata1 = "This is a test of an external hook\nwith multiple lines\nof data"
+    extname2 = 'testext2'
+    extdata2 = "This is a test of a different external hook\nwith multiple lines\nof different data"
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(
+        File.join(TESTPKGDIR, 'tpkg-nofiles.xml'),
+        File.join(srcdir, 'tpkg.xml'))
+      externalspkg = make_package(
+        :change => { 'name' => 'externalpkg', 'version' => '1' },
+        :externals => { extname1 => {'data' => extdata1},
+                        extname2 => {'data' => extdata2} },
+        :source_directory => srcdir,
+        :remove => ['operatingsystem', 'architecture'])
+    end
+    Dir.mktmpdir('testroot') do |testroot|
+      # Make external scripts which write the data they receive to temporary
+      # files, so that we can verify the external scripts received the data
+      # properly.
+      exttmpfile1 = Tempfile.new('tpkgtest_external')
+      exttmpfile2 = Tempfile.new('tpkgtest_external')
+      externalsdir = File.join(testroot, 'usr', 'lib', 'tpkg', 'externals')
+      FileUtils.mkdir_p(externalsdir)
+      extscript1 = File.join(externalsdir, extname1)
+      extscript2 = File.join(externalsdir, extname2)
+      File.open(extscript1, 'w') do |file|
+        file.puts('#!/bin/sh')
+        # Operation (install/remove)
+        file.puts("echo $2 >> #{exttmpfile1.path}")
+        # Data
+        file.puts("cat >> #{exttmpfile1.path}")
+      end
+      File.open(extscript2, 'w') do |file|
+        file.puts('#!/bin/sh')
+        # Operation (install/remove)
+        file.puts("echo $2 >> #{exttmpfile2.path}")
+        # Data
+        file.puts("cat >> #{exttmpfile2.path}")
+      end
+      File.chmod(0755, extscript1)
+      File.chmod(0755, extscript2)
+      # And run the test
+      tpkg = Tpkg.new(
+        :file_system_root => testroot,
+        :base => File.join('home', 'tpkg'),
+        :sources => [externalspkg])
+      assert_nothing_raised { tpkg.install([externalspkg], PASSPHRASE) }
+      assert_equal("install\n#{extdata1}", IO.read(exttmpfile1.path))
+      assert_equal("install\n#{extdata2}", IO.read(exttmpfile2.path))
+    end
+    FileUtils.rm_f(externalspkg)
+  end
+  
+  def test_stub_native_pkg
+    # FIXME
+  end
+  
+  def teardown
+    FileUtils.rm_f(@pkgfile)
+    FileUtils.rm_rf(@testroot)
+  end
+end
+

data/test/test_lock.rb

@@ -0,0 +1,82 @@
+
+
+#
+# Test tpkg's ability to lock/unlock the package repository
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgLockTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # Make up our regular test package
+    @pkgfile = make_package(:remove => ['operatingsystem', 'architecture'])
+    
+    # Make a test repository
+    @testbase = Dir.mktmpdir('testbase')
+  end
+
+  def test_lock
+    # Lock the repo
+    tpkg = Tpkg.new(:base => @testbase)
+    assert_nothing_raised('lock') { tpkg.lock }
+    
+    # Verify that an operation requiring a lock works with this instance
+    assert_nothing_raised('install') { tpkg.install([@pkgfile], PASSPHRASE) }
+    
+    # Make a seperate instance of Tpkg using the same repo
+    tpkg2 = Tpkg.new(:base => @testbase)
+    # Verify that attempting a lock with this instance fails
+    assert_raise(RuntimeError, 'lock in other instance') { tpkg2.lock }
+    # Verify that an operation requiring a lock fails with this instance
+    assert_raise(RuntimeError, 'install in other instance') { tpkg2.install([@pkgfile], PASSPHRASE) }
+    # Verify that attempting to unlock this instance fails
+    # Decided to have it just warn rather than throw an exception
+    #assert_raise(RuntimeError, 'unlock in other instance') { tpkg2.unlock }
+    
+    # Re-verify that things work with the original instance
+    assert_nothing_raised('remove') { tpkg.remove(['testpkg']) }
+    
+    # Unlock the repo
+    assert_nothing_raised('unlock') { tpkg.unlock }
+  end
+  
+  def test_old_lock
+    # Create a lock that is more than 2 hours old
+    FileUtils.mkdir_p(File.join(@testbase, 'var', 'tpkg', 'lock'))
+    File.open(File.join(@testbase, 'var', 'tpkg', 'lock', 'pid'), 'w') { |file| file.puts($$) }
+    threehoursago = Time.at(Time.now - 60*60*3)
+    File.utime(threehoursago, threehoursago, File.join(@testbase, 'var', 'tpkg', 'lock'))
+    
+    tpkg = Tpkg.new(:base => @testbase)
+    
+    # Verify that tpkg will lock, removing the stale lock file
+    assert_nothing_raised('lock') { tpkg.lock }
+    assert_nothing_raised('unlock') { tpkg.unlock }
+  end
+  
+  def test_lock_force
+    # Create a lock
+    FileUtils.mkdir_p(File.join(@testbase, 'var', 'tpkg', 'lock'))
+    File.open(File.join(@testbase, 'var', 'tpkg', 'lock', 'pid'), 'w') { |file| file.puts($$) }
+    
+    # Verify that locking fails without the :lockforce option
+    tpkg = Tpkg.new(:base => @testbase)
+    assert_raise(RuntimeError) { tpkg.lock }
+    
+    # Set the :lockforce option
+    tpkg = Tpkg.new(:base => @testbase, :lockforce => true)
+    
+    # Verify that tpkg will lock, removing the lock file
+    assert_nothing_raised('lock') { tpkg.lock }
+    assert_nothing_raised('unlock') { tpkg.unlock }
+  end
+  
+  def teardown
+    FileUtils.rm_f(@pkgfile)
+    FileUtils.rm_rf(@testbase)
+  end
+end

data/test/test_make.rb

@@ -0,0 +1,410 @@
+#
+# Test tpkg's ability to make packages
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgMakeTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    @tar = Tpkg::find_tar
+    
+    @pkgdir = Dir.mktmpdir('pkgdir')
+    system("#{@tar} -C #{TESTPKGDIR} --exclude .svn --exclude tpkg-*.xml --exclude tpkg*.yml -cf - . | #{@tar} -C #{@pkgdir} -xf -")
+    # Set special permissions on a file so that we can verify they are
+    # preserved
+    File.chmod(0400, File.join(@pkgdir, 'reloc', 'file'))
+    @srcmode = File.stat(File.join(@pkgdir, 'reloc', 'file')).mode
+    @srcmtime = File.stat(File.join(@pkgdir, 'reloc', 'file')).mtime
+    # Insert a directory and symlink so that we can verify they are
+    # properly included in the package
+    Dir.mkdir(File.join(@pkgdir, 'reloc', 'directory'))
+    File.symlink('linktarget', File.join(@pkgdir, 'reloc', 'directory', 'link'))
+  end
+  
+  def verify_pkg(pkgfile)
+    Dir.mktmpdir('workdir') do |workdir|
+      assert(!pkgfile.nil? && pkgfile.kind_of?(String) && !pkgfile.empty?, 'make_package returned package filename')
+      assert(File.exist?(pkgfile), 'make_package returned package filename that exists')
+      
+      # Verify checksum.xml
+      #  We test verify_package_checksum in checksum.rb to make sure it works
+      assert_nothing_raised('checksum verify') { Tpkg::verify_package_checksum(pkgfile) }
+      
+      # Unpack the package
+      assert(system("#{@tar} -C #{workdir} -xf #{pkgfile}"), 'unpack package')
+      unpackdir = File.join(workdir, 'testpkg-1.0-1-os-architecture')
+      # Packages consist of directory containing checksum.xml and a tpkg.tar
+      # with the rest of the package contents.  Ensure that the package
+      # contains the right files and nothing else.
+      assert(File.exist?(File.join(unpackdir, 'checksum.xml')), 'checksum.xml in package')
+      tpkgfile = File.join(unpackdir, 'tpkg.tar')
+      assert(File.exist?(tpkgfile), 'tpkg.tar in package')
+      assert_equal(3, Dir.entries(workdir).length, 'nothing else in package top level')
+      assert_equal(4, Dir.entries(unpackdir).length, 'nothing else in package directory')
+      # Now unpack the tarball with the rest of the package contents
+      assert(system("#{@tar} -C #{unpackdir} -xf #{File.join(unpackdir, 'tpkg.tar')}"), 'unpack tpkg.tar')
+    
+      # Verify that tpkg.xml and our various test files were included in the
+      # package
+      assert(File.exist?(File.join(unpackdir, 'tpkg', 'tpkg.xml')), 'tpkg.xml in package')
+      assert(File.directory?(File.join(unpackdir, 'tpkg', 'reloc')), 'reloc in package')
+      assert_equal(5, Dir.entries(File.join(unpackdir, 'tpkg')).length, 'nothing else in tpkg directory') # ., .., reloc|root, tpkg.xml, file_metadata.bin
+      assert(File.exist?(File.join(unpackdir, 'tpkg', 'reloc', 'file')), 'generic file in package')
+      assert(File.directory?(File.join(unpackdir, 'tpkg', 'reloc', 'directory')), 'directory in package')
+      assert(File.symlink?(File.join(unpackdir, 'tpkg', 'reloc', 'directory', 'link')), 'link in package')
+      # Verify that permissions and modification timestamps were preserved
+      dstmode = File.stat(File.join(unpackdir, 'tpkg', 'reloc', 'file')).mode
+      assert_equal(@srcmode, dstmode, 'mode preserved')
+      dstmtime = File.stat(File.join(unpackdir, 'tpkg', 'reloc', 'file')).mtime
+      assert_equal(@srcmtime, dstmtime, 'mtime preserved')
+    
+      # Verify that the file we specified should be encrypted was encrypted
+      testname = 'encrypted file is encrypted'
+      encrypted_contents = IO.read(File.join(unpackdir, 'tpkg', 'reloc', 'encfile'))
+      unencrypted_contents = IO.read(File.join(TESTPKGDIR, 'reloc', 'encfile'))
+      assert_not_equal(unencrypted_contents, encrypted_contents, testname)
+      testname = 'encrypted file can be decrypted'
+      Tpkg::decrypt('testpkg', File.join(unpackdir, 'tpkg', 'reloc', 'encfile'), PASSPHRASE)
+      decrypted_contents = IO.read(File.join(unpackdir, 'tpkg', 'reloc', 'encfile'))
+      assert_equal(unencrypted_contents, decrypted_contents, testname)
+      # Verify that the precrypt file can still be decrypted
+      testname = 'precrypt file can be decrypted'
+      Tpkg::decrypt('testpkg', File.join(unpackdir, 'tpkg', 'reloc', 'precryptfile'), PASSPHRASE)
+      decrypted_contents = IO.read(File.join(unpackdir, 'tpkg', 'reloc', 'precryptfile'))
+      unencrypted_contents = IO.read(File.join(TESTPKGDIR, 'reloc', 'precryptfile.plaintext'))
+      assert_equal(unencrypted_contents, decrypted_contents, testname)
+    end
+  end
+  
+  def test_make_required_fields
+    # Verify that you can't make a package without one of the required fields
+    Metadata::REQUIRED_FIELDS.each do |r|
+      testname = "make package without required field #{r}"
+      File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+        IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+          if line !~ /^\s*<#{r}>/
+            pkgxmlfile.print(line)
+          end
+        end
+      end
+      assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    end
+    # Verify that you can't make a package with one of the required fields empty
+    Metadata::REQUIRED_FIELDS.each do |r|
+      testname = "make package with empty required field #{r}"
+      File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+        IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+          line.sub!(/^(\s*<#{r}>).*(<\/#{r}>.*)/, '\1\2')
+          pkgxmlfile.print(line)
+        end
+      end
+      assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    end
+  end
+  
+  def test_make_optional_fields
+    # Verify that you can make a package without the optional fields
+    testname = 'make package without optional fields'
+    pkgfile = nil
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line =~ /^<?xml/ || line =~ /^<!DOCTYPE/ || line =~ /^<\/?tpkg>/
+          # XML headers and document root
+          pkgxmlfile.print(line)
+        elsif Metadata::REQUIRED_FIELDS.any? { |r| line =~ /^\s*<\/?#{r}>/ }
+          # Include just the required fields
+          pkgxmlfile.print(line)
+        end
+      end
+    end
+    assert_nothing_raised(testname) { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_rf(pkgfile)
+  end
+  
+  def test_make_nonexistent_file
+    # Insert a non-existent file into tpkg.xml and verify that it throws
+    # an exception
+    testname = 'make package with non-existent file'
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        # Insert our files entry right before the end of the file
+        if line =~ /^\s*<\/tpkg>/
+          pkgxmlfile.puts('<files>')
+          pkgxmlfile.puts('  <file>')
+          pkgxmlfile.puts('    <path>does-not-exist</path>')
+          pkgxmlfile.puts('  </file>')
+          pkgxmlfile.puts('</files>')
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, PASSPHRASE) }
+  end
+
+  def test_group_owner
+    # Ensure a warning given if file owner and group set to non-existing accounts
+    FileUtils.cp("#{TESTPKGDIR}/tpkg-bad-ownergroup.xml", "#{@pkgdir}/tpkg.xml")
+    out = capture_stdout do 
+      Tpkg.make_package(@pkgdir,nil)
+    end
+    expectederr = "Package requests user baduser, but that user can't be found.  Using UID 0.\nPackage requests group badgroup, but that group can't be found.  Using GID 0.\n"
+    assert_equal(expectederr,out.string)
+    FileUtils.cp("#{TESTPKGDIR}/tpkg-good-ownergroup.xml", "#{@pkgdir}/tpkg.xml")
+    out = capture_stdout do 
+      Tpkg.make_package(@pkgdir,nil)
+    end
+    assert_equal("",out.string)
+  end
+ 
+  
+  def test_make_nil_passphrase
+    # Pass a nil passphrase with a package that requests encryption,
+    # verify that it throws an exception
+    testname = 'make package with encryption but nil passphrase'
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        # Insert our files entry right before the end of the file
+        if line =~ /^\s*<\/tpkg>/
+          pkgxmlfile.puts('<files>')
+          pkgxmlfile.puts('  <file>')
+          pkgxmlfile.puts('    <path>encfile</path>')
+          pkgxmlfile.puts('    <encrypt/>')
+          pkgxmlfile.puts('  </file>')
+          pkgxmlfile.puts('</files>')
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    FileUtils.cp(File.join(TESTPKGDIR, 'reloc', 'encfile'), File.join(@pkgdir, 'reloc'))
+    assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, nil) }
+  end
+  
+  def test_make_bad_precrypt
+    # Include an unencrypted file flagged as precrypt=true,
+    # verify that it throws an exception
+    testname = 'make package with plaintext precrypt'
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        # Insert our files entry right before the end of the file
+        if line =~ /^\s*<\/tpkg>/
+          pkgxmlfile.puts('<files>')
+          pkgxmlfile.puts('  <file>')
+          pkgxmlfile.puts('    <path>precryptfile</path>')
+          pkgxmlfile.puts('    <encrypt precrypt="true"/>')
+          pkgxmlfile.puts('  </file>')
+          pkgxmlfile.puts('</files>')
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    FileUtils.cp(File.join(TESTPKGDIR, 'reloc', 'precryptfile.plaintext'), File.join(@pkgdir, 'reloc', 'precryptfile'))
+    assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, nil) }
+  end
+  
+  def test_make_already_exists
+    # Try to make a package where the output file already exists, verify that it is overwritten
+    pkgfile = File.join(Dir::tmpdir, 'testpkg-1.0-1.tpkg')
+    existing_contents = 'Hello world'
+    File.open(pkgfile, 'w') do |file|
+      file.puts existing_contents
+    end
+    FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(@pkgdir, 'tpkg.xml'))
+    assert_nothing_raised { Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    assert_not_equal(existing_contents, IO.read(pkgfile))
+    FileUtils.rm_f(pkgfile)
+    # It would be nice to test that if the user is prompted and answers no that the file is not overwritten
+  end
+  
+  def test_make_full_path
+    # Test using a full path to the package directory
+    pkgfile = nil
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    begin
+      verify_pkg(pkgfile)
+    ensure
+      FileUtils.rm_f(pkgfile)
+    end
+  end
+  
+  def test_make_relative_path
+    # Test using a relative path to the directory
+    pkgfile = nil
+    pwd = Dir.pwd
+    Dir.chdir(File.dirname(@pkgdir))
+    assert_nothing_raised { pkgfile = Tpkg.make_package(File.basename(@pkgdir), PASSPHRASE) }
+    pkgfile = File.join(Dir.pwd, pkgfile)
+    Dir.chdir(pwd)
+    begin
+      verify_pkg(pkgfile)
+    ensure
+      FileUtils.rm_f(pkgfile)
+    end
+  end
+  
+  def test_make_dot_path
+    # Test from within the directory, passing '.' to make_package
+    pkgfile = nil
+    pwd = Dir.pwd
+    Dir.chdir(@pkgdir)
+    assert_nothing_raised { pkgfile = Tpkg.make_package('.', PASSPHRASE) }
+    pkgfile = File.join(Dir.pwd, pkgfile)
+    Dir.chdir(pwd)
+    begin
+      verify_pkg(pkgfile)
+    ensure
+      FileUtils.rm_f(pkgfile)
+    end
+  end
+  
+  def test_make_passphrase_callback
+    # Test using a callback to supply the passphrase
+    callback = lambda { |pkgname| PASSPHRASE }
+    pkgfile = nil
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, callback) }
+    begin
+      verify_pkg(pkgfile)
+    ensure
+      FileUtils.rm_f(pkgfile)
+    end
+  end
+  
+  def test_make_osarch_names
+    # Test that make_package properly names packages that are specific to
+    # particular operating systems or architectures.
+    pkgfile = nil
+    
+    # The default tpkg.xml is tied to OS "OS" and architecture "Architecture"
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-os-architecture.tpkg/, pkgfile)
+    
+    # Add another OS
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line =~ /operatingsystem/
+          line << "<operatingsystem>otheros</operatingsystem>\n"
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-multios-architecture.tpkg/, pkgfile)
+    
+    # Add another architecture
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line =~ /architecture/
+          line << "<architecture>otherarch</architecture>\n"
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-os-multiarch.tpkg/, pkgfile)
+    
+    # Remove the OS
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line !~ /operatingsystem/
+          pkgxmlfile.print(line)
+        end
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-architecture.tpkg/, pkgfile)
+    
+    # Remove the architecture
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line !~ /architecture/
+          pkgxmlfile.print(line)
+        end
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-os.tpkg/, pkgfile)
+    
+    # Set OS to a set of Red Hat variants, they get special treatment
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line =~ /operatingsystem/
+          line = "<operatingsystem>RedHat-5,CentOS-5</operatingsystem>\n"
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-redhat5-architecture.tpkg/, pkgfile)
+    
+    # Red Hat variants with different versions
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line =~ /operatingsystem/
+          line = "<operatingsystem>RedHat-5,CentOS-5,RedHat-4</operatingsystem>\n"
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-redhat-architecture.tpkg/, pkgfile)
+    
+    # Same OS with different versions
+    File.open(File.join(@pkgdir, 'tpkg.xml'), 'w') do |pkgxmlfile|
+      IO.foreach(File.join(TESTPKGDIR, 'tpkg-nofiles.xml')) do |line|
+        if line =~ /operatingsystem/
+          line = "<operatingsystem>Solaris-5.8,Solaris-5.9</operatingsystem>\n"
+        end
+        pkgxmlfile.print(line)
+      end
+    end
+    assert_nothing_raised { pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE) }
+    FileUtils.rm_f(pkgfile)
+    assert_match(/testpkg-1.0-1-solaris-architecture.tpkg/, pkgfile)
+  end
+
+  def test_make_output_dir
+    testname = "Trying to output to a non-existing directory"
+    assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, PASSPHRASE, :out => 'bogus/direc/tory') }
+
+    outdir = Tempfile.new('testfile')
+    testname = "Trying to output to something that is not a directory"
+    assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, PASSPHRASE, :out => outdir.path) }
+
+    testname = "Trying to output to a directory that is not writable"
+    Dir.mktmpdir('outdir') do |outdir|
+      FileUtils.chmod 0555, outdir
+      assert_raise(RuntimeError, testname) { Tpkg.make_package(@pkgdir, PASSPHRASE, :out => outdir) }
+    end
+
+    # Trying to output to a good directory
+    Dir.mktmpdir('outdir') do |outdir|
+      pkgfile = Tpkg.make_package(@pkgdir, PASSPHRASE, :out => outdir)
+      assert(File.exists?(pkgfile))
+    end
+  end
+  
+  def test_make_tpkg_version
+    # FIXME
+    testname = 'make_package added tpkg_version to metadata'
+    # The source directory from which the package is made may not be writeable
+    # by the user making the package.  As such attempting to add tpkg_version
+    # to the metadata file will fail.  We expect tpkg to warn the user about
+    # that fact but not fail.
+    testname = 'make_package warned if adding tpkg_version failed due to permissions'
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@pkgdir)
+  end
+end
+