/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: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_uncommit.py
19
19
import os
20
20
 
21
21
from breezy import uncommit
22
 
from breezy.bzr.bzrdir import BzrDirMetaFormat1
 
22
from breezy.bzrdir import BzrDirMetaFormat1
23
23
from breezy.errors import BoundBranchOutOfDate
24
24
from breezy.tests import TestCaseWithTransport
 
25
from breezy.tests.matchers import ContainsNoVfsCalls
25
26
from breezy.tests.script import (
26
27
    run_script,
27
28
    ScriptRunner,
34
35
        wt = self.make_branch_and_tree('tree')
35
36
        self.build_tree(['tree/a', 'tree/b', 'tree/c'])
36
37
        wt.add(['a', 'b', 'c'])
37
 
        wt.commit('initial commit', rev_id=b'a1')
 
38
        wt.commit('initial commit', rev_id='a1')
38
39
 
39
 
        self.build_tree_contents([('tree/a', b'new contents of a\n')])
40
 
        wt.commit('second commit', rev_id=b'a2')
 
40
        self.build_tree_contents([('tree/a', 'new contents of a\n')])
 
41
        wt.commit('second commit', rev_id='a2')
41
42
 
42
43
        return wt
43
44
 
52
53
        self.assertContainsRe(out, 'second commit')
53
54
 
54
55
        # Nothing has changed
55
 
        self.assertEqual([b'a2'], wt.get_parent_ids())
 
56
        self.assertEqual(['a2'], wt.get_parent_ids())
56
57
 
57
58
        # Uncommit, don't prompt
58
59
        out, err = self.run_bzr('uncommit --force')
60
61
        self.assertContainsRe(out, 'second commit')
61
62
 
62
63
        # This should look like we are back in revno 1
63
 
        self.assertEqual([b'a1'], wt.get_parent_ids())
 
64
        self.assertEqual(['a1'], wt.get_parent_ids())
64
65
        out, err = self.run_bzr('status')
65
66
        self.assertEqual(out, 'modified:\n  a\n')
66
67
 
68
69
        """Uncommit seeks confirmation, and doesn't proceed without it."""
69
70
        wt = self.create_simple_tree()
70
71
        os.chdir('tree')
71
 
        run_script(self, """
 
72
        run_script(self, """    
72
73
        $ brz uncommit
73
74
        ...
74
75
        The above revision(s) will be removed.
76
77
        <n
77
78
        Canceled
78
79
        """)
79
 
        self.assertEqual([b'a2'], wt.get_parent_ids())
 
80
        self.assertEqual(['a2'], wt.get_parent_ids())
80
81
 
81
82
    def test_uncommit_no_history(self):
82
83
        wt = self.make_branch_and_tree('tree')
88
89
        wt = self.create_simple_tree()
89
90
        checkout_tree = wt.branch.create_checkout('checkout')
90
91
 
91
 
        self.assertEqual([b'a2'], checkout_tree.get_parent_ids())
 
92
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
92
93
 
93
94
        os.chdir('checkout')
94
95
        out, err = self.run_bzr('uncommit --dry-run --force')
96
97
        self.assertNotContainsRe(out, 'initial commit')
97
98
        self.assertContainsRe(out, 'second commit')
98
99
 
99
 
        self.assertEqual([b'a2'], checkout_tree.get_parent_ids())
 
100
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
100
101
 
101
102
        out, err = self.run_bzr('uncommit --force')
102
103
        self.assertNotContainsRe(out, 'initial commit')
104
105
 
105
106
        # uncommit in a checkout should uncommit the parent branch
106
107
        # (but doesn't effect the other working tree)
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())
 
108
        self.assertEqual(['a1'], checkout_tree.get_parent_ids())
 
109
        self.assertEqual('a1', wt.branch.last_revision())
 
110
        self.assertEqual(['a2'], wt.get_parent_ids())
110
111
 
111
112
    def test_uncommit_bound(self):
112
113
        os.mkdir('a')
148
149
 
149
150
        self.assertNotContainsRe(out, 'initial commit')
150
151
        self.assertContainsRe(out, 'second commit')
151
 
        self.assertEqual([b'a1'], wt.get_parent_ids())
152
 
        self.assertEqual(b'a1', wt.branch.last_revision())
 
152
        self.assertEqual(['a1'], wt.get_parent_ids())
 
153
        self.assertEqual('a1', wt.branch.last_revision())
153
154
 
154
155
    def test_uncommit_neg_1(self):
155
156
        wt = self.create_simple_tree()
160
161
    def test_uncommit_merges(self):
161
162
        wt = self.create_simple_tree()
162
163
 
163
 
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
 
164
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
164
165
 
165
 
        tree2.commit('unchanged', rev_id=b'b3')
166
 
        tree2.commit('unchanged', rev_id=b'b4')
 
166
        tree2.commit('unchanged', rev_id='b3')
 
167
        tree2.commit('unchanged', rev_id='b4')
167
168
 
168
169
        wt.merge_from_branch(tree2.branch)
169
 
        wt.commit('merge b4', rev_id=b'a3')
 
170
        wt.commit('merge b4', rev_id='a3')
170
171
 
171
 
        self.assertEqual([b'a3'], wt.get_parent_ids())
 
172
        self.assertEqual(['a3'], wt.get_parent_ids())
172
173
 
173
174
        os.chdir('tree')
174
175
        out, err = self.run_bzr('uncommit --force')
175
176
 
176
 
        self.assertEqual([b'a2', b'b4'], wt.get_parent_ids())
 
177
        self.assertEqual(['a2', 'b4'], wt.get_parent_ids())
177
178
 
178
179
    def test_uncommit_pending_merge(self):
179
180
        wt = self.create_simple_tree()
180
 
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
181
 
        tree2.commit('unchanged', rev_id=b'b3')
 
181
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
182
        tree2.commit('unchanged', rev_id='b3')
182
183
 
183
184
        wt.branch.fetch(tree2.branch)
184
 
        wt.set_pending_merges([b'b3'])
 
185
        wt.set_pending_merges(['b3'])
185
186
 
186
187
        os.chdir('tree')
187
188
        out, err = self.run_bzr('uncommit --force')
188
 
        self.assertEqual([b'a1', b'b3'], wt.get_parent_ids())
 
189
        self.assertEqual(['a1', 'b3'], wt.get_parent_ids())
189
190
 
190
191
    def test_uncommit_multiple_merge(self):
191
192
        wt = self.create_simple_tree()
192
193
 
193
 
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
194
 
        tree2.commit('unchanged', rev_id=b'b3')
 
194
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
195
        tree2.commit('unchanged', rev_id='b3')
195
196
 
196
 
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
197
 
        tree3.commit('unchanged', rev_id=b'c3')
 
197
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
 
198
        tree3.commit('unchanged', rev_id='c3')
198
199
 
199
200
        wt.merge_from_branch(tree2.branch)
200
 
        wt.commit('merge b3', rev_id=b'a3')
 
201
        wt.commit('merge b3', rev_id='a3')
201
202
 
202
203
        wt.merge_from_branch(tree3.branch)
203
 
        wt.commit('merge c3', rev_id=b'a4')
 
204
        wt.commit('merge c3', rev_id='a4')
204
205
 
205
 
        self.assertEqual([b'a4'], wt.get_parent_ids())
 
206
        self.assertEqual(['a4'], wt.get_parent_ids())
206
207
 
207
208
        os.chdir('tree')
208
209
        out, err = self.run_bzr('uncommit --force -r 2')
209
210
 
210
 
        self.assertEqual([b'a2', b'b3', b'c3'], wt.get_parent_ids())
 
211
        self.assertEqual(['a2', 'b3', 'c3'], wt.get_parent_ids())
211
212
 
212
213
    def test_uncommit_merge_plus_pending(self):
213
214
        wt = self.create_simple_tree()
214
215
 
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')
 
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')
219
220
 
220
221
        wt.branch.fetch(tree2.branch)
221
 
        wt.set_pending_merges([b'b3'])
222
 
        wt.commit('merge b3', rev_id=b'a3')
 
222
        wt.set_pending_merges(['b3'])
 
223
        wt.commit('merge b3', rev_id='a3')
 
224
 
223
225
 
224
226
        wt.merge_from_branch(tree3.branch)
225
227
 
226
 
        self.assertEqual([b'a3', b'c3'], wt.get_parent_ids())
 
228
        self.assertEqual(['a3', 'c3'], wt.get_parent_ids())
227
229
 
228
230
        os.chdir('tree')
229
231
        out, err = self.run_bzr('uncommit --force -r 2')
230
232
 
231
 
        self.assertEqual([b'a2', b'b3', b'c3'], wt.get_parent_ids())
 
233
        self.assertEqual(['a2', 'b3', 'c3'], wt.get_parent_ids())
232
234
 
233
235
    def test_uncommit_shows_log_with_revision_id(self):
234
236
        wt = self.create_simple_tree()
236
238
        script = ScriptRunner()
237
239
        script.run_script(self, """
238
240
$ cd tree
239
 
$ brz uncommit --force
 
241
$ brz uncommit --force 
240
242
    2 ...
241
243
      second commit
242
244
...
245
247
  brz pull . -r revid:a2
246
248
""")
247
249
 
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
260
 
""")
261
 
 
262
250
    def test_uncommit_octopus_merge(self):
263
251
        # Check that uncommit keeps the pending merges in the same order
264
252
        # though it will also filter out ones in the ancestry
265
253
        wt = self.create_simple_tree()
266
254
 
267
 
        tree2 = wt.controldir.sprout('tree2').open_workingtree()
268
 
        tree3 = wt.controldir.sprout('tree3').open_workingtree()
 
255
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
256
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
269
257
 
270
 
        tree2.commit('unchanged', rev_id=b'b3')
271
 
        tree3.commit('unchanged', rev_id=b'c3')
 
258
        tree2.commit('unchanged', rev_id='b3')
 
259
        tree3.commit('unchanged', rev_id='c3')
272
260
 
273
261
        wt.merge_from_branch(tree2.branch)
274
262
        wt.merge_from_branch(tree3.branch, force=True)
275
 
        wt.commit('merge b3, c3', rev_id=b'a3')
 
263
        wt.commit('merge b3, c3', rev_id='a3')
276
264
 
277
 
        tree2.commit('unchanged', rev_id=b'b4')
278
 
        tree3.commit('unchanged', rev_id=b'c4')
 
265
        tree2.commit('unchanged', rev_id='b4')
 
266
        tree3.commit('unchanged', rev_id='c4')
279
267
 
280
268
        wt.merge_from_branch(tree3.branch)
281
269
        wt.merge_from_branch(tree2.branch, force=True)
282
 
        wt.commit('merge b4, c4', rev_id=b'a4')
 
270
        wt.commit('merge b4, c4', rev_id='a4')
283
271
 
284
 
        self.assertEqual([b'a4'], wt.get_parent_ids())
 
272
        self.assertEqual(['a4'], wt.get_parent_ids())
285
273
 
286
274
        os.chdir('tree')
287
275
        out, err = self.run_bzr('uncommit --force -r 2')
288
276
 
289
 
        self.assertEqual([b'a2', b'c4', b'b4'], wt.get_parent_ids())
 
277
        self.assertEqual(['a2', 'c4', 'b4'], wt.get_parent_ids())
290
278
 
291
279
    def test_uncommit_nonascii(self):
292
280
        tree = self.make_branch_and_tree('tree')
309
297
        self.assertEqual({"atag": revid}, tree.branch.tags.get_tag_dict())
310
298
 
311
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)
 
317
 
 
318
 
312
319
class TestInconsistentDelta(TestCaseWithTransport):
313
320
    # See https://bugs.launchpad.net/bzr/+bug/855155
314
321
    # See https://bugs.launchpad.net/bzr/+bug/1100385
320
327
        wt = self.make_branch_and_tree('test')
321
328
        self.build_tree(['test/a/', 'test/a/b', 'test/a/c'])
322
329
        wt.add(['a', 'a/b', 'a/c'])
323
 
        wt.commit('initial commit', rev_id=b'a1')
 
330
        wt.commit('initial commit', rev_id='a1')
324
331
        wt.remove(['a/b', 'a/c'])
325
 
        wt.commit('remove b and c', rev_id=b'a2')
 
332
        wt.commit('remove b and c', rev_id='a2')
326
333
        self.run_bzr("uncommit --force test")