← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Johan Walles
  • Date: 2009-05-06 05:36:28 UTC
  • mfrom: (4332 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4343.
  • Revision ID: johan.walles@gmail.com-20090506053628-tbf1wz4a0m9t684g
Merge from upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
586
586
            '')
587
587
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
588
588
        self.assertEqual('bar', config.get_option('foo'))
589
 
        # Cleanup
590
 
        branch.unlock()
591
589
 
592
590
    def test_value_name_section(self):
593
591
        branch = self.make_branch('.')
599
597
            'gam')
600
598
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
601
599
        self.assertEqual('bar', config.get_option('foo', 'gam'))
602
 
        # Cleanup
603
 
        branch.unlock()
604
600
 
605
601
 
606
602
class SetLastRevisionTestBase(TestLockedBranch):
919
915
        # with a new branch object.
920
916
        new_branch = repository.bzrdir.open_branch()
921
917
        self.assertRaises(errors.LockContention, new_branch.lock_write)
922
 
        # Cleanup
923
 
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
924
 
        response = request.execute('', branch_nonce, repository_nonce)
925
918
 
926
919
    def test_lock_write_on_locked_branch(self):
927
920
        backing = self.get_transport()
928
921
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
929
922
        branch = self.make_branch('.')
930
 
        branch_token = branch.lock_write()
 
923
        branch.lock_write()
931
924
        branch.leave_lock_in_place()
932
925
        branch.unlock()
933
926
        response = request.execute('')
934
927
        self.assertEqual(
935
928
            SmartServerResponse(('LockContention',)), response)
936
 
        # Cleanup
937
 
        branch.lock_write(branch_token)
938
 
        branch.dont_leave_lock_in_place()
939
 
        branch.unlock()
940
929
 
941
930
    def test_lock_write_with_tokens_on_locked_branch(self):
942
931
        backing = self.get_transport()
952
941
                                   branch_token, repo_token)
953
942
        self.assertEqual(
954
943
            SmartServerResponse(('ok', branch_token, repo_token)), response)
955
 
        # Cleanup
956
 
        branch.repository.lock_write(repo_token)
957
 
        branch.repository.dont_leave_lock_in_place()
958
 
        branch.repository.unlock()
959
 
        branch.lock_write(branch_token)
960
 
        branch.dont_leave_lock_in_place()
961
 
        branch.unlock()
962
944
 
963
945
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
964
946
        backing = self.get_transport()
974
956
                                   branch_token+'xxx', repo_token)
975
957
        self.assertEqual(
976
958
            SmartServerResponse(('TokenMismatch',)), response)
977
 
        # Cleanup
978
 
        branch.repository.lock_write(repo_token)
979
 
        branch.repository.dont_leave_lock_in_place()
980
 
        branch.repository.unlock()
981
 
        branch.lock_write(branch_token)
982
 
        branch.dont_leave_lock_in_place()
983
 
        branch.unlock()
984
959
 
985
960
    def test_lock_write_on_locked_repo(self):
986
961
        backing = self.get_transport()
987
962
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
988
963
        branch = self.make_branch('.', format='knit')
989
 
        repo = branch.repository
990
 
        repo_token = repo.lock_write()
991
 
        repo.leave_lock_in_place()
992
 
        repo.unlock()
 
964
        branch.repository.lock_write()
 
965
        branch.repository.leave_lock_in_place()
 
966
        branch.repository.unlock()
993
967
        response = request.execute('')
994
968
        self.assertEqual(
995
969
            SmartServerResponse(('LockContention',)), response)
996
 
        # Cleanup
997
 
        repo.lock_write(repo_token)
998
 
        repo.dont_leave_lock_in_place()
999
 
        repo.unlock()
1000
970
 
1001
971
    def test_lock_write_on_readonly_transport(self):
1002
972
        backing = self.get_readonly_transport()
1061
1031
            '', 'branch token', repo_token)
1062
1032
        self.assertEqual(
1063
1033
            SmartServerResponse(('TokenMismatch',)), response)
1064
 
        # Cleanup
1065
 
        branch.repository.lock_write(repo_token)
1066
 
        branch.repository.dont_leave_lock_in_place()
1067
 
        branch.repository.unlock()
1068
1034
 
1069
1035
 
1070
1036
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1316
1282
        # object.
1317
1283
        new_repo = repository.bzrdir.open_repository()
1318
1284
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1319
 
        # Cleanup
1320
 
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1321
 
        response = request.execute('', nonce)
1322
1285
 
1323
1286
    def test_lock_write_on_locked_repo(self):
1324
1287
        backing = self.get_transport()
1325
1288
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1326
1289
        repository = self.make_repository('.', format='knit')
1327
 
        repo_token = repository.lock_write()
 
1290
        repository.lock_write()
1328
1291
        repository.leave_lock_in_place()
1329
1292
        repository.unlock()
1330
1293
        response = request.execute('')
1331
1294
        self.assertEqual(
1332
1295
            SmartServerResponse(('LockContention',)), response)
1333
 
        # Cleanup
1334
 
        repository.lock_write(repo_token)
1335
 
        repository.dont_leave_lock_in_place()
1336
 
        repository.unlock()
1337
1296
 
1338
1297
    def test_lock_write_on_readonly_transport(self):
1339
1298
        backing = self.get_readonly_transport()