/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/test_versionedfile.py

  • Committer: Martin Pool
  • Date: 2007-09-14 06:31:28 UTC
  • mfrom: (2822 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2823.
  • Revision ID: mbp@sourcefrog.net-20070914063128-0p7mh6zfb4pzdg9p
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_versionedfile.py
34
34
                           RevisionAlreadyPresent,
35
35
                           WeaveParentMismatch
36
36
                           )
37
 
from bzrlib.knit import KnitVersionedFile, \
38
 
     KnitAnnotateFactory
39
 
from bzrlib.tests import TestCaseWithTransport
 
37
from bzrlib.knit import (
 
38
    KnitVersionedFile,
 
39
    KnitAnnotateFactory,
 
40
    KnitPlainFactory,
 
41
    )
 
42
from bzrlib.tests import TestCaseWithMemoryTransport, TestSkipped
40
43
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
41
44
from bzrlib.trace import mutter
42
45
from bzrlib.transport import get_transport
81
84
    def test_adds_with_parent_texts(self):
82
85
        f = self.get_file()
83
86
        parent_texts = {}
84
 
        parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
 
87
        _, _, parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
85
88
        try:
86
 
            parent_texts['r1'] = f.add_lines_with_ghosts('r1',
87
 
                                                         ['r0', 'ghost'], 
88
 
                                                         ['b\n', 'c\n'],
89
 
                                                         parent_texts=parent_texts)
 
89
            _, _, parent_texts['r1'] = f.add_lines_with_ghosts('r1',
 
90
                ['r0', 'ghost'], ['b\n', 'c\n'], parent_texts=parent_texts)
90
91
        except NotImplementedError:
91
92
            # if the format doesn't support ghosts, just add normally.
92
 
            parent_texts['r1'] = f.add_lines('r1',
93
 
                                             ['r0'], 
94
 
                                             ['b\n', 'c\n'],
95
 
                                             parent_texts=parent_texts)
 
93
            _, _, parent_texts['r1'] = f.add_lines('r1',
 
94
                ['r0'], ['b\n', 'c\n'], parent_texts=parent_texts)
96
95
        f.add_lines('r2', ['r1'], ['c\n', 'd\n'], parent_texts=parent_texts)
97
96
        self.assertNotEqual(None, parent_texts['r0'])
98
97
        self.assertNotEqual(None, parent_texts['r1'])
126
125
            (errors.BzrBadParameterUnicode, NotImplementedError),
127
126
            vf.add_lines_with_ghosts, 'a', [], ['a\n', u'b\n', 'c\n'])
128
127
 
 
128
    def test_add_follows_left_matching_blocks(self):
 
129
        """If we change left_matching_blocks, delta changes
 
130
 
 
131
        Note: There are multiple correct deltas in this case, because
 
132
        we start with 1 "a" and we get 3.
 
133
        """
 
134
        vf = self.get_file()
 
135
        if isinstance(vf, WeaveFile):
 
136
            raise TestSkipped("WeaveFile ignores left_matching_blocks")
 
137
        vf.add_lines('1', [], ['a\n'])
 
138
        vf.add_lines('2', ['1'], ['a\n', 'a\n', 'a\n'],
 
139
                     left_matching_blocks=[(0, 0, 1), (1, 3, 0)])
 
140
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('2'))
 
141
        vf.add_lines('3', ['1'], ['a\n', 'a\n', 'a\n'],
 
142
                     left_matching_blocks=[(0, 2, 1), (1, 3, 0)])
 
143
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('3'))
 
144
 
129
145
    def test_inline_newline_throws(self):
130
146
        # \r characters are not permitted in lines being added
131
147
        vf = self.get_file()
