JSON Schema validator

Like XML, JSON also provides schema and the code has to validate the json instance with a schema.  In this post, let us see how we can validate the given instance with its JSON schema.

The validator I would recommend is 'json-schema-validator'.  The version I have used is 2.0.1, which  supports both v3 and v4 Json schemas.  You can take a look at the latest versions of the validator also.

Add the following in your pom.xml:

<dependency>

    <groupId>com.github.fge</groupId>
    <artifactId>json-schema-validator</artifactId>
    <version>2.0.1</version>
</dependency>

Then follow these steps:

1) If the schema or the instance are strings, transform them to JsonNode objects:

            ObjectMapper mapper = new ObjectMapper();
             //json instance object
            JsonNode instanceJsonObject = mapper.readTree(jsonInstance);
            //json schema string to json object.
            JsonNode schemaJsonObject = mapper.readTree(jsonSchema);

2) Next step is to get the json schema object:

             //The schema factory supports both Json's v3 and v4 schemas.  Most of the times, the default
             //factory is enough.
             JsonSchemaFactory schemaFactory = JsonSchemaFactory.byDefault();            
             JsonSchema schema = schemaFactory.getJsonSchema(schemaJsonObject );

3) Now the instance can be validated with the validate() of JsonSchema:

             ListProcessingReport report = (ListProcessingReport)schema.validate(instanceNode);

The ListProcessing contains the valiation messages, the missing required field(s) details.  To obtain those details, follow these steps:

            if(!report.isSuccess()){

                JsonNode reportRootNode = report.asJson();            

                if(rootNode.size() > 0){
                    JsonNode errorNode = rootNode.get(0);
                    JsonNode messageNode = errorNode.get("message");
                    if(messageNode != null){
                        logger.error(messageNode.asText());
                    }
                    JsonNode requiredNode = errorNode.get("required");
                    if(requiredNode != null) {
                        logger.error(requiredNode.toString());
                    }
                    JsonNode missingNode = errorNode.get("missing");
                    if(missingNode != null){
                        logger.error((missingNode.toString());
                    }

                }
            }

And...that's all folks.

Debugging Junit tests (in Eclipse)

Let me start my first blog post with what most of the developers don't do:  Writing unit tests.  Just kidding.

Every developer knows the importance of the unit tests.  Before a functionality is implemented, unit tests must be written and it will help to design the implementation effectively.  This post is not about writing the tests.  It is about how to debug the unit tests.

Often times, you may wonder how to find out what is wrong in my test and why it fails.  Debugging it is one of finding what is going wrong.  This post shows how to debug the junit tests using Maven surefire plugin.

Prerequisites:

1. Setup a Eclipse project using maven artifact.
2. Make sure pom.xml has  the following entries:

                      <dependency>
                         <groupId>junit</groupId>
                         <artifactId>junit</artifactId>
                         <version>4.10</version>
                         <scope>test</scope>
                      </dependency>

             and

                     <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-surefire-plugin</artifactId>
                        <version>2.5</version>
                        <inherited>true</inherited>
                        <configuration>
                            <forkMode>always</forkMode>
                            <trimStackTrace>false</trimStackTrace>
                            <argLine>-Xmx1024m</argLine>
                        </configuration>
                     </plugin>

Note: The plugin version may vary.

         
      

To debug the unit tests, follow these steps:

1. The surefire plugin allows to run the tests using -Dmaven.surefire.debug option.  This option will open the port 5005 as a debug port.
2. Using Maven Debug Configuration... create the configuration as shown here:
   
   
   


3. Then using a remote java application option, create a dummy configuration in Eclipse "Remote Java Application" section.   The port is usually 5005.  The server name is 'localhost'.
   
   
   


4. Then run the configuration created in step 2).  Make sure you set breakpoints in the test code.  The test get deployed and halt with the message "Listening for transport dt_socket at address: 5005".
5. Run the configuration created in 2) as "Debug as...", then choose the entry under "Remote Java Application".
6. The execution will stop at the breakpoint.  Now you can debug the unit tests as you do with the regular java code.

Gotchas:

• If you kill the remote java application, it will not terminate the maven surefire plugin.  It is a separate process so it will just run the current test case and when it is about to run the second test case, it will halt with the message "Listening for transport dt_socket at address: 5005".
• If you terminate the remote java application configuration forcibly (by pressing the "Stop" icon in Eclipse), the java process will not be terminated.  Next time if you try to run the maven configuration, it will complain "Address already in use".  You need to terminate the java process manually.