← 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: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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
    errors,
20
21
    tag,
21
22
    transform,
22
23
    )
27
28
    script,
28
29
    TestCaseWithTransport,
29
30
    )
 
31
from bzrlib.tests.matchers import ContainsNoVfsCalls
30
32
from bzrlib.workingtree import WorkingTree
31
33
 
32
34
 
61
63
        out, err = self.run_bzr('tag -d branch NEWTAG')
62
64
        self.assertContainsRe(err, 'Created tag NEWTAG.')
63
65
        # tag should be observable through the api
64
 
        self.assertEquals(t.branch.tags.get_tag_dict(),
 
66
        self.assertEqual(t.branch.tags.get_tag_dict(),
65
67
                dict(NEWTAG='first-revid'))
66
68
        # can also create tags using -r
67
69
        self.run_bzr('tag -d branch tag2 -r1')
68
 
        self.assertEquals(t.branch.tags.lookup_tag('tag2'), 'first-revid')
 
70
        self.assertEqual(t.branch.tags.lookup_tag('tag2'), 'first-revid')
69
71
        # regression test: make sure a unicode revision from the user
70
72
        # gets turned into a str object properly. The use of a unicode
71
73
        # object for the revid is intentional.
72
74
        self.run_bzr(['tag', '-d', 'branch', 'tag3', u'-rrevid:first-revid'])
73
 
        self.assertEquals(t.branch.tags.lookup_tag('tag3'), 'first-revid')
 
75
        self.assertEqual(t.branch.tags.lookup_tag('tag3'), 'first-revid')
74
76
        # can also delete an existing tag
75
77
        out, err = self.run_bzr('tag --delete -d branch tag2')
76
78
        # cannot replace an existing tag normally
78
80
        self.assertContainsRe(err, 'Tag NEWTAG already exists\\.')
79
81
        # ... but can if you use --force
80
82
        out, err = self.run_bzr('tag -d branch NEWTAG --force -r0')
81
 
        self.assertEquals("Updated tag NEWTAG.\n", err)
 
83
        self.assertEqual("Updated tag NEWTAG.\n", err)
82
84
 
83
85
    def test_tag_same_revision(self):
84
86
        t = self.make_branch_and_tree('branch')
107
109
        # branching copies the tag across
108
110
        self.run_bzr('branch branch1 branch2')
109
111
        b2 = Branch.open('branch2')
110
 
        self.assertEquals(b2.tags.lookup_tag('tag1'), 'first-revid')
 
112
        self.assertEqual(b2.tags.lookup_tag('tag1'), 'first-revid')
111
113
        # make a new tag and pull it
112
114
        b1.tags.set_tag('tag2', 'twa')
113
115
        self.run_bzr('pull -d branch2 branch1')
114
 
        self.assertEquals(b2.tags.lookup_tag('tag2'), 'twa')
 
116
        self.assertEqual(b2.tags.lookup_tag('tag2'), 'twa')
115
117
        # make a new tag and push it
116
118
        b1.tags.set_tag('tag3', 'san')
117
119
        self.run_bzr('push -d branch1 branch2')
118
 
        self.assertEquals(b2.tags.lookup_tag('tag3'), 'san')
 
120
        self.assertEqual(b2.tags.lookup_tag('tag3'), 'san')
119
121
        # make a new tag and merge it
120
122
        t.commit(allow_pointless=True, message='second commit',
121
123
            rev_id='second-revid')
123
125
        t2.commit(allow_pointless=True, message='commit in second')
124
126
        b1.tags.set_tag('tag4', 'second-revid')
125
127
        self.run_bzr('merge -d branch2 branch1')
126
 
        self.assertEquals(b2.tags.lookup_tag('tag4'), 'second-revid')
 
128
        self.assertEqual(b2.tags.lookup_tag('tag4'), 'second-revid')
127
129
        # pushing to a new location copies the tag across
128
130
        self.run_bzr('push -d branch1 branch3')
129
131
        b3 = Branch.open('branch3')
130
 
        self.assertEquals(b3.tags.lookup_tag('tag1'), 'first-revid')
 
132
        self.assertEqual(b3.tags.lookup_tag('tag1'), 'first-revid')
131
133
 
132
134
    def make_master_and_checkout(self):
133
135
        builder = self.make_branch_builder('master')
219
221
        # natural order
220
222
        out, err = self.run_bzr('tags -d branch1',
221
223
                                encoding='utf-8')
222
 
        self.assertEquals(err, '')
 
224
        self.assertEqual(err, '')
223
225
        self.assertContainsRe(out, (u'^tag1\u30d0  *2\ntag2\u30d0  *1\n' +
224
226
            u'tag10\u30d0 *\\?\n').encode('utf-8'))
225
227
 
226
228
        # lexicographical order
227
229
        out, err = self.run_bzr('tags --sort=alpha -d branch1',
228
230
                                encoding='utf-8')
229
 
        self.assertEquals(err, '')
 
231
        self.assertEqual(err, '')
230
232
        self.assertContainsRe(out, (u'^tag10\u30d0  *\\?\ntag1\u30d0  *2\n' +
231
233
            u'tag2\u30d0 *1\n').encode('utf-8'))
232
234
 
233
235
        out, err = self.run_bzr('tags --sort=alpha --show-ids -d branch1',
234
236
                                encoding='utf-8')
235
 
        self.assertEquals(err, '')
 
237
        self.assertEqual(err, '')
236
238
        self.assertContainsRe(out, (u'^tag10\u30d0  *missing\n' +
237
239
            u'tag1\u30d0  *revid-2\ntag2\u30d0 *revid-1\n').encode('utf-8'))
238
240
 
239
241
        # chronological order
240
242
        out, err = self.run_bzr('tags --sort=time -d branch1',
241
243
                encoding='utf-8')
242
 
        self.assertEquals(err, '')
 
244
        self.assertEqual(err, '')
243
245
        self.assertContainsRe(out, (u'^tag2\u30d0  *1\ntag1\u30d0  *2\n' +
244
246
            u'tag10\u30d0 *\\?\n').encode('utf-8'))
245
247
 
246
248
        out, err = self.run_bzr('tags --sort=time --show-ids -d branch1',
247
249
                encoding='utf-8')
248
 
        self.assertEquals(err, '')
 
250
        self.assertEqual(err, '')
249
251
        self.assertContainsRe(out, (u'^tag2\u30d0  *revid-1\n' +
250
252
            u'tag1\u30d0  *revid-2\ntag10\u30d0 *missing\n').encode('utf-8'))
251
253
 
262
264
        tree1.commit('merge', rev_id='revid-4')
263
265
 
264
266
        out, err = self.run_bzr('tags -d branch1', encoding='utf-8')
265
 
        self.assertEquals(err, '')
 
267
        self.assertEqual(err, '')
266
268
        self.assertContainsRe(out, r'tagD  *2\.1\.1\n')
267
269
        out, err = self.run_bzr('tags -d branch2', encoding='utf-8')
268
 
        self.assertEquals(err, '')
 
270
        self.assertEqual(err, '')
269
271
        self.assertContainsRe(out, r'tagD  *3\n')
270
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
 
271
284
    def test_list_tags_revision_filtering(self):
272
285
        tree1 = self.make_branch_and_tree('.')
273
286
        tree1.commit(allow_pointless=True, message='revision 1',
325
338
 
326
339
        # sorted by number of dots
327
340
        out, err = self.run_bzr('tags --sort=dots -d branch1')
328
 
        self.assertEquals(err, '')
329
 
        self.assertEquals([
 
341
        self.assertEqual(err, '')
 
342
        self.assertEqual([
330
343
            'tag.                 1',
331
344
            'tag..                2',
332
345
            'tag...               1',
336
349
    def _check_tag_filter(self, argstr, expected_revnos):
337
350
        #upper bound of laziness
338
351
        out, err = self.run_bzr('tags ' + argstr)
339
 
        self.assertEquals(err, '')
 
352
        self.assertEqual(err, '')
340
353
        self.assertContainsRe(out, "^" + ''.join(["tag %s +%s\n" % (
341
354
            revno, revno) for revno in expected_revnos]) + "$")
342
355
 
394
407
            'tag2                 2\n'
395
408
            'unknown              ?\n')
396
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)