/// <summary>
/// Examines input json string to ensure that it compiles with the JsonSchema definition. Any errors in the
/// validation of the schema are returned via the errors out parameter.
/// </summary>
/// <param name="schema">Schemas definition used as a reference.</param>
/// <param name="inputJson">Input json example to be validated</param>
/// <param name="issues"></param>
/// <param name="expectedJson"></param>
/// <returns></returns>
public bool ValidateJsonCompilesWithSchema(JsonSchema schema, JsonExample inputJson, IssueLogger issues, JsonExample expectedJson = null, ValidationOptions options = null)
{
if (null == schema)
{
throw new ArgumentNullException("schema");
}
if (null == inputJson)
{
throw new ArgumentNullException("inputJson");
}
string collectionPropertyName = "value";
if (null != inputJson.Annotation && null != inputJson.Annotation.CollectionPropertyName)
{
collectionPropertyName = inputJson.Annotation.CollectionPropertyName;
}
// If we didn't get an options, create a new one with some defaults provided by the annotation
options = options ?? new ValidationOptions();
var annotationTruncated = (inputJson.Annotation ?? new CodeBlockAnnotation()).TruncatedResult;
options.AllowTruncatedResponses = annotationTruncated || options.AllowTruncatedResponses;
options.CollectionPropertyName = collectionPropertyName;
return(schema.ValidateJson(inputJson, issues, this.registeredSchema, options, expectedJson));
}
/// <summary>
/// Checks that the expected response of a method definition is valid with this resource.
/// </summary>
/// <param name="method"></param>
/// <param name="issues"></param>
/// <returns></returns>
public bool ValidateExpectedResponse(MethodDefinition method, IssueLogger issues)
{
HttpParser parser = new HttpParser();
var response = parser.ParseHttpResponse(method.ExpectedResponse);
JsonExample example = new JsonExample(response.Body, method.ExpectedResponseMetadata);
var otherSchemas = new Dictionary <string, JsonSchema>();
return(this.ValidateJson(example, issues, otherSchemas, null));
}
/// <summary>
/// Checks that the expected response of a method definition is valid with this resource.
/// </summary>
/// <param name="method"></param>
/// <param name="issues"></param>
/// <returns></returns>
public bool ValidateExpectedResponse(MethodDefinition method, IssueLogger issues)
{
HttpResponse response;
HttpParser.TryParseHttpResponse(method.ExpectedResponse, out response, issues);
if (response != null)
{
JsonExample example = new JsonExample(response.Body, method.ExpectedResponseMetadata);
var otherSchemas = new Dictionary <string, JsonSchema>();
return(this.ValidateJson(example, issues, otherSchemas, null));
}
return(false);
}
/// <summary>
/// Validate the input json against the defined scehma when the instance was created.
/// </summary>
/// <param name="jsonInput">Input json to validate against schema</param>
/// <param name="issues"></param>
/// <param name="otherSchemas"></param>
/// <param name="options"></param>
/// <param name="expectedJson"></param>
/// <returns>True if validation was successful, otherwise false.</returns>
public bool ValidateJson(JsonExample jsonInput, IssueLogger issues, Dictionary <string, JsonSchema> otherSchemas, ValidationOptions options, JsonExample expectedJson = null)
{
JContainer obj;
try
{
var settings = new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None, NullValueHandling = NullValueHandling.Include, DefaultValueHandling = DefaultValueHandling.Include
};
obj = (JContainer)JsonConvert.DeserializeObject(jsonInput.JsonData, settings);
}
catch (Exception ex)
{
issues.Error(ValidationErrorCode.JsonParserException, $"Failed to parse json string: {jsonInput.JsonData}.", ex);
return(false);
}
var annotation = jsonInput.Annotation ?? new CodeBlockAnnotation();
bool expectErrorObject = (jsonInput.Annotation != null) && jsonInput.Annotation.ExpectError;
// Check for an error response
try
{
dynamic errorObject = obj["error"];
if (null != errorObject && !expectErrorObject)
{
string code = errorObject.code;
string message = errorObject.message;
issues.Error(ValidationErrorCode.JsonErrorObject, $"Error response received. Code: {code}, Message: {message}");
return(false);
}
else if (expectErrorObject && null == errorObject)
{
issues.Error(ValidationErrorCode.JsonErrorObjectExpected, "Expected an error object response, but didn't receive one.");
return(false);
}
}
catch (Exception ex)
{
if (annotation.ExpectError)
{
issues.Error(ValidationErrorCode.JsonErrorObjectExpected, "Expected an error object, but it doesn't look like we got one.", ex);
}
}
// Check to see if this is a "collection" instance
if (null != annotation && annotation.IsCollection)
{
this.ValidateCollectionObject(obj, annotation, otherSchemas, options.CollectionPropertyName, issues, options);
}
// otherwise verify the object matches this schema
else
{
options = options ?? new ValidationOptions(annotation);
if (null != expectedJson)
{
var expectedJsonSchema = new JsonSchema(expectedJson.JsonData, expectedJson.Annotation);
options.ExpectedJsonSchema = expectedJsonSchema;
options.RequiredPropertyNames = expectedJsonSchema.ExpectedProperties.Keys.ToArray();
}
this.ValidateContainerObject(obj, options, otherSchemas, issues);
}
return(issues.Issues.Count() == 0);
}
