def test_try_get_date(self):
data = datetime.datetime(2020, 3, 20, 17, 56, 34, 74807)
self.assertEqual(data, try_get_object(data.__repr__()))
obj_str = "{'key':'value','date':" + data.__repr__() + '}'
self.assertEqual({
'key': 'value',
'date': data
}, try_get_object(obj_str))
def action(self, includes: dict, variables: dict) -> dict:
filled_vars = dict([(k, fill_template_str(v, variables)) for (k, v) in self.variables.items()])
out = fill_template_str(self.include, variables)
test, tag = get_tag(out)
if test not in includes:
error('No include registered for name ' + test)
raise Exception('No include registered for name ' + test)
include = includes[test]
variables = merge_two_dicts(include.variables, merge_two_dicts(variables, filled_vars))
include.variables = try_get_object(fill_template_str(variables, variables))
try:
info('Running {}'.format(test))
logger.log_storage.nested_test_in()
variables = include.run(tag=tag, raise_stop=True)
logger.log_storage.nested_test_out()
except SkipException:
logger.log_storage.nested_test_out()
debug('Include ignored')
return variables
except StopException as e:
logger.log_storage.nested_test_out()
raise e
except Exception as e:
logger.log_storage.nested_test_out()
if not self.ignore_errors:
raise Exception('Step run ' + test + ' failed: ' + str(e))
return variables
def run_tests(self) -> bool:
try:
self._compose.up()
variables = {}
if self.inventory is not None:
variables = read_source_file(self.inventory)
variables['INVENTORY'] = get_filename(self.inventory)
variables = try_get_object(fill_template_str(
variables, {})) # fill env vars
variables['CURRENT_DIR'] = self.path
test_files = get_files(self.tests_path)
results = []
for file in test_files:
self.all_includes = []
try:
variables['TEST_NAME'] = file
test = self.prepare_test(file, variables)
test.run()
results.append(True)
info('Test ' + file + ' passed.')
except Exception as e:
warning('Test ' + file + ' failed: ' + str(e))
results.append(False)
return all(results)
finally:
self._compose.down()
def test_try_get_object(self):
not_an_object = 'not an not_an_object'
self.assertEqual(not_an_object, try_get_object(not_an_object))
python_term = '{\'key\': \'string\', \'int_key\': 1, \'sub_term\': {\'k\':[1,2,3]}, \'non_existent\':None}'
python_object = {
'key': 'string',
'int_key': 1,
'sub_term': {
'k': [1, 2, 3]
},
'non_existent': None
}
self.assertEqual(python_object, try_get_object(python_term))
json_object = '{"key": "string", "int_key": 1, "sub_term": {"k":[1,2,3]}, "non_existent":null}'
self.assertEqual(python_object, try_get_object(json_object))
def test_try_get_primitives(self):
self.assertEqual(True, try_get_object('True'))
self.assertEqual(True, try_get_object('true'))
self.assertEqual(11, try_get_object('11'))
self.assertEqual(7.3, try_get_object('7.3'))
self.assertEqual('string', try_get_object('string'))
self.assertEqual('id', try_get_object('id'))
self.assertEqual('2020-03-20', try_get_object('2020-03-20'))
def _prepare_include_vars(test, global_variables):
if test.include:
include_vars = try_get_object(
fill_template_str(test.include.variables, global_variables))
else:
include_vars = {}
override_keys = report_override(test.variables, include_vars)
if override_keys:
debug('Include variables override these variables: ' +
str(override_keys))
return include_vars
def consume(connection_parameters, queue, disconnect_timeout):
message = None
import pika
connection_parameters.blocked_connection_timeout = disconnect_timeout
with pika.BlockingConnection(connection_parameters) as connection:
channel = connection.channel()
method_frame, header_frame, body = channel.basic_get(queue)
if isinstance(body, (bytes, bytearray)):
body = body.decode('utf-8')
if method_frame:
channel.basic_ack(method_frame.delivery_tag)
message = try_get_object(body)
return message
def process_register(self,
variables,
output: dict or list or str or None = None) -> dict:
if self.register is not None:
for key in self.register.keys():
if output is not None:
out = fill_template(
self.register[key],
merge_two_dicts(variables,
{'OUTPUT': try_get_object(output)}))
else:
out = fill_template(self.register[key], variables)
variables[key] = out
return variables
def get_messages(consumer, where: Operator or None, variables,
timeout) -> dict or None:
try:
while True:
consumer.fetch()
for message in consumer:
value = try_get_object(message.value.decode('utf-8'))
debug(value)
if Kafka.check_message(where, value, variables):
return value
if timeout > 0:
sleep(1)
timeout -= 1
else:
return None
finally:
consumer.commit_offsets()
def prepare_variables(self, test, global_variables: dict):
"""
Create variables for test
:param global_variables:
:param test: test with test variables
"""
# system env + inventory
# (test template is filled in based on system, inventory & cmd vars)
test.variables = try_get_object(
fill_template_str(test.variables,
merge_two_dicts(global_variables,
self._cmd_env)))
# test local
global_variables.update(test.variables)
# include vars override test local
global_variables.update(
self._prepare_include_vars(test, global_variables))
# cmd_env override everything
global_variables.update(self._cmd_env)
test.variables = global_variables
def __init__(self,
path: str,
system_environment=None,
inventory_vars: dict = None,
cmd_env: Optional[dict] = None,
resources: Optional[dict] = None) -> None:
system_vars = system_environment or {}
if system_vars:
debug('Use system variables: ' + str(list(system_vars.keys())))
self._variables = system_vars
else:
self._variables = {}
inventory = try_get_object(
fill_template_str(inventory_vars,
self._variables)) # fill env vars
self._cmd_env = cmd_env or {}
self._variables.update(inventory)
self._variables['CURRENT_DIR'] = path
self._variables['RESOURCES_DIR'] = resources or os.path.join(
path, 'resources')
def test_set_complex(self):
self.populate_file(
'main.yaml', '''---
variables:
complex:
a: 1
b: 'c'
d: [1,2,4]
steps:
- redis:
request:
set:
key: '{{ complex }}'
''')
runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None)
self.assertTrue(runner.run_tests())
r = redis.StrictRedis()
self.assertEqual({
'a': 1,
'b': 'c',
'd': [1, 2, 4]
}, try_get_object(r.get('key').decode()))
def run_tests(self) -> bool:
try:
self._compose.up()
if self.system_vars:
debug('Use system variables: ' +
str(list(self.system_vars.keys())))
variables = self.system_vars
else:
variables = {}
if self.inventory is not None:
inv_vars = read_source_file(self.inventory)
inv_vars['INVENTORY'] = get_filename(self.inventory)
variables = try_get_object(
fill_template_str(inv_vars, variables)) # fill env vars
variables['CURRENT_DIR'] = self.path
variables[
'RESOURCES_DIR'] = self.resources or self.path + '/resources'
test_files = get_files(self.tests_path)
results = []
for file in test_files:
self.all_includes = []
try:
variables['TEST_NAME'] = file
test = self.prepare_test(file, variables)
logger.log_storage.test_start(file)
test.run()
results.append(True)
info('Test ' + file + ' passed.')
logger.log_storage.test_end(file, True)
except Exception as e:
warning('Test ' + file + ' failed: ' + str(e))
results.append(False)
logger.log_storage.test_end(file, False, str(e))
return all(results)
finally:
logger.log_storage.write_report(self.path)
self._compose.down()
def test_try_json(self):
my_dict = {'key': 'value', 'inner': {'key': 'value'}}
self.assertEqual(
my_dict, try_get_object('{"key":"value","inner":{"key":"value"}}'))
my_list = [1, 2, 3, [1, 2, 3]]
self.assertEqual(my_list, try_get_object('[1, 2, 3, [1, 2, 3]]'))
