← 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: Patch Queue Manager
  • Date: 2016-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_tags.py
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2007-2011, 2016 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
 
    branchbuilder,
 
20
    errors,
21
21
    tag,
22
22
    transform,
23
23
    )
28
28
    script,
29
29
    TestCaseWithTransport,
30
30
    )
 
31
from bzrlib.tests.matchers import ContainsNoVfsCalls
31
32
from bzrlib.workingtree import WorkingTree
32
33
 
33
34
 
62
63
        out, err = self.run_bzr('tag -d branch NEWTAG')
63
64
        self.assertContainsRe(err, 'Created tag NEWTAG.')
64
65
        # tag should be observable through the api
65
 
        self.assertEquals(t.branch.tags.get_tag_dict(),
 
66
        self.assertEqual(t.branch.tags.get_tag_dict(),
66
67
                dict(NEWTAG='first-revid'))
67
68
        # can also create tags using -r
68
69
        self.run_bzr('tag -d branch tag2 -r1')
69
 
        self.assertEquals(t.branch.tags.lookup_tag('tag2'), 'first-revid')
 
70
        self.assertEqual(t.branch.tags.lookup_tag('tag2'), 'first-revid')
70
71
        # regression test: make sure a unicode revision from the user
71
72
        # gets turned into a str object properly. The use of a unicode
72
73
        # object for the revid is intentional.
73
74
        self.run_bzr(['tag', '-d', 'branch', 'tag3', u'-rrevid:first-revid'])
74
 
        self.assertEquals(t.branch.tags.lookup_tag('tag3'), 'first-revid')
 
75
        self.assertEqual(t.branch.tags.lookup_tag('tag3'), 'first-revid')
75
76
        # can also delete an existing tag
76
77
        out, err = self.run_bzr('tag --delete -d branch tag2')
77
78
        # cannot replace an existing tag normally
78
 
        out, err = self.run_bzr('tag -d branch NEWTAG', retcode=3)
 
79
        out, err = self.run_bzr('tag -d branch NEWTAG -r0', retcode=3)
79
80
        self.assertContainsRe(err, 'Tag NEWTAG already exists\\.')
80
81
        # ... but can if you use --force
81
 
        out, err = self.run_bzr('tag -d branch NEWTAG --force')
 
82
        out, err = self.run_bzr('tag -d branch NEWTAG --force -r0')
 
83
        self.assertEqual("Updated tag NEWTAG.\n", err)
 
84
 
 
85
    def test_tag_same_revision(self):
 
86
        t = self.make_branch_and_tree('branch')
 
87
        t.commit(allow_pointless=True, message='initial commit',
 
88
            rev_id='first-revid')
 
89
        t.commit(allow_pointless=True, message='second commit',
 
90
            rev_id='second-revid')
 
91
        out, err = self.run_bzr('tag -rrevid:first-revid -d branch NEWTAG')
 
92
        out, err = self.run_bzr('tag -rrevid:first-revid -d branch NEWTAG')
 
93
        self.assertContainsRe(err,
 
94
            'Tag NEWTAG already exists for that revision\\.')
 
95
        out, err = self.run_bzr('tag -rrevid:second-revid -d branch NEWTAG',
 
96
            retcode=3)
 
97
        self.assertContainsRe(err, 'Tag NEWTAG already exists\\.')
82
98
 
83
99
    def test_tag_delete_requires_name(self):
84
100
        out, err = self.run_bzr('tag -d branch', retcode=3)
93
109
        # branching copies the tag across
94
110
        self.run_bzr('branch branch1 branch2')
95
111
        b2 = Branch.open('branch2')
96
 
        self.assertEquals(b2.tags.lookup_tag('tag1'), 'first-revid')
 
112
        self.assertEqual(b2.tags.lookup_tag('tag1'), 'first-revid')
97
113
        # make a new tag and pull it
98
114
        b1.tags.set_tag('tag2', 'twa')
99
115
        self.run_bzr('pull -d branch2 branch1')
100
 
        self.assertEquals(b2.tags.lookup_tag('tag2'), 'twa')
 
116
        self.assertEqual(b2.tags.lookup_tag('tag2'), 'twa')
101
117
        # make a new tag and push it
102
118
        b1.tags.set_tag('tag3', 'san')
103
119
        self.run_bzr('push -d branch1 branch2')
104
 
        self.assertEquals(b2.tags.lookup_tag('tag3'), 'san')
 
120
        self.assertEqual(b2.tags.lookup_tag('tag3'), 'san')
105
121
        # make a new tag and merge it
106
122
        t.commit(allow_pointless=True, message='second commit',
107
123
            rev_id='second-revid')
109
125
        t2.commit(allow_pointless=True, message='commit in second')
110
126
        b1.tags.set_tag('tag4', 'second-revid')
111
127
        self.run_bzr('merge -d branch2 branch1')
112
 
        self.assertEquals(b2.tags.lookup_tag('tag4'), 'second-revid')
 
128
        self.assertEqual(b2.tags.lookup_tag('tag4'), 'second-revid')
113
129
        # pushing to a new location copies the tag across
114
130
        self.run_bzr('push -d branch1 branch3')
115
131
        b3 = Branch.open('branch3')
116
 
        self.assertEquals(b3.tags.lookup_tag('tag1'), 'first-revid')
 
132
        self.assertEqual(b3.tags.lookup_tag('tag1'), 'first-revid')
117
133
 
118
134
    def make_master_and_checkout(self):
119
135
        builder = self.make_branch_builder('master')
205
221
        # natural order
206
222
        out, err = self.run_bzr('tags -d branch1',
207
223
                                encoding='utf-8')
208
 
        self.assertEquals(err, '')
 
224
        self.assertEqual(err, '')
209
225
        self.assertContainsRe(out, (u'^tag1\u30d0  *2\ntag2\u30d0  *1\n' +
210
226
            u'tag10\u30d0 *\\?\n').encode('utf-8'))
211
227
 
212
228
        # lexicographical order
213
229
        out, err = self.run_bzr('tags --sort=alpha -d branch1',
214
230
                                encoding='utf-8')
215
 
        self.assertEquals(err, '')
 
231
        self.assertEqual(err, '')
216
232
        self.assertContainsRe(out, (u'^tag10\u30d0  *\\?\ntag1\u30d0  *2\n' +
217
233
            u'tag2\u30d0 *1\n').encode('utf-8'))
218
234
 
219
235
        out, err = self.run_bzr('tags --sort=alpha --show-ids -d branch1',
220
236
                                encoding='utf-8')
221
 
        self.assertEquals(err, '')
 
237
        self.assertEqual(err, '')
222
238
        self.assertContainsRe(out, (u'^tag10\u30d0  *missing\n' +
223
239
            u'tag1\u30d0  *revid-2\ntag2\u30d0 *revid-1\n').encode('utf-8'))
224
240
 
225
241
        # chronological order
226
242
        out, err = self.run_bzr('tags --sort=time -d branch1',
227
243
                encoding='utf-8')
228
 
        self.assertEquals(err, '')
 
244
        self.assertEqual(err, '')
229
245
        self.assertContainsRe(out, (u'^tag2\u30d0  *1\ntag1\u30d0  *2\n' +
230
246
            u'tag10\u30d0 *\\?\n').encode('utf-8'))
231
247
 
232
248
        out, err = self.run_bzr('tags --sort=time --show-ids -d branch1',
233
249
                encoding='utf-8')
234
 
        self.assertEquals(err, '')
 
250
        self.assertEqual(err, '')
235
251
        self.assertContainsRe(out, (u'^tag2\u30d0  *revid-1\n' +
236
252
            u'tag1\u30d0  *revid-2\ntag10\u30d0 *missing\n').encode('utf-8'))
237
253
 
248
264
        tree1.commit('merge', rev_id='revid-4')
249
265
 
250
266
        out, err = self.run_bzr('tags -d branch1', encoding='utf-8')
251
 
        self.assertEquals(err, '')
 
267
        self.assertEqual(err, '')
252
268
        self.assertContainsRe(out, r'tagD  *2\.1\.1\n')
253
269
        out, err = self.run_bzr('tags -d branch2', encoding='utf-8')
254
 
        self.assertEquals(err, '')
 
270
        self.assertEqual(err, '')
255
271
        self.assertContainsRe(out, r'tagD  *3\n')
256
272
 
 
273
    def test_list_tags_dotted_revnos_unsupported(self):
 
274
        tree = self.make_branch_and_tree('branch')
 
275
        rev1 = tree.commit("rev1")
 
276
        tree.branch.tags.set_tag("mytag", rev1)
 
277
        def revision_id_to_dotted_revno(self, revid):
 
278
            raise errors.UnsupportedOperation(revision_id_to_dotted_revno, self)
 
279
        self.overrideAttr(Branch, "revision_id_to_dotted_revno",
 
280
            revision_id_to_dotted_revno)
 
281
        out, err = self.run_bzr('tags -d branch', encoding='utf-8')
 
282
        self.assertEqual(out, 'mytag                ?\n')
 
283
 
257
284
    def test_list_tags_revision_filtering(self):
258
285
        tree1 = self.make_branch_and_tree('.')
259
286
        tree1.commit(allow_pointless=True, message='revision 1',
311
338
 
312
339
        # sorted by number of dots
313
340
        out, err = self.run_bzr('tags --sort=dots -d branch1')
314
 
        self.assertEquals(err, '')
315
 
        self.assertEquals([
 
341
        self.assertEqual(err, '')
 
342
        self.assertEqual([
316
343
            'tag.                 1',
317
344
            'tag..                2',
318
345
            'tag...               1',
322
349
    def _check_tag_filter(self, argstr, expected_revnos):
323
350
        #upper bound of laziness
324
351
        out, err = self.run_bzr('tags ' + argstr)
325
 
        self.assertEquals(err, '')
 
352
        self.assertEqual(err, '')
326
353
        self.assertContainsRe(out, "^" + ''.join(["tag %s +%s\n" % (
327
354
            revno, revno) for revno in expected_revnos]) + "$")
328
355
 
380
407
            'tag2                 2\n'
381
408
            'unknown              ?\n')
382
409
        self.assertEqual('', err)
 
410
 
 
411
 
 
412
class TestSmartServerCat(TestCaseWithTransport):
 
413
 
 
414
    def test_set_tag(self):
 
415
        self.setup_smart_server_with_call_log()
 
416
        t = self.make_branch_and_tree('branch')
 
417
        self.build_tree_contents([('branch/foo', 'thecontents')])
 
418
        t.add("foo")
 
419
        t.commit("message")
 
420
        self.reset_smart_call_log()
 
421
        out, err = self.run_bzr(['tag', "-d", self.get_url('branch'), "tagname"])
 
422
        # This figure represent the amount of work to perform this use case. It
 
423
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
424
        # being too low. If rpc_count increases, more network roundtrips have
 
425
        # become necessary for this use case. Please do not adjust this number
 
426
        # upwards without agreement from bzr's network support maintainers.
 
427
        self.assertLength(9, self.hpss_calls)
 
428
        self.assertLength(1, self.hpss_connections)
 
429
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
430
 
 
431
    def test_show_tags(self):
 
432
        self.setup_smart_server_with_call_log()
 
433
        t = self.make_branch_and_tree('branch')
 
434
        self.build_tree_contents([('branch/foo', 'thecontents')])
 
435
        t.add("foo")
 
436
        t.commit("message")
 
437
        t.branch.tags.set_tag("sometag", "rev1")
 
438
        t.branch.tags.set_tag("sometag", "rev2")
 
439
        self.reset_smart_call_log()
 
440
        out, err = self.run_bzr(['tags', "-d", self.get_url('branch')])
 
441
        # This figure represent the amount of work to perform this use case. It
 
442
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
443
        # being too low. If rpc_count increases, more network roundtrips have
 
444
        # become necessary for this use case. Please do not adjust this number
 
445
        # upwards without agreement from bzr's network support maintainers.
 
446
        self.assertLength(6, self.hpss_calls)
 
447
        self.assertLength(1, self.hpss_connections)
 
448
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)