146
162
        self.assertRaises(errors.ReservedId,
147
163
            vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
148
164
 
149
 
        self.assertRaises(errors.ReservedId,
150
 
            vf.add_delta, 'a:', [], None, 'sha1', False, ((0, 0, 0, []),))
 
165
    def test_add_lines_nostoresha(self):
 
166
        """When nostore_sha is supplied using old content raises."""
 
167
        vf = self.get_file()
 
168
        empty_text = ('a', [])
 
169
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
170
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
171
        shas = []
 
172
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
173
            sha, _, _ = vf.add_lines(version, [], lines)
 
174
            shas.append(sha)
 
175
        # we now have a copy of all the lines in the vf.
 
176
        for sha, (version, lines) in zip(
 
177
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
178
            self.assertRaises(errors.ExistingContent,
 
179
                vf.add_lines, version + "2", [], lines,
 
180
                nostore_sha=sha)
 
181
            # and no new version should have been added.
 
182
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
 
183
                version + "2")
 
184
 
 
185
    def test_add_lines_with_ghosts_nostoresha(self):
 
186
        """When nostore_sha is supplied using old content raises."""
 
187
        vf = self.get_file()
 
188
        empty_text = ('a', [])
 
189
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
190
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
191
        shas = []
 
192
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
193
            sha, _, _ = vf.add_lines(version, [], lines)
 
194
            shas.append(sha)
 
195
        # we now have a copy of all the lines in the vf.
 
196
        # is the test applicable to this vf implementation?
 
197
        try:
 
198
            vf.add_lines_with_ghosts('d', [], [])
 
199
        except NotImplementedError:
 
200
            raise TestSkipped("add_lines_with_ghosts is optional")
 
201
        for sha, (version, lines) in zip(
 
202
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
203
            self.assertRaises(errors.ExistingContent,
 
204
                vf.add_lines_with_ghosts, version + "2", [], lines,
 
205
                nostore_sha=sha)
 
206
            # and no new version should have been added.
 
207
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
 
208
                version + "2")
 
209
 
 
210
    def test_add_lines_return_value(self):
 
211
        # add_lines should return the sha1 and the text size.
 
212
        vf = self.get_file()
 
213
        empty_text = ('a', [])
 
214
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
215
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
216
        # check results for the three cases:
 
217
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
218
            # the first two elements are the same for all versioned files:
 
219
            # - the digest and the size of the text. For some versioned files
 
220
            #   additional data is returned in additional tuple elements.
 
221
            result = vf.add_lines(version, [], lines)
 
222
            self.assertEqual(3, len(result))
 
223
            self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
 
224
                result[0:2])
 
225
        # parents should not affect the result:
 
226
        lines = sample_text_nl[1]
 
227
        self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
 
228
            vf.add_lines('d', ['b', 'c'], lines)[0:2])
151
229
 
152
230
    def test_get_reserved(self):
153
231
        vf = self.get_file()
154
 
        self.assertRaises(errors.ReservedId, vf.get_delta, 'b:')
155
232
        self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
156
233
        self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
157
234
        self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
158
235
 
159
 
    def test_get_delta(self):
160
 
        f = self.get_file()
161
 
        sha1s = self._setup_for_deltas(f)
162
 
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
163
 
                          [(0, 0, 1, [('base', 'line\n')])])
164
 
        self.assertEqual(expected_delta, f.get_delta('base'))
165
 
        next_parent = 'base'
166
 
        text_name = 'chain1-'
167
 
        for depth in range(26):
168
 
            new_version = text_name + '%s' % depth
