/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Michael Ellerman
  • Date: 2006-05-31 08:44:29 UTC
  • mto: (1711.2.63 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1792.
  • Revision ID: michael@ellerman.id.au-20060531084429-35e5429abda9f560
Add optional location to ancestry and fix behaviour for checkouts.

This adds an optional location parameter to the ancestry command. It also
changes the behaviour of ancestry on checkouts such that if they have
been created with a subset of the branch history, only the subset is
shown by 'bzr ancestry'. Tests for all of that as well.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
205
205
        tree.unlock()
206
206
        self.assertEquals(our_lock.peek(), None)
207
207
 
 
208
 
 
209
class TestFormat2WorkingTree(TestCaseWithTransport):
 
210
    """Tests that are specific to format 2 trees."""
 
211
 
208
212
    def create_format2_tree(self, url):
209
 
        return BzrDir.create_standalone_workingtree(url)
 
213
        return self.make_branch_and_tree(
 
214
            url, format=bzrlib.bzrdir.BzrDirFormat6())
210
215
 
211
 
    def test_conflicts_format2(self):
 
216
    def test_conflicts(self):
212
217
        # test backwards compatability
213
218
        tree = self.create_format2_tree('.')
214
219
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
229
234
        os.mkdir('lala.OTHER')
230
235
        expected = ContentsConflict('lala', file_id='lala-id')
231
236
        self.assertEqual(list(tree.conflicts()), [expected])
 
237
 
 
238
 
 
239
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
240
    """This class contains tests of workingtree that are not format specific."""
 
241
 
 
242
    
 
243
    def test_gen_file_id(self):
 
244
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('bar'), 'bar-')
 
245
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('Mwoo oof\t m'), 'Mwoooofm-')
 
246
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..gam.py'), 'gam.py-')
 
247
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..Mwoo oof\t m'), 'Mwoooofm-')
 
248
 
 
249
    def test_next_id_suffix(self):
 
250
        bzrlib.workingtree._gen_id_suffix = None
 
251
        bzrlib.workingtree._next_id_suffix()
 
252
        self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
 
253
        bzrlib.workingtree._gen_id_suffix = "foo-"
 
254
        bzrlib.workingtree._gen_id_serial = 1
 
255
        self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
 
256
        self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
 
257
        self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
 
258
        self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
 
259
        self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
 
260
        self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
 
261
        self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
 
262
        self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
 
263
        self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
 
264
 
 
265
    def test__translate_ignore_rule(self):
 
266
        tree = self.make_branch_and_tree('.')
 
267
        # translation should return the regex, the number of groups in it,
 
268
        # and the original rule in a tuple.
 
269
        # there are three sorts of ignore rules:
 
270
        # root only - regex is the rule itself without the leading ./
 
271
        self.assertEqual(
 
272
            "(rootdirrule$)", 
 
273
            tree._translate_ignore_rule("./rootdirrule"))
 
274
        # full path - regex is the rule itself
 
275
        self.assertEqual(
 
276
            "(path\\/to\\/file$)",
 
277
            tree._translate_ignore_rule("path/to/file"))
 
278
        # basename only rule - regex is a rule that ignores everything up
 
279
        # to the last / in the filename
 
280
        self.assertEqual(
 
281
            "((?:.*/)?(?!.*/)basenamerule$)",
 
282
            tree._translate_ignore_rule("basenamerule"))
 
283
 
 
284
    def test__combine_ignore_rules(self):
 
285
        tree = self.make_branch_and_tree('.')
 
286
        # the combined ignore regexs need the outer group indices
 
287
        # placed in a dictionary with the rules that were combined.
 
288
        # an empty set of rules
 
289
        # this is returned as a list of combined regex,rule sets, because
 
290
        # python has a limit of 100 combined regexes.
 
291
        compiled_rules = tree._combine_ignore_rules([])
 
292
        self.assertEqual([], compiled_rules)
 
293
        # one of each type of rule.
 
294
        compiled_rules = tree._combine_ignore_rules(
 
295
            ["rule1", "rule/two", "./three"])[0]
 
296
        # what type *is* the compiled regex to do an isinstance of ?
 
297
        self.assertEqual(3, compiled_rules[0].groups)
 
298
        self.assertEqual(
 
299
            {0:"rule1",1:"rule/two",2:"./three"},
 
300
            compiled_rules[1])
 
301
 
 
302
    def test__combine_ignore_rules_grouping(self):
 
303
        tree = self.make_branch_and_tree('.')
 
304
        # when there are too many rules, the output is split into groups of 100
 
305
        rules = []
 
306
        for index in range(198):
 
307
            rules.append('foo')
 
308
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
 
309
 
 
310
    def test__get_ignore_rules_as_regex(self):
 
311
        tree = self.make_branch_and_tree('.')
 
312
        # test against the default rules.
 
313
        reference_output = tree._combine_ignore_rules(bzrlib.DEFAULT_IGNORE)[0]
 
314
        regex_rules = tree._get_ignore_rules_as_regex()[0]
 
315
        self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
 
316
        self.assertEqual(reference_output[1], regex_rules[1])