← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_tags.py

  • Committer: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_tags.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2011 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
17
17
"""Tests for commands related to tags"""
18
18
 
19
19
from bzrlib import (
20
 
    bzrdir,
 
20
    branchbuilder,
21
21
    tag,
22
22
    )
23
23
from bzrlib.branch import (
24
24
    Branch,
25
25
    )
26
 
from bzrlib.bzrdir import BzrDir
27
 
from bzrlib.tests import TestCaseWithTransport
28
 
from bzrlib.repository import (
29
 
    Repository,
 
26
from bzrlib.tests import (
 
27
    script,
 
28
    TestCaseWithTransport,
30
29
    )
31
30
from bzrlib.workingtree import WorkingTree
32
31
 
33
32
 
34
33
class TestTagging(TestCaseWithTransport):
35
34
 
36
 
    # as of 0.14, the default format doesn't do tags so we need to use a
37
 
    # specific format
38
 
 
39
 
    def make_branch_and_tree(self, relpath):
40
 
        format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
41
 
        return TestCaseWithTransport.make_branch_and_tree(self, relpath,
42
 
            format=format)
43
 
 
44
35
    def test_tag_command_help(self):
45
36
        out, err = self.run_bzr('help tag')
46
37
        self.assertContainsRe(out, 'Create, remove or modify a tag')
60
51
        Branch.hooks.install_named_hook('automatic_tag_name',
61
52
            get_tag_name, 'get tag name')
62
53
        out, err = self.run_bzr('tag -d branch')
63
 
        self.assertContainsRe(out, 'Created tag mytag.')
 
54
        self.assertContainsRe(err, 'Created tag mytag.')
64
55
 
65
56
    def test_tag_current_rev(self):
66
57
        t = self.make_branch_and_tree('branch')
68
59
            rev_id='first-revid')
69
60
        # make a tag through the command line
70
61
        out, err = self.run_bzr('tag -d branch NEWTAG')
71
 
        self.assertContainsRe(out, 'Created tag NEWTAG.')
 
62
        self.assertContainsRe(err, 'Created tag NEWTAG.')
72
63
        # tag should be observable through the api
73
64
        self.assertEquals(t.branch.tags.get_tag_dict(),
74
65
                dict(NEWTAG='first-revid'))
123
114
        b3 = Branch.open('branch3')
124
115
        self.assertEquals(b3.tags.lookup_tag('tag1'), 'first-revid')
125
116
 
 
117
    def make_master_and_checkout(self):
 
118
        builder = self.make_branch_builder('master')
 
119
        builder.build_commit(message='Initial commit.', rev_id='rev-1')
 
120
        master = builder.get_branch()
 
121
        child = master.create_checkout(self.get_url('child'))
 
122
        return master, child
 
123
 
 
124
    def make_fork(self, branch):
 
125
        fork = branch.create_clone_on_transport(self.get_transport('fork'))
 
126
        builder = branchbuilder.BranchBuilder(branch=fork)
 
127
        builder.build_commit(message='Commit in fork.', rev_id='fork-0')
 
128
        fork.set_last_revision_info(1, 'rev-1')
 
129
        builder.build_commit(message='Commit in fork.', rev_id='fork-1')
 
130
        return fork
 
131
 
 
132
    def test_merge_without_commit_does_not_propagate_tags_to_master(self):
 
133
        """'bzr merge' alone does not propagate tags to a master branch.
 
134
 
 
135
        (If the user runs 'bzr commit', then that is when the tags from the
 
136
        merge are propagated.)
 
137
        """
 
138
        master, child = self.make_master_and_checkout()
 
139
        fork = self.make_fork(master)
 
140
        fork.tags.set_tag('new-tag', fork.last_revision())
 
141
        self.run_bzr(['merge', '../fork'], working_dir='child')
 
142
        self.assertEqual({}, master.tags.get_tag_dict())
 
143
 
 
144
    def test_commit_in_heavyweight_checkout_copies_tags_to_master(self):
 
145
        master, child = self.make_master_and_checkout()
 
146
        fork = self.make_fork(master)
 
147
        fork.tags.set_tag('new-tag', fork.last_revision())
 
148
        fork.tags.set_tag('non-ancestry-tag', 'fork-0')
 
149
        fork.tags.set_tag('absent-tag', 'absent-rev')
 
150
        script.run_script(self, """
 
151
            $ cd child
 
152
            $ bzr merge ../fork
 
153
            $ bzr commit -m "Merge fork."
 
154
            2>Committing to: .../master/
 
155
            2>Committed revision 2.
 
156
            """, null_output_matches_anything=True)
 
157
        # Merge copied the tag to child and commit propagated it to master
 
158
        expected_tag_dict = {
 
159
            'new-tag': fork.last_revision(),
 
160
            'non-ancestry-tag': 'fork-0',
 
161
            'absent-tag': 'absent-rev',
 
162
            }
 
163
        self.assertEqual(expected_tag_dict, child.branch.tags.get_tag_dict())
 
