← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_uncommit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-08-17 07:52:09 UTC
  • mfrom: (1910.3.4 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20060817075209-e85a1f9e05ff8b87
(andrew) Trivial fixes to NotImplemented errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_uncommit.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by 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
25
25
 
26
26
 
27
27
class TestUncommit(TestCaseWithTransport):
28
 
 
29
28
    def create_simple_tree(self):
30
29
        wt = self.make_branch_and_tree('tree')
31
30
        self.build_tree(['tree/a', 'tree/b', 'tree/c'])
42
41
        wt = self.create_simple_tree()
43
42
 
44
43
        os.chdir('tree')
45
 
        out, err = self.run_bzr('uncommit --dry-run --force')
 
44
        out, err = self.run_bzr('uncommit', '--dry-run', '--force')
46
45
        self.assertContainsRe(out, 'Dry-run')
47
46
        self.assertNotContainsRe(out, 'initial commit')
48
47
        self.assertContainsRe(out, 'second commit')
49
48
 
50
49
        # Nothing has changed
51
 
        self.assertEqual(['a2'], wt.get_parent_ids())
 
50
        self.assertEqual('a2', wt.last_revision())
52
51
 
53
52
        # Uncommit, don't prompt
54
 
        out, err = self.run_bzr('uncommit --force')
 
53
        out, err = self.run_bzr('uncommit', '--force')
55
54
        self.assertNotContainsRe(out, 'initial commit')
56
55
        self.assertContainsRe(out, 'second commit')
57
56
 
58
57
        # This should look like we are back in revno 1
59
 
        self.assertEqual(['a1'], wt.get_parent_ids())
 
58
        self.assertEqual('a1', wt.last_revision())
60
59
        out, err = self.run_bzr('status')
61
60
        self.assertEquals(out, 'modified:\n  a\n')
62
61
 
63
62
    def test_uncommit_checkout(self):
64
63
        wt = self.create_simple_tree()
65
 
        checkout_tree = wt.branch.create_checkout('checkout')
66
 
 
67
 
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
 
64
 
 
65
        checkout_tree = wt.bzrdir.sprout('checkout').open_workingtree()
 
66
        checkout_tree.branch.bind(wt.branch)
 
67
 
 
68
        self.assertEqual('a2', checkout_tree.last_revision())
68
69
 
69
70
        os.chdir('checkout')
70
 
        out, err = self.run_bzr('uncommit --dry-run --force')
 
71
        out, err = self.run_bzr('uncommit', '--dry-run', '--force')
71
72
        self.assertContainsRe(out, 'Dry-run')
72
73
        self.assertNotContainsRe(out, 'initial commit')
73
74
        self.assertContainsRe(out, 'second commit')
74
75
 
75
 
        self.assertEqual(['a2'], checkout_tree.get_parent_ids())
 
76
        self.assertEqual('a2', checkout_tree.last_revision())
76
77
 
77
 
        out, err = self.run_bzr('uncommit --force')
 
78
        out, err = self.run_bzr('uncommit', '--force')
78
79
        self.assertNotContainsRe(out, 'initial commit')
79
80
        self.assertContainsRe(out, 'second commit')
80
81
 
81
82
        # uncommit in a checkout should uncommit the parent branch
82
83
        # (but doesn't effect the other working tree)
83
 
        self.assertEquals(['a1'], checkout_tree.get_parent_ids())
 
84
        self.assertEquals('a1', checkout_tree.last_revision())
84
85
        self.assertEquals('a1', wt.branch.last_revision())
85
 
        self.assertEquals(['a2'], wt.get_parent_ids())
 
86
        self.assertEquals('a2', wt.last_revision())
86
87
 
87
88
    def test_uncommit_bound(self):
88
89
        os.mkdir('a')
89
90
        a = BzrDirMetaFormat1().initialize('a')
90
91
        a.create_repository()
91
92
        a.create_branch()
92
 
        t_a = a.create_workingtree()
93
 
        t_a.commit('commit 1')
94
 
        t_a.commit('commit 2')
95
 
        t_a.commit('commit 3')
96
 
        b = t_a.branch.create_checkout('b').branch
 
93
        t = a.create_workingtree()
 
94
        t.commit('commit 1')
 
95
        t.commit('commit 2')
 
96
        t.commit('commit 3')
 
97
        b = t.bzrdir.sprout('b').open_branch()
 
98
        b.bind(t.branch)
97
99
        uncommit.uncommit(b)
 
100
        t.set_last_revision(t.branch.last_revision())
98
101
        self.assertEqual(len(b.revision_history()), 2)
99
 
        self.assertEqual(len(t_a.branch.revision_history()), 2)
100
 
        # update A's tree to not have the uncomitted revision referenced.
101
 
        t_a.update()
102
 
        t_a.commit('commit 3b')
 
102
        self.assertEqual(len(t.branch.revision_history()), 2)
 
103
        t.commit('commit 3b')
103
104
        self.assertRaises(BoundBranchOutOfDate, uncommit.uncommit, b)
104
 
        b.pull(t_a.branch)
 
105
        b.pull(t.branch)
105
106
        uncommit.uncommit(b)
106
107
 
107
108
    def test_uncommit_revision(self):
108
109
        wt = self.create_simple_tree()
109
110
 
110
111
        os.chdir('tree')
111
 
        out, err = self.run_bzr('uncommit -r1 --force')
 
112
        out, err = self.run_bzr('uncommit', '-r1', '--force')
112
113
 
113
114
        self.assertNotContainsRe(out, 'initial commit')
114
115
        self.assertContainsRe(out, 'second commit')
115
 
        self.assertEqual(['a1'], wt.get_parent_ids())
 
116
        self.assertEqual('a1', wt.last_revision())
116
117
        self.assertEqual('a1', wt.branch.last_revision())
117
118
 
118
119
    def test_uncommit_neg_1(self):
119
120
        wt = self.create_simple_tree()
120
121
        os.chdir('tree')
121
 
        out, err = self.run_bzr('uncommit -r -1', retcode=1)
 
122
        out, err = self.run_bzr('uncommit', '-r', '-1', retcode=1)
122
123
        self.assertEqual('No revisions to uncommit.\n', out)
123
124
 
124
125
    def test_uncommit_merges(self):
129
130
        tree2.commit('unchanged', rev_id='b3')
130
131
        tree2.commit('unchanged', rev_id='b4')
131
132
 
132
 
        wt.merge_from_branch(tree2.branch)
 
133
        wt.branch.fetch(tree2.branch)
 
134
        wt.set_pending_merges(['b4'])
133
135
        wt.commit('merge b4', rev_id='a3')
134
136
 
135
 
        self.assertEqual(['a3'], wt.get_parent_ids())
136
 
 
137
 
        os.chdir('tree')
138
 
        out, err = self.run_bzr('uncommit --force')
139
 
 
140
 
        self.assertEqual(['a2', 'b4'], wt.get_parent_ids())
141
 
 
142
 
    def test_uncommit_pending_merge(self):
143
 
        wt = self.create_simple_tree()
144
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
145
 
        tree2.commit('unchanged', rev_id='b3')
146
 
 
147
 
        wt.branch.fetch(tree2.branch)
148
 
        wt.set_pending_merges(['b3'])
149
 
 
150
 
        os.chdir('tree')
151
 
        out, err = self.run_bzr('uncommit --force')
152
 
        self.assertEqual(['a1', 'b3'], wt.get_parent_ids())
 
137
        self.assertEqual('a3', wt.last_revision())
 
138
        self.assertEqual([], wt.pending_merges())
 
139
 
 
140
        os.chdir('tree')
 
141
        out, err = self.run_bzr('uncommit', '--force')
 
142
 
 
143
        self.assertEqual('a2', wt.last_revision())
 
144
        self.assertEqual(['b4'], wt.pending_merges())
153
145
 
154
146
    def test_uncommit_multiple_merge(self):
155
147
        wt = self.create_simple_tree()
157
149
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
158
150
 
159
151
        tree2.commit('unchanged', rev_id='b3')
160
 
 
161
 
        wt.merge_from_branch(tree2.branch)
 
152
        wt.branch.fetch(tree2.branch)
 
153
        wt.set_pending_merges(['b3'])
162
154
        wt.commit('merge b3', rev_id='a3')
163
155
 
164
156
        tree2.commit('unchanged', rev_id='b4')
165
 
 
166
 
        wt.merge_from_branch(tree2.branch)
 
157
        wt.branch.fetch(tree2.branch)
 
158
        wt.set_pending_merges(['b4'])
167
159
        wt.commit('merge b4', rev_id='a4')
168
160
 
169
 
        self.assertEqual(['a4'], wt.get_parent_ids())
170
 
 
171
 
        os.chdir('tree')
172
 
        out, err = self.run_bzr('uncommit --force -r 2')
173
 
 
174
 
        self.assertEqual(['a2', 'b3', 'b4'], wt.get_parent_ids())
175
 
 
176
 
    def test_uncommit_merge_plus_pending(self):
177
 
        wt = self.create_simple_tree()
178
 
 
179
 
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
180
 
 
181
 
        tree2.commit('unchanged', rev_id='b3')
182
 
        wt.branch.fetch(tree2.branch)
183
 
        wt.set_pending_merges(['b3'])
184
 
        wt.commit('merge b3', rev_id='a3')
185
 
 
186
 
        tree2.commit('unchanged', rev_id='b4')
187
 
        wt.branch.fetch(tree2.branch)
188
 
        wt.set_pending_merges(['b4'])
189
 
 
190
 
        self.assertEqual(['a3', 'b4'], wt.get_parent_ids())
191
 
 
192
 
        os.chdir('tree')
193
 
        out, err = self.run_bzr('uncommit --force -r 2')
194
 
 
195
 
        self.assertEqual(['a2', 'b3', 'b4'], wt.get_parent_ids())
 
161
        self.assertEqual('a4', wt.last_revision())
 
162
        self.assertEqual([], wt.pending_merges())
 
163
 
 
164
        os.chdir('tree')
 
165
        out, err = self.run_bzr('uncommit', '--force', '-r', '2')
 
166
 
 
167
        self.assertEqual('a2', wt.last_revision())
 
168
        self.assertEqual(['b3', 'b4'], wt.pending_merges())
196
169
 
197
170
    def test_uncommit_octopus_merge(self):
198
171
        # Check that uncommit keeps the pending merges in the same order
203
176
 
204
177
        tree2.commit('unchanged', rev_id='b3')
205
178
        tree3.commit('unchanged', rev_id='c3')
206
 
        
207
 
        wt.merge_from_branch(tree2.branch)
208
 
        wt.merge_from_branch(tree3.branch)
 
179
        wt.branch.fetch(tree2.branch)
 
180
        wt.branch.fetch(tree3.branch)
 
181
        wt.set_pending_merges(['b3', 'c3'])
209
182
        wt.commit('merge b3, c3', rev_id='a3')
210
183
 
211
184
        tree2.commit('unchanged', rev_id='b4')
212
185
        tree3.commit('unchanged', rev_id='c4')
213
 
 
214
 
        wt.merge_from_branch(tree3.branch)
215
 
        wt.merge_from_branch(tree2.branch)
 
186
        wt.branch.fetch(tree2.branch)
 
187
        wt.branch.fetch(tree3.branch)
 
188
        wt.set_pending_merges(['c4', 'b4'])
216
189
        wt.commit('merge b4, c4', rev_id='a4')
217
190
 
218
 
        self.assertEqual(['a4'], wt.get_parent_ids())
 
191
        self.assertEqual('a4', wt.last_revision())
 
192
        self.assertEqual([], wt.pending_merges())
219
193
 
220
194
        os.chdir('tree')
221
 
        out, err = self.run_bzr('uncommit --force -r 2')
 
195
        out, err = self.run_bzr('uncommit', '--force', '-r', '2')
222
196
 
223
 
        self.assertEqual(['a2', 'b3', 'c3', 'c4', 'b4'], wt.get_parent_ids())
 
197
        self.assertEqual('a2', wt.last_revision())
 
198
        self.assertEqual(['b3', 'c3', 'c4', 'b4'], wt.pending_merges())