def export_stubs():
parser = ArgumentParser(description="Export scenario stubs")
parser.add_argument('-s',
'--scenario',
dest='scenario',
help="scenario name")
parser.add_argument('-p',
'--static-path-dir',
dest='static_path',
default=None,
help="Path to static dir to export files. If not "
"specified the output will placed in a tmp dir.")
args = parser.parse_args()
scenario = args.scenario
if args.static_path:
request = DummyRequestHandler(static_path=args.static_path)
else:
request = DummyRequestHandler()
init_mongo()
slave, master = start_redis({})
response = api.export_stubs(request, scenario)
print json.dumps(response,
sort_keys=True,
indent=4,
separators=(',', ': '))
def test_get_tracks_with_args(self):
from stubo.service.admin import get_tracks
import datetime
dt = datetime.datetime(2013, 12, 11, 13, 0, 0)
response = get_tracks(DummyRequestHandler(), 'xyz',
'mangle', True, 50, 1000,
dt.strftime('%Y-%m-%d %H:%M:%S'), 200, True,
'get/response')
self.assertEqual(
response['_filter'], {
'function': 'get/response',
'scenario': {
'$regex': 'xyz'
},
'request_params.session': {
'$regex': 'mangle'
},
'start_time': {
'$lt': dt
},
'duration_ms': {
'$gt': 200
},
'return_code': {
'$ne': 200
}
})
self.assertEqual(response['_skip'], 50)
self.assertEqual(response['_limit'], 1000)
def test_missing_session_param(self):
from stubo.exceptions import HTTPClientError
from urlparse import urlparse
cmds = self.make_one(DummyRequestHandler())
with self.assertRaises(HTTPClientError):
cmds.run_command(urlparse('put/stub'), 1)
def test_get_tracks_with_bad_dt(self):
from stubo.service.admin import get_tracks
from stubo.exceptions import HTTPClientError
with self.assertRaises(HTTPClientError):
get_tracks(DummyRequestHandler(), '', '', False, 50, 1000,
'13-12-11', 0, False, '')
def latency_pcent():
parser = ArgumentParser(
description="Get response latency % > limit"
)
parser.add_argument('-c', '--cluster', dest='cluster',
help="cluster name", default='aws_cluster1')
parser.add_argument('-p', '--percent_above_value', dest='percent_above_value',
help="percent found above this value",
default='50')
parser.add_argument('-f', '--from', dest='from_str',
help="from (relative or absolute time period to graph)",
default="-1hours")
parser.add_argument('-t', '--to', dest='to_str',
help="to (relative or absolute time period to graph)",
default="now")
args = parser.parse_args()
cluster = args.cluster
percent_above_value = args.percent_above_value
args = {
'cluster_name' : args.cluster,
'percent_above_value' : args.percent_above_value,
'from' : [args.from_str],
'to' : [args.to_str]
}
handler = DummyRequestHandler(**args)
try:
response = get_stats(handler)
print response
except StuboException, e:
print e
def test_get_tracks(self):
from stubo.service.admin import get_tracks
response = get_tracks(DummyRequestHandler(), '', False, 0, 100,
'', 0, False, '')
self.assertEqual(response['_filter'], {'function': '',
'host': 'localhost'})
self.assertEqual(response['_skip'], 0)
self.assertEqual(response['_limit'], 100)
def list_stubs_core(host, scenario):
init_mongo()
response = api.list_stubs(DummyRequestHandler(), scenario, host)
if response:
result = json.dumps(response,
sort_keys=True,
indent=4,
separators=(',', ': '))
else:
result = 'no stubs found'
return result
def test_put_stub_empty_response(self):
cmds = self.make_one(DummyRequestHandler(), 'cmd_file_empty_response')
response = cmds.run()
self.assertTrue('executed_commands' in response)
self.assertEqual(len(response['executed_commands']['commands']), 3)
self.assertEqual(response['executed_commands']['commands'][1],
('put/stub?session=xy, matcher_text, EMPTY_RESPONSE', 400,
'400: put/stub response text can not be empty.: The server could '
'not comply with the request since it is either malformed or otherwise incorrect.'))
def test_put_stub_with_response_urltext(self):
cmds = self.make_one(DummyRequestHandler(), 'cmd_file4')
cmds.run()
self.assertTrue(len(self.requests.posts) == 4)
def test_get_response_no_session(self):
cmds = self.make_one(DummyRequestHandler(), 'cmd_file6')
responses = cmds.run()
get_response_result = responses['executed_commands']['commands'][-1]
self.assertEqual(get_response_result[:2], ('get/response', 400))
def test_get_response_no_session(self):
from stubo.exceptions import HTTPClientError
cmds = self.make_one(DummyRequestHandler(), 'cmd_file6')
responses = cmds.run()
get_response_result = responses['executed_commands']['commands'][-1]
self.assertEqual(get_response_result[:2], ('get/response', 400))
def test_put_stub_with_text_param(self):
cmds = self.make_one(DummyRequestHandler(), 'cmd_file2')
cmds.run()
self.assertTrue(len(self.requests.posts) == 4)
def test_file_not_provided(self):
from stubo.exceptions import HTTPServerError
cmds = self.make_one(DummyRequestHandler())
with self.assertRaises(HTTPServerError):
cmds.run()
def test_file_not_found(self):
from stubo.exceptions import HTTPClientError
cmds = self.make_one(DummyRequestHandler(), 'bogus')
with self.assertRaises(HTTPClientError):
cmds.run()
def test_cmdfile_with_spaces(self):
cmds = self.make_one(DummyRequestHandler(), 'cmd_file_with_spaces')
cmds.run()
self.assertTrue(len(self.requests.posts) == 4)
def test_get_response_no_session(self):
from stubo.exceptions import HTTPClientError
cmds = self.make_one(DummyRequestHandler(), 'cmd_file6')
with self.assertRaises(HTTPClientError):
cmds.run()
def test_ctor(self):
cmds = self.make_one(DummyRequestHandler(), "/a/b/c")
self.assertEqual(cmds.location.get_base_url(), 'http://localhost:8001')
self.assertEqual(cmds.cmd_file_url, '/a/b/c')
def test_get_response9(self):
cmds = self.make_one(DummyRequestHandler(), 'cmd_file9')
cmds.run()
self.assertTrue(len(self.requests.posts) == 5)
def test_get_track(self):
from stubo.service.admin import get_track
response = get_track(DummyRequestHandler(), 123)
self.assertEqual(response, None)
def test_parse(self):
importer = self.make_one(DummyRequestHandler())
payload = importer.parse(yaml1)
self.assertTrue('commands' in payload)
self.assertTrue('recording' in payload)
def test_rtz_exit_full(self):
cmds = self.make_one(DummyRequestHandler(), 'rtz_exit_full')
cmds.run()
self.assertTrue(len(self.requests.posts) == 6)
def purge_stubs():
# importing helper handler from testing deps
from stubo.testing import DummyRequestHandler
parser = ArgumentParser(
description="Purge stubs older than given expiry date."
)
parser.add_argument('-l', '--list', action='store_const', const=True,
dest='list_only', help="Just list the stubs to delete.")
parser.add_argument('-e', '--expiry', default=14, dest='expiry',
help="expiry is number of days from now (default is 14).")
parser.add_argument('--host', default='all', dest='host',
help="specify the host uri to use (defaults to all)")
parser.add_argument('-c', '--config', dest='config',
help='Path to configuration file (defaults to $CWD/etc/dev.ini)',
metavar='FILE')
args = parser.parse_args()
list_only = args.list_only or False
expiry_days = args.expiry
expiry = datetime.today().date() - timedelta(int(expiry_days))
host = args.host
config = args.config or get_default_config()
logging.config.fileConfig(config)
settings = read_config(config)
dbenv = default_env.copy()
dbenv.update((k[6:], coerce_mongo_param(k[6:], v)) for k, v in \
settings.iteritems() if k.startswith('mongo.'))
log.debug('mongo params: {0}'.format(dbenv))
log.info('purge stubs whereby all sessions in the scenario were last used before {0}'.format(expiry))
db_conn = init_mongo(dbenv).connection
slave, master = start_redis(settings)
response = list_scenarios(host)
if 'error' in response:
print response['error']
sys.exit(-1)
handler = DummyRequestHandler()
session_handler = DummyRequestHandler()
for scenario_key in response['data']['scenarios']:
log.debug("*** scenario '{0}' ***".format(scenario_key))
hostname, scenario = scenario_key.split(':')
if host != 'all' and host != hostname:
continue
handler.host = hostname
handler.request.host = '{0}:8001'.format(hostname)
session_handler.host = hostname
session_handler.request.host = '{0}:8001'.format(hostname)
handler.request.arguments['scenario'] = [scenario]
status = get_status(handler)
if 'error' in status:
log.warn('get_status error: {0}'.format(status['error']))
else:
scenario_last_used = []
sessions = status['data']['sessions']
for session in zip(*sessions)[0]:
log.debug("*** -> session '{0}' ***".format(session))
session_handler.request.arguments['session'] = [session]
session_status = get_status(session_handler)
if 'error' in session_status:
log.warn('get_status error: {0}'.format(status['error']))
else:
last_used = session_status['data']['session'].get('last_used', '-')
if last_used != '-':
scenario_last_used.append(as_date(last_used[0:10]))
if scenario_last_used and (max(scenario_last_used) < expiry):
log.info("sessions in scenario '{0}' were last used '{1}' which"
" is before expiry date '{2}'".format(scenario_key,
max(scenario_last_used), expiry))
if not list_only:
response = delete_stubs(handler, scenario_name=scenario,
force=True)
if 'error' in response:
log.error('delete stubs error: {0}'.format(response['error']))
else:
log.info('deleted stubs: {0}'.format(response['data']))
def test_put_stub_empty_response(self):
from stubo.exceptions import HTTPClientError
cmds = self.make_one(DummyRequestHandler(), 'cmd_file_empty_response')
with self.assertRaises(HTTPClientError):
cmds.run()
