subversion 1.6.6-x86-mswin32-60 → 1.6.11-x86-mswin32-60

data/subversion/test/test_error.rb

@@ -0,0 +1,16 @@
+require "my-assertions"
+
+require "svn/error"
+
+class SvnErrorTest < Test::Unit::TestCase
+  def test_error_name
+    Svn::Error.constants.each do |const_name|
+      if /\A[A-Z0-9_]+\z/ =~ const_name and
+          Svn::Error.const_get(const_name).is_a?(Class)
+        class_name = Svn::Util.to_ruby_class_name(const_name)
+        assert_equal(Svn::Error.const_get(class_name),
+                     Svn::Error.const_get(const_name))
+      end
+    end
+  end
+end

data/subversion/test/test_fs.rb

@@ -0,0 +1,519 @@
+require "my-assertions"
+require "util"
+require "time"
+require "md5"
+
+require "svn/core"
+require "svn/fs"
+require "svn/repos"
+require "svn/client"
+
+class SvnFsTest < Test::Unit::TestCase
+  include SvnTestUtil
+
+  def setup
+    setup_basic
+  end
+
+  def teardown
+    teardown_basic
+  end
+
+  def test_version
+    assert_equal(Svn::Core.subr_version, Svn::Fs.version)
+  end
+
+  def assert_create
+    path = File.join(@tmp_path, "fs")
+    fs_type = Svn::Fs::TYPE_FSFS
+    config = {Svn::Fs::CONFIG_FS_TYPE => fs_type}
+
+    assert(!File.exist?(path))
+    fs = nil
+    callback = Proc.new do |fs|
+      assert(File.exist?(path))
+      assert_equal(fs_type, Svn::Fs.type(path))
+      fs.set_warning_func do |err|
+        p err
+        abort
+      end
+      assert_equal(path, fs.path)
+    end
+    yield(:create, [path, config], callback)
+
+    assert(fs.closed?)
+    assert_raises(Svn::Error::FsAlreadyClose) do
+      fs.path
+    end
+
+    yield(:delete, [path])
+    assert(!File.exist?(path))
+  end
+
+  def test_create
+    assert_create do |method, args, callback|
+      Svn::Fs.__send__(method, *args, &callback)
+    end
+  end
+
+  def test_create_for_backward_compatibility
+    assert_create do |method, args, callback|
+      Svn::Fs::FileSystem.__send__(method, *args, &callback)
+    end
+  end
+
+  def assert_hotcopy
+    log = "sample log"
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+    FileUtils.touch(path)
+
+    rev = nil
+
+    backup_path = make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      rev = commit_info.revision
+
+      assert_equal(log, ctx.log_message(path, rev))
+
+      backup_path = File.join(@tmp_path, "back")
+    end
+
+    fs_path = @fs.path
+    @fs.close
+    @fs = nil
+    @repos.close
+    @repos = nil
+
+    FileUtils.mv(fs_path, backup_path)
+    FileUtils.mkdir_p(fs_path)
+
+    make_context(log) do |ctx|
+      assert_raises(Svn::Error::RaLocalReposOpenFailed) do
+        ctx.log_message(path, rev)
+      end
+
+      yield(backup_path, fs_path)
+      assert_equal(log, ctx.log_message(path, rev))
+    end
+  end
+
+  def test_hotcopy
+    assert_hotcopy do |src, dest|
+      Svn::Fs.hotcopy(src, dest)
+    end
+  end
+
+  def test_hotcopy_for_backward_compatibility
+    assert_hotcopy do |src, dest|
+      Svn::Fs::FileSystem.hotcopy(src, dest)
+    end
+  end
+
+  def test_root
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample source"
+    path_in_repos = "/#{file}"
+    path = File.join(@wc_path, file)
+
+    assert_nil(@fs.root.name)
+    assert_equal(Svn::Core::INVALID_REVNUM, @fs.root.base_revision)
+
+    make_context(log) do |ctx|
+      FileUtils.touch(path)
+      ctx.add(path)
+      rev1 = ctx.commit(@wc_path).revision
+      file_id1 = @fs.root.node_id(path_in_repos)
+
+      assert_equal(rev1, @fs.root.revision)
+      assert_equal(Svn::Core::NODE_FILE, @fs.root.check_path(path_in_repos))
+      assert(@fs.root.file?(path_in_repos))
+      assert(!@fs.root.dir?(path_in_repos))
+
+      assert_equal([path_in_repos], @fs.root.paths_changed.keys)
+      info = @fs.root.paths_changed[path_in_repos]
+      assert(info.text_mod?)
+      assert(info.add?)
+
+      File.open(path, "w") {|f| f.print(src)}
+      rev2 = ctx.commit(@wc_path).revision
+      file_id2 = @fs.root.node_id(path_in_repos)
+
+      assert_equal(src, @fs.root.file_contents(path_in_repos){|f| f.read})
+      assert_equal(src.length, @fs.root.file_length(path_in_repos))
+      assert_equal(MD5.new(src).hexdigest,
+                   @fs.root.file_md5_checksum(path_in_repos))
+
+      assert_equal([path_in_repos], @fs.root.paths_changed.keys)
+      info = @fs.root.paths_changed[path_in_repos]
+      assert(info.text_mod?)
+      assert(info.modify?)
+
+      assert_equal([path_in_repos, rev2],
+                   @fs.root.node_history(file).location)
+      assert_equal([path_in_repos, rev2],
+                   @fs.root.node_history(file).prev.location)
+      assert_equal([path_in_repos, rev1],
+                   @fs.root.node_history(file).prev.prev.location)
+
+      assert(!@fs.root.dir?(path_in_repos))
+      assert(@fs.root.file?(path_in_repos))
+
+      assert(file_id1.related?(file_id2))
+      assert_equal(1, file_id1.compare(file_id2))
+      assert_equal(1, file_id2.compare(file_id1))
+
+      assert_equal(rev2, @fs.root.node_created_rev(path_in_repos))
+      assert_equal(path_in_repos, @fs.root.node_created_path(path_in_repos))
+
+      assert_raises(Svn::Error::FsNotTxnRoot) do
+        @fs.root.set_node_prop(path_in_repos, "name", "value")
+      end
+    end
+  end
+
+  def test_transaction
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample source"
+    path_in_repos = "/#{file}"
+    path = File.join(@wc_path, file)
+    prop_name = "prop"
+    prop_value = "value"
+
+    make_context(log) do |ctx|
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.commit(@wc_path)
+    end
+
+    assert_raises(Svn::Error::FsNoSuchTransaction) do
+      @fs.open_txn("NOT-EXIST")
+    end
+
+    start_time = Time.now
+    txn1 = @fs.transaction
+    assert_equal([Svn::Core::PROP_REVISION_DATE], txn1.proplist.keys)
+    assert_instance_of(Time, txn1.proplist[Svn::Core::PROP_REVISION_DATE])
+    date = txn1.prop(Svn::Core::PROP_REVISION_DATE)
+
+    # Subversion's clock is more precise than Ruby's on
+    # Windows.  So this test can fail intermittently because
+    # the begin and end of the range are the same (to 3
+    # decimal places), but the time from Subversion has 6
+    # decimal places so it looks like it's not in the range.
+    # So we just add a smidgen to the end of the Range.
+    assert_operator(start_time..(Time.now + 0.001), :include?, date)
+    txn1.set_prop(Svn::Core::PROP_REVISION_DATE, nil)
+    assert_equal([], txn1.proplist.keys)
+    assert_equal(youngest_rev, txn1.base_revision)
+    assert(txn1.root.txn_root?)
+    assert(!txn1.root.revision_root?)
+    assert_equal(txn1.name, txn1.root.name)
+    assert_equal(txn1.base_revision, txn1.root.base_revision)
+
+    @fs.transaction do |txn|
+      assert_nothing_raised do
+        @fs.open_txn(txn.name)
+      end
+      txn2 = txn
+    end
+
+    txn3 = @fs.transaction
+
+    assert_equal([txn1.name, txn3.name].sort, @fs.transactions.sort)
+    @fs.purge_txn(txn3.name)
+    assert_equal([txn1.name].sort, @fs.transactions.sort)
+
+    @fs.transaction do |txn|
+      assert(@fs.transactions.include?(txn.name))
+      txn.abort
+      assert(!@fs.transactions.include?(txn.name))
+    end
+
+    txn4 = @fs.transaction
+    assert_equal({}, txn1.root.node_proplist(path_in_repos))
+    assert_nil(txn1.root.node_prop(path_in_repos, prop_name))
+    txn1.root.set_node_prop(path_in_repos, prop_name, prop_value)
+    assert_equal(prop_value, txn1.root.node_prop(path_in_repos, prop_name))
+    assert_equal({prop_name => prop_value},
+                 txn1.root.node_proplist(path_in_repos))
+    assert(txn1.root.props_changed?(path_in_repos, txn4.root, path_in_repos))
+    assert(!txn1.root.props_changed?(path_in_repos, txn1.root, path_in_repos))
+    txn1.root.set_node_prop(path_in_repos, prop_name, nil)
+    assert_nil(txn1.root.node_prop(path_in_repos, prop_name))
+    assert_equal({}, txn1.root.node_proplist(path_in_repos))
+  end
+
+  def test_operation
+    log = "sample log"
+    file = "sample.txt"
+    file2 = "sample2.txt"
+    file3 = "sample3.txt"
+    dir = "sample"
+    src = "sample source"
+    path_in_repos = "/#{file}"
+    path2_in_repos = "/#{file2}"
+    path3_in_repos = "/#{file3}"
+    dir_path_in_repos = "/#{dir}"
+    path = File.join(@wc_path, file)
+    path2 = File.join(@wc_path, file2)
+    path3 = File.join(@wc_path, file3)
+    dir_path = File.join(@wc_path, dir)
+    token = @fs.generate_lock_token
+    make_context(log) do |ctx|
+
+      @fs.transaction do |txn|
+        txn.root.make_file(file)
+        txn.root.make_dir(dir)
+      end
+      ctx.up(@wc_path)
+      assert(File.exist?(path))
+      assert(File.directory?(dir_path))
+
+      @fs.transaction do |txn|
+        txn.root.copy(file2, @fs.root, file)
+        txn.root.delete(file)
+        txn.abort
+      end
+      ctx.up(@wc_path)
+      assert(File.exist?(path))
+      assert(!File.exist?(path2))
+
+      @fs.transaction do |txn|
+        txn.root.copy(file2, @fs.root, file)
+        txn.root.delete(file)
+      end
+      ctx.up(@wc_path)
+      assert(!File.exist?(path))
+      assert(File.exist?(path2))
+
+      prev_root = @fs.root(youngest_rev - 1)
+      assert(!prev_root.contents_changed?(file, @fs.root, file2))
+      File.open(path2, "w") {|f| f.print(src)}
+      ctx.ci(@wc_path)
+      assert(prev_root.contents_changed?(file, @fs.root, file2))
+
+      txn1 = @fs.transaction
+      access = Svn::Fs::Access.new(@author)
+      @fs.access = access
+      @fs.access.add_lock_token(token)
+      assert_equal([], @fs.get_locks(file2))
+      lock = @fs.lock(file2)
+      assert_equal(lock.token, @fs.get_lock(file2).token)
+      assert_equal([lock.token],
+                   @fs.get_locks(file2).collect{|l| l.token})
+      @fs.unlock(file2, lock.token)
+      assert_equal([], @fs.get_locks(file2))
+
+      entries = @fs.root.dir_entries("/")
+      assert_equal([file2, dir].sort, entries.keys.sort)
+      assert_equal(@fs.root.node_id(path2_in_repos).to_s,
+                   entries[file2].id.to_s)
+      assert_equal(@fs.root.node_id(dir_path_in_repos).to_s,
+                   entries[dir].id.to_s)
+
+      @fs.transaction do |txn|
+        prev_root = @fs.root(youngest_rev - 2)
+        txn.root.revision_link(prev_root, file)
+      end
+      ctx.up(@wc_path)
+      assert(File.exist?(path))
+
+      closest_root, closet_path = @fs.root.closest_copy(file2)
+      assert_equal(path2_in_repos, closet_path)
+    end
+  end
+
+  def test_delta(use_deprecated_api=false)
+    log = "sample log"
+    file = "source.txt"
+    src = "a\nb\nc\nd\ne\n"
+    modified = "A\nb\nc\nd\nE\n"
+    result = "a\n\n\n\ne\n"
+    expected = "A\n\n\n\nE\n"
+    path_in_repos = "/#{file}"
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      rev1 = ctx.ci(@wc_path).revision
+
+      File.open(path, "w") {|f| f.print(modified)}
+      @fs.transaction do |txn|
+        checksum = MD5.new(normalize_line_break(result)).hexdigest
+        stream = txn.root.apply_text(path_in_repos, checksum)
+        stream.write(normalize_line_break(result))
+        stream.close
+      end
+      ctx.up(@wc_path)
+      assert_equal(expected, File.open(path){|f| f.read})
+
+      rev2 = ctx.ci(@wc_path).revision
+      if use_deprecated_api
+        stream = @fs.root(rev2).file_delta_stream(@fs.root(rev1),
+                                                  path_in_repos,
+                                                  path_in_repos)
+      else
+        stream = @fs.root(rev1).file_delta_stream(path_in_repos,
+                                                  @fs.root(rev2),
+                                                  path_in_repos)
+      end
+
+      data = ''
+      stream.each{|w| data << w.new_data}
+      assert_equal(normalize_line_break(expected), data)
+
+      File.open(path, "w") {|f| f.print(src)}
+      rev3 = ctx.ci(@wc_path).revision
+
+      File.open(path, "w") {|f| f.print(modified)}
+      @fs.transaction do |txn|
+        base_checksum = MD5.new(normalize_line_break(src)).hexdigest
+        checksum = MD5.new(normalize_line_break(result)).hexdigest
+        handler = txn.root.apply_textdelta(path_in_repos,
+                                           base_checksum, checksum)
+        assert_raises(Svn::Error::ChecksumMismatch) do
+          handler.call(nil)
+        end
+      end
+    end
+  end
+
+  def test_delta_with_deprecated_api
+    test_delta(true)
+  end
+
+  def test_prop
+    log = "sample log"
+    make_context(log) do |ctx|
+      ctx.checkout(@repos_uri, @wc_path)
+      ctx.mkdir(["#{@wc_path}/new_dir"])
+
+      start_time = Time.now
+      info = ctx.commit([@wc_path])
+
+      assert_equal(@author, info.author)
+      assert_equal(@fs.youngest_rev, info.revision)
+      assert_operator(start_time..(Time.now), :include?, info.date)
+
+      assert_equal(@author, @fs.prop(Svn::Core::PROP_REVISION_AUTHOR))
+      assert_equal(log, @fs.prop(Svn::Core::PROP_REVISION_LOG))
+      assert_equal([
+                     Svn::Core::PROP_REVISION_AUTHOR,
+                     Svn::Core::PROP_REVISION_DATE,
+                     Svn::Core::PROP_REVISION_LOG,
+                   ].sort,
+                   @fs.proplist.keys.sort)
+      @fs.set_prop(Svn::Core::PROP_REVISION_LOG, nil)
+      assert_nil(@fs.prop(Svn::Core::PROP_REVISION_LOG))
+      assert_equal([
+                     Svn::Core::PROP_REVISION_AUTHOR,
+                     Svn::Core::PROP_REVISION_DATE,
+                   ].sort,
+                   @fs.proplist.keys.sort)
+    end
+  end
+
+  def assert_recover
+    path = File.join(@tmp_path, "fs")
+    fs_type = Svn::Fs::TYPE_FSFS
+    config = {Svn::Fs::CONFIG_FS_TYPE => fs_type}
+
+    yield(:create, [path, config])
+
+    assert_nothing_raised do
+      yield(:recover, [path], Proc.new{})
+    end
+  end
+
+  def test_recover_for_backward_compatibility
+    assert_recover do |method, args, block|
+      Svn::Fs::FileSystem.__send__(method, *args, &block)
+    end
+  end
+
+  def test_recover
+    assert_recover do |method, args, block|
+      Svn::Fs.__send__(method, *args, &block)
+    end
+  end
+
+  def test_deleted_revision
+    file = "file"
+    log = "sample log"
+    path = File.join(@wc_path, file)
+    path_in_repos = "/#{file}"
+    make_context(log) do |ctx|
+
+      FileUtils.touch(path)
+      ctx.add(path)
+      rev1 = ctx.ci(@wc_path).revision
+
+      ctx.rm_f(path)
+      rev2 = ctx.ci(@wc_path).revision
+
+      FileUtils.touch(path)
+      ctx.add(path)
+      rev3 = ctx.ci(@wc_path).revision
+
+      ctx.rm_f(path)
+      rev4 = ctx.ci(@wc_path).revision
+
+      assert_equal(Svn::Core::INVALID_REVNUM,
+                   @fs.deleted_revision(path_in_repos, 0, rev4))
+      assert_equal(rev2, @fs.deleted_revision(path_in_repos, rev1, rev4))
+      assert_equal(Svn::Core::INVALID_REVNUM,
+                   @fs.deleted_revision(path_in_repos, rev2, rev4))
+      assert_equal(rev4, @fs.deleted_revision(path_in_repos, rev3, rev4))
+      assert_equal(Svn::Core::INVALID_REVNUM,
+                   @fs.deleted_revision(path_in_repos, rev4, rev4))
+    end
+  end
+
+  def test_mergeinfo
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample\n"
+    trunk = File.join(@wc_path, "trunk")
+    branch = File.join(@wc_path, "branch")
+    trunk_path = File.join(trunk, file)
+    branch_path = File.join(branch, file)
+    trunk_in_repos = "/trunk"
+    branch_in_repos = "/branch"
+
+    make_context(log) do |ctx|
+      ctx.mkdir(trunk, branch)
+      File.open(trunk_path, "w") {}
+      File.open(branch_path, "w") {}
+      ctx.add(trunk_path)
+      ctx.add(branch_path)
+      rev1 = ctx.commit(@wc_path).revision
+
+      File.open(branch_path, "w") {|f| f.print(src)}
+      rev2 = ctx.commit(@wc_path).revision
+
+      assert_equal({}, @fs.root.mergeinfo(trunk_in_repos))
+      ctx.merge(branch, rev1, branch, rev2, trunk)
+      assert_equal({}, @fs.root.mergeinfo(trunk_in_repos))
+
+      rev3 = ctx.commit(@wc_path).revision
+      mergeinfo = Svn::Core::MergeInfo.parse("#{branch_in_repos}:2")
+      assert_equal({trunk_in_repos => mergeinfo},
+                   @fs.root.mergeinfo(trunk_in_repos))
+
+      ctx.rm(branch_path)
+      rev4 = ctx.commit(@wc_path).revision
+
+      ctx.merge(branch, rev3, branch, rev4, trunk)
+      assert(!File.exist?(trunk_path))
+      rev5 = ctx.commit(@wc_path).revision
+      assert_equal({trunk_in_repos => Svn::Core::MergeInfo.parse("#{branch_in_repos}:2,4")},
+                   @fs.root.mergeinfo(trunk_in_repos))
+    end
+  end
+end