169
 
            expected_delta = (next_parent, sha1s[depth], 
170
 
                              False,
171
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
172
 
            self.assertEqual(expected_delta, f.get_delta(new_version))
173
 
            next_parent = new_version
174
 
        next_parent = 'base'
175
 
        text_name = 'chain2-'
176
 
        for depth in range(26):
177
 
            new_version = text_name + '%s' % depth
178
 
            expected_delta = (next_parent, sha1s[depth], False,
179
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
180
 
            self.assertEqual(expected_delta, f.get_delta(new_version))
181
 
            next_parent = new_version
182
 
        # smoke test for eol support
183
 
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
184
 
        self.assertEqual(['line'], f.get_lines('noeol'))
185
 
        self.assertEqual(expected_delta, f.get_delta('noeol'))
186
 
 
187
 
    def test_get_deltas(self):
188
 
        f = self.get_file()
189
 
        sha1s = self._setup_for_deltas(f)
190
 
        deltas = f.get_deltas(f.versions())
191
 
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
192
 
                          [(0, 0, 1, [('base', 'line\n')])])
193
 
        self.assertEqual(expected_delta, deltas['base'])
194
 
        next_parent = 'base'
195
 
        text_name = 'chain1-'
196
 
        for depth in range(26):
197
 
            new_version = text_name + '%s' % depth
198
 
            expected_delta = (next_parent, sha1s[depth], 
199
 
                              False,
200
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
201
 
            self.assertEqual(expected_delta, deltas[new_version])
202
 
            next_parent = new_version
203
 
        next_parent = 'base'
204
 
        text_name = 'chain2-'
205
 
        for depth in range(26):
206
 
            new_version = text_name + '%s' % depth
207
 
            expected_delta = (next_parent, sha1s[depth], False,
208
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
209
 
            self.assertEqual(expected_delta, deltas[new_version])
210
 
            next_parent = new_version
211
 
        # smoke tests for eol support
212
 
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
213
 
        self.assertEqual(['line'], f.get_lines('noeol'))
214
 
        self.assertEqual(expected_delta, deltas['noeol'])
215
 
        # smoke tests for eol support - two noeol in a row same content
216
 
        expected_deltas = (('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
217
 
                          [(0, 1, 2, [('noeolsecond', 'line\n'), ('noeolsecond', 'line\n')])]),
218
 
                          ('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
219
 
                           [(0, 0, 1, [('noeolsecond', 'line\n')]), (1, 1, 0, [])]))
220
 
        self.assertEqual(['line\n', 'line'], f.get_lines('noeolsecond'))
221
 
        self.assertTrue(deltas['noeolsecond'] in expected_deltas)
222
 
        # two no-eol in a row, different content
223
 
        expected_delta = ('noeolsecond', '8bb553a84e019ef1149db082d65f3133b195223b', True, 
224
 
                          [(1, 2, 1, [('noeolnotshared', 'phone\n')])])
225
 
        self.assertEqual(['line\n', 'phone'], f.get_lines('noeolnotshared'))
226
 
        self.assertEqual(expected_delta, deltas['noeolnotshared'])
227
 
        # eol folling a no-eol with content change
228
 
        expected_delta = ('noeol', 'a61f6fb6cfc4596e8d88c34a308d1e724caf8977', False, 
229
 
                          [(0, 1, 1, [('eol', 'phone\n')])])
230
 
        self.assertEqual(['phone\n'], f.get_lines('eol'))
231
 
        self.assertEqual(expected_delta, deltas['eol'])
232
 
        # eol folling a no-eol with content change
233
 
        expected_delta = ('noeol', '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
234
 
                          [(0, 1, 1, [('eolline', 'line\n')])])
235
 
        self.assertEqual(['line\n'], f.get_lines('eolline'))
236
 
        self.assertEqual(expected_delta, deltas['eolline'])
237
 
        # eol with no parents
238
 
        expected_delta = (None, '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, 
239
 
                          [(0, 0, 1, [('noeolbase', 'line\n')])])
240
 
        self.assertEqual(['line'], f.get_lines('noeolbase'))
241
 
        self.assertEqual(expected_delta, deltas['noeolbase'])
242
 
        # eol with two parents, in inverse insertion order
243
 
        expected_deltas = (('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
244
 
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]),
245
 
                           ('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
246
 
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]))
247
 
        self.assertEqual(['line'], f.get_lines('eolbeforefirstparent'))
248
 
        #self.assertTrue(deltas['eolbeforefirstparent'] in expected_deltas)
 
236
    def test_make_mpdiffs(self):
 
237
        from bzrlib import multiparent
 
238
        vf = self.get_file('foo')
 
239
        sha1s = self._setup_for_deltas(vf)
 
240
        new_vf = self.get_file('bar')
 
241
        for version in multiparent.topo_iter(vf):
 
242
            mpdiff = vf.make_mpdiffs([version])[0]
 
243
            new_vf.add_mpdiffs([(version, vf.get_parents(version),
 
244
                                 vf.get_sha1(version), mpdiff)])
 
245
            self.assertEqualDiff(vf.get_text(version),
 
246
                                 new_vf.get_text(version))
249
247
 
250
248
    def _setup_for_deltas(self, f):
251
 
        self.assertRaises(errors.RevisionNotPresent, f.get_delta, 'base')
 
249
        self.assertFalse(f.has_version('base'))
252
250
        # add texts that should trip the knit maximum delta chain threshold
253
251
        # as well as doing parallel chains of data in knits.
254
252
        # this is done by two chains of 25 insertions
317
315
            next_parent = new_version
318
316
        return sha1s
319
317
 
320
 
    def test_add_delta(self):
321
 
        # tests for the add-delta facility.
322
 
        # at this point, optimising for speed, we assume no checks when deltas are inserted.
323
 
        # this may need to be revisited.
324
 
        source = self.get_file('source')
325
 
        source.add_lines('base', [], ['line\n'])
326
 
        next_parent = 'base'
327
 
        text_name = 'chain1-'
328
 
        text = ['line\n']
329
 
        for depth in range(26):
330
 
            new_version = text_name + '%s' % depth
331
 
            text = text + ['line\n']
332
 
            source.add_lines(new_version, [next_parent], text)
333
 
            next_parent = new_version
334
 
        next_parent = 'base'
335
 
        text_name = 'chain2-'
336
 
        text = ['line\n']
337
 
        for depth in range(26):
338
 
            new_version = text_name + '%s' % depth
339
 
            text = text + ['line\n']
340
 
            source.add_lines(new_version, [next_parent], text)
341
 
            next_parent = new_version
342
 
        source.add_lines('noeol', ['base'], ['line'])
343
 
        
344
 
        target = self.get_file('target')
345
 
        for version in source.versions():
346
 
            parent, sha1, noeol, delta = source.get_delta(version)
347
 
            target.add_delta(version,
348
 
                             source.get_parents(version),
349
 
                             parent,
350
 
                             sha1,
351
 
                             noeol,
352
 
                             delta)
353
 
        self.assertRaises(RevisionAlreadyPresent,
354
 
                          target.add_delta, 'base', [], None, '', False, [])
355
 
        for version in source.versions():
356
 
            self.assertEqual(source.get_lines(version),
357
 
                             target.get_lines(version))
358
 
 
359
318
    def test_ancestry(self):
360
319
        f = self.get_file()
361
320
        self.assertEqual([], f.get_ancestry([]))
390
349
    def test_mutate_after_finish(self):
391
350
        f = self.get_file()
392
351
        f.transaction_finished()
393
 
        self.assertRaises(errors.OutSideTransaction, f.add_delta, '', [], '', '', False, [])
394
352
        self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
395
353
        self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
396
354
        self.assertRaises(errors.OutSideTransaction, f.fix_parents, '', [])
453
411
    def test_get_graph(self):
454
412
        f = self.get_file()
455
413
        graph = {
456
 
            'v1': [],
457
 
            'v2': ['v1'],
458
 
            'v3': ['v2']}
 
414
            'v1': (),
 
415
            'v2': ('v1', ),
 
416
            'v3': ('v2', )}
