Beispiel #1
0
def additionalProperties(validator, aP, instance, schema):
    if not validator.is_type(instance, "object"):
        return

    extras = set(_utils.find_additional_properties(instance, schema))

    if validator.is_type(aP, "object"):
        for extra in extras:
            for error in validator.descend(instance[extra], aP, path=extra):
                yield error
    elif not aP and extras:
        if "patternProperties" in schema:
            patterns = sorted(schema["patternProperties"])
            if len(extras) == 1:
                verb = "does"
            else:
                verb = "do"
            error = "%s %s not match any of the regexes: %s" % (
                ", ".join(map(repr, sorted(extras))),
                verb,
                ", ".join(map(repr, patterns)),
            )
            yield ValidationError(error)
        else:
            error = "Additional properties are not allowed (%s %s unexpected)"
            yield ValidationError(error % _utils.extras_msg(extras))
Beispiel #2
0
def own_additional_properties(validator, aP, instance,
                              schema) -> Iterator:  # type: ignore
    """Additional properties validator."""
    for _ in additionalProperties(validator, aP, instance, schema):
        raise ExtraPropertiesError(
            list(find_additional_properties(instance, schema)))
    return iter(())
Beispiel #3
0
def additionalProperties(validator, aP, instance, schema):
    if not validator.is_type(instance, "object"):
        return

    extras = set(_utils.find_additional_properties(instance, schema))

    if validator.is_type(aP, "object"):
        for extra in extras:
            for error in validator.descend(instance[extra], aP, path=extra):
                yield error
    elif not aP and extras:
        if "patternProperties" in schema:
            patterns = sorted(schema["patternProperties"])
            if len(extras) == 1:
                verb = "does"
            else:
                verb = "do"
            error = "%s %s not match any of the regexes: %s" % (
                ", ".join(map(repr, sorted(extras))),
                verb,
                ", ".join(map(repr, patterns)),
            )
            yield ValidationError(error)
        else:
            error = "Additional properties are not allowed (%s %s unexpected)"
            yield ValidationError(error % _utils.extras_msg(extras))
Beispiel #4
0
def scrub_index_data(index_data: dict, bundle_id: str) -> list:
    cache = S3UrlCache()

    def request_json(url):
        return json.loads(cache.resolve(url).decode("utf-8"))

    resolver = validators.RefResolver(referrer='',
                                      base_uri='',
                                      handlers={
                                          'http': request_json,
                                          'https': request_json
                                      })
    extra_fields = []
    extra_documents = []
    for document in index_data.keys():
        for doc_list_ind, document_content in enumerate(index_data[document]):
            schema_info = SchemaInfo.from_json(document_content)
            if schema_info is not None:
                try:
                    schema = request_json(schema_info.url)
                except Exception as ex:
                    extra_documents.append(document)
                    logger.warning(
                        f"Unable to retrieve JSON schema information from {document} in bundle {bundle_id} "
                        f"because retrieving {schema_info.url} caused exception: {ex}."
                    )
                else:
                    for error in DSS_Draft4Validator(
                            schema,
                            resolver=resolver).iter_errors(document_content):
                        if error.validator == 'additionalProperties':
                            path = [document, doc_list_ind, *error.path]
                            #  Example error message: "Additional properties are not allowed ('extra_lst', 'extra_top'
                            #  were unexpected)" or "'extra', does not match any of the regexes: '^characteristics_.*$'"
                            fields_to_remove = (path, [
                                field
                                for field in _utils.find_additional_properties(
                                    error.instance, error.schema)
                            ])
                            extra_fields.append(fields_to_remove)
            else:
                logger.warning(
                    f"Unable to retrieve JSON schema information from {document} in bundle {bundle_id}."
                )
                extra_documents.append(document)

    if extra_documents:
        extra_fields.append(([], extra_documents))
    removed_fields = []
    for path, fields in extra_fields:
        remove_json_fields(index_data, path, fields)
        removed_fields.extend(
            ['.'.join((*[str(p) for p in path], field)) for field in fields])
    if removed_fields:
        logger.info(
            f"In {bundle_id}, unexpected additional fields have been removed from the data"
            f" to be indexed. Removed {removed_fields}.")
    return removed_fields
