← Back to branch summary

~didrocks/ubuntuone-client/use_result_var

« back to all changes in this revision

Viewing changes to tests/syncdaemon/test_sync.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_sync.py
53
53
class TestSyncClassAPI(unittest.TestCase):
54
54
    """Tests that make sure the Sync class has the correct API."""
55
55
 
56
 
    def test_error_handle_signatures(self):
57
 
        """Make sure signatures match for the error handlers.
 
56
    def test_handle_signatures(self):
 
57
        """Make sure signatures match for the handlers.
58
58
 
59
59
        Each handle_<EVENT> should map to an EVENT in event_queue and have the
60
60
        same signature.
61
61
        """
62
 
        for k in [k for k in dict(getmembers(Sync)) if k.startswith('handle_')]:
63
 
            handler = getattr(Sync, k, None)
 
62
        handls = (k for k in dict(getmembers(Sync)) if k.startswith('handle_'))
 
63
        for handle in handls:
 
64
            handler = getattr(Sync, handle, None)
64
65
            # it must be a method
65
66
            self.assertTrue(ismethod(handler))
66
 
            event = EVENTS.get(k.replace('handle_', ''))
67
 
            # there must be a matching EVENT
68
 
            self.assertNotEqual(event, None)
69
 
            spec = getargspec(handler).args[1::]
 
67
            event = EVENTS[handle.replace('handle_', '')]
 
68
            spec = getargspec(handler).args[1:]
70
69
            # the argspec must also match (same order same variable names)
71
 
            self.assertEqual(list(event),spec,
72
 
                "Handler %s args do not match event args %s" % (k, event))
 
70
            self.assertEqual(list(event), spec,
 
71
                "Handler %s args do not match event args %s" % (handle, event))
73
72
 
74
73
 
75
74
class FSKeyTestCase(BaseTwistedTestCase):
76
75
    """ Base test case for FSKey """
77
76
 
 
77
    @defer.inlineCallbacks
78
78
    def setUp(self):
79
79
        """ Setup the test """
80
80
        unittest.TestCase.setUp(self)
93
93
                                     self.db)
94
94
        self.eq = EventQueue(self.fsm)
95
95
        self.fsm.register_eq(self.eq)
96
 
        self.share = self.create_share('share', 'share_name',
97
 
                                            self.fsm, self.shares_dir)
 
96
        self.share = yield self.create_share('share', 'share_name')
98
97
        self.share_path = self.share.path
99
98
 
100
99
    def tearDown(self):
103
102
        self.db.shutdown()
104
103
        shutil.rmtree(self.test_dir)
105
104
 
106
 
    @staticmethod
107
 
    def create_share(share_id, share_name, fsm, shares_dir,
108
 
                     access_level='Modify'):
109
 
        """ creates a share """
110
 
        share_path = os.path.join(shares_dir, share_name)
 
105
    @defer.inlineCallbacks
 
106
    def create_share(self, share_id, share_name, access_level='Modify'):
 
107
        """Create a share."""
 
108
        share_path = os.path.join(self.shares_dir, share_name)
111
109
        os.makedirs(share_path)
112
110
        share = Share(path=share_path, volume_id=share_id,
113
111
                      access_level=access_level)
114
 
        fsm.vm.add_share(share)
115
 
        return share
 
112
        yield self.fsm.vm.add_share(share)
 
113
        defer.returnValue(share)
116
114
 
117
115
 
118
116
class FSKeyTests(FSKeyTestCase):
1470
1468
        # check event
1471
1469
        kwargs = dict(volume_id=mdobj.share_id, node_id=mdobj.node_id,
1472
1470
                      path=mdobj.path, mdid=mdobj.mdid)
1473
 
        self.assertTrue(("SYS_BROKEN_NODE", (), kwargs) in listener.events)
 
1471
        self.assertTrue(("SYS_BROKEN_NODE", kwargs) in listener.events)
1474
1472
 
1475
1473
    def test_dirty_node_sends_event_nonode(self):
1476
1474
        """When a node is marked dirty, an event should fly, no node."""
1482
1480
 
1483
1481
        # check event
1484
1482
        kwargs = dict(volume_id='volume', node_id='node', path=None, mdid=None)
1485
 
        self.assertTrue(("SYS_BROKEN_NODE", (), kwargs) in listener.events)
 
1483
        self.assertTrue(("SYS_BROKEN_NODE", kwargs) in listener.events)
1486
1484
 
1487
1485
    def test_dirty_node_logs_special(self):
1488
1486
        """When a node is marked dirty, it should log in a special handler."""
1619
1617
        # check event
1620
1618
        kwargs = dict(volume_id=ROOT, node_id='node_id', parent_id="parent_id",
1621
1619
                      name="file")
1622
 
        self.assertIn(("SV_FILE_NEW", (), kwargs), self.listener.events)
 
1620
        self.assertIn(("SV_FILE_NEW", kwargs), self.listener.events)
1623
1621
 
1624
1622
    def test_server_new_dir_sends_event(self):
1625
1623
        """When a new directory is created on the server, an event is sent."""
1631
1629
        # check event
1632
1630
        kwargs = dict(volume_id=ROOT, node_id='node_id', parent_id="parent_id",
1633
1631
                      name="file")
1634
 
        self.assertIn(("SV_DIR_NEW", (), kwargs), self.listener.events)
 
1632
        self.assertIn(("SV_DIR_NEW", kwargs), self.listener.events)
1635
1633
 
1636
1634
    def test_server_file_deleted_sends_event(self):
1637
1635
        """When a file is deleted, an event is sent."""
1642
1640
 
1643
1641
        # check event
1644
1642
        kwargs = dict(volume_id=ROOT, node_id='node_id', is_dir=True)
1645
 
        self.assertIn(("SV_FILE_DELETED", (), kwargs), self.listener.events)
 
1643
        self.assertIn(("SV_FILE_DELETED", kwargs), self.listener.events)