459
417
        self.build_graph(f, graph)
460
418
        self.assertEqual(graph, f.get_graph())
461
419
    
463
421
        f = self.get_file()
464
422
        complex_graph = {}
465
423
        simple_a = {
466
 
            'c': [],
467
 
            'b': ['c'],
468
 
            'a': ['b'],
 
424
            'c': (),
 
425
            'b': ('c', ),
 
426
            'a': ('b', ),
469
427
            }
470
428
        complex_graph.update(simple_a)
471
429
        simple_b = {
472
 
            'c': [],
473
 
            'b': ['c'],
 
430
            'c': (),
 
431
            'b': ('c', ),
474
432
            }
475
433
        complex_graph.update(simple_b)
476
434
        simple_gam = {
477
 
            'c': [],
478
 
            'oo': [],
479
 
            'bar': ['oo', 'c'],
480
 
            'gam': ['bar'],
 
435
            'c': (),
 
436
            'oo': (),
 
437
            'bar': ('oo', 'c'),
 
438
            'gam': ('bar', ),
481
439
            }
482
440
        complex_graph.update(simple_gam)
483
441
        simple_b_gam = {}
512
470
        self.assertRaises(RevisionNotPresent,
513
471
            f.annotate, 'foo')
514
472
 
515
 
    def test_walk(self):
516
 
        # tests that walk returns all the inclusions for the requested
517
 
        # revisions as well as the revisions changes themselves.
518
 
        f = self.get_file('1')
519
 
        f.add_lines('r0', [], ['a\n', 'b\n'])
520
 
        f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
521
 
        f.add_lines('rX', ['r1'], ['d\n', 'b\n'])
