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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-22 00:56:52 UTC
  • mfrom: (6621.2.26 py3_pokes)
  • Revision ID: jelmer@jelmer.uk-20170522005652-yjahcr9hwmjkno7n
Merge Python3 porting work ('py3 pokes')

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_versionedfile.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
21
21
# TODO: might be nice to create a versionedfile with some type of corruption
22
22
# considered typical and check that it can be detected/corrected.
23
23
 
 
24
from gzip import GzipFile
24
25
from itertools import chain, izip
25
 
from StringIO import StringIO
26
26
 
27
 
from bzrlib import (
 
27
from .. import (
28
28
    errors,
29
29
    graph as _mod_graph,
30
30
    groupcompress,
31
31
    knit as _mod_knit,
32
32
    osutils,
33
33
    progress,
 
34
    transport,
34
35
    ui,
35
36
    )
36
 
from bzrlib.errors import (
 
37
from ..errors import (
37
38
                           RevisionNotPresent,
38
39
                           RevisionAlreadyPresent,
39
 
                           WeaveParentMismatch
40
40
                           )
41
 
from bzrlib.knit import (
 
41
from ..knit import (
42
42
    cleanup_pack_knit,
43
43
    make_file_factory,
44
44
    make_pack_factory,
45
 
    KnitAnnotateFactory,
46
 
    KnitPlainFactory,
47
 
    )
48
 
from bzrlib.tests import (
 
45
    )
 
46
from ..sixish import (
 
47
    BytesIO,
 
48
    )
 
49
from . import (
49
50
    TestCase,
50
51
    TestCaseWithMemoryTransport,
51
52
    TestNotApplicable,
52
53
    TestSkipped,
53
 
    condition_isinstance,
54
 
    split_suite_by_condition,
55
 
    multiply_tests,
56
54
    )
57
 
from bzrlib.tests.http_utils import TestCaseWithWebserver
58
 
from bzrlib.trace import mutter
59
 
from bzrlib.transport import get_transport
60
 
from bzrlib.transport.memory import MemoryTransport
61
 
from bzrlib.tsort import topo_sort
62
 
from bzrlib.tuned_gzip import GzipFile
63
 
import bzrlib.versionedfile as versionedfile
64
 
from bzrlib.versionedfile import (
 
55
from .http_utils import TestCaseWithWebserver
 
56
from ..transport.memory import MemoryTransport
 
57
from .. import versionedfile as versionedfile
 
58
from ..versionedfile import (
65
59
    ConstantMapper,
66
60
    HashEscapedPrefixMapper,
67
61
    PrefixMapper,
68
62
    VirtualVersionedFiles,
69
63
    make_versioned_files_factory,
70
64
    )
71
 
from bzrlib.weave import WeaveFile
72
 
from bzrlib.weavefile import read_weave, write_weave
73
 
 
74
 
 
75
 
def load_tests(standard_tests, module, loader):
76
 
    """Parameterize VersionedFiles tests for different implementations."""
77
 
    to_adapt, result = split_suite_by_condition(
78
 
        standard_tests, condition_isinstance(TestVersionedFiles))
79
 
    # We want to be sure of behaviour for:
80
 
    # weaves prefix layout (weave texts)
81
 
    # individually named weaves (weave inventories)
82
 
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
83
 
    #                   as it is the most complex mapper.
84
 
    # individually named knits
85
 
    # individual no-graph knits in packs (signatures)
86
 
    # individual graph knits in packs (inventories)
87
 
    # individual graph nocompression knits in packs (revisions)
88
 
    # plain text knits in packs (texts)
89
 
    len_one_scenarios = [
90
 
        ('weave-named', {
91
 
            'cleanup':None,
92
 
            'factory':make_versioned_files_factory(WeaveFile,
93
 
                ConstantMapper('inventory')),
94
 
            'graph':True,
95
 
            'key_length':1,
96
 
            'support_partial_insertion': False,
97
 
            }),
98
 
        ('named-knit', {
99
 
            'cleanup':None,
100
 
            'factory':make_file_factory(False, ConstantMapper('revisions')),
101
 
            'graph':True,
102
 
            'key_length':1,
103
 
            'support_partial_insertion': False,
104
 
            }),
105
 
        ('named-nograph-nodelta-knit-pack', {
106
 
            'cleanup':cleanup_pack_knit,
107
 
            'factory':make_pack_factory(False, False, 1),
108
 
            'graph':False,
109
 
            'key_length':1,
110
 
            'support_partial_insertion': False,
111
 
            }),
112
 
        ('named-graph-knit-pack', {
113
 
            'cleanup':cleanup_pack_knit,
114
 
            'factory':make_pack_factory(True, True, 1),
115
 
            'graph':True,
116
 
            'key_length':1,
117
 
            'support_partial_insertion': True,
118
 
            }),
119
 
        ('named-graph-nodelta-knit-pack', {
120
 
            'cleanup':cleanup_pack_knit,
121
 
            'factory':make_pack_factory(True, False, 1),
122
 
            'graph':True,
123
 
            'key_length':1,
124
 
            'support_partial_insertion': False,
125
 
            }),
126
 
        ('groupcompress-nograph', {
127
 
            'cleanup':groupcompress.cleanup_pack_group,
128
 
            'factory':groupcompress.make_pack_factory(False, False, 1),
129
 
            'graph': False,
130
 
            'key_length':1,
131
 
            'support_partial_insertion':False,
132
 
            }),
133
 
        ]
134
 
    len_two_scenarios = [
135
 
        ('weave-prefix', {
136
 
            'cleanup':None,
137
 
            'factory':make_versioned_files_factory(WeaveFile,
138
 
                PrefixMapper()),
139
 
            'graph':True,
140
 
            'key_length':2,
141
 
            'support_partial_insertion': False,
142
 
            }),
143
 
        ('annotated-knit-escape', {
144
 
            'cleanup':None,
145
 
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
146
 
            'graph':True,
147
 
            'key_length':2,
148
 
            'support_partial_insertion': False,
149
 
            }),
150
 
        ('plain-knit-pack', {
151
 
            'cleanup':cleanup_pack_knit,
152
 
            'factory':make_pack_factory(True, True, 2),
153
 
            'graph':True,
154
 
            'key_length':2,
155
 
            'support_partial_insertion': True,
156
 
            }),
157
 
        ('groupcompress', {
158
 
            'cleanup':groupcompress.cleanup_pack_group,
159
 
            'factory':groupcompress.make_pack_factory(True, False, 1),
160
 
            'graph': True,
161
 
            'key_length':1,
162
 
            'support_partial_insertion':False,
163
 
            }),
164
 
        ]
165
 
    scenarios = len_one_scenarios + len_two_scenarios
166
 
    return multiply_tests(to_adapt, scenarios, result)
 
65
from ..weave import WeaveFile
 
66
from ..weavefile import write_weave
 
67
from .scenarios import load_tests_apply_scenarios
 
68
 
 
69
 
 
70
load_tests = load_tests_apply_scenarios
167
71
 
168
72
 
169
73
def get_diamond_vf(f, trailing_eol=True, left_only=False):
280
184
            versions = f.versions()
281
185
            self.assertTrue('r0' in versions)
282
186
            self.assertTrue('r1' in versions)
283
 
            self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
284
 
            self.assertEquals(f.get_text('r0'), 'a\nb\n')
285
 
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
 
187
            self.assertEqual(f.get_lines('r0'), ['a\n', 'b\n'])
 
188
            self.assertEqual(f.get_text('r0'), 'a\nb\n')
 
189
            self.assertEqual(f.get_lines('r1'), ['b\n', 'c\n'])
286
190
            self.assertEqual(2, len(f))
287
191
            self.assertEqual(2, f.num_versions())
288
192
 
314
218
            self.assertTrue('r0' in versions)
315
219
            self.assertTrue('r1' in versions)
316
220
            self.assertTrue('r2' in versions)
317
 
            self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
318
 
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
319
 
            self.assertEquals(f.get_lines('r2'), ['c\n', 'd\n'])
 
221
            self.assertEqual(f.get_lines('r0'), ['a\n', 'b\n'])
 
222
            self.assertEqual(f.get_lines('r1'), ['b\n', 'c\n'])
 
223
            self.assertEqual(f.get_lines('r2'), ['c\n', 'd\n'])
320
224
            self.assertEqual(3, f.num_versions())
321
225
            origins = f.annotate('r1')
322
 
            self.assertEquals(origins[0][0], 'r0')
323
 
            self.assertEquals(origins[1][0], 'r1')
 
226
            self.assertEqual(origins[0][0], 'r0')
 
227
            self.assertEqual(origins[1][0], 'r1')
324
228
            origins = f.annotate('r2')
325
 
            self.assertEquals(origins[0][0], 'r1')
326
 
            self.assertEquals(origins[1][0], 'r2')
 
229
            self.assertEqual(origins[0][0], 'r1')
 
230
            self.assertEqual(origins[1][0], 'r2')
327
231
 
328
232
        verify_file(f)
329
233
        f = self.reopen_file()
503
407
 
504
408
    def test_add_lines_with_matching_blocks_noeol_last_line(self):
505
409
        """Add a text with an unchanged last line with no eol should work."""
506
 
        from bzrlib import multiparent
 
410
        from breezy import multiparent
507
411
        # Hand verified sha1 of the text we're adding.
508
412
        sha1 = '6a1d115ec7b60afb664dc14890b5af5ce3c827a4'
509
413
        # Create a mpdiff which adds a new line before the trailing line, and
524
428
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
525
429
 
526
430
    def test_make_mpdiffs(self):
527
 
        from bzrlib import multiparent
 
431
        from breezy import multiparent
528
432
        vf = self.get_file('foo')
529
433
        sha1s = self._setup_for_deltas(vf)
530
434
        new_vf = self.get_file('bar')
693
597
        f.add_lines('r0', [], ['a\n', 'b\n'])
694
598
        f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
695
599
        origins = f.annotate('r1')
696
 
        self.assertEquals(origins[0][0], 'r1')
697
 
        self.assertEquals(origins[1][0], 'r0')
 
600
        self.assertEqual(origins[0][0], 'r1')
 
601
        self.assertEqual(origins[1][0], 'r0')
698
602
 
699
603
        self.assertRaises(RevisionNotPresent,
700
604
            f.annotate, 'foo')
844
748
                                 ['base', 'a_ghost'],
845
749
                                 ['line\n', 'line_b\n', 'line_c\n'])
846
750
        origins = vf.annotate('references_ghost')
847
 
        self.assertEquals(('base', 'line\n'), origins[0])
848
 
        self.assertEquals(('base', 'line_b\n'), origins[1])
849
 
        self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
 
751
        self.assertEqual(('base', 'line\n'), origins[0])
 
752
        self.assertEqual(('base', 'line_b\n'), origins[1])
 
753
        self.assertEqual(('references_ghost', 'line_c\n'), origins[2])
850
754
 
851
755
    def test_readonly_mode(self):
852
 
        transport = get_transport(self.get_url('.'))
 
756
        t = self.get_transport()
853
757
        factory = self.get_factory()
854
 
        vf = factory('id', transport, 0777, create=True, access_mode='w')
855
 
        vf = factory('id', transport, access_mode='r')
 
758
        vf = factory('id', t, 0o777, create=True, access_mode='w')
 
759
        vf = factory('id', t, access_mode='r')
856
760
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
857
761
        self.assertRaises(errors.ReadOnlyError,
858
762
                          vf.add_lines_with_ghosts,
880
784
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
881
785
 
882
786
    def get_file(self, name='foo'):
883
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True,
884
 
            get_scope=self.get_transaction)
 
787
        return WeaveFile(name, self.get_transport(),
 
788
                         create=True,
 
789
                         get_scope=self.get_transaction)
885
790
 
886
791
    def get_file_corrupted_text(self):
887
 
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
888
 
            get_scope=self.get_transaction)
 
792
        w = WeaveFile('foo', self.get_transport(),
 
793
                      create=True,
 
794
                      get_scope=self.get_transaction)
889
795
        w.add_lines('v1', [], ['hello\n'])
890
796
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
891
797
 
919
825
        return w
920
826
 
921
827
    def reopen_file(self, name='foo', create=False):
922
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=create,
923
 
            get_scope=self.get_transaction)
 
828
        return WeaveFile(name, self.get_transport(),
 
829
                         create=create,
 
830
                         get_scope=self.get_transaction)
924
831
 
925
832
    def test_no_implicit_create(self):
926
833
        self.assertRaises(errors.NoSuchFile,
927
834
                          WeaveFile,
928
835
                          'foo',
929
 
                          get_transport(self.get_url('.')),
 
836
                          self.get_transport(),
930
837
                          get_scope=self.get_transaction)
931
838
 
932
839
    def get_factory(self):
936
843
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
937
844
 
938
845
    def setUp(self):
939
 
        TestCaseWithMemoryTransport.setUp(self)
 
846
        super(TestPlanMergeVersionedFile, self).setUp()
940
847
        mapper = PrefixMapper()
941
848
        factory = make_file_factory(True, mapper)
942
849
        self.vf1 = factory(self.get_transport('root-1'))
999
906
        # we should be able to read from http with a versioned file.
1000
907
        vf = self.get_file()
1001
908
        # try an empty file access
1002
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
909
        readonly_vf = self.get_factory()('foo',
 
910
            transport.get_transport_from_url(self.get_readonly_url('.')))
1003
911
        self.assertEqual([], readonly_vf.versions())
 
912
 
 
913
    def test_readonly_http_works_with_feeling(self):
 
914
        # we should be able to read from http with a versioned file.
 
915
        vf = self.get_file()
1004
916
        # now with feeling.
1005
917
        vf.add_lines('1', [], ['a\n'])
1006
918
        vf.add_lines('2', ['1'], ['b\n', 'a\n'])
1007
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
919
        readonly_vf = self.get_factory()('foo',
 
920
            transport.get_transport_from_url(self.get_readonly_url('.')))
1008
921
        self.assertEqual(['1', '2'], vf.versions())
 
922
        self.assertEqual(['1', '2'], readonly_vf.versions())
1009
923
        for version in readonly_vf.versions():
1010
924
            readonly_vf.get_lines(version)
1011
925
 
1013
927
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
1014
928
 
1015
929
    def get_file(self):
1016
 
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
1017
 
            get_scope=self.get_transaction)
 
