/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/interversionedfile_implementations/test_join.py

Merge bzr.dev r3466

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/interversionedfile_implementations/test_join.py
18
18
 
19
19
 
20
20
import bzrlib.errors as errors
 
21
from bzrlib.symbol_versioning import one_five
21
22
from bzrlib.tests import TestCaseWithTransport
22
23
from bzrlib.transport import get_transport
23
24
import bzrlib.versionedfile as versionedfile
44
45
        f1.add_lines('r0', [], ['a\n', 'b\n'])
45
46
        f1.add_lines('r1', ['r0'], ['c\n', 'b\n'])
46
47
        f2 = self.get_target()
47
 
        f2.join(f1, None)
 
48
        self.applyDeprecated(one_five, f2.join, f1, None)
48
49
        def verify_file(f):
49
50
            self.assertTrue(f.has_version('r0'))
50
51
            self.assertTrue(f.has_version('r1'))
52
53
        verify_file(self.get_target())
53
54
 
54
55
        self.assertRaises(errors.RevisionNotPresent,
55
 
            f2.join, f1, version_ids=['r3'])
 
56
            self.applyDeprecated, one_five, f2.join, f1, version_ids=['r3'])
56
57
 
57
58
    def test_gets_expected_inter_worker(self):
58
59
        source = self.get_source()
72
73
        source.add_lines('ancestorright', ['base'], [])
73
74
        source.add_lines('namedleft', ['ancestorleft'], [])
74
75
        source.add_lines('namedright', ['ancestorright'], [])
75
 
        target.join(source, version_ids=['namedleft', 'namedright'])
 
76
        self.applyDeprecated(one_five, target.join, source,
 
77
            version_ids=['namedleft', 'namedright'])
76
78
        self.assertFalse(target.has_version('sibling'))
77
79
        self.assertTrue(target.has_version('ancestorleft'))
78
80
        self.assertTrue(target.has_version('ancestorright'))
88
90
        w1.add_lines('v-3', ['v-1'], ['line 1\n'])
89
91
        w2.add_lines('v-3', ['v-2'], ['line 1\n'])
90
92
        try:
91
 
            w1.join(w2)
 
93
            self.applyDeprecated(one_five, w1.join, w2)
92
94
        except errors.WeaveParentMismatch:
93
95
            # Acceptable behaviour:
94
96
            return
96
98
                         'v-1 v-2 v-3'.split())
97
99
        self.assertEqualDiff(w1.get_text('v-3'),
98
100
                'line 1\n')
99
 
        self.assertEqual(sorted(w1.get_parents('v-3')),
100
 
                ['v-1'])
 
101
        self.assertEqual({'v-3':('v-1',)}, w1.get_parent_map(['v-3']))
101
102
        ann = list(w1.annotate('v-3'))
102
103
        self.assertEqual(len(ann), 1)
103
104
        self.assertEqual(ann[0][0], 'v-1')
116
117
        """Reweave adding empty weave"""
117
118
        wb = self.get_target()
118
119
        w1 = self.build_weave1()
119
 
        w1.join(wb)
 
120
        self.applyDeprecated(one_five, w1.join, wb)
120
121
        self.verify_weave1(w1)
121
122
 
122
123
    def verify_weave1(self, w1):
123
124
        self.assertEqual(sorted(w1.versions()), ['v1', 'v2', 'v3'])
124
125
        self.assertEqual(w1.get_lines('v1'), ['hello\n'])
125
 
        self.assertEqual([], w1.get_parents('v1'))
 
126
        self.assertEqual({'v1':()}, w1.get_parent_map(['v1']))
126
127
        self.assertEqual(w1.get_lines('v2'), ['hello\n', 'world\n'])
127
 
        self.assertEqual(['v1'], w1.get_parents('v2'))
 
128
        self.assertEqual({'v2':('v1',)}, w1.get_parent_map(['v2']))
128
129
        self.assertEqual(w1.get_lines('v3'), ['hello\n', 'cruel\n', 'world\n'])
129
 
        self.assertEqual(['v2'], w1.get_parents('v3'))
 
