/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 breezy/tests/blackbox/test_uncommit.py

  • Committer: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_uncommit.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011, 2013, 2016 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
18
18
 
19
19
import os
20
20
 
21
 
from bzrlib import uncommit
22
 
from bzrlib.bzrdir import BzrDirMetaFormat1
23
 
from bzrlib.errors import BoundBranchOutOfDate
24
 
from bzrlib.tests import TestCaseWithTransport
25
 
from bzrlib.tests.matchers import ContainsNoVfsCalls
26
 
from bzrlib.tests.script import (
 
21
from breezy import uncommit
 
22
from breezy.bzr.bzrdir import BzrDirMetaFormat1
 
23
from breezy.errors import BoundBranchOutOfDate
 
24
from breezy.tests import TestCaseWithTransport
 
25
from breezy.tests.script import (
27
26
    run_script,
28
27
    ScriptRunner,
29
28
    )
35
34
        wt = self.make_branch_and_tree('tree')
36
35
        self.build_tree(['tree/a', 'tree/b', 'tree/c'])
37
36
        wt.add(['a', 'b', 'c'])
38
 
        wt.commit('initial commit', rev_id='a1')
 
37
        wt.commit('initial commit', rev_id=b'a1')
39
38
 
40
 
        self.build_tree_contents([('tree/a', 'new contents of a\n')])
41
 
        wt.commit('second commit', rev_id='a2')
 
39
        self.build_tree_contents([('tree/a', b'new contents of a\n')])
 
40
        wt.commit('second commit', rev_id=b'a2')
42
41
 
43
42
        return wt
44
43
 
53
52
        self.assertContainsRe(out, 'second commit')
54
53
 
55
54
        # Nothing has changed
56
 
        self.assertEqual(['a2'], wt.get_parent_ids())
 
55
        self.assertEqual([b'a2'], wt.get_parent_ids())
57
56
 
58
57
        # Uncommit, don't prompt
59
58
        out, err = self.run_bzr('uncommit --force')
61
60
        self.assertContainsRe(out, 'second commit')
62
61
 
63
62
        # This should look like we are back in revno 1
64
 
        self.assertEqual(['a1'], wt.get_parent_ids())
 
63
        self.assertEqual([b'a1'], wt.get_parent_ids())
65
64
        out, err = self.run_bzr('status')
66
 
        self.assertEquals(out, 'modified:\n  a\n')
 
65
        self.assertEqual(out, 'modified:\n  a\n')
67
66
 
68
67
    def test_uncommit_interactive(self):
69
68
        """Uncommit seeks confirmation, and doesn't proceed without it."""
70
69
        wt = self.create_simple_tree()
71
70
        os.chdir('tree')
72
 
        run_script(self, """    
73
 
        $ bzr uncommit
 
71
        run_script(self, """
 
72
        $ brz uncommit
74
73
        ...
75
74
        The above revision(s) will be removed.
76
75
        2>Uncommit these revisions? ([y]es, [n]o): no
77
76
        <n
78
77
        Canceled
79
78
        """)
80
 
        self.assertEqual(['a2'], wt.get_parent_ids())
 
79
        self.assertEqual([b'a2'], wt.get_parent_ids())
81
80
 
82
81
    def test_uncommit_no_history(self):
83
82
        wt = self.make_branch_and_tree('tree')
89
88
        wt = self.create_simple_tree()
90
89
        checkout_tree = wt.branch.create_checkout('checkout')
91
90
 
92
 
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
 
91
        self.assertEqual([b'a2'], checkout_tree.get_parent_ids())
93
92
 
94
93
        os.chdir('checkout')
95
94
        out, err = self.run_bzr('uncommit --dry-run --force')
97
96
        self.assertNotContainsRe(out, 'initial commit')
98
97
        self.assertContainsRe(out, 'second commit')
99
98
 
100
 
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
 
99
        self.assertEqual([b'a2'], checkout_tree.get_parent_ids())
101
100
 
102
101
        out, err = self.run_bzr('uncommit --force')
103
102
        self.assertNotContainsRe(out, 'initial commit')
105
104
 
106
105
        # uncommit in a checkout should uncommit the parent branch
107
106
        # (but doesn't effect the other working tree)
108
 
        self.assertEquals(['a1'], checkout_tree.get_parent_ids())
109
 
        self.assertEquals('a1', wt.branch.last_revision())
110
 
        self.assertEquals(['a2'], wt.get_parent_ids())
 
107
        self.assertEqual([b'a1'], checkout_tree.get_parent_ids())
 
108
        self.assertEqual(b'a1', wt.branch.last_revision())
 
109
        self.assertEqual([b'a2'], wt.get_parent_ids())
111
110
 
112
111
    def test_uncommit_bound(self):
113
112
        os.mkdir('a')
149
148
 
150
149
        self.assertNotContainsRe(out, 'initial commit')
151
150
        self.assertContainsRe(out, 'second commit')
152
 
        self.assertEqual(['a1'], wt.get_parent_ids())
153
 
        self.assertEqual('a1', wt.branch.last_revision())
 
151
        self.assertEqual([b'a1'], wt.get_parent_ids())
 
152
        self.assertEqual(b'a1', wt.branch.last_revision())
154
153
 
155
154
    def test_uncommit_neg_1(self):
156
155
        wt = self.create_simple_tree()
161
160
    def test_uncommit_merges(self):
162
161
        wt = self.create_simple_tree()
163
162
 
164
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
163
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
165
164
 
166
 
        tree2.commit('unchanged', rev_id='b3')
167
 
        tree2.commit('unchanged', rev_id='b4')
 
165
        tree2.commit('unchanged', rev_id=b'b3')
 
166
        tree2.commit('unchanged', rev_id=b'b4')
168
167
 
169
168
        wt.merge_from_branch(tree2.branch)
170
 
        wt.commit('merge b4', rev_id='a3')
 
169
        wt.commit('merge b4', rev_id=b'a3')
171
170
 
172
 
        self.assertEqual(['a3'], wt.get_parent_ids())
 
171
        self.assertEqual([b'a3'], wt.get_parent_ids())
173
172
 
174
173
        os.chdir('tree')
175
174
        out, err = self.run_bzr('uncommit --force')
176
175
 
177
 
        self.assertEqual(['a2', 'b4'], wt.get_parent_ids())
 
176
        self.assertEqual([b'a2', b'b4'], wt.get_parent_ids())
178
177
 
179
178
    def test_uncommit_pending_merge(self):
180
179
        wt = self.create_simple_tree()
181
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
182
 
        tree2.commit('unchanged', rev_id='b3')
 
180
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
181
        tree2.commit('unchanged', rev_id=b'b3')
183
182
 
184
183
        wt.branch.fetch(tree2.branch)
185
 
        wt.set_pending_merges(['b3'])
 
184
        wt.set_pending_merges([b'b3'])
186
185
 
187
186
        os.chdir('tree')
188
187
        out, err = self.run_bzr('uncommit --force')
189
 
        self.assertEqual(['a1', 'b3'], wt.get_parent_ids())
 
188
        self.assertEqual([b'a1', b'b3'], wt.get_parent_ids())
190
189
 
191
190
    def test_uncommit_multiple_merge(self):
192
191
        wt = self.create_simple_tree()
193
192
 
194
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
195
 
        tree2.commit('unchanged', rev_id='b3')
 
193
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
194
        tree2.commit('unchanged', rev_id=b'b3')
196
195
 
197
 
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
198
 
        tree3.commit('unchanged', rev_id='c3')
 
196
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
 
197
        tree3.commit('unchanged', rev_id=b'c3')
199
198
 
200
199
        wt.merge_from_branch(tree2.branch)
201
 
        wt.commit('merge b3', rev_id='a3')
 
200
        wt.commit('merge b3', rev_id=b'a3')
202
201
 
203
202
        wt.merge_from_branch(tree3.branch)
204
 
        wt.commit('merge c3', rev_id='a4')
 
203
        wt.commit('merge c3', rev_id=b'a4')
205
204
 
206
 
        self.assertEqual(['a4'], wt.get_parent_ids())
 
205
        self.assertEqual([b'a4'], wt.get_parent_ids())
207
206
 
208
207
        os.chdir('tree')
209
208
        out, err = self.run_bzr('uncommit --force -r 2')
210
209
 
211
 
        self.assertEqual(['a2', 'b3', 'c3'], wt.get_parent_ids())
 
210
        self.assertEqual([b'a2', b'b3', b'c3'], wt.get_parent_ids())
212
211
 
213
212
    def test_uncommit_merge_plus_pending(self):
214
213
        wt = self.create_simple_tree()
215
214
 
216
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
217
 
        tree2.commit('unchanged', rev_id='b3')
218
 
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
219
 
        tree3.commit('unchanged', rev_id='c3')
 
215
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
216
        tree2.commit('unchanged', rev_id=b'b3')
 
217
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
 
218
        tree3.commit('unchanged', rev_id=b'c3')
220
219
 
221
220
        wt.branch.fetch(tree2.branch)
222
 
        wt.set_pending_merges(['b3'])
223
 
        wt.commit('merge b3', rev_id='a3')
224
 
 
 
221
        wt.set_pending_merges([b'b3'])
 
222
        wt.commit('merge b3', rev_id=b'a3')
225
223
 
226
224
        wt.merge_from_branch(tree3.branch)
227
225
 
228
 
        self.assertEqual(['a3', 'c3'], wt.get_parent_ids())
 
226
        self.assertEqual([b'a3', b'c3'], wt.get_parent_ids())
229
227
 
230
228
        os.chdir('tree')
231
229
        out, err = self.run_bzr('uncommit --force -r 2')
232
230
 
233
 
        self.assertEqual(['a2', 'b3', 'c3'], wt.get_parent_ids())
 
231
        self.assertEqual([b'a2', b'b3', b'c3'], wt.get_parent_ids())
234
232
 
235
233
    def test_uncommit_shows_log_with_revision_id(self):
236
234
        wt = self.create_simple_tree()
238
236
        script = ScriptRunner()
239
237
        script.run_script(self, """
240
238
$ cd tree
241
 
$ bzr uncommit --force 
242
 
    2 ...
243
 
      second commit
244
 
...
245
 
The above revision(s) will be removed.
246
 
You can restore the old tip by running:
247
 
  bzr pull . -r revid:a2
 
239
$ brz uncommit --force
 
240
    2 ...
 
241
      second commit
 
242
...
 
243
The above revision(s) will be removed.
 
244
You can restore the old tip by running:
 
245
  brz pull . -r revid:a2
 
246
""")
 
247
 
 
248
    def test_uncommit_shows_pull_with_location(self):
 
249
        wt = self.create_simple_tree()
 
250
 
 
251
        script = ScriptRunner()
 
252
        script.run_script(self, """
 
253
$ brz uncommit --force tree
 
254
    2 ...
 
255
      second commit
 
256
...
 
257
The above revision(s) will be removed.
 
258
You can restore the old tip by running:
 
259
  brz pull -d tree tree -r revid:a2
248
260
""")
249
261
 
250
262
    def test_uncommit_octopus_merge(self):
252
264
        # though it will also filter out ones in the ancestry
253
265
        wt = self.create_simple_tree()
254
266
 
255
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
256
 
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
 
267
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
268
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
257
269
 
258
 
        tree2.commit('unchanged', rev_id='b3')
259
 
        tree3.commit('unchanged', rev_id='c3')
 
270
        tree2.commit('unchanged', rev_id=b'b3')
 
271
        tree3.commit('unchanged', rev_id=b'c3')
260
272
 
261
273
        wt.merge_from_branch(tree2.branch)
262
274
        wt.merge_from_branch(tree3.branch, force=True)
263
 
        wt.commit('merge b3, c3', rev_id='a3')
 
275
        wt.commit('merge b3, c3', rev_id=b'a3')
264
276
 
265
 
        tree2.commit('unchanged', rev_id='b4')
266
 
        tree3.commit('unchanged', rev_id='c4')
 
277
        tree2.commit('unchanged', rev_id=b'b4')
 
278
        tree3.commit('unchanged', rev_id=b'c4')
267
279
 
268
280
        wt.merge_from_branch(tree3.branch)
269
281
        wt.merge_from_branch(tree2.branch, force=True)
270
 
        wt.commit('merge b4, c4', rev_id='a4')
 
282
        wt.commit('merge b4, c4', rev_id=b'a4')
271
283
 
272
 
        self.assertEqual(['a4'], wt.get_parent_ids())
 
284
        self.assertEqual([b'a4'], wt.get_parent_ids())
273
285
 
274
286
        os.chdir('tree')
275
287
        out, err = self.run_bzr('uncommit --force -r 2')
276
288
 
277
 
        self.assertEqual(['a2', 'c4', 'b4'], wt.get_parent_ids())
 
289
        self.assertEqual([b'a2', b'c4', b'b4'], wt.get_parent_ids())
278
290
 
279
291
    def test_uncommit_nonascii(self):
280
292
        tree = self.make_branch_and_tree('tree')
287
299
        revid = tree.commit('message')
288
300
        tree.branch.tags.set_tag("atag", revid)
289
301
        out, err = self.run_bzr('uncommit --force tree')
290
 
        self.assertEquals({}, tree.branch.tags.get_tag_dict())
 
302
        self.assertEqual({}, tree.branch.tags.get_tag_dict())
291
303
 
292
304
    def test_uncommit_keep_tags(self):
293
305
        tree = self.make_branch_and_tree('tree')
294
306
        revid = tree.commit('message')
295
307
        tree.branch.tags.set_tag("atag", revid)
296
308
        out, err = self.run_bzr('uncommit --keep-tags --force tree')
297
 
        self.assertEquals({"atag": revid}, tree.branch.tags.get_tag_dict())
298
 
 
299
 
 
300
 
class TestSmartServerUncommit(TestCaseWithTransport):
301
 
 
302
 
    def test_uncommit(self):
303
 
        self.setup_smart_server_with_call_log()
304
 
        t = self.make_branch_and_tree('from')
305
 
        for count in range(2):
306
 
            t.commit(message='commit %d' % count)
307
 
        self.reset_smart_call_log()
308
 
        out, err = self.run_bzr(['uncommit', '--force', self.get_url('from')])
309
 
        # This figure represent the amount of work to perform this use case. It
310
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
311
 
        # being too low. If rpc_count increases, more network roundtrips have
312
 
        # become necessary for this use case. Please do not adjust this number
313
 
        # upwards without agreement from bzr's network support maintainers.
314
 
        self.assertLength(14, self.hpss_calls)
315
 
        self.assertLength(1, self.hpss_connections)
316
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
309
        self.assertEqual({"atag": revid}, tree.branch.tags.get_tag_dict())
317
310
 
318
311
 
319
312
class TestInconsistentDelta(TestCaseWithTransport):
320
313
    # See https://bugs.launchpad.net/bzr/+bug/855155
321
314
    # See https://bugs.launchpad.net/bzr/+bug/1100385
322
 
    # bzr uncommit may result in error
 
315
    # brz uncommit may result in error
323
316
    # 'An inconsistent delta was supplied involving'
324
317
 
325
318
    def test_inconsistent_delta(self):
327
320
        wt = self.make_branch_and_tree('test')
328
321
        self.build_tree(['test/a/', 'test/a/b', 'test/a/c'])
329
322
        wt.add(['a', 'a/b', 'a/c'])
330
 
        wt.commit('initial commit', rev_id='a1')
 
323
        wt.commit('initial commit', rev_id=b'a1')
331
324
        wt.remove(['a/b', 'a/c'])
332
 
        wt.commit('remove b and c', rev_id='a2')
 
325
        wt.commit('remove b and c', rev_id=b'a2')
333
326
        self.run_bzr("uncommit --force test")