def copy_A(dest_name, rev):
expected = verify.UnorderedOutput([
"A " + sbox.ospath(path_join(dest_name, p)) + "\n"
for p in A_paths
])
expected_status.add({
path_join(dest_name, p): Item(status=' ', wc_rev=rev)
for p in A_paths
})
expected_disk.add(
{path_join(dest_name, p): greek_file_item(p)
for p in A_paths})
# Make a branch A_COPY to merge into.
actions.run_and_verify_svn(expected, [], 'copy', sbox.repo_url + "/A",
os.path.join(wc_dir, dest_name))
expected_output = wc.State(wc_dir, {dest_name: Item(verb='Adding')})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
def copy_A(dest_name, rev):
expected = verify.UnorderedOutput(
[ "A " + sbox.ospath(path_join(dest_name, p)) + "\n"
for p in A_paths ])
expected_status.add(
{ path_join(dest_name, p) : Item(status=' ', wc_rev=rev)
for p in A_paths })
expected_disk.add(
{ path_join(dest_name, p) : greek_file_item(p)
for p in A_paths })
# Make a branch A_COPY to merge into.
actions.run_and_verify_svn(expected, [], 'copy',
sbox.repo_url + "/A",
os.path.join(wc_dir,
dest_name))
expected_output = wc.State(wc_dir, {dest_name : Item(verb='Adding')})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
def ensure_tree_conflict(sbox, operation,
incoming_scenarios, localmod_scenarios,
commit_local_mods):
sbox.build()
wc_dir = sbox.wc_dir
def url_of(repo_relative_path):
return sbox.repo_url + '/' + repo_relative_path
verbose_print("")
verbose_print("=== Starting a set of '" + operation + "' tests.")
# Path to source branch, relative to wc_dir.
# Source is where the "incoming" mods are made.
source_br = "branch1"
verbose_print("--- Creating changes in repos")
source_wc_dir = os.path.join(wc_dir, source_br)
source_left_rev, source_right_rev = set_up_repos(wc_dir, source_wc_dir,
incoming_scenarios)
head_rev = source_right_rev ### assumption
# Local mods are the outer loop because cleaning up the WC is slow
# ('svn revert' isn't sufficient because it leaves unversioned files)
for _loc_init_mods, loc_action in localmod_scenarios:
# Determine the branch (directory) in which local mods will be made.
if operation == 'update':
# Path to target branch (where conflicts are raised), relative to wc_dir.
target_br = source_br
target_start_rev = source_left_rev
else: # switch/merge
# Make, and work in, a "branch2" that is a copy of "branch1".
target_br = "branch2"
run_and_verify_svn(None, AnyOutput, [],
'copy', '-r', str(source_left_rev), url_of(source_br),
url_of(target_br),
'-m', 'Create target branch.')
head_rev += 1
target_start_rev = head_rev
main.run_svn(None, 'checkout', '-r', str(target_start_rev), sbox.repo_url,
wc_dir)
saved_cwd = os.getcwd()
os.chdir(wc_dir)
for _inc_init_mods, inc_action in incoming_scenarios:
scen_name = "_".join(inc_action)
source_url = url_of(source_br + '/' + scen_name)
target_path = os.path.join(target_br, scen_name)
verbose_print("=== " + str(inc_action) + " onto " + str(loc_action))
verbose_print("--- Making local mods")
for modaction in loc_action:
modify(modaction, localmod_paths(".", target_path))
if commit_local_mods:
run_and_verify_svn(None, AnyOutput, [],
'commit', target_path,
'-m', 'Mods in target branch.')
head_rev += 1
# What do we want to test for? (This selection could in future be
# passed in to this function as a parameter.)
test_what = [
'commit-ood',
'action', # required for any of the following ones to work
'notify',
'commit-c',
'status-c',
'resolve', # required for any of the following ones to work
'status-nc',
#'commit-ok',
]
if 'commit-ood' in test_what:
# For update, verify the pre-condition that WC is out of date.
# For switch/merge, there is no such precondition.
if operation == 'update':
verbose_print("--- Trying to commit (expecting 'out-of-date' error)")
run_and_verify_commit(".", None, None, "Commit failed",
target_path)
if modaction.startswith('f'):
victim = os.path.join(target_path, 'F')
else:
victim = os.path.join(target_path, 'D')
# Perform the operation that tries to apply incoming changes to the WC.
# The command is expected to do something (and give some output),
# and it should raise a conflict but not an error.
if 'action' in test_what:
# Determine what notification to expect
if 'notify' in test_what:
expected_stdout = svntest.verify.ExpectedOutput(" C " + victim
+ "\n",
match_all=False)
else:
expected_stdout = svntest.verify.AnyOutput
# Do the main action
if operation == 'update':
verbose_print("--- Updating")
run_and_verify_svn(None, expected_stdout, [],
'update', target_path)
elif operation == 'switch':
verbose_print("--- Switching")
run_and_verify_svn(None, expected_stdout, [],
'switch', source_url, target_path)
elif operation == 'merge':
verbose_print("--- Merging")
run_and_verify_svn(None, expected_stdout, [],
'merge', '--ignore-ancestry',
'-r', str(source_left_rev) + ':' + str(source_right_rev),
source_url, target_path)
else:
raise Exception("unknown operation: '" + operation + "'")
if 'commit-c' in test_what:
verbose_print("--- Trying to commit (expecting 'conflict' error)")
### run_and_verify_commit() requires an "output_tree" argument, but
# here we get away with passing None because we know an implementation
# detail: namely that it's not going to look at that argument if it
# gets the stderr that we're expecting.
run_and_verify_commit(".", None, None, ".*conflict.*", victim)
if 'status-c' in test_what:
verbose_print("--- Checking that 'status' reports the conflict")
expected_stdout = svntest.verify.RegexOutput("^......C.* " +
re.escape(victim) + "$",
match_all=False)
run_and_verify_svn(None, expected_stdout, [],
'status', victim)
if 'resolve' in test_what:
verbose_print("--- Resolving the conflict")
# Make sure resolving the parent does nothing.
run_and_verify_resolved([], os.path.dirname(victim))
# The real resolved call.
run_and_verify_resolved([victim])
if 'status-nc' in test_what:
verbose_print("--- Checking that 'status' does not report a conflict")
exitcode, stdout, stderr = run_and_verify_svn(None, None, [],
'status', victim)
for line in stdout:
if line[6] == 'C': # and line.endswith(victim + '\n'):
raise svntest.Failure("unexpected status C") # on path '" + victim + "'")
if 'commit-ok' in test_what:
verbose_print("--- Committing (should now succeed)")
run_and_verify_svn(None, None, [],
'commit', '-m', '', target_path)
target_start_rev += 1
verbose_print("")
os.chdir(saved_cwd)
# Clean up the target branch and WC
main.run_svn(None, 'revert', '-R', wc_dir)
main.safe_rmtree(wc_dir)
if operation != 'update':
run_and_verify_svn(None, AnyOutput, [],
'delete', url_of(target_br),
'-m', 'Delete target branch.')
head_rev += 1
def ensure_tree_conflict(sbox, operation, incoming_scenarios, localmod_scenarios, commit_local_mods):
sbox.build()
wc_dir = sbox.wc_dir
def url_of(repo_relative_path):
return sbox.repo_url + "/" + repo_relative_path
verbose_print("")
verbose_print("=== Starting a set of '" + operation + "' tests.")
# Path to source branch, relative to wc_dir.
# Source is where the "incoming" mods are made.
source_br = "branch1"
verbose_print("--- Creating changes in repos")
source_wc_dir = os.path.join(wc_dir, source_br)
source_left_rev, source_right_rev = set_up_repos(wc_dir, source_wc_dir, incoming_scenarios)
head_rev = source_right_rev ### assumption
# Local mods are the outer loop because cleaning up the WC is slow
# ('svn revert' isn't sufficient because it leaves unversioned files)
for _loc_init_mods, loc_action in localmod_scenarios:
# Determine the branch (directory) in which local mods will be made.
if operation == "update":
# Path to target branch (where conflicts are raised), relative to wc_dir.
target_br = source_br
target_start_rev = source_left_rev
else: # switch/merge
# Make, and work in, a "branch2" that is a copy of "branch1".
target_br = "branch2"
run_and_verify_svn(
None,
AnyOutput,
[],
"copy",
"-r",
str(source_left_rev),
url_of(source_br),
url_of(target_br),
"-m",
"Create target branch.",
)
head_rev += 1
target_start_rev = head_rev
main.run_svn(None, "checkout", "-r", str(target_start_rev), sbox.repo_url, wc_dir)
saved_cwd = os.getcwd()
os.chdir(wc_dir)
for _inc_init_mods, inc_action in incoming_scenarios:
scen_name = "_".join(inc_action)
source_url = url_of(source_br + "/" + scen_name)
target_path = os.path.join(target_br, scen_name)
verbose_print("=== " + str(inc_action) + " onto " + str(loc_action))
verbose_print("--- Making local mods")
for modaction in loc_action:
modify(modaction, localmod_paths(".", target_path))
if commit_local_mods:
run_and_verify_svn(None, AnyOutput, [], "commit", target_path, "-m", "Mods in target branch.")
head_rev += 1
# What do we want to test for? (This selection could in future be
# passed in to this function as a parameter.)
test_what = [
"commit-ood",
"action", # required for any of the following ones to work
"notify",
"commit-c",
"status-c",
"resolve", # required for any of the following ones to work
"status-nc",
#'commit-ok',
]
if "commit-ood" in test_what:
# For update, verify the pre-condition that WC is out of date.
# For switch/merge, there is no such precondition.
if operation == "update":
verbose_print("--- Trying to commit (expecting 'out-of-date' error)")
run_and_verify_commit(".", None, None, "Commit failed", target_path)
if modaction.startswith("f"):
victim = os.path.join(target_path, "F")
else:
victim = os.path.join(target_path, "D")
# Perform the operation that tries to apply incoming changes to the WC.
# The command is expected to do something (and give some output),
# and it should raise a conflict but not an error.
if "action" in test_what:
# Determine what notification to expect
if "notify" in test_what:
expected_stdout = svntest.verify.ExpectedOutput(" C " + victim + "\n", match_all=False)
else:
expected_stdout = svntest.verify.AnyOutput
# Do the main action
if operation == "update":
verbose_print("--- Updating")
run_and_verify_svn(None, expected_stdout, [], "update", target_path)
elif operation == "switch":
verbose_print("--- Switching")
run_and_verify_svn(None, expected_stdout, [], "switch", source_url, target_path)
elif operation == "merge":
verbose_print("--- Merging")
run_and_verify_svn(
None,
expected_stdout,
[],
"merge",
"--ignore-ancestry",
"-r",
str(source_left_rev) + ":" + str(source_right_rev),
source_url,
target_path,
)
else:
raise Exception("unknown operation: '" + operation + "'")
if "commit-c" in test_what:
verbose_print("--- Trying to commit (expecting 'conflict' error)")
### run_and_verify_commit() requires an "output_tree" argument, but
# here we get away with passing None because we know an implementation
# detail: namely that it's not going to look at that argument if it
# gets the stderr that we're expecting.
run_and_verify_commit(".", None, None, ".*conflict.*", victim)
if "status-c" in test_what:
verbose_print("--- Checking that 'status' reports the conflict")
expected_stdout = svntest.verify.RegexOutput("^......C.* " + re.escape(victim) + "$", match_all=False)
run_and_verify_svn(None, expected_stdout, [], "status", victim)
if "resolve" in test_what:
verbose_print("--- Resolving the conflict")
# Make sure resolving the parent does nothing.
run_and_verify_resolved([], os.path.dirname(victim))
# The real resolved call.
run_and_verify_resolved([victim])
if "status-nc" in test_what:
verbose_print("--- Checking that 'status' does not report a conflict")
exitcode, stdout, stderr = run_and_verify_svn(None, None, [], "status", victim)
for line in stdout:
if line[6] == "C": # and line.endswith(victim + '\n'):
raise svntest.Failure("unexpected status C") # on path '" + victim + "'")
if "commit-ok" in test_what:
verbose_print("--- Committing (should now succeed)")
run_and_verify_svn(None, None, [], "commit", "-m", "", target_path)
target_start_rev += 1
verbose_print("")
os.chdir(saved_cwd)
# Clean up the target branch and WC
main.run_svn(None, "revert", "-R", wc_dir)
main.safe_rmtree(wc_dir)
if operation != "update":
run_and_verify_svn(None, AnyOutput, [], "delete", url_of(target_br), "-m", "Delete target branch.")
head_rev += 1
def set_up_branch(sbox, branch_only=False, nbr_of_branches=1):
'''Starting with standard greek tree, copy 'A' NBR_OF_BRANCHES times
to A_COPY, A_COPY_2, A_COPY_3, and so on. Then, unless BRANCH_ONLY is
true, make four modifications (setting file contents to "New content")
under A:
r(2 + NBR_OF_BRANCHES) - A/D/H/psi
r(3 + NBR_OF_BRANCHES) - A/D/G/rho
r(4 + NBR_OF_BRANCHES) - A/B/E/beta
r(5 + NBR_OF_BRANCHES) - A/D/H/omega
Return (expected_disk, expected_status).'''
# With the default parameters, the branching looks like this:
#
# A -1-----3-4-5-6--
# \
# A_COPY 2-----------
wc_dir = sbox.wc_dir
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_disk = main.greek_state.copy()
def path_join(head, tail):
if not head: return tail
if not tail: return head
return head + '/' + tail
def greek_file_item(path):
if path[-1:].islower():
basename = re.sub('.*/', '', path)
return Item("This is the file '" + basename + "'.\n")
return Item()
A_paths = [
"",
"B",
"B/lambda",
"B/E",
"B/E/alpha",
"B/E/beta",
"B/F",
"mu",
"C",
"D",
"D/gamma",
"D/G",
"D/G/pi",
"D/G/rho",
"D/G/tau",
"D/H",
"D/H/chi",
"D/H/omega",
"D/H/psi",
]
def copy_A(dest_name, rev):
expected = verify.UnorderedOutput([
"A " + sbox.ospath(path_join(dest_name, p)) + "\n"
for p in A_paths
])
expected_status.add({
path_join(dest_name, p): Item(status=' ', wc_rev=rev)
for p in A_paths
})
expected_disk.add(
{path_join(dest_name, p): greek_file_item(p)
for p in A_paths})
# Make a branch A_COPY to merge into.
actions.run_and_verify_svn(expected, [], 'copy', sbox.repo_url + "/A",
os.path.join(wc_dir, dest_name))
expected_output = wc.State(wc_dir, {dest_name: Item(verb='Adding')})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
for i in range(nbr_of_branches):
if i == 0:
copy_A('A_COPY', i + 2)
else:
copy_A('A_COPY_' + str(i + 1), i + 2)
if branch_only:
return expected_disk, expected_status
# Make some changes under A which we'll later merge under A_COPY:
# r(nbr_of_branches + 2) - modify and commit A/D/H/psi
main.file_write(sbox.ospath('A/D/H/psi'), "New content")
expected_output = wc.State(wc_dir, {'A/D/H/psi': Item(verb='Sending')})
expected_status.tweak('A/D/H/psi', wc_rev=nbr_of_branches + 2)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/H/psi', contents="New content")
# r(nbr_of_branches + 3) - modify and commit A/D/G/rho
main.file_write(sbox.ospath('A/D/G/rho'), "New content")
expected_output = wc.State(wc_dir, {'A/D/G/rho': Item(verb='Sending')})
expected_status.tweak('A/D/G/rho', wc_rev=nbr_of_branches + 3)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/G/rho', contents="New content")
# r(nbr_of_branches + 4) - modify and commit A/B/E/beta
main.file_write(sbox.ospath('A/B/E/beta'), "New content")
expected_output = wc.State(wc_dir, {'A/B/E/beta': Item(verb='Sending')})
expected_status.tweak('A/B/E/beta', wc_rev=nbr_of_branches + 4)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/B/E/beta', contents="New content")
# r(nbr_of_branches + 5) - modify and commit A/D/H/omega
main.file_write(sbox.ospath('A/D/H/omega'), "New content")
expected_output = wc.State(wc_dir, {'A/D/H/omega': Item(verb='Sending')})
expected_status.tweak('A/D/H/omega', wc_rev=nbr_of_branches + 5)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/H/omega', contents="New content")
return expected_disk, expected_status
def set_up_dir_replace(sbox):
"""Set up the working copy for directory replace tests, creating
directory 'A/B/F/foo' with files 'new file' and 'new file2' within
it (r2), and merging 'foo' onto 'C' (r3), then deleting 'A/B/F/foo'
(r4)."""
sbox.build()
wc_dir = sbox.wc_dir
C_path = sbox.ospath('A/C')
F_path = sbox.ospath('A/B/F')
F_url = sbox.repo_url + '/A/B/F'
foo_path = os.path.join(F_path, 'foo')
new_file = os.path.join(foo_path, "new file")
new_file2 = os.path.join(foo_path, "new file 2")
# Make directory foo in F, and add some files within it.
actions.run_and_verify_svn(None, [], 'mkdir', foo_path)
main.file_append(new_file, "Initial text in new file.\n")
main.file_append(new_file2, "Initial text in new file 2.\n")
main.run_svn(None, "add", new_file)
main.run_svn(None, "add", new_file2)
# Commit all the new content, creating r2.
expected_output = wc.State(
wc_dir, {
'A/B/F/foo': Item(verb='Adding'),
'A/B/F/foo/new file': Item(verb='Adding'),
'A/B/F/foo/new file 2': Item(verb='Adding'),
})
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_status.add({
'A/B/F/foo': Item(status=' ', wc_rev=2),
'A/B/F/foo/new file': Item(status=' ', wc_rev=2),
'A/B/F/foo/new file 2': Item(status=' ', wc_rev=2),
})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
# Merge foo onto C
expected_output = wc.State(
C_path, {
'foo': Item(status='A '),
'foo/new file': Item(status='A '),
'foo/new file 2': Item(status='A '),
})
expected_mergeinfo_output = wc.State(C_path, {
'': Item(status=' U'),
})
expected_elision_output = wc.State(C_path, {})
expected_disk = wc.State(
'', {
'': Item(props={SVN_PROP_MERGEINFO: '/A/B/F:2'}),
'foo': Item(),
'foo/new file': Item("Initial text in new file.\n"),
'foo/new file 2': Item("Initial text in new file 2.\n"),
})
expected_status = wc.State(
C_path, {
'': Item(status=' M', wc_rev=1),
'foo': Item(status='A ', wc_rev='-', copied='+'),
'foo/new file': Item(status=' ', wc_rev='-', copied='+'),
'foo/new file 2': Item(status=' ', wc_rev='-', copied='+'),
})
expected_skip = wc.State(C_path, {})
actions.run_and_verify_merge(C_path,
'1',
'2',
F_url,
None,
expected_output,
expected_mergeinfo_output,
expected_elision_output,
expected_disk,
expected_status,
expected_skip,
check_props=True)
# Commit merge of foo onto C, creating r3.
expected_output = wc.State(wc_dir, {
'A/C': Item(verb='Sending'),
'A/C/foo': Item(verb='Adding'),
})
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_status.add({
'A/B/F/foo': Item(status=' ', wc_rev=2),
'A/C': Item(status=' ', wc_rev=3),
'A/B/F/foo/new file': Item(status=' ', wc_rev=2),
'A/B/F/foo/new file 2': Item(status=' ', wc_rev=2),
'A/C/foo': Item(status=' ', wc_rev=3),
'A/C/foo/new file': Item(status=' ', wc_rev=3),
'A/C/foo/new file 2': Item(status=' ', wc_rev=3),
})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
# Delete foo on F, creating r4.
actions.run_and_verify_svn(None, [], 'rm', foo_path)
expected_output = wc.State(wc_dir, {
'A/B/F/foo': Item(verb='Deleting'),
})
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_status.add({
'A/C': Item(status=' ', wc_rev=3),
'A/C/foo': Item(status=' ', wc_rev=3),
'A/C/foo/new file': Item(status=' ', wc_rev=3),
'A/C/foo/new file 2': Item(status=' ', wc_rev=3),
})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
def copy_A(dest_name, rev):
expected = verify.UnorderedOutput([
"A " + os.path.join(wc_dir, dest_name, "B") + "\n",
"A " + os.path.join(wc_dir, dest_name, "B", "lambda") + "\n",
"A " + os.path.join(wc_dir, dest_name, "B", "E") + "\n",
"A " + os.path.join(wc_dir, dest_name, "B", "E", "alpha") +
"\n", "A " + os.path.join(wc_dir, dest_name, "B", "E", "beta") +
"\n", "A " + os.path.join(wc_dir, dest_name, "B", "F") + "\n",
"A " + os.path.join(wc_dir, dest_name, "mu") + "\n",
"A " + os.path.join(wc_dir, dest_name, "C") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "gamma") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G", "pi") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G", "rho") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G", "tau") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "H") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "H", "chi") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "H", "omega") +
"\n", "A " + os.path.join(wc_dir, dest_name, "D", "H", "psi") +
"\n", "Checked out revision " + str(rev - 1) + ".\n",
"A " + os.path.join(wc_dir, dest_name) + "\n"
])
expected_status.add({
dest_name + "/B":
Item(status=' ', wc_rev=rev),
dest_name + "/B/lambda":
Item(status=' ', wc_rev=rev),
dest_name + "/B/E":
Item(status=' ', wc_rev=rev),
dest_name + "/B/E/alpha":
Item(status=' ', wc_rev=rev),
dest_name + "/B/E/beta":
Item(status=' ', wc_rev=rev),
dest_name + "/B/F":
Item(status=' ', wc_rev=rev),
dest_name + "/mu":
Item(status=' ', wc_rev=rev),
dest_name + "/C":
Item(status=' ', wc_rev=rev),
dest_name + "/D":
Item(status=' ', wc_rev=rev),
dest_name + "/D/gamma":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G/pi":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G/rho":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G/tau":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H/chi":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H/omega":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H/psi":
Item(status=' ', wc_rev=rev),
dest_name:
Item(status=' ', wc_rev=rev)
})
expected_disk.add({
dest_name:
Item(),
dest_name + '/B':
Item(),
dest_name + '/B/lambda':
Item("This is the file 'lambda'.\n"),
dest_name + '/B/E':
Item(),
dest_name + '/B/E/alpha':
Item("This is the file 'alpha'.\n"),
dest_name + '/B/E/beta':
Item("This is the file 'beta'.\n"),
dest_name + '/B/F':
Item(),
dest_name + '/mu':
Item("This is the file 'mu'.\n"),
dest_name + '/C':
Item(),
dest_name + '/D':
Item(),
dest_name + '/D/gamma':
Item("This is the file 'gamma'.\n"),
dest_name + '/D/G':
Item(),
dest_name + '/D/G/pi':
Item("This is the file 'pi'.\n"),
dest_name + '/D/G/rho':
Item("This is the file 'rho'.\n"),
dest_name + '/D/G/tau':
Item("This is the file 'tau'.\n"),
dest_name + '/D/H':
Item(),
dest_name + '/D/H/chi':
Item("This is the file 'chi'.\n"),
dest_name + '/D/H/omega':
Item("This is the file 'omega'.\n"),
dest_name + '/D/H/psi':
Item("This is the file 'psi'.\n"),
})
# Make a branch A_COPY to merge into.
actions.run_and_verify_svn(expected, [], 'copy', sbox.repo_url + "/A",
os.path.join(wc_dir, dest_name))
expected_output = wc.State(wc_dir, {dest_name: Item(verb='Adding')})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
def set_up_branch(sbox, branch_only=False, nbr_of_branches=1):
'''Starting with standard greek tree, copy 'A' NBR_OF_BRANCHES times
to A_COPY, A_COPY_2, A_COPY_3, and so on. Then, unless BRANCH_ONLY is
true, make four modifications (setting file contents to "New content")
under A:
r(2 + NBR_OF_BRANCHES) - A/D/H/psi
r(3 + NBR_OF_BRANCHES) - A/D/G/rho
r(4 + NBR_OF_BRANCHES) - A/B/E/beta
r(5 + NBR_OF_BRANCHES) - A/D/H/omega
Return (expected_disk, expected_status).'''
# With the default parameters, the branching looks like this:
#
# A -1-----3-4-5-6--
# \
# A_COPY 2-----------
wc_dir = sbox.wc_dir
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_disk = main.greek_state.copy()
def copy_A(dest_name, rev):
expected = verify.UnorderedOutput([
"A " + os.path.join(wc_dir, dest_name, "B") + "\n",
"A " + os.path.join(wc_dir, dest_name, "B", "lambda") + "\n",
"A " + os.path.join(wc_dir, dest_name, "B", "E") + "\n",
"A " + os.path.join(wc_dir, dest_name, "B", "E", "alpha") +
"\n", "A " + os.path.join(wc_dir, dest_name, "B", "E", "beta") +
"\n", "A " + os.path.join(wc_dir, dest_name, "B", "F") + "\n",
"A " + os.path.join(wc_dir, dest_name, "mu") + "\n",
"A " + os.path.join(wc_dir, dest_name, "C") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "gamma") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G", "pi") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G", "rho") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "G", "tau") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "H") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "H", "chi") + "\n",
"A " + os.path.join(wc_dir, dest_name, "D", "H", "omega") +
"\n", "A " + os.path.join(wc_dir, dest_name, "D", "H", "psi") +
"\n", "Checked out revision " + str(rev - 1) + ".\n",
"A " + os.path.join(wc_dir, dest_name) + "\n"
])
expected_status.add({
dest_name + "/B":
Item(status=' ', wc_rev=rev),
dest_name + "/B/lambda":
Item(status=' ', wc_rev=rev),
dest_name + "/B/E":
Item(status=' ', wc_rev=rev),
dest_name + "/B/E/alpha":
Item(status=' ', wc_rev=rev),
dest_name + "/B/E/beta":
Item(status=' ', wc_rev=rev),
dest_name + "/B/F":
Item(status=' ', wc_rev=rev),
dest_name + "/mu":
Item(status=' ', wc_rev=rev),
dest_name + "/C":
Item(status=' ', wc_rev=rev),
dest_name + "/D":
Item(status=' ', wc_rev=rev),
dest_name + "/D/gamma":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G/pi":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G/rho":
Item(status=' ', wc_rev=rev),
dest_name + "/D/G/tau":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H/chi":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H/omega":
Item(status=' ', wc_rev=rev),
dest_name + "/D/H/psi":
Item(status=' ', wc_rev=rev),
dest_name:
Item(status=' ', wc_rev=rev)
})
expected_disk.add({
dest_name:
Item(),
dest_name + '/B':
Item(),
dest_name + '/B/lambda':
Item("This is the file 'lambda'.\n"),
dest_name + '/B/E':
Item(),
dest_name + '/B/E/alpha':
Item("This is the file 'alpha'.\n"),
dest_name + '/B/E/beta':
Item("This is the file 'beta'.\n"),
dest_name + '/B/F':
Item(),
dest_name + '/mu':
Item("This is the file 'mu'.\n"),
dest_name + '/C':
Item(),
dest_name + '/D':
Item(),
dest_name + '/D/gamma':
Item("This is the file 'gamma'.\n"),
dest_name + '/D/G':
Item(),
dest_name + '/D/G/pi':
Item("This is the file 'pi'.\n"),
dest_name + '/D/G/rho':
Item("This is the file 'rho'.\n"),
dest_name + '/D/G/tau':
Item("This is the file 'tau'.\n"),
dest_name + '/D/H':
Item(),
dest_name + '/D/H/chi':
Item("This is the file 'chi'.\n"),
dest_name + '/D/H/omega':
Item("This is the file 'omega'.\n"),
dest_name + '/D/H/psi':
Item("This is the file 'psi'.\n"),
})
# Make a branch A_COPY to merge into.
actions.run_and_verify_svn(expected, [], 'copy', sbox.repo_url + "/A",
os.path.join(wc_dir, dest_name))
expected_output = wc.State(wc_dir, {dest_name: Item(verb='Adding')})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
for i in range(nbr_of_branches):
if i == 0:
copy_A('A_COPY', i + 2)
else:
copy_A('A_COPY_' + str(i + 1), i + 2)
if branch_only:
return expected_disk, expected_status
# Make some changes under A which we'll later merge under A_COPY:
# r(nbr_of_branches + 2) - modify and commit A/D/H/psi
main.file_write(sbox.ospath('A/D/H/psi'), "New content")
expected_output = wc.State(wc_dir, {'A/D/H/psi': Item(verb='Sending')})
expected_status.tweak('A/D/H/psi', wc_rev=nbr_of_branches + 2)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/H/psi', contents="New content")
# r(nbr_of_branches + 3) - modify and commit A/D/G/rho
main.file_write(sbox.ospath('A/D/G/rho'), "New content")
expected_output = wc.State(wc_dir, {'A/D/G/rho': Item(verb='Sending')})
expected_status.tweak('A/D/G/rho', wc_rev=nbr_of_branches + 3)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/G/rho', contents="New content")
# r(nbr_of_branches + 4) - modify and commit A/B/E/beta
main.file_write(sbox.ospath('A/B/E/beta'), "New content")
expected_output = wc.State(wc_dir, {'A/B/E/beta': Item(verb='Sending')})
expected_status.tweak('A/B/E/beta', wc_rev=nbr_of_branches + 4)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/B/E/beta', contents="New content")
# r(nbr_of_branches + 5) - modify and commit A/D/H/omega
main.file_write(sbox.ospath('A/D/H/omega'), "New content")
expected_output = wc.State(wc_dir, {'A/D/H/omega': Item(verb='Sending')})
expected_status.tweak('A/D/H/omega', wc_rev=nbr_of_branches + 5)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/H/omega', contents="New content")
return expected_disk, expected_status
def set_up_branch(sbox, branch_only = False, nbr_of_branches = 1):
'''Starting with standard greek tree, copy 'A' NBR_OF_BRANCHES times
to A_COPY, A_COPY_2, A_COPY_3, and so on. Then, unless BRANCH_ONLY is
true, make four modifications (setting file contents to "New content")
under A:
r(2 + NBR_OF_BRANCHES) - A/D/H/psi
r(3 + NBR_OF_BRANCHES) - A/D/G/rho
r(4 + NBR_OF_BRANCHES) - A/B/E/beta
r(5 + NBR_OF_BRANCHES) - A/D/H/omega
Return (expected_disk, expected_status).'''
# With the default parameters, the branching looks like this:
#
# A -1-----3-4-5-6--
# \
# A_COPY 2-----------
wc_dir = sbox.wc_dir
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_disk = main.greek_state.copy()
def path_join(head, tail):
if not head: return tail
if not tail: return head
return head + '/' + tail
def greek_file_item(path):
if path[-1:].islower():
basename = re.sub('.*/', '', path)
return Item("This is the file '" + basename + "'.\n")
return Item()
A_paths = [
"",
"B",
"B/lambda",
"B/E",
"B/E/alpha",
"B/E/beta",
"B/F",
"mu",
"C",
"D",
"D/gamma",
"D/G",
"D/G/pi",
"D/G/rho",
"D/G/tau",
"D/H",
"D/H/chi",
"D/H/omega",
"D/H/psi",
]
def copy_A(dest_name, rev):
expected = verify.UnorderedOutput(
[ "A " + sbox.ospath(path_join(dest_name, p)) + "\n"
for p in A_paths ])
expected_status.add(
{ path_join(dest_name, p) : Item(status=' ', wc_rev=rev)
for p in A_paths })
expected_disk.add(
{ path_join(dest_name, p) : greek_file_item(p)
for p in A_paths })
# Make a branch A_COPY to merge into.
actions.run_and_verify_svn(expected, [], 'copy',
sbox.repo_url + "/A",
os.path.join(wc_dir,
dest_name))
expected_output = wc.State(wc_dir, {dest_name : Item(verb='Adding')})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
for i in range(nbr_of_branches):
if i == 0:
copy_A('A_COPY', i + 2)
else:
copy_A('A_COPY_' + str(i + 1), i + 2)
if branch_only:
return expected_disk, expected_status
# Make some changes under A which we'll later merge under A_COPY:
# r(nbr_of_branches + 2) - modify and commit A/D/H/psi
main.file_write(sbox.ospath('A/D/H/psi'),
"New content")
expected_output = wc.State(wc_dir, {'A/D/H/psi' : Item(verb='Sending')})
expected_status.tweak('A/D/H/psi', wc_rev=nbr_of_branches + 2)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/H/psi', contents="New content")
# r(nbr_of_branches + 3) - modify and commit A/D/G/rho
main.file_write(sbox.ospath('A/D/G/rho'),
"New content")
expected_output = wc.State(wc_dir, {'A/D/G/rho' : Item(verb='Sending')})
expected_status.tweak('A/D/G/rho', wc_rev=nbr_of_branches + 3)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/G/rho', contents="New content")
# r(nbr_of_branches + 4) - modify and commit A/B/E/beta
main.file_write(sbox.ospath('A/B/E/beta'),
"New content")
expected_output = wc.State(wc_dir, {'A/B/E/beta' : Item(verb='Sending')})
expected_status.tweak('A/B/E/beta', wc_rev=nbr_of_branches + 4)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/B/E/beta', contents="New content")
# r(nbr_of_branches + 5) - modify and commit A/D/H/omega
main.file_write(sbox.ospath('A/D/H/omega'),
"New content")
expected_output = wc.State(wc_dir, {'A/D/H/omega' : Item(verb='Sending')})
expected_status.tweak('A/D/H/omega', wc_rev=nbr_of_branches + 5)
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
expected_disk.tweak('A/D/H/omega', contents="New content")
return expected_disk, expected_status
def set_up_dir_replace(sbox):
"""Set up the working copy for directory replace tests, creating
directory 'A/B/F/foo' with files 'new file' and 'new file2' within
it (r2), and merging 'foo' onto 'C' (r3), then deleting 'A/B/F/foo'
(r4)."""
sbox.build()
wc_dir = sbox.wc_dir
C_path = sbox.ospath('A/C')
F_path = sbox.ospath('A/B/F')
F_url = sbox.repo_url + '/A/B/F'
foo_path = os.path.join(F_path, 'foo')
new_file = os.path.join(foo_path, "new file")
new_file2 = os.path.join(foo_path, "new file 2")
# Make directory foo in F, and add some files within it.
actions.run_and_verify_svn(None, [], 'mkdir', foo_path)
main.file_append(new_file, "Initial text in new file.\n")
main.file_append(new_file2, "Initial text in new file 2.\n")
main.run_svn(None, "add", new_file)
main.run_svn(None, "add", new_file2)
# Commit all the new content, creating r2.
expected_output = wc.State(wc_dir, {
'A/B/F/foo' : Item(verb='Adding'),
'A/B/F/foo/new file' : Item(verb='Adding'),
'A/B/F/foo/new file 2' : Item(verb='Adding'),
})
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_status.add({
'A/B/F/foo' : Item(status=' ', wc_rev=2),
'A/B/F/foo/new file' : Item(status=' ', wc_rev=2),
'A/B/F/foo/new file 2' : Item(status=' ', wc_rev=2),
})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
# Merge foo onto C
expected_output = wc.State(C_path, {
'foo' : Item(status='A '),
'foo/new file' : Item(status='A '),
'foo/new file 2' : Item(status='A '),
})
expected_mergeinfo_output = wc.State(C_path, {
'' : Item(status=' U'),
})
expected_elision_output = wc.State(C_path, {
})
expected_disk = wc.State('', {
'' : Item(props={SVN_PROP_MERGEINFO : '/A/B/F:2'}),
'foo' : Item(),
'foo/new file' : Item("Initial text in new file.\n"),
'foo/new file 2' : Item("Initial text in new file 2.\n"),
})
expected_status = wc.State(C_path, {
'' : Item(status=' M', wc_rev=1),
'foo' : Item(status='A ', wc_rev='-', copied='+'),
'foo/new file' : Item(status=' ', wc_rev='-', copied='+'),
'foo/new file 2' : Item(status=' ', wc_rev='-', copied='+'),
})
expected_skip = wc.State(C_path, { })
actions.run_and_verify_merge(C_path, '1', '2', F_url, None,
expected_output,
expected_mergeinfo_output,
expected_elision_output,
expected_disk,
expected_status,
expected_skip,
check_props=True)
# Commit merge of foo onto C, creating r3.
expected_output = wc.State(wc_dir, {
'A/C' : Item(verb='Sending'),
'A/C/foo' : Item(verb='Adding'),
})
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_status.add({
'A/B/F/foo' : Item(status=' ', wc_rev=2),
'A/C' : Item(status=' ', wc_rev=3),
'A/B/F/foo/new file' : Item(status=' ', wc_rev=2),
'A/B/F/foo/new file 2' : Item(status=' ', wc_rev=2),
'A/C/foo' : Item(status=' ', wc_rev=3),
'A/C/foo/new file' : Item(status=' ', wc_rev=3),
'A/C/foo/new file 2' : Item(status=' ', wc_rev=3),
})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
# Delete foo on F, creating r4.
actions.run_and_verify_svn(None, [], 'rm', foo_path)
expected_output = wc.State(wc_dir, {
'A/B/F/foo' : Item(verb='Deleting'),
})
expected_status = actions.get_virginal_state(wc_dir, 1)
expected_status.add({
'A/C' : Item(status=' ', wc_rev=3),
'A/C/foo' : Item(status=' ', wc_rev=3),
'A/C/foo/new file' : Item(status=' ', wc_rev=3),
'A/C/foo/new file 2' : Item(status=' ', wc_rev=3),
})
actions.run_and_verify_commit(wc_dir, expected_output, expected_status)