def load_validator(name):
""" Load the JSON Schema Draft 4 validator with the given name from the
local schema directory. """
with open(os.path.join(SCHEMA_PATH, name)) as fh:
schema = json.load(fh)
Draft4Validator.check_schema(schema)
return Draft4Validator(schema, format_checker=checker)
def test_select_all(self, testapi):
"""
Select all link relations and check them for valid JSON schema.
"""
for rel_id in testapi.get(url_for('v1.LinkRelationsView:index')).json.keys():
resp = testapi.get(url_for('v1.LinkRelationsView:get',id=rel_id))
Draft4Validator.check_schema(resp.json).should.be(None)
def serialize(self):
"""Serialize the schema to a pure Python data structure.
After serializing the schema once, it's not possible to mutate
self._schema any more, since these changes would not be reflected in
the serialized output.
"""
# Order keys before serializing.
# This is to get a stable sort order when dumping schemas, and a
# convenient API at the same time (no need to pass in OrderedDicts
# all the time). This keeps calling code more readable.
self._schema = order_dict(self._schema, SCHEMA_KEYS_ORDER)
if 'properties' in self._schema:
for prop_name, prop_def in self._schema['properties'].items():
self._schema['properties'][prop_name] = order_dict(
prop_def, PROPERTY_KEYS_ORDER)
schema = deepcopy(self._schema)
Draft4Validator.check_schema(schema)
# Prevent access to self._schema after serialization in order to avoid
# gotchas where mutations to self._schema don't take effect any more
del self._schema
return schema
def validate(data, schema=None):
if schema is None:
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
counter = Counter([p['name'] for p in data.get('policies')])
dupes = []
for k, v in counter.items():
if v > 1:
dupes.append(k)
if dupes:
return [ValueError(
"Only one policy with a given name allowed, duplicates: %s" % (
", ".join(dupes)))]
return []
try:
resp = specific_error(errors[0])
name = isinstance(errors[0].instance, dict) and errors[0].instance.get('name', 'unknown') or 'unknown'
return [resp, name]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
])
def __init__(self, json_data, strict=False, live_schema=None):
self.live_schema = live_schema
if not hasattr(json_data, '__getitem__'):
raise TypeError('json_data must be a dict.')
if (not self.schema) and (live_schema is None):
raise NotImplementedError('schema not implemented!')
if live_schema is not None:
if not self.schema:
self.schema = live_schema
else:
self.schema['properties'].update(live_schema['properties'])
if "required" in self.schema and "required" in live_schema:
self.schema['required'] = list(
set(self.schema['required']) |
set(live_schema["required"])
)
Draft4Validator.check_schema(self.schema)
self.data = {}
if not strict:
self._filter_data(json_data, self.schema['properties'], self.data)
else:
self.data = json_data
self.validator = Draft4Validator(self.schema)
self.errors = None
def validate(self):
self.log.info("Checking schemas for validity")
for application in self.applications.values():
self.log.info("+ " + application.slug)
for collection in application.collections:
self.log.info('--- ' + collection.slug)
Draft4Validator.check_schema(collection.schema)
def __init__(self, schema=DEFAULT_LTM_SCHEMA):
"""Choose schema and initialize extended Draft4Validator.
Raises:
F5CcclSchemaError: Failed to read or validate the CCCL
API schema file.
"""
try:
self.schema = read_yaml_or_json(schema)
except json.JSONDecodeError as error:
LOGGER.error("%s", error)
raise cccl_exc.F5CcclSchemaError(
'CCCL API schema could not be decoded.')
except IOError as error:
LOGGER.error("%s", error)
raise cccl_exc.F5CcclSchemaError(
'CCCL API schema could not be read.')
try:
Draft4Validator.check_schema(self.schema)
self.validate_properties = Draft4Validator.VALIDATORS["properties"]
validator_with_defaults = validators.extend(
Draft4Validator,
{"properties": self.__set_defaults})
self.validator = validator_with_defaults(self.schema)
except jsonschema.SchemaError as error:
LOGGER.error("%s", error)
raise cccl_exc.F5CcclSchemaError("Invalid API schema")
def validate(data, schema=None):
if schema is None:
schema = generate()
Validator.check_schema(schema)
validator = Validator(schema)
errors = list(validator.iter_errors(data))
if not errors:
return check_unique(data) or []
try:
resp = policy_error_scope(specific_error(errors[0]), data)
name = isinstance(
errors[0].instance,
dict) and errors[0].instance.get(
'name',
'unknown') or 'unknown'
return [resp, name]
except Exception:
logging.exception(
"specific_error failed, traceback, followed by fallback")
return list(filter(None, [
errors[0],
best_match(validator.iter_errors(data)),
]))
def test_schemas_are_valid():
root_dir = os.path.join(
'inspirehep', 'modules', 'records', 'jsonschemas', 'records')
for schemas_dir, _, schemas in os.walk(root_dir):
schemas_path = os.path.sep.join(schemas_dir.split(os.path.sep)[1:])
for schema in schemas:
schema_path = os.path.join(schemas_path, schema)
Draft4Validator.check_schema(fetch_schema(schema_path))
def _validate(self):
# Draft4Validator accepts empty JSON, but we don't want to accept it.
if not self.json:
raise ValueError('Schema is invalid.')
try:
Draft4Validator.check_schema(self.json)
except (SchemaError, ValidationError):
raise ValueError('Schema is invalid.')
def test_put_schema(self):
"""The schema defined for PUT on base end point is valid"""
try:
Draft4Validator.check_schema(snapshot.SnapshotView.PUT_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_schemas_are_valid():
root_dir = os.path.join('inspirehep', 'modules', 'records', 'jsonschemas',
'records')
for schemas_dir, _, schemas in os.walk(root_dir):
schemas_path = os.path.sep.join(schemas_dir.split(os.path.sep)[1:])
for schema in schemas:
if schema.endswith('.json'):
schema_path = os.path.join(schemas_path, schema)
Draft4Validator.check_schema(fetch_schema(schema_path))
def test_get_schema(self):
"""The schema defined for GET is valid"""
try:
Draft4Validator.check_schema(insightiq.InsightIQView.GET_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_post_schema(self):
"""The schema defined for POST on is valid"""
try:
Draft4Validator.check_schema(claritynow.ClarityNowView.POST_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_get_schema(self):
"""The schema defined for GET on is valid"""
try:
Draft4Validator.check_schema(portmap.PortMapView.GET_ARGS_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_get_args(self):
"""The schema defined for the query params on GET is valid"""
try:
Draft4Validator.check_schema(addr.AddrView.GET_ARGS_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def validate_draft4(self, schema):
self.assertEqual(schema['$schema'],
'http://json-schema.org/draft-04/schema#')
try:
Draft4Validator.check_schema(schema)
except SchemaError as ex:
self.fail(
"Json-schema for root is not valid. Failed for {0:s}".format(
ex))
def test_v1_response_schema(self):
"""The default shape we return for every JSON response has a valid schema"""
try:
Draft4Validator.check_schema(flask_common.v1_RESPONSE)
response_schema_ok = True
except ValidationError:
response_schema_ok = False
self.assertTrue(response_schema_ok)
def test_get_schema(self):
"""The schema defined for GET on is valid"""
try:
Draft4Validator.check_schema(jumpbox.JumpboxView.GET_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_token_schema(self):
"""The schema defined for DELETE on /api/1/inf/vlan/token is valid"""
try:
Draft4Validator.check_schema(vlan.VlanView.TASK_ARGS)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def setUpClass(cls):
#warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<ssl.SSLSocket.*>")
network = httplib2.Http()
response, content = network.request('https://developer.mpds.io/mpds.schema.json')
assert response.status == 200
cls.schema = json.loads(content)
Draft4Validator.check_schema(cls.schema)
def test_post_schema(self):
"""The schema defined for POST on /api/1/link is valid"""
try:
Draft4Validator.check_schema(link.LinkView.POST_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_config_schema(self):
"""The schema defined for POST on /config is valid"""
try:
Draft4Validator.check_schema(onefs.OneFSView.CONFIG_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def api(require_login=True, schema=None):
"""
Decorator for API requests.
Handles auth and adds the username as the first argument.
"""
if schema is not None:
Draft4Validator.check_schema(schema)
validator = Draft4Validator(schema)
else:
validator = None
def innerdec(f):
@wraps(f)
def wrapper(*args, **kwargs):
g.user = PUBLIC
user_agent_str = request.headers.get('user-agent', '')
g.user_agent = httpagentparser.detect(user_agent_str,
fill_none=True)
if validator is not None:
try:
validator.validate(request.get_json(cache=True))
except ValidationError as ex:
raise ApiException(requests.codes.bad_request, ex.message)
auth = request.headers.get(AUTHORIZATION_HEADER)
g.auth = auth
if auth is None:
if require_login:
raise ApiException(requests.codes.unauthorized,
"Not logged in")
else:
headers = {AUTHORIZATION_HEADER: auth}
try:
resp = requests.get(OAUTH_USER_API, headers=headers)
resp.raise_for_status()
data = resp.json()
# TODO(dima): Generalize this.
g.user = data.get('current_user', data.get('login'))
assert g.user
g.email = data['email']
except requests.HTTPError as ex:
if resp.status_code == requests.codes.unauthorized:
raise ApiException(requests.codes.unauthorized,
"Invalid credentials")
else:
raise ApiException(requests.codes.server_error,
"Server error")
except (ConnectionError, requests.RequestException) as ex:
raise ApiException(requests.codes.server_error,
"Server error")
return f(g.user, *args, **kwargs)
return wrapper
return innerdec
def test_delete_schema(self):
"""The schema defined for DELETE on /api/1/inf/vlan is valid"""
try:
Draft4Validator.check_schema(vlan.VlanView.DELETE_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_delete_schema(self):
"""The schema defined for DELETE on /api/1/inf/inventory is a valid schema"""
try:
Draft4Validator.check_schema(inventory.InventoryView.DELETE_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def validate(schema_filename, data):
with open(schema_filename) as f:
schema = json.load(f) # cteme JSON Schema primo ze souboru
Validator.check_schema(schema) # zkontroluje schema nebo vyhodi vyjimku
base_uri = 'file://' + os.path.dirname(schema_filename) + '/'
resolver = RefResolver(base_uri, schema)
validator = Validator(schema, resolver=resolver)
return validator.iter_errors(data) # vraci chyby jednu po druhe
def get_error(schema_text):
try:
schema_object = json.loads(schema_text)
Draft4Validator.check_schema(schema_object)
except SchemaError as schema_error:
return schema_error
except ValueError as value_error:
return value_error
return None
def test_post_schema(self):
"""The schema defined for POST on is valid"""
try:
Draft4Validator.check_schema(winserver.WinServerView.POST_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def __testValidateOpts(self, updateId, schemaLevel="full"):
schemaNames = ["repository_holdings"]
collectionNames = {
"repository_holdings": [
"repository_holdings_update_entry",
"repository_holdings_current_entry",
"repository_holdings_unreleased_entry",
"repository_holdings_removed_entry",
"repository_holdings_combined_entry",
],
"entity_sequence_clusters":
["cluster_members", "cluster_provenance", "entity_members"],
}
#
eCount = 0
for schemaName in schemaNames:
for collectionName in collectionNames[schemaName]:
_ = self.__schP.makeSchemaDef(schemaName,
dataTyping="ANY",
saveSchema=True)
cD = self.__schP.makeSchema(schemaName,
collectionName,
encodingType="JSON",
level=schemaLevel,
saveSchema=True)
dL = self.__getRepositoryHoldingsDocuments(
schemaName, collectionName, updateId)
if self.__export:
savePath = os.path.join(HERE, "test-output",
collectionName + ".json")
self.__mU.doExport(savePath, dL, fmt="json", indent=3)
# Raises exceptions for schema compliance.
Draft4Validator.check_schema(cD)
#
valInfo = Draft4Validator(cD, format_checker=FormatChecker())
for ii, dD in enumerate(dL):
logger.debug("Schema %s collection %s document %d",
schemaName, collectionName, ii)
try:
cCount = 0
for error in sorted(valInfo.iter_errors(dD), key=str):
logger.info(
"schema %s collection %s path %s error: %s",
schemaName, collectionName, error.path,
error.message)
logger.info(">>>")
logger.info(">>> failing object is %r", dD)
logger.info(">>>")
eCount += 1
cCount += 1
#
logger.debug("schema %s collection %s count %d",
schemaName, collectionName, cCount)
except Exception as e:
logger.exception("Validation error %s", str(e))
return eCount
def test_post_schema(self):
"""The schema we've defined for POST on /api/2/auth/token is valid"""
try:
Draft4Validator.check_schema(token.TokenView2.POST_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_schema_validity():
for name in ("schema_base.json",
"schema_data.json",
"schema_node.json",
"schema_prov_exe.json",
"schema_workflow.json"):
with open(os.path.join(sch_pth, name), 'r') as f:
schema = json.load(f)
Draft4Validator.check_schema(schema)
def json_schema_validator(value):
"""
raises ValidationError if value is not a valid json schema
"""
try:
Draft4Validator.check_schema(value)
except SchemaError as e:
raise ValidationError(_('Schema is invalid: %(msg)s'),
params={"msg": str(e.message)})
def assertContainsRequiredFields(schema_filename, response):
schema_dir = os.path.abspath(os.path.join(os.path.dirname(
inspect.getfile(inspect.currentframe())), '..', '..', 'schema'))
schema_filename = os.path.join(schema_dir, schema_filename)
schema = json.load(open(schema_filename))
Draft4Validator.check_schema(schema)
resolver = RefResolver(referrer=schema, base_uri='file://' + schema_dir + '/')
# Raises ValidationError when incorrect response
validate(response, schema, resolver=resolver)
def test_iamges_schema(self):
"""The schema defined for GET on /images is valid"""
try:
Draft4Validator.check_schema(centos.CentOSView.IMAGES_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def check_schema(schema):
try:
Draft4Validator.check_schema(schema)
except SchemaError as e:
pytest.fail(
'invalid schema in test, should only happen while developing'
' tests! %s' % e)
else:
return schema
def test_delete_schema(self):
"""The schema defined for DELETE on is valid"""
try:
Draft4Validator.check_schema(centos.CentOSView.DELETE_SCHEMA)
schema_valid = True
except RuntimeError:
schema_valid = False
self.assertTrue(schema_valid)
def test_schema(self):
"""Check schema for validity."""
# check it loads okay
with open(
resource_filename("gramps_webapi", "data/apispec.yaml")
) as file_handle:
api_schema = yaml.safe_load(file_handle)
# check structure
Draft4Validator.check_schema(api_schema)
def get_validator(self, ref):
from jsonschema import Draft4Validator
validator = self._validators.get(ref)
if validator is not None:
return validator
schema = {"$ref": ref, **self.doc}
Draft4Validator.check_schema(schema)
self._validators[ref] = validator = Draft4Validator(schema)
return validator
def test():
"""Tests all included schemata against the Draft4Validator"""
from jsonschema import Draft4Validator
for schemaname, schemadata in schemastore.items():
hfoslog("[SCHEMATA] Validating schema ", schemaname)
Draft4Validator.check_schema(schemadata['schema'])
if 'uuid' not in schemadata['schema']:
hfoslog("[SCHEMATA] Schema without uuid encountered: ", schemaname, lvl=debug)
def test_schema_handler_with_default_uri_normalization(self):
response = self.fetch('/person/Gender/_schema')
self.assertEqual(response.code, 200)
schema = json.loads(response.body)
self.assertEqual(schema['id'], u'http://semantica.globo.com/person/Gender')
self.assertEqual(schema['$schema'], 'http://json-schema.org/draft-04/schema#')
try:
Draft4Validator.check_schema(schema)
except SchemaError as ex:
self.fail("Json-schema for class {0} is not valid. Failed for {1:s}".format('person:Gender', ex))
def validate_obj_schema(obj, schema):
""" Validate an object with an schema, if false, returns error message """
try:
Draft4Validator.check_schema(schema)
Draft4Validator(schema).validate(obj)
except jsonschema.ValidationError as val_err:
return (False, {'msg': str(val_err)})
except jsonschema.SchemaError as sch_err:
return (False, {'msg': str(sch_err)})
return (True, obj)
def test_skill_configuration_schema_is_valid_wrt_draft_04():
"""Test that the JSON schema for the skill configuration file is compliant with the specification Draft 04."""
skill_config_schema = json.load(
open(
os.path.join(
ROOT_DIR, "aea", "configurations", "schemas", "skill-config_schema.json"
)
)
)
Draft4Validator.check_schema(skill_config_schema)
def test_valid_schema(self):
schema_path = "../schema/phenopacket-schema.json"
schema_fh = open(os.path.join(os.path.dirname(__file__), schema_path), "r")
schema = json.load(schema_fh)
schema_fh.close()
## call validator
Draft4Validator.check_schema(schema)
def validateSchemasInFolder(folder):
path = os.path.abspath(folder)
files = [f for f in listdir(path) if isfile(join(path, f))]
for schemaFile in files:
if (schemaFile.endswith('.json')):
print("Validating schema ", schemaFile, "...")
schema = json.load(open(join(path, schemaFile)))
Draft4Validator.check_schema(schema)
print("done.")
def load_schema(schema):
"""Validates the given schema and returns an associated schema validator
object that can check other objects' conformance to the schema.
:param schema: The JSON schema object.
:returns: The object loaded in from the JSON schema file.
"""
Draft4Validator.check_schema(schema)
return Draft4Validator(schema, format_checker=FormatChecker())
def validateSchemasInFolder(folder):
path = os.path.abspath(folder)
files = [ f for f in listdir(path) if isfile(join(path,f)) ]
for schemaFile in files:
if (schemaFile.endswith('.json')):
print("Validating schema ", schemaFile, "...")
schema = json.load(open(join(path,schemaFile)))
Draft4Validator.check_schema(schema)
print("done.")
def schema(self, schema):
"""sets the stream's schema. An empty schema is "{}". The schemas allow you to set a specific data type.
Both python dicts and strings are accepted."""
if isinstance(schema, basestring):
strschema = schema
schema = json.loads(schema)
else:
strschema = json.dumps(schema)
Draft4Validator.check_schema(schema)
self.set({"schema": strschema})
def __parse_schema(self):
if '$schema' not in self.schema or self.schema['$schema'].find('draft-03') == -1:
Draft4Validator.check_schema(self.schema)
else:
raise ValueError("Draft-03 schema is not supported currently.")
self.object_defines['root'] = self.schema
if 'id' in self.schema:
self.base_uri = self.schema['id']
self.__parse_object('root',self.schema)
def test_1_generate_json_schema(self):
meta_json = SQLJSON()
print()
f = open(os.path.join(Test_Resource_Dir, "../../../schema/", "sql.json"), "w")
_schema = meta_json.generate_schema()
json.dump(obj=_schema, fp=f, sort_keys=True, indent=4)
f.close()
Draft4Validator.check_schema(_schema)
def create(self, schema="{}", **kwargs):
"""Creates a stream given an optional JSON schema encoded as a python dict. You can also add other properties
of the stream, such as the icon, datatype or description. Create accepts both a string schema and
a dict-encoded schema."""
if isinstance(schema, basestring):
strschema = schema
schema = json.loads(schema)
else:
strschema = json.dumps(schema)
Draft4Validator.check_schema(schema)
kwargs["schema"] = strschema
self.metadata = self.db.create(self.path, kwargs).json()
def derive_invocation_schema(manifest):
"""
Creates an invocation schema from a gear manifest.
This can be used to validate the files and configuration offered to run a gear.
"""
validate_manifest(manifest)
result = {
'title': 'Invocation manifest for ' + manifest['label'],
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'properties': {
'config': {
'type': 'object',
'properties': {},
'required': []
},
'inputs': {
'type': 'object',
'properties': {},
'required': []
}
},
'required': [ 'config', 'inputs' ]
}
# Copy over constraints from manifest
for kind in ['config', 'inputs']:
for key in manifest[kind]:
# Copy constraints, removing 'base' keyword which is not a constraint
val = copy.deepcopy(manifest[kind][key])
val.pop('base', None)
# The config map holds scalars, while the inputs map holds objects.
if kind == 'config':
result['properties'][kind]['properties'][key] = val
else:
result['properties'][kind]['properties'][key] = {}
result['properties'][kind]['properties'][key]['properties'] = val
result['properties'][kind]['properties'][key]['type'] = 'object'
# Require the key be preset.
result['properties'][kind]['required'].append(key)
# After handling each key, remove required array if none are present.
# Required by jsonschema (minItems 1).
if len(result['properties'][kind]['required']) == 0:
result['properties'][kind].pop('required', None)
# Important: check our work - the result must be a valid schema.
Draft4Validator.check_schema(result)
return result
def generate_models(self, files):
loader = JmgLoader()
for fname in (f for fileGlob in files for f in glob.glob(fileGlob)):
if self.root_name:
scope = [self.root_name]
else:
base_name = os.path.basename(fname)
base_uri = os.path.splitext(base_name)[0]
base_uri = base_uri.replace('.schema', '')
scope = [base_uri]
with open(fname) as jsonFile:
print("%s" % fname)
# root_schema = json.load(jsonFile)
# base_uri = 'file://' + os.path.split(os.path.realpath(f))[0]
base_uri = 'file://' + os.path.realpath(fname)
root_schema = jsonref.load(jsonFile,
base_uri=base_uri,
jsonschema=False, # resolve references relative to local tree, not against "id" URIs
loader=loader,
object_pairs_hook=collections.OrderedDict
)
# import json
# print(json.dumps(root_schema, indent=4, separators=(',', ': ')))
if self.validate:
# TODO: Add exception handling
try:
Draft4Validator.check_schema(root_schema)
except SchemaError as e:
print(e)
sys.exit(-1)
assert isinstance(root_schema, dict)
if JsonSchema2Model.SCHEMA_URI not in root_schema:
root_schema[JsonSchema2Model.SCHEMA_URI] = fname
self.create_model(root_schema, scope)
self.render_models()
self.copy_static_files()
if self.include_dependencies:
self.copy_dependencies()
def validate_schema(path, schemaFile):
try:
logger.info("Validating schema %s", schemaFile)
schema_file = open(join(path, schemaFile))
schema = json.load(schema_file)
try:
Draft4Validator.check_schema(schema)
return True
except Exception as e:
logger.error(e)
return False
logger.info("done.")
finally:
schema_file.close()
def _jsonschema_errors(self):
from django.conf import settings
errors = []
schemas = settings.SIMPLE_JSONSCHEMA
for url, schema in schemas.items():
try:
Draft4Validator.check_schema(schema)
except SchemaError as e:
errors.append({
'url': url,
'error': e,
'schema': json.dumps(schema, indent=4, sort_keys=True)
})
return errors
def setUp(self):
self.test_request = {
"elements": "K-Ag",
"classes": "iodide",
"props": "heat capacity",
"lattices": "cubic"
}
network = httplib2.Http()
response, content = network.request('http://developer.mpds.io/mpds.schema.json')
assert response.status == 200
self.schema = json.loads(content)
Draft4Validator.check_schema(self.schema)
def validate(self, obj, check_schema=False):
'''Validate obj against the schema and check reference constraints.
Returns a dictionary where each key is a tuple to the path of the
error and each value is a list of errors which occurred at that
path. On successful validation, None is returned.
'''
# Validate object against schema
schema = self.schema
add_instance_constraints(schema, obj)
if check_schema:
Draft4Validator.check_schema(schema)
validator = Draft4Validator(schema)
try:
validator.validate(obj)
except exceptions.ValidationError as e:
return {tuple(e.path): [e.message]}
def isolate_file_invocation(invocation, input_name): """ Given an invocation schema, isolate just a specific file. Useful to validate a single input. """ inv = copy.deepcopy(invocation) fis = inv['properties']['inputs']['properties'][input_name] fis['title'] = 'Input invocation manifest for ' + input_name fis['$schema'] = 'http://json-schema.org/draft-04/schema#' fis['type'] = 'object' # Important: check our work - the result must be a valid schema. Draft4Validator.check_schema(fis) return fis
def isolate_config_invocation(invocation): """ Given an invocation schema, isolate just the config portion. Useful to validate configuration options separately from files. """ inv = copy.deepcopy(invocation) fis = inv['properties']['config'] fis['title'] = 'Config invocation manifest' fis['$schema'] = 'http://json-schema.org/draft-04/schema#' fis['type'] = 'object' # Important: check our work - the result must be a valid schema. Draft4Validator.check_schema(fis) return fis
