← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_missing.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
# -*- coding: utf-8 -*-
3
 
# vim: encoding=utf-8
 
1
# Copyright (C) 2005-2012, 2016 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""Black-box tests for bzr missing."""
20
18
 
21
 
import os
22
 
 
23
 
from bzrlib import osutils
24
 
 
25
 
from bzrlib.branch import Branch
26
 
from bzrlib.tests import TestCaseWithTransport
27
 
 
28
 
 
29
 
class TestMissing(TestCaseWithTransport):
 
19
from bzrlib import (
 
20
    osutils,
 
21
    tests,
 
22
    )
 
23
 
 
24
 
 
25
class TestMissing(tests.TestCaseWithTransport):
 
26
 
 
27
    def assertMessages(self, out, must_have=(), must_not_have=()):
 
28
        """Check if commit messages are in or not in the output"""
 
29
        for m in must_have:
 
30
            self.assertContainsRe(out, r'\nmessage:\n  %s\n' % m)
 
31
        for m in must_not_have:
 
32
            self.assertNotContainsRe(out, r'\nmessage:\n  %s\n' % m)
 
33
 
 
34
    def test_missing_quiet(self):
 
35
        # <https://bugs.launchpad.net/bzr/+bug/284748>
 
36
        # create a source branch
 
37
        #
 
38
        # XXX: This still needs a test that missing is quiet when there are
 
39
        # missing revisions.
 
40
        a_tree = self.make_branch_and_tree('.')
 
41
        self.build_tree_contents([('a', 'initial\n')])
 
42
        a_tree.add('a')
 
43
        a_tree.commit(message='initial')
 
44
 
 
45
        out, err = self.run_bzr('missing -q .')
 
46
        self.assertEqual('', out)
 
47
        self.assertEqual('', err)
30
48
 
31
49
    def test_missing(self):
32
 
        missing = "You are missing 1 revision(s):"
 
50
        missing_one = "You are missing 1 revision:"
 
51
        extra_one = "You have 1 extra revision:"
33
52
 
34
53
        # create a source branch
35
54
        a_tree = self.make_branch_and_tree('a')
42
61
        self.build_tree_contents([('b/a', 'initial\nmore\n')])
43
62
        b_tree.commit(message='more')
44
63
 
 
64
        def run_missing(args, retcode=1, working_dir=None):
 
65
            out, err = self.run_bzr(['missing'] + args,
 
66
                                    retcode=retcode, working_dir=working_dir)
 
67
            # we do not expect any error output.
 
68
            self.assertEqual('', err)
 
69
            return out.splitlines()
 
70
 
 
71
        def run_missing_a(args, retcode=1):
 
72
            return run_missing(['../a'] + args,
 
73
                               retcode=retcode, working_dir='b')
 
74
 
 
75
        def run_missing_b(args, retcode=1):
 
76
            return run_missing(['../b'] + args,
 
77
                               retcode=retcode, working_dir='a')
 
78
 
45
79
        # run missing in a against b
46
 
        # this should not require missing to take out a write lock on a 
 
80
        # this should not require missing to take out a write lock on a
47
81
        # or b. So we take a write lock on both to test that at the same
48
82
        # time. This may let the test pass while the default branch is an
49
83
        # os-locking branch, but it will trigger failures with lockdir based
52
86
        a_branch.lock_write()
53
87
        b_branch = b_tree.branch
54
88
        b_branch.lock_write()
55
 
        os.chdir('a')
56
 
        out,err = self.run_bzr('missing ../b', retcode=1)
57
 
        lines = out.splitlines()
 
89
 
 
90
        lines = run_missing_b([])
58
91
        # we're missing the extra revision here
59
 
        self.assertEqual(missing, lines[0])
 
92
        self.assertEqual(missing_one, lines[0])
60
93
        # and we expect 8 lines of output which we trust at the moment to be
61
94
        # good.
62
95
        self.assertEqual(8, len(lines))
63
 
        # we do not expect any error output.
64
 
        self.assertEqual('', err)
65
96
        # unlock the branches for the rest of the test
66
97
        a_branch.unlock()
67
98
        b_branch.unlock()
71
102
        a_tree.commit(message='merge')
72
103
 
73
104
        # compare again, but now we have the 'merge' commit extra
74
 
        lines = self.run_bzr('missing ../b', retcode=1)[0].splitlines()
75
 
        self.assertEqual("You have 1 extra revision(s):", lines[0])
76
 
        self.assertEqual(8, len(lines))
77
 
        lines2 = self.run_bzr('missing ../b --mine-only', retcode=1)[0]
78
 
        lines2 = lines2.splitlines()
79
 
        self.assertEqual(lines, lines2)
80
 
        lines3 = self.run_bzr('missing ../b --theirs-only', retcode=1)[0]
