gonzui 1.2

data/test/test_dbm.rb

@@ -0,0 +1,171 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools.rb'
+require '_test-util'
+
+class DBMTest < Test::Unit::TestCase
+  include TestUtil
+
+  def test_dbm_create
+    config   = Gonzui::Config.new
+    remove_db(config)
+    dbm = Gonzui::DBM.open(config)
+    assert(dbm.is_a?(Gonzui::AbstractDBM))
+    dbm.close
+  end
+
+  def test_dbm_create_with_block
+    config   = Gonzui::Config.new
+    remove_db(config)
+    Gonzui::DBM.open(config) {|dbm|
+      assert(dbm.is_a?(Gonzui::AbstractDBM))
+    }
+  end
+
+  def _test_consistent_p(dbm)
+    assert(dbm.consistent?)
+  end
+
+  def _test_content_info(dbm)
+    dbm.each_package_name {|package_name|
+      package_id = dbm.get_package_id(package_name)
+      assert(package_id)
+      path_ids = dbm.get_path_ids(package_id)
+      path_ids.each {|path_id|
+        stat = dbm.get_content_info(path_id)
+        assert(stat.is_a?(Gonzui::ContentInfo))
+        content = dbm.get_content(path_id)
+        assert_equal(stat.size, content.length)
+        assert(stat.itime >= stat.mtime)
+        assert((Time.now.to_i - stat.itime) < 600) # within 10 minutes
+      }
+    }
+  end
+
+  def _test_each_foo(dbm)
+    dbm.each_package_name {|package_name|
+      assert_equal(FOO_PACKAGE, package_name)
+    }
+
+    dbm.each_db_name {|db_name|
+      assert(db_name.is_a?(String))
+      assert(dbm.respond_to?(db_name))
+    }
+  end
+
+  def _test_get_foo(dbm)
+    make_dist_tree
+    package_id = dbm.get_package_id(FOO_PACKAGE)
+    dbm.get_path_ids(package_id).each {|path_id|
+      path = dbm.get_path(path_id)
+      assert(FOO_FILES.include?(File.basename(path)))
+      assert_equal(path_id, dbm.get_path_id(path))
+      content = dbm.get_content(path_id)
+      content = File.read(File.join(File.dirname(__FILE__), "foo", path))
+      assert_equal(content, content)
+      dbm.get_word_ids(path_id).each {|word_id|
+        FOO_SYMBOLS.include?(dbm.get_word(word_id))
+      }
+      assert_equal(0, package_id)
+      assert_equal(FOO_PACKAGE, dbm.get_package_name(package_id))
+    }
+  end
+
+  def _test_foo_find(dbm)
+    found_types = []
+    [:find_all, :find_all_by_regexp, :find_all_by_prefix].each {|search_method|
+      FOO_SYMBOLS.each {|word|
+        tuples = dbm.send(search_method, word)
+        assert(tuples.is_a?(Array))
+        assert_equal(false, tuples.empty?)
+        tuples.each {|info|
+          type = dbm.get_type(info.type_id)
+          assert(type.is_a?(Symbol))
+          found_types.push(type)
+
+          assert(info.is_a?(Gonzui::WordInfo))
+          if search_method == :find_all
+            assert_equal(word, dbm.get_word(info.word_id))
+          else
+            assert(dbm.get_word(info.word_id).index(word))
+          end
+          assert(info.byteno.is_a?(Fixnum))
+          assert(info.lineno.is_a?(Fixnum))
+          assert(info.type_id.is_a?(Fixnum))
+          assert(info.path_id.is_a?(Fixnum))
+          path = dbm.get_path(info.path_id)
+          assert(FOO_FILES.include?(File.basename(path)))
+        }
+      }
+      [:fundef, :funcall, :fundecl].each {|type|
+        assert(found_types.include?(type))
+      }
+      assert(dbm.send(search_method, "__not_existing_word__").empty?)
+    }
+  end
+
+  def _test_digest(dbm)
+    path_id = dbm.get_path_id(File.join(FOO_PACKAGE, "foo.c"))
+    content = dbm.get_content(path_id)
+    digest = dbm.get_digest(path_id)
+    digest.each {|info|
+      assert(info.is_a?(Gonzui::DigestInfo))
+      word = content[info.byteno, info.length]
+      if word
+        assert_equal(word.length, info.length)
+        assert_equal(word, content[info.byteno, info.length])
+      end
+    }
+  end
+
+  def _test_close(dbm)
+    begin
+      dbm.close
+      dbm.close
+      assert(false)
+    rescue Gonzui::DBMError => e
+      assert(true)
+    end
+
+    begin
+      dbm.get_npackages
+      assert(false)
+    rescue BDB::Fatal => e # closed DB
+      assert(true)
+    end
+  end
+
+  def test_bdb
+    tmp = "test.#{$$}.db"
+    db = BDB::Btree.open(tmp, nil, BDB::CREATE, 0644,
+                         "set_flags" => BDB::DUPSORT)
+    db["foo"] = "1"
+    db["foo"] = "2"
+    assert_equal(2, db.duplicates("foo").length)
+
+    # The assert failed with Ruby BDB 0.5.1 or older due to
+    # BDB::Btree#duplicates's bug. The bug was fixed in BDB
+    # 0.5.2.
+    assert_equal(0, db.duplicates("f").length)
+    assert_equal(0, db.duplicates("").length)
+    db.close
+    File.unlink(tmp)
+  end
+
+  def test_dbm_operations
+    config = Gonzui::Config.new
+    remove_db(config)
+
+    make_archives
+    add_package(config)
+
+    dbm = Gonzui::DBM.open(config)
+    _test_content_info(dbm)
+    _test_each_foo(dbm)
+    _test_get_foo(dbm)
+    _test_foo_find(dbm)
+    _test_digest(dbm)
+    _test_close(dbm)
+    remove_db(config)
+  end
+end if (ARC_)

