def test_runner(self):
test_loop = asyncio.get_event_loop()
test_loop.set_debug(True)
test_loop._close = test_loop.close
test_loop.close = lambda: None
_RES = []
@scenario(10)
async def here_one(session):
async with session.get('http://localhost:8888') as resp:
await resp.text()
_RES.append(1)
@scenario(90)
async def here_two(session):
session.statsd.incr('yopla')
_RES.append(2)
args = namedtuple('args', 'verbose quiet duration exception')
args.verbose = True
args.quiet = False
args.duration = 1
args.exception = True
args.console = True
args.processes = 1
args.workers = 1
args.debug = True
args.statsd = True
args.statsd_server = '127.0.0.1'
args.statsd_port = 9999
args.scenario = 'molotov.tests.test_run'
server = UDPServer('127.0.0.1', 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
with coserver():
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
self.assertTrue(len(_RES) > 0)
udp = server.flush()
self.assertTrue(len(udp) > 0)
test_loop._close()
def test_runner(self):
test_loop = asyncio.get_event_loop()
test_loop.set_debug(True)
test_loop._close = test_loop.close
test_loop.close = lambda: None
@global_setup()
def something_sync(args):
grab = request('http://localhost:8888')
self.assertEqual(grab['status'], 200)
grab_json = json_request('http://localhost:8888/molotov.json')
self.assertTrue('molotov' in grab_json['content'])
@scenario(weight=10)
async def here_one(session):
async with session.get('http://localhost:8888') as resp:
await resp.text()
_RES.append(1)
@scenario(weight=90)
async def here_two(session):
if session.statsd is not None:
session.statsd.incr('yopla')
_RES.append(2)
args = self._get_args()
server = UDPServer('127.0.0.1', 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
with coserver():
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
self.assertTrue(len(_RES) > 0)
udp = server.flush()
self.assertTrue(len(udp) > 0)
test_loop._close()
def test_statsd_multiprocess(self):
test_loop = asyncio.get_event_loop()
@scenario()
async def staty(session):
get_context(session).statsd.increment("yopla")
server = UDPServer("127.0.0.1", 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
args = self._get_args()
args.verbose = 2
args.processes = 2
args.max_runs = 5
args.duration = 1000
args.statsd = True
args.statsd_address = "udp://127.0.0.1:9999"
args.single_mode = "staty"
args.scenario = "molotov.tests.test_run"
stream = io.StringIO()
run(args, stream=stream)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
udp = server.flush()
incrs = 0
for line in udp:
for el in line.split(b"\n"):
if el.strip() == b"":
continue
incrs += 1
# two processes making 5 run each
# we want at least 5 here
self.assertTrue(incrs > 5)
stream.seek(0)
output = stream.read()
self.assertTrue("Happy breaking!" in output, output)
def test_runner(self):
test_loop = asyncio.get_event_loop()
@global_setup()
def something_sync(args):
grab = request("http://localhost:8888")
self.assertEqual(grab["status"], 200)
grab_json = json_request("http://localhost:8888/molotov.json")
self.assertTrue("molotov" in grab_json["content"])
@scenario(weight=10)
async def here_one(session):
async with session.get("http://localhost:8888") as resp:
await resp.text()
_RES.append(1)
@scenario(weight=90)
async def here_two(session):
if get_context(session).statsd is not None:
get_context(session).statsd.increment("yopla")
_RES.append(2)
args = self._get_args()
server = UDPServer("127.0.0.1", 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
args.max_runs = 3
args.duration = 9999
with coserver():
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
self.assertTrue(len(_RES) > 0)
udp = server.flush()
self.assertTrue(len(udp) > 0)
def test_runner(self):
test_loop = asyncio.get_event_loop()
@global_setup()
def something_sync(args):
grab = request('http://localhost:8888')
self.assertEqual(grab['status'], 200)
grab_json = json_request('http://localhost:8888/molotov.json')
self.assertTrue('molotov' in grab_json['content'])
@scenario(weight=10)
async def here_one(session):
async with session.get('http://localhost:8888') as resp:
await resp.text()
_RES.append(1)
@scenario(weight=90)
async def here_two(session):
if session.statsd is not None:
session.statsd.incr('yopla')
_RES.append(2)
args = self._get_args()
server = UDPServer('127.0.0.1', 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
args.max_runs = 3
with coserver():
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
self.assertTrue(len(_RES) > 0)
udp = server.flush()
self.assertTrue(len(udp) > 0)
def test_statsd_multiprocess(self):
test_loop = asyncio.get_event_loop()
test_loop.set_debug(True)
test_loop._close = test_loop.close
test_loop.close = lambda: None
@scenario()
async def staty(session):
session.statsd.incr('yopla')
server = UDPServer('127.0.0.1', 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
args = self._get_args()
args.verbose = 2
args.processes = 2
args.max_runs = 5
args.statsd = True
args.statsd_address = 'udp://127.0.0.1:9999'
args.single_mode = 'staty'
args.scenario = 'molotov.tests.test_run'
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
udp = server.flush()
incrs = 0
for line in udp:
for el in line.split(b'\n'):
if el.strip() == b'':
continue
incrs += 1
# two processes making 5 run each
self.assertEqual(incrs, 10)
test_loop._close()
def test_statsd_multiprocess(self):
test_loop = asyncio.get_event_loop()
@scenario()
async def staty(session):
session.statsd.incr('yopla')
server = UDPServer('127.0.0.1', 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
args = self._get_args()
args.verbose = 2
args.processes = 2
args.max_runs = 5
args.duration = 1000
args.statsd = True
args.statsd_address = 'udp://127.0.0.1:9999'
args.single_mode = 'staty'
args.scenario = 'molotov.tests.test_run'
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
udp = server.flush()
incrs = 0
for line in udp:
for el in line.split(b'\n'):
if el.strip() == b'':
continue
incrs += 1
# two processes making 5 run each
self.assertEqual(incrs, 10)
def test_runner(self):
test_loop = asyncio.get_event_loop()
test_loop.set_debug(True)
test_loop._close = test_loop.close
test_loop.close = lambda: None
@global_setup()
def something_sync(args):
grab = request('http://localhost:8888')
self.assertEqual(grab['status'], 200)
grab_json = json_request('http://localhost:8888/molotov.json')
self.assertTrue('molotov' in grab_json['content'])
@scenario(10)
async def here_one(session):
async with session.get('http://localhost:8888') as resp:
await resp.text()
_RES.append(1)
@scenario(90)
async def here_two(session):
if session.statsd is not None:
session.statsd.incr('yopla')
_RES.append(2)
args = namedtuple('args', 'verbose quiet duration exception')
args.verbose = 1
args.quiet = False
args.duration = 1
args.exception = True
args.console = True
args.processes = 1
args.workers = 1
args.debug = True
args.statsd = True
args.statsd_server = '127.0.0.1'
args.statsd_port = 9999
args.scenario = 'molotov.tests.test_run'
args.single_mode = None
args.max_runs = None
server = UDPServer('127.0.0.1', 9999, loop=test_loop)
_stop = asyncio.Future()
async def stop():
await _stop
await server.stop()
server_task = asyncio.ensure_future(server.run())
stop_task = asyncio.ensure_future(stop())
with coserver():
run(args)
_stop.set_result(True)
test_loop.run_until_complete(asyncio.gather(server_task, stop_task))
self.assertTrue(len(_RES) > 0)
udp = server.flush()
self.assertTrue(len(udp) > 0)
test_loop._close()