930
        return WeaveFile('foo', self.get_transport(),
 
931
                         create=True,
 
932
                         get_scope=self.get_transaction)
1018
933
 
1019
934
    def get_factory(self):
1020
935
        return WeaveFile
1023
938
class MergeCasesMixin(object):
1024
939
 
1025
940
    def doMerge(self, base, a, b, mp):
1026
 
        from cStringIO import StringIO
1027
941
        from textwrap import dedent
1028
942
 
1029
943
        def addcrlf(x):
1043
957
                self.log('%12s | %s' % (state, line[:-1]))
1044
958
 
1045
959
        self.log('merge:')
1046
 
        mt = StringIO()
 
960
        mt = BytesIO()
1047
961
        mt.writelines(w.weave_merge(p))
1048
962
        mt.seek(0)
1049
963
        self.log(mt.getvalue())
1264
1178
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1265
1179
 
1266
1180
    def get_file(self, name='foo'):
1267
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
 
1181
        return WeaveFile(name, self.get_transport(),
 
1182
                         create=True)
1268
1183
 
1269
1184
    def log_contents(self, w):
1270
1185
        self.log('weave is:')
1271
 
        tmpf = StringIO()
 
1186
        tmpf = BytesIO()
1272
1187
        write_weave(w, tmpf)