522
 
        f.add_lines('rY', ['r1'], ['c\n', 'e\n'])
523
 
 
524
 
        lines = {}
525
 
        for lineno, insert, dset, text in f.walk(['rX', 'rY']):
526
 
            lines[text] = (insert, dset)
527
 
 
528
 
        self.assertTrue(lines['a\n'], ('r0', set(['r1'])))
529
 
        self.assertTrue(lines['b\n'], ('r0', set(['rY'])))
530
 
        self.assertTrue(lines['c\n'], ('r1', set(['rX'])))
531
 
        self.assertTrue(lines['d\n'], ('rX', set([])))
532
 
        self.assertTrue(lines['e\n'], ('rY', set([])))
533
 
 
534
473
    def test_detection(self):
535
474
        # Test weaves detect corruption.
536
475
        #
560
499
        """Open the versioned file from disk again."""
561
500
        raise NotImplementedError(self.reopen_file)
562
501
 
 
502
    def test_iter_parents(self):
 
503
        """iter_parents returns the parents for many nodes."""
 
504
        f = self.get_file()
 
505
        # sample data:
 
506
        # no parents
 
507
        f.add_lines('r0', [], ['a\n', 'b\n'])
 
508
        # 1 parents
 
509
        f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
 
510
        # 2 parents
 
511
        f.add_lines('r2', ['r1', 'r0'], ['a\n', 'b\n'])
 
512
        # XXX TODO a ghost
 
513
        # cases: each sample data individually:
 
514
        self.assertEqual(set([('r0', ())]),
 
515
            set(f.iter_parents(['r0'])))
 
516
        self.assertEqual(set([('r1', ('r0', ))]),
 
517
            set(f.iter_parents(['r1'])))
 
518
        self.assertEqual(set([('r2', ('r1', 'r0'))]),
 
519
            set(f.iter_parents(['r2'])))
 
520
        # no nodes returned for a missing node
 
521
        self.assertEqual(set(),
 
522
            set(f.iter_parents(['missing'])))
 
523
        # 1 node returned with missing nodes skipped
 
524
        self.assertEqual(set([('r1', ('r0', ))]),
 
525
            set(f.iter_parents(['ghost1', 'r1', 'ghost'])))
 
526
        # 2 nodes returned
 
527
        self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
 
528
            set(f.iter_parents(['r0', 'r1'])))
 
529
        # 2 nodes returned, missing skipped
 
530
        self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
 
531
            set(f.iter_parents(['a', 'r0', 'b', 'r1', 'c'])))
 
532
 
563
533
    def test_iter_lines_added_or_present_in_versions(self):
564
534
        # test that we get at least an equalset of the lines added by
565
535
        # versions in the weave 
690
660
        # - these are ghost unaware and must not be reflect ghosts
691
661
        self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
692
662
        self.assertEqual([], vf.get_parents('notbxbfse'))
693
 
        self.assertEqual({'notbxbfse':[]}, vf.get_graph())
 
663
        self.assertEqual({'notbxbfse':()}, vf.get_graph())
694
664
        self.assertFalse(self.callDeprecated([osutils._revision_id_warning],
695
665
                         vf.has_version, parent_id_unicode))
696
666
        self.assertFalse(vf.has_version(parent_id_utf8))
707
677
                            vf.add_lines, parent_id_unicode, [], [])
708
678
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
709
679
        self.assertEqual([parent_id_utf8], vf.get_parents('notbxbfse'))
