← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/bzrdir_implementations/test_bzrdir.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-05 08:29:29 UTC
  • mfrom: (1697.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060505082929-a037ee137f1ff240
Merge break-lock command.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/bzrdir_implementations/test_bzrdir.py
16
16
 
17
17
"""Tests for bzrdir implementations - tests a bzrdir format."""
18
18
 
 
19
from cStringIO import StringIO
19
20
import os
20
21
from stat import *
21
22
import sys
1116
1117
        self.failUnless(len(text))
1117
1118
 
1118
1119
 
 
1120
class TestBreakLock(TestCaseWithBzrDir):
 
1121
 
 
1122
    def setUp(self):
 
1123
        super(TestBreakLock, self).setUp()
 
1124
        # we want a UI factory that accepts canned input for the tests:
 
1125
        # while SilentUIFactory still accepts stdin, we need to customise
 
1126
        # ours
 
1127
        self.old_factory = bzrlib.ui.ui_factory
 
1128
        self.addCleanup(self.restoreFactory)
 
1129
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
1130
 
 
1131
    def restoreFactory(self):
 
1132
        bzrlib.ui.ui_factory = self.old_factory
 
1133
 
 
1134
    def test_break_lock_empty(self):
 
1135
        # break lock on an empty bzrdir should work silently.
 
1136
        dir = self.make_bzrdir('.')
 
1137
        try:
 
1138
            dir.break_lock()
 
1139
        except NotImplementedError:
 
1140
            pass
 
1141
 
 
1142
    def test_break_lock_repository(self):
 
1143
        # break lock with just a repo should unlock the repo.
 
1144
        repo = self.make_repository('.')
 
1145
        repo.lock_write()
 
1146
        # only one yes needed here: it should only be unlocking
 
1147
        # the repo
 
1148
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
 
1149
        try:
 
1150
            repo.bzrdir.break_lock()
 
1151
        except NotImplementedError:
 
1152
            # this bzrdir does not implement break_lock - so we cant test it.
 
1153
            repo.unlock()
 
1154
            return
 
1155
        lock_repo = repo.bzrdir.open_repository()
 
1156
        lock_repo.lock_write()
 
1157
        lock_repo.unlock()
 
1158
        self.assertRaises(errors.LockBroken, repo.unlock)
 
1159
 
 
1160
    def test_break_lock_branch(self):
 
1161
        # break lock with just a repo should unlock the branch.
 
1162
        # and not directly try the repository.
 
1163
        # we test this by making a branch reference to a branch
 
1164
        # and repository in another bzrdir
 
1165
        # for pre-metadir formats this will fail, thats ok.
 
1166
        master = self.make_branch('branch')
 
1167
        thisdir = self.make_bzrdir('this')
 
1168
        try:
 
1169
            bzrlib.branch.BranchReferenceFormat().initialize(
 
1170
                thisdir, master)
 
1171
        except errors.IncompatibleFormat:
 
1172
            return
 
1173
        unused_repo = thisdir.create_repository()
 
1174
        master.lock_write()
 
1175
        unused_repo.lock_write()
 
1176
        # two yes's : branch and repository. If the repo in this
 
1177
        # dir is inappropriately accessed, 3 will be needed, and
 
1178
        # we'll see that because the stream will be fully consumed
 
1179
        bzrlib.ui.ui_factory.stdin = StringIO("y\ny\ny\n")
 
1180
        master.bzrdir.break_lock()
 
1181
        # only two ys should have been read
 
1182
        self.assertEqual("y\n", bzrlib.ui.ui_factory.stdin.read())
 
1183
        # we should be able to lock a newly opened branch now
 
1184
        branch = master.bzrdir.open_branch()
 
1185
        branch.lock_write()
 
1186
        branch.unlock()
 
1187
        # we should not be able to lock the repository in thisdir as its still
 
1188
        # held by the explicit lock we took, and the break lock should not have
 
1189
        # touched it.
 
1190
        repo = thisdir.open_repository()
 
1191
        self.assertRaises(errors.LockContention, repo.lock_write)
 
1192
        unused_repo.unlock()
 
1193
        self.assertRaises(errors.LockBroken, master.unlock)
 
1194
 
 
1195
    def test_break_lock_tree(self):
 
1196
        # break lock with a tree should unlock the tree but not try the 
 
1197
        # branch explicitly. However this is very hard to test for as we 
 
1198
        # dont have a tree reference class, nor is one needed; 
 
1199
        # the worst case if this code unlocks twice is an extra question
 
1200
        # being asked.
 
1201
        tree = self.make_branch_and_tree('.')
 
1202
        tree.lock_write()
 
1203
        # three yes's : tree, branch and repository.
 
1204
        bzrlib.ui.ui_factory.stdin = StringIO("y\ny\ny\ny\n")
 
1205
        try:
 
1206
            tree.bzrdir.break_lock()
 
1207
        except NotImplementedError:
 
1208
            # bzrdir does not support break_lock
 
1209
            tree.unlock()
 
1210
            return
 
1211
        self.assertEqual("y\n", bzrlib.ui.ui_factory.stdin.read())
 
1212
        lock_tree = tree.bzrdir.open_workingtree()
 
1213
        lock_tree.lock_write()
 
1214
        lock_tree.unlock()
 
1215
        self.assertRaises(errors.LockBroken, tree.unlock)
 
1216
 
 
1217
 
1119
1218
class ChrootedBzrDirTests(ChrootedTestCase):
1120
1219
 
1121
1220
    def test_find_repository_no_repository(self):