130
        self.assertEqual({'v3':('v2',)}, w1.get_parent_map(['v3']))
130
131
 
131
132
    def test_join_source_has_less_parents_preserves_parents(self):
132
133
        # when the target has a text with more parent info, join 
137
138
        t = self.get_target()
138
139
        t.add_lines('base', [], [])
139
140
        t.add_lines('text', ['base'], [])
140
 
        t.join(s)
141
 
        self.assertEqual(['base'], t.get_parents('text'))
 
141
        self.applyDeprecated(one_five, t.join, s)
 
142
        self.assertEqual({'text':('base',)}, t.get_parent_map(['text']))
142
143
 
143
144
    def test_join_with_ghosts(self):
144
145
        """Join that inserts parents of an existing revision.
160
161
        wb.add_lines('v1', [], ['hello\n'])
161
162
        wb.add_lines('v2', ['v1', 'x1'], ['hello\n', 'world\n'])
162
163
        try:
163
 
            w1.join(wb)
 
164
            self.applyDeprecated(one_five, w1.join, wb)
164
165
        except errors.WeaveParentMismatch:
165
166
            # Acceptable behaviour:
166
167
            return
167
168
        self.assertEqual(['v1', 'v2', 'v3', 'x1',], sorted(w1.versions()))
168
169
        self.assertEqual('line from x1\n', w1.get_text('x1'))
169
170
        self.assertEqual(['hello\n', 'world\n'], w1.get_lines('v2'))
170
 
        self.assertEqual(['v1'], w1.get_parents('v2'))
 
171
        self.assertEqual({'v2':('v1',)}, w1.get_parent_map(['v2']))
171
172
 
172
173
    def test_join_with_ignore_missing_versions(self):
173
174
        # test that ignore_missing=True makes a listed but absent version id
177
178
        wb.add_lines('x1', [], ['line from x1\n'])
178
179
        wb.add_lines('v1', [], ['hello\n'])
179
180
        wb.add_lines('v2', ['v1', 'x1'], ['hello\n', 'world\n'])
180
 
        w1.join(wb, version_ids=['x1', 'z1'], ignore_missing=True)
 
181
        self.applyDeprecated(one_five, w1.join, wb, version_ids=['x1', 'z1'],
 
182
            ignore_missing=True)
181
183
        eq = self.assertEquals
182
184
        eq(sorted(w1.versions()), ['v1', 'v2', 'v3', 'x1'])
183
185
        eq(w1.get_text('x1'), 'line from x1\n')
184
186
        eq(w1.get_lines('v2'), ['hello\n', 'world\n'])
185
 
        eq(w1.get_parents('v2'), ['v1'])
 
187
        self.assertEqual({'v2':('v1',)}, w1.get_parent_map(['v2']))
186
188
    
187
189
    def build_source_weave(self, name, *pattern):
188
190
        w = self.get_source(name)
206
208
        # does not must discard it, and when filling a ghost for a listed
207
209
        # ghost must reconcile it
208
210
        source = self.get_source()
209
 
        try:
210
 
            source.has_ghost('a')
211
 
            source_ghosts = True
212
 
        except NotImplementedError:
213
 
            source_ghosts = False
214
211
        target = self.get_target()
215
 
        try:
216
 
            target.has_ghost('a')
217
 
            target_ghosts = True
218
 
        except NotImplementedError:
219
 
            target_ghosts = False
220
 
 
221
 
        if not source_ghosts and not target_ghosts:
222
 
            # nothing to do
223
 
            return
224
 
        if source_ghosts and not target_ghosts:
225
 
            # switch source and target so source is ghostless
226
 
            t = source
227
 
            source = target
228
 
            target = t
229
 
            source_ghosts = False
230
 
            target_ghosts = True
231
 
        # now target always supports ghosts.
232
 
 
233
212
        # try filling target with ghosts and filling in reverse -  
234
 
        target.add_lines_with_ghosts('notbase', ['base'], [])
235
 
        source.join(target)
 
213
        try:
 
214
            target.add_lines_with_ghosts('notbase', ['base'], [])
 
215
        except NotImplementedError:
 
216
            # The target does not support ghosts; the test is irrelevant.
 
217
            return
 
218
        try:
 
219
            self.applyDeprecated(one_five, source.join, target)
 
220
        except errors.RevisionNotPresent:
 
221
            return
236
222
        # legacy apis should behave
237
223
        self.assertEqual(['notbase'], source.get_ancestry(['notbase']))
238
 
        self.assertEqual([], source.get_parents('notbase'))
239
 
        self.assertEqual({'notbase':()}, source.get_graph())
240
224
        self.assertFalse(source.has_version('base'))
241
 
        if source_ghosts:
242
 
            # ghost data should have been preserved
243
 
            self.assertEqual(['base', 'notbase'], source.get_ancestry_with_ghosts(['notbase']))
244
 
            self.assertEqual(['base'], source.get_parents_with_ghosts('notbase'))
245
 
            self.assertEqual({'notbase':['base']}, source.get_graph_with_ghosts())
246
 
            self.assertTrue(source.has_ghost('base'))
 
225
        # ghost data should have been preserved
 
226
        self.assertEqual(['base', 'notbase'], source.get_ancestry_with_ghosts(['notbase']))
 
227
        self.assertEqual(['base'], source.get_parents_with_ghosts('notbase'))
 
228
        self.assertEqual({'notbase':('base',)},
 
229
            source.get_parent_map(source.versions()))
247
230
 
248
231
        # if we add something that is fills out what is a ghost, then 
249
232
        # when joining into a ghost aware join it should flesh out the ghosts.
250
233
        source.add_lines('base', [], [])
251
 
        target.join(source, version_ids=['base']) 
 
234
        self.applyDeprecated(one_five, target.join, source, version_ids=['base'])
252
235
        self.assertEqual(['base', 'notbase'], target.get_ancestry(['notbase']))
253
 
        self.assertEqual(['base'], target.get_parents('notbase'))
254
236
        self.assertEqual({'base':(),
255
237
                          'notbase':('base', ),
256
238
                          },
257
 
                         target.get_graph())
 
239
                         target.get_parent_map(target.versions()))
258
240
        self.assertTrue(target.has_version('base'))
259
241
        # we have _with_ghost apis to give us ghost information.
260
242
        self.assertEqual(['base', 'notbase'], target.get_ancestry_with_ghosts(['notbase']))
261
243
        self.assertEqual(['base'], target.get_parents_with_ghosts('notbase'))
262
 
        self.assertEqual({'base':[],
263
 
                          'notbase':['base'],
 
244
        self.assertEqual({'base':(),
 
245
                          'notbase':('base',),
264
246
                          },
265
 
                         target.get_graph_with_ghosts())
266
 
        self.assertFalse(target.has_ghost('base'))
 
247
            source.get_parent_map(source.versions()))
267
248
 
268
249
    def test_restricted_join_into_empty(self):
269
250
        # joining into an empty versioned file with a version_ids list
273
254
        source.add_lines('inherit_me', [], ['b\n'])
274
255
        source.add_lines('select_me', ['inherit_me'], ['b\n'])
275
256
        target = self.get_target()
276
 
        target.join(source, version_ids=['select_me'])
 
257
        self.applyDeprecated(one_five, target.join, source, version_ids=['select_me'])
277
258
        self.assertEqual(['inherit_me', 'select_me'], target.versions())
278
259
 
279
260
    def test_join_odd_records(self):
289
270
        source.add_lines('4', ['2'], ['1st\n'])
290
271
        source.add_lines('5', ['3'], ['1st\n', '2nd\n', '3rd\n'])
291
272
        target = self.get_target()
292
 
        target.join(source, version_ids=['1', '3', '5'])
 
273
        self.applyDeprecated(one_five, target.join, source, version_ids=['1', '3', '5'])
293
274
        target = self.get_target(create=False)
294
275
        self.assertEqual(set(['1', '3', '5']), set(target.versions()))
295
276
        self.assertEqual(3, len(target.versions()))