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

  • Committer: Martin Pool
  • Date: 2009-07-17 10:38:41 UTC
  • mfrom: (4536 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4558.
  • Revision ID: mbp@sourcefrog.net-20090717103841-z35onk04bkiw7zb6
Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_versionedfile.py
1471
1471
            self.addCleanup(lambda:self.cleanup(files))
1472
1472
        return files
1473
1473
 
 
1474
    def get_simple_key(self, suffix):
 
1475
        """Return a key for the object under test."""
 
1476
        if self.key_length == 1:
 
1477
            return (suffix,)
 
1478
        else:
 
1479
            return ('FileA',) + (suffix,)
 
1480
 
 
1481
    def test_add_lines(self):
 
1482
        f = self.get_versionedfiles()
 
1483
        key0 = self.get_simple_key('r0')
 
1484
        key1 = self.get_simple_key('r1')
 
1485
        key2 = self.get_simple_key('r2')
 
1486
        keyf = self.get_simple_key('foo')
 
1487
        f.add_lines(key0, [], ['a\n', 'b\n'])
 
1488
        if self.graph:
 
1489
            f.add_lines(key1, [key0], ['b\n', 'c\n'])
 
1490
        else:
 
1491
            f.add_lines(key1, [], ['b\n', 'c\n'])
 
1492
        keys = f.keys()
 
1493
        self.assertTrue(key0 in keys)
 
1494
        self.assertTrue(key1 in keys)
 
1495
        records = []
 
1496
        for record in f.get_record_stream([key0, key1], 'unordered', True):
 
1497
            records.append((record.key, record.get_bytes_as('fulltext')))
 
1498
        records.sort()
 
1499
        self.assertEqual([(key0, 'a\nb\n'), (key1, 'b\nc\n')], records)
 
1500
 
 
1501
    def test__add_text(self):
 
1502
        f = self.get_versionedfiles()
 
1503
        key0 = self.get_simple_key('r0')
 
1504
        key1 = self.get_simple_key('r1')
 
1505
        key2 = self.get_simple_key('r2')
 
1506
        keyf = self.get_simple_key('foo')
 
1507
        f._add_text(key0, [], 'a\nb\n')
 
1508
        if self.graph:
 
1509
            f._add_text(key1, [key0], 'b\nc\n')
 
1510
        else:
 
1511
            f._add_text(key1, [], 'b\nc\n')
 
1512
        keys = f.keys()
 
1513
        self.assertTrue(key0 in keys)
 
1514
        self.assertTrue(key1 in keys)
 
1515
        records = []
 
1516
        for record in f.get_record_stream([key0, key1], 'unordered', True):
 
1517
            records.append((record.key, record.get_bytes_as('fulltext')))
 
1518
        records.sort()
 
1519
        self.assertEqual([(key0, 'a\nb\n'), (key1, 'b\nc\n')], records)
 
1520
 
1474
1521
    def test_annotate(self):
1475
1522
        files = self.get_versionedfiles()
1476
1523
        self.get_diamond_files(files)
1510
1557
        self.assertRaises(RevisionNotPresent,
1511
1558
            files.annotate, prefix + ('missing-key',))
1512
1559
 
 
1560
    def test_get_annotator(self):
 
1561
        files = self.get_versionedfiles()
 
1562
        self.get_diamond_files(files)
 
1563
        origin_key = self.get_simple_key('origin')
 
1564
        base_key = self.get_simple_key('base')
 
1565
        left_key = self.get_simple_key('left')
 
1566
        right_key = self.get_simple_key('right')
 
1567
        merged_key = self.get_simple_key('merged')
 
1568
        # annotator = files.get_annotator()
 
1569
        # introduced full text
 
1570
        origins, lines = files.get_annotator().annotate(origin_key)
 
1571
        self.assertEqual([(origin_key,)], origins)
 
1572
        self.assertEqual(['origin\n'], lines)
 
1573
        # a delta
 
1574
        origins, lines = files.get_annotator().annotate(base_key)
 
1575
        self.assertEqual([(base_key,)], origins)
 
1576
        # a merge
 
1577
        origins, lines = files.get_annotator().annotate(merged_key)
 
1578
        if self.graph:
 
1579
            self.assertEqual([
 
1580
                (base_key,),
 
1581
                (left_key,),
 
1582
                (right_key,),
 
1583
                (merged_key,),
 
1584
                ], origins)
 
1585
        else:
 
1586
            # Without a graph everything is new.
 
1587
            self.assertEqual([
 
1588
                (merged_key,),
 
1589
                (merged_key,),
 
1590
                (merged_key,),
 
1591
                (merged_key,),
 
1592
                ], origins)
 
1593
        self.assertRaises(RevisionNotPresent,
 
1594
            files.get_annotator().annotate, self.get_simple_key('missing-key'))
 
1595
 
1513
1596
    def test_construct(self):
1514
1597
        """Each parameterised test can be constructed on a transport."""
1515
1598
        files = self.get_versionedfiles()
1520
1603
            trailing_eol=trailing_eol, nograph=not self.graph,
1521
1604
            left_only=left_only, nokeys=nokeys)
