/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

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
 
1
# Copyright (C) 2005, 2008 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Black-box tests for brz missing."""
18
 
 
19
 
from breezy import (
20
 
    osutils,
21
 
    tests,
22
 
    )
23
 
 
24
 
 
25
 
class TestMissing(tests.TestCaseWithTransport):
 
17
"""Black-box tests for bzr missing."""
 
18
 
 
19
import os
 
20
 
 
21
from bzrlib import osutils
 
22
 
 
23
from bzrlib.branch import Branch
 
24
from bzrlib.tests import TestCaseWithTransport
 
25
 
 
26
 
 
27
class TestMissing(TestCaseWithTransport):
26
28
 
27
29
    def assertMessages(self, out, must_have=(), must_not_have=()):
28
30
        """Check if commit messages are in or not in the output"""
38
40
        # XXX: This still needs a test that missing is quiet when there are
39
41
        # missing revisions.
40
42
        a_tree = self.make_branch_and_tree('.')
41
 
        self.build_tree_contents([('a', b'initial\n')])
 
43
        self.build_tree_contents([('a', 'initial\n')])
42
44
        a_tree.add('a')
43
45
        a_tree.commit(message='initial')
44
46
 
47
49
        self.assertEqual('', err)
48
50
 
49
51
    def test_missing(self):
50
 
        missing_one = "You are missing 1 revision:"
51
 
        extra_one = "You have 1 extra revision:"
 
52
        missing = "You are missing 1 revision(s):"
52
53
 
53
54
        # create a source branch
54
55
        a_tree = self.make_branch_and_tree('a')
55
 
        self.build_tree_contents([('a/a', b'initial\n')])
 
56
        self.build_tree_contents([('a/a', 'initial\n')])
56
57
        a_tree.add('a')
57
58
        a_tree.commit(message='initial')
58
59
 
59
60
        # clone and add a differing revision
60
 
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
61
 
        self.build_tree_contents([('b/a', b'initial\nmore\n')])
 
61
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
62
        self.build_tree_contents([('b/a', 'initial\nmore\n')])
62
63
        b_tree.commit(message='more')
63
64
 
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
65
        # run missing in a against b
80
66
        # this should not require missing to take out a write lock on a
81
67
        # or b. So we take a write lock on both to test that at the same
86
72
        a_branch.lock_write()
87
73
        b_branch = b_tree.branch
88
74
        b_branch.lock_write()
89
 
 
90
 
        lines = run_missing_b([])
 
75
        os.chdir('a')
 
76
        out,err = self.run_bzr('missing ../b', retcode=1)
 
77
        lines = out.splitlines()
91
78
        # we're missing the extra revision here
92
 
        self.assertEqual(missing_one, lines[0])
 
79
        self.assertEqual(missing, lines[0])
93
80
        # and we expect 8 lines of output which we trust at the moment to be
94
81
        # good.
95
82
        self.assertEqual(8, len(lines))
 
83
        # we do not expect any error output.
 
84
        self.assertEqual('', err)
96
85
        # unlock the branches for the rest of the test
97
86
        a_branch.unlock()
98
87
        b_branch.unlock()
102
91
        a_tree.commit(message='merge')
103
92
 
104
93
        # 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'])
 
94
        lines = self.run_bzr('missing ../b', retcode=1)[0].splitlines()
 
95
        self.assertEqual("You have 1 extra revision(s):", lines[0])
 
96
        self.assertEqual(8, len(lines))
 
97
        lines2 = self.run_bzr('missing ../b --mine-only', retcode=1)[0]
 
98
        lines2 = lines2.splitlines()
110
99
        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])
 
100
        lines3 = self.run_bzr('missing ../b --theirs-only', retcode=0)[0]
 
101
        self.assertEqualDiff('Other branch is up to date.\n', lines3)
114
102
 
115
103
        # 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'])
 
104
        os.chdir('../b')
 
105
        lines = self.run_bzr('missing ../a', retcode=1)[0].splitlines()
 
106
        self.assertEqual(missing, lines[0])
 
107
        self.assertEqual(8, len(lines))
 
108
        lines2 = self.run_bzr('missing ../a --theirs-only', retcode=1)[0]
 
109
        lines2 = lines2.splitlines()
121
110
        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'])
 
111
        lines3 = self.run_bzr('missing ../a --mine-only', retcode=0)[0]
 
112
        self.assertEqualDiff('This branch is up to date.\n', lines3)
 
113
        lines4 = self.run_bzr('missing ../a --short', retcode=1)[0]
 
114
        lines4 = lines4.splitlines()
 
115
        self.assertEqual(4, len(lines4))
 
116
        lines5 = self.run_bzr('missing ../a --line', retcode=1)[0]
 
117
        lines5 = lines5.splitlines()
 
118
        self.assertEqual(2, len(lines5))
 
119
        lines6 = self.run_bzr('missing ../a --reverse', retcode=1)[0]
 
120
        lines6 = lines6.splitlines()
136
121
        self.assertEqual(lines6, lines)
137
 
 
138
 
        lines7 = run_missing_a(['--show-ids'])
139
 
        self.assertLength(11, lines7)
140
 
 
141
 
        lines8 = run_missing_a(['--verbose'])
 
