import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Validates a given JSON Object against the default profile schema.
 * @param jsonObjectToValidate
 * @throws IOException
 * @throws DataPackageException
 * @throws ValidationException 
 */
public void validate(JSONObject jsonObjectToValidate) throws IOException, DataPackageException, ValidationException{
    
    // If a profile value is provided.
    if(jsonObjectToValidate.has(Package.JSON_KEY_PROFILE)){
        String profile = jsonObjectToValidate.getString(Package.JSON_KEY_PROFILE);
        
        String[] schemes = {"http", "https"};
        UrlValidator urlValidator = new UrlValidator(schemes);
        
        if (urlValidator.isValid(profile)) {
            this.validate(jsonObjectToValidate, new URL(profile));
        }else{
            this.validate(jsonObjectToValidate, profile);
        }
        
    }else{
        // If no profile value is provided, use default value.
        this.validate(jsonObjectToValidate, Profile.PROFILE_DEFAULT);
    }   
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Override
public boolean check(
        HttpServerExchange exchange,
        RequestContext context,
        BsonDocument contentToCheck,
        BsonValue args) {
    if (contentToCheck == null) {
        return false;
    }

    try {
        schema.validate(new JSONObject(contentToCheck.toString()));
    } catch (ValidationException ve) {
        context.addWarning(ve.getMessage());
        ve.getCausingExceptions().stream()
                .map(ValidationException::getMessage)
                .forEach(context::addWarning);

        return false;
    }

    return true;
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * We only want to go through this initialization if we have to because it's a
 * performance issue the first time it is executed.
 * Because of this, so we don't include this logic in the constructor and only
 * call it when it is actually required after trying all other type inferral.
 * @param geoJson
 * @throws ValidationException 
 */
private void validateGeoJsonSchema(JSONObject geoJson) throws ValidationException{
    if(this.getGeoJsonSchema() == null){
        // FIXME: Maybe this infering against geojson scheme is too much.
        // Grabbed geojson schema from here: https://github.com/fge/sample-json-schemas/tree/master/geojson
        InputStream geoJsonSchemaInputStream = TypeInferrer.class.getResourceAsStream("/schemas/geojson/geojson.json");
        JSONObject rawGeoJsonSchema = new JSONObject(new JSONTokener(geoJsonSchemaInputStream));
        this.setGeoJsonSchema(SchemaLoader.load(rawGeoJsonSchema));
    }
    this.getGeoJsonSchema().validate(geoJson);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Read, create, and validate a table schema with local descriptor.
 * @param schemaFilePath
 * @param strict
 * @throws ValidationException
 * @throws PrimaryKeyException
 * @throws ForeignKeyException
 * @throws Exception 
 */
public Schema(String schemaFilePath, boolean strict) throws ValidationException, PrimaryKeyException, ForeignKeyException, Exception{
    this.strictValidation = strict;
    this.initValidator(); 
    InputStream is = new FileInputStream(schemaFilePath);
    InputStreamReader inputStreamReader = new InputStreamReader(is);
    this.initSchemaFromStream(inputStreamReader);
    
    this.validate();
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Check if schema is valid or not.
 * @return 
 */
public boolean isValid(){
    try{
        validate();
        return true;
        
    }catch(ValidationException ve){
        return false;
    }
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Validate the loaded Schema.
 * Validation is strict or unstrict depending on how the package was
 * instanciated with the strict flag.
 * @throws ValidationException 
 */
public final void validate() throws ValidationException{
    try{
         this.tableJsonSchema.validate(this.getJson());
        
    }catch(ValidationException ve){
        if(this.strictValidation){
            throw ve;
        }else{
            this.getErrors().add(ve);
        }
    }
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testCreateSchemaFromInvalidSchemaJson() throws PrimaryKeyException, ForeignKeyException{  
    JSONObject schemaJsonObj = new JSONObject();
   
    schemaJsonObj.put("fields", new JSONArray());
    Field nameField = new Field("id", Field.FIELD_TYPE_INTEGER);
    Field invalidField = new Field("coordinates", "invalid");
    schemaJsonObj.getJSONArray("fields").put(nameField.getJson());
    schemaJsonObj.getJSONArray("fields").put(invalidField.getJson());
    
    exception.expect(ValidationException.class);
    Schema invalidSchema = new Schema(schemaJsonObj, true);
    
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testInvalidForeignKeyString() throws PrimaryKeyException, ForeignKeyException, Exception{
    String sourceFileAbsPath = SchemaTest.class.getResource("/fixtures/foreignkeys/schema_invalid_fk_string.json").getPath();
    
    exception.expect(ValidationException.class);
    Schema schema = new Schema(sourceFileAbsPath, true);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Load from String representation of JSON object or from a zip file path.
 * @param jsonStringSource
 * @param strict
 * @throws IOException
 * @throws DataPackageException
 * @throws ValidationException
 */
public Package(String jsonStringSource, boolean strict) throws IOException, DataPackageException, ValidationException{
    this.strictValidation = strict;
    
    // If zip file is given.
    if(jsonStringSource.toLowerCase().endsWith(".zip")){
        // Read in memory the file inside the zip.
        ZipFile zipFile = new ZipFile(jsonStringSource);
        ZipEntry entry = zipFile.getEntry(DATAPACKAGE_FILENAME);
        
        // Throw exception if expected datapackage.json file not found.
        if(entry == null){
            throw new DataPackageException("The zip file does not contain the expected file: " + DATAPACKAGE_FILENAME);
        }
        
        // Read the datapackage.json file inside the zip
        try(InputStream is = zipFile.getInputStream(entry)){
            StringBuilder out = new StringBuilder();
            try(BufferedReader reader = new BufferedReader(new InputStreamReader(is))){
                String line = null;
                while ((line = reader.readLine()) != null) {
                    out.append(line);
                }
            }
            
            // Create and set the JSONObject for the datapackage.json that was read from inside the zip file.
            this.setJson(new JSONObject(out.toString()));  
            
            // Validate.
            this.validate();
        }
   
    }else{
        // Create and set the JSONObject fpr the String representation of desriptor JSON object.
        this.setJson(new JSONObject(jsonStringSource)); 
        
        // If String representation of desriptor JSON object is provided.
        this.validate(); 
    }
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Validation is strict or unstrict depending on how the package was
 * instanciated with the strict flag.
 * @throws IOException
 * @throws DataPackageException
 * @throws ValidationException 
 */
public final void validate() throws IOException, DataPackageException, ValidationException{
    try{
        this.validator.validate(this.getJson());
        
    }catch(ValidationException ve){
        if(this.strictValidation){
            throw ve;
        }else{
            errors.add(ve);
        }
    }
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testLoadInvalidJsonObject() throws IOException, DataPackageException{
    // Create JSON Object for testing
    JSONObject jsonObject = new JSONObject("{\"name\": \"test\"}");
    
    // Build the datapackage, it will throw ValidationException because there are no resources.
    exception.expect(ValidationException.class);
    Package dp = new Package(jsonObject, true);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testValidUrlWithInvalidJson() throws DataPackageException, MalformedURLException, IOException{
    // Preferably we would use mockito/powermock to mock URL Connection
    // But could not resolve AbstractMethodError: https://stackoverflow.com/a/32696152/4030804
    URL url = new URL("https://raw.githubusercontent.com/frictionlessdata/datapackage-java/master/src/test/resources/fixtures/simple_invalid_datapackage.json");
    exception.expect(ValidationException.class);
    Package dp = new Package(url, true);
    
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testReadFromZipFileWithInvalidDatapackageDescriptorAndStrictValidation() throws Exception{
    String sourceFileAbsPath = PackageTest.class.getResource("/fixtures/zip/invalid_datapackage.zip").getPath();
    
    exception.expect(ValidationException.class);
    Package p = new Package(sourceFileAbsPath, true);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testValidatingInvalidJsonObject() throws IOException, DataPackageException {
    JSONObject datapackageJsonObject = new JSONObject("{\"invalid\" : \"json\"}");
    
    exception.expect(ValidationException.class);
    validator.validate(datapackageJsonObject);  
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testValidatingInvalidJsonString() throws IOException, DataPackageException{
    String datapackageJsonString = "{\"invalid\" : \"json\"}";
    
    exception.expect(ValidationException.class);
    validator.validate(datapackageJsonString);   
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
/**
 * Deploy a component with given JSON configuration
 *
 * @param deployConfig Json configuration corresponding to a component to be deployed
 * @param future       Future to provide the status of deployment
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
public void deploy(JsonObject deployConfig, Future<Boolean> future) {
	if (null == this.vertx) {
		String errMesg = "Not setup yet! Call 'setup' method first.";

		logger.error(errMesg);
		future.fail(new Exception(errMesg));

		return;
	}

	try {
		Schema jsonSchema = BaseUtil.schemaFromResource("/deploy-opts-schema.json");
		String jsonData = deployConfig.toString();

		BaseUtil.validateData(jsonSchema, jsonData);
	} catch (ValidationException vldEx) {
		logger.error("Issue with deployment configuration validation!", vldEx);

		vldEx
				.getCausingExceptions()
				.stream()
				.map(ValidationException::getMessage)
				.forEach((errMsg) -> {
					logger.error(errMsg);
				});

		future.fail(vldEx);

		return;
	} catch (IOException ioEx) {
		logger.error("Issue while loading schema configuration!", ioEx);
		future.fail(ioEx);

		return;
	}

	DeployComponent component = this.setupComponent(deployConfig);
	this.deployRecords.deploy(component.getIdentifier(), component.getDeployOpts(), future);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void invalidSchemaTest() throws Exception {
	thrown.expect(ValidationException.class);

	Schema jsonSchema = BaseUtil.schemaFromResource("/deployer-schema.json");
	Assert.assertNotNull(jsonSchema);

	File jsonFile = new File("sample/test-component.json");
	Assert.assertNotNull(jsonFile);

	String jsonData = FileUtils.readFileToString(jsonFile, Charset.defaultCharset());
	Assert.assertTrue("JSON string length greater than zero", (0 < jsonData.length()));

	BaseUtil.validateData(jsonSchema, jsonData);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
@Test
public void testDeployWrongConfig(TestContext testContext) throws Exception {
	Future<Void> future = Future.future();

	future.setHandler(testContext.asyncAssertFailure(res -> {
		Assert.assertFalse(vtxDeployer.isVertxSetup());
		Assert.assertTrue("Invalid configuration", ValidationException.class.isInstance(res));
	}));

	vtxDeployer.setup("sample/test-component.json", future);
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
public List<SchemaIncompatibility> collectIncompatibilities(final JSONObject schemaJson) {
    final List<SchemaIncompatibility> incompatibilities = new ArrayList<>();

    try {
        metaSchema.validate(schemaJson);
    } catch (final ValidationException e) {
        collectErrorMessages(e, incompatibilities);
    }

    return incompatibilities;
}
 

import org.everit.json.schema.ValidationException; //导入依赖的package包/类
private void collectErrorMessages(final ValidationException e,
                                  final List<SchemaIncompatibility> incompatibilities) {
    if (e.getCausingExceptions().isEmpty()) {
        incompatibilities.add(
                new ForbiddenAttributeIncompatibility(e.getPointerToViolation(), e.getErrorMessage()));
    } else {
        e.getCausingExceptions()
                .forEach(causingException -> collectErrorMessages(causingException, incompatibilities));
    }
}