def validate(self, raise_exception=True, silent=False): """ """ log.debug(u"starting core") self._start_validate(self.source) self.validation_errors = [unicode(error) for error in self.errors] self.validation_errors_exceptions = self.errors if self.errors is None or len(self.errors) == 0: if not silent: log.info(u"validation.valid") else: if not silent: log.error(u"validation.invalid") log.error(u" --- All found errors ---") log.error(self.validation_errors) if raise_exception: raise SchemaError(u"Schema validation failed:\n - {error_msg}.".format( error_msg=u'.\n - '.join(self.validation_errors))) else: if not silent: log.error(u"Errors found but will not raise exception...") # Return validated data return len(self.errors) == 0
def test_files_with_unicode_content_failing(self): """ These tests should fail with the specified exception """ _fail_tests = [ # Test mapping with unicode key and value but wrong type (u"1f.yaml", SchemaError), # Test unicode filename with validation errors (u"2få.yaml", SchemaError), # Test unicode data inside seq but wrong type (u"3f.yaml", SchemaError), ] for failing_test, exception_type in _fail_tests: # f = self.f(os.path.join("fail", failing_test)) f = unicode(self.f(failing_test)) with open(f, "r") as stream: yaml_data = yaml.load(stream) data = yaml_data["data"] schema = yaml_data["schema"] errors = yaml_data["errors"] try: print(u"Running test files: {}".format(f)) c = Core(source_data=data, schema_data=schema) c.validate() except exception_type: pass # OK else: raise AssertionError(u"Exception {} not raised as expected... FILES: {} : {}".format(exception_type, exception_type)) compare(sorted(c.validation_errors), sorted(errors), prefix=u"Wrong validation errors when parsing files : {}".format(f))
def test_type_value(self): # TODO: This test is currently semi broken, partial schemas might be somewhat broken possibly # # Test that when only having a schema; rule it should throw error # with pytest.raises(RuleError) as r: # Rule(schema={"schema;fooone": {"type": "map", "mapping": {"foo": {"type": "str"}}}}) # assert str(r.value) == "<RuleError: error code 4: Key 'type' not found in schema rule: Path: '/'>" # assert r.value.error_key == 'type.missing' # Test a valid rule with both "str" and "unicode" types work r = Rule(schema={"type": str("str")}) r = Rule(schema={"type": unicode("str")}) # Test that type key must be string otherwise exception is raised with pytest.raises(RuleError) as r: Rule(schema={"type": 1}) assert str( r.value ) == "<RuleError: error code 4: Key 'type' in schema rule is not a string type (found int): Path: '/'>" assert r.value.error_key == 'type.not_string' # this tests that the type key must be a string with pytest.raises(RuleError) as r: Rule(schema={"type": 1}, parent=None) assert str( r.value ) == "<RuleError: error code 4: Key 'type' in schema rule is not a string type (found int): Path: '/'>" assert r.value.error_key == 'type.not_string'
def test_files_with_unicode_content_success(self): """ These tests should pass with no exception raised """ _pass_tests = [ # Test mapping with unicode key and value u"1s.yaml", # Test unicode filename u"2så.yaml", # Test sequence with unicode keys u"3s.yaml", ] for passing_test_files in _pass_tests: f = unicode(self.f(passing_test_files)) with open(f, "r") as stream: yaml_data = yaml.load(stream) data = yaml_data["data"] schema = yaml_data["schema"] try: print(u"Running test files: {}".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: {}".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 : {}".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))
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))
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 _validate_scalar_type(self, value, t, path): log.debug(u" # Core scalar: validating scalar type : %s", t) log.debug(u" # Core scalar: scalar type: %s", type(value)) try: if not tt[t](value): self.errors.append(SchemaError.SchemaErrorEntry( msg=u"Value '{value}' is not of type '{scalar_type}'. Path: '{path}'", path=path, value=unicode(value) if tt['str'](value) else value, scalar_type=t)) except KeyError as e: # Type not found in valid types mapping log.debug(e) raise CoreError(u"Unknown type check: %s : %s : %s" % (path, value, t))
def _validate_scalar_type(self, value, t, errors, path): log.debug(u" # Core scalar: validating scalar type : {}".format(t)) log.debug(u" # Core scalar: scalar type: {}".format(type(value))) try: if not tt[t](value): errors.append(SchemaError.SchemaErrorEntry( msg=u"Value '{value}' is not of type '{scalar_type}'. Path: '{path}'", path=path, value=unicode(value) if tt['str'](value) else value, scalar_type=t)) except Exception as e: # Type not found in map log.debug(e) raise Exception(u"Unknown type check: {} : {} : {}".format(path, value, t))
def _validate_scalar_type(self, value, t, path): log.debug(u" # Core scalar: validating scalar type : %s", t) log.debug(u" # Core scalar: scalar type: %s", type(value)) try: if not tt[t](value): self.errors.append( SchemaError.SchemaErrorEntry( msg= u"Value '{value}' is not of type '{scalar_type}'. Path: '{path}'", path=path, value=unicode(value) if tt['str'](value) else value, scalar_type=t)) except Exception as e: # Type not found in map log.debug(e) raise Exception(u"Unknown type check: %s : %s : %s", path, value, t)
def _validate_scalar_type(self, value, t, path): """ """ log.debug(u" # Core scalar: validating scalar type : %s", t) log.debug(u" # Core scalar: scalar type: %s", type(value)) try: if not tt[t](value): self.errors.append(SchemaError.SchemaErrorEntry( msg=u"Value '{value}' is not of type '{scalar_type}'. Path: '{path}'", path=path, value=unicode(value) if tt['str'](value) else value, scalar_type=t)) return False return True except KeyError as e: # Type not found in valid types mapping log.debug(e) raise CoreError(u"Unknown type check: {0!s} : {1!s} : {2!s}".format(path, value, t))
def _handle_func(self, value, rule, path, done=None): """ Helper function that should check if func is specified for this rule and then handle it for all cases in a generic way. """ func = rule.func # func keyword is not defined so nothing to do if not func: return found_method = False for extension in self.loaded_extensions: method = getattr(extension, func, None) if method: found_method = True # No exception will should be caught. If one is raised it should bubble up all the way. ret = method(value, rule, path) if ret is not True and ret is not None: msg = '%s. Path: {path}' % unicode(ret) self.errors.append( SchemaError.SchemaErrorEntry(msg=msg, path=path, value=None)) # If False or None or some other object that is interpreted as False if not ret: raise CoreError( u"Error when running extension function : {0}".format( func)) # Only run the first matched function. Sinc loading order is determined # it should be easy to determine which file is used before others break if not found_method: raise CoreError( u"Did not find method '{0}' in any loaded extension file". format(func))
def validate(self, raise_exception=True): log.debug(u"starting core") self._start_validate(self.source) self.validation_errors = [unicode(error) for error in self.errors] self.validation_errors_exceptions = self.errors if self.errors is None or len(self.errors) == 0: log.info(u"validation.valid") else: log.error(u"validation.invalid") log.error(u" --- All found errors ---") log.error(self.validation_errors) if raise_exception: raise SchemaError(u"Schema validation failed:\n - {error_msg}.".format( error_msg=u'.\n - '.join(self.validation_errors))) else: log.error(u"Errors found but will not raise exception...") # Return validated data return self.source
def test_files_with_unicode_content_failing(self): """ These tests should fail with the specified exception """ _fail_tests = [ # Test mapping with unicode key and value but wrong type (u"1f.yaml", SchemaError), # Test unicode filename with validation errors (u"2få.yaml", SchemaError), # Test unicode data inside seq but wrong type (u"3f.yaml", SchemaError), ] for failing_test, exception_type in _fail_tests: # f = self.f(os.path.join("fail", failing_test)) f = unicode(self.f(failing_test)) with open(f, "r") as stream: yaml_data = yaml.load(stream) data = yaml_data["data"] schema = yaml_data["schema"] errors = yaml_data["errors"] try: print(u"Running test files: {}".format(f)) c = Core(source_data=data, schema_data=schema) c.validate() except exception_type: pass # OK else: raise AssertionError( u"Exception {} not raised as expected... FILES: {} : {}". format(exception_type, exception_type)) compare(sorted(c.validation_errors), sorted(errors), prefix=u"Wrong validation errors when parsing files : {}". format(f))
def test_files_with_unicode_content_success(self): """ These tests should pass with no exception raised """ _pass_tests = [ # Test mapping with unicode key and value u"1s.yaml", # Test unicode filename u"2så.yaml", # Test sequence with unicode keys u"3s.yaml", ] for passing_test_files in _pass_tests: f = unicode(self.f(passing_test_files)) with open(f, "r") as stream: yaml_data = yaml.load(stream) data = yaml_data["data"] schema = yaml_data["schema"] try: print(u"Running test files: {}".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: {}".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 : {}" .format(f))
def test_type_value(self): # TODO: This test is currently semi broken, partial schemas might be somewhat broken possibly # # Test that when only having a schema; rule it should throw error # with pytest.raises(RuleError) as r: # Rule(schema={"schema;fooone": {"type": "map", "mapping": {"foo": {"type": "str"}}}}) # assert str(r.value) == "<RuleError: error code 4: Key 'type' not found in schema rule: Path: '/'>" # assert r.value.error_key == 'type.missing' # Test a valid rule with both "str" and "unicode" types work r = Rule(schema={"type": str("str")}) r = Rule(schema={"type": unicode("str")}) # Test that type key must be string otherwise exception is raised with pytest.raises(RuleError) as r: Rule(schema={"type": 1}) assert str(r.value) == "<RuleError: error code 4: Key 'type' in schema rule is not a string type (found int): Path: '/'>" assert r.value.error_key == 'type.not_string' # this tests that the type key must be a string with pytest.raises(RuleError) as r: Rule(schema={"type": 1}, parent=None) assert str(r.value) == "<RuleError: error code 4: Key 'type' in schema rule is not a string type (found int): Path: '/'>" assert r.value.error_key == 'type.not_string'
def _remap_errors(c): return [unicode(error) for error in c.errors]