← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
# Authors:  Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
19
19
    bzrdir,
20
20
    conflicts,
21
21
    errors,
 
22
    symbol_versioning,
22
23
    transport,
23
24
    workingtree,
24
25
    workingtree_3,
25
26
    workingtree_4,
26
27
    )
27
 
from bzrlib.lock import write_locked
28
28
from bzrlib.lockdir import LockDir
29
29
from bzrlib.mutabletree import needs_tree_write_lock
30
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
186
186
        transport.put_bytes("format", "some format name")
187
187
        # The format does not have to be known by Bazaar,
188
188
        # find_format_string just retrieves the name
189
 
        self.assertEqual("some format name",
 
189
        self.assertEquals("some format name",
190
190
            workingtree.WorkingTreeFormatMetaDir.find_format_string(branch.bzrdir))
191
191
 
192
192
    def test_find_format(self):
218
218
                          workingtree.WorkingTreeFormatMetaDir.find_format,
219
219
                          dir)
220
220
 
 
221
    def test_register_unregister_format(self):
 
222
        format = SampleTreeFormat()
 
223
        # make a control dir
 
224
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
225
        dir.create_repository()
 
226
        dir.create_branch()
 
227
        # make a branch
 
228
        format.initialize(dir)
 
229
        # register a format for it.
 
230
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
231
            workingtree.WorkingTreeFormat.register_format, format)
 
232
        self.assertTrue(format in 
 
233
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
234
                workingtree.WorkingTreeFormat.get_formats))
 
235
        # which branch.Open will refuse (not supported)
 
236
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
 
237
        # but open_downlevel will work
 
238
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
 
239
        # unregister the format
 
240
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
241
            workingtree.WorkingTreeFormat.unregister_format, format)
 
242
        self.assertFalse(format in
 
243
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
244
                workingtree.WorkingTreeFormat.get_formats))
 
245
 
221
246
    def test_find_format_with_features(self):
222
247
        tree = self.make_branch_and_tree('.', format='2a')
223
248
        tree.update_feature_flags({"name": "necessity"})
224
249
        found_format = workingtree.WorkingTreeFormatMetaDir.find_format(
225
250
            tree.bzrdir)
226
251
        self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)
227
 
        self.assertEqual(found_format.features.get("name"), "necessity")
 
252
        self.assertEquals(found_format.features.get("name"), "necessity")
228
253
        self.assertRaises(errors.MissingFeature, found_format.check_support_status,
229
254
            True)
230
255
        self.addCleanup(workingtree.WorkingTreeFormatMetaDir.unregister_feature,
283
308
    def test_register_unregister_format(self):
284
309
        format = SampleTreeFormat()
285
310
        self.registry.register(format)
286
 
        self.assertEqual(format, self.registry.get("Sample tree format."))
 
311
        self.assertEquals(format, self.registry.get("Sample tree format."))
287
312
        self.registry.remove(format)
288
313
        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
289
314
 
290
315
    def test_get_all(self):
291
316
        format = SampleTreeFormat()
292
 
        self.assertEqual([], self.registry._get_all())
 
317
        self.assertEquals([], self.registry._get_all())
293
318
        self.registry.register(format)
294
 
        self.assertEqual([format], self.registry._get_all())
 
319
        self.assertEquals([format], self.registry._get_all())
295
320
 
296
321
    def test_register_extra(self):
297
322
        format = SampleExtraTreeFormat()
298
 
        self.assertEqual([], self.registry._get_all())
 
323
        self.assertEquals([], self.registry._get_all())
299
324
        self.registry.register_extra(format)
300
 
        self.assertEqual([format], self.registry._get_all())
 
325
        self.assertEquals([format], self.registry._get_all())
301
326
 
302
327
    def test_register_extra_lazy(self):
303
 
        self.assertEqual([], self.registry._get_all())
 
328
        self.assertEquals([], self.registry._get_all())
304
329
        self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
305
330
            "SampleExtraTreeFormat")
306
331
        formats = self.registry._get_all()
307
 
        self.assertEqual(1, len(formats))
 
332
        self.assertEquals(1, len(formats))
308
333
        self.assertIsInstance(formats[0], SampleExtraTreeFormat)
309
334
 
310
335
 
356
381
        self.assertIsDirectory('.bzr/checkout', t)
357
382
        self.assertIsDirectory('.bzr/checkout/lock', t)
358
383
        our_lock = LockDir(t, '.bzr/checkout/lock')
359
 
        self.assertEqual(our_lock.peek(), None)
 
384
        self.assertEquals(our_lock.peek(), None)
360
385
        tree.lock_write()
361
386
        self.assertTrue(our_lock.peek())
362
387
        tree.unlock()
363
 
        self.assertEqual(our_lock.peek(), None)
 
388
        self.assertEquals(our_lock.peek(), None)
364
389
 
365
390
    def test_missing_pending_merges(self):
366
391
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
495
520
        self.make_branch('qux')
496
521
        trees = workingtree.WorkingTree.find_trees('.')
497
522
        self.assertEqual(2, len(list(trees)))
498
 
 
499
 
 
500
 
class TestStoredUncommitted(TestCaseWithTransport):
501
 
 
502
 
    def store_uncommitted(self):
503
 
        tree = self.make_branch_and_tree('tree')
504
 
        tree.commit('get root in there')
505
 
        self.build_tree_contents([('tree/file', 'content')])
506
 
        tree.add('file', 'file-id')
507
 
        tree.store_uncommitted()
508
 
        return tree
509
 
 
510
 
    def test_store_uncommitted(self):
511
 
        self.store_uncommitted()
512
 
        self.assertPathDoesNotExist('tree/file')
513
 
 
514
 
    def test_store_uncommitted_no_change(self):
515
 
        tree = self.make_branch_and_tree('tree')
516
 
        tree.commit('get root in there')
517
 
        tree.store_uncommitted()
518
 
        self.assertIs(None, tree.branch.get_unshelver(tree))
519
 
 
520
 
    def test_restore_uncommitted(self):
521
 
        with write_locked(self.store_uncommitted()) as tree:
522
 
            tree.restore_uncommitted()
523
 
            self.assertPathExists('tree/file')
524
 
            self.assertIs(None, tree.branch.get_unshelver(tree))
525
 
 
526
 
    def test_restore_uncommitted_none(self):
527
 
        tree = self.make_branch_and_tree('tree')
528
 
        tree.restore_uncommitted()