← 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

Merge bzr.dev and tree-file-ids-as-tuples.

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 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=0)[0]
81
 
        self.assertEqualDiff('Other branch is up to date.\n', lines3)
82
 
 
83
 
        # relative to a, missing the 'merge' commit 
84
 
        os.chdir('../b')
85
 
        lines = self.run_bzr('missing ../a', retcode=1)[0].splitlines()
86
 
        self.assertEqual(missing, lines[0])
87
 
        self.assertEqual(8, len(lines))
88
 
        lines2 = self.run_bzr('missing ../a --theirs-only', retcode=1)[0]
89
 
        lines2 = lines2.splitlines()
90
 
        self.assertEqual(lines, lines2)
91
 
        lines3 = self.run_bzr('missing ../a --mine-only', retcode=0)[0]
92
 
        self.assertEqualDiff('This branch is up to date.\n', lines3)
93
 
        lines4 = self.run_bzr('missing ../a --short', retcode=1)[0]
94
 
        lines4 = lines4.splitlines()
95
 
        self.assertEqual(4, len(lines4))
96
 
        lines5 = self.run_bzr('missing ../a --line', retcode=1)[0]
97
 
        lines5 = lines5.splitlines()
98
 
        self.assertEqual(2, len(lines5))
99
 
        lines6 = self.run_bzr('missing ../a --reverse', retcode=1)[0]
100
 
        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'])
101
136
        self.assertEqual(lines6, lines)
102
 
        lines7 = self.run_bzr('missing ../a --show-ids', retcode=1)[0]
103
 
        lines7 = lines7.splitlines()
104
 
        self.assertEqual(11, len(lines7))
105
 
        lines8 = self.run_bzr('missing ../a --verbose', retcode=1)[0]
106
 
        lines8 = lines8.splitlines()
 
137
 
 
138
        lines7 = run_missing_a(['--show-ids'])
 
139
        self.assertLength(11, lines7)
 
140
 
 
141
        lines8 =  run_missing_a(['--verbose'])
107
142
        self.assertEqual("modified:", lines8[-2])
108
143
        self.assertEqual("  a", lines8[-1])
109
144
 
110
 
        os.chdir('../a')
111
 
        self.assertEqualDiff('Other branch is up to date.\n',
112
 
                             self.run_bzr('missing ../b --theirs-only')[0])
 
145
        self.assertEqualDiff('Other branch has no new revisions.',
 
146
                             run_missing_b(['--theirs-only'], retcode=0)[0])
113
147
 
114
148
        # after a pull we're back on track
115
149
        b_tree.pull(a_branch)
116
 
        self.assertEqualDiff("Branches are up to date.\n",
117
 
                             self.run_bzr('missing ../b')[0])
118
 
        os.chdir('../b')
119
 
        self.assertEqualDiff('Branches are up to date.\n',
120
 
                             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])
121
154
        # If you supply mine or theirs you only know one side is up to date
122
 
        self.assertEqualDiff('This branch is up to date.\n',
123
 
                             self.run_bzr('missing ../a --mine-only')[0])
124
 
        self.assertEqualDiff('Other branch is up to date.\n',
125
 
                             self.run_bzr('missing ../a --theirs-only')[0])
 
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'))
126
196
 
127
197
    def test_missing_check_last_location(self):
128
198
        # check that last location shown as filepath not file URL
134
204
        wt.add('foo')
135
205
        wt.commit('initial')
136
206
 
137
 
        os.chdir('a')
138
 
        location = osutils.getcwd() + '/'
 
207
        location = osutils.getcwd() + '/a/'
139
208
 
140
209
        # clone
141
 
        b.bzrdir.sprout('../b')
 
210
        b.bzrdir.sprout('b')
142
211
 
143
212
        # check last location
144
 
        lines, err = self.run_bzr('missing', working_dir='../b')
 
213
        lines, err = self.run_bzr('missing', working_dir='b')
145
214
        self.assertEquals('Using saved parent location: %s\n'
146
215
                          'Branches are up to date.\n' % location,
147
216
                          lines)
148
217
        self.assertEquals('', 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)