def test_looping(self):
        # Push several items with a delay of 1s
        queue = BlacklistQueue(delay=1)
        queue.push(1, "Item1")
        queue.push(2, "Item2")
        queue.push(3, "Item3")
        queue.push(4, "Item4")
        queue.push(5, "Item5")
        queue.push(6, "Item6")
        queue.push(7, "Item7")
        log.debug('queue:\n%s', str(queue))

        count = 0
        for item in queue.process_items():
            if item:
                log.debug('item: %s', item.get_id())
                count += 1

        self.assertEqual(queue.size(), 7, "queue size has changed")
        self.assertEqual(count, 0, "no item should have been ready for processing")

        sleep_time = 3
        sleep(sleep_time)
        for item in queue.process_items():
            if item:
                log.debug('item: %s', item.get_id())
                count += 1
                queue.repush(item)

        self.assertEqual(queue.size(), 7, "queue size has changed")
        self.assertEqual(count, 7, "all items should have been ready for processing")

        log.debug('queue:\n%s', str(queue))
        count = 0
        for item in queue.process_items():
            if item:
                log.debug('item: %s', item.get_id())
                count += 1

        self.assertEqual(queue.size(), 7, "queue size has changed")
        self.assertEqual(count, 0, "no item should have been ready for processing after repush")

        sleep_time = 4
        sleep(sleep_time)
        log.debug('queue:\n%s', str(queue))
        count = 0
        for item in queue.process_items():
            if item:
                log.debug('item: %s', item.get_id())
                count += 1

        self.assertTrue(queue.is_empty(), 'queue is not empty')
        self.assertEqual(count, 7, "all items should have been ready for processing after repush")
    def test_delay(self):
        sleep_time = 3
        # Push two items with a delay of 1s
        queue = BlacklistQueue(delay=1)
        queue.push(1, "Item1")
        queue.push(2, "Item2")

        # Verify no item is returned back before 1s
        item = queue.get()
        self.assertIsNone(item)
        sleep(sleep_time)

        # Verfiy we get the two items now
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEqual(item.get(), "Item1")
        self.assertEqual(item.get_id(), 1)
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEqual(item.get(), "Item2")
        self.assertEqual(item.get_id(), 2)
        self.assertEqual(item._count, 1)

        # Repush item without increasing delay
        queue.repush(item, increase_wait=False)
        item = queue.get()
        self.assertIsNone(item)
        sleep(sleep_time)

        # We should get the repushed item after 1s wait
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEqual(item.get(), "Item2")
        self.assertEqual(item.get_id(), 2)
        self.assertEqual(item._count, 2)

        # Repush item with increase
        queue.repush(item, increase_wait=True)
        sleep(sleep_time)
        item = queue.get()
        self.assertIsNone(item)
        sleep(sleep_time)
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEqual(item.get(), "Item2")
        self.assertEqual(item.get_id(), 2)
        self.assertEqual(item._count, 3)
        item = queue.get()
        self.assertIsNone(item)
Beispiel #3
0
def test_delay():
    sleep_time = 3

    # Push two items with a delay of 1s
    queue = BlacklistQueue(delay=1)
    queue.push("1", "Item1")
    queue.push("2", "Item2")

    # Verify no item is returned back before 1s
    assert not list(queue.get())
    sleep(sleep_time)

    # Verfiy we get the two items now
    item = next(queue.get())
    assert isinstance(item, BlacklistItem)
    assert item.name == "Item1"
    assert item.uid == "1"
    item = next(queue.get())
    assert item.name == "Item2"
    assert item.uid == "2"
    assert item.count == 1

    # Repush item without increasing delay
    queue.repush(item, increase_wait=False)
    assert not list(queue.get())
    sleep(sleep_time)

    # We should get the repushed item after 1s wait
    item = next(queue.get())
    assert item.name == "Item2"
    assert item.uid == "2"
    assert item.count == 2

    # Repush item with increase
    queue.repush(item, increase_wait=True)
    sleep(sleep_time)
    assert not list(queue.get())

    sleep(sleep_time)
    item = next(queue.get())
    assert item.name == "Item2"
    assert item.uid == "2"
    assert item.count == 3
    assert not list(queue.get())
Beispiel #4
0
 def __init__(self, manager, folder, url):
     super(DirectEdit, self).__init__()
     self._test = False
     self._manager = manager
     self._url = url
     self._thread.started.connect(self.run)
     self._event_handler = None
     self._metrics = dict()
     self._metrics['edit_files'] = 0
     self._observer = None
     if isinstance(folder, bytes):
         folder = unicode(folder)
     self._folder = folder
     self._local_client = LocalClient(self._folder)
     self._upload_queue = Queue()
     self._lock_queue = Queue()
     self._error_queue = BlacklistQueue()
     self._stop = False
     self._manager.get_autolock_service().orphanLocks.connect(
         self._autolock_orphans)
     self._last_action_timing = -1
    def test_delay(self):
        sleep_time = 3
        # Push two items with a delay of 1s
        queue = BlacklistQueue(delay=1)
        interval1 = queue.push(1, "Item1")
        interval2 = queue.push(2, "Item2")
        log.debug('interval1=%d', interval1)
        log.debug('interval2=%d', interval2)
        log.debug('queue:\n%s', str(queue))

        # Verify no item is returned back before 1s
        item = queue.get()
        self.assertIsNone(item)
        sleep(sleep_time)
        # Verify we get the two items now
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEquals(item.get(), "Item1")
        self.assertEquals(item.get_id(), 1)
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEquals(item.get(), "Item2")
        self.assertEquals(item.get_id(), 2)
        self.assertEquals(item._count, 1)
        # Repush item without increasing delay
        queue.repush(item, increase_wait=False)
        item = queue.get()
        self.assertIsNone(item)
        sleep(sleep_time)
        # We should get the repushed item after 1s wait
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEquals(item.get(), "Item2")
        self.assertEquals(item.get_id(), 2)
        self.assertEquals(item._count, 2)

        # Repush item with increase
        interval3 = queue.push(3, "Item3")
        log.debug('interval3=%d', interval3)
        item = queue.get()
        self.assertIsNone(item)
        sleep(sleep_time)
        # Verify we get the item now
        item = queue.get()
        self.assertIsNotNone(item)
        self.assertEquals(item.get(), "Item3")
        self.assertEquals(item.get_id(), 3)
        log.debug('queue:\n%s', str(queue))

        for i in range(1, 3):
            queue.repush(item, increase_wait=True)
            log.debug('item after repush:\n%s', str(item))
            log.debug('queue after repush:\n%s', str(queue))
            # sleep time should be at least 2 ** i + 20%
            min_sleep_time = int(0.8 * 2 ** i) - 1
            max_sleep_time = int(1.2 * 2 ** i) + 2
            if min_sleep_time < 0:
                min_sleep_time = 0

            log.debug('min sleep time=%d', min_sleep_time)
            log.debug('max sleep time=%d', max_sleep_time)
            if min_sleep_time > 0:
                log.debug('sleep %d', min_sleep_time)
                sleep(min_sleep_time)
                max_sleep_time -= min_sleep_time
            item = queue.get()
            self.assertIsNone(item)
            log.debug('sleep %d', max_sleep_time)
            sleep(max_sleep_time)
            item = queue.get()
            self.assertIsNotNone(item)
            self.assertEquals(item.get(), "Item3")
            self.assertEquals(item.get_id(), 3)
            self.assertEquals(item._count, i + 1)