1522
1605
 
1523
 
    def test_add_lines_nostoresha(self):
 
1606
    def _add_content_nostoresha(self, add_lines):
1524
1607
        """When nostore_sha is supplied using old content raises."""
1525
1608
        vf = self.get_versionedfiles()
1526
1609
        empty_text = ('a', [])
1528
1611
        sample_text_no_nl = ('c', ["foo\n", "bar"])
1529
1612
        shas = []
1530
1613
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
1531
 
            sha, _, _ = vf.add_lines(self.get_simple_key(version), [], lines)
 
1614
            if add_lines:
 
1615
                sha, _, _ = vf.add_lines(self.get_simple_key(version), [],
 
1616
                                         lines)
 
1617
            else:
 
1618
                sha, _, _ = vf._add_text(self.get_simple_key(version), [],
 
1619
                                         ''.join(lines))
1532
1620
            shas.append(sha)
1533
1621
        # we now have a copy of all the lines in the vf.
1534
1622
        for sha, (version, lines) in zip(
1537
1625
            self.assertRaises(errors.ExistingContent,
1538
1626
                vf.add_lines, new_key, [], lines,
1539
1627
                nostore_sha=sha)
 
1628
            self.assertRaises(errors.ExistingContent,
 
1629
                vf._add_text, new_key, [], ''.join(lines),
 
1630
                nostore_sha=sha)
1540
1631
            # and no new version should have been added.
1541
1632
            record = vf.get_record_stream([new_key], 'unordered', True).next()
1542
1633
            self.assertEqual('absent', record.storage_kind)
1543
1634
 
 
1635
    def test_add_lines_nostoresha(self):
 
1636
        self._add_content_nostoresha(add_lines=True)
 
1637
 
 
1638
    def test__add_text_nostoresha(self):
 
1639
        self._add_content_nostoresha(add_lines=False)
 
1640
 
1544
1641
    def test_add_lines_return(self):
1545
1642
        files = self.get_versionedfiles()
1546
1643
        # save code by using the stock data insertion helper.
1692
1789
        self.capture_stream(files, entries, seen.add, parent_map)
1693
1790
        self.assertEqual(set(keys), seen)
1694
1791
 
1695
 
    def get_simple_key(self, suffix):
1696
 
        """Return a key for the object under test."""
1697
 
        if self.key_length == 1:
1698
 
            return (suffix,)
1699
 
        else:
1700
 
            return ('FileA',) + (suffix,)
1701
 
 
1702
1792
    def get_keys_and_sort_order(self):
1703
1793
        """Get diamond test keys list, and their sort ordering."""
1704
1794
        if self.key_length == 1: