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]]'))