tpkg 2.3.3 → 2.3.4

data/test/test_downgrade.rb

@@ -0,0 +1,80 @@
+#
+# Test tpkg's ability to upgrade packages
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgDowngradeTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+
+    @pkgfiles = []
+    Dir.mktmpdir('srcdir') do |srcdir|
+      FileUtils.cp(File.join(TESTPKGDIR, 'tpkg-nofiles.xml'), File.join(srcdir, 'tpkg.xml'))
+      FileUtils.mkdir(File.join(srcdir, 'reloc'))
+      
+      # Creating packages that will be used for testing
+      
+      # Package a-1 and a-2. No dependency.
+      @pkgfiles << make_package(:change => {'name' => 'a', 'version' => '1', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      @pkgfiles << make_package(:change => {'name' => 'a', 'version' => '2', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      
+      # Package b-1 and b-2. b-1 depends on c-1
+      @pkgfiles << make_package(:change => {'name' => 'b', 'version' => '1', 'package_version' => '1'}, :dependencies => {'c' => {}}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      @pkgfiles << make_package(:change => {'name' => 'b', 'version' => '2', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      @pkgfiles << make_package(:change => {'name' => 'c', 'version' => '1', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      
+      # Package d-1 and d-2. d-1 depends on nonexistingpkg
+      @pkgfiles << make_package(:change => {'name' => 'd', 'version' => '1', 'package_version' => '1'}, :dependencies => {'nonexistingpkg' => {}}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      @pkgfiles << make_package(:change => {'name' => 'd', 'version' => '2', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      
+      # Package e-1, e-2 and f-1. f-1 depends on e-2
+      @pkgfiles << make_package(:change => {'name' => 'e', 'version' => '1', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      @pkgfiles << make_package(:change => {'name' => 'e', 'version' => '2', 'package_version' => '1'}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+      @pkgfiles << make_package(:change => {'name' => 'f', 'version' => '1', 'package_version' => '1'}, :dependencies => {'e' => {'minimum_version' => '2.0', 'maximum_version' => '2.0'}}, :source_directory => srcdir, :remove => ['operatingsystem', 'architecture'])
+    end
+    
+    @testroot = Dir.mktmpdir('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', 'd', 'e', 'f'], PASSPHRASE)
+  end
+
+  def test_downgrade
+
+    # should be able to downgrade to a-1
+    assert_nothing_raised {@tpkg.upgrade(['a=1'], PASSPHRASE, {:downgrade => true})}
+
+    # should be able to downgrade to b-1, 
+    assert_nothing_raised {@tpkg.upgrade(['b=1'], PASSPHRASE, {:downgrade => true})}
+
+    # should not be able to downgrade to d-1 since it depends on non-existing pkg
+    assert_raise(RuntimeError) {@tpkg.upgrade(['d=1'], PASSPHRASE, {:downgrade => true})}
+
+    # should not be able to downgrade to e-1 since f-1 depends on e-2
+    assert_raise(RuntimeError) {@tpkg.upgrade(['e=1'], PASSPHRASE, {:downgrade => true})}
+
+    #  There should be 6 packages installed
+    metadata = @tpkg.metadata_for_installed_packages
+    assert_equal(6, metadata.size)
+    # a, b, c  and f should be version 1
+    metadata.each do | m |
+      if ['a','b','c','f'].include?(m[:name])
+        assert_equal('1', m[:version])       
+      elsif ['d', 'e'].include?(m[:name])
+        assert_equal('2', m[:version])       
+      else
+        assert(false)
+      end
+    end
+  end
+  
+  def teardown
+    @pkgfiles.each { |pkgfile| FileUtils.rm_f(pkgfile) }
+    FileUtils.rm_rf(@testroot)
+  end
+end
+

data/test/test_download.rb

@@ -0,0 +1,95 @@
+#
+# Test tpkg's ability to download packages
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+require 'webrick'
+
+class TpkgDownloadTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # Make up our regular test package
+    @pkgfile = make_package
+    
+    # Copy the package into a directory to test directory-related operations
+    @pkgdir = Dir.mktmpdir('pkgdir')
+    FileUtils.cp(@pkgfile, @pkgdir)
+  end
+  
+  def test_download
+    Tpkg::extract_metadata(@pkgdir)
+    
+    s = WEBrick::HTTPServer.new(:Port => 3500, :DocumentRoot => @pkgdir)
+    # There may be an easier way to push WEBrick into the background, but
+    # the WEBrick docs are mostly non-existent so I'm taking the quick and
+    # dirty route.
+    t = Thread.new { s.start }
+    
+    Dir.mktmpdir('testbase') do |testbase|
+      source = 'http://localhost:3500/'
+      tpkg = Tpkg.new(:base => testbase, :sources => [source])
+      # Download and verify
+      assert_nothing_raised { tpkg.download(source, File.basename(@pkgfile)) }
+      localpath = File.join(tpkg.source_to_local_directory(source), File.basename(@pkgfile))
+      assert(File.exist?(localpath))
+      assert_equal(0644, File.stat(localpath).mode & 07777)
+      assert(Tpkg::verify_package_checksum(localpath))
+      
+      # Mess with the package so that it doesn't verify, then confirm that
+      # calling download again re-downloads it
+      File.open(localpath, 'w') do |file|
+        file.puts "Bogus package now"
+      end
+      assert_raise(RuntimeError, NoMethodError) { Tpkg::verify_package_checksum(localpath) }
+      assert_nothing_raised { tpkg.download(source, File.basename(@pkgfile)) }
+      assert(File.exist?(localpath))
+      assert(Tpkg::verify_package_checksum(localpath))
+    end
+    
+    s.shutdown
+    t.kill
+  end
+
+  def test_download_pkgs
+    # set up multiple packages
+    ['pkga', 'pkgb'].each do |name|
+      pkgfile = make_package(:change => {'name' => name}, :remove => ['operatingsystem', 'architecture'])
+      FileUtils.cp(pkgfile, @pkgdir)
+    end
+
+    Tpkg::extract_metadata(@pkgdir)
+
+    s = WEBrick::HTTPServer.new(:Port => 3500, :DocumentRoot => @pkgdir)
+    # There may be an easier way to push WEBrick into the background, but
+    # the WEBrick docs are mostly non-existent so I'm taking the quick and
+    # dirty route.
+    t = Thread.new { s.start }
+
+    Dir.mktmpdir('testbase') do |testbase|
+      Dir.mktmpdir('destdir') do |destdir|
+        source = 'http://localhost:3500/'
+        tpkg = Tpkg.new(:base => testbase, :sources => [source])
+        
+        # Try to request a download of a non-existing package
+        result = tpkg.download_pkgs(['non-existing'], {:out => destdir})
+        assert_equal(Tpkg::GENERIC_ERR, result)
+        
+        # Try to request a download of existing packages
+        result = tpkg.download_pkgs(['pkga', 'pkgb'], {:out => destdir})
+        assert_equal(0, result)
+        assert_equal(2, Dir.glob(File.join(destdir, '*')).size)  # we have downloaded 2 packages
+      end
+    end
+    
+    s.shutdown
+    t.kill
+  end
+  
+  def teardown
+    FileUtils.rm_f(@pkgfile)
+    FileUtils.rm_rf(@pkgdir)
+  end
+end

data/test/test_encrypt.rb

@@ -0,0 +1,136 @@
+
+
+#
+# Test tpkg's encrypt/decrypt methods
+#
+# The methods are supposed to be compatible with openssl's 'enc' utility,
+# so we test them by encrypting some plaintext with openssl and then using
+# the method to decrypt it or vice-versa.
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgEncryptTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+  end
+  
+  def test_encrypt
+    plaintext = 'This is the plaintext'
+    cipher = 'aes-256-cbc'
+    
+    tmpfile = Tempfile.new('tpkgtest')
+    tmpfile.write(plaintext)
+    tmpfile.close
+    File.chmod(0604, tmpfile.path)
+    
+    # Test encrypt
+    Tpkg::encrypt('tpkgtest', tmpfile.path, PASSPHRASE, cipher)
+    decrypted = `openssl enc -d -#{cipher} -pass pass:#{PASSPHRASE} -in #{tmpfile.path}`
+    assert_equal(plaintext, decrypted)
+    assert_equal(0604, File.stat(tmpfile.path).mode & 07777)
+    
+    # Test using a callback to supply the passphrase
+    File.open(tmpfile.path, 'w') do |file|
+      file.write(plaintext)
+    end
+    callback = lambda { |pkgname| PASSPHRASE }
+    Tpkg::encrypt('tpkgtest', tmpfile.path, callback, cipher)
+    decrypted = `openssl enc -d -#{cipher} -pass pass:#{PASSPHRASE} -in #{tmpfile.path}`
+    assert_equal(plaintext, decrypted)
+
+    # Test encrypting on a directory
+    Dir.mktmpdir('testdir') do |testdir|
+      File.open(File.join(testdir, 'file1'), 'w') do |file|
+        file.write(plaintext)
+      end
+      File.open(File.join(testdir, 'file2'), 'w') do |file|
+        file.write(plaintext)
+      end
+      Tpkg::encrypt('tpkgtest', testdir, PASSPHRASE, cipher)
+      decrypted = `openssl enc -d -#{cipher} -pass pass:#{PASSPHRASE} -in #{File.join(testdir, 'file1')}`
+      assert_equal(plaintext, decrypted)
+      decrypted = `openssl enc -d -#{cipher} -pass pass:#{PASSPHRASE} -in #{File.join(testdir, 'file2')}`
+      assert_equal(plaintext, decrypted)
+    end
+    
+    # Test encrypting an empty file
+    File.open(tmpfile.path, 'w') do |file|
+    end
+    Tpkg::encrypt('tpkgtest', tmpfile.path, callback, cipher)
+  end
+  
+  def test_decrypt
+    plaintext = 'This is the plaintext'
+    cipher = 'aes-256-cbc'
+    
+    tmpfile = Tempfile.new('tpkgtest')
+    tmpfile.close
+    File.chmod(0604, tmpfile.path)
+    
+    # Test decrypt
+    IO.popen(
+      "openssl enc -#{cipher} -salt -pass pass:#{PASSPHRASE} -out #{tmpfile.path}",
+      'w') do |pipe|
+      pipe.write(plaintext)
+    end
+    Tpkg::decrypt('tpkgtest', tmpfile.path, PASSPHRASE, cipher)
+    decrypted = IO.read(tmpfile.path)
+    assert_equal(plaintext, decrypted)
+    assert_equal(0604, File.stat(tmpfile.path).mode & 07777)
+    
+    # Test using a callback to supply the passphrase
+    IO.popen(
+      "openssl enc -#{cipher} -salt -pass pass:#{PASSPHRASE} -out #{tmpfile.path}",
+      'w') do |pipe|
+      pipe.write(plaintext)
+    end
+    callback = lambda { |pkgname| PASSPHRASE }
+    Tpkg::decrypt('tpkgtest', tmpfile.path, callback, cipher)
+    decrypted = IO.read(tmpfile.path)
+    assert_equal(plaintext, decrypted)
+
+    # Test decrypting on a directory
+    Dir.mktmpdir('testdir') do |testdir|
+      IO.popen(
+        "openssl enc -#{cipher} -salt -pass pass:#{PASSPHRASE} -out #{File.join(testdir, 'file1')}",
+        'w') do |pipe|
+        pipe.write(plaintext)
+      end
+      Tpkg::decrypt('tpkgtest', testdir, PASSPHRASE, cipher)
+      decrypted = IO.read(File.join(testdir, 'file1'))
+      assert_equal(plaintext, decrypted)
+    end
+    
+    # Test decrypting an empty file
+    IO.popen(
+      "openssl enc -#{cipher} -salt -pass pass:#{PASSPHRASE} -out #{tmpfile.path}",
+      'w') do |pipe|
+    end
+    Tpkg::decrypt('tpkgtest', tmpfile.path, callback, cipher)
+  end
+  
+  def test_verify_precrypt_file
+    plaintext = 'This is the plaintext'
+    cipher = 'aes-256-cbc'
+    
+    tmpfile = Tempfile.new('tpkgtest')
+    tmpfile.close
+    
+    IO.popen(
+      "openssl enc -#{cipher} -salt -pass pass:#{PASSPHRASE} -out #{tmpfile.path}",
+      'w') do |pipe|
+      pipe.write(plaintext)
+    end
+    
+    assert(Tpkg::verify_precrypt_file(tmpfile.path))
+    
+    File.open(tmpfile.path, 'w') do |file|
+      file.puts plaintext
+    end
+    
+    assert_raise(RuntimeError) { Tpkg::verify_precrypt_file(tmpfile.path) }
+  end
+end

data/test/test_filemetadata.rb

@@ -0,0 +1,131 @@
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgFileMetadataTests < Test::Unit::TestCase
+  include TpkgTests
+  
+  def setup
+    Tpkg::set_prompt(false)
+    
+    # Make up our regular test package
+    @pkgfile = make_package(:remove => ['operatingsystem', 'architecture'], :files => {'file' => {'perms' => '0641'}})
+  end
+  
+  def test_file_metadata
+    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 => [@pkgfile])
+      
+      assert_nothing_raised { tpkg.install([@pkgfile], PASSPHRASE) }
+      
+      # check that we can get read file_metadata for the newly installed package
+      assert_nothing_raised { @file_metadata = tpkg.file_metadata_for_installed_packages[File.basename(@pkgfile)]}
+      
+      # checking content of file_metadata
+      assert_equal(@file_metadata[:package_file], File.basename(@pkgfile))
+      
+      # check file's ownership and permissions are ok
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg']) }
+      puts @errors.inspect
+      @errors.each do | file, error |
+        assert(error.empty?)
+      end
+      
+      # modify a file's perms and verify that tpkg can detect it
+      File.chmod(07777, File.join(testroot, 'home','tpkg','file'))
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg'])}
+      @errors.each do | file, error |
+        if File.basename(file) == "file"
+          assert(!error.empty?)
+        else
+          assert(error.empty?)
+        end
+      end
+      
+      # modify a file content and verify that tpkg can detect it
+      File.open(File.join(testroot, 'home','tpkg','file'), 'w') do |file|
+        file.puts "Hello"
+      end
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg'])}
+      @errors.each do | file, error |
+        if File.basename(file) == "file"
+          assert(!error.empty?)
+          assert(error.length == 2) # error 1 is for bad perm, error 2 is for bad checksum
+        else
+          assert(error.empty?)
+        end
+      end
+      
+      # remove a file and verify that tpkg can detect it
+      FileUtils.rm(File.join(testroot, 'home','tpkg','file'))
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg'])}
+      @errors.each do | file, error |
+        if File.basename(file) == "file"
+          assert(!error.empty?)
+        else
+          assert(error.empty?)
+        end
+      end
+    end
+
+    # TODO: modify a file owner, group and verify that tpkg can detect it
+    # 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 => [@pkgfile])
+    #   assert_nothing_raised { tpkg.install([@pkgfile], PASSPHRASE) }
+    #   uid = Tpkg::lookup_uid("bogus")
+    #   gid = Tpkg::lookup_gid("bogus")
+    #   File.chown(uid, gid, File.join(testroot, 'home','tpkg','file'))
+    #   assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg'])}
+    #   @errors.each do | file, error |
+    #    if File.basename(file) == "file"
+    #      assert(!error.empty?)
+    #      assert(error.length == 2) # 2 errors: 1 for gid and 1 for uid
+    #    else
+    #      assert(error.empty?) 
+    #    end   
+    #   end
+    # end
+  end
+
+  def test_backward_compatibility
+    # Test that tpkg doesn't break when user wants to verify old installed packages 
+    # that were created without file_metadata.xml
+    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 => [@pkgfile])
+      
+      assert_nothing_raised { tpkg.install([@pkgfile], PASSPHRASE) }
+      
+      # remove file_metadata
+      pkgname = File.basename(@pkgfile, File.extname(@pkgfile))
+      FileUtils.rm(File.join(testroot, 'home','tpkg', 'var', 'tpkg', 'installed', 'metadata', pkgname, 'file_metadata.bin'))
+      
+      # verify nothing bad when user try to run -V
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg'])}
+      
+      # remove metadata directory and check the verify method doesn't break
+      FileUtils.rm_r(File.join(testroot, 'home','tpkg', 'var', 'tpkg', 'installed', 'metadata', pkgname))
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['testpkg'])}
+      
+      # Test that tpkg doesn't break when user try to install old packages that were created without file_metadata.xml 
+      pkg_without_file_metadata = File.join(File.dirname(__FILE__), 'premadetestpkg', 'pkg_without_file_metadata-1.0-1.tpkg')
+      assert_nothing_raised { tpkg.install([pkg_without_file_metadata], 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')))
+      
+      # verify nothing bad when user try to run -V
+      assert_nothing_raised { @errors = tpkg.verify_file_metadata(['pkg_without_file_metadata'])}
+    end
+  end
+  
+  def teardown
+    FileUtils.rm_f(@pkgfile)
+  end
+end
+

data/test/test_initscript.rb

@@ -0,0 +1,93 @@
+
+
+#
+# Test tpkg's ability to execute init scripts
+#
+
+require File.expand_path('tpkgtest', File.dirname(__FILE__))
+
+class TpkgInitScriptsTests < 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 a package with both relocatable and non-relocatable
+    # directory trees so that we can ensure both types are unpacked
+    # properly.
+    Dir.mktmpdir('srcdir') do |srcdir|
+      # The stock test package has a reloc directory we can use
+      system("#{Tpkg::find_tar} -C #{TESTPKGDIR} --exclude .svn -cf - . | #{Tpkg::find_tar} -C #{srcdir} -xf -")
+      # Then add a root directory
+      FileUtils.mkdir_p(File.join(srcdir, 'root', 'etc'))
+      File.open(File.join(srcdir, 'root', 'etc', 'rootfile'), 'w') do |file|
+        file.puts "Hello"
+      end
+      @pkgfile = make_package(:output_directory => @tempoutdir, :source_directory => srcdir, :files => {'/etc/rootfile' => {'perms' => '0666'}})
+    end
+  end
+  
+  # Test init script start/stop init scripts in correct order
+  def test_order
+    pkg = nil
+    tmpfile = Tempfile.new('initscripttest')
+    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'))
+      (1..3).each do | i |
+        File.open(File.join(srcdir, 'reloc', "myinit#{i}"), 'w') do |file|
+          file.puts("#!/bin/sh\necho myinit#{i} >> #{tmpfile.path}")
+        end
+        File.chmod(0755, File.join(srcdir, 'reloc', "myinit#{i}"))
+      end
+      
+      pkg  = make_package(:output_directory => @tempoutdir, :change => { 'name' => 'initpkg'  }, :source_directory => srcdir, 
+                          :files => { "myinit1" => { 'init' => {'start' => '1' }} , "myinit2" => { 'init' => {'start' => '2' }}, "myinit3" => { 'init' => {'start' => '3' }}}, 
+                          :remove => ['operatingsystem', 'architecture'])
+    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 => [pkg])
+      metadata  = Tpkg::metadata_from_package(pkg)
+      begin
+        tpkg.install([pkg], PASSPHRASE)
+        tpkg.init_links(metadata).each do |link, init_script|
+          assert(File.symlink?(link))
+          assert_equal(init_script, File.readlink(link))
+        end
+        
+        # check that init scripts are started in correct order
+        tpkg.execute_init(["initpkg"], "start")
+        lines = File.open(tmpfile.path).readlines
+        assert_equal("myinit1", lines[0].chomp)
+        assert_equal("myinit2", lines[1].chomp)
+        assert_equal("myinit3", lines[2].chomp)
+        
+        # clear out the file
+        system("cat /dev/null > #{tmpfile.path}")
+        # check that init scripts are stopped in correct order
+        tpkg.execute_init(["initpkg"], "stop")
+        lines = File.open(tmpfile.path).readlines
+        assert_equal("myinit3", lines[0].chomp)
+        assert_equal("myinit2", lines[1].chomp)
+        assert_equal("myinit1", lines[2].chomp)
+      rescue RuntimeError => e
+        if e.message =~ /No init script support/
+          warn "No init script support on this platform, init script handling will not be tested (#{e.message})"
+        else
+          raise
+        end
+      end
+    end
+    FileUtils.rm_f(pkg)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@tempoutdir)
+  end
+end
+