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

  • Committer: Martin Pool
  • Date: 2009-06-05 23:21:51 UTC
  • mfrom: (4415 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4416.
  • Revision ID: mbp@sourcefrog.net-20090605232151-luwmyyl95siraqyz
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_graph.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
from bzrlib import (
18
18
    errors,
992
992
        :param next: A callable to advance the search.
993
993
        """
994
994
        for seen, recipe, included_keys, starts, stops in instructions:
 
995
            # Adjust for recipe contract changes that don't vary for all the
 
996
            # current tests.
 
997
            recipe = ('search',) + recipe
995
998
            next()
996
999
            if starts is not None:
997
1000
                search.start_searching(starts)
1011
1014
        search = graph._make_breadth_first_searcher(['head'])
1012
1015
        # At the start, nothing has been seen, to its all excluded:
1013
1016
        result = search.get_result()
1014
 
        self.assertEqual((set(['head']), set(['head']), 0),
 
1017
        self.assertEqual(('search', set(['head']), set(['head']), 0),
1015
1018
            result.get_recipe())
1016
1019
        self.assertEqual(set(), result.get_keys())
1017
1020
        self.assertEqual(set(), search.seen)
1043
1046
        search.start_searching(['head'])
1044
1047
        # head has been seen:
1045
1048
        result = search.get_result()
1046
 
        self.assertEqual((set(['head']), set(['child']), 1),
 
1049
        self.assertEqual(('search', set(['head']), set(['child']), 1),
1047
1050
            result.get_recipe())
1048
1051
        self.assertEqual(set(['head']), result.get_keys())
1049
1052
        self.assertEqual(set(['head']), search.seen)
1203
1206
        self.assertRaises(StopIteration, search.next)
1204
1207
        self.assertEqual(set(['head', 'ghost', NULL_REVISION]), search.seen)
1205
1208
        result = search.get_result()
1206
 
        self.assertEqual((set(['ghost', 'head']), set(['ghost']), 2),
 
1209
        self.assertEqual(('search', set(['ghost', 'head']), set(['ghost']), 2),
1207
1210
            result.get_recipe())
1208
1211
        self.assertEqual(set(['head', NULL_REVISION]), result.get_keys())
1209
1212
        # using next_with_ghosts:
1212
1215
        self.assertRaises(StopIteration, search.next)
1213
1216
        self.assertEqual(set(['head', 'ghost', NULL_REVISION]), search.seen)
1214
1217
        result = search.get_result()
1215
 
        self.assertEqual((set(['ghost', 'head']), set(['ghost']), 2),
 
1218
        self.assertEqual(('search', set(['ghost', 'head']), set(['ghost']), 2),
1216
1219
            result.get_recipe())
1217
1220
        self.assertEqual(set(['head', NULL_REVISION]), result.get_keys())
1218
1221
 
1382
1385
 
1383
1386
 
1384
1387
class TestCachingParentsProvider(tests.TestCase):
 
1388
    """These tests run with:
 
1389
 
 
1390
    self.inst_pp, a recording parents provider with a graph of a->b, and b is a
 
1391
    ghost.
 
1392
    self.caching_pp, a CachingParentsProvider layered on inst_pp.
 
1393
    """
1385
1394
 
1386
1395
    def setUp(self):
1387
1396
        super(TestCachingParentsProvider, self).setUp()
1406
1415
        self.assertEqual({}, self.caching_pp.get_parent_map(['b']))
1407
1416
        # No new calls
1408
1417
        self.assertEqual(['b'], self.inst_pp.calls)
1409
 
        self.assertEqual({'b':None}, self.caching_pp._cache)
1410
1418
 
1411
1419
    def test_get_parent_map_mixed(self):
1412
1420
        """Anything that can be returned from cache, should be"""
1424
1432
        # only present 1 time.
1425
1433
        self.assertEqual(['a', 'b'], sorted(self.inst_pp.calls))
1426
1434
 
 
1435
    def test_note_missing_key(self):
 
1436
        """After noting that a key is missing it is cached."""
 
1437
        self.caching_pp.note_missing_key('b')
 
1438
        self.assertEqual({}, self.caching_pp.get_parent_map(['b']))
 
1439
        self.assertEqual([], self.inst_pp.calls)
 
1440
        self.assertEqual(set(['b']), self.caching_pp.missing_keys)
 
1441
 
1427
1442
 
1428
1443
class TestCachingParentsProviderExtras(tests.TestCaseWithTransport):
1429
1444
    """Test the behaviour when parents are provided that were not requested."""
1527
1542
        self.assertCollapsed(d, d)
1528
1543
 
1529
1544
 
1530
 
class TestPendingAncestryResult(TestCaseWithMemoryTransport):
 
1545
class TestPendingAncestryResultGetKeys(TestCaseWithMemoryTransport):
1531
1546
    """Tests for bzrlib.graph.PendingAncestryResult."""
1532
1547
 
1533
1548
    def test_get_keys(self):
1540
1555
        repo = builder.get_branch().repository
1541
1556
        repo.lock_read()
1542
1557
        self.addCleanup(repo.unlock)
1543
 
        par = _mod_graph.PendingAncestryResult(['rev-2'], repo)
1544
 
        self.assertEqual(set(['rev-1', 'rev-2']), set(par.get_keys()))
 
1558
        result = _mod_graph.PendingAncestryResult(['rev-2'], repo)
 
1559
        self.assertEqual(set(['rev-1', 'rev-2']), set(result.get_keys()))
 
1560
 
 
1561
    def test_get_keys_excludes_ghosts(self):
 
1562
        builder = self.make_branch_builder('b')
 
1563
        builder.start_series()
 
1564
        builder.build_snapshot('rev-1', None, [
 
1565
            ('add', ('', 'root-id', 'directory', ''))])
 
1566
        builder.build_snapshot('rev-2', ['rev-1', 'ghost'], [])
 
1567
        builder.finish_series()
 
1568
        repo = builder.get_branch().repository
 
1569
        repo.lock_read()
 
1570
        self.addCleanup(repo.unlock)
 
1571
        result = _mod_graph.PendingAncestryResult(['rev-2'], repo)
 
1572
        self.assertEqual(sorted(['rev-1', 'rev-2']), sorted(result.get_keys()))
1545
1573
 
1546
1574
    def test_get_keys_excludes_null(self):
1547
1575
        # Make a 'graph' with an iter_ancestry that returns NULL_REVISION
1550
1578
        class StubGraph(object):
1551
1579
            def iter_ancestry(self, keys):
1552
1580
                return [(NULL_REVISION, ()), ('foo', (NULL_REVISION,))]
1553
 
        par = _mod_graph.PendingAncestryResult(['rev-3'], None)
1554
 
        par_keys = par._get_keys(StubGraph())
 
1581
        result = _mod_graph.PendingAncestryResult(['rev-3'], None)
 
1582
        result_keys = result._get_keys(StubGraph())
1555
1583
        # Only the non-null keys from the ancestry appear.
1556
 
        self.assertEqual(set(['foo']), set(par_keys))
1557
 
 
 
1584
        self.assertEqual(set(['foo']), set(result_keys))
 
1585
 
 
1586
 
 
1587
class TestPendingAncestryResultRefine(TestGraphBase):
 
1588
 
 
1589
    def test_refine(self):
 
1590
        # Used when pulling from a stacked repository, so test some revisions
 
1591
        # being satisfied from the stacking branch.
 
1592
        g = self.make_graph(
 
1593
            {"tip":["mid"], "mid":["base"], "tag":["base"],
 
1594
             "base":[NULL_REVISION], NULL_REVISION:[]})
 
1595
        result = _mod_graph.PendingAncestryResult(['tip', 'tag'], None)
 
1596
        result = result.refine(set(['tip']), set(['mid']))
 
1597
        self.assertEqual(set(['mid', 'tag']), result.heads)
 
1598
        result = result.refine(set(['mid', 'tag', 'base']),
 
1599
            set([NULL_REVISION]))
 
1600
        self.assertEqual(set([NULL_REVISION]), result.heads)
 
1601
        self.assertTrue(result.is_empty())
 
1602
 
 
1603
 
 
1604
class TestSearchResultRefine(TestGraphBase):
 
1605
 
 
1606
    def test_refine(self):
 
1607
        # Used when pulling from a stacked repository, so test some revisions
 
1608
        # being satisfied from the stacking branch.
 
1609
        g = self.make_graph(
 
1610
            {"tip":["mid"], "mid":["base"], "tag":["base"],
 
1611
             "base":[NULL_REVISION], NULL_REVISION:[]})
 
1612
        result = _mod_graph.SearchResult(set(['tip', 'tag']),
 
1613
            set([NULL_REVISION]), 4, set(['tip', 'mid', 'tag', 'base']))
 
1614
        result = result.refine(set(['tip']), set(['mid']))
 
1615
        recipe = result.get_recipe()
 
1616
        # We should be starting from tag (original head) and mid (seen ref)
 
1617
        self.assertEqual(set(['mid', 'tag']), recipe[1])
 
1618
        # We should be stopping at NULL (original stop) and tip (seen head)
 
1619
        self.assertEqual(set([NULL_REVISION, 'tip']), recipe[2])
 
1620
        self.assertEqual(3, recipe[3])
 
1621
        result = result.refine(set(['mid', 'tag', 'base']),
 
1622
            set([NULL_REVISION]))
 
1623
        recipe = result.get_recipe()
 
1624
        # We should be starting from nothing (NULL was known as a cut point)
 
1625
        self.assertEqual(set([]), recipe[1])
 
1626
        # We should be stopping at NULL (original stop) and tip (seen head) and
 
1627
        # tag (seen head) and mid(seen mid-point head). We could come back and
 
1628
        # define this as not including mid, for minimal results, but it is
 
1629
        # still 'correct' to include mid, and simpler/easier.
 
1630
        self.assertEqual(set([NULL_REVISION, 'tip', 'tag', 'mid']), recipe[2])
 
1631
        self.assertEqual(0, recipe[3])
 
1632
        self.assertTrue(result.is_empty())