← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_graph.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-05-24 11:41:24 UTC
  • mfrom: (3449.1.2 unbreak-push-overwrite)
  • Revision ID: pqm@pqm.ubuntu.com-20080524114124-ubdyd5iqf7zxl2pn
Fix "bzr push --overwrite -r NNN". (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_graph.py
396
396
with_ghost = {'a': ['b'], 'c': ['b', 'd'], 'b':['e'], 'd':['e', 'g'],
397
397
              'e': ['f'], 'f':[NULL_REVISION], NULL_REVISION:()}
398
398
 
399
 
# A graph that shows we can shortcut finding revnos when reaching them from the
400
 
# side.
401
 
#  NULL_REVISION
402
 
#       |
403
 
#       a
404
 
#       |
405
 
#       b
406
 
#       |
407
 
#       c
408
 
#       |
409
 
#       d
410
 
#       |
411
 
#       e
412
 
#      / \
413
 
#     f   g
414
 
#     |
415
 
#     h
416
 
#     |
417
 
#     i
418
 
 
419
 
with_tail = {'a':[NULL_REVISION], 'b':['a'], 'c':['b'], 'd':['c'], 'e':['d'],
420
 
             'f':['e'], 'g':['e'], 'h':['f'], 'i':['h']}
421
399
 
422
400
 
423
401
class InstrumentedParentsProvider(object):
431
409
        return self._real_parents_provider.get_parent_map(nodes)
432
410
 
433
411
 
434
 
class TestGraphBase(tests.TestCase):
435
 
 
436
 
    def make_graph(self, ancestors):
437
 
        return _mod_graph.Graph(_mod_graph.DictParentsProvider(ancestors))
438
 
 
439
 
    def make_breaking_graph(self, ancestors, break_on):
440
 
        """Make a Graph that raises an exception if we hit a node."""
441
 
        g = self.make_graph(ancestors)
442
 
        orig_parent_map = g.get_parent_map
443
 
        def get_parent_map(keys):
444
 
            bad_keys = set(keys).intersection(break_on)
445
 
            if bad_keys:
446
 
                self.fail('key(s) %s was accessed' % (sorted(bad_keys),))
447
 
            return orig_parent_map(keys)
448
 
        g.get_parent_map = get_parent_map
449
 
        return g
450
 
 
451
 
 
452
412
class TestGraph(TestCaseWithMemoryTransport):
453
413
 
454
414
    def make_graph(self, ancestors):
1178
1138
        self.assertEqual(set(['head', NULL_REVISION]), result.get_keys())
1179
1139
 
1180
1140
 
1181
 
class TestFindUniqueAncestors(TestGraphBase):
 
1141
class TestFindUniqueAncestors(tests.TestCase):
 
1142
 
 
1143
    def make_graph(self, ancestors):
 
1144
        return _mod_graph.Graph(_mod_graph.DictParentsProvider(ancestors))
 
1145
 
 
1146
    def make_breaking_graph(self, ancestors, break_on):
 
1147
        """Make a Graph that raises an exception if we hit a node."""
 
1148
        g = self.make_graph(ancestors)
 
1149
        orig_parent_map = g.get_parent_map
 
1150
        def get_parent_map(keys):
 
1151
            bad_keys = set(keys).intersection(break_on)
 
1152
            if bad_keys:
 
1153
                self.fail('key(s) %s was accessed' % (sorted(bad_keys),))
 
1154
            return orig_parent_map(keys)
 
1155
        g.get_parent_map = get_parent_map
 
1156
        return g
1182
1157
 
1183
1158
    def assertFindUniqueAncestors(self, graph, expected, node, common):
1184
1159
        actual = graph.find_unique_ancestors(node, common)
1253
1228
            ['h', 'i', 'j', 'y'], 'j', ['z'])
1254
1229
 
1255
1230
 
1256
 
class TestGraphFindDistanceToNull(TestGraphBase):
1257
 
    """Test an api that should be able to compute a revno"""
1258
 
 
1259
 
    def assertFindDistance(self, revno, graph, target_id, known_ids):
1260
 
        """Assert the output of Graph.find_distance_to_null()"""
1261
 
        actual = graph.find_distance_to_null(target_id, known_ids)
1262
 
        self.assertEqual(revno, actual)
1263
 
 
1264
 
    def test_nothing_known(self):
1265
 
        graph = self.make_graph(ancestry_1)
1266
 
        self.assertFindDistance(0, graph, NULL_REVISION, [])
1267
 
        self.assertFindDistance(1, graph, 'rev1', [])
1268
 
        self.assertFindDistance(2, graph, 'rev2a', [])
1269
 
        self.assertFindDistance(2, graph, 'rev2b', [])
1270
 
        self.assertFindDistance(3, graph, 'rev3', [])
1271
 
        self.assertFindDistance(4, graph, 'rev4', [])
1272
 
 
1273
 
    def test_rev_is_ghost(self):
1274
 
        graph = self.make_graph(ancestry_1)
1275
 
        e = self.assertRaises(errors.GhostRevisionsHaveNoRevno,
1276
 
                              graph.find_distance_to_null, 'rev_missing', [])
1277
 
        self.assertEqual('rev_missing', e.revision_id)
1278
 
        self.assertEqual('rev_missing', e.ghost_revision_id)
1279
 
 
1280
 
    def test_ancestor_is_ghost(self):
1281
 
        graph = self.make_graph({'rev':['parent']})
1282
 
        e = self.assertRaises(errors.GhostRevisionsHaveNoRevno,
1283
 
                              graph.find_distance_to_null, 'rev', [])
1284
 
        self.assertEqual('rev', e.revision_id)
1285
 
        self.assertEqual('parent', e.ghost_revision_id)
1286
 
 
1287
 
    def test_known_in_ancestry(self):
1288
 
        graph = self.make_graph(ancestry_1)
1289
 
        self.assertFindDistance(2, graph, 'rev2a', [('rev1', 1)])
1290
 
        self.assertFindDistance(3, graph, 'rev3', [('rev2a', 2)])
1291
 
 
1292
 
    def test_known_in_ancestry_limits(self):
1293
 
        graph = self.make_breaking_graph(ancestry_1, ['rev1'])
1294
 
        self.assertFindDistance(4, graph, 'rev4', [('rev3', 3)])
1295
 
 
1296
 
    def test_target_is_ancestor(self):
1297
 
        graph = self.make_graph(ancestry_1)
1298
 
        self.assertFindDistance(2, graph, 'rev2a', [('rev3', 3)])
1299
 
 
1300
 
    def test_target_is_ancestor_limits(self):
1301
 
        """We shouldn't search all history if we run into ourselves"""
1302
 
        graph = self.make_breaking_graph(ancestry_1, ['rev1'])
1303
 
        self.assertFindDistance(3, graph, 'rev3', [('rev4', 4)])
1304
 
 
1305
 
    def test_target_parallel_to_known_limits(self):
1306
 
        # Even though the known revision isn't part of the other ancestry, they
1307
 
        # eventually converge
1308
 
        graph = self.make_breaking_graph(with_tail, ['a'])
1309
 
        self.assertFindDistance(6, graph, 'f', [('g', 6)])
1310
 
        self.assertFindDistance(7, graph, 'h', [('g', 6)])
1311
 
        self.assertFindDistance(8, graph, 'i', [('g', 6)])
1312
 
        self.assertFindDistance(6, graph, 'g', [('i', 8)])
1313
 
 
1314
 
 
1315
1231
class TestCachingParentsProvider(tests.TestCase):
1316
1232
 
1317
1233
    def setUp(self):