/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: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_missing.py
 
1
# Copyright (C) 2005-2012 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.assertEquals('Using saved parent location: %s\n'
 
215
                          'Branches are up to date.\n' % location,
 
216
                          lines)
 
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)