def parse_configuration(node, base_config=None):
""" Parse input config to configuration information """
test_config = base_config
if not test_config:
test_config = TestConfig()
node = lowercase_keys(flatten_dictionaries(node)) # Make it usable
for key, value in node.items():
if key == u'timeout':
test_config.timeout = int(value)
elif key == u'print_bodies':
test_config.print_bodies = safe_to_bool(value)
elif key == u'retries':
test_config.retries = int(value)
elif key == u'variable_binds':
if not test_config.variable_binds:
test_config.variable_binds = dict()
test_config.variable_binds.update(flatten_dictionaries(value))
elif key == u'generators':
flat = flatten_dictionaries(value)
gen_map = dict()
for generator_name, generator_config in flat.items():
gen = parse_generator(generator_config)
gen_map[str(generator_name)] = gen
test_config.generators = gen_map
return test_config
def parse(config):
""" Create a validator that does an extract from body and applies a comparator,
Then does comparison vs expected value
Syntax sample:
{ jsonpath_mini: 'node.child',
operator: 'eq',
expected: 'my_file_name'
}
"""
output = JSONFileValidator()
config = parsing.lowercase_keys(parsing.flatten_dictionaries(config))
output.config = config
# Extract functions are called by using defined extractor names
output.extractor = validators._get_extractor(config)
if output.extractor is None:
raise ValueError(
"Extract function for comparison is not valid or not found!")
if 'comparator' not in config: # Equals comparator if unspecified
output.comparator_name = 'eq'
else:
output.comparator_name = config['comparator'].lower()
output.comparator = validators.COMPARATORS[output.comparator_name]
if not output.comparator:
raise ValueError("Invalid comparator given!")
try:
expected = config['expected']
except KeyError:
raise ValueError(
"No expected value found in comparator validator config, one must be!"
)
# Expected value can be base or templated string contains file name without extension.
if isinstance(expected, basestring) or isinstance(
expected, (int, long, float, complex)):
output.expected = expected
elif isinstance(expected, dict):
expected = parsing.lowercase_keys(expected)
template = expected.get('template')
if template: # Templated string
if not isinstance(template, basestring):
raise ValueError(
"Can't template a comparator-validator unless template value is a string"
)
output.isTemplateExpected = True
output.expected = template
else: # Extractor to compare against
raise ValueError(
"Can't supply a non-template, non-extract dictionary to comparator-validator"
)
return output
def parse(config):
""" Create a validator that does an extract from body and applies a comparator,
Then does comparison vs expected value
Syntax sample:
{ jsonpath_mini: 'node.child',
operator: 'eq',
expected: 'my_file_name'
}
"""
output = JSONFileValidator()
config = parsing.lowercase_keys(parsing.flatten_dictionaries(config))
output.config = config
# Extract functions are called by using defined extractor names
output.extractor = validators._get_extractor(config)
if output.extractor is None:
raise ValueError(
"Extract function for comparison is not valid or not found!")
if 'comparator' not in config: # Equals comparator if unspecified
output.comparator_name = 'eq'
else:
output.comparator_name = config['comparator'].lower()
output.comparator = validators.COMPARATORS[output.comparator_name]
if not output.comparator:
raise ValueError("Invalid comparator given!")
try:
expected = config['expected']
except KeyError:
raise ValueError(
"No expected value found in comparator validator config, one must be!")
# Expected value can be base or templated string contains file name without extension.
if isinstance(expected, basestring) or isinstance(expected, (int, long, float, complex)):
output.expected = expected
elif isinstance(expected, dict):
expected = parsing.lowercase_keys(expected)
template = expected.get('template')
if template: # Templated string
if not isinstance(template, basestring):
raise ValueError(
"Can't template a comparator-validator unless template value is a string")
output.isTemplateExpected = True
output.expected = template
else: # Extractor to compare against
raise ValueError(
"Can't supply a non-template, non-extract dictionary to comparator-validator")
return output
