def test_remote_change_event(self):
        """ Test whether changes by other users result in events. """
        store2 = LockingFileSystemStore(self.path)
        store2._remote_event_poll_interval = self.store._remote_event_poll_interval = 0.1

        events = []
        lock = threading.Lock()

        def callback(event):
            events.append(event)
            lock.release()

        self.store.event_manager.connect(StoreSetEvent, callback)
        lock.acquire()
        store2.set_metadata('key', {'name': 'key'})

        # Wait until the event is emitted.
        with lock:
            self.assertEqual(len(events), 1)

        thread = self.store._remote_poll_thread
        self.store._remote_poll_thread = None
        thread.join()
        thread = store2._remote_poll_thread
        store2._remote_poll_thread = None
        thread.join()
    def test_remote_change_event(self):
        """ Test whether changes by other users result in events. """
        store2 = LockingFileSystemStore(self.path)
        store2._remote_event_poll_interval = self.store._remote_event_poll_interval = 0.1

        events = []
        lock = threading.Lock()
        def callback(event):
            events.append(event)
            if lock.locked():
                # Prevent double-release on some filesystems where multiple
                # events get emitted occasionally
                lock.release()
        self.store.event_manager.connect(StoreSetEvent, callback)
        lock.acquire()
        store2.set_metadata('key', {'name':'key'})

        # Wait until the event is emitted.
        with lock:
            self.assertTrue(len(events) >= 1)

        thread = self.store._remote_poll_thread
        self.store._remote_poll_thread = None
        thread.join()
        thread = store2._remote_poll_thread
        store2._remote_poll_thread = None
        thread.join()
    def test_remote_change_event(self):
        """ Test whether changes by other users result in events. """
        store2 = LockingFileSystemStore(self.path)
        store2._remote_event_poll_interval = self.store._remote_event_poll_interval = 0.1

        events = []
        lock = threading.Lock()

        def callback(event):
            events.append(event)
            if lock.locked():
                # Prevent double-release on some filesystems where multiple
                # events get emitted occasionally
                lock.release()

        self.store.event_manager.connect(StoreSetEvent, callback)
        lock.acquire()
        store2.set_metadata('key', {'name': 'key'})

        # Wait until the event is emitted.
        with lock:
            self.assertTrue(len(events) >= 1)

        thread = self.store._remote_poll_thread
        self.store._remote_poll_thread = None
        thread.join()
        thread = store2._remote_poll_thread
        store2._remote_poll_thread = None
        thread.join()
    def test_remote_change_event(self):
        """ Test whether changes by other users result in events. """
        store2 = LockingFileSystemStore(self.path)
        store2._remote_event_poll_interval = self.store._remote_event_poll_interval = 0.1

        got_file_system_event = threading.Event()
        def callback(event):
            got_file_system_event.set()
        self.store.event_manager.connect(StoreSetEvent, callback)
        store2.set_metadata('key', {'name':'key'})

        # Wait until the event is emitted; fail if not emitted
        # within 10 seconds.
        event_occurred = got_file_system_event.wait(timeout=10.0)
        self.assertTrue(event_occurred)

        thread = self.store._remote_poll_thread
        self.store._remote_poll_thread = None
        thread.join()
        thread = store2._remote_poll_thread
        store2._remote_poll_thread = None
        thread.join()
    def test_remote_change_event(self):
        """ Test whether changes by other users result in events. """
        store2 = LockingFileSystemStore(self.path)
        store2._remote_event_poll_interval = self.store._remote_event_poll_interval = 0.1

        events = []
        lock = threading.Lock()
        def callback(event):
            events.append(event)
            lock.release()
        self.store.event_manager.connect(StoreSetEvent, callback)
        lock.acquire()
        store2.set_metadata('key', {'name':'key'})

        # Wait until the event is emitted.
        with lock:
            self.assertEqual(len(events), 1)

        thread = self.store._remote_poll_thread
        self.store._remote_poll_thread = None
        thread.join()
        thread = store2._remote_poll_thread
        store2._remote_poll_thread = None
        thread.join()