1273
1188
        self.log(tmpf.getvalue())
1274
1189
 
1329
1244
            'version origin 1 b284f94827db1fa2970d9e2014f080413b547a7e\n'
1330
1245
            'origin\n'
1331
1246
            'end origin\n',
1332
 
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
 
1247
            GzipFile(mode='rb', fileobj=BytesIO(ft_data)).read())
1333
1248
        self.assertEqual(
1334
1249
            'version merged 4 32c2e79763b3f90e8ccde37f9710b6629c25a796\n'
1335
1250
            '1,2,3\nleft\nright\nmerged\nend merged\n',
1336
 
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
 
1251
            GzipFile(mode='rb', fileobj=BytesIO(delta_data)).read())
1337
1252
 
1338
1253
    def test_deannotation(self):
1339
1254
        """Test converting annotated knits to unannotated knits."""
1347
1262
            'version origin 1 00e364d235126be43292ab09cb4686cf703ddc17\n'
1348
1263
            'origin\n'
1349
1264
            'end origin\n',
1350
 
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
 
1265
            GzipFile(mode='rb', fileobj=BytesIO(ft_data)).read())
1351
1266
        self.assertEqual(
1352
1267
            'version merged 3 ed8bce375198ea62444dc71952b22cfc2b09226d\n'
1353
1268
            '2,2,2\nright\nmerged\nend merged\n',
1354
 
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
 
1269
            GzipFile(mode='rb', fileobj=BytesIO(delta_data)).read())
