def test_flatten_lowercase_keys_dict(self):
input_dict = {"x": 1, "y": 2}
result_dict = Parser.flatten_lowercase_keys_dict([{'x': 2}, input_dict])
self.assertEqual(input_dict, result_dict)
input_dict = {"X": 1, "y": 2}
result_dict = Parser.flatten_lowercase_keys_dict([{'x': 2}, input_dict])
self.assertEqual({'x': 1, 'y': 2}, result_dict)
input_dict = {"X": 1, "y": 2}
result_dict = Parser.flatten_lowercase_keys_dict(input_dict)
self.assertEqual({'x': 1, 'y': 2}, result_dict)
input_dict = 22 # unexpected
result_dict = Parser.flatten_lowercase_keys_dict(input_dict)
self.assertEqual(22, result_dict)
def parse(self, testcase_dict):
testcase_dict = Parser.flatten_lowercase_keys_dict(testcase_dict)
for keyword in TestCase.KEYWORD_DICT.keys():
value = testcase_dict.get(keyword)
if value is None:
continue
if keyword == TestCaseKeywords.auth_username:
self.auth_username = value
elif keyword == TestCaseKeywords.auth_password:
self.auth_password = value
elif keyword == TestCaseKeywords.method:
self.http_method = value
elif keyword == TestCaseKeywords.delay:
self.__delay = int(value)
elif keyword == TestCaseKeywords.group:
self.__group = value
elif keyword == TestCaseKeywords.name:
self.__name = value
elif keyword == TestCaseKeywords.url:
self.url = value
elif keyword == TestCaseKeywords.extract_binds:
self.extract_binds = value
elif keyword == TestCaseKeywords.validators:
self.validators = value
elif keyword == TestCaseKeywords.headers:
self.headers = value
elif keyword == TestCaseKeywords.variable_binds:
self.__variable_binds_dict = Parser.flatten_dictionaries(value)
elif keyword == TestCaseKeywords.generator_binds:
self.__generator_binds_dict = {
str(k): str(v)
for k, v in Parser.flatten_dictionaries(value)
}
elif keyword == TestCaseKeywords.options:
raise NotImplementedError("Yet to Support")
elif keyword == TestCaseKeywords.body:
self.body = value
elif keyword == TestCaseKeywords.absolute_urls:
self.__abs_url = Parser.safe_to_bool(value)
expected_status = testcase_dict.get(TestCaseKeywords.expected_status,
[])
if expected_status:
self.expected_http_status_code_list = expected_status
else:
if self.http_method in ["POST", "PUT", "DELETE"]:
self.expected_http_status_code_list = [200, 201, 204]
def parse(self, config_node):
node = Parser.flatten_lowercase_keys_dict(config_node)
for key, value in node.items():
if key == 'timeout':
self.timeout = int(value)
elif key == u'print_bodies':
self.print_bodies = Parser.safe_to_bool(value)
elif key == 'retries':
self.retries = int(value)
elif key == 'variable_binds':
self.variable_binds = value
elif key == u'generators':
if not isinstance(value, list):
raise TypeError("generators in config should defined as list(array).")
flat = Parser.flatten_dictionaries(value)
gen_dict = {}
for generator_name, generator_config in flat.items():
gen = parse_generator(generator_config)
gen_dict[str(generator_name)] = gen
self.generators = gen_dict
def parse_content(node):
""" Parse content from input node and returns ContentHandler object
it'll look like:
- template:
- file:
- temple: path
or something
"""
# Tread carefully, this one is a bit narly because of nesting
output = ContentHandler()
is_template_path = False
is_template_content = False
is_file = False
is_done = False
if not isinstance(node, (str, dict, list)):
raise TypeError(
"Content must be a string, dictionary, or list of dictionaries")
while node and not is_done: # Dive through the configuration tree
# Finally we've found the value!
if isinstance(node, str):
output.content = node
output.setup(node, is_file=is_file, is_template_path=is_template_path,
is_template_content=is_template_content)
return output
is_done = True
# Dictionary or list of dictionaries
flat_dict = Parser.flatten_lowercase_keys_dict(node)
for key, value in flat_dict.items():
if key == 'template':
if isinstance(value, str):
if is_file:
value = os.path.abspath(value)
output.content = value
is_template_content = is_template_content or not is_file
output.is_template_content = is_template_content
output.is_template_path = is_file
output.is_file = is_file
return output
else:
is_template_content = True
node = value
is_done = False
break
elif key == 'file':
if isinstance(value, str):
output.content = os.path.abspath(value)
output.is_file = True
output.is_template_content = is_template_content
return output
else:
is_file = True
node = value
is_done = False
break
raise Exception("Invalid configuration for content.")
def test_flatten_lowercase_keys(self):
input_dict = "22" # unexpected
result_dict = Parser.flatten_lowercase_keys_dict(input_dict)
self.assertEqual("22", result_dict)