/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

  • Committer: Robert Collins
  • Date: 2008-04-04 00:43:07 UTC
  • mfrom: (3331 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3333.
  • Revision ID: robertc@robertcollins.net-20080404004307-0whomfhm3yal2rvw
Resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/interversionedfile_implementations/test_join.py
96
96
                         'v-1 v-2 v-3'.split())
97
97
        self.assertEqualDiff(w1.get_text('v-3'),
98
98
                'line 1\n')
99
 
        self.assertEqual(sorted(w1.get_parents('v-3')),
100
 
                ['v-1'])
 
99
        self.assertEqual({'v-3':('v-1',)}, w1.get_parent_map(['v-3']))
101
100
        ann = list(w1.annotate('v-3'))
102
101
        self.assertEqual(len(ann), 1)
103
102
        self.assertEqual(ann[0][0], 'v-1')
122
121
    def verify_weave1(self, w1):
123
122
        self.assertEqual(sorted(w1.versions()), ['v1', 'v2', 'v3'])
124
123
        self.assertEqual(w1.get_lines('v1'), ['hello\n'])
125
 
        self.assertEqual([], w1.get_parents('v1'))
 
124
        self.assertEqual({'v1':()}, w1.get_parent_map(['v1']))
126
125
        self.assertEqual(w1.get_lines('v2'), ['hello\n', 'world\n'])
127
 
        self.assertEqual(['v1'], w1.get_parents('v2'))
 
126
        self.assertEqual({'v2':('v1',)}, w1.get_parent_map(['v2']))
128
127
        self.assertEqual(w1.get_lines('v3'), ['hello\n', 'cruel\n', 'world\n'])
129
 
        self.assertEqual(['v2'], w1.get_parents('v3'))
 
128
        self.assertEqual({'v3':('v2',)}, w1.get_parent_map(['v3']))
130
129
 
131
130
    def test_join_source_has_less_parents_preserves_parents(self):
132
131
        # when the target has a text with more parent info, join 
138
137
        t.add_lines('base', [], [])
139
138
        t.add_lines('text', ['base'], [])
140
139
        t.join(s)
141
 
        self.assertEqual(['base'], t.get_parents('text'))
 
140
        self.assertEqual({'text':('base',)}, t.get_parent_map(['text']))
142
141
 
143
142
    def test_join_with_ghosts(self):
144
143
        """Join that inserts parents of an existing revision.
167
166
        self.assertEqual(['v1', 'v2', 'v3', 'x1',], sorted(w1.versions()))
168
167
        self.assertEqual('line from x1\n', w1.get_text('x1'))
169
168
        self.assertEqual(['hello\n', 'world\n'], w1.get_lines('v2'))
170
 
        self.assertEqual(['v1'], w1.get_parents('v2'))
 
169
        self.assertEqual({'v2':('v1',)}, w1.get_parent_map(['v2']))
171
170
 
172
171
    def test_join_with_ignore_missing_versions(self):
173
172
        # test that ignore_missing=True makes a listed but absent version id
182
181
        eq(sorted(w1.versions()), ['v1', 'v2', 'v3', 'x1'])
183
182
        eq(w1.get_text('x1'), 'line from x1\n')
184
183
        eq(w1.get_lines('v2'), ['hello\n', 'world\n'])
185
 
        eq(w1.get_parents('v2'), ['v1'])
 
184
        self.assertEqual({'v2':('v1',)}, w1.get_parent_map(['v2']))
186
185
    
187
186
    def build_source_weave(self, name, *pattern):
188
187
        w = self.get_source(name)
206
205
        # does not must discard it, and when filling a ghost for a listed
207
206
        # ghost must reconcile it
208
207
        source = self.get_source()
209
 
        try:
210
 
            source.has_ghost('a')
211
 
            source_ghosts = True
212
 
        except NotImplementedError:
213
 
            source_ghosts = False
214
208
        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
209
        # try filling target with ghosts and filling in reverse -  
234
 
        target.add_lines_with_ghosts('notbase', ['base'], [])
235
 
        source.join(target)
 
210
        try:
 
211
            target.add_lines_with_ghosts('notbase', ['base'], [])
 
212
        except NotImplementedError:
 
213
            # The target does not support ghosts; the test is irrelevant.
 
214
            return
 
215
        try:
 
216
            source.join(target)
 
217
        except errors.RevisionNotPresent:
 
218
            return
236
219
        # legacy apis should behave
237
220
        self.assertEqual(['notbase'], source.get_ancestry(['notbase']))
238
 
        self.assertEqual([], source.get_parents('notbase'))
239
 
        self.assertEqual({'notbase':()}, source.get_graph())
240
221
        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'))
 
222
        # ghost data should have been preserved
 
223
        self.assertEqual(['base', 'notbase'], source.get_ancestry_with_ghosts(['notbase']))
 
224
        self.assertEqual(['base'], source.get_parents_with_ghosts('notbase'))
 
225
        self.assertEqual({'notbase':('base',)},
 
226
            source.get_parent_map(source.versions()))
247
227
 
248
228
        # if we add something that is fills out what is a ghost, then 
249
229
        # when joining into a ghost aware join it should flesh out the ghosts.
250
230
        source.add_lines('base', [], [])
251
 
        target.join(source, version_ids=['base']) 
 
231
        target.join(source, version_ids=['base'])
252
232
        self.assertEqual(['base', 'notbase'], target.get_ancestry(['notbase']))
253
 
        self.assertEqual(['base'], target.get_parents('notbase'))
254
233
        self.assertEqual({'base':(),
255
234
                          'notbase':('base', ),
256
235
                          },
257
 
                         target.get_graph())
 
236
                         target.get_parent_map(target.versions()))
258
237
        self.assertTrue(target.has_version('base'))
259
238
        # we have _with_ghost apis to give us ghost information.
260
239
        self.assertEqual(['base', 'notbase'], target.get_ancestry_with_ghosts(['notbase']))
261
240
        self.assertEqual(['base'], target.get_parents_with_ghosts('notbase'))
262
 
        self.assertEqual({'base':[],
263
 
                          'notbase':['base'],
 
241
        self.assertEqual({'base':(),
 
242
                          'notbase':('base',),
264
243
                          },
265
 
                         target.get_graph_with_ghosts())
266
 
        self.assertFalse(target.has_ghost('base'))
 
244
            source.get_parent_map(source.versions()))
267
245
 
268
246
    def test_restricted_join_into_empty(self):
269
247
        # joining into an empty versioned file with a version_ids list