1355
1270
 
1356
1271
    def test_annotated_to_fulltext_no_eol(self):
1357
1272
        """Test adapting annotated knits to full texts (for -> weaves)."""
1463
1378
class TestVersionedFiles(TestCaseWithMemoryTransport):
1464
1379
    """Tests for the multiple-file variant of VersionedFile."""
1465
1380
 
 
1381
    # We want to be sure of behaviour for:
 
1382
    # weaves prefix layout (weave texts)
 
1383
    # individually named weaves (weave inventories)
 
1384
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
 
1385
    #                   as it is the most complex mapper.
 
1386
    # individually named knits
 
1387
    # individual no-graph knits in packs (signatures)
 
1388
    # individual graph knits in packs (inventories)
 
1389
    # individual graph nocompression knits in packs (revisions)
 
1390
    # plain text knits in packs (texts)
 
1391
    len_one_scenarios = [
 
1392
        ('weave-named', {
 
1393
            'cleanup':None,
 
1394
            'factory':make_versioned_files_factory(WeaveFile,
 
1395
                ConstantMapper('inventory')),
 
1396
            'graph':True,
 
1397
            'key_length':1,
 
1398
            'support_partial_insertion': False,
 
1399
            }),
 
1400
        ('named-knit', {
 
1401
            'cleanup':None,
 
1402
            'factory':make_file_factory(False, ConstantMapper('revisions')),
 
1403
            'graph':True,
 
1404
            'key_length':1,
 
1405
            'support_partial_insertion': False,
 
1406
            }),
 
1407
        ('named-nograph-nodelta-knit-pack', {
 
1408
            'cleanup':cleanup_pack_knit,
 
1409
            'factory':make_pack_factory(False, False, 1),
 
1410
            'graph':False,
 
1411
            'key_length':1,
 
1412
            'support_partial_insertion': False,
 
1413
            }),
 
1414
        ('named-graph-knit-pack', {
 
1415
            'cleanup':cleanup_pack_knit,
 
1416
            'factory':make_pack_factory(True, True, 1),
 
1417
            'graph':True,
 
1418
            'key_length':1,
 
1419
            'support_partial_insertion': True,
 
1420
            }),
 
1421
        ('named-graph-nodelta-knit-pack', {
 
1422
            'cleanup':cleanup_pack_knit,
 
1423
            'factory':make_pack_factory(True, False, 1),
 
1424
            'graph':True,
 
1425
            'key_length':1,
 
1426
            'support_partial_insertion': False,
 
1427
            }),
 
1428
        ('groupcompress-nograph', {
 
1429
            'cleanup':groupcompress.cleanup_pack_group,
 
1430
            'factory':groupcompress.make_pack_factory(False, False, 1),
 
1431
            'graph': False,
 
1432
            'key_length':1,
 
1433
            'support_partial_insertion':False,
 
1434
            }),
 
1435
        ]
 
