/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): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

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, workingtree
22
 
from bzrlib.bzrdir import BzrDirMetaFormat1
23
 
from bzrlib.errors import BzrError, BoundBranchOutOfDate
24
 
from bzrlib.tests import TestCaseWithTransport
25
 
from bzrlib.tests.script import ScriptRunner
 
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 (
 
26
    run_script,
 
27
    ScriptRunner,
 
28
    )
26
29
 
27
30
 
28
31
class TestUncommit(TestCaseWithTransport):
31
34
        wt = self.make_branch_and_tree('tree')
32
35
        self.build_tree(['tree/a', 'tree/b', 'tree/c'])
33
36
        wt.add(['a', 'b', 'c'])
34
 
        wt.commit('initial commit', rev_id='a1')
 
37
        wt.commit('initial commit', rev_id=b'a1')
35
38
 
36
 
        self.build_tree_contents([('tree/a', 'new contents of a\n')])
37
 
        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')
38
41
 
39
42
        return wt
40
43
 
49
52
        self.assertContainsRe(out, 'second commit')
50
53
 
51
54
        # Nothing has changed
52
 
        self.assertEqual(['a2'], wt.get_parent_ids())
 
55
        self.assertEqual([b'a2'], wt.get_parent_ids())
53
56
 
54
57
        # Uncommit, don't prompt
55
58
        out, err = self.run_bzr('uncommit --force')
57
60
        self.assertContainsRe(out, 'second commit')
58
61
 
59
62
        # This should look like we are back in revno 1
60
 
        self.assertEqual(['a1'], wt.get_parent_ids())
 
63
        self.assertEqual([b'a1'], wt.get_parent_ids())
61
64
        out, err = self.run_bzr('status')
62
 
        self.assertEquals(out, 'modified:\n  a\n')
 
65
        self.assertEqual(out, 'modified:\n  a\n')
 
66
 
 
67
    def test_uncommit_interactive(self):
 
68
        """Uncommit seeks confirmation, and doesn't proceed without it."""
 
69
        wt = self.create_simple_tree()
 
70
        os.chdir('tree')
 
71
        run_script(self, """
 
72
        $ brz uncommit
 
73
        ...
 
74
        The above revision(s) will be removed.
 
75
        2>Uncommit these revisions? ([y]es, [n]o): no
 
76
        <n
 
77
        Canceled
 
78
        """)
 
79
        self.assertEqual([b'a2'], wt.get_parent_ids())
63
80
 
64
81
    def test_uncommit_no_history(self):
65
82
        wt = self.make_branch_and_tree('tree')
71
88
        wt = self.create_simple_tree()
72
89
        checkout_tree = wt.branch.create_checkout('checkout')
73
90
 
74
 
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
 
91
        self.assertEqual([b'a2'], checkout_tree.get_parent_ids())
75
92
 
76
93
        os.chdir('checkout')
77
94
        out, err = self.run_bzr('uncommit --dry-run --force')
79
96
        self.assertNotContainsRe(out, 'initial commit')
80
97
        self.assertContainsRe(out, 'second commit')
81
98
 
82
 
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
 
99
        self.assertEqual([b'a2'], checkout_tree.get_parent_ids())
83
100
 
84
101
        out, err = self.run_bzr('uncommit --force')
85
102
        self.assertNotContainsRe(out, 'initial commit')
87
104
 
88
105
        # uncommit in a checkout should uncommit the parent branch
89
106
        # (but doesn't effect the other working tree)
90
 
        self.assertEquals(['a1'], checkout_tree.get_parent_ids())
91
 
        self.assertEquals('a1', wt.branch.last_revision())
92
 
        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())
93
110
 
94
111
    def test_uncommit_bound(self):
95
112
        os.mkdir('a')
102
119
        t_a.commit('commit 3')
103
120
        b = t_a.branch.create_checkout('b').branch
104
121
        uncommit.uncommit(b)
105
 
        self.assertEqual(len(b.revision_history()), 2)
106
 
        self.assertEqual(len(t_a.branch.revision_history()), 2)
 
122
        self.assertEqual(b.last_revision_info()[0], 2)
 
123
        self.assertEqual(t_a.branch.last_revision_info()[0], 2)
107
124
        # update A's tree to not have the uncommitted revision referenced.
108
125
        t_a.update()
109
126
        t_a.commit('commit 3b')
131
148
 
132
149
        self.assertNotContainsRe(out, 'initial commit')
133
150
        self.assertContainsRe(out, 'second commit')
134
 
        self.assertEqual(['a1'], wt.get_parent_ids())
