#!/usr/bin/env python
#
# lock_tests.py: testing versioned properties
#
# Subversion is a tool for revision control.
# See http://subversion.tigris.org for more information.
#
# ====================================================================
# Copyright (c) 2005-2006 CollabNet. All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at http://subversion.tigris.org/license-1.html.
# If newer versions of this license are posted there, you may use a
# newer version instead, at your option.
#
######################################################################
# General modules
import string, sys, re, os.path, shutil, stat
# Our testing module
import svntest
# A helper function for examining svn:needs-lock
from prop_tests import check_prop
# (abbreviation)
Skip = svntest.testcase.Skip
XFail = svntest.testcase.XFail
Item = svntest.wc.StateItem
######################################################################
# Tests
#----------------------------------------------------------------------
# Each test refers to a section in
# notes/locking/locking-functional-spec.txt
# II.A.2, II.C.2.a: Lock a file in wc A as user FOO and make sure we
# have a representation of it. Checkout wc B as user BAR. Verify
# that user BAR cannot commit changes to the file nor its properties.
def lock_file(sbox):
"lock a file and verify that it's locked"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_path_b = os.path.join(wc_b, fname)
svntest.main.file_append(file_path, "This represents a binary file\n")
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
# --- Meanwhile, in our other working copy... ---
err_re = "((.*User jconstant does not own lock on path.*)|(.*423 Locked.*))"
svntest.main.run_svn(None, 'update', wc_b)
# -- Try to change a file --
# change the locked file
svntest.main.file_append(file_path_b, "Covert tweak\n")
# attempt (and fail) to commit as user Sally
svntest.actions.run_and_verify_commit (wc_b, None, None, err_re,
None, None, None, None,
'--username',
svntest.main.wc_author2,
'--password',
svntest.main.wc_passwd,
'-m', '', file_path_b)
# Revert our change that we failed to commit
svntest.main.run_svn(None, 'revert', file_path_b)
# -- Try to change a property --
# change the locked file's properties
svntest.main.run_svn(None, 'propset', 'sneakyuser', 'Sally', file_path_b)
err_re = "((.*User jconstant does not own lock on path.*)" + \
"|(.*At least one property change failed.*))"
# attempt (and fail) to commit as user Sally
svntest.actions.run_and_verify_commit (wc_b, None, None, err_re,
None, None, None, None,
'--username',
svntest.main.wc_author2,
'--password',
svntest.main.wc_passwd,
'-m', '', file_path_b)
#----------------------------------------------------------------------
# II.C.2.b.[12]: Lock a file and commit using the lock. Make sure the
# lock is released. Repeat, but request that the lock not be
# released. Make sure the lock is retained.
def commit_file_keep_lock(sbox):
"commit a file and keep lock"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'A/mu'
file_path = os.path.join(sbox.wc_dir, fname)
# lock fname as wc_author
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', 'some lock comment', file_path)
# make a change and commit it, holding lock
svntest.main.file_append(file_path, "Tweak!\n")
svntest.main.run_svn(None, 'commit', '-m', '', '--no-unlock', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak(fname, wc_rev=2)
expected_status.tweak(fname, writelocked='K')
# Make sure the file is still locked
svntest.actions.run_and_verify_status(wc_dir, expected_status)
def commit_file_unlock(sbox):
"commit a file and release lock"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'A/mu'
file_path = os.path.join(sbox.wc_dir, fname)
# lock fname as wc_author
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', 'some lock comment', file_path)
# make a change and commit it, allowing lock to be released
svntest.main.file_append(file_path, "Tweak!\n")
svntest.main.run_svn(None, 'commit', '-m', '', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak(fname, wc_rev=2)
# Make sure the file is unlocked
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
def commit_propchange(sbox):
"commit a locked file with a prop change"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'A/mu'
file_path = os.path.join(sbox.wc_dir, fname)
# lock fname as wc_author
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', 'some lock comment', file_path)
# make a property change and commit it, allowing lock to be released
svntest.main.run_svn(None, 'propset', 'blue', 'azul', file_path)
svntest.main.run_svn(None, 'commit', '-m', '', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak(fname, wc_rev=2)
# Make sure the file is unlocked
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
# II.C.2.c: Lock a file in wc A as user FOO. Attempt to unlock same
# file in same wc as user BAR. Should fail.
#
# Attempt again with --force. Should succeed.
#
# II.C.2.c: Lock a file in wc A as user FOO. Attempt to unlock same
# file in wc B as user FOO. Should fail.
#
# Attempt again with --force. Should succeed.
def break_lock(sbox):
"lock a file and verify lock breaking behavior"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_path_b = os.path.join(wc_b, fname)
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
# --- Meanwhile, in our other working copy... ---
svntest.main.run_svn(None, 'update', wc_b)
# attempt (and fail) to unlock file
# This should give a "iota' is not locked in this working copy" error
svntest.actions.run_and_verify_svn(None, None, ".*not locked",
'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_path_b)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [],
'unlock', '--force',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_path_b)
#----------------------------------------------------------------------
# II.C.2.d: Lock a file in wc A as user FOO. Attempt to lock same
# file in wc B as user BAR. Should fail.
#
# Attempt again with --force. Should succeed.
#
# II.C.2.d: Lock a file in wc A as user FOO. Attempt to lock same
# file in wc B as user FOO. Should fail.
#
# Attempt again with --force. Should succeed.
def steal_lock(sbox):
"lock a file and verify lock stealing behavior"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_path_b = os.path.join(wc_b, fname)
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
# --- Meanwhile, in our other working copy... ---
svntest.main.run_svn(None, 'update', wc_b)
# attempt (and fail) to lock file
# This should give a "iota' is already locked... error.
svntest.actions.run_and_verify_svn(None, None,
".*already locked",
'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', 'trying to break', file_path_b)
svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
'lock', '--force',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', 'trying to break', file_path_b)
#----------------------------------------------------------------------
# II.B.2, II.C.2.e: Lock a file in wc A. Query wc for the
# lock and verify that all lock fields are present and correct.
def examine_lock(sbox):
"examine the fields of a lockfile for correctness"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'iota'
comment = 'This is a lock test.'
file_path = os.path.join(sbox.wc_dir, fname)
# lock a file as wc_author
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', comment, file_path)
output, err = svntest.actions.run_and_verify_svn(None, None, [],
'info', file_path)
lock_info = output[-6:-1]
if ((len(lock_info) != 5)
or (lock_info[0][0:28] != 'Lock Token: opaquelocktoken:')
or (lock_info[1] != 'Lock Owner: ' + svntest.main.wc_author + '\n')
or (lock_info[2][0:13] != 'Lock Created:')
or (lock_info[4] != comment + '\n')):
raise svntest.Failure
#----------------------------------------------------------------------
# II.C.1: Lock a file in wc A. Check out wc B. Break the lock in wc
# B. Verify that wc A gracefully cleans up the lock via update as
# well as via commit.
def handle_defunct_lock(sbox):
"verify behavior when a lock in a wc is defunct"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
# set up our expected status
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
# lock the file
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
file_path_b = os.path.join(wc_b, fname)
# --- Meanwhile, in our other working copy... ---
# Try unlocking the file in the second wc.
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_path_b)
# update the 1st wc, which should clear the lock there
svntest.main.run_svn(None, 'update', wc_dir)
# Make sure the file is unlocked
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
# II.B.1: Set "svn:needs-lock" property on file in wc A. Checkout wc
# B and verify that that file is set as read-only.
#
# Tests propset, propdel, lock, and unlock
def enforce_lock(sbox):
"verify svn:needs-lock read-only behavior"
sbox.build()
wc_dir = sbox.wc_dir
iota_path = os.path.join(wc_dir, 'iota')
lambda_path = os.path.join(wc_dir, 'A', 'B', 'lambda')
mu_path = os.path.join(wc_dir, 'A', 'mu')
# svn:needs-lock value should be forced to a '*'
svntest.main.run_svn(None, 'propset', 'svn:needs-lock', 'foo', iota_path)
svntest.main.run_svn(None, 'propset', 'svn:needs-lock', '', lambda_path)
svntest.main.run_svn(None, 'propset', 'svn:needs-lock', ' ', mu_path)
# Check svn:needs-lock
check_prop('svn:needs-lock', iota_path, ['*'])
check_prop('svn:needs-lock', lambda_path, ['*'])
check_prop('svn:needs-lock', mu_path, ['*'])
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path, lambda_path, mu_path)
# Now make sure that the perms were flipped on all files
if os.name == 'posix':
mode = stat.S_IWGRP | stat.S_IWOTH | stat.S_IWRITE
if ((os.stat (iota_path)[0] & mode)
or (os.stat (lambda_path)[0] & mode)
or (os.stat (mu_path)[0] & mode)):
print "Setting 'svn:needs-lock' property on a file failed to set"
print "file mode to read-only."
raise svntest.Failure
# obtain a lock on one of these files...
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
# ...and verify that the write bit gets set...
if not (os.stat (iota_path)[0] & mode):
print "Locking a file with 'svn:needs-lock' failed to set write bit."
raise svntest.Failure
# ...and unlock it...
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
iota_path)
# ...and verify that the write bit gets unset
if (os.stat (iota_path)[0] & mode):
print "Unlocking a file with 'svn:needs-lock' failed to unset write bit."
raise svntest.Failure
# Verify that removing the property restores the file to read-write
svntest.main.run_svn(None, 'propdel', 'svn:needs-lock', iota_path)
if not (os.stat (iota_path)[0] & mode):
print "Deleting 'svn:needs-lock' failed to set write bit."
raise svntest.Failure
#----------------------------------------------------------------------
# Test that updating a file with the "svn:needs-lock" property works,
# especially on Windows, where renaming A to B fails if B already
# exists and has its read-only bit set. See also issue #2278.
def update_while_needing_lock(sbox):
"update handles svn:needs-lock correctly"
sbox.build()
wc_dir = sbox.wc_dir
iota_path = os.path.join(wc_dir, 'iota')
svntest.main.run_svn(None, 'propset', 'svn:needs-lock', 'foo', iota_path)
svntest.main.run_svn(None, 'commit', '-m', 'log msg', iota_path)
svntest.main.run_svn(None, 'up', wc_dir)
# Lock, modify, commit, unlock, to create r3.
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
svntest.main.file_append(iota_path, "This line added in r2.\n")
svntest.main.run_svn(None, 'commit', '-m', '', iota_path) # auto-unlocks
# Backdate to r2.
svntest.main.run_svn(None, 'update', '-r2', iota_path)
# Try updating forward to r3 again. This is where the bug happened.
svntest.main.run_svn(None, 'update', '-r3', iota_path)
#----------------------------------------------------------------------
# Tests update / checkout with changing props
def defunct_lock(sbox):
"verify svn:needs-lock behavior with defunct lock"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
iota_path = os.path.join(wc_dir, 'iota')
iota_path_b = os.path.join(wc_b, 'iota')
mode = stat.S_IWGRP | stat.S_IWOTH | stat.S_IWRITE
# Set the prop in wc a
svntest.main.run_svn(None, 'propset', 'svn:needs-lock', 'foo', iota_path)
# commit r2
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
# update wc_b
svntest.main.run_svn(None, 'update', wc_b)
# lock iota in wc_b
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path_b)
# break the lock iota in wc a
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock', '--force',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
# update wc_b
svntest.main.run_svn(None, 'update', wc_b)
# make sure that iota got set to read-only
if (os.stat (iota_path_b)[0] & mode):
print "Upon removal of a defunct lock, a file with 'svn:needs-lock'"
print "was not set back to read-only"
raise svntest.Failure
#----------------------------------------------------------------------
# Tests dealing with a lock on a deleted path
def deleted_path_lock(sbox):
"verify lock removal on a deleted path"
sbox.build()
wc_dir = sbox.wc_dir
iota_path = os.path.join(wc_dir, 'iota')
iota_url = svntest.main.current_repo_url + '/iota'
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
svntest.actions.run_and_verify_svn(None, None, [], 'delete', iota_path)
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'--no-unlock',
'-m', '', iota_path)
# Now make sure that we can delete the lock from iota via a URL
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
iota_url)
#----------------------------------------------------------------------
# Tests dealing with locking and unlocking
def lock_unlock(sbox):
"lock and unlock some files"
sbox.build()
wc_dir = sbox.wc_dir
pi_path = os.path.join(wc_dir, 'A', 'D', 'G', 'pi')
rho_path = os.path.join(wc_dir, 'A', 'D', 'G', 'rho')
tau_path = os.path.join(wc_dir, 'A', 'D', 'G', 'tau')
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.tweak('A/D/G/pi', 'A/D/G/rho', 'A/D/G/tau', writelocked='K')
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', pi_path, rho_path, tau_path)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
expected_status.tweak('A/D/G/pi', 'A/D/G/rho', 'A/D/G/tau', writelocked=None)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
pi_path, rho_path, tau_path)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
# Tests dealing with directory deletion and locks
def deleted_dir_lock(sbox):
"verify removal of a directory with locks inside"
sbox.build()
wc_dir = sbox.wc_dir
parent_dir = os.path.join(wc_dir, 'A', 'D', 'G')
pi_path = os.path.join(wc_dir, 'A', 'D', 'G', 'pi')
rho_path = os.path.join(wc_dir, 'A', 'D', 'G', 'rho')
tau_path = os.path.join(wc_dir, 'A', 'D', 'G', 'tau')
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', pi_path, rho_path, tau_path)
svntest.actions.run_and_verify_svn(None, None, [], 'delete', parent_dir)
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'--no-unlock',
'-m', '', parent_dir)
#----------------------------------------------------------------------
# III.c : Lock a file and check the output of 'svn stat' from the same
# working copy and another.
def lock_status(sbox):
"verify status of lock in working copy"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
svntest.main.file_append(file_path, "This is a spreadsheet\n")
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
svntest.main.run_svn(None, 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak(fname, wc_rev=2)
expected_status.tweak(fname, writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Verify status again after modifying the file
svntest.main.file_append(file_path, "check stat output after mod")
expected_status.tweak(fname, status='M ')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Verify status of lock from another working copy
svntest.main.run_svn(None, 'update', wc_b)
expected_status = svntest.actions.get_virginal_state(wc_b, 2)
expected_status.tweak(fname, writelocked='O')
svntest.actions.run_and_verify_status(wc_b, expected_status)
#----------------------------------------------------------------------
# III.c : Steal lock on a file from another working copy with 'svn lock
# --force', and check the status of lock in the repository from the
# working copy in which the file was initially locked.
def stolen_lock_status (sbox):
"verify status of stolen lock"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_path_b = os.path.join(wc_b, fname)
svntest.main.file_append(file_path, "This is a spreadsheet\n")
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
svntest.main.run_svn(None, 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak(fname, wc_rev=2)
expected_status.tweak(fname, writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Forcibly lock same file (steal lock) from another working copy
svntest.main.run_svn(None, 'update', wc_b)
svntest.main.run_svn(None, 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', '--force', file_path_b)
# Verify status from working copy where file was initially locked
expected_status.tweak(fname, writelocked='T')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
# III.c : Break lock from another working copy with 'svn unlock --force'
# and verify the status of the lock in the repository with 'svn stat -u'
# from the working copy in the file was initially locked
def broken_lock_status (sbox):
"verify status of broken lock"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_path_b = os.path.join(wc_b, fname)
svntest.main.file_append(file_path, "This is a spreadsheet\n")
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
svntest.main.run_svn(None, 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak(fname, wc_rev=2)
expected_status.tweak(fname, writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Forcibly unlock the same file (break lock) from another working copy
svntest.main.run_svn(None, 'update', wc_b)
svntest.main.run_svn(None, 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'--force', file_path_b)
# Verify status from working copy where file was initially locked
expected_status.tweak(fname, writelocked='B')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
# Invalid input test - lock non-existent file
def lock_non_existent_file (sbox):
"verify error on locking non-existent file"
sbox.build()
fname = 'A/foo'
file_path = os.path.join(sbox.wc_dir, fname)
output, error = svntest.main.run_svn(1, 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
error_msg = "'foo' is not under version control"
for line in error:
if line.find(error_msg) != -1:
break
else:
print "Error:", error_msg, ": not found in:", error
raise svntest.Failure
#----------------------------------------------------------------------
# Check that locking an out-of-date file fails.
def out_of_date(sbox):
"lock an out-of-date file and ensure failure"
sbox.build()
wc_dir = sbox.wc_dir
# Make a second copy of the working copy
wc_b = sbox.add_wc_path('_b')
svntest.actions.duplicate_dir(wc_dir, wc_b)
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_path_b = os.path.join(wc_b, fname)
# Make a new revision of the file in the first WC.
svntest.main.file_append(file_path, "This represents a binary file\n")
svntest.main.run_svn(None, 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
# --- Meanwhile, in our other working copy... ---
svntest.actions.run_and_verify_svn(None, None,
".*newer version of '/iota' exists",
'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'-m', '', file_path_b)
#----------------------------------------------------------------------
# Tests reverting a svn:needs-lock file
def revert_lock(sbox):
"verify svn:needs-lock behavior with revert"
sbox.build()
wc_dir = sbox.wc_dir
iota_path = os.path.join(wc_dir, 'iota')
mode = stat.S_IWGRP | stat.S_IWOTH | stat.S_IWRITE
# set the prop in wc
svntest.actions.run_and_verify_svn(None, None, [], 'propset',
'svn:needs-lock', 'foo', iota_path)
# commit r2
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
# make sure that iota got set to read-only
if (os.stat (iota_path)[0] & mode):
print "Committing a file with 'svn:needs-lock'"
print "did not set the file to read-only"
raise svntest.Failure
# verify status is as we expect
expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
expected_status.tweak(wc_rev=1)
expected_status.tweak('iota', wc_rev=2)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# remove read-only-ness
svntest.actions.run_and_verify_svn(None, None, [], 'propdel',
'svn:needs-lock', iota_path)
# make sure that iota got read-only-ness removed
if (os.stat (iota_path)[0] & mode == 0):
print "Deleting the 'svn:needs-lock' property "
print "did not remove read-only-ness"
raise svntest.Failure
# revert the change
svntest.actions.run_and_verify_svn(None, None, [], 'revert', iota_path)
# make sure that iota got set back to read-only
if (os.stat (iota_path)[0] & mode):
print "Reverting a file with 'svn:needs-lock'"
print "did not set the file back to read-only"
raise svntest.Failure
# try propdel and revert from a different directory so
# full filenames are used
extra_name = 'xx'
# now lock the file
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', iota_path)
# modify it
svntest.main.file_append(iota_path, "This line added\n")
expected_status.tweak(wc_rev=1)
expected_status.tweak('iota', wc_rev=2)
expected_status.tweak('iota', status='M ', writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# revert it
svntest.actions.run_and_verify_svn(None, None, [], 'revert', iota_path)
# make sure it is still writable since we have the lock
if (os.stat (iota_path)[0] & mode == 0):
print "Reverting a 'svn:needs-lock' file (with lock in wc) "
print "did not leave the file writable"
raise svntest.Failure
#----------------------------------------------------------------------
def examine_lock_via_url(sbox):
"examine the fields of a lock from a URL"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'iota'
comment = 'This is a lock test.'
file_path = os.path.join(sbox.wc_dir, fname)
file_url = svntest.main.current_repo_url + '/' + fname
# lock a file as wc_author
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'-m', comment, file_path)
output, err = svntest.actions.run_and_verify_svn(None, None, [], 'info',
file_url)
match_line = 'Lock Owner: ' + svntest.main.wc_author2 + '\n'
if not match_line in output:
print "Error: expected output '%s' not found in output." % match_line
raise svntest.Failure
#----------------------------------------------------------------------
def lock_several_files(sbox):
"lock/unlock several files in one go"
sbox.build()
wc_dir = sbox.wc_dir
# Deliberately have no direct child of A as a target
iota_path = os.path.join(sbox.wc_dir, 'iota')
lambda_path = os.path.join(sbox.wc_dir, 'A', 'B', 'lambda')
alpha_path = os.path.join(sbox.wc_dir, 'A', 'B', 'E', 'alpha')
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'-m', 'lock several',
iota_path, lambda_path, alpha_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.tweak('iota', 'A/B/lambda', 'A/B/E/alpha', writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
iota_path, lambda_path, alpha_path)
expected_status.tweak('iota', 'A/B/lambda', 'A/B/E/alpha', writelocked=None)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
def lock_switched_files(sbox):
"lock/unlock switched files"
sbox.build()
wc_dir = sbox.wc_dir
gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
lambda_path = os.path.join(wc_dir, 'A', 'B', 'lambda')
iota_URL = svntest.main.current_repo_url + '/iota'
alpha_URL = svntest.main.current_repo_url + '/A/B/E/alpha'
svntest.actions.run_and_verify_svn(None, None, [], 'switch',
iota_URL, gamma_path)
svntest.actions.run_and_verify_svn(None, None, [], 'switch',
alpha_URL, lambda_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.tweak('A/D/gamma', 'A/B/lambda', switched='S')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'-m', 'lock several',
gamma_path, lambda_path)
expected_status.tweak('A/D/gamma', 'A/B/lambda', writelocked='K')
expected_status.tweak('A/B/E/alpha', 'iota', writelocked='O')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
gamma_path, lambda_path)
expected_status.tweak('A/D/gamma', 'A/B/lambda', writelocked=None)
expected_status.tweak('A/B/E/alpha', 'iota', writelocked=None)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
def lock_uri_encoded(sbox):
"lock and unlock a file with an URI-unsafe name"
sbox.build()
wc_dir = sbox.wc_dir
# lock a file as wc_author
fname = 'amazing space'
file_path = os.path.join(wc_dir, fname)
svntest.main.file_append(file_path, "This represents a binary file\n")
svntest.actions.run_and_verify_svn(None, None, [], "add", file_path)
expected_output = svntest.wc.State(wc_dir, {
fname : Item(verb='Adding'),
})
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.add({ fname: Item(wc_rev=2, status=' ') })
# Commit the file.
svntest.actions.run_and_verify_commit(wc_dir,
expected_output,
expected_status,
None,
None, None,
None, None,
file_path)
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_path)
# Make sure that the file was locked.
expected_status.tweak(fname, writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_path)
# Make sure it was successfully unlocked again.
expected_status.tweak(fname, writelocked=None)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# And now the URL case.
file_url = svntest.main.current_repo_url + '/' + fname
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', file_url)
# Make sure that the file was locked.
expected_status.tweak(fname, writelocked='O')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_url)
# Make sure it was successfully unlocked again.
expected_status.tweak(fname, writelocked=None)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
# A regression test for a bug when svn:needs-lock and svn:executable
# interact badly. The bug was fixed in trunk @ r14859.
def lock_and_exebit1(sbox):
"svn:needs-lock and svn:executable, part I"
mode_w = stat.S_IWUSR
mode_x = stat.S_IXUSR
mode_r = stat.S_IRUSR
sbox.build()
wc_dir = sbox.wc_dir
gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
svntest.actions.run_and_verify_svn(None, None, [], 'ps',
'svn:needs-lock', ' ', gamma_path)
svntest.actions.run_and_verify_svn(None, None, [], 'ps',
'svn:executable', ' ', gamma_path)
# commit
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', gamma_path)
# mode should be +r, -w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Committing a file with 'svn:needs-lock, svn:executable'"
print "did not set the file to read-only, executable"
raise svntest.Failure
# lock
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', gamma_path)
# mode should be +r, +w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or not gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Locking a file with 'svn:needs-lock, svn:executable'"
print "did not set the file to read-write, executable"
raise svntest.Failure
# modify
svntest.main.file_append(gamma_path, "check stat output after mod & unlock")
# unlock
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
gamma_path)
# Mode should be +r, -w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Unlocking a file with 'svn:needs-lock, svn:executable'"
print "did not set the file to read-only, executable"
raise svntest.Failure
# ci
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', gamma_path)
# Mode should be still +r, -w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Commiting a file with 'svn:needs-lock, svn:executable'"
print "after unlocking modified file's permissions"
raise svntest.Failure
#----------------------------------------------------------------------
# A variant of lock_and_exebit1: same test without unlock
def lock_and_exebit2(sbox):
"svn:needs-lock and svn:executable, part II"
mode_w = stat.S_IWUSR
mode_x = stat.S_IXUSR
mode_r = stat.S_IRUSR
sbox.build()
wc_dir = sbox.wc_dir
gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
svntest.actions.run_and_verify_svn(None, None, [], 'ps',
'svn:needs-lock', ' ', gamma_path)
svntest.actions.run_and_verify_svn(None, None, [], 'ps',
'svn:executable', ' ', gamma_path)
# commit
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', gamma_path)
# mode should be +r, -w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Committing a file with 'svn:needs-lock, svn:executable'"
print "did not set the file to read-only, executable"
raise svntest.Failure
# lock
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', gamma_path)
# mode should be +r, +w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or not gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Locking a file with 'svn:needs-lock, svn:executable'"
print "did not set the file to read-write, executable"
raise svntest.Failure
# modify
svntest.main.file_append(gamma_path, "check stat output after mod & unlock")
# commit
svntest.actions.run_and_verify_svn(None, None, [], 'commit',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', '', gamma_path)
# Mode should be +r, -w, +x
gamma_stat = os.stat (gamma_path)[0]
if (not gamma_stat & mode_r
or gamma_stat & mode_w
or not gamma_stat & mode_x):
print "Commiting a file with 'svn:needs-lock, svn:executable'"
print "did not set the file to read-only, executable"
raise svntest.Failure
def commit_xml_unsafe_file_unlock(sbox):
"commit file with xml-unsafe name and release lock"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'foo & bar'
file_path = os.path.join(sbox.wc_dir, fname)
svntest.main.file_append(file_path, "Initial data.\n")
svntest.main.run_svn(None, 'add', file_path)
svntest.main.run_svn(None, 'commit', '-m', '', file_path)
# lock fname as wc_author
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', 'some lock comment', file_path)
# make a change and commit it, allowing lock to be released
svntest.main.file_append(file_path, "Followup data.\n")
svntest.main.run_svn(None, 'commit', '-m', '', file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 3)
expected_status.tweak(wc_rev=1)
expected_status.add({ fname : Item(status=' ', wc_rev=3), })
# Make sure the file is unlocked
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
def repos_lock_with_info(sbox):
"verify info path@X or path -rY return repos lock"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'iota'
comment = 'This is a lock test.'
file_path = os.path.join(sbox.wc_dir, fname)
file_url = svntest.main.current_repo_url + '/' + fname
# lock wc file
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'-m', comment, file_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.tweak(fname, writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Steal lock on wc file
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'--force',
'-m', comment, file_url)
expected_status.tweak(fname, writelocked='T')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Get repository lock token
output, err = svntest.actions.run_and_verify_svn(None, None, [], 'info',
file_url)
for line in output:
if line.find("Lock Token:") != -1:
repos_lock_token = line[12:]
break
else:
print "Error: Lock token not found"
raise svntest.Failure
# info with revision option
output, err = svntest.actions.run_and_verify_svn(None, None, [], 'info',
file_path, '-r1')
for line in output:
if line.find("Lock Token:") != -1:
lock_token = line[12:]
break
else:
print "Error: Lock token not found"
raise svntest.Failure
if (repos_lock_token != lock_token):
print "Error: expected repository lock information not found."
raise svntest.Failure
# info with peg revision
output, err = svntest.actions.run_and_verify_svn(None, None, [], 'info',
file_path + '@1')
for line in output:
if line.find("Lock Token:") != -1:
lock_token = line[12:]
break
else:
print "Error: Lock token not found"
raise svntest.Failure
if (repos_lock_token != lock_token):
print "Error: expected repository lock information not found."
raise svntest.Failure
#----------------------------------------------------------------------
def unlock_already_unlocked_files(sbox):
"(un)lock set of files, one already (un)locked"
sbox.build()
wc_dir = sbox.wc_dir
# Deliberately have no direct child of A as a target
iota_path = os.path.join(wc_dir, 'iota')
lambda_path = os.path.join(wc_dir, 'A', 'B', 'lambda')
alpha_path = os.path.join(wc_dir, 'A', 'B', 'E', 'alpha')
gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'-m', 'lock several',
iota_path, lambda_path, alpha_path)
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.tweak('iota', 'A/B/lambda', 'A/B/E/alpha', writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
error_msg = ".*Path '/A/B/E/alpha' is already locked by user '" + \
svntest.main.wc_author2 + "'.*"
svntest.actions.run_and_verify_svn(None, None, error_msg,
'lock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
alpha_path, gamma_path)
expected_status.tweak('A/D/gamma', writelocked='K')
svntest.actions.run_and_verify_status(wc_dir, expected_status)
svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
lambda_path)
expected_status.tweak('A/B/lambda', writelocked=None)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
error_msg = "(.*No lock on path '/A/B/lambda'.*)" + \
"|(.*'A/B/lambda' is not locked.*)"
svntest.actions.run_and_verify_svn(None, None, error_msg,
'unlock',
'--username', svntest.main.wc_author2,
'--password', svntest.main.wc_passwd,
'--no-auth-cache',
'--force',
iota_path, lambda_path, alpha_path)
expected_status.tweak('iota', 'A/B/E/alpha', writelocked=None)
svntest.actions.run_and_verify_status(wc_dir, expected_status)
#----------------------------------------------------------------------
def info_moved_path(sbox):
"show correct lock info on moved path"
sbox.build()
wc_dir = sbox.wc_dir
fname = os.path.join(wc_dir, "iota")
fname2 = os.path.join(wc_dir, "iota2")
# Move iota, creating r2.
svntest.actions.run_and_verify_svn(None, None, [],
"mv", fname, fname2)
expected_output = svntest.wc.State(wc_dir, {
'iota2' : Item(verb='Adding'),
'iota' : Item(verb='Deleting'),
})
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.add({
"iota2" : Item(status=' ', wc_rev=2)
})
expected_status.remove("iota")
svntest.actions.run_and_verify_commit (wc_dir,
expected_output,
expected_status,
None,
None, None,
None, None,
wc_dir)
# Create a new, unrelated iota, creating r3.
svntest.main.file_append(fname, "Another iota")
svntest.actions.run_and_verify_svn(None, None, [],
"add", fname)
expected_output = svntest.wc.State(wc_dir, {
'iota' : Item(verb='Adding'),
})
expected_status.add({
"iota" : Item(status=' ', wc_rev=3)
})
svntest.actions.run_and_verify_commit (wc_dir,
expected_output,
expected_status,
None,
None, None,
None, None,
wc_dir)
# Lock the new iota.
svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
"lock", fname,
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd)
expected_status.tweak("iota", writelocked="K")
svntest.actions.run_and_verify_status(wc_dir, expected_status)
# Get info for old iota at r1. This shouldn't give us any lock info.
output, errput = svntest.actions.run_and_verify_svn(None, None, [],
'info',
fname2, '-r1')
# Since we want to make sure that there is *no* lock info, to make this
# more robust, we also check that the info command actually output some info.
got_url = 0
for line in output:
if line.find("URL:") >= 0:
got_url = 1
if line.find("Lock Token:") >= 0:
print fname2 + " was reported as locked."
raise svntest.Failure
if not got_url:
print "Info didn't output an URL."
raise svntest.Failure
#----------------------------------------------------------------------
def ls_url_encoded(sbox):
"ls locked path needing URL encoding"
sbox.build()
wc_dir = sbox.wc_dir
dirname = os.path.join(wc_dir, "space dir")
fname = os.path.join(dirname, "f")
# Create a dir with a space in its name and a file therein.
svntest.actions.run_and_verify_svn(None, None, [],
"mkdir", dirname)
svntest.main.file_append(fname, "someone was here")
svntest.actions.run_and_verify_svn(None, None, [],
"add", fname)
expected_output = svntest.wc.State(wc_dir, {
'space dir' : Item(verb='Adding'),
'space dir/f' : Item(verb='Adding'),
})
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.add({
"space dir" : Item(status=' ', wc_rev=2),
"space dir/f" : Item(status=' ', wc_rev=2),
})
svntest.actions.run_and_verify_commit(wc_dir,
expected_output,
expected_status,
None,
None, None,
None, None,
wc_dir)
# Lock the file.
svntest.actions.run_and_verify_svn("Lock space dir/f", ".*locked by user",
[], "lock", fname,
"--username", svntest.main.wc_author,
"--password", svntest.main.wc_passwd)
# Make sure ls shows it being locked.
expected_output = " +2 " + re.escape(svntest.main.wc_author) + " +O .+f"
svntest.actions.run_and_verify_svn("List space dir",
expected_output, [],
"list", "-v", dirname)
#----------------------------------------------------------------------
# Make sure unlocking a path with the wrong lock token fails.
def unlock_wrong_token(sbox):
"veriy unlocking with wrong lock token"
sbox.build()
wc_dir = sbox.wc_dir
# lock a file as wc_author
fname = 'iota'
file_path = os.path.join(sbox.wc_dir, fname)
file_url = svntest.main.current_repo_url + "/iota"
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_path)
# Steal the lock as the same author, but using an URL to keep the old token
# in the WC.
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
"--force", file_url)
# Then, unlocking the WC path should fail.
# ### The error message returned is actually this, but let's worry about that
# ### another day...
svntest.actions.run_and_verify_svn(None, None,
".*((No lock on path)|(400 Bad Request))",
'unlock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
file_path)
#----------------------------------------------------------------------
# Verify that info shows lock info for locked files with URI-unsafe names
# when run in recursive mode.
def examine_lock_encoded_recurse(sbox):
"verify recursive info shows lock info"
sbox.build()
wc_dir = sbox.wc_dir
fname = 'A/B/F/one iota'
comment = 'This is a lock test.'
file_path = os.path.join(sbox.wc_dir, fname)
svntest.main.file_append(file_path, "This represents a binary file\n")
svntest.actions.run_and_verify_svn(None, None, [], "add", file_path)
expected_output = svntest.wc.State(wc_dir, {
fname : Item(verb='Adding'),
})
expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
expected_status.add({ fname: Item(wc_rev=2, status=' ') })
# Commit the file.
svntest.actions.run_and_verify_commit(wc_dir,
expected_output,
expected_status,
None,
None, None,
None, None,
file_path)
# lock the file
svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
'--username', svntest.main.wc_author,
'--password', svntest.main.wc_passwd,
'-m', comment, file_path)
# Run info and check that we get the lock fields.
output, err = svntest.actions.run_and_verify_svn(None, None, [],
'info', '-R',
svntest.main.current_repo_url + '/A/B/F')
lock_info = output[-6:-1]
if ((len(lock_info) != 5)
or (lock_info[0][0:28] != 'Lock Token: opaquelocktoken:')
or (lock_info[1] != 'Lock Owner: ' + svntest.main.wc_author + '\n')
or (lock_info[2][0:13] != 'Lock Created:')
or (lock_info[4] != comment + '\n')):
raise svntest.Failure
########################################################################
# Run the tests
# list all tests here, starting with None:
test_list = [ None,
lock_file,
commit_file_keep_lock,
commit_file_unlock,
commit_propchange,
break_lock,
steal_lock,
examine_lock,
handle_defunct_lock,
enforce_lock,
defunct_lock,
deleted_path_lock,
lock_unlock,
deleted_dir_lock,
lock_status,
stolen_lock_status,
broken_lock_status,
lock_non_existent_file,
out_of_date,
update_while_needing_lock,
revert_lock,
examine_lock_via_url,
lock_several_files,
lock_switched_files,
lock_uri_encoded,
Skip(lock_and_exebit1, (os.name != 'posix')),
Skip(lock_and_exebit2, (os.name != 'posix')),
commit_xml_unsafe_file_unlock,
repos_lock_with_info,
unlock_already_unlocked_files,
info_moved_path,
ls_url_encoded,
unlock_wrong_token,
examine_lock_encoded_recurse,
]
if __name__ == '__main__':
svntest.main.run_tests(test_list)
# NOTREACHED
### End of file.
syntax highlighted by Code2HTML, v. 0.9.1