def setUp(self, connections=2):
""" Create all threads necessary to run the parametrized test. Each thread will stablish a
connection and will bind to one queues.
"""
self._threads = [Consumer(messages=self.messages) for i in xrange(0, connections)]
map(lambda tq: tq[0].add_queue(QUEUE_NAME.format(number=tq[1])),
izip(cycle(self._threads), xrange(0, self.queues)))
def setUp(self, connections=2):
""" Create all connections necessary to run the parametrized test. Each connection will stablish a
will bind on a set of queues.
"""
self._ioloop = pika.adapters.select_connection.IOLoop()
# All consumers share the follwoing array, each time that ones consumer
# has finished its work checks if the other ones have finished their work, the
# last one will close the ioloop.
self._consumers_finsihed = [False] * connections
self._consumers = [Consumer(self._ioloop, i, self.messages, self._consumers_finsihed)
for i in xrange(0, connections)]
# it spreads the queues over the consumers until they run out.
map(lambda cq: cq[0].add_queue(QUEUE_NAME.format(number=cq[1])),
izip(cycle(self._consumers), xrange(0, self.queues)))
def run(tests=None, queues=None, messages=None):
""" Runs all many queues consumer tests using the `queues` amount
with the `messages` amount published in each one.
The tests to be executed can be filtered using the *args, setting as
arguments those test that we wanna run.
:param tests: list, Runs only these tests i.e ['pika_thread', ['pika_async']
By default runs all tests
:param queues: integer, defaults QUEUES. Runs the test using this amount of queues
:param messages: integer, defaults MESSAGES. Runs the test using this amount of messages
"""
def AMQP_OPERATION(f, args, result):
if f(*args) != result:
raise Exception("{}({}) did not return {}".format(f.__name__,
args,
result))
queues_ = queues if queues else QUEUES
messages_ = messages if messages else MESSAGES
tests_ = tests
logging.info('Running the tests with {} messages and {} queues, total messages {}'.format(messages_,
queues_,
messages_*queues_))
try:
# create all AMQP entities and bind the queues. We
# use a "macro" that checks that all was fine, otherwise
# raises a exception.
logging.info("Creating the Exchange {}".format(EXCHANGE_NAME))
AMQP_OPERATION(create_exchange, (EXCHANGE_NAME, 'fanout'), True)
logging.info("Creating {} queues".format(queues_))
for i in xrange(0, queues_):
queue_name = QUEUE_NAME.format(number=i)
logging.debug("Creating the Queue {} and binding it".format(queue_name))
AMQP_OPERATION(create_queue, (queue_name,), True)
AMQP_OPERATION(purge_queue, (queue_name,), True)
AMQP_OPERATION(set_binding, (EXCHANGE_NAME, queue_name, 'queue'), True)
logging.info("Queues created")
logging.info("Running tests")
results = []
for test in _installed_tests():
logging.info("+ {} test".format(test.NAME))
# filter those test that haven't been given.
if tests_ and test.NAME not in tests_:
logging.info("- filtered".format(test.NAME))
continue
# Each instsance returns a list of sort of executions to evaluate each
# test sceanrio with different configurations. At leas each test runs
# once time. Parameters are build using the queues and messaages parameters
# given to the constructor.
t = test(EXCHANGE_NAME, QUEUE_NAME, queues_, messages_)
for parameters in t.parameters():
logging.info("- Running with params {}".format(parameters))
try:
t.setUp(**parameters)
real, user, sys = t.run(**parameters)
results.append(
(test.NAME,
parameters,
real, user, sys,
(messages_*queues_)/real))
logging.info(_green_message("Finished"))
except (Exception, TestFailed), e:
logging.warning(_red_message("Failed {}".format(str(e))))
logging.debug(traceback.format_exc())
finally:
# always call the tearDown method for the specific
# test to avoid leave the environment dirty.
try:
t.tearDown(**parameters)
except Exception:
logging.warning(_red_message("tearDown failed"))
for parameters in t.parameters():
logging.info("- Running with params {}".format(parameters))
try:
t.setUp(**parameters)
real, user, sys = t.run(**parameters)
results.append(
(test.NAME,
parameters,
real, user, sys,
(messages_*queues_)/real))
logging.info(_green_message("Finished"))
except (Exception, TestFailed), e:
logging.warning(_red_message("Failed {}".format(str(e))))
logging.debug(traceback.format_exc())
finally:
# always call the tearDown method for the specific
# test to avoid leave the environment dirty.
try:
t.tearDown(**parameters)
except Exception:
logging.warning(_red_message("tearDown failed"))
finally:
# We have to remove the AMQP entities created before
# event there was a exception.
delete_exchange(EXCHANGE_NAME)
for i in xrange(0, queues_):
delete_queue(QUEUE_NAME.format(number=i))
logging.info('Leaving all AMQP stuff cleaned, removed exchanges and queues used by the tests')
return results