710
 
        self.assertEqual({parent_id_utf8:[],
711
 
                          'notbxbfse':[parent_id_utf8],
 
680
        self.assertEqual({parent_id_utf8:(),
 
681
                          'notbxbfse':(parent_id_utf8, ),
712
682
                          },
713
683
                         vf.get_graph())
714
684
        self.assertTrue(self.callDeprecated([osutils._revision_id_warning],
750
720
        factory = self.get_factory()
751
721
        vf = factory('id', transport, 0777, create=True, access_mode='w')
752
722
        vf = factory('id', transport, access_mode='r')
753
 
        self.assertRaises(errors.ReadOnlyError, vf.add_delta, '', [], '', '', False, [])
754
723
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
755
724
        self.assertRaises(errors.ReadOnlyError,
756
725
                          vf.add_lines_with_ghosts,
776
745
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('b'))
777
746
        self.assertEqual(
778
747
            '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8', vf.get_sha1('c'))
 
748
 
 
749
        self.assertEqual(['3f786850e387550fdab836ed7e6dc881de23001b',
 
750
                          '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
 
751
                          '3f786850e387550fdab836ed7e6dc881de23001b'],
 
752
                          vf.get_sha1s(['a', 'c', 'b']))
779
753
        
780
754
 
781
 
class TestWeave(TestCaseWithTransport, VersionedFileTestMixIn):
 
755
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
782
756
 
783
757
    def get_file(self, name='foo'):
784
758
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
830
804
        return WeaveFile
831
805
 
832
806
 
833
 
class TestKnit(TestCaseWithTransport, VersionedFileTestMixIn):
 
807
class TestKnit(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
834
808
 
835
809
    def get_file(self, name='foo'):
836
 
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
837
 
                                 delta=True, create=True)
 
810
        return self.get_factory()(name, get_transport(self.get_url('.')),
 
811
                                  delta=True, create=True)
838
812
 
839
813
    def get_factory(self):
840
814
        return KnitVersionedFile
846
820
        return knit
847
821
 
848
822
    def reopen_file(self, name='foo', create=False):
849
 
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
 
823
        return self.get_factory()(name, get_transport(self.get_url('.')),
850
824
            delta=True,
851
825
            create=create)
852
826
 
861
835
                          get_transport(self.get_url('.')))
862
836
 
863
837
 
 
838
class TestPlaintextKnit(TestKnit):
 
839
    """Test a knit with no cached annotations"""
 
840
 
 
841
    def _factory(self, name, transport, file_mode=None, access_mode=None,
 
842
                 delta=True, create=False):
 
843
        return KnitVersionedFile(name, transport, file_mode, access_mode,
 
844
                                 KnitPlainFactory(), delta=delta,
 
845
                                 create=create)
 
846
 
 
847
    def get_factory(self):
 
848
        return self._factory
 
849
 
 
850
 
864
851
class InterString(versionedfile.InterVersionedFile):
865
852
    """An inter-versionedfile optimised code path for strings.
866
853
 
879
866
# if we make the registry a separate class though we still need to 
880
867
# test the behaviour in the active registry to catch failure-to-handle-
881
868
# stange-objects
882
 
class TestInterVersionedFile(TestCaseWithTransport):
 
869
class TestInterVersionedFile(TestCaseWithMemoryTransport):
883
870
 
884
871
    def test_get_default_inter_versionedfile(self):
885
872
        # test that the InterVersionedFile.get(a, b) probes
1199
1186
        self._test_merge_from_strings(base, a, b, result)
1200
1187
 
1201
1188
 
1202
 
class TestKnitMerge(TestCaseWithTransport, MergeCasesMixin):
 
1189
class TestKnitMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1203
1190
 
1204
1191
    def get_file(self, name='foo'):
1205
1192
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
1209
1196
        pass
1210
1197
 
1211
1198
 
1212
 
class TestWeaveMerge(TestCaseWithTransport, MergeCasesMixin):
 
1199
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1213
1200
 
1214
1201
    def get_file(self, name='foo'):
1215
1202
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
1222
1209
 
1223
1210
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 
1224
1211
                                'xxx', '>>>>>>> ', 'bbb']
 
1212
 
 
1213
 
 
1214
class TestFormatSignatures(TestCaseWithMemoryTransport):
 
1215
 
 
1216
    def get_knit_file(self, name, annotated):
 
1217
        if annotated:
 
1218
            factory = KnitAnnotateFactory()
 
1219
        else:
 
1220
            factory = KnitPlainFactory()
 
1221
        return KnitVersionedFile(
 
1222
            name, get_transport(self.get_url('.')), create=True,
 
1223
            factory=factory)
 
1224
 
 
1225
    def test_knit_format_signatures(self):
 
1226
        """Different formats of knit have different signature strings."""
 
1227
        knit = self.get_knit_file('a', True)
 
1228
        self.assertEqual('knit-annotated', knit.get_format_signature())
 
1229
        knit = self.get_knit_file('p', False)
 
1230
        self.assertEqual('knit-plain', knit.get_format_signature())
 
1231