← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_branch.py

  • Committer: Rory Yorke
  • Date: 2010-10-20 14:38:53 UTC
  • mto: This revision was merged to the branch mainline in revision 5519.
  • Revision ID: rory.yorke@gmail.com-20101020143853-9kfd2ldcjfroh8jw
Show missing files in bzr status (bug 134168).

"bzr status" will now show missing files, that is, those added with "bzr
add" and then removed by non bzr means (e.g., rm).

Blackbox tests were added for this case, and tests were also added to
test_delta, since the implementation change is in bzrlib.delta.

Might also affect bug 189709.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
32
32
    symbol_versioning,
33
33
    tests,
34
34
    trace,
 
35
    transport,
35
36
    urlutils,
36
37
    )
37
38
 
40
41
 
41
42
    def test_default_format(self):
42
43
        # update this if you change the default branch format
43
 
        self.assertIsInstance(_mod_branch.format_registry.get_default(),
 
44
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
44
45
                _mod_branch.BzrBranchFormat7)
45
46
 
46
47
    def test_default_format_is_same_as_bzrdir_default(self):
48
49
        # set, but at the moment that's not true -- mbp 20070814 --
49
50
        # https://bugs.launchpad.net/bzr/+bug/132376
50
51
        self.assertEqual(
51
 
            _mod_branch.format_registry.get_default(),
 
52
            _mod_branch.BranchFormat.get_default_format(),
52
53
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
53
54
 
54
55
    def test_get_set_default_format(self):
55
56
        # set the format and then set it back again
56
 
        old_format = _mod_branch.format_registry.get_default()
57
 
        _mod_branch.format_registry.set_default(SampleBranchFormat())
 
57
        old_format = _mod_branch.BranchFormat.get_default_format()
 
58
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
58
59
        try:
59
60
            # the default branch format is used by the meta dir format
60
61
            # which is not the default bzrdir format at this point
62
63
            result = dir.create_branch()
63
64
            self.assertEqual(result, 'A branch')
64
65
        finally:
65
 
            _mod_branch.format_registry.set_default(old_format)
 
66
            _mod_branch.BranchFormat.set_default_format(old_format)
66
67
        self.assertEqual(old_format,
67
 
                         _mod_branch.format_registry.get_default())
 
68
                         _mod_branch.BranchFormat.get_default_format())
68
69
 
69
70
 
70
71
class TestBranchFormat5(tests.TestCaseWithTransport):
112
113
        """See BzrBranchFormat.get_format_string()."""
113
114
        return "Sample branch format."
114
115
 
115
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
116
    def initialize(self, a_bzrdir, name=None):
116
117
        """Format 4 branches cannot be created."""
117
118
        t = a_bzrdir.get_branch_transport(self, name=name)
118
119
        t.put_bytes('format', self.get_format_string())
146
147
        return "opened supported branch."
147
148
 
148
149
 
149
 
class SampleExtraBranchFormat(_mod_branch.BranchFormat):
150
 
    """A sample format that is not usable in a metadir."""
151
 
 
152
 
    def get_format_string(self):
153
 
        # This format is not usable in a metadir.
154
 
        return None
155
 
 
156
 
    def network_name(self):
157
 
        # Network name always has to be provided.
158
 
        return "extra"
159
 
 
160
 
    def initialize(self, a_bzrdir, name=None):
161
 
        raise NotImplementedError(self.initialize)
162
 
 
163
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
164
 
        raise NotImplementedError(self.open)
165
 
 
166
 
 
167
150
class TestBzrBranchFormat(tests.TestCaseWithTransport):
168
151
    """Tests for the BzrBranchFormat facility."""
169
152
 
177
160
            dir.create_repository()
178
161
            format.initialize(dir)
179
162
            found_format = _mod_branch.BranchFormat.find_format(dir)
180
 
            self.assertIsInstance(found_format, format.__class__)
 
163
            self.failUnless(isinstance(found_format, format.__class__))
181
164
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
182
165
 
183
166
    def test_find_format_factory(self):