1436
    len_two_scenarios = [
 
1437
        ('weave-prefix', {
 
1438
            'cleanup':None,
 
1439
            'factory':make_versioned_files_factory(WeaveFile,
 
1440
                PrefixMapper()),
 
1441
            'graph':True,
 
1442
            'key_length':2,
 
1443
            'support_partial_insertion': False,
 
1444
            }),
 
1445
        ('annotated-knit-escape', {
 
1446
            'cleanup':None,
 
1447
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
 
1448
            'graph':True,
 
1449
            'key_length':2,
 
1450
            'support_partial_insertion': False,
 
1451
            }),
 
1452
        ('plain-knit-pack', {
 
1453
            'cleanup':cleanup_pack_knit,
 
1454
            'factory':make_pack_factory(True, True, 2),
 
1455
            'graph':True,
 
1456
            'key_length':2,
 
1457
            'support_partial_insertion': True,
 
1458
            }),
 
1459
        ('groupcompress', {
 
1460
            'cleanup':groupcompress.cleanup_pack_group,
 
1461
            'factory':groupcompress.make_pack_factory(True, False, 1),
 
1462
            'graph': True,
 
1463
            'key_length':1,
 
1464
            'support_partial_insertion':False,
 
1465
            }),
 
1466
        ]
 
1467
 
 
1468
    scenarios = len_one_scenarios + len_two_scenarios
 
