def test_iterationProducer(self):
N1, N2 = 50, 100
stuff = TestStuff()
stuff.setStuff(N1, N2)
consumer = IterationConsumer(self.verbose)
yield self.queue.call(stuff.stufferator, consumer=consumer)
for chunk in consumer.data:
self.assertEqual(len(chunk), N1)
self.assertEqual(len(consumer.data), N2)
def test_iterates(self):
N = 10
gf = generatorFunction("x", N)
consumer = IterationConsumer(self.isVerbose())
ip = yield iteration.iteratorToProducer(gf, consumer)
result = yield ip.deferUntilDone()
self.assertEqual(result, consumer)
self.assertEqual(len(consumer.data), N)
for k in xrange(N):
self.assertEqual(consumer.data[k], "x" * k)
def test_iterate_nextWhileIterating(self):
slowConsumer = IterationConsumer(self.verbose, writeTime=0.2)
# In this case, do NOT wait for the done-iterating deferred
# before doing another transaction
d = self.broker.everybody(consumer=slowConsumer)
# Add a new person while we are iterating the people from the
# last query
yield self.broker.addPerson("George", "Washington")
# Confirm we have one more person now
fastConsumer = IterationConsumer(self.verbose)
yield self.broker.everybody(consumer=fastConsumer)
self.assertEqual(len(fastConsumer.data), 6)
# Now wait for the slow consumer
yield d
# It still should only have gotten the smaller number of people
self.assertEqual(len(slowConsumer.data), 5)
# Wait for the slow consumer's last write delay, just to avoid
# unclean reactor messiness
yield slowConsumer.d
def test_iterates_and_stops(self):
N = 5
# The generator will yield twice as many values as the
# consumer will accept.
gf = generatorFunction("x", 2 * N)
consumer = IterationConsumer(self.isVerbose(), N)
ip = yield iteration.iteratorToProducer(gf, consumer)
result = yield ip.deferUntilDone()
self.assertEqual(result, consumer)
self.assertEqual(len(consumer.data), N)
for k in xrange(N):
self.assertEqual(consumer.data[k], "x" * k)
def test_runManually(self):
N = 10
gf = generatorFunction("x", N)
dr = iteration.Deferator(gf)
ip = iteration.IterationProducer(dr)
consumer = IterationConsumer(self.isVerbose())
ip.registerConsumer(consumer)
result = yield ip.run()
self.assertEqual(result, consumer)
self.assertEqual(len(consumer.data), N)
for k in xrange(N):
self.assertEqual(consumer.data[k], "x" * k)
def test_selectorator_twoConcurrently(self):
slowConsumer = IterationConsumer(self.verbose, writeTime=0.2)
cols = self.broker.people.c
# In this case, do NOT wait for the done-iterating deferred
# before doing another selectoration
dSelectExecuted = defer.Deferred()
s = self.broker.select([cols.name_last, cols.name_first])
d = self.broker.selectorator(s, slowConsumer, dSelectExecuted)
# Wait until the query was executed...
yield dSelectExecuted
# ...then add a new person while we are iterating the people
# from that query
yield self.broker.addPerson("George", "Washington")
# Confirm we have one more person now
fastConsumer = IterationConsumer(self.verbose)
yield self.broker.everybody(consumer=fastConsumer)
#self.assertEqual(len(fastConsumer.data), 6)
# Now wait for the slow consumer
yield d
# It still should only have gotten the smaller number of people
self.assertEqual(len(slowConsumer.data), 5)
# Wait for the slow consumer's last write delay, just to avoid
# unclean reactor messiness
yield slowConsumer.d
def test_handleResult_asProducer(self):
def getResultToHandle():
col = self.broker.people.c
s = SA.select([col.name_first, col.name_last])
return s.execute()
fc = FakeConnection()
rp = yield self.broker.deferToQueue(getResultToHandle)
consumer = IterationConsumer(self.verbose, 0.05)
yield self.broker.handleResult(rp, consumer=consumer, conn=fc)
yield consumer.d
for k, row in enumerate(consumer.data):
self.assertIn(row, self.broker.defaultRoster)
self.assertEqual(k, 4)
self.assertTrue(fc.wasClosed)
def test_selectorator_withConsumer(self):
consumer = IterationConsumer(self.verbose)
cols = self.broker.people.c
s = self.broker.select([cols.name_last, cols.name_first])
consumer = yield self.broker.selectorator(s, consumer)
self.assertEqual(len(consumer.data), 5)
def test_iterate_withConsumer(self):
consumer = IterationConsumer(self.verbose)
yield self.broker.everybody(consumer=consumer)
self.assertEqual(len(consumer.data), 5)