135
 
        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())
136
153
 
137
154
    def test_uncommit_neg_1(self):
138
155
        wt = self.create_simple_tree()
143
160
    def test_uncommit_merges(self):
144
161
        wt = self.create_simple_tree()
145
162
 
146
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
163
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
147
164
 
148
 
        tree2.commit('unchanged', rev_id='b3')
149
 
        tree2.commit('unchanged', rev_id='b4')
 
165
        tree2.commit('unchanged', rev_id=b'b3')
 
166
        tree2.commit('unchanged', rev_id=b'b4')
150
167
 
151
168
        wt.merge_from_branch(tree2.branch)
152
 
        wt.commit('merge b4', rev_id='a3')
 
169
        wt.commit('merge b4', rev_id=b'a3')
153
170
 
154
 
        self.assertEqual(['a3'], wt.get_parent_ids())
 
171
        self.assertEqual([b'a3'], wt.get_parent_ids())
155
172
 
156
173
        os.chdir('tree')
157
174
        out, err = self.run_bzr('uncommit --force')
158
175
 
159
 
        self.assertEqual(['a2', 'b4'], wt.get_parent_ids())
 
176
        self.assertEqual([b'a2', b'b4'], wt.get_parent_ids())
160
177
 
161
178
    def test_uncommit_pending_merge(self):
162
179
        wt = self.create_simple_tree()
163
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
164
 
        tree2.commit('unchanged', rev_id='b3')
 
180
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
181
        tree2.commit('unchanged', rev_id=b'b3')
165
182
 
166
183
        wt.branch.fetch(tree2.branch)
167
 
        wt.set_pending_merges(['b3'])
 
184
        wt.set_pending_merges([b'b3'])
168
185
 
169
186
        os.chdir('tree')
170
187
        out, err = self.run_bzr('uncommit --force')
171
 
        self.assertEqual(['a1', 'b3'], wt.get_parent_ids())
 
188
        self.assertEqual([b'a1', b'b3'], wt.get_parent_ids())
172
189
 
173
190
    def test_uncommit_multiple_merge(self):
174
191
        wt = self.create_simple_tree()
175
192
 
176
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
177
 
        tree2.commit('unchanged', rev_id='b3')
 
193
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
194
        tree2.commit('unchanged', rev_id=b'b3')
178
195
 
179
 
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
180
 
        tree3.commit('unchanged', rev_id='c3')
 
196
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
 
197
        tree3.commit('unchanged', rev_id=b'c3')
181
198
 
182
199
        wt.merge_from_branch(tree2.branch)
183
 
        wt.commit('merge b3', rev_id='a3')
 
200
        wt.commit('merge b3', rev_id=b'a3')
184
201
 
185
202
        wt.merge_from_branch(tree3.branch)
186
 
        wt.commit('merge c3', rev_id='a4')
 
203
        wt.commit('merge c3', rev_id=b'a4')
187
204
 
188
 
        self.assertEqual(['a4'], wt.get_parent_ids())
 
205
        self.assertEqual([b'a4'], wt.get_parent_ids())
189
206
 
190
207
        os.chdir('tree')
191
208
        out, err = self.run_bzr('uncommit --force -r 2')
192
209
 
193
 
        self.assertEqual(['a2', 'b3', 'c3'], wt.get_parent_ids())
 
210
        self.assertEqual([b'a2', b'b3', b'c3'], wt.get_parent_ids())
194
211
 
195
212
    def test_uncommit_merge_plus_pending(self):
196
213
        wt = self.create_simple_tree()
197
214
 
198
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
199
 
        tree2.commit('unchanged', rev_id='b3')
200
 
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
201
 
        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')
202
219
 
203
220
        wt.branch.fetch(tree2.branch)
204
 
        wt.set_pending_merges(['b3'])
205
 
        wt.commit('merge b3', rev_id='a3')
206
 
 
 
221
        wt.set_pending_merges([b'b3'])
 
222
        wt.commit('merge b3', rev_id=b'a3')
207
223
 
208
224
        wt.merge_from_branch(tree3.branch)
209
225
 
210
 
        self.assertEqual(['a3', 'c3'], wt.get_parent_ids())
 
226
        self.assertEqual([b'a3', b'c3'], wt.get_parent_ids())
211
227
 
212
228
        os.chdir('tree')
213
229
        out, err = self.run_bzr('uncommit --force -r 2')
214
230
 
215
 
        self.assertEqual(['a2', 'b3', 'c3'], wt.get_parent_ids())
 
231
        self.assertEqual([b'a2', b'b3', b'c3'], wt.get_parent_ids())