1469
 
1466
1470
    def get_versionedfiles(self, relpath='files'):
1467
1471
        transport = self.get_transport(relpath)
1468
1472
        if relpath != '.':
1479
1483
        else:
1480
1484
            return ('FileA',) + (suffix,)
1481
1485
 
 
1486
    def test_add_fallback_implies_without_fallbacks(self):
 
1487
        f = self.get_versionedfiles('files')
 
1488
        if getattr(f, 'add_fallback_versioned_files', None) is None:
 
1489
            raise TestNotApplicable("%s doesn't support fallbacks"
 
1490
                                    % (f.__class__.__name__,))
 
1491
        g = self.get_versionedfiles('fallback')
 
1492
        key_a = self.get_simple_key('a')
 
1493
        g.add_lines(key_a, [], ['\n'])
 
1494
        f.add_fallback_versioned_files(g)
 
1495
        self.assertTrue(key_a in f.get_parent_map([key_a]))
 
1496
        self.assertFalse(key_a in f.without_fallbacks().get_parent_map([key_a]))
 
1497
 
1482
1498
    def test_add_lines(self):
1483
1499
        f = self.get_versionedfiles()
1484
1500
        key0 = self.get_simple_key('r0')
1678
1694
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1679
1695
                results)
1680
1696
            # Check the added items got CHK keys.
