← Back to branch summary

~didrocks/ubuntuone-client/use_result_var

« back to all changes in this revision

Viewing changes to tests/syncdaemon/test_eq_inotify.py

  • Committer: Bazaar Package Importer
  • Author(s): Rodney Dawes
  • Date: 2011-02-11 16:18:11 UTC
  • mto: This revision was merged to the branch mainline in revision 67.
  • Revision ID: james.westby@ubuntu.com-20110211161811-n18dj9lde7dxqjzr
Tags: upstream-1.5.4
Import upstream version 1.5.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/syncdaemon/test_eq_inotify.py
144
144
            self.finished_error(exception)
145
145
            raise exception
146
146
        return first
147
 
    assertEqual = assertEquals = failUnlessEquals = failUnlessEqual
 
147
    assertEqual = failUnlessEqual
148
148
 
149
149
 
150
150
class FreezeTests(BaseTwisted):
581
581
            self._deferred.errback(msg)
582
582
            raise exception
583
583
        return first
584
 
    assertEqual = assertEquals = failUnlessEquals = failUnlessEqual
 
584
    assertEqual = failUnlessEqual
585
585
 
586
586
    def test_file_events_are_ignored_on_udf_ancestor(self):
587
587
        """Events on UDF ancestors are ignored."""
605
605
 
606
606
        def check():
607
607
            """Check."""
608
 
            self.assertEquals([], self.listener.events)
 
608
            self.assertEqual([], self.listener.events)
609
609
            self._deferred.callback(True)
610
610
 
611
611
        reactor.callLater(.1, check)
631
631
        # generate FS_DIR_DELETE
632
632
        os.rmdir(fnamedir)
633
633
 
634
 
        expected = [('FS_FILE_CREATE', (), {'path': fname}),
635
 
                    ('FS_FILE_OPEN', (), {'path': fname}),
636
 
                    ('FS_FILE_CLOSE_WRITE', (), {'path': fname}),
637
 
                    ('FS_FILE_OPEN', (), {'path': fname}),
638
 
                    ('FS_FILE_CLOSE_NOWRITE', (), {'path': fname}),
639
 
                    ('FS_FILE_DELETE', (), {'path': fname}),
640
 
                    ('FS_DIR_CREATE', (), {'path': fnamedir}),
641
 
                    ('FS_DIR_DELETE', (), {'path': fnamedir})]
 
634
        expected = [('FS_FILE_CREATE', {'path': fname}),
 
635
                    ('FS_FILE_OPEN', {'path': fname}),
 
636
                    ('FS_FILE_CLOSE_WRITE', {'path': fname}),
 
637
                    ('FS_FILE_OPEN', {'path': fname}),
 
638
                    ('FS_FILE_CLOSE_NOWRITE', {'path': fname}),
 
639
                    ('FS_FILE_DELETE', {'path': fname}),
 
640
                    ('FS_DIR_CREATE', {'path': fnamedir}),
 
641
                    ('FS_DIR_DELETE', {'path': fnamedir})]
642
642
 
643
643
        def check():
644
644
            """Check."""
651
651
    def test_file_events_are_not_ignored_on_common_prefix_name(self):
652
652
        """Events in a UDF with similar name to ancestor are not ignored."""
653
653
        fname = os.path.join(self.udf2.path, 'testit')
654
 
        expected = [('FS_FILE_CREATE', (), {'path': fname}),
655
 
                    ('FS_FILE_OPEN', (), {'path': fname}),
656
 
                    ('FS_FILE_CLOSE_WRITE', (), {'path': fname}),
657
 
                    ('FS_FILE_OPEN', (), {'path': fname}),
658
 
                    ('FS_FILE_CLOSE_NOWRITE', (), {'path': fname})]
 
654
        expected = [('FS_FILE_CREATE', {'path': fname}),
 
655
                    ('FS_FILE_OPEN', {'path': fname}),
 
656
                    ('FS_FILE_CLOSE_WRITE', {'path': fname}),
 
657
                    ('FS_FILE_OPEN', {'path': fname}),
 
658
                    ('FS_FILE_CLOSE_NOWRITE', {'path': fname})]
659
659
 
660
660
        def check():
661
661
            """Check."""
691
691
                    udf = self.udf2
692
692
                else:
693
693
                    self._deferred.errback(ValueError("uid %s is wrong" % uid))
