Validating json payload against swagger file - json-schema-validator

Question

I am trying to validate a json payload against a swagger file that contains the service agreement. I am using the json-schema-validator(2.1.7) library to achieve this, but at the moment it's not validating against the specified patterns or min/max length.

Java Code:

public void validateJsonData(final String jsonData) throws IOException, ProcessingException {

    ClassLoader classLoader = getClass().getClassLoader();
    File jsonSchemaFile = new File (classLoader.getResource("coachingStatusUpdate.json").getFile());

    String jsonSchema = new String(Files.readAllBytes(jsonSchemaFile.toPath()));

    final JsonNode dataNode = JsonLoader.fromString(jsonData);
    final JsonNode schemaNode = JsonLoader.fromString(jsonSchema);

    final JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
    JsonValidator jsonValidator = factory.getValidator();

    ProcessingReport report = jsonValidator.validate(schemaNode, dataNode);
    System.out.println(report);
    if (!report.toString().contains("success")) {
        throw new ProcessingException (
                report.toString());
    }
}

Message I am sending through

{
  "a": "b",
  "c": "d",
  "e": -1,
  "f": "2018-10-30",
  "g": "string" }

The swagger definition:

    {
  "swagger": "2.0",
  "info": {
    "version": "1.0.0",
    "title": "Test",
    "termsOfService": "http://www.test.co.za",
    "license": {
      "name": "Test"
    }
  },
  "host": "localhost:9001",
  "basePath": "/test/",
  "tags": [
    {
      "name": "controller",
      "description": "Submission"
    }
  ],
  "paths": {
    "/a": {
      "put": {
        "tags": [
          "controller"
        ],
        "summary": "a",
        "operationId": "aPUT",
        "consumes": [
          "application/json;charset=UTF-8"
        ],
        "produces": [
          "application/json;charset=UTF-8"
        ],
        "parameters": [
          {
            "in": "body",
            "name": "aRequest",
            "description": "aRequest",
            "required": true,
            "schema": {
              "$ref": "#/definitions/aRequest"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Received",
            "schema": {
              "$ref": "#/definitions/a"
            }
          },
          "400": {
            "description": "Bad Request"
          },
          "401": {
            "description": "Unauthorized"
          },
          "408": {
            "description": "Request Timeout"
          },
          "500": {
            "description": "Generic Error"
          },
          "502": {
            "description": "Bad Gateway"
          },
          "503": {
            "description": "Service Unavailable"
          }
        }
      }
    }
  },
  "definitions": {
    "aRequest": {
      "type": "object",
      "required": [
        "a",
        "b",
        "c",
        "d"
      ],
      "properties": {
        "a": {
          "type": "string",
          "description": "Status",
          "enum": [
            "a",
            "b",
            "c",
            "d",
            "e",
            "f",
            "g",
            "h"
          ]
        },
        "aReason": {
          "type": "string",
          "description": "Reason",
          "enum": [
            "a",
            "b",
            "c",
            "d",
            "e",
            "f",
            "g",
            "h",
            "i",
            "j",
            "k",
            "l",
            "m",
            "n"
          ]
        },
        "correlationID": {
          "type": "integer",
          "format": "int32",
          "description": "",
          "minimum": 1,
          "maximum": 9999999
        },
        "effectiveDate": {
          "type": "string",
          "format": "date",
          "description": ""
        },
        "f": {
          "type": "string",
          "description": "",
          "minLength": 1,
          "maxLength": 100
        }
      }
    },
    "ResponseEntity": {
      "type": "object",
      "properties": {
        "body": {
          "type": "object"
        },
        "statusCode": {
          "type": "string",
          "enum": [
            "100",
            "101",
            "102",
            "103",
            "200",
            "201",
            "202",
            "203",
            "204",
            "205",
            "206",
            "207",
            "208",
            "226",
            "300",
            "301",
            "302",
            "303",
            "304",
            "305",
            "307",
            "308",
            "400",
            "401",
            "402",
            "403",
            "404",
            "405",
            "406",
            "407",
            "408",
            "409",
            "410",
            "411",
            "412",
            "413",
            "414",
            "415",
            "416",
            "417",
            "418",
            "419",
            "420",
            "421",
            "422",
            "423",
            "424",
            "426",
            "428",
            "429",
            "431",
            "451",
            "500",
            "501",
            "502",
            "503",
            "504",
            "505",
            "506",
            "507",
            "508",
            "509",
            "510",
            "511"
          ]
        },
        "statusCodeValue": {
          "type": "integer",
          "format": "int32"
        }
      }
    }
  }
}

As you can see I am sending through a correlationID of -1, which should fail validation, but at the moment is's returning as successful:

com.github.fge.jsonschema.report.ListProcessingReport: success

Answer 1

json-schema-validator seems to work with pure JSON Schema only. OpenAPI Specification uses an extended subset of JSON Schema, so the schema format is different. You need a library that can validate specifically against OpenAPI/Swagger definitions, such as Atlassian's swagger-request-validator.