216
232
 
217
233
    def test_uncommit_shows_log_with_revision_id(self):
218
234
        wt = self.create_simple_tree()
220
236
        script = ScriptRunner()
221
237
        script.run_script(self, """
222
238
$ cd tree
223
 
$ bzr uncommit --force 
224
 
    2 ...
225
 
      second commit
226
 
...
227
 
The above revision(s) will be removed.
228
 
You can restore the old tip by running:
229
 
  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
230
260
""")
231
261
 
232
262
    def test_uncommit_octopus_merge(self):
234
264
        # though it will also filter out ones in the ancestry
235
265
        wt = self.create_simple_tree()
236
266
 
237
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
238
 
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
 
267
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
268
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
239
269
 
240
 
        tree2.commit('unchanged', rev_id='b3')
241
 
        tree3.commit('unchanged', rev_id='c3')
 
270
        tree2.commit('unchanged', rev_id=b'b3')
 
271
        tree3.commit('unchanged', rev_id=b'c3')
242
272
 
243
273
        wt.merge_from_branch(tree2.branch)
244
274
        wt.merge_from_branch(tree3.branch, force=True)
245
 
        wt.commit('merge b3, c3', rev_id='a3')
 
275
        wt.commit('merge b3, c3', rev_id=b'a3')
246
276
 
247
 
        tree2.commit('unchanged', rev_id='b4')
248
 
        tree3.commit('unchanged', rev_id='c4')
 
277
        tree2.commit('unchanged', rev_id=b'b4')
 
278
        tree3.commit('unchanged', rev_id=b'c4')
249
279
 
250
280
        wt.merge_from_branch(tree3.branch)
251
281
        wt.merge_from_branch(tree2.branch, force=True)
252
 
        wt.commit('merge b4, c4', rev_id='a4')
 
282
        wt.commit('merge b4, c4', rev_id=b'a4')
253
283
 
254
 
        self.assertEqual(['a4'], wt.get_parent_ids())
 
284
        self.assertEqual([b'a4'], wt.get_parent_ids())
255
285
 
256
286
        os.chdir('tree')
257
287
        out, err = self.run_bzr('uncommit --force -r 2')
258
288
 
259
 
        self.assertEqual(['a2', 'c4', 'b4'], wt.get_parent_ids())
 
289
        self.assertEqual([b'a2', b'c4', b'b4'], wt.get_parent_ids())
260
290
 
261
291
    def test_uncommit_nonascii(self):
262
292
        tree = self.make_branch_and_tree('tree')
263
293
        tree.commit(u'\u1234 message')
264
294
        out, err = self.run_bzr('uncommit --force tree', encoding='ascii')
265
295
        self.assertContainsRe(out, r'\? message')
 
296
 
 
297
    def test_uncommit_removes_tags(self):
 
298
        tree = self.make_branch_and_tree('tree')
 
299
        revid = tree.commit('message')
 
300
        tree.branch.tags.set_tag("atag", revid)
 
301
        out, err = self.run_bzr('uncommit --force tree')
 
302
        self.assertEqual({}, tree.branch.tags.get_tag_dict())
 
303
 
 
304
    def test_uncommit_keep_tags(self):
 
305
        tree = self.make_branch_and_tree('tree')
 
306
        revid = tree.commit('message')
 
307
        tree.branch.tags.set_tag("atag", revid)
 
308
        out, err = self.run_bzr('uncommit --keep-tags --force tree')
 
309
        self.assertEqual({"atag": revid}, tree.branch.tags.get_tag_dict())
 
310
 
 
311
 
 
312
class TestInconsistentDelta(TestCaseWithTransport):
 
313
    # See https://bugs.launchpad.net/bzr/+bug/855155
 
314
    # See https://bugs.launchpad.net/bzr/+bug/1100385
 
315
    # brz uncommit may result in error
 
316
    # 'An inconsistent delta was supplied involving'
 
317
 
 
318
    def test_inconsistent_delta(self):
 
319
        # Script taken from https://bugs.launchpad.net/bzr/+bug/855155/comments/26
 
320
        wt = self.make_branch_and_tree('test')
 
321
        self.build_tree(['test/a/', 'test/a/b', 'test/a/c'])
 
322
        wt.add(['a', 'a/b', 'a/c'])
 
323
        wt.commit('initial commit', rev_id=b'a1')
 
324
        wt.remove(['a/b', 'a/c'])
 
325
        wt.commit('remove b and c', rev_id=b'a2')
 
326
        self.run_bzr("uncommit --force test")