Java ValidationException类代码示例

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);   
}