164
        self.assertEqual(expected_tag_dict, master.tags.get_tag_dict())
 
165
        # Revisions not in ancestry but named in tags are present
 
166
        child.branch.repository.get_revision('fork-0')
 
167
        master.repository.get_revision('fork-0')
 
168
 
 
169
    def test_commit_in_heavyweight_checkout_reports_tag_conflict(self):
 
170
        master, child = self.make_master_and_checkout()
 
171
        fork = self.make_fork(master)
 
172
        fork.tags.set_tag('new-tag', fork.last_revision())
 
173
        master_r1 = master.last_revision()
 
174
        master.tags.set_tag('new-tag', master_r1)
 
175
        script.run_script(self, """
 
176
            $ cd child
 
177
            $ bzr merge ../fork
 
178
            $ bzr commit -m "Merge fork."
 
179
            2>Committing to: .../master/
 
180
            2>Conflicting tags in bound branch:
 
181
            2>    new-tag
 
182
            2>Committed revision 2.
 
183
            """, null_output_matches_anything=True)
 
184
        # Merge copied the tag to child.  master's conflicting tag is unchanged.
 
185
        self.assertEqual(
 
186
            {'new-tag': fork.last_revision()}, child.branch.tags.get_tag_dict())
 
187
        self.assertEqual(
 
188
            {'new-tag': master_r1}, master.tags.get_tag_dict())
 
189
 
126
190
    def test_list_tags(self):
127
191
        tree1 = self.make_branch_and_tree('branch1')
128
192
        tree1.commit(allow_pointless=True, message='revision 1',
132
196
 
133
197
        b1 = tree1.branch
134
198
        # note how the tag for revid-1 sorts after the one for revid-2
135
 
        b1.tags.set_tag(u'tagA\u30d0', 'revid-2')
136
 
        b1.tags.set_tag(u'tagB\u30d0', 'missing') # not present in repository
137
 
        b1.tags.set_tag(u'tagC\u30d0', 'revid-1')
 
199
        b1.tags.set_tag(u'tag1\u30d0', 'revid-2')
 
200
        b1.tags.set_tag(u'tag10\u30d0', 'missing') # not present in repository
 
201
        b1.tags.set_tag(u'tag2\u30d0', 'revid-1')
 
202
 
 
203
        # natural order
 
204
        out, err = self.run_bzr('tags -d branch1',
 
205
                                encoding='utf-8')
 
206
        self.assertEquals(err, '')
 
207
        self.assertContainsRe(out, (u'^tag1\u30d0  *2\ntag2\u30d0  *1\n' +
 
208
            u'tag10\u30d0 *\\?\n').encode('utf-8'))
138
209
 
139
210
        # lexicographical order
140
 
        out, err = self.run_bzr('tags -d branch1', encoding='utf-8')
 
211
        out, err = self.run_bzr('tags --sort=alpha -d branch1',
 
212
                                encoding='utf-8')
141
213
        self.assertEquals(err, '')
142
 
        self.assertContainsRe(out, (u'^tagA\u30d0  *2\ntagB\u30d0  *\\?\n' +
143
 
            u'tagC\u30d0 *1\n').encode('utf-8'))
 
214
        self.assertContainsRe(out, (u'^tag10\u30d0  *\\?\ntag1\u30d0  *2\n' +
 
215
            u'tag2\u30d0 *1\n').encode('utf-8'))
144
216
 
145
 
        out, err = self.run_bzr('tags --show-ids -d branch1', encoding='utf-8')
 
217
        out, err = self.run_bzr('tags --sort=alpha --show-ids -d branch1',
 
218
                                encoding='utf-8')
146
219
        self.assertEquals(err, '')
147
 
        self.assertContainsRe(out, (u'^tagA\u30d0  *revid-2\n' +
148
 
            u'tagB\u30d0  *missing\ntagC\u30d0 *revid-1\n').encode('utf-8'))
 
220
        self.assertContainsRe(out, (u'^tag10\u30d0  *missing\n' +
 
221
            u'tag1\u30d0  *revid-2\ntag2\u30d0 *revid-1\n').encode('utf-8'))
149
222
 
150
223
        # chronological order
151
224
        out, err = self.run_bzr('tags --sort=time -d branch1',
152
225
                encoding='utf-8')
153
226
        self.assertEquals(err, '')
154
 
        self.assertContainsRe(out, (u'^tagC\u30d0  *1\ntagA\u30d0  *2\n' +
155
 
            u'tagB\u30d0 *\\?\n').encode('utf-8'))
 
227
        self.assertContainsRe(out, (u'^tag2\u30d0  *1\ntag1\u30d0  *2\n' +
 
228
            u'tag10\u30d0 *\\?\n').encode('utf-8'))
156
229
 
157
230
        out, err = self.run_bzr('tags --sort=time --show-ids -d branch1',
158
231
                encoding='utf-8')
159
232
        self.assertEquals(err, '')
160
 
        self.assertContainsRe(out, (u'^tagC\u30d0  *revid-1\n' +
161
 
            u'tagA\u30d0  *revid-2\ntagB\u30d0 *missing\n').encode('utf-8'))
 
233
        self.assertContainsRe(out, (u'^tag2\u30d0  *revid-1\n' +
 
234
            u'tag1\u30d0  *revid-2\ntag10\u30d0 *missing\n').encode('utf-8'))
162
235
 
163
236
        # now test dotted revnos
164
237
        tree2 = tree1.bzrdir.sprout('branch2').open_workingtree()
210
283
            error_regexes=["bzr: ERROR: Requested revision: '123.123' "
211
284
                "does not exist in branch:"])
