/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_versionedfile.py

• browse files at revision 4584.3.27
• compare with another revision
• download diff
• download tarball
• view history from revision 4584.3.27

• reverse the comparison (4584.3.27 to 5200.3.2)
• stop comparing with revision 5200.3.2

Show diffs side-by-side

added

removed

bzrlib/tests/test_versionedfile.py

1

 

# Copyright (C) 2006-2010 Canonical Ltd

 

1

# Copyright (C) 2005, 2009 Canonical Ltd

2

2

#

3

3

# Authors:

4

4

#   Johan Rydberg <jrydberg@gnu.org>

26

26

 

27

27

from bzrlib import (

28

28

    errors,

29

 

    graph as _mod_graph,

30

29

    groupcompress,

31

30

    knit as _mod_knit,

32

31

    osutils,

734

733

        # the ordering here is to make a tree so that dumb searches have

735

734

        # more changes to muck up.

736

735

 

737

 

        class InstrumentedProgress(progress.ProgressTask):

 

736

        class InstrumentedProgress(progress.DummyProgress):

738

737

 

739

738

            def __init__(self):

740

 

                progress.ProgressTask.__init__(self)

 

739

 

 

740

                progress.DummyProgress.__init__(self)

741

741

                self.updates = []

742

742

 

743

743

            def update(self, msg=None, current=None, total=None):

1469

1469

            transport.mkdir('.')

1470

1470

        files = self.factory(transport)

1471

1471

        if self.cleanup is not None:

1472

 

            self.addCleanup(self.cleanup, files)

 

1472

            self.addCleanup(lambda:self.cleanup(files))

1473

1473

        return files

1474

1474

 

1475

1475

    def get_simple_key(self, suffix):

1580

1580

        # All texts should be output.

1581

1581

        self.assertEqual(set(keys), seen)

1582

1582

 

1583

 

    def test_clear_cache(self):

1584

 

        files = self.get_versionedfiles()

1585

 

        files.clear_cache()

1586

 

 

1587

1583

    def test_construct(self):

1588

1584

        """Each parameterised test can be constructed on a transport."""

1589

1585

        files = self.get_versionedfiles()

1741

1737

            f.get_record_stream([key_b], 'unordered', True

1742

1738

                ).next().get_bytes_as('fulltext'))

1743

1739

 

1744

 

    def test_get_known_graph_ancestry(self):

1745

 

        f = self.get_versionedfiles()

1746

 

        if not self.graph:

1747

 

            raise TestNotApplicable('ancestry info only relevant with graph.')

1748

 

        key_a = self.get_simple_key('a')

1749

 

        key_b = self.get_simple_key('b')

1750

 

        key_c = self.get_simple_key('c')

1751

 

        # A

1752

 

        # |\

1753

 

        # | B

1754

 

        # |/

1755

 

        # C

1756

 

        f.add_lines(key_a, [], ['\n'])

1757

 

        f.add_lines(key_b, [key_a], ['\n'])

1758

 

        f.add_lines(key_c, [key_a, key_b], ['\n'])

1759

 

        kg = f.get_known_graph_ancestry([key_c])

1760

 

        self.assertIsInstance(kg, _mod_graph.KnownGraph)

1761

 

        self.assertEqual([key_a, key_b, key_c], list(kg.topo_sort()))

1762

 

 

1763

 

    def test_known_graph_with_fallbacks(self):

1764

 

        f = self.get_versionedfiles('files')

1765

 

        if not self.graph:

1766

 

            raise TestNotApplicable('ancestry info only relevant with graph.')

1767

 

        if getattr(f, 'add_fallback_versioned_files', None) is None:

1768

 

            raise TestNotApplicable("%s doesn't support fallbacks"

1769

 

                                    % (f.__class__.__name__,))

1770

 

        key_a = self.get_simple_key('a')

1771

 

        key_b = self.get_simple_key('b')

1772

 

        key_c = self.get_simple_key('c')

1773

 

        # A     only in fallback

1774

 

        # |\

1775

 

        # | B

1776

 

        # |/

1777

 

        # C

1778

 

        g = self.get_versionedfiles('fallback')

1779

 

        g.add_lines(key_a, [], ['\n'])

1780

 

        f.add_fallback_versioned_files(g)

1781

 

        f.add_lines(key_b, [key_a], ['\n'])

1782

 

        f.add_lines(key_c, [key_a, key_b], ['\n'])

1783

 

        kg = f.get_known_graph_ancestry([key_c])

1784

 

        self.assertEqual([key_a, key_b, key_c], list(kg.topo_sort()))

1785

 

 

1786

1740

    def test_get_record_stream_empty(self):

1787

1741

        """An empty stream can be requested without error."""

1788

1742

        f = self.get_versionedfiles()

2437

2391

        else:

2438

2392

            self.assertIdenticalVersionedFile(source, files)

2439

2393

 

2440

 

    def test_insert_record_stream_long_parent_chain_out_of_order(self):

2441

 

        """An out of order stream can either error or work."""

2442

 

        if not self.graph:

2443

 

            raise TestNotApplicable('ancestry info only relevant with graph.')

2444

 

        # Create a reasonably long chain of records based on each other, where

2445

 

        # most will be deltas.

2446

 

        source = self.get_versionedfiles('source')

2447

 

        parents = ()

2448

 

        keys = []

2449

 

        content = [('same same %d\n' % n) for n in range(500)]

2450

 

        for letter in 'abcdefghijklmnopqrstuvwxyz':

2451

 

            key = ('key-' + letter,)

2452

 

            if self.key_length == 2:

2453

 

                key = ('prefix',) + key

2454

 

            content.append('content for ' + letter + '\n')

2455

 

            source.add_lines(key, parents, content)

2456

 

            keys.append(key)

2457

 

            parents = (key,)

2458

 

        # Create a stream of these records, excluding the first record that the

2459

 

        # rest ultimately depend upon, and insert it into a new vf.

2460

 

        streams = []

2461

 

        for key in reversed(keys):

2462

 

            streams.append(source.get_record_stream([key], 'unordered', False))

2463

 

        deltas = chain(*streams[:-1])

2464

 

        files = self.get_versionedfiles()

2465

 

        try:

2466

 

            files.insert_record_stream(deltas)

2467

 

        except RevisionNotPresent:

2468

 

            # Must not have corrupted the file.

2469

 

            files.check()

2470

 

        else:

2471

 

            # Must only report either just the first key as a missing parent,

2472

 

            # no key as missing (for nodelta scenarios).

2473

 

            missing = set(files.get_missing_compression_parent_keys())

2474

 

            missing.discard(keys[0])

2475

 

            self.assertEqual(set(), missing)

2476

 

 

2477

2394

    def get_knit_delta_source(self):

2478

2395

        """Get a source that can produce a stream with knit delta records,

2479

2396

        regardless of this test's scenario.

2547

2464

        # the ordering here is to make a tree so that dumb searches have

2548

2465

        # more changes to muck up.

2549

2466

 

2550

 

        class InstrumentedProgress(progress.ProgressTask):

 

2467

        class InstrumentedProgress(progress.DummyProgress):

2551

2468

 

2552

2469

            def __init__(self):

2553

 

                progress.ProgressTask.__init__(self)

 

2470

 

 

2471

                progress.DummyProgress.__init__(self)

2554

2472

                self.updates = []

2555

2473

 

2556

2474

            def update(self, msg=None, current=None, total=None):

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0