← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_dirstate.py

  • Committer: John Arbash Meinel
  • Date: 2007-06-07 22:31:44 UTC
  • mfrom: (2517 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2518.
  • Revision ID: john@arbash-meinel.com-20070607223144-u4oljlajcvq6by2n
[merge] bzr.dev 2517

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
558
558
            self.assertEqual('', entry[1][0][1])
559
559
            # We should have a real entry.
560
560
            self.assertNotEqual((None, None), entry)
 
561
            # Make sure everything is old enough
 
562
            state._sha_cutoff_time()
 
563
            state._cutoff_time += 10
561
564
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
562
565
            # We should have gotten a real sha1
563
566
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
1462
1465
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1463
1466
                         link_or_sha1)
1464
1467
 
1465
 
        # The dirblock entry should be updated with the new info
1466
 
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1468
        # The dirblock entry should not cache the file's sha1
 
1469
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
1467
1470
                         entry[1])
1468
1471
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1469
1472
                         state._dirblock_state)
1488
1491
                         link_or_sha1)
1489
1492
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1490
1493
                         state._dirblock_state)
 
1494
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1495
                         entry[1])
1491
1496
        state.save()
1492
1497
 
1493
1498
        # However, if we move the clock forward so the file is considered
1494
 
        # "stable", it should just returned the cached value.
1495
 
        state.adjust_time(20)
 
1499
        # "stable", it should just cache the value.
 
1500
        state.adjust_time(+20)
1496
1501
        link_or_sha1 = state.update_entry(entry, abspath='a',
1497
1502
                                          stat_value=stat_value)
1498
1503
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1499
1504
                         link_or_sha1)
1500
1505
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1501
1506
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1507
                          ('sha1', 'a'), ('is_exec', mode, False),
1502
1508
                         ], state._log)
 
1509
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1510
                         entry[1])
1503
1511
 
1504
 
    def test_update_entry_no_stat_value(self):
1505
 
        """Passing the stat_value is optional."""
1506
 
        state, entry = self.get_state_with_a()
1507
 
        state.adjust_time(-10) # Make sure the file looks new
1508
 
        self.build_tree(['a'])
1509
 
        # Add one where we don't provide the stat or sha already
1510
 
        link_or_sha1 = state.update_entry(entry, abspath='a')
 
1512
        # Subsequent calls will just return the cached value
 
1513
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1514
                                          stat_value=stat_value)
1511
1515
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1512
1516
                         link_or_sha1)
1513
 
        stat_value = os.lstat('a')
1514
 
        self.assertEqual([('lstat', 'a'), ('sha1', 'a'),
1515
 
                          ('is_exec', stat_value.st_mode, False),
 
1517
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1518
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1519
                          ('sha1', 'a'), ('is_exec', mode, False),
1516
1520
                         ], state._log)
 
1521
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1522
                         entry[1])
1517
1523
 
1518
1524
    def test_update_entry_symlink(self):
1519
1525
        """Update entry should read symlinks."""
1533
1539
                                          stat_value=stat_value)
1534
1540
        self.assertEqual('target', link_or_sha1)
1535
1541
        self.assertEqual([('read_link', 'a', '')], state._log)
1536
 
        # Dirblock is updated
1537
 
        self.assertEqual([('l', link_or_sha1, 6, False, packed_stat)],
 
1542
        # Dirblock is not updated (the link is too new)
 
1543
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
1538
1544
                         entry[1])
1539
1545
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1540
1546
                         state._dirblock_state)
1544
1550
                                          stat_value=stat_value)
1545
1551
        self.assertEqual('target', link_or_sha1)
1546
1552
        self.assertEqual([('read_link', 'a', ''),
1547
 
                          ('read_link', 'a', 'target'),
 
1553
                          ('read_link', 'a', ''),
1548
1554
                         ], state._log)
 
1555
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1556
                         entry[1])
1549
1557
        state.adjust_time(+20) # Skip into the future, all files look old
1550
1558
        link_or_sha1 = state.update_entry(entry, abspath='a',
1551
1559
                                          stat_value=stat_value)
1552
1560
        self.assertEqual('target', link_or_sha1)
1553
 
        # There should not be a new read_link call.
1554
 
        # (this is a weak assertion, because read_link is fairly inexpensive,