212
285
 
 
286
    def test_sort_tags_custom(self):
 
287
        def sort_by_dots(branch, tags):
 
288
            def sort_key((tag, revid)):
 
289
                return tag.count(".")
 
290
            tags.sort(key=sort_key)
 
291
 
 
292
        # Register a custom sort method
 
293
        tag.tag_sort_methods.register("dots", sort_by_dots, "Sort by dots.")
 
294
        self.addCleanup(tag.tag_sort_methods.remove, "dots")
 
295
 
 
296
        tree1 = self.make_branch_and_tree('branch1')
 
297
        tree1.commit(allow_pointless=True, message='revision 1',
 
298
                rev_id='revid-1', timestamp=10)
 
299
        tree1.commit(allow_pointless=True, message='revision 2',
 
300
                rev_id='revid-2', timestamp=15)
 
301
 
 
302
        b1 = tree1.branch
 
303
 
 
304
        b1.tags.set_tag(u'tag..', 'revid-2')
 
305
        b1.tags.set_tag(u'tag....', 'missing') # not present in repository
 
306
        b1.tags.set_tag(u'tag.', 'revid-1')
 
307
        b1.tags.set_tag(u'tag...', 'revid-1')
 
308
        b1.tags.set_tag(u'tag....', 'revid-1')
 
309
 
 
310
        # sorted by number of dots
 
311
        out, err = self.run_bzr('tags --sort=dots -d branch1')
 
312
        self.assertEquals(err, '')
 
313
        self.assertEquals([
 
314
            'tag.                 1',
 
315
            'tag..                2',
 
316
            'tag...               1',
 
317
            'tag....              1'],
 
318
            out.splitlines())
 
319
 
213
320
    def _check_tag_filter(self, argstr, expected_revnos):
214
321
        #upper bound of laziness
215
322
        out, err = self.run_bzr('tags ' + argstr)
231
338
        self.assertContainsRe(out,
232
339
                'Conflicting tags:\n.*' + tagname.encode('utf-8'))
233
340
        # pull should give a warning about the tags
234
 
        out, err = self.run_bzr('pull -d one two', encoding='utf-8')
 
341
        out, err = self.run_bzr('pull -d one two', encoding='utf-8',
 
342
            retcode=1)
235
343
        self.assertContainsRe(out,
236
344
                'Conflicting tags:\n.*' + tagname.encode('utf-8'))
237
345
        # merge should give a warning about the tags -- not implemented yet
238
346
        ## out, err = self.run_bzr('merge -d one two', encoding='utf-8')
239
347
        ## self.assertContainsRe(out,
240
348
        ##         'Conflicting tags:\n.*' + tagname.encode('utf-8'))
 
349
 
 
350
    def test_tag_quiet(self):
 
351
        t1 = self.make_branch_and_tree('')
 
352
        out, err = self.run_bzr('tag --quiet test1')
 
353
        self.assertEqual('', out)
 
354
        self.assertEqual('', err)
 
355
 
 
356
    def test_tag_delete_quiet(self):
 
357
        t1 = self.make_branch_and_tree('')
 
358
        self.run_bzr('tag test1')
 
359
        out, err = self.run_bzr('tag --delete --quiet test1')
 
360
        self.assertEqual('', out)
 
361
        self.assertEqual('', err)
 
362
 
 
363
    def test_tags_with_mainline_ghosts(self):
 
364
        tree = self.make_branch_and_tree('tree1')
 
365
        tree.set_parent_ids(["spooky"], allow_leftmost_as_ghost=True)
 
366
        tree.add('')
 
367
        tree.commit('msg1', rev_id='rev1')
 
368
        tree.commit('msg2', rev_id='rev2')
 
369
        tree.branch.tags.set_tag('unknown', 'out-of-mainline')
 
370
        tree.branch.tags.set_tag('ghost', 'spooky')
 
371
        tree.branch.tags.set_tag('tag1', 'rev1')
 
372
        tree.branch.tags.set_tag('tag2', 'rev2')
 
373
 
 
374
        out, err = self.run_bzr('tags -d tree1', encoding='utf-8')
 
375
        self.assertEqual(out,
 
376
            'ghost                ?\n'
 
377
            'tag1                 1\n'
 
378
            'tag2                 2\n'
 
379
            'unknown              ?\n')
 
380
        self.assertEqual('', err)