694
 
                self.assertEquals(False, self.eq.has_watch(udf.path),
 
694
                self.assertEqual(False, self.eq.has_watch(udf.path),
695
695
                                  'watch must be removed')
696
 
                self.assertEquals(False, self.eq.fs.vm.udfs[udf.id].subscribed)
 
696
                self.assertEqual(False, self.eq.fs.vm.udfs[udf.id].subscribed)
697
697
            self._deferred.callback(True)
698
698
 
699
699
        def unsubsc(uid):
720
720
        unsubscribed = []
721
721
        def check():
722
722
            """Check."""
723
 
            self.assertEquals(len(unsubscribed), 1)
 
723
            self.assertEqual(len(unsubscribed), 1)
724
724
            uid = unsubscribed[0]
725
 
            self.assertEquals(uid, self.udf.id, "wrong UDF removed!")
726
 
            self.assertEquals(False, self.eq.has_watch(self.udf.path),
 
725
            self.assertEqual(uid, self.udf.id, "wrong UDF removed!")
 
726
            self.assertEqual(False, self.eq.has_watch(self.udf.path),
727
727
                              'watch must be removed')
728
 
            self.assertEquals(False,
 
728
            self.assertEqual(False,
729
729
                              self.eq.fs.vm.udfs[self.udf.id].subscribed)
730
730
            self._deferred.callback(True)
731
731
 
761
761
 
762
762
        def check():
763
763
            """Check."""
764
 
            self.assertEquals([], self.listener.events)
765
 
            self.assertEquals(expected, [uid], 'udf deleted')
 
764
            self.assertEqual([], self.listener.events)
 
765
            self.assertEqual(expected, [uid], 'udf deleted')
766
766
            self._deferred.callback(True)
767
767
 
768
768
        reactor.callLater(.1, check)
789
789
 
790
790
        def check():
791
791
            """Check."""
792
 
            self.assertEquals([], self.listener.events)
793
 
            self.assertEquals(expected, [], 'udf should not be deleted')
 
792
            self.assertEqual([], self.listener.events)
 
793
            self.assertEqual(expected, [], 'udf should not be deleted')
794
794
            self._deferred.callback(True)
795
795
 
796
796
        reactor.callLater(.1, check)
815
815
        # and should not be removed
816
816
        expected = os.path.dirname(self.udf.path)
817
817
        def check():
818
 
            self.assertEquals([expected], removed_watches,
 
818
            self.assertEqual([expected], removed_watches,
819
819
                              "Removed watches don't match the expected")
820
820
            self._deferred.callback(True)
821
821
 
843
843
        # and should not be removed, and the path of the udf itself
844
844
        expected = [os.path.dirname(self.udf.path), self.udf.path]
845
845
        def check():
846
 
            self.assertEquals(sorted(expected), sorted(removed_watches),
 
846
            self.assertEqual(sorted(expected), sorted(removed_watches),
847
847
                              "Removed watches don't match the expected")
848
848
            self._deferred.callback(True)
849
849
 
871
871
        expected = list(set(self.udf.ancestors) | set(self.udf2.ancestors)) + [
872
872
                            self.udf.path, self.udf2.path]
873
873
        def check():
874
 
            self.assertEquals(sorted(expected), sorted(removed_watches),
 
874
            self.assertEqual(sorted(expected), sorted(removed_watches),
875
875
                              "Removed watches don't match the expected")
876
876
            self._deferred.callback(True)
877
877
 
1708
1708
 
1709
1709
        def check(record):
1710
1710
            self.assertIn(testfile, record.args)
1711
 
            self.assertEquals(1, len(record.args))
 
1711
            self.assertEqual(1, len(record.args))
1712
1712
        self._deferred.addCallback(check)
1713
1713
        return self._deferred
1714
1714
 
1741
1741
 
1742
1742
        def check(record):
1743
1743
            self.assertIn(testdir, record.args)
1744
 
            self.assertEquals(1, len(record.args))
 
1744
            self.assertEqual(1, len(record.args))
1745
1745
        self._deferred.addCallback(check)
1746
1746
        return self._deferred
1747
1747
 
 
1748
    @defer.inlineCallbacks
1748
1749
    def _create_udf(self, vol_id, path):
1749
1750
        """Create an UDF and returns it and the volume"""
1750
1751
        os.makedirs(path)
1751
1752
        udf = volume_manager.UDF(vol_id, "node_id", path.decode('utf-8'),
1752
1753
                                 path, True)
1753
 
        self.vm.add_udf(udf)
 
1754
        yield self.vm.add_udf(udf)
1754
1755
 
 
1756
    @defer.inlineCallbacks
1755
1757
    def test_move_dir_across_volumes(self):
1756
1758
        """Dir move between volumes is deletion and creation."""
1757
1759
        # base dir 1
1758
1760
        base1 = os.path.join(self.home_dir, "dir1")
1759
 
        self._create_udf('vol1', base1)
 
1761
        yield self._create_udf('vol1', base1)
1760
1762
        self.fs.create(path=base1, share_id='vol1', is_dir=True)
1761
1763
 
1762
1764
        # base dir 2
1763
1765
        base2 = os.path.join(self.home_dir, "dir2")
1764
 
        self._create_udf('vol2', base2)
 
1766
        yield self._create_udf('vol2', base2)
1765
1767
        self.fs.create(path=base2, share_id='vol2', is_dir=True)
1766
1768
 
1767
1769
        # working stuff
1779
1781
 
1780
1782
        # generate the event
1781
1783
        os.rename(moving1, moving2)
1782
 
        return self._deferred
 
1784
        yield self._deferred
1783
1785
 
 
1786
    @defer.inlineCallbacks
1784
1787
    def test_move_file_across_volumes(self):
1785
1788
        """File ove between volumes is deletion and creation (and write)."""
1786
1789
        # base dir 1
1787
1790
        base1 = os.path.join(self.home_dir, "dir1")
1788
 
        self._create_udf('vol1', base1)
 
1791
        yield self._create_udf('vol1', base1)
1789
1792
        self.fs.create(path=base1, share_id='vol1', is_dir=True)
1790
1793
 
1791
1794
        # base dir 2
1792
1795
        base2 = os.path.join(self.home_dir, "dir2")
1793
 
        self._create_udf('vol2', base2)
 
1796
        yield self._create_udf('vol2', base2)
1794
1797
        self.fs.create(path=base2, share_id='vol2', is_dir=True)
1795
1798
 
1796
1799
        # working stuff
1809
1812
 
1810
1813
        # generate the event
1811
1814
        os.rename(moving1, moving2)
1812
 
        return self._deferred
 
1815
        yield self._deferred
1813
1816
 
1814
1817
 
1815
1818
def test_suite():