1555
 
        # versus the number of symlinks that we would have)
1556
 
        self.assertEqual([('read_link', 'a', ''),
1557
 
                          ('read_link', 'a', 'target'),
1558
 
                         ], state._log)
 
1561
        # We need to re-read the link because only now can we cache it
 
1562
        self.assertEqual([('read_link', 'a', ''),
 
1563
                          ('read_link', 'a', ''),
 
1564
                          ('read_link', 'a', ''),
 
1565
                         ], state._log)
 
1566
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1567
                         entry[1])
 
1568
 
 
1569
        # Another call won't re-read the link
 
1570
        self.assertEqual([('read_link', 'a', ''),
 
1571
                          ('read_link', 'a', ''),
 
1572
                          ('read_link', 'a', ''),
 
1573
                         ], state._log)
 
1574
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1575
                                          stat_value=stat_value)
 
1576
        self.assertEqual('target', link_or_sha1)
 
1577
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1578
                         entry[1])
 
1579
 
 
1580
    def do_update_entry(self, state, entry, abspath):
 
1581
        stat_value = os.lstat(abspath)
 
1582
        return state.update_entry(entry, abspath, stat_value)
1559
1583
 
1560
1584
    def test_update_entry_dir(self):
1561
1585
        state, entry = self.get_state_with_a()
1562
1586
        self.build_tree(['a/'])
1563
 
        self.assertIs(None, state.update_entry(entry, 'a'))
 
1587
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1588
 
 
1589
    def test_update_entry_dir_unchanged(self):
 
1590
        state, entry = self.get_state_with_a()
 
1591
        self.build_tree(['a/'])
 
1592
        state.adjust_time(+20)
 
1593
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1594
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1595
                         state._dirblock_state)
 
1596
        state.save()
 
1597
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1598
                         state._dirblock_state)
 
1599
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1600
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1601
                         state._dirblock_state)
 
1602
 
 
1603
    def test_update_entry_file_unchanged(self):
 
1604
        state, entry = self.get_state_with_a()
 
1605
        self.build_tree(['a'])
 
1606
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1607
        state.adjust_time(+20)
 
1608
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1609
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1610
                         state._dirblock_state)
 
1611
        state.save()
 
1612
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1613
                         state._dirblock_state)
 
1614
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1615
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1616
                         state._dirblock_state)
1564
1617
 
1565
1618
    def create_and_test_file(self, state, entry):
1566
1619
        """Create a file at 'a' and verify the state finds it.
1572
1625
        stat_value = os.lstat('a')
1573
1626
        packed_stat = dirstate.pack_stat(stat_value)
1574
1627
 
1575
 
        link_or_sha1 = state.update_entry(entry, abspath='a')
 
1628
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1576
1629
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1577
1630
                         link_or_sha1)
1578
1631
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1589
1642
        stat_value = os.lstat('a')
1590
1643
        packed_stat = dirstate.pack_stat(stat_value)
1591
1644
 
1592
 
        link_or_sha1 = state.update_entry(entry, abspath='a')
 
1645
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1593
1646
        self.assertIs(None, link_or_sha1)
1594
1647
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1595
1648
 
1610
1663
        stat_value = os.lstat('a')
1611
1664
        packed_stat = dirstate.pack_stat(stat_value)
1612
1665
 
1613
 
        link_or_sha1 = state.update_entry(entry, abspath='a')
 
1666
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1614
1667
        self.assertEqual('path/to/foo', link_or_sha1)
1615
1668
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1616
1669
                         entry[1])
1617
1670
        return packed_stat
1618
1671
 
1619
 
    def test_update_missing_file(self):
1620
 
        state, entry = self.get_state_with_a()
1621
 
        packed_stat = self.create_and_test_file(state, entry)
1622
 
        # Now if we delete the file, update_entry should recover and
1623
 
        # return None.
1624
 
        os.remove('a')
1625
 
        self.assertIs(None, state.update_entry(entry, abspath='a'))
1626
 
        # And the record shouldn't be changed.
1627
 
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1628
 
        self.assertEqual([('f', digest, 14, False, packed_stat)],
1629
 
                         entry[1])
1630
 
 
1631
 
    def test_update_missing_dir(self):
1632
 
        state, entry = self.get_state_with_a()
1633
 
        packed_stat = self.create_and_test_dir(state, entry)
1634
 
        # Now if we delete the directory, update_entry should recover and
1635
 
        # return None.
1636
 
        os.rmdir('a')
1637
 
        self.assertIs(None, state.update_entry(entry, abspath='a'))
1638
 
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1639
 
 
1640
 
    def test_update_missing_symlink(self):
1641
 
        if not osutils.has_symlinks():
1642
 
            # PlatformDeficiency / TestSkipped
1643
 
            raise TestSkipped("No symlink support")
1644
 
        state, entry = self.get_state_with_a()
1645
 
        packed_stat = self.create_and_test_symlink(state, entry)
1646
 
        os.remove('a')
1647
 
        self.assertIs(None, state.update_entry(entry, abspath='a'))
1648
 
        # And the record shouldn't be changed.
1649
 
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1650
 
                         entry[1])
1651
 
 
1652
1672
    def test_update_file_to_dir(self):
1653
1673
        """If a file changes to a directory we return None for the sha.
