Ejemplo n.º 1
0
    def test_done_err(self):
        limiter = TaskLimiter(2)
        w = ManualWritable()

        limiter.add(w.write, 1)
        limiter.add(w.write, 2)
        limiter.add(w.write, 3)
        limiter.add(w.write, 4)

        d = limiter.done()
        self.assertFalse(d.called)
        self.assertEqual(w.writing, [1, 2])
        self.assertEqual(w.written, [])

        yield w.err(Exception())
        self.assertFalse(d.called)
        self.assertEqual(w.writing, [2, 3])
        self.assertEqual(w.written, [])

        yield w.err(Exception())
        self.assertFalse(d.called)
        self.assertEqual(w.writing, [3, 4])
        self.assertEqual(w.written, [])

        yield w.next()
        self.assertFalse(d.called)
        self.assertEqual(w.writing, [4])
        self.assertEqual(w.written, [3])

        yield w.err(Exception())
        self.assertTrue(d.called)
        self.assertEqual(w.writing, [])
        self.assertEqual(w.written, [3])
Ejemplo n.º 2
0
    def test_loop_retry_err(self):
        e1 = Exception()
        e3 = Exception()
        errors = self.patch_on_error()

        r = ManualReadable([1, 2, 3])
        w = ManualWritable()
        self.patch(RetrySenderWorker, 'next_req', staticmethod(r.read))
        self.patch(RetrySenderWorker, 'retry', staticmethod(w.write))

        yield self.mk_worker({
            'frequency': 5,
            'concurrency_limit': 2,
        })

        # We've read all three requests from redis and are busy retrying the
        # first two
        yield r.next()
        yield r.next()
        yield r.next()
        self.assertEqual(errors, [])
        self.assertEqual(r.unread, [])
        self.assertEqual(r.reading, [])
        self.assertEqual(w.writing, [1, 2])
        self.assertEqual(w.written, [])

        # Retry 1 throws an error, we catch it. We now have space for
        # request 3.
        yield w.err(e1)
        self.assertEqual(errors, [e1])
        self.assertEqual(r.unread, [])
        self.assertEqual(r.reading, [])
        self.assertEqual(w.writing, [2, 3])
        self.assertEqual(w.written, [])

        # Retry 2 succeeds.
        yield w.next()
        self.assertEqual(errors, [e1])
        self.assertEqual(r.unread, [])
        self.assertEqual(r.reading, [])
        self.assertEqual(w.writing, [3])
        self.assertEqual(w.written, [2])

        # Retry 3 throws an error, we catch it.
        yield w.err(e3)
        self.assertEqual(errors, [e1, e3])
        self.assertEqual(r.unread, [])
        self.assertEqual(r.reading, [])
        self.assertEqual(w.writing, [])
        self.assertEqual(w.written, [2])
Ejemplo n.º 3
0
 def test_err(self):
     w = ManualWritable()
     e = Exception()
     errs = []
     d = w.write(23)
     d.addErrback(lambda f: errs.append(f.value))
     yield w.err(e)
     self.assertEqual(errs, [e])
Ejemplo n.º 4
0
    def test_add_err(self):
        errs = []
        w = ManualWritable()
        limiter = TaskLimiter(2, lambda f: errs.append(f.value))

        e1, e2, e4 = [Exception() for i in range(3)]
        yield limiter.add(w.write, 1)
        yield limiter.add(w.write, 2)
        d3 = limiter.add(w.write, 3)
        d4 = limiter.add(w.write, 4)

        self.assertFalse(d3.called)
        self.assertFalse(d4.called)
        self.assertEqual(errs, [])
        self.assertEqual(w.writing, [1, 2])
        self.assertEqual(w.written, [])

        yield w.err(e1)
        yield d3
        self.assertEqual(errs, [e1])
        self.assertEqual(w.writing, [2, 3])
        self.assertEqual(w.written, [])

        yield w.err(e2)
        yield d4
        self.assertEqual(errs, [e1, e2])
        self.assertEqual(w.writing, [3, 4])
        self.assertEqual(w.written, [])

        yield w.next()
        self.assertEqual(w.writing, [4])
        self.assertEqual(w.written, [3])

        yield w.err(e4)
        self.assertEqual(errs, [e1, e2, e4])
        self.assertEqual(w.writing, [])
        self.assertEqual(w.written, [3])