# ====================================================================
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ====================================================================
require "my-assertions"
require "util"
require "svn/core"
require "svn/wc"
require "svn/repos"
require "svn/ra"
class SvnWcTest < 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::Wc.version)
end
def test_status
file1 = "a"
file1_path = File.join(@wc_path, file1)
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 0) do |adm|
status = adm.status(file1_path)
assert_equal(Svn::Wc::STATUS_NONE, status.text_status)
assert_nil(status.entry)
end
non_exist_child_path = File.join(@wc_path, "NOT-EXIST")
assert_nothing_raised do
Svn::Wc::AdmAccess.probe_open(nil, non_exist_child_path, false, 0){}
end
FileUtils.touch(file1_path)
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 0) do |adm|
status = adm.status(file1_path)
assert_equal(Svn::Wc::STATUS_UNVERSIONED, status.text_status)
assert_nil(status.entry)
end
log = "sample log"
make_context(log) do |ctx|
ctx.add(file1_path)
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 0) do |adm|
status = adm.status(file1_path)
assert_equal(Svn::Wc::STATUS_ADDED, status.text_status)
end
commit_info = ctx.commit(@wc_path)
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 0) do |adm|
status = adm.status(file1_path)
assert_equal(Svn::Wc::STATUS_NORMAL, status.text_status)
assert_equal(commit_info.revision, status.entry.revision)
end
end
end
def test_wc
assert_not_equal(0, Svn::Wc.check_wc(@wc_path))
assert(Svn::Wc.normal_prop?("name"))
assert(Svn::Wc.wc_prop?("#{Svn::Core::PROP_WC_PREFIX}name"))
assert(Svn::Wc.entry_prop?("#{Svn::Core::PROP_ENTRY_PREFIX}name"))
end
def test_adm_access
log = "sample log"
source = "sample source"
dir = "dir"
file = "file"
prop_name = "name"
prop_value = "value"
dir_path = File.join(@wc_path, dir)
path = File.join(dir_path, file)
make_context(log) do |ctx|
ctx.mkdir(dir_path)
File.open(path, "w") {|f| f.print(source)}
ctx.add(path)
rev = ctx.ci(@wc_path).revision
result = Svn::Wc::AdmAccess.open_anchor(path, true, 5)
anchor_access, target_access, target = result
assert_equal(file, target)
assert_equal(dir_path, anchor_access.path)
assert_equal(dir_path, target_access.path)
assert(anchor_access.locked?)
assert(target_access.locked?)
assert(!target_access.has_binary_prop?(path))
assert(!target_access.text_modified?(path))
assert(!target_access.props_modified?(path))
File.open(path, "w") {|f| f.print(source * 2)}
target_access.set_prop(prop_name, prop_value, path)
assert_equal(prop_value, target_access.prop(prop_name, path))
assert_equal({prop_name => prop_value},
target_access.prop_list(path))
assert(target_access.text_modified?(path))
assert(target_access.props_modified?(path))
target_access.set_prop("name", nil, path)
assert(!target_access.props_modified?(path))
target_access.revert(path)
assert(!target_access.text_modified?(path))
assert(!target_access.props_modified?(path))
anchor_access.close
target_access.close
access = Svn::Wc::AdmAccess.probe_open(nil, path, false, 5)
assert(!Svn::Wc.default_ignores({}).empty?)
assert_equal(Svn::Wc.default_ignores({}), access.ignores({}))
assert(access.wc_root?(@wc_path))
access.close
access = Svn::Wc::AdmAccess.probe_open(nil, @wc_path, false, 5)
assert_equal(@wc_path, access.path)
assert_equal(dir_path, access.retrieve(dir_path).path)
assert_equal(dir_path, access.probe_retrieve(dir_path).path)
assert_equal(dir_path, access.probe_try(dir_path, false, 5).path)
access.close
Svn::Wc::AdmAccess.probe_open(nil, @wc_path, false, 5) do |access|
assert(!access.locked?)
end
Svn::Wc::AdmAccess.probe_open(nil, @wc_path, true, 5) do |access|
assert(access.locked?)
end
end
end
def test_traversal_info
info = Svn::Wc::TraversalInfo.new
assert_equal([{}, {}], info.edited_externals)
end
def assert_externals_description
dir = "dir"
url = "http://svn.example.com/trunk"
description = "#{dir} #{url}"
items = yield([@wc_path, description])
assert_equal([[dir, url]],
items.collect {|item| [item.target_dir, item.url]})
assert_kind_of(Svn::Wc::ExternalItem2, items.first)
end
def test_externals_description
assert_externals_description do |args|
Svn::Wc::ExternalsDescription.parse(*args)
end
end
def test_externals_description_for_backward_compatibility
assert_externals_description do |args|
Svn::Wc.parse_externals_description(*args)
end
end
def test_notify
path = @wc_path
action = Svn::Wc::NOTIFY_SKIP
notify = Svn::Wc::Notify.new(path, action)
assert_equal(path, notify.path)
assert_equal(action, notify.action)
notify2 = notify.dup
assert_equal(path, notify2.path)
assert_equal(action, notify2.action)
end
def test_entry
log = "sample log"
source1 = "source"
source2 = "SOURCE"
source3 = "SHOYU"
file = "file"
path = File.join(@wc_path, file)
make_context(log) do |ctx|
File.open(path, "w") {|f| f.print(source1)}
ctx.add(path)
rev1 = ctx.ci(@wc_path).revision
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 5) do |access|
show = true
entry = Svn::Wc::Entry.new(path, access, show)
assert_equal(file, entry.name)
assert_equal(file, entry.dup.name)
entries = access.read_entries
assert_equal(["", file].sort, entries.keys.sort)
entry = entries[file]
assert_equal(file, entry.name)
assert(!entry.conflicted?(@wc_path))
end
File.open(path, "w") {|f| f.print(source2)}
rev2 = ctx.ci(@wc_path).revision
ctx.up(@wc_path, rev1)
File.open(path, "w") {|f| f.print(source3)}
ctx.up(@wc_path, rev2)
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
entry = access.read_entries[file]
assert(entry.conflicted?(@wc_path))
assert(entry.text_conflicted?(@wc_path))
assert(!entry.prop_conflicted?(@wc_path))
access.resolved_conflict(path)
assert(!entry.conflicted?(@wc_path))
access.process_committed(@wc_path, rev2 + 1)
end
end
end
def test_committed_queue
log = "sample log"
source1 = "source"
source2 = "SOURCE"
file1 = "file1"
file2 = "file2"
path1 = File.join(@wc_path, file1)
path2 = File.join(@wc_path, file2)
make_context(log) do |ctx|
File.open(path1, "w") {|f| f.print(source1)}
File.open(path2, "w") {|f| f.print(source2)}
ctx.add(path1)
ctx.add(path2)
rev1 = ctx.ci(@wc_path).revision
next_rev = rev1 + 1
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
queue = Svn::Wc::CommittedQueue.new
queue.push(access, path1, true, {"my-prop" => "value"})
queue.process(access, next_rev)
end
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
queue = Svn::Wc::CommittedQueue.new
queue.push(access, path1, true, [Svn::Core::Prop.new("my-prop", "value")])
queue.process(access, next_rev)
end
end
end
def test_ancestry
file1 = "file1"
file2 = "file2"
path1 = File.join(@wc_path, file1)
path2 = File.join(@wc_path, file2)
log = "sample log"
make_context(log) do |ctx|
FileUtils.touch(path1)
ctx.add(path1)
rev1 = ctx.ci(@wc_path).revision
ctx.cp(path1, path2)
rev2 = ctx.ci(@wc_path).revision
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 5) do |access|
assert_equal(["#{@repos_uri}/#{file2}", rev2],
access.ancestry(path2))
result = []
callbacks = Proc.new do |path, entry|
result << [path, entry]
end
def callbacks.found_entry(path, entry)
call(path, entry)
end
access.walk_entries(@wc_path, callbacks)
assert_equal([@wc_path, path1, path2].sort,
result.collect{|path, entry| path}.sort)
entry = result.assoc(path2)[1]
assert_equal(file2, entry.name)
callbacks = Proc.new do |path, entry|
raise Svn::Error::Cancelled
end
def callbacks.found_entry(path, entry)
call(path, entry)
end
assert_raises(Svn::Error::Cancelled) do
access.walk_entries(@wc_path, callbacks)
end
def callbacks.ignored_errors=(value)
@ignored_errors = value
end
def callbacks.handle_error(path, err)
@ignored_errors << [path, err] if err
end
ignored_errors = []
callbacks.ignored_errors = ignored_errors
access.walk_entries(@wc_path, callbacks)
sorted_ignored_errors = ignored_errors.sort_by {|path, err| path}
sorted_ignored_errors = sorted_ignored_errors.collect! do |path, err|
[path, err.class]
end
assert_equal([
[@wc_path, Svn::Error::Cancelled],
[path1, Svn::Error::Cancelled],
[path2, Svn::Error::Cancelled],
],
sorted_ignored_errors)
end
end
end
def test_adm_ensure
adm_dir = Dir.glob(File.join(@wc_path, "{.,_}svn")).first
assert(File.exists?(adm_dir))
FileUtils.rm_rf(adm_dir)
assert(!File.exists?(adm_dir))
Svn::Wc.ensure_adm(@wc_path, @fs.uuid, @repos_uri, @repos_uri, 0)
assert(File.exists?(adm_dir))
end
def test_merge
left = <<-EOL
a
b
c
d
e
EOL
right = <<-EOR
A
b
c
d
E
EOR
merge_target = <<-EOM
a
b
C
d
e
EOM
expect = <<-EOE
A
b
C
d
E
EOE
left_label = "left"
right_label = "right"
merge_target_label = "merge_target"
left_file = "left"
right_file = "right"
merge_target_file = "merge_target"
left_path = File.join(@wc_path, left_file)
right_path = File.join(@wc_path, right_file)
merge_target_path = File.join(@wc_path, merge_target_file)
log = "sample log"
make_context(log) do |ctx|
File.open(left_path, "w") {|f| f.print(left)}
File.open(right_path, "w") {|f| f.print(right)}
File.open(merge_target_path, "w") {|f| f.print(merge_target)}
ctx.add(left_path)
ctx.add(right_path)
ctx.add(merge_target_path)
ctx.ci(@wc_path)
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
assert_equal(Svn::Wc::MERGE_MERGED,
access.merge(left_path, right_path, merge_target_path,
left_label, right_label, merge_target_label))
assert_equal(expect, File.read(merge_target_path))
end
end
end
def test_status
source = "source"
file1 = "file1"
file2 = "file2"
file3 = "file3"
file4 = "file4"
file5 = "file5"
path1 = File.join(@wc_path, file1)
path2 = File.join(@wc_path, file2)
path3 = File.join(@wc_path, file3)
path4 = File.join(@wc_path, file4)
path5 = File.join(@wc_path, file5)
log = "sample log"
make_context(log) do |ctx|
File.open(path1, "w") {|f| f.print(source)}
ctx.add(path1)
rev1 = ctx.ci(@wc_path).revision
ctx.cp(path1, path2)
rev2 = ctx.ci(@wc_path).revision
FileUtils.rm(path1)
Svn::Wc::AdmAccess.open(nil, @wc_path, false, 5) do |access|
status = access.status(path1)
assert_equal(Svn::Wc::STATUS_MISSING, status.text_status)
assert_equal(Svn::Wc::STATUS_MISSING, status.dup.text_status)
end
ctx.revert(path1)
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
access.copy(path1, file3)
assert(File.exist?(path3))
access.delete(path1)
assert(!File.exist?(path1))
FileUtils.touch(path4)
access.add(path4)
assert(File.exist?(path4))
access.add_repos_file2(path5, path2, {})
assert_equal(source, File.open(path5) {|f| f.read})
status = access.status(path2)
assert_equal(Svn::Wc::STATUS_MISSING, status.text_status)
access.remove_from_revision_control(file2)
status = access.status(path2)
assert_equal(Svn::Wc::STATUS_NONE, status.text_status)
end
end
end
def test_delete
source = "source"
file = "file"
path = File.join(@wc_path, file)
log = "sample log"
make_context(log) do |ctx|
File.open(path, "w") {|f| f.print(source)}
ctx.add(path)
ctx.ci(@wc_path).revision
assert(File.exists?(path))
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
access.delete(path)
end
assert(!File.exists?(path))
ctx.revert(path)
assert(File.exists?(path))
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
access.delete(path, nil, nil, true)
end
assert(File.exists?(path))
end
end
def test_locked
assert(!Svn::Wc.locked?(@wc_path))
Svn::Wc::AdmAccess.open(nil, @wc_path, true, -1) do |access|
assert(Svn::Wc.locked?(@wc_path))
end
assert(!Svn::Wc.locked?(@wc_path))
Svn::Wc::AdmAccess.open(nil, @wc_path, false, -1) do |access|
assert(!Svn::Wc.locked?(@wc_path))
end
assert(!Svn::Wc.locked?(@wc_path))
end
def assert_translated_eol(method_name)
src_file = "src"
crlf_file = "crlf"
cr_file = "cr"
lf_file = "lf"
src_path = File.join(@wc_path, src_file)
crlf_path = File.join(@wc_path, crlf_file)
cr_path = File.join(@wc_path, cr_file)
lf_path = File.join(@wc_path, lf_file)
source = "a\n"
crlf_source = source.gsub(/\n/, "\r\n")
cr_source = source.gsub(/\n/, "\r")
lf_source = source.gsub(/\n/, "\n")
File.open(crlf_path, "w") {}
File.open(cr_path, "w") {}
File.open(lf_path, "w") {}
log = "log"
make_context(log) do |ctx|
ctx.add(crlf_path)
ctx.add(cr_path)
ctx.add(lf_path)
ctx.prop_set("svn:eol-style", "CRLF", crlf_path)
ctx.prop_set("svn:eol-style", "CR", cr_path)
ctx.prop_set("svn:eol-style", "LF", lf_path)
ctx.ci(crlf_path)
ctx.ci(cr_path)
ctx.ci(lf_path)
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
_my_assert_block do
File.open(src_path, "wb") {|f| f.print(source)}
args = [method_name, src_path, crlf_path, Svn::Wc::TRANSLATE_FROM_NF]
result = yield(access.send(*args), source)
result ||= File.open(src_path, "rb") {|f| f.read}
assert_equal(crlf_source, result)
File.open(src_path, "wb") {|f| f.print(source)}
args = [method_name, src_path, cr_path, Svn::Wc::TRANSLATE_FROM_NF]
result = yield(access.send(*args), source)
result ||= File.open(src_path, "rb") {|f| f.read}
assert_equal(cr_source, result)
File.open(src_path, "wb") {|f| f.print(source)}
args = [method_name, src_path, lf_path, Svn::Wc::TRANSLATE_FROM_NF]
result = yield(access.send(*args), source)
result ||= File.open(src_path, "rb") {|f| f.read}
assert_equal(lf_source, result)
end
end
end
end
def test_translated_file_eol
assert_translated_eol(:translated_file) do |name, source|
File.open(name, "rb") {|f| f.read}
end
end
def test_translated_file2_eol
assert_translated_eol(:translated_file2) do |file, source|
result = file.read
file.close
result
end
end
def test_translated_stream_eol
assert_translated_eol(:translated_stream) do |stream, source|
if source
stream.write(source)
stream.close
nil
else
stream.read
end
end
end
def assert_translated_keyword(method_name)
src_file = "$Revision$"
revision_file = "revision_file"
src_path = File.join(@wc_path, src_file)
revision_path = File.join(@wc_path, revision_file)
source = "$Revision$\n"
revision_source = source.gsub(/\$Revision\$/, "$Revision: 1 $")
File.open(revision_path, "w") {}
log = "log"
make_context(log) do |ctx|
ctx.add(revision_path)
ctx.prop_set("svn:keywords", "Revision", revision_path)
ctx.ci(revision_path)
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |access|
File.open(src_path, "wb") {|f| f.print(source)}
args = [method_name, src_path, revision_path, Svn::Wc::TRANSLATE_FROM_NF]
result = yield(access.send(*args), source)
result ||= File.open(src_path, "rb") {|f| f.read}
assert_equal(revision_source, result)
File.open(src_path, "wb") {|f| f.print(source)}
args = [method_name, src_path, revision_path, Svn::Wc::TRANSLATE_TO_NF]
assert_equal(source, yield(access.send(*args)))
end
end
end
def test_translated_file_keyword
assert_translated_keyword(:translated_file) do |name, source|
File.open(name, "rb") {|f| f.read}
end
end
def test_translated_file2_keyword
assert_translated_keyword(:translated_file2) do |file, source|
file.read
end
end
def test_translated_stream_keyword
assert_translated_keyword(:translated_stream) do |stream, source|
if source
stream.write(source)
stream.close
nil
else
result = stream.read
stream.close
result
end
end
end
def test_revision_status
log = "log"
file = "file"
path = File.join(@wc_path, file)
File.open(path, "w") {|f| f.print("a")}
make_context(log) do |ctx|
ctx.add(path)
ctx.ci(path)
File.open(path, "w") {|f| f.print("bb")}
ctx.ci(path)
File.open(path, "w") {|f| f.print("ccc")}
rev = ctx.ci(path).revision
status = Svn::Wc::RevisionStatus.new(path, nil, true)
assert_equal(rev, status.min_rev)
assert_equal(rev, status.max_rev)
end
end
def test_external_item_new
assert_raises(NoMethodError) do
Svn::Wc::ExternalItem.new
end
item = Svn::Wc::ExternalItem2.new
assert_kind_of(Svn::Wc::ExternalItem2, item)
end
def test_external_item_dup
item = Svn::Wc::ExternalItem2.new
assert_kind_of(Svn::Wc::ExternalItem2, item)
item.target_dir = "xxx"
duped_item = item.dup
assert_equal(item.target_dir, duped_item.target_dir)
end
def test_committed_queue_new
queue = Svn::Wc::CommittedQueue.new
assert_kind_of(Svn::Wc::CommittedQueue, queue)
end
def assert_diff_callbacks(method_name)
log = "sample log"
file1 = "hello.txt"
file2 = "hello2.txt"
src = "Hello"
dir = "dir"
dir_path = File.join(@wc_path, dir)
path1 = File.join(dir_path, file1)
path2 = File.join(dir_path, file2)
prop_name = "my-prop"
prop_value = "value"
make_context(log) do |ctx|
config = {}
callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
FileUtils.mkdir(dir_path)
File.open(path1, "w") {|f| f.print(src)}
ctx.add(dir_path)
rev1 = ctx.commit(@wc_path).revision
File.open(path1, "w") {|f| f.print(src * 2)}
File.open(path2, "w") {|f| f.print(src)}
ctx.add(path2)
ctx.prop_set(prop_name, prop_value, path1)
Svn::Wc::AdmAccess.open(nil, @wc_path, true, 5) do |adm|
callbacks = Object.new
def callbacks.result
@result
end
def callbacks.result=(result)
@result = result
end
def callbacks.file_added(access, path, tmpfile1, tmpfile2, rev1,
rev2, mimetype1, mimetype2,
prop_changes, original_props)
@result << [:file_added, path, prop_changes]
[Svn::Wc::NOTIFY_STATE_UNCHANGED, Svn::Wc::NOTIFY_STATE_UNCHANGED]
end
def callbacks.file_changed(access, path, tmpfile1, tmpfile2, rev1,
rev2, mimetype1, mimetype2,
prop_changes, original_props)
@result << [:file_changed, path, prop_changes]
[Svn::Wc::NOTIFY_STATE_UNCHANGED, Svn::Wc::NOTIFY_STATE_UNCHANGED]
end
def callbacks.dir_props_changed(access, path, prop_changes, original_props)
@result << [:dir_props_changed, path, prop_changes]
Svn::Wc::NOTIFY_STATE_UNCHANGED
end
callbacks.result = []
editor = adm.__send__(method_name, dir, callbacks)
reporter = session.diff(rev1, "", @repos_uri, editor)
adm.crawl_revisions(dir_path, reporter)
property_info = {
:file_changed_prop_name => prop_name,
:file_changed_prop_value => prop_value,
}
sorted_result = callbacks.result.sort_by {|r| r.first.to_s}
expected_props, actual_result = yield(property_info, sorted_result)
file_changed_props, empty_changed_props = expected_props
assert_equal([
[:file_added, path2, empty_changed_props],
[:file_changed, path1, file_changed_props],
],
sorted_result)
end
end
end
end
def test_diff_callbacks_for_backward_compatibility
assert_diff_callbacks(:diff_editor) do |property_info, result|
prop_name = property_info[:file_changed_prop_name]
prop_value = property_info[:file_changed_prop_value]
file_changed_props = [Svn::Core::Prop.new(prop_name, prop_value)]
empty_changed_props = []
sorted_result = result.dup
[[file_changed_props, empty_changed_props],
sorted_result]
end
end
def test_diff_callbacks
assert_diff_callbacks(:diff_editor2) do |property_info, result|
prop_name = property_info[:file_changed_prop_name]
prop_value = property_info[:file_changed_prop_value]
file_changed_props = {prop_name => prop_value}
empty_changed_props = {}
[[file_changed_props, empty_changed_props],
result]
end
end
def test_update_editor
log = "sample log"
file1 = "hello.txt"
file2 = "hello2.txt"
src = "Hello"
dir = "dir"
dir_path = File.join(@wc_path, dir)
path1 = File.join(dir_path, file1)
path2 = File.join(dir_path, file2)
make_context(log) do |ctx|
config = {}
callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
FileUtils.mkdir(dir_path)
File.open(path1, "w") {|f| f.print(src)}
ctx.add(dir_path)
rev1 = ctx.commit(@wc_path).revision
File.open(path1, "w") {|f| f.print(src * 2)}
File.open(path2, "w") {|f| f.print(src)}
ctx.add(path2)
rev2 = ctx.commit(@wc_path).revision
assert(File.exists?(path2))
assert_equal(0, ctx.up(@wc_path, 0))
assert(!File.exists?(path2))
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
editor = access.update_editor('', 0)
assert_equal(0, editor.target_revision)
reporter = session.update2(rev2, "", editor)
access.crawl_revisions(@wc_path, reporter)
assert_equal(rev2, editor.target_revision)
end
end
end
end
def test_update_editor_options
log = "sample log"
file1 = "hello.txt"
file2 = "hello2.txt"
src = "Hello"
dir = "dir"
dir_path = File.join(@wc_path, dir)
path1 = File.join(dir_path, file1)
path2 = File.join(dir_path, file2)
make_context(log) do |ctx|
config = {}
callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
Svn::Ra::Session.open(@repos_uri) do |session|
FileUtils.mkdir(dir_path)
File.open(path1, "w") {|f| f.print(src)}
ctx.add(dir_path)
rev1 = ctx.commit(@wc_path).revision
File.open(path1, "w") {|f| f.print(src * 2)}
File.open(path2, "w") {|f| f.print(src)}
ctx.add(path2)
rev2 = ctx.commit(@wc_path).revision
assert(File.exists?(path2))
assert_equal(0, ctx.up(@wc_path, 0))
assert(!File.exists?(path2))
notification_count = 0
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
notify_func = Proc.new {|n| notification_count += 1}
assert_raises(ArgumentError) do
access.update_editor2(:target_revision => 0,
:target => '',
:notify_fun => notify_func)
end
editor = access.update_editor('', 0, true, nil, false, nil,
notify_func)
assert_equal(0, editor.target_revision)
reporter = session.update2(rev2, "", editor)
access.crawl_revisions(@wc_path, reporter)
assert_equal(rev2, editor.target_revision)
end
assert_equal(4, notification_count, "wrong number of notifications")
end
end
end
def test_update_editor2_conflict_func
log = "sample log"
source1 = "source"
source2 = "SOURCE"
source3 = "SHOYU"
file = "file"
path = File.join(@wc_path, file)
make_context(log) do |ctx|
File.open(path, "w") {|f| f.print(source1)}
ctx.add(path)
rev1 = ctx.ci(@wc_path).revision
File.open(path, "w") {|f| f.print(source2)}
rev2 = ctx.ci(@wc_path).revision
ctx.up(@wc_path, rev1)
File.open(path, "w") {|f| f.print(source3)}
Svn::Ra::Session.open(@repos_uri) do |session|
conflicted_paths = {}
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
editor = access.update_editor2(
:target => '',
:conflict_func => lambda{|n|
conflicted_paths[n.path]=true
Svn::Wc::CONFLICT_CHOOSE_MERGED
},
:target_revision => 0
)
assert_equal(0, editor.target_revision)
reporter = session.update2(rev2, "", editor)
access.crawl_revisions(@wc_path, reporter)
assert_equal(rev2, editor.target_revision)
end
assert_equal([File.expand_path(path)], conflicted_paths.keys);
end
end
end
def test_switch_editor
log = "sample log"
file1 = "hello.txt"
file2 = "hello2.txt"
src = "Hello"
dir1 = "dir1"
dir2 = "dir2"
dir1_path = File.join(@wc_path, dir1)
dir2_path = File.join(@wc_path, dir2)
dir1_uri = "#{@repos_uri}/#{dir1}"
dir2_uri = "#{@repos_uri}/#{dir2}"
path1 = File.join(dir1_path, file1)
path2 = File.join(dir2_path, file2)
make_context(log) do |ctx|
config = {}
callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
FileUtils.mkdir(dir1_path)
File.open(path1, "w") {|f| f.print(src)}
ctx.add(dir1_path)
rev1 = ctx.commit(@wc_path).revision
FileUtils.mkdir(dir2_path)
File.open(path2, "w") {|f| f.print(src)}
ctx.add(dir2_path)
rev2 = ctx.commit(@wc_path).revision
assert(File.exists?(path1))
assert_equal(rev2, ctx.switch(@wc_path, dir2_uri))
assert(File.exists?(File.join(@wc_path, file2)))
Svn::Wc::AdmAccess.open_anchor(@wc_path) do |access, dir_access, target|
editor = dir_access.switch_editor('', dir1_uri, rev2)
assert_equal(rev2, editor.target_revision)
reporter = session.switch2(rev1, dir1, dir1_uri, editor)
dir_access.crawl_revisions(@wc_path, reporter)
assert_equal(rev1, editor.target_revision)
end
end
end
end
def test_relocate
log = "sample log"
file1 = "hello.txt"
file2 = "hello2.txt"
src = "Hello"
dir1 = "dir1"
dir2 = "dir2"
dir1_path = File.join(@wc_path, dir1)
dir2_path = File.join(@wc_path, dir2)
dir1_uri = "#{@repos_uri}/#{dir1}"
dir2_uri = "#{@repos_uri}/#{dir2}"
path1 = File.join(dir1_path, file1)
path2 = File.join(dir2_path, file2)
make_context(log) do |ctx|
config = {}
callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
FileUtils.mkdir(dir1_path)
File.open(path1, "w") {|f| f.print(src)}
ctx.add(dir1_path)
rev1 = ctx.commit(@wc_path).revision
FileUtils.mkdir(dir2_path)
File.open(path2, "w") {|f| f.print(src)}
ctx.add(dir2_path)
rev2 = ctx.commit(@wc_path).revision
Svn::Wc::AdmAccess.probe_open(nil, @wc_path) do |access|
assert(@repos_uri, access.entry(@wc_path).url)
values = []
access.relocate(@wc_path, @repos_uri, dir2_uri) do |uuid, url, root_url|
values << [uuid, url, root_url]
end
assert(!values.empty?)
assert(dir2_uri, access.entry(@wc_path).url)
end
end
end
end
def test_ignore?
assert(!Svn::Wc.ignore?("xxx.c", []))
assert(Svn::Wc.ignore?("xxx.c", ["*.c"]))
assert(!Svn::Wc.ignore?("xxx.c", ["XXX.c"]))
assert(Svn::Wc.ignore?("xxx.c", ["xxx.c"]))
assert(!Svn::Wc.ignore?("xxx.c", ["*.H", "*.C"]))
assert(Svn::Wc.ignore?("xxx.C", ["*.H", "*.C"]))
end
def test_changelist
log = "sample log"
file = "hello.txt"
src = "Hello"
path = File.join(@wc_path, file)
make_context(log) do |ctx|
File.open(path, "w") {|f| f.print(src)}
ctx.add(path)
rev1 = ctx.commit(@wc_path).revision
end
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
assert_nil(access.entry(@wc_path).changelist)
end
notifies = []
notify_collector = Proc.new {|notify| notifies << notify }
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
access.set_changelist(path, "123", nil, notify_collector)
end
assert_equal([[File.expand_path(path), nil]],
notifies.collect {|notify| [notify.path, notify.err]})
notifies = []
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
access.set_changelist(path, "456", nil, notify_collector)
end
assert_equal([[File.expand_path(path), Svn::Wc::NOTIFY_CHANGELIST_CLEAR],
[File.expand_path(path), Svn::Wc::NOTIFY_CHANGELIST_SET]],
notifies.collect {|notify| [notify.path, notify.action]})
notifies = []
Svn::Wc::AdmAccess.open(nil, @wc_path) do |access|
access.set_changelist(@wc_path, "789", nil, notify_collector)
end
end
def test_context_new_default_config
assert_not_nil context = Svn::Wc::Context.new
ensure
context.destroy
end
def test_context_new_specified_config
config_file = File.join(@config_path, Svn::Core::CONFIG_CATEGORY_CONFIG)
config = Svn::Core::Config.read(config_file)
assert_not_nil context = Svn::Wc::Context.new(:config=>config)
ensure
context.destroy
end
def test_context_create
assert_nothing_raised do
result = Svn::Wc::Context.create do |context|
assert_not_nil context
assert_kind_of Svn::Wc::Context, context
end
if RUBY_VERSION > '1.9'
assert_equal(result,true)
else
assert_nil result
end
end
end
end