Beispiel #5
0
def additionalProperties(validator, aP, instance, schema):
    if not validator.is_type(instance, "object"):
        return

    extras = set(_utils.find_additional_properties(instance, schema))

    if validator.is_type(aP, "object"):
        for extra in extras:
            for error in validator.descend(instance[extra], aP, path=extra):
                yield error
    elif not aP and extras:
        error = "Additional properties are not allowed (%s %s unexpected)"
        yield ValidationError(error % _utils.extras_msg(extras))
Beispiel #6
0
def additionalProperties(validator, aP, instance, schema):
    if not validator.is_type(instance, "object"):
        return

    extras = set(_utils.find_additional_properties(instance, schema))

    if validator.is_type(aP, "object"):
        for extra in extras:
            for error in validator.descend(instance[extra], aP, path=extra):
                yield error
    elif not aP and extras:
        error = "Additional properties are not allowed (%s %s unexpected)"
        yield ValidationError(error % _utils.extras_msg(extras))
Beispiel #7
0
def strictProperties_draft5(validator, sP, instance, schema):
    if not validator.is_type(instance, "object"):
        return

    extras = set(_utils.find_additional_properties(instance, schema, strict=True))
    missing = _utils.property_missing(instance, schema)

    if sP and (extras or (missing is not None)):
        if extras:
            error = ("Additional properties are strictly not allowed (%s %s unexpected)" %
                _utils.extras_msg(extras,))
        else:
            error = "Missing strictly required property (%s)" % (missing,)
        yield ValidationError(error)
Beispiel #8
0
def handle_error_for_schema_with_id(error, path):
    schema_id = error.schema['id']

    if is_service_dict_schema(
            schema_id) and error.validator == 'additionalProperties':
        properties = _utils.find_additional_properties(error.instance,
                                                       error.schema)
        return "Invalid service name '{}' - only {} characters are allowed".format(
            # The service_name is the key to the json object
            properties.next(),
            VALID_NAME_CHARS)

    if error.validator == 'additionalProperties':
        if schema_id == '#/definitions/service':
            invalid_config_key = parse_key_from_error_msg(error)
            return get_unsupported_config_msg(path, invalid_config_key)

        if not error.path:
            return '{}\n{}'.format(error.message, VERSION_EXPLANATION)
def _additional_properties(validator, aP, instance, schema):
    """Validate 'additionalProperties' properties."""
    from jsonschema import _utils

    if not validator.is_type(instance, "object"):  # pragma: no cover
        return

    extras = set(_utils.find_additional_properties(instance, schema))

    if validator.is_type(aP, "object"):
        # We hardly use this below
        for extra in extras:  # pragma: no cover
            for error in validator.descend(instance[extra], aP, path=extra):
                yield error

    elif not aP and extras:
        for extra in extras:
            error = jsonschema.ValidationError("Unrecognized property")
            error.path.append(extra)
            yield error
Beispiel #10
0
def additionalProperties(validator, aP, instance, schema):
    if not validator.is_type(instance, "object"):
        return

    extras = set(find_additional_properties(instance, schema))

    if validator.is_type(aP, "object"):
        for extra in extras:
            yield from validator.descend(instance[extra], aP, path=extra)
    elif not aP and extras:
        if "patternProperties" in schema:
            if len(extras) == 1:
                verb = "does"
            else:
                verb = "do"

            joined = ", ".join(repr(each) for each in sorted(extras))
            patterns = ", ".join(
                repr(each) for each in sorted(schema["patternProperties"]))
            error = f"{joined} {verb} not match any of the regexes: {patterns}"
            yield ValidationError(error)
        else:
            error = "Additional properties are not allowed (%s %s unexpected)"
            yield ValidationError(error % extras_msg(extras))
Beispiel #11
0
def flex_additionalProperties(schema, err):
    extras = find_additional_properties(err.instance, err.schema)
    for extra in extras:
        schema['properties'][extra] = json2schema(err.instance[extra], extra, err.path)