/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-30 19:32:13 UTC
  • mfrom: (6637 work)
  • mto: This revision was merged to the branch mainline in revision 6639.
  • Revision ID: jelmer@jelmer.uk-20170530193213-qm21s6dc7dln237t
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_versionedfile.py
22
22
# considered typical and check that it can be detected/corrected.
23
23
 
24
24
from gzip import GzipFile
25
 
from itertools import chain, izip
 
25
import itertools
26
26
 
27
27
from .. import (
28
28
    errors,
45
45
    )
46
46
from ..sixish import (
47
47
    BytesIO,
 
48
    zip,
48
49
    )
49
50
from . import (
50
51
    TestCase,
889
890
    def test_get_record_stream(self):
890
891
        self.setup_abcde()
891
892
        def get_record(suffix):
892
 
            return self.plan_merge_vf.get_record_stream(
893
 
                [('root', suffix)], 'unordered', True).next()
 
893
            return next(self.plan_merge_vf.get_record_stream(
 
894
                [('root', suffix)], 'unordered', True))
894
895
        self.assertEqual('a', get_record('A').get_bytes_as('fulltext'))
895
896
        self.assertEqual('c', get_record('C').get_bytes_as('fulltext'))
896
897
        self.assertEqual('e', get_record('E:').get_bytes_as('fulltext'))
944
945
            return x + '\n'
945
946
 
946
947
        w = self.get_file()
947
 
        w.add_lines('text0', [], map(addcrlf, base))
948
 
        w.add_lines('text1', ['text0'], map(addcrlf, a))
949
 
        w.add_lines('text2', ['text0'], map(addcrlf, b))
 
948
        w.add_lines('text0', [], list(map(addcrlf, base)))
 
949
        w.add_lines('text1', ['text0'], list(map(addcrlf, a)))
 
950
        w.add_lines('text2', ['text0'], list(map(addcrlf, b)))
950
951
 
951
952
        self.log_contents(w)
952
953
 
962
963
        mt.seek(0)
963
964
        self.log(mt.getvalue())
964
965
 
965
 
        mp = map(addcrlf, mp)
 
966
        mp = list(map(addcrlf, mp))
966
967
        self.assertEqual(mt.readlines(), mp)
967
968
 
968
969
 
1224
1225
        """Grab the interested adapted texts for tests."""
1225
1226
        # origin is a fulltext
1226
1227
        entries = f.get_record_stream([('origin',)], 'unordered', False)
1227
 
        base = entries.next()
 
1228
        base = next(entries)
1228
1229
        ft_data = ft_adapter.get_bytes(base)
1229
1230
        # merged is both a delta and multiple parents.
1230
1231
        entries = f.get_record_stream([('merged',)], 'unordered', False)
1231
 
        merged = entries.next()
 
1232
        merged = next(entries)
1232
1233
        delta_data = delta_adapter.get_bytes(merged)
1233
1234
        return ft_data, delta_data
1234
1235
 
1636
1637
                vf._add_text, new_key, [], ''.join(lines),
1637
1638
                nostore_sha=sha)
1638
1639
            # and no new version should have been added.
1639
 
            record = vf.get_record_stream([new_key], 'unordered', True).next()
 
1640
            record = next(vf.get_record_stream([new_key], 'unordered', True))
1640
1641
            self.assertEqual('absent', record.storage_kind)
1641
1642
 
1642
1643
    def test_add_lines_nostoresha(self):
2001
2002
        key = self.get_simple_key('foo')
2002
2003
        files.add_lines(key, (), ['my text\n', 'content'])
2003
2004
        stream = files.get_record_stream([key], 'unordered', False)
2004
 
        record = stream.next()
 
2005
        record = next(stream)
2005
2006
        if record.storage_kind in ('chunked', 'fulltext'):
2006
2007
            # chunked and fulltext representations are for direct use not wire
2007
2008
            # serialisation: check they are able to be used directly. To send
2028
2029
        :param records: A list to collect the seen records.
2029
2030
        :return: A generator of the records in stream.
2030
2031
        """
2031
 
        # We make assertions during copying to catch things early for
2032
 
        # easier debugging.
2033
 
        for record, ref_record in izip(stream, expected):
 
2032
        # We make assertions during copying to catch things early for easier
 
2033
        # debugging. This must use the iterating zip() from the future.
 
2034
        for record, ref_record in zip(stream, expected):
2034
2035
            records.append(record)
2035
2036
            self.assertEqual(ref_record.key, record.key)
2036
2037
            self.assertEqual(ref_record.storage_kind, record.storage_kind)
2444
2445
        origin_entries = source.get_record_stream(origin_keys, 'unordered', False)
2445
2446
        end_entries = source.get_record_stream(end_keys, 'topological', False)
2446
2447
        start_entries = source.get_record_stream(start_keys, 'topological', False)
2447
 
        entries = chain(origin_entries, end_entries, start_entries)
 
2448
        entries = itertools.chain(origin_entries, end_entries, start_entries)
2448
2449
        try:
2449
2450
            files.insert_record_stream(entries)
2450
2451
        except RevisionNotPresent:
2476
2477
        streams = []
2477
2478
        for key in reversed(keys):
2478
2479
            streams.append(source.get_record_stream([key], 'unordered', False))
2479
 
        deltas = chain(*streams[:-1])
 
2480
        deltas = itertools.chain.from_iterable(streams[:-1])
2480
2481
        files = self.get_versionedfiles()
2481
2482
        try:
2482
2483
            files.insert_record_stream(deltas)
2784
2785
    def test_get_record_stream(self):
2785
2786
        self._lines["A"] = ["FOO", "BAR"]
2786
2787
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2787
 
        record = it.next()
 
2788
        record = next(it)
2788
2789
        self.assertEqual("chunked", record.storage_kind)
2789
2790
        self.assertEqual("FOOBAR", record.get_bytes_as("fulltext"))
2790
2791
        self.assertEqual(["FOO", "BAR"], record.get_bytes_as("chunked"))
2791
2792
 
2792
2793
    def test_get_record_stream_absent(self):
2793
2794
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2794
 
        record = it.next()
 
2795
        record = next(it)
2795
2796
        self.assertEqual("absent", record.storage_kind)
2796
2797
 
2797
2798
    def test_iter_lines_added_or_present_in_keys(self):