data/test/test_deindexer.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools.rb'
+require '_test-util'
+
+class DeindexerTest < Test::Unit::TestCase
+  include TestUtil
+
+  def setup
+	  @dbm = nil
+    @config   = Gonzui::Config.new
+  end
+  def teardown
+    unless @dbm.nil?
+      @dbm.close rescue nil
+    end
+    @dbm = nil
+    remove_db(@config)
+  end
+
+  def _test_removed_clearly?(dbm)
+    exclude_dbs = [
+      :seq, :stat, :type_typeid, :typeid_type, :version,
+    ]
+    dbm.each_db_name {|db_name|
+      next if exclude_dbs.include?(db_name.intern)
+      assert(dbm.send(db_name).empty?)
+    }
+  end
+
+  def test_deindex
+    remove_db(@config)
+    make_db(@config)
+    dbm = Gonzui::DBM.open(@config)
+    @dbm = dbm
+
+    package_id = dbm.get_package_id(FOO_PACKAGE)
+    assert_equal(0, package_id)
+    dbm.get_path_ids(package_id).each {|path_id|
+      normalized_path = dbm.get_path(path_id)
+      deindexer = Gonzui::Deindexer.new(@config, dbm, normalized_path)
+      deindexer.deindex
+    }
+    assert(!dbm.has_package?(FOO_PACKAGE))
+    assert_equal(0, dbm.get_ncontents)
+    assert_equal(0, dbm.get_nwords)
+    assert(dbm.consistent?)
+    _test_removed_clearly?(dbm)
+  end
+end if (ARC_)

data/test/test_delta.rb