1681
 
            self.assertEqual(set([
 
1697
            self.assertEqual({
1682
1698
                ('sha1:00e364d235126be43292ab09cb4686cf703ddc17',),
1683
1699
                ('sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44',),
1684
1700
                ('sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',),
1685
1701
                ('sha1:a8478686da38e370e32e42e8a0c220e33ee9132f',),
1686
1702
                ('sha1:ed8bce375198ea62444dc71952b22cfc2b09226d',),
1687
 
                ]),
 
1703
                },
1688
1704
                files.keys())
1689
1705
        elif self.key_length == 2:
1690
1706
            self.assertEqual([
1700
1716
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1701
1717
                results)
1702
1718
            # Check the added items got CHK keys.
1703
 
            self.assertEqual(set([
 
1719
            self.assertEqual({
1704
1720
                ('FileA', 'sha1:00e364d235126be43292ab09cb4686cf703ddc17'),
1705
1721
                ('FileA', 'sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44'),
1706
1722
                ('FileA', 'sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1'),
1711
1727
                ('FileB', 'sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1'),
1712
1728
                ('FileB', 'sha1:a8478686da38e370e32e42e8a0c220e33ee9132f'),
1713
1729
                ('FileB', 'sha1:ed8bce375198ea62444dc71952b22cfc2b09226d'),
1714
 
                ]),
 
1730
                },
1715
1731
                files.keys())
1716
1732
 
1717
1733
    def test_empty_lines(self):
2500
2516
                list(files.get_missing_compression_parent_keys()))
2501
2517
            files.insert_record_stream(entries)
2502
2518
            missing_bases = files.get_missing_compression_parent_keys()
2503
 
            self.assertEqual(set([self.get_simple_key('left')]),
 
2519
            self.assertEqual({self.get_simple_key('left')},
2504
2520
                set(missing_bases))
2505
2521
            self.assertEqual(set(keys), set(files.get_parent_map(keys)))
2506
2522
        else:
2524
2540
        files = self.get_versionedfiles()
2525
2541
        files.insert_record_stream(entries)
2526
2542
        missing_bases = files.get_missing_compression_parent_keys()
2527
 
        self.assertEqual(set([self.get_simple_key('left')]),
 
2543
        self.assertEqual({self.get_simple_key('left')},
2528
2544
            set(missing_bases))
2529
2545
        # 'merged' is inserted (although a commit of a write group involving
2530
2546
        # this versionedfiles would fail).
2615
2631
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
2616
2632
 
2617
2633
    def test_make_mpdiffs(self):
2618
 
        from bzrlib import multiparent
 
2634
        from breezy import multiparent
2619
2635
        files = self.get_versionedfiles('source')
2620
2636
        # add texts that should trip the knit maximum delta chain threshold
2621
2637
        # as well as doing parallel chains of data in knits.
2717
2733
        else:
2718
2734
            key = ('foo', 'bar',)
2719
2735
        files.add_lines(key, (), [])
2720
 
        self.assertEqual(set([key]), set(files.keys()))
 
2736
        self.assertEqual({key}, set(files.keys()))
2721
2737
 
2722
2738
 
2723
2739
class VirtualVersionedFilesTests(TestCase):
2731
2747
        return ret
2732
2748
 
2733
2749
    def setUp(self):
2734
 
        TestCase.setUp(self)
 
2750
        super(VirtualVersionedFilesTests, self).setUp()
2735
2751
        self._lines = {}
2736
2752
        self._parent_map = {}
2737
2753
        self.texts = VirtualVersionedFiles(self._get_parent_map,
2753
2769
                          [])
2754
2770
 
2755
2771
    def test_get_sha1s_nonexistent(self):
2756
 
        self.assertEquals({}, self.texts.get_sha1s([("NONEXISTENT",)]))
 
2772
        self.assertEqual({}, self.texts.get_sha1s([("NONEXISTENT",)]))
2757
2773
 
2758
2774
    def test_get_sha1s(self):
2759
2775
        self._lines["key"] = ["dataline1", "dataline2"]
2760
 
        self.assertEquals({("key",): osutils.sha_strings(self._lines["key"])},
 
2776
        self.assertEqual({("key",): osutils.sha_strings(self._lines["key"])},
2761
2777
                           self.texts.get_sha1s([("key",)]))
2762
2778
 
2763
2779
    def test_get_parent_map(self):
2764
2780
        self._parent_map = {"G": ("A", "B")}
2765
 
        self.assertEquals({("G",): (("A",),("B",))},
 
2781
        self.assertEqual({("G",): (("A",),("B",))},
2766
2782
                          self.texts.get_parent_map([("G",), ("L",)]))
2767
2783
 
2768
2784
    def test_get_record_stream(self):
2769
2785
        self._lines["A"] = ["FOO", "BAR"]
2770
2786
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2771
2787
        record = it.next()
2772
 
        self.assertEquals("chunked", record.storage_kind)
2773
 
        self.assertEquals("FOOBAR", record.get_bytes_as("fulltext"))
2774
 
        self.assertEquals(["FOO", "BAR"], record.get_bytes_as("chunked"))
 
2788
        self.assertEqual("chunked", record.storage_kind)
 
2789
        self.assertEqual("FOOBAR", record.get_bytes_as("fulltext"))
 
2790
        self.assertEqual(["FOO", "BAR"], record.get_bytes_as("chunked"))
2775
2791
 
2776
2792
    def test_get_record_stream_absent(self):
2777
2793
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2778
2794
        record = it.next()
2779
 
        self.assertEquals("absent", record.storage_kind)
 
2795
        self.assertEqual("absent", record.storage_kind)
2780
2796
 
2781
2797
    def test_iter_lines_added_or_present_in_keys(self):
2782
2798
        self._lines["A"] = ["FOO", "BAR"]
2783
2799
        self._lines["B"] = ["HEY"]
2784
2800
        self._lines["C"] = ["Alberta"]
2785
2801
        it = self.texts.iter_lines_added_or_present_in_keys([("A",), ("B",)])
2786
 
        self.assertEquals(sorted([("FOO", "A"), ("BAR", "A"), ("HEY", "B")]),
 
2802
        self.assertEqual(sorted([("FOO", "A"), ("BAR", "A"), ("HEY", "B")]),
2787
2803
            sorted(list(it)))
2788
2804
 
2789
2805