view release on metacpan or  search on metacpan

src/subversion/subversion/tests/cmdline/lock_tests.py  view on Meta::CPAN

  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.remove_subtree('A/B')
  
  svntest.actions.run_and_verify_commit(wc_dir,
                                        [],
                                        expected_status,
                                        None,
                                        wc_dir)

  # now re-add entities to the deleted pathes.
  sbox.simple_mkdir('A/B')
  sbox.simple_add_text('new file replacing old file', 'A/B/lambda')
  sbox.simple_add_text('file replacing former dir', 'A/B/F')
  # The bug also resurrected locks on directories when their path
  # matched a former file.
  sbox.simple_mkdir('A/B/E', 'A/B/E/alpha')
    
  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.tweak('A/B',
						'A/B/E',
						'A/B/E/alpha',
						'A/B/F',
						'A/B/lambda',
						wc_rev='3')
  expected_status.remove('A/B/E/beta')
   
  svntest.actions.run_and_verify_commit(wc_dir,
                                        [],
                                        expected_status,
                                        None,
                                        wc_dir)
	
										
@SkipUnless(svntest.main.is_ra_type_dav)
def dav_lock_timeout(sbox):
  "unlock a lock with timeout"

  import httplib
  from urlparse import urlparse
  import base64

  sbox.build()
  loc = urlparse(sbox.repo_url)

  if loc.scheme == 'http':
    h = httplib.HTTPConnection(loc.hostname, loc.port)
  else:
    h = httplib.HTTPSConnection(loc.hostname, loc.port)

  lock_body = '<?xml version="1.0" encoding="utf-8" ?>' \
              '<D:lockinfo xmlns:D="DAV:">' \
              '  <D:lockscope><D:exclusive/></D:lockscope>' \
              '  <D:locktype><D:write/></D:locktype>' \
              '  <D:owner>' \
              '       <D:href>http://a/test</D:href>' \
              '  </D:owner>' \
              '</D:lockinfo>'

  lock_headers = {
    'Authorization': 'Basic ' + base64.b64encode('jconstant:rayjandom'),
    'Timeout': 'Second-86400'
  }

  # Enabling the following line makes this test easier to debug
  h.set_debuglevel(9)

  h.request('LOCK', sbox.repo_url + '/iota', lock_body, lock_headers)

  r = h.getresponse()

  # Verify that there is a lock, by trying to obtain one
  svntest.actions.run_and_verify_svn2(None, None, ".*locked by user", 0,
                                      'lock', '-m', '', sbox.ospath('iota'))

  # Before this patch this used to fail with a parse error of the timeout
  svntest.actions.run_and_verify_svn2(None, None, ".*W160039.*Unlock.*403", 0,
                                     'unlock', sbox.repo_url + '/iota')

  svntest.actions.run_and_verify_svn(None, None, [],
                                     'unlock', sbox.ospath('iota'), '--force')



def non_root_locks(sbox):
  "locks for working copies not at repos root"

  sbox.build()
  wc_dir = sbox.wc_dir

  svntest.actions.run_and_verify_svn(None, None, [],
                                     'cp', sbox.repo_url, sbox.repo_url + '/X',
                                     '-m', 'copy greek tree')

  sbox.simple_switch(sbox.repo_url + '/X')  
  expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Lock a file
  svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
                                     'lock', sbox.ospath('A/D/G/pi'),
                                     '-m', '')
  expected_status.tweak('A/D/G/pi', writelocked='K')
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Updates don't break the lock
  sbox.simple_update('A/D')
  svntest.actions.run_and_verify_status(wc_dir, expected_status)
  sbox.simple_update('')
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Break the lock
  svntest.actions.run_and_verify_svn(None, None, [],
                                     'unlock', sbox.repo_url + '/X/A/D/G/pi')

  # Subdir update reports the break
  sbox.simple_update('A/D')
  expected_status.tweak('A/D/G/pi', writelocked=None)
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Relock and break
  svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
                                     'lock', sbox.ospath('A/D/G/pi'),
                                     '-m', '')
  expected_status.tweak('A/D/G/pi', writelocked='K')
  svntest.actions.run_and_verify_status(wc_dir, expected_status)
  svntest.actions.run_and_verify_svn(None, None, [],
                                     'unlock', sbox.repo_url + '/X/A/D/G/pi')

  # Root update reports the break
  sbox.simple_update('')
  expected_status.tweak('A/D/G/pi', writelocked=None)
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

@Issue(3515)
@SkipUnless(svntest.main.is_ra_type_dav)
def dav_lock_refresh(sbox):
  "refresh timeout of DAV lock"

  import httplib
  from urlparse import urlparse
  import base64

  sbox.build(create_wc = False)

  # Acquire lock on 'iota'
  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
                                     sbox.repo_url + '/iota')

  # Try to refresh lock using 'If' header
  loc = urlparse(sbox.repo_url)

  if loc.scheme == 'http':
    h = httplib.HTTPConnection(loc.hostname, loc.port)
  else:
    h = httplib.HTTPSConnection(loc.hostname, loc.port)

  lock_token = svntest.actions.run_and_parse_info(sbox.repo_url + '/iota')[0]['Lock Token']

  lock_headers = {
    'Authorization': 'Basic ' + base64.b64encode('jrandom:rayjandom'),
    'If': '(<' + lock_token + '>)',
    'Timeout': 'Second-7200'
  }

  # Enabling the following line makes this test easier to debug
  h.set_debuglevel(9)

  h.request('LOCK', sbox.repo_url + '/iota', '', lock_headers)

  # XFAIL Refreshing of DAV lock fails with error '412 Precondition Failed'
  r = h.getresponse()
  if r.status != httplib.OK:
    raise svntest.Failure('Lock refresh failed: %d %s' % (r.status, r.reason))

@SkipUnless(svntest.main.is_ra_type_dav)
def delete_locked_file_with_percent(sbox):
  "lock and delete a file called 'a %( ) .txt'"

  sbox.build()

  locked_filename = 'a %( ) .txt'
  locked_path = sbox.ospath(locked_filename)
  svntest.main.file_write(locked_path, "content\n")
  sbox.simple_add(locked_filename)
  sbox.simple_commit()
  
  sbox.simple_lock(locked_filename)
  sbox.simple_rm(locked_filename)

  # XFAIL: With a 1.8.x client, this commit fails with:
  #  svn: E175002: Unexpected HTTP status 400 'Bad Request' on '/svn-test-work/repositories/lock_tests-52/!svn/txr/2-2/a%20%25(%20)%20.txt'
  # and the following error in the httpd error log:
  #  Invalid percent encoded URI in tagged If-header [400, #104]
  sbox.simple_commit()

########################################################################
# 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,