@@ -0,0 +1,66 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class DeltaDumperTest < Test::Unit::TestCase
+  include Gonzui::DeltaDumper
+
+  def test_fixnums
+    list = [
+      [[1,2,3,4,5,6], [1,1,1,1,1,1]],
+      [[0,0,0,0,0,0], [0,0,0,0,0,0]],
+      [[1,1,2,3,5,8], [1,0,1,1,2,3]],
+    ]
+    list.each {|original, encoded|
+      tmp = original.dup
+      assert_equal(encoded,  encode_fixnums(tmp))
+      assert_equal(original, decode_fixnums(tmp))
+    }
+  end
+
+  def test_fixnums_with_broken_data
+    broken_data = [
+      nil, 
+      "",
+      [1,2,nil,3],
+      [1,2,3,2,1]
+    ]
+    broken_data.each {|list|
+      begin
+        encode_fixnums(list)
+        assert_not_reached
+      rescue ArgumentError, TypeError => e
+      end
+    }
+  end
+
+  def test_tuples
+    list = [
+      [[1,2,3,4,5,6], [1,2,2,2,2,2], 2, 2],
+      [[1,2,3,4,5,6], [1,2,2,4,2,6], 1, 2],
+    ]
+    list.each {|original, encoded, dsize, usize|
+      tmp = original.dup
+      assert_equal(encoded,  encode_tuples(tmp, dsize, usize))
+      assert_equal(original, decode_tuples(tmp, dsize, usize))
+    }
+  end
+
+  def test_tuples_with_broken_data
+    broken_data = [
+      [nil, 2, 2],
+      [[1,2,3,4,5], 2, 2],
+      [[1,2,3,4,5,6], 3, 2],
+      [[1,2,nil,4,5,6], 2, 2],
+      [[1,2,3,3,2,1], 2, 2]
+    ]
+    broken_data.each {|list, dsize, usize|
+      begin
+        encode_tuples(list, dsize, usize)
+        assert_not_reached
+      rescue ArgumentError, TypeError => e
+      end
+    }
+  end
+end
+

data/test/test_extractor.rb

@@ -0,0 +1,78 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools.rb'
+require '_test-util'
+
+class ExtractorTest < Test::Unit::TestCase
+  include TestUtil
+
+  include Gonzui::Util
+
+  def test_supported_archive
+    supported_files = {}
+    supported_files["foo.zip"] = ".zip" if command_exist?("unzip")
+    supported_files["foo.tar.gz"] = ".tar.gz" if
+      command_exist?("tar") and command_exist?("gunzip")
+    supported_files["foo.tar.bz2"] = ".tar.bz2" if 
+      command_exist?("tar") and command_exist?("bunzip2")
+    supported_files["foo.src.rpm"] = ".src.rpm" if 
+      command_exist?("rpm2cpio") and command_exist?("cpio")
+
+    supported_files.each {|file_name, extname|
+      assert_equal(extname, Gonzui::Extractor.get_archive_extname(file_name))
+      assert(Gonzui::Extractor.supported_file?(file_name))
+      assert_equal(file_name,
+                    Gonzui::Extractor.suppress_archive_extname(file_name) + extname)
+    }
+  end
+
+  def test_unsupported_archive
+    unsupported_files = {
+      "foo.rpm"     => ".rpm",
+    }
+    unsupported_files.each {|file_name, extname|
+      assert_equal(nil, Gonzui::Extractor.get_archive_extname(file_name))
+      assert_equal(false, Gonzui::Extractor.supported_file?(file_name))
+    }
+  end
+
+  def _test_extract(file_name)
+    config = Gonzui::Config.new
+    extractor = Gonzui::Extractor.new(config, file_name)
+    directory = extractor.extract
+    assert(File.directory?(directory))
+    package_name = File.basename(directory)
+    source_url = URI.from_path(directory)
+    fetcher = Gonzui::Fetcher.new(config, source_url)
+    relative_paths = fetcher.collect
+    FOO_FILES.each {|base_name|
+      assert(relative_paths.include?(base_name))
+    }
+    
+    assert(File.directory?(extractor.temporary_directory))
+    extractor.clean
+    assert_equal(false, File.directory?(extractor.temporary_directory))
+  end
+
+  def test_extract
+    make_archives
+
+    good_archives = [
+      "foo-0.1.tar.gz",
+      "foo-0.1.tar.bz2",
+      "foo-0.1.zip",
+      "foo-0.1-1.src.rpm",
+    ].map {|x| File.join("foo", x) }
+    good_archives = good_archives.find_all {|x| File.file?(x) }
+
+    poor_archives = [
+      "foo-0.1p.tar.gz",
+      "foo-0.1p.tar.bz2",
+      "foo-0.1p.zip",
+    ].map {|x| File.join("foo", x) }
+    poor_archives = poor_archives.find_all {|x| File.file?(x) }
+
+    good_archives.each {|file_name| _test_extract(file_name) }
+    poor_archives.each {|file_name| _test_extract(file_name) }
+  end
+end if (ARC_)

