← 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-2012, 2016 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Black-box tests for bzr missing."""
 
18
 
 
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)
 
48
 
 
49
    def test_missing(self):
 
50
        missing_one = "You are missing 1 revision:"
 
51
        extra_one = "You have 1 extra revision:"
 
52
 
 
53
        # create a source branch
 
54
        a_tree = self.make_branch_and_tree('a')
 
55
        self.build_tree_contents([('a/a', 'initial\n')])
 
56
        a_tree.add('a')
 
57
        a_tree.commit(message='initial')
 
58
 
 
59
        # clone and add a differing revision
 
60
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
61
        self.build_tree_contents([('b/a', 'initial\nmore\n')])
 
62
        b_tree.commit(message='more')
 
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
 
 
79
        # run missing in a against b
 
80
        # this should not require missing to take out a write lock on a
 
81
        # or b. So we take a write lock on both to test that at the same
 
82
        # time. This may let the test pass while the default branch is an
 
83
        # os-locking branch, but it will trigger failures with lockdir based
 
84
        # branches.
 
85
        a_branch = a_tree.branch
 
86
        a_branch.lock_write()
 
87
        b_branch = b_tree.branch
 
88
        b_branch.lock_write()
 
89
 
 
90
        lines = run_missing_b([])
 
91
        # we're missing the extra revision here
 
92
        self.assertEqual(missing_one, lines[0])
 
93
        # and we expect 8 lines of output which we trust at the moment to be
 
94
        # good.
 
95
        self.assertEqual(8, len(lines))
 
96
        # unlock the branches for the rest of the test
 
97
        a_branch.unlock()
 
98
        b_branch.unlock()
 
99
 
 
100
        # get extra revision from b
 
101
        a_tree.merge_from_branch(b_branch)
 
102
        a_tree.commit(message='merge')
 
103
 
 
104
        # compare again, but now we have the 'merge' commit extra
 
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'])
 
136
        self.assertEqual(lines6, lines)
 
137
 
 
138
        lines7 = run_missing_a(['--show-ids'])
 
139
        self.assertLength(11, lines7)
 
140
 
 
141
        lines8 =  run_missing_a(['--verbose'])
 
142
        self.assertEqual("modified:", lines8[-2])
 
143
        self.assertEqual("  a", lines8[-1])
 
144
 
 
145
        self.assertEqualDiff('Other branch has no new revisions.',
 
146
                             run_missing_b(['--theirs-only'], retcode=0)[0])
 
147
 
 
148
        # after a pull we're back on track
 
149
        b_tree.pull(a_branch)
 
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'))
 
196
 
 
197
    def test_missing_check_last_location(self):
 
198
        # check that last location shown as filepath not file URL
 
199
 
 
200
        # create a source branch
 
201
        wt = self.make_branch_and_tree('a')
 
202
        b = wt.branch
 
203
        self.build_tree(['a/foo'])
 
204
        wt.add('foo')
 
205
        wt.commit('initial')
 
206
 
 
207
        location = osutils.getcwd() + '/a/'
 
208
 
 
209
        # clone
 
210
        b.bzrdir.sprout('b')
 
211
 
 
212
        # check last location
 
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')