122
        lines7 = self.run_bzr('missing ../a --show-ids', retcode=1)[0]
 
123
        lines7 = lines7.splitlines()
 
124
        self.assertEqual(11, len(lines7))
 
125
        lines8 = self.run_bzr('missing ../a --verbose', retcode=1)[0]
 
126
        lines8 = lines8.splitlines()
142
127
        self.assertEqual("modified:", lines8[-2])
143
128
        self.assertEqual("  a", lines8[-1])
144
129
 
145
 
        self.assertEqualDiff('Other branch has no new revisions.',
146
 
                             run_missing_b(['--theirs-only'], retcode=0)[0])
 
130
        os.chdir('../a')
 
131
        self.assertEqualDiff('Other branch is up to date.\n',
 
132
                             self.run_bzr('missing ../b --theirs-only')[0])
147
133
 
148
134
        # after a pull we're back on track
149
135
        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])
 
136
        self.assertEqualDiff("Branches are up to date.\n",
 
137
                             self.run_bzr('missing ../b')[0])
 
138
        os.chdir('../b')
 
139
        self.assertEqualDiff('Branches are up to date.\n',
 
140
                             self.run_bzr('missing ../a')[0])
154
141
        # 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])
 
142
        self.assertEqualDiff('This branch is up to date.\n',
 
143
                             self.run_bzr('missing ../a --mine-only')[0])
 
144
        self.assertEqualDiff('Other branch is up to date.\n',
 
145
                             self.run_bzr('missing ../a --theirs-only')[0])
159
146
 
160
147
    def test_missing_filtered(self):
161
148
        # create a source branch
162
149
        a_tree = self.make_branch_and_tree('a')
163
 
        self.build_tree_contents([('a/a', b'initial\n')])
 
150
        self.build_tree_contents([('a/a', 'initial\n')])
164
151
        a_tree.add('a')
165
152
        a_tree.commit(message='r1')
166
153
        # clone and add differing revisions
167
 
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
 
154
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
168
155
 
169
156
        for i in range(2, 6):
170
157
            a_tree.commit(message='a%d' % i)
171
158
            b_tree.commit(message='b%d' % i)
172
159
 
 
160
        os.chdir('a')
173
161
        # local
174
 
        out, err = self.run_bzr('missing ../b --my-revision 3',
175
 
                                retcode=1, working_dir='a')
 
162
        out,err = self.run_bzr('missing ../b --my-revision 3', retcode=1)
176
163
        self.assertMessages(out, ('a3', 'b2', 'b3', 'b4', 'b5'), ('a2', 'a4'))
177
164
 
178
 
        out, err = self.run_bzr('missing ../b --my-revision 3..4',
179
 
                                retcode=1, working_dir='a')
 
165
        out,err = self.run_bzr('missing ../b --my-revision 3..4', retcode=1)
180
166
        self.assertMessages(out, ('a3', 'a4'), ('a2', 'a5'))
181
167
 
182
 
        # remote
183
 
        out, err = self.run_bzr('missing ../b -r 3',
184
 
                                retcode=1, working_dir='a')
 
168
        #remote
 
169
        out,err = self.run_bzr('missing ../b -r 3', retcode=1)
185
170
        self.assertMessages(out, ('a2', 'a3', 'a4', 'a5', 'b3'), ('b2', 'b4'))
186
171
 
187
 
        out, err = self.run_bzr('missing ../b -r 3..4',
188
 
                                retcode=1, working_dir='a')
 
172
        out,err = self.run_bzr('missing ../b -r 3..4', retcode=1)
189
173
        self.assertMessages(out, ('b3', 'b4'), ('b2', 'b5'))
190
174
 
191
 
        # both
192
 
        out, err = self.run_bzr('missing ../b --my-revision 3..4 -r 3..4',
193
 
                                retcode=1, working_dir='a')
 
175
        #both
 
176
        out,err = self.run_bzr('missing ../b --my-revision 3..4 -r 3..4',
 
177
            retcode=1)
194
178
        self.assertMessages(out, ('a3', 'a4', 'b3', 'b4'),
195
 
                            ('a2', 'a5', 'b2', 'b5'))
 
179
            ('a2', 'a5', 'b2', 'b5'))
196
180
 
197
181
    def test_missing_check_last_location(self):
198
182
        # check that last location shown as filepath not file URL
204
188
        wt.add('foo')
205
189
        wt.commit('initial')
206
190
 
207
 
        location = osutils.getcwd() + '/a/'
 
191
        os.chdir('a')
 
192
        location = osutils.getcwd() + '/'
208
193
 
209
194
        # clone
210
 
        b.controldir.sprout('b')
 
195
        b.bzrdir.sprout('../b')
211
196
 
212
197
        # 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', b'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.controldir.sprout('b').open_workingtree()
230
 
        self.build_tree_contents([('b/a', b'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', b'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.controldir.sprout('b').open_workingtree()
249
 
        self.build_tree_contents([('b/a', b'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')
 
198
        lines, err = self.run_bzr('missing', working_dir='../b')
 
199
        self.assertEquals('Using saved parent location: %s\n'
 
200
                          'Branches are up to date.\n' % location,
 
201
                          lines)
 
202
        self.assertEquals('', err)