def test_load_empty_yaml_file(self, tmpdir):
"""
Loading empty yaml files should raise an exception
"""
# Load empty source file
source_f = tmpdir.join("foo.yaml")
source_f.write("")
schema_f = tmpdir.join("bar.yaml")
schema_f.write("")
# TODO: This is abit buggy because wrong exception is raised...
with pytest.raises(CoreError) as ex:
Core(source_file=str(source_f), schema_files=[str(schema_f)])
# assert "Unable to load any data from source yaml file" in str(ex.value)
# Load empty schema files
source_f = tmpdir.join("foo.yaml")
source_f.write("3.14159")
schema_f = tmpdir.join("bar.yaml")
schema_f.write("")
with pytest.raises(CoreError) as ex:
Core(source_file=str(source_f), schema_files=[str(schema_f)])
assert "No data loaded from file" in str(ex.value)
def __init__(self, config_path, schema_path, config_changes):
with open(config_path, 'rt') as src:
config = read_config(src)
make_config_changes(config, config_changes)
self.multi_stage = 'stages' in config
if self.multi_stage:
ordered_changes = OrderedDict(
sorted(
config['stages'].items(),
key=lambda (k, v): v['number'],
))
self.ordered_stages = OrderedDict()
for name, changes in ordered_changes.items():
current_config = copy.deepcopy(config)
del current_config['stages']
del changes['number']
merge_recursively(current_config, changes)
self.ordered_stages[name] = current_config
# Validate the configuration and the training stages
with open(os.path.expandvars(schema_path)) as schema_file:
schema = yaml.safe_load(schema_file)
core = Core(source_data=config, schema_data=schema)
core.validate(raise_exception=True)
if self.multi_stage:
for stage in self.ordered_stages.values():
core = Core(source_data=config, schema_data=schema)
core.validate(raise_exception=True)
super(Configuration, self).__init__(config)
def test_load_empty_json_file(self, tmpdir):
"""
Loading an empty json files should raise an exception
"""
# Load empty source file
source_f = tmpdir.join("foo.json")
source_f.write("")
schema_f = tmpdir.join("bar.json")
schema_f.write("")
with pytest.raises(ValueError) as ex:
Core(source_file=str(source_f), schema_files=[str(schema_f)])
# Python 2.7 and Python 3.5 JSON parsers return different exception
# strings for the same data file, so check for both errors strings.
assert ("No JSON object could be decoded" in str(ex.value)
or "Expecting value:" in str(ex.value))
# Load empty schema files
source_f = tmpdir.join("foo.json")
source_f.write("3.14159")
schema_f = tmpdir.join("bar.json")
schema_f.write("")
with pytest.raises(ValueError) as ex:
Core(source_file=str(source_f), schema_files=[str(schema_f)])
assert ("No JSON object could be decoded" in str(ex.value)
or "Expecting value:" in str(ex.value))
def test_load_empty_json_file(self, tmpdir):
"""
Loading an empty json files should raise an exception
"""
# Load empty source file
source_f = tmpdir.join("foo.json")
source_f.write("")
schema_f = tmpdir.join("bar.json")
schema_f.write("")
with pytest.raises(CoreError) as ex:
Core(source_file=str(source_f), schema_files=[str(schema_f)])
assert "Unable to load any data from source json file" in str(ex.value)
# Load empty schema files
source_f = tmpdir.join("foo.json")
source_f.write("3.14159")
schema_f = tmpdir.join("bar.json")
schema_f.write("")
with pytest.raises(CoreError) as ex:
Core(source_file=str(source_f), schema_files=[str(schema_f)])
assert "No data loaded from file" in str(ex.value)
def parse_data(site):
base = op.join(op.dirname(__file__), 'games')
originals = []
for fn in sorted(os.listdir(op.join(base, 'originals'))):
if fn.endswith('.yaml'):
originals.extend(yaml.load(open(op.join(base, 'originals', fn))))
print(str(len(originals)) + ' games in total')
try:
core = Core(source_data=originals,
schema_files=['schema_originals.yaml'])
core.validate(raise_exception=True)
except Exception as error:
if len(core.errors) > 0:
show_validation_errors(originals, core.errors)
else:
raise error
clones = []
for fn in sorted(os.listdir(op.join(base, 'clones'))):
if fn.endswith('.yaml'):
clones.extend(yaml.load(open(op.join(base, 'clones', fn))))
print(str(len(clones)) + ' clones in total')
try:
core = Core(source_data=clones, schema_files=['schema_clones.yaml'])
core.validate(raise_exception=True)
except Exception as error:
if len(core.errors) > 0:
show_validation_errors(clones, core.errors)
else:
raise error
for item in originals:
parse_global_tags(site, item.get('meta', {}), 'genre')
# Recombine originals and clones
combined = copy.deepcopy(item)
name = combined['name']
if isinstance(name, list):
name = name[0]
combined_remakes = [
clone for clone in clones
if 'remakes' in clone and name in clone['remakes']
]
if len(combined_remakes) > 0:
combined['remakes'] = combined_remakes
combined_clones = [
clone for clone in clones
if 'clones' in clone and name in clone['clones']
]
if len(combined_clones) > 0:
combined['clones'] = combined_clones
parse_items(site, combined, 'remakes')
parse_items(site, combined, 'clones')
def test_create_empty_core_object(self, tmpdir):
"""
If createing a core object without any source or schema file an exception should be raised.
"""
with pytest.raises(CoreError) as ex:
Core()
assert "No source file/data was loaded" in str(ex.value)
# To trigger schema exception we must pass in a source file
source_f = tmpdir.join("bar.json")
source_f.write("3.14159")
with pytest.raises(CoreError) as ex:
Core(source_file=str(source_f))
assert "No schema file/data was loaded" in str(ex.value)
def load_config(file_name):
"""
Load the file, verify that it conforms to the schema,
and return the configuration.
"""
try:
with open(file_name, 'r') as conf_file:
data = yaml.safe_load(conf_file)
validator = Core(
source_data=data,
schema_files=[dirname(__file__) + "/rebench-schema.yml"])
try:
validator.validate(raise_exception=True)
except SchemaError as err:
errors = [
escape_braces(val_err)
for val_err in validator.validation_errors
]
raise UIError(
"Validation of " + file_name + " failed.\n{ind}" +
"\n{ind}".join(errors) + "\n", err)
return data
except IOError as err:
if err.errno == 2:
assert err.strerror == "No such file or directory"
raise UIError(
"The requested config file (%s) could not be opened. %s.\n" %
(file_name, err.strerror), err)
raise UIError(str(err) + "\n", err)
except yaml.YAMLError as err:
raise UIError(
"Parsing of the config file " + file_name + " failed.\nError " +
str(err) + "\n", err)
def acquireYAMLConfig(configFile: str,
validationFile: str,
domains: List[str]) -> _ValRetType:
"""
Parse YAML config file and return dictionary.
"""
# Validate the input file before reading it from file with `yaml`.
c = Core(source_file=configFile, schema_files=[validationFile],
strict_rule_validation=True)
# If there's an exception, then call it out to the user.
c.validate(raise_exception=True)
# Proceed with opening and parsing the file, now that its structure /
# schema has been validated.
with open(configFile, 'r') as y:
parsed = yaml.safe_load(y)
class InvalidDomainRequest(KeyError):
pass
# Validate the requested domains against a master list.
for pool in parsed:
if pool['name'] not in domains:
raise InvalidDomainRequest(f'Invalid domain: {pool["name"]}')
return parsed
def test_python_obj_loading(self, tmp_path):
# in latest pytest version, tmp_path is a PosixPath
tmp_path = str(tmp_path)
schema = """
allowempty: True
mapping:
intents:
type: !!python/str "seq"
sequence:
- type: !!python/str "str"
"""
data = """
intents:
- greet
- default
- goodbye
"""
schema_path = os.path.join(tmp_path, 'schema.yaml')
with open(schema_path, 'w') as stream:
stream.write(schema)
data_path = os.path.join(tmp_path, 'data.yaml')
with open(data_path, 'w') as stream:
stream.write(data)
c = Core(source_file=data_path, schema_files=[schema_path])
c.validate()
def load_config(config_name):
with open(config_name) as config_file:
c = Core(data_file_obj=config_file, schema_files=[
"schema.yaml",
"resolvers_schema.yaml"])
app_config = c.validate(raise_exception=True)
return app_config
def create_validator(source_data):
""" Generate validator from PyKwalify """
version = source_data.get('schema_version', '3.1.0')
schema = get_schema(version)
validator = Core(source_data={}, schema_data=schema)
validator.source = source_data
return validator
def load(testfile):
"""
It loads a test file.
:param testfile: the file path of the test
:type testfile: str
:returns: dict representing the test file
"""
if not testfile:
raise ValueError("'testfile' is empty")
logger = logging.getLogger(__name__)
logger.debug("loading file '%s'", testfile)
file_def = {}
file_name, file_ext = os.path.splitext(testfile)
logger.debug("filename=%s, extension=%s", file_name, file_ext)
if file_ext == '.yml' or file_ext == '.yaml':
try:
currdir = os.path.abspath(os.path.dirname(__file__))
schemafile = os.path.join(currdir, "files", "schema.yml")
validator = Core(source_file=testfile, schema_files=[schemafile])
validator.validate(raise_exception=True)
except PyKwalifyException as ex:
raise FileParseError(ex.msg)
with open(testfile, 'r') as stream:
file_def = yaml.load(stream)
else:
raise FileNotSupported("'%s' file type is not supported"%file_ext)
return file_def
def validate_config(config_file):
''' Validates config against the schema
And also validates the lambdas in the subscriptions that they are defined
Raises ConfigValidationError if not valid.
'''
schema_path = resource_filename("xflow", "schema.yaml")
c = Core(source_file=config_file, schema_files=[schema_path])
try:
config = c.validate(raise_exception=True)
except pykwalify.errors.SchemaError as ex:
raise ConfigValidationError(str(ex))
subscriptions = config.get('subscriptions') or []
lambdas = config.get('lambdas') or []
lambda_names = [l['name'] for l in lambdas]
subscription_events = []
for ss in subscriptions:
event_name = ss['event']
subscription_events.append(event_name)
subscribers = ss.get('subscribers') or []
for s in subscribers:
if s not in lambda_names:
raise ConfigValidationError("Lambda not defined for subscriber %s" % s)
workflows = config.get('workflows') or []
for w in workflows:
workflow_id = w['id']
events = w.get('flow') or []
for e in events:
if e not in subscription_events:
raise ConfigValidationError("Event %s not defined in workflow %s" % (e, workflow_id))
def run_check(queue, file):
# print(file)
c = Core(source_file=file, schema_files=[DICTIONARY_SCHEMA_FILE])
try:
c.validate(raise_exception=True)
except SchemaError as e:
queue.put([file, e.msg])
def is_valid_scheme(self):
# type: () -> bool
"""Validate the file scheme according to the scheme we have saved in SCHEMAS_PATH.
Returns:
bool. Whether the scheme is valid on self.file_path.
"""
if self.scheme_name in [None, 'image', 'readme', 'changelog']:
return True
# ignore reputations.json
if checked_type(self.file_path,
JSON_ALL_REPUTATIONS_INDICATOR_TYPES_REGEXES):
return True
try:
# disabling massages of level INFO and beneath of pykwalify such as: INFO:pykwalify.core:validation.valid
log = logging.getLogger('pykwalify.core')
log.setLevel(logging.WARNING)
path = os.path.normpath(
os.path.join(__file__, "..", "..", self.SCHEMAS_PATH,
'{}.yml'.format(self.scheme_name)))
core = Core(source_file=self.file_path, schema_files=[path])
core.validate(raise_exception=True)
except Exception as err:
try:
print_error(self.parse_error_msg(err))
print_error(Errors.suggest_fix(self.file_path))
except Exception:
print_error('Failed: {} failed.\nin {}'.format(
self.file_path, str(err)))
self.is_valid = False
return False
return True
def _validate_cfg(self):
"""
Open and parse the YAML configuration file and ensure it matches
our Schema for a Dogen configuration.
"""
# Fail early if descriptor file is not found
if not os.path.exists(self.descriptor):
raise Error(
"Descriptor file '%s' could not be found. Please make sure you specified correct path."
% self.descriptor)
schema_path = os.path.join(self.pwd, "schema", "kwalify_schema.yaml")
schema = {}
with open(schema_path, 'r') as fh:
schema = yaml.safe_load(fh)
if schema is None:
raise Error("couldn't read a valid schema at %s" % schema_path)
for plugin in self.plugins:
plugin.extend_schema(schema)
with open(self.descriptor, 'r') as stream:
self.cfg = yaml.safe_load(stream)
c = Core(source_data=self.cfg, schema_data=schema)
try:
c.validate(raise_exception=True)
except SchemaError as e:
raise Error(e)
def main(argv=None):
parser = argparse.ArgumentParser()
parser.add_argument('filenames', nargs='*', help='filenames to check')
args = parser.parse_args(argv)
filenames = args.filenames
settings = load_settings()
rules = settings["rules"]
checked_files = set()
errors = False
for rule in rules:
schema_file, data_dir = rule["schema_file"], rule["data_dir"]
for filename in filenames:
if filename not in checked_files:
file_path = Path(filename)
parent = file_path.parent
if str(parent) == data_dir:
try:
print("\n" + filename)
file = Core(source_file=filename,
schema_files=[schema_file])
file.validate(raise_exception=True)
checked_files.add(filename)
except SchemaError:
errors = True
else:
print("Validated")
return 0 if not errors else 1
def verify_generic(to_verify, schema_filename):
"""Verify a generic file against a given schema file
Args:
to_verify (str): filename of file to check
schema_filename (str): filename of schema
Raises:
BadSchemaError: Schema did not match
"""
logger.debug("Verifying %s against %s", to_verify, schema_filename)
here = os.path.dirname(os.path.abspath(__file__))
extension_module_filename = os.path.join(here, "extensions.py")
verifier = Core(
to_verify,
[schema_filename],
extensions=[extension_module_filename],
)
try:
verifier.validate()
except pykwalify.errors.PyKwalifyException as e:
logger.exception("Error validating %s", to_verify)
raise_from(BadSchemaError(), e)
def test_load_wrong_schema_files_type(self):
"""
It should only be possible to send in a list type as 'schema_files' object
"""
with pytest.raises(CoreError) as ex:
Core(source_file=None, schema_files={})
assert "schema_files must be of list type" in str(ex.value)
def validate_schema(file_path, matching_regex=None):
if matching_regex is None:
for regex in CHECKED_TYPES_REGEXES:
if re.match(regex, file_path, re.IGNORECASE):
matching_regex = regex
break
if matching_regex in SKIPPED_SCHEMAS:
return True
if not os.path.isfile(file_path):
return True
if matching_regex is not None and REGEXES_TO_SCHEMA_DIC.get(
matching_regex):
c = Core(source_file=file_path,
schema_files=[
SCHEMAS_PATH + REGEXES_TO_SCHEMA_DIC.get(matching_regex) +
'.yml'
])
try:
c.validate(raise_exception=True)
return True
except Exception as err:
print_error('Failed: %s failed' % (file_path, ))
print_error(err)
return False
print file_path + " doesn't match any of the known supported file prefix/suffix," \
" please make sure that its naming is correct."
return True
def validate(self, cloudformation_string):
"""
Validating the schema for a cloudformation segment
:param cloudformation_string:
:return:
"""
if self.debug:
print("\n\n##################################################")
print(
'CloudformationValidator - validate - validating following string'
+ lineno())
print(str(cloudformation_string) + lineno())
print(
"#######################################################\n\n")
schema = SchemaGenerator.SchemaGenerator(debug=self.debug)
main_schema = schema.generate(cloudformation_string)
if self.debug:
print('main_schema: ' + str(main_schema) + lineno())
## create validator
c = Core(source_data=cloudformation_string, schema_data=main_schema)
c.validate(raise_exception=False)
if len(c.errors) > 0:
if self.debug:
print('errors: ' + str(c.errors) + lineno())
#raise ParserError.new('Basic CloudFormation syntax error', errors)
# Return any validation error
return c.errors
def _validate(args, app_desc):
path = _find_config(args, app_desc)
# Allow empty mapping (not allowed by pykawlify)
raw_config = _order_load_path(path)
if raw_config.get(app_desc.app_name, None) is None:
raw_config[app_desc.app_name] = {}
config_p = tempfile.NamedTemporaryFile('w',
delete=False,
suffix=".yml")
ordered_dump(raw_config, config_p)
config_p.flush()
path = config_p.name
fp = tempfile.NamedTemporaryFile('w', delete=False, suffix=".yml")
def _clean(p, k, v):
return k != 'reloadable'
clean_schema = remap(app_desc.schema.raw_schema, _clean)
ordered_dump(clean_schema, fp)
fp.flush()
name = fp.name
if Core is None:
raise Exception("Cannot validate file, pykwalify is not installed.")
c = Core(
source_file=path,
schema_files=[name],
)
c.validate()
def validate_domain_yaml(cls, yaml):
"""Validate domain yaml."""
from pykwalify.core import Core
log = logging.getLogger("pykwalify")
log.setLevel(logging.WARN)
try:
schema_file = pkg_resources.resource_filename(
__name__, "schemas/domain.yml")
source_data = rasa.utils.io.read_yaml(yaml)
except YAMLError:
raise InvalidDomain(
"The provided domain file is invalid. You can use "
"http://www.yamllint.com/ to validate the yaml syntax "
"of your domain file.")
except DuplicateKeyError as e:
raise InvalidDomain(
"The provided domain file contains a duplicated key: {}".
format(str(e)))
try:
c = Core(source_data=source_data, schema_files=[schema_file])
c.validate(raise_exception=True)
except SchemaError:
raise InvalidDomain(
"Failed to validate your domain yaml. "
"Please make sure the file is correct; to do so, "
"take a look at the errors logged during "
"validation previous to this exception. "
"You can also validate your domain file's yaml "
"syntax using http://www.yamllint.com/.")
def get_group_config(self, group_dir):
with Dir(group_dir):
group_schema_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"schema_group.yml")
c = Core(source_file="group.yml", schema_files=[group_schema_path])
c.validate(raise_exception=True)
with open("group.yml", "r") as f:
group_yml = f.read()
# group.yml can contain a `vars` section which should be a
# single level dict containing keys to str.format(**dict) replace
# into the YAML content. If `vars` found, the format will be
# preformed and the YAML model will reloaded from that result
tmp_config = Model(yaml.load(group_yml))
replace_vars = tmp_config.vars
if replace_vars is not Missing:
try:
tmp_config = Model(
yaml.load(group_yml.format(**replace_vars)))
except KeyError as e:
raise ValueError(
'group.yml contains template key `{}` but no value was provided'
.format(e.args[0]))
return tmp_config
def is_valid_scheme(self):
# type: () -> bool
"""Validate the file scheme according to the scheme we have saved in SCHEMAS_PATH.
Returns:
bool. Whether the scheme is valid on self.file_path.
"""
if self.scheme_name in [None, FileType.IMAGE, FileType.README, FileType.RELEASE_NOTES, FileType.TEST_PLAYBOOK]:
return True
# ignore reputations.json
if checked_type(self.file_path, JSON_ALL_REPUTATIONS_INDICATOR_TYPES_REGEXES):
return True
try:
# disabling massages of level INFO and beneath of pykwalify such as: INFO:pykwalify.core:validation.valid
log = logging.getLogger('pykwalify.core')
log.setLevel(logging.WARNING)
scheme_file_name = 'integration' if self.scheme_name.value == 'betaintegration' else self.scheme_name.value
path = os.path.normpath(
os.path.join(__file__, "..", "..", self.SCHEMAS_PATH, '{}.yml'.format(scheme_file_name)))
core = Core(source_file=self.file_path,
schema_files=[path])
core.validate(raise_exception=True)
except Exception as err:
try:
error_message, error_code = self.parse_error_msg(err)
if self.handle_error(error_message, error_code, self.file_path,
suggested_fix=Errors.suggest_fix(self.file_path)):
self.is_valid = False
return False
except Exception:
error_message, error_code = Errors.pykwalify_general_error(err)
if self.handle_error(error_message, error_code, self.file_path):
self.is_valid = False
return False
return True
def validate_file_schema(file_url: str, info) -> bool:
"""Validate if a file has the correct schema."""
schema_dir = os.path.dirname(os.path.abspath(__file__))
schema_dir = os.path.join(schema_dir, '../entity/schema.yaml')
core = Core(source_file=file_url, schema_files=[schema_dir])
is_valid = False
try:
core.validate(raise_exception=True)
is_valid = True
except SchemaError:
lines_of_exceptions = core.errors
errors_values = \
[x.value for x in lines_of_exceptions if not hasattr(x, 'key')]
errors_keys = \
[x for x in lines_of_exceptions if hasattr(x, 'key')]
errors_values_formated = \
['"{val}"'.format(val=x) for x in errors_values]
errors_keys_formated = \
['"{val}"'.format(val=x.key) for x in errors_keys
if x.msg and str(x.msg).find('was not defined') >= 0]
errors_keys_joined = ','.join(errors_keys_formated)
errors_values_joined = ','.join(errors_values_formated)
error_value = '"values": [{values}], "keys": [{keys}]'.format(
values=errors_values_joined, keys=errors_keys_joined)
util.cloudwatch_log(
info.context,
'Error: An error occurred validating vulnerabilities file')
raise InvalidSchema(expr=error_value)
except CoreError:
raise InvalidSchema()
finally:
os.unlink(file_url)
return is_valid
def _validate(args, app_desc):
if Core is None:
raise Exception("Cannot validate file, pykwalify is not installed.")
path = _find_config(args, app_desc)
# Allow empty mapping (not allowed by pykwalify)
raw_config = _order_load_path(path)
if raw_config.get(app_desc.app_name) is None:
raw_config[app_desc.app_name] = {}
# Rewrite the file any way to merge any duplicate keys
with tempfile.NamedTemporaryFile('w', delete=False,
suffix=".yml") as config_p:
ordered_dump(raw_config, config_p)
def _clean(p, k, v):
return k not in ['reloadable', 'path_resolves_to']
clean_schema = remap(app_desc.schema.raw_schema, _clean)
with tempfile.NamedTemporaryFile('w', suffix=".yml") as fp:
ordered_dump(clean_schema, fp)
fp.flush()
c = Core(
source_file=config_p.name,
schema_files=[fp.name],
)
os.remove(config_p.name)
c.validate()
def validate_yaml_schema(yaml_file_content: Text, schema_path: Text) -> None:
"""
Validate yaml content.
Args:
yaml_file_content: the content of the yaml file to be validated
schema_path: the schema of the yaml file
"""
from pykwalify.core import Core
from pykwalify.errors import SchemaError
from ruamel.yaml import YAMLError
import pkg_resources
import logging
log = logging.getLogger("pykwalify")
log.setLevel(logging.CRITICAL)
try:
# we need "rt" since
# it will add meta information to the parsed output. this meta information
# will include e.g. at which line an object was parsed. this is very
# helpful when we validate files later on and want to point the user to the
# right line
source_data = rasa.shared.utils.io.read_yaml(
yaml_file_content, reader_type=["safe", "rt"]
)
except (YAMLError, DuplicateKeyError) as e:
raise YamlSyntaxException(underlying_yaml_exception=e)
schema_file = pkg_resources.resource_filename(PACKAGE_NAME, schema_path)
schema_utils_file = pkg_resources.resource_filename(
PACKAGE_NAME, RESPONSES_SCHEMA_FILE
)
schema_extensions = pkg_resources.resource_filename(
PACKAGE_NAME, SCHEMA_EXTENSIONS_FILE
)
# Load schema content using our YAML loader as `pykwalify` uses a global instance
# which can fail when used concurrently
schema_content = rasa.shared.utils.io.read_yaml_file(schema_file)
schema_utils_content = rasa.shared.utils.io.read_yaml_file(schema_utils_file)
schema_content = dict(schema_content, **schema_utils_content)
c = Core(
source_data=source_data,
schema_data=schema_content,
extensions=[schema_extensions],
)
try:
c.validate(raise_exception=True)
except SchemaError:
raise YamlValidationException(
"Please make sure the file is correct and all "
"mandatory parameters are specified. Here are the errors "
"found during validation",
c.errors,
content=source_data,
)
def test_files_with_unicode_content_success(self, tmpdir):
"""
These tests should pass with no exception raised
"""
fail_data_2s_yaml = {
'schema': {
'type': 'map',
'mapping': {
'msg': {
'type': 'int',
},
}
},
'data': {
'msg': 123,
},
'errors': []
}
source_f = tmpdir.join(u"2så.json")
source_f.write(yaml.safe_dump(fail_data_2s_yaml, allow_unicode=True))
_pass_tests = [
# Test mapping with unicode key and value
u"1s.yaml",
# # Test unicode filename.
# It is not possible to package a file with unicode characters
# like åäö in the filename in some python versions.
# Mock a file with åäö during testing to properly simulate this again.
unicode(source_f),
# Test sequence with unicode keys
u"3s.yaml",
]
for passing_test_files in _pass_tests:
f = self.f(passing_test_files)
with open(f, "r") as stream:
yaml_data = yaml.safe_load(stream)
data = yaml_data["data"]
schema = yaml_data["schema"]
try:
print(u"Running test files: {0}".format(f))
c = Core(source_data=data, schema_data=schema)
c.validate()
compare(c.validation_errors, [],
prefix="No validation errors should exist...")
except Exception as e:
print(u"ERROR RUNNING FILES: {0}".format(f))
raise e
# This serve as an extra schema validation that tests more complex structures then testrule.py do
compare(
c.root_rule.schema_str,
schema,
prefix=
u"Parsed rules is not correct, something have changed... files : {0}"
.format(f))
def test_files_with_unicode_content_failing(self, tmpdir):
"""
These tests should fail with the specified exception
"""
# To trigger schema exception we must pass in a source file
fail_data_2f_yaml = {
'schema': {
'type': 'map',
'mapping': {
'msg': {
'type': 'int',
},
}
},
'data': {
'msg': 'Foobar',
},
'errors': ["Value 'Foobar' is not of type 'int'. Path: '/msg'"]
}
source_f = tmpdir.join(u"2få.json")
source_f.write(yaml.safe_dump(fail_data_2f_yaml, allow_unicode=True))
_fail_tests = [
# Test mapping with unicode key and value but wrong type
(u"1f.yaml", SchemaError),
# Test unicode filename with validation errors.
# It is not possible to package a file with unicode characters
# like åäö in the filename in some python versions.
# Mock a file with åäö during testing to properly simulate this again.
(unicode(source_f), SchemaError),
# Test unicode data inside seq but wrong type
(u"3f.yaml", SchemaError),
]
for failing_test, exception_type in _fail_tests:
f = self.f(failing_test)
with open(f, "r") as stream:
yaml_data = yaml.safe_load(stream)
data = yaml_data["data"]
schema = yaml_data["schema"]
errors = yaml_data["errors"]
try:
print(u"Running test files: {0}".format(f))
c = Core(source_data=data, schema_data=schema)
c.validate()
except exception_type:
pass # OK
else:
raise AssertionError(
u"Exception {0} not raised as expected... FILES: {1} : {2}"
.format(exception_type, exception_type))
compare(sorted(c.validation_errors),
sorted(errors),
prefix=u"Wrong validation errors when parsing files : {0}".
format(f))