186
169
        factory = _mod_branch.MetaDirBranchFormatFactory(
187
170
            SampleSupportedBranchFormatString,
188
171
            "bzrlib.tests.test_branch", "SampleSupportedBranchFormat")
189
 
        _mod_branch.format_registry.register(factory)
190
 
        self.addCleanup(_mod_branch.format_registry.remove, factory)
 
172
        _mod_branch.BranchFormat.register_format(factory)
 
173
        self.addCleanup(_mod_branch.BranchFormat.unregister_format, factory)
191
174
        b = _mod_branch.Branch.open(self.get_url())
192
175
        self.assertEqual(b, "opened supported branch.")
193
176
 
205
188
                          dir)
206
189
 
207
190
    def test_register_unregister_format(self):
208
 
        # Test the deprecated format registration functions
209
191
        format = SampleBranchFormat()
210
192
        # make a control dir
211
193
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
212
194
        # make a branch
213
195
        format.initialize(dir)
214
196
        # register a format for it.
215
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
216
 
            _mod_branch.BranchFormat.register_format, format)
 
197
        _mod_branch.BranchFormat.register_format(format)
217
198
        # which branch.Open will refuse (not supported)
218
199
        self.assertRaises(errors.UnsupportedFormatError,
219
200
                          _mod_branch.Branch.open, self.get_url())
223
204
            format.open(dir),
224
205
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
225
206
        # unregister the format
226
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
227
 
            _mod_branch.BranchFormat.unregister_format, format)
 
207
        _mod_branch.BranchFormat.unregister_format(format)
228
208
        self.make_branch_and_tree('bar')
229
209
 
230
210
 
231
 
class TestBranchFormatRegistry(tests.TestCase):
232
 
 
233
 
    def setUp(self):
234
 
        super(TestBranchFormatRegistry, self).setUp()
235
 
        self.registry = _mod_branch.BranchFormatRegistry()
236
 
 
237
 
    def test_default(self):
238
 
        self.assertIs(None, self.registry.get_default())
239
 
        format = SampleBranchFormat()
240
 
        self.registry.set_default(format)
241
 
        self.assertEquals(format, self.registry.get_default())
242
 
 
243
 
    def test_register_unregister_format(self):
244
 
        format = SampleBranchFormat()
245
 
        self.registry.register(format)
246
 
        self.assertEquals(format,
247
 
            self.registry.get("Sample branch format."))
248
 
        self.registry.remove(format)
249
 
        self.assertRaises(KeyError, self.registry.get,
250
 
            "Sample branch format.")
251
 
 
252
 
    def test_get_all(self):
253
 
        format = SampleBranchFormat()
254
 
        self.assertEquals([], self.registry._get_all())
255
 
        self.registry.register(format)
256
 
        self.assertEquals([format], self.registry._get_all())
257
 
 
258
 
    def test_register_extra(self):
259
 
        format = SampleExtraBranchFormat()
260
 
        self.assertEquals([], self.registry._get_all())
261
 
        self.registry.register_extra(format)
262
 
        self.assertEquals([format], self.registry._get_all())
263
 
 
264
 
    def test_register_extra_lazy(self):
265
 
        self.assertEquals([], self.registry._get_all())
266
 
        self.registry.register_extra_lazy("bzrlib.tests.test_branch",
267
 
            "SampleExtraBranchFormat")
268
 
        formats = self.registry._get_all()
269
 
        self.assertEquals(1, len(formats))
270
 
        self.assertIsInstance(formats[0], SampleExtraBranchFormat)
271
 
 
272
 
 
273
211
#Used by TestMetaDirBranchFormatFactory 
274
212
FakeLazyFormat = None
275
213
 
322
260
 
323
261
    def test_layout(self):
324
262
        branch = self.make_branch('a', format=self.get_format_name())
325
 
        self.assertPathExists('a/.bzr/branch/last-revision')
326
 
        self.assertPathDoesNotExist('a/.bzr/branch/revision-history')