81
 
        lines3 = lines3.splitlines()
82
 
        self.assertEqual(0, len(lines3))
83
 
 
84
 
        # relative to a, missing the 'merge' commit 
85
 
        os.chdir('../b')
86
 
        lines = self.run_bzr('missing ../a', retcode=1)[0].splitlines()
87
 
        self.assertEqual(missing, lines[0])
88
 
        self.assertEqual(8, len(lines))
89
 
        lines2 = self.run_bzr('missing ../a --theirs-only', retcode=1)[0]
90
 
        lines2 = lines2.splitlines()
91
 
        self.assertEqual(lines, lines2)
92
 
        lines3 = self.run_bzr('missing ../a --mine-only', retcode=1)[0]
93
 
        lines3 = lines3.splitlines()
94
 
        self.assertEqual(0, len(lines3))
95
 
        lines4 = self.run_bzr('missing ../a --short', retcode=1)[0]
96
 
        lines4 = lines4.splitlines()
97
 
        self.assertEqual(4, len(lines4))
98
 
        lines5 = self.run_bzr('missing ../a --line', retcode=1)[0]
99
 
        lines5 = lines5.splitlines()
100
 
        self.assertEqual(2, len(lines5))
101
 
        lines6 = self.run_bzr('missing ../a --reverse', retcode=1)[0]
102
 
        lines6 = lines6.splitlines()
 
105
        lines = run_missing_b([])
 
106
        self.assertEqual(extra_one, lines[0])
 
107
        self.assertLength(8, lines)
 
108
 
 
109
        lines2 = run_missing_b(['--mine-only'])
 
110
        self.assertEqual(lines, lines2)
 
111
 
 
112
        lines3 = run_missing_b(['--theirs-only'], retcode=0)
 
113
        self.assertEqualDiff('Other branch has no new revisions.', lines3[0])
 
114
 
 
115
        # relative to a, missing the 'merge' commit
 
116
        lines = run_missing_a([])
 
117
        self.assertEqual(missing_one, lines[0])
 
118
        self.assertLength(8, lines)
 
119
 
 
120
        lines2 = run_missing_a(['--theirs-only'])
 
121
        self.assertEqual(lines, lines2)
 
122
 
 
123
        lines3 = run_missing_a(['--mine-only'], retcode=0)
 
124
        self.assertEqualDiff('This branch has no new revisions.', lines3[0])
 
125
 
 
126
        lines4 = run_missing_a(['--short'])
 
127
        self.assertLength(4, lines4)
 
128
 
 
129
        lines4a = run_missing_a(['-S'])
 
130
        self.assertEqual(lines4, lines4a)
 
131
 
 
132
        lines5 = run_missing_a(['--line'])
 
133
        self.assertLength(2, lines5)
 
134
 
 
135
        lines6 = run_missing_a(['--reverse'])
103
136
        self.assertEqual(lines6, lines)
104
 
        lines7 = self.run_bzr('missing ../a --show-ids', retcode=1)[0]
105
 
        lines7 = lines7.splitlines()
106
 
        self.assertEqual(11, len(lines7))
107
 
        lines8 = self.run_bzr('missing ../a --verbose', retcode=1)[0]
108
 
        lines8 = lines8.splitlines()
 
137
 
 
138
        lines7 = run_missing_a(['--show-ids'])
 
139
        self.assertLength(11, lines7)
 
140
 
 
141
        lines8 =  run_missing_a(['--verbose'])
109
142
        self.assertEqual("modified:", lines8[-2])
110
143
        self.assertEqual("  a", lines8[-1])
111
144
 
 
145
        self.assertEqualDiff('Other branch has no new revisions.',
 
146
                             run_missing_b(['--theirs-only'], retcode=0)[0])
 
147
 
112
148
        # after a pull we're back on track
113
149
        b_tree.pull(a_branch)
114
 
        self.assertEqual("Branches are up to date.\n", self.run_bzr('missing ../a')[0])
 
150
        self.assertEqualDiff("Branches are up to date.",
 
151
                             run_missing_b([], retcode=0)[0])
 
152
        self.assertEqualDiff('Branches are up to date.',
 
153
                             run_missing_a([], retcode=0)[0])
 
154
        # If you supply mine or theirs you only know one side is up to date
 
155
        self.assertEqualDiff('This branch has no new revisions.',
 
156
                             run_missing_a(['--mine-only'], retcode=0)[0])
 
157
        self.assertEqualDiff('Other branch has no new revisions.',
 
158
                              run_missing_a(['--theirs-only'], retcode=0)[0])
 
159
 
 
160
    def test_missing_filtered(self):
 
161
        # create a source branch
 
162
        a_tree = self.make_branch_and_tree('a')
 
163
        self.build_tree_contents([('a/a', 'initial\n')])
 
164
        a_tree.add('a')
 