1654
1674
        We also update the inventory record.
1655
1675
        """
1656
1676
        state, entry = self.get_state_with_a()
 
1677
        # The file sha1 won't be cached unless the file is old
 
1678
        state.adjust_time(+10)
1657
1679
        self.create_and_test_file(state, entry)
1658
1680
        os.remove('a')
1659
1681
        self.create_and_test_dir(state, entry)
1664
1686
            # PlatformDeficiency / TestSkipped
1665
1687
            raise TestSkipped("No symlink support")
1666
1688
        state, entry = self.get_state_with_a()
 
1689
        # The file sha1 won't be cached unless the file is old
 
1690
        state.adjust_time(+10)
1667
1691
        self.create_and_test_file(state, entry)
1668
1692
        os.remove('a')
1669
1693
        self.create_and_test_symlink(state, entry)
1671
1695
    def test_update_dir_to_file(self):
1672
1696
        """Directory becoming a file updates the entry."""
1673
1697
        state, entry = self.get_state_with_a()
 
1698
        # The file sha1 won't be cached unless the file is old
 
1699
        state.adjust_time(+10)
1674
1700
        self.create_and_test_dir(state, entry)
1675
1701
        os.rmdir('a')
1676
1702
        self.create_and_test_file(state, entry)
1681
1707
            # PlatformDeficiency / TestSkipped
1682
1708
            raise TestSkipped("No symlink support")
1683
1709
        state, entry = self.get_state_with_a()
 
1710
        # The symlink target won't be cached if it isn't old
 
1711
        state.adjust_time(+10)
1684
1712
        self.create_and_test_dir(state, entry)
1685
1713
        os.rmdir('a')
1686
1714
        self.create_and_test_symlink(state, entry)
1690
1718
        if not has_symlinks():
1691
1719
            raise TestSkipped("No symlink support")
1692
1720
        state, entry = self.get_state_with_a()
 
1721
        # The symlink and file info won't be cached unless old
 
1722
        state.adjust_time(+10)
1693
1723
        self.create_and_test_symlink(state, entry)
1694
1724
        os.remove('a')
1695
1725
        self.create_and_test_file(state, entry)
1699
1729
        if not has_symlinks():
1700
1730
            raise TestSkipped("No symlink support")
1701
1731
        state, entry = self.get_state_with_a()
 
1732
        # The symlink target won't be cached if it isn't old
 
1733
        state.adjust_time(+10)
1702
1734
        self.create_and_test_symlink(state, entry)
1703
1735
        os.remove('a')
1704
1736
        self.create_and_test_dir(state, entry)
1718
1750
        packed_stat = dirstate.pack_stat(stat_value)
1719
1751
 
1720
1752
        state.adjust_time(-10) # Make sure everything is new
1721
 
        # Make sure it wants to kkkkkkkk
1722
1753
        state.update_entry(entry, abspath='a', stat_value=stat_value)
1723
1754
 
1724
1755
        # The row is updated, but the executable bit stays set.
 
1756
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1757
                         entry[1])
 
1758
 
 
1759
        # Make the disk object look old enough to cache
 
1760
        state.adjust_time(+20)
1725
1761
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1762
        state.update_entry(entry, abspath='a', stat_value=stat_value)
1726
1763
        self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
1727
1764
 
1728
1765