327
 
        self.assertPathDoesNotExist('a/.bzr/branch/references')
 
263
        self.failUnlessExists('a/.bzr/branch/last-revision')
 
264
        self.failIfExists('a/.bzr/branch/revision-history')
 
265
        self.failIfExists('a/.bzr/branch/references')
328
266
 
329
267
    def test_config(self):
330
268
        """Ensure that all configuration data is stored in the branch"""
331
269
        branch = self.make_branch('a', format=self.get_format_name())
332
 
        branch.set_parent('http://example.com')
333
 
        self.assertPathDoesNotExist('a/.bzr/branch/parent')
334
 
        self.assertEqual('http://example.com', branch.get_parent())
335
 
        branch.set_push_location('sftp://example.com')
 
270
        branch.set_parent('http://bazaar-vcs.org')
 
271
        self.failIfExists('a/.bzr/branch/parent')
 
272
        self.assertEqual('http://bazaar-vcs.org', branch.get_parent())
 
273
        branch.set_push_location('sftp://bazaar-vcs.org')
336
274
        config = branch.get_config()._get_branch_data_config()
337
 
        self.assertEqual('sftp://example.com',
 
275
        self.assertEqual('sftp://bazaar-vcs.org',
338
276
                         config.get_user_option('push_location'))
339
 
        branch.set_bound_location('ftp://example.com')
340
 
        self.assertPathDoesNotExist('a/.bzr/branch/bound')
341
 
        self.assertEqual('ftp://example.com', branch.get_bound_location())
 
277
        branch.set_bound_location('ftp://bazaar-vcs.org')
 
278
        self.failIfExists('a/.bzr/branch/bound')
 
279
        self.assertEqual('ftp://bazaar-vcs.org', branch.get_bound_location())
342
280
 
343
281
    def test_set_revision_history(self):
344
282
        builder = self.make_branch_builder('.', format=self.get_format_name())
349
287
        branch = builder.get_branch()
350
288
        branch.lock_write()
351
289
        self.addCleanup(branch.unlock)
352
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
353
 
            branch.set_revision_history, ['foo', 'bar'])
354
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
355
 
                branch.set_revision_history, ['foo'])
 
290
        branch.set_revision_history(['foo', 'bar'])
 
291
        branch.set_revision_history(['foo'])
356
292
        self.assertRaises(errors.NotLefthandHistory,
357
 
            self.applyDeprecated, symbol_versioning.deprecated_in((2, 4, 0)),
358
 
            branch.set_revision_history, ['bar'])
 
293
                          branch.set_revision_history, ['bar'])
359
294
 
360
295
    def do_checkout_test(self, lightweight=False):
361
296
        tree = self.make_branch_and_tree('source',
374
309
        subtree.commit('a subtree file')
375
310
        subsubtree.commit('a subsubtree file')
376
311
        tree.branch.create_checkout('target', lightweight=lightweight)
377
 
        self.assertPathExists('target')
378
 
        self.assertPathExists('target/subtree')
379
 
        self.assertPathExists('target/subtree/file')
380
 
        self.assertPathExists('target/subtree/subsubtree/file')
 
312
        self.failUnlessExists('target')
 
313
        self.failUnlessExists('target/subtree')
 
314
        self.failUnlessExists('target/subtree/file')
 
315
        self.failUnlessExists('target/subtree/subsubtree/file')
381
316
        subbranch = _mod_branch.Branch.open('target/subtree/subsubtree')
382
317
        if lightweight:
383
318
            self.assertEndsWith(subbranch.base, 'source/subtree/subsubtree/')
545
480
 
546
481
    def test_create_open_reference(self):
547
482
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
548
 
        t = self.get_transport()
 
483
        t = transport.get_transport(self.get_url('.'))
549
484
        t.mkdir('repo')
550
485
        dir = bzrdirformat.initialize(self.get_url('repo'))
551
486
        dir.create_repository()
778
713
                          _mod_branch._run_with_write_locked_target,
779
714
                          lockable, self.func_that_raises)
780
715
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
 
716
 
 
717