165
        a_tree.commit(message='r1')
 
166
        # clone and add differing revisions
 
167
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
168
 
 
169
        for i in range(2, 6):
 
170
            a_tree.commit(message='a%d' % i)
 
171
            b_tree.commit(message='b%d' % i)
 
172
 
 
173
        # local
 
174
        out,err = self.run_bzr('missing ../b --my-revision 3',
 
175
                               retcode=1, working_dir='a')
 
176
        self.assertMessages(out, ('a3', 'b2', 'b3', 'b4', 'b5'), ('a2', 'a4'))
 
177
 
 
178
        out,err = self.run_bzr('missing ../b --my-revision 3..4',
 
179
                               retcode=1, working_dir='a')
 
180
        self.assertMessages(out, ('a3', 'a4'), ('a2', 'a5'))
 
181
 
 
182
        #remote
 
183
        out,err = self.run_bzr('missing ../b -r 3',
 
184
                               retcode=1, working_dir='a')
 
185
        self.assertMessages(out, ('a2', 'a3', 'a4', 'a5', 'b3'), ('b2', 'b4'))
 
186
 
 
187
        out,err = self.run_bzr('missing ../b -r 3..4',
 
188
                               retcode=1, working_dir='a')
 
189
        self.assertMessages(out, ('b3', 'b4'), ('b2', 'b5'))
 
190
 
 
191
        #both
 
192
        out,err = self.run_bzr('missing ../b --my-revision 3..4 -r 3..4',
 
193
                               retcode=1, working_dir='a')
 
194
        self.assertMessages(out, ('a3', 'a4', 'b3', 'b4'),
 
195
            ('a2', 'a5', 'b2', 'b5'))
115
196
 
116
197
    def test_missing_check_last_location(self):
117
198
        # check that last location shown as filepath not file URL
123
204
        wt.add('foo')
124
205
        wt.commit('initial')
125
206
 
126
 
        os.chdir('a')
127
 
        location = osutils.getcwd() + '/'
 
207
        location = osutils.getcwd() + '/a/'
128
208
 
129
209
        # clone
130
 
        b.bzrdir.sprout('../b')
 
210
        b.bzrdir.sprout('b')
131
211
 
132
212
        # check last location
133
 
        lines, err = self.run_bzr('missing', working_dir='../b')
134
 
        self.assertEquals('Using last location: %s\n'
135
 
                          'Branches are up to date.\n' % location,
136
 
                          lines)
137
 
        self.assertEquals('', err)
 
213
        lines, err = self.run_bzr('missing', working_dir='b')
 
214
        self.assertEqual('Using saved parent location: %s\n'
 
215
                         'Branches are up to date.\n' % location,
 
216
                         lines)
 
217
        self.assertEqual('', err)
 
218
 
 
219
    def test_missing_directory(self):
 
220
        """Test --directory option"""
 
221
 
 
222
        # create a source branch
 
223
        a_tree = self.make_branch_and_tree('a')
 
224
        self.build_tree_contents([('a/a', 'initial\n')])
 
225
        a_tree.add('a')
 
226
        a_tree.commit(message='initial')
 
227
 
 
228
        # clone and add a differing revision
 
229
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
230
        self.build_tree_contents([('b/a', 'initial\nmore\n')])
 
231
        b_tree.commit(message='more')
 
232
 
 
233
        out2, err2 = self.run_bzr('missing --directory a b', retcode=1)
 
234
        out1, err1 = self.run_bzr('missing ../b', retcode=1, working_dir='a')
 
235
        self.assertEqualDiff(out1, out2)
 
236
        self.assertEqualDiff(err1, err2)
 
237
 
 
238
    def test_missing_tags(self):
 
239
        """Test showing tags"""
 
240
 
 
241
        # create a source branch
 
242
        a_tree = self.make_branch_and_tree('a')
 
243
        self.build_tree_contents([('a/a', 'initial\n')])
 
244
        a_tree.add('a')
 
245
        a_tree.commit(message='initial')
 
246
 
 
247
        # clone and add a differing revision
 
248
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
249
        self.build_tree_contents([('b/a', 'initial\nmore\n')])
 
250
        b_tree.commit(message='more')
 
251
        b_tree.branch.tags.set_tag('a-tag', b_tree.last_revision())
 
252
 
 
253
        for log_format in ['long', 'short', 'line']:
 
254
            out, err = self.run_bzr(
 
255
                'missing --log-format={0} ../a'.format(log_format),
 
256
                working_dir='b', retcode=1)
 
257
            self.assertContainsString(out, 'a-tag')
 
258
 
 
259
            out, err = self.run_bzr(
 
260
                'missing --log-format={0} ../b'.format(log_format),
 
261
                working_dir='a', retcode=1)
 
262
            self.assertContainsString(out, 'a-tag')