data/test/test_fetcher.rb

@@ -0,0 +1,75 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools'
+require '_test-util'
+
+class FetcherTest < Test::Unit::TestCase
+  include Gonzui::Util
+  include TestUtil
+
+  def teardown
+    remove_db(Gonzui::Config.new)
+  end
+
+  def validate_foo_files(fetcher, paths)
+    paths.each {|path|
+      FOO_FILES.include?(File.basename(path))
+      content = fetcher.fetch(path)
+      tmp = File.read(File.join(File.dirname(__FILE__),
+                      "foo", FOO_PACKAGE, path))
+      assert_equal(tmp, content.text)
+    }
+  end
+
+  def test_file
+    config = Gonzui::Config.new
+    make_dist_tree
+    uri = URI.parse(sprintf("file://%s/foo/%s",
+        File.expand_path(File.dirname(__FILE__)), # Dir.pwd
+        FOO_PACKAGE))
+    fetcher = Gonzui::Fetcher.new(config, uri)
+    paths = fetcher.collect
+    assert_equal(false, paths.empty?)
+    validate_foo_files(fetcher, paths)
+    fetcher.finish
+  end
+
+  def test_http
+    config = Gonzui::Config.new
+    uri = URI.parse("http://gonzui.sourceforge.net/archives/gonzui-0.1.tar.gz")
+    fetcher = Gonzui::Fetcher.new(config, uri)
+    paths = fetcher.collect
+    assert_equal(false, paths.empty?)
+    paths.each {|path|
+      content = fetcher.fetch(path)
+      assert(content.text.is_a?(String))
+    }
+    fetcher.finish
+  end
+
+  def test_cvs
+    config = Gonzui::Config.new
+    config.quiet = true
+    remove_db(config)
+    make_cvs
+    uri = URI.for_cvs(cvsroot, "foo")
+    fetcher = Gonzui::Fetcher.new(config, uri)
+    paths = fetcher.collect
+    assert_equal(false, paths.empty?)
+    validate_foo_files(fetcher, paths)
+    remove_cvs
+  end
+
+  def test_svn
+    config = Gonzui::Config.new
+    config.quiet = true
+    remove_db(config)
+    make_svn
+    uri = URI.for_svn("file://" + svnroot, "foo")
+    fetcher = Gonzui::Fetcher.new(config, uri)
+    paths = fetcher.collect
+    assert_equal(false, paths.empty?)
+    validate_foo_files(fetcher, paths)
+    remove_svn
+  end
+end if (ARC_ && CVS_ && SVN_)

data/test/test_gettext.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby -Ku
+# -*- coding: utf-8-unix -*-
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class GetTextTest < Test::Unit::TestCase
+  include Gonzui::GetText
+
+  CATALOG_FILE_NAME = "catalog.ja"
+  CATALOG = {
+    "hello" => "こんにちは"
+  }
+
+  def make_catalog
+    File.open(CATALOG_FILE_NAME, "w") {|f|
+      f.puts "{"
+      CATALOG.each {|key, value|
+        f.printf('  "%s" => "%s",', key, value)
+        f.puts
+      }
+      f.puts "}"
+    }
+  end
+
+  def remove_catalog
+    File.unlink(CATALOG_FILE_NAME)
+  end
+
+  def test_gettext
+    make_catalog
+    assert_equal("hello", _("hello"))
+    catalog_repository = Gonzui::CatalogRepository.new(".")
+    catalog = catalog_repository.choose("ja")
+    assert_equal(catalog, load_catalog("catalog.ja"))
+    set_catalog(catalog)
+    assert_equal("こんにちは", _("hello"))
+
+    remove_catalog
+  end
+
+  def test_validator
+    validator = Gonzui::CatalogValidator.new(__FILE__, CATALOG)
+    validator.validate
+    assert_equal(true, validator.ok?)
+
+    validator = Gonzui::CatalogValidator.new(__FILE__, {})
+    validator.validate
+    assert_equal(false, validator.ok?)
+  end
+end