private static IJsonSchema _GetSchemaSlow(TypeInfo typeInfo)
{
var attribute = typeInfo.GetCustomAttribute <SchemaAttribute>();
if (attribute == null)
{
return(null);
}
Exception exception = null;
IJsonSchema schema = null;
try
{
schema = _GetPropertySchema(typeInfo, attribute) ?? _GetFileSchema(attribute);
}
catch (FileNotFoundException e)
{
exception = e;
}
catch (UriFormatException e)
{
exception = e;
}
if (schema == null)
{
throw new JsonSerializationException($"The value '{attribute.Source}' could not be translated into a valid schema. " +
$"This value should represent either a public static property on the {typeInfo.Name} type " +
$"or a file with this name should exist at the execution path.", exception);
}
return(schema);
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var typed = (JsonSchema04)schema;
if (typed.ExclusiveMinimum ?? false)
{
if (json.Number <= typed.Minimum)
{
var message = SchemaErrorMessages.ExclusiveMinimum.ResolveTokens(new Dictionary <string, object>
{
["expected"] = typed.Minimum,
["value"] = json
});
return(new SchemaValidationResults(string.Empty, message));
}
}
else
{
if (json.Number < typed.Minimum)
{
var message = SchemaErrorMessages.Minimum.ResolveTokens(new Dictionary <string, object>
{
["expected"] = typed.Minimum,
["value"] = json
});
return(new SchemaValidationResults(string.Empty, message));
}
}
return(new SchemaValidationResults());
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var typed = (QuasiSchema7)schema;
if (typed.If == null)
{
return(new SchemaValidationResults());
}
var ifResults = _ValidateSubSchema(typed.If, json, root);
if (ifResults.Valid)
{
var thenResults = _ValidateSubSchema(typed.Then, json, root);
if (thenResults.Valid)
{
return(new SchemaValidationResults());
}
return(new SchemaValidationResults(schema, string.Empty, "Validation of `if` succeeded, but validation of `then` failed.",
validationKeyword: "then",
innerErrors: thenResults.Errors));
}
var elseResults = _ValidateSubSchema(typed.Else, json, root);
if (elseResults.Valid)
{
return(new SchemaValidationResults());
}
return(new SchemaValidationResults(schema, string.Empty, "Validation of `if` failed, but validation of `else` also failed.",
validationKeyword: "else",
innerErrors: elseResults.Errors));
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var typed = (JsonSchema07)schema;
if (typed.If == null)
{
return(new SchemaValidationResults());
}
var ifResults = _ValidateSubSchema(typed.If, json, root);
if (ifResults.Valid)
{
var thenResults = _ValidateSubSchema(typed.Then, json, root);
if (thenResults.Valid)
{
return(new SchemaValidationResults());
}
return(new SchemaValidationResults("then", "Validation of `if` succeeded, but validation of `then` failed."));
}
var elseResults = _ValidateSubSchema(typed.Else, json, root);
if (elseResults.Valid)
{
return(new SchemaValidationResults());
}
return(new SchemaValidationResults("else", "Validation of `if` failed, but validation of `else` also failed."));
}
public void Online(IJsonSchema schema)
{
try
{
// TODO: Catch web exceptions and assert inconclusive.
var localSchemaJson = schema.ToJson(null);
var onlineSchemaText = JsonSchemaOptions.Download(schema.Id);
var onlineSchemaJson = JsonValue.Parse(onlineSchemaText);
var onlineSchema = JsonSchemaFactory.FromJson(onlineSchemaJson);
var localValidation = schema.Validate(onlineSchemaJson);
var onlineValidation = onlineSchema.Validate(localSchemaJson);
Assert.AreEqual(onlineSchema, schema);
onlineValidation.AssertValid();
localValidation.AssertValid();
Assert.AreEqual(onlineSchemaJson, localSchemaJson);
}
catch (WebException)
{
Assert.Inconclusive();
}
catch (AggregateException e)
{
if (e.InnerExceptions.OfType <WebException>().Any())
{
Assert.Inconclusive();
}
throw;
}
}
/// <summary>
/// Indicates whether the current object is equal to another object of the same type.
/// </summary>
/// <returns>
/// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
/// </returns>
/// <param name="other">An object to compare with this object.</param>
public bool Equals(IJsonSchema other)
{
var schema = other as JsonSchemaReference;
return(schema != null && schema.Reference == Reference &&
Equals(Base, schema.Base));
}
public void Hardcoded(IJsonSchema schema)
{
var json = schema.ToJson(null);
var validation = schema.Validate(json);
validation.AssertValid();
}
public void ValidateReturnsErrorOnNonInteger(IJsonSchema schema)
{
var json = (JsonValue)1.2;
var results = schema.Validate(json);
results.AssertInvalid();
}
public void ValidateReturnsValidOnMultipleOf_Zero(IJsonSchema schema)
{
var json = (JsonValue)0;
var results = schema.Validate(json);
results.AssertValid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var maxProperties = GetMaxProperties((T)schema);
return(json.Object.Count > maxProperties
? new SchemaValidationResults(string.Empty, $"Expected: <= {maxProperties} properties; Actual: {json.Object.Count} properties.")
: new SchemaValidationResults());
}
public void ValidateReturnsValidOnLessThanMaximum(IJsonSchema schema)
{
var json = (JsonValue)3;
var results = schema.Validate(json);
results.AssertValid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var errors = GetEnum((T)schema).Select(d => d.Validate(json)).ToList();
return(errors.Any(r => r.Valid)
? new SchemaValidationResults()
: new SchemaValidationResults(schema, string.Empty, string.Empty, validationKeyword: "enum"));
}
public void ValidateReturnsValidOnBoolean(IJsonSchema schema)
{
var json = (JsonValue)false;
var results = schema.Validate(json);
results.AssertValid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var minProperties = GetMinProperties((T)schema);
return(json.Object.Count < minProperties
? new SchemaValidationResults(string.Empty, $"Expected: >= {minProperties} items; Actual: {json.Object.Count} items.")
: new SchemaValidationResults());
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var results = GetNot((T)schema).Validate(json, root);
return(results.Valid
? new SchemaValidationResults(string.Empty, "Expected schema to be invalid, but was valid.")
: new SchemaValidationResults());
}
public void ValidateReturnsValidOnValueInRange(IJsonSchema schema)
{
var json = (JsonValue)"test1";
var results = schema.Validate(json);
results.AssertValid();
}
public void ValidateReturnsErrorOnValueOutOfRange(IJsonSchema schema)
{
var json = (JsonValue)"string";
var results = schema.Validate(json);
results.AssertInvalid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var pattern = GetPattern((T)schema);
return(Regex.IsMatch(json.String, pattern)
? new SchemaValidationResults()
: new SchemaValidationResults(string.Empty, $"Value [{json.String}] does not match required Regex pattern [{pattern}]."));
}
public void ValidateReturnsErrorOnLessThanMinimum(IJsonSchema schema)
{
var json = (JsonValue)4;
var results = schema.Validate(json);
results.AssertInvalid();
}
public void ValidateReturnsValidOnMoreThanMinimum(IJsonSchema schema)
{
var json = (JsonValue)10;
var results = schema.Validate(json);
results.AssertValid();
}
public void ValidateReturnsValidOnNull(IJsonSchema schema)
{
var json = JsonValue.Null;
var results = schema.Validate(json);
results.AssertValid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var multipleOf = GetMultipleOf((T)schema);
return((decimal)json.Number % (decimal?)multipleOf != 0
? new SchemaValidationResults(string.Empty, $"Expected: {json.Number}%{multipleOf}=0; Actual: {json.Number % multipleOf}.")
: new SchemaValidationResults());
}
public void ValidateReturnsErrorOnMoreThanMaximum(IJsonSchema schema)
{
var json = (JsonValue)10;
var results = schema.Validate(json);
results.AssertInvalid();
}
public virtual bool Applies(IJsonSchema schema, JsonValue json)
{
return(schema is T typed &&
(GetProperties(typed) != null ||
GetAdditionalProperties(typed) != null ||
GetPatternProperties(typed) != null) &&
json.Type == JsonValueType.Object);
}
public void ValidateReturnsErrorOnString(IJsonSchema schema)
{
JsonValue json = "string";
var results = schema.Validate(json);
results.AssertInvalid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var errors = GetAnyOf((T)schema).Select(s => s.Validate(json, root)).ToList();
return(errors.Any(r => r.Valid)
? new SchemaValidationResults()
: new SchemaValidationResults(errors));
}
public void ValidateReturnsValidOnMultipleOf_Negative(IJsonSchema schema)
{
var json = (JsonValue)(-15);
var results = schema.Validate(json);
results.AssertValid();
}
public void ValidateReturnsErrorOnNoneValid(IJsonSchema schema)
{
var json = new JsonObject();
var results = schema.Validate(json);
results.AssertInvalid();
}
public SchemaValidationResults Validate(IJsonSchema schema, JsonValue json, JsonValue root)
{
var errors = GetDependencies((T)schema).SelectMany(d => d.Validate(json, root).Errors).ToArray();
return(errors.Any()
? new SchemaValidationResults(schema, string.Empty, string.Empty, validationKeyword: "dependencies")
: new SchemaValidationResults());
}
public void ValidateReturnsValidOnSingleValid(IJsonSchema schema)
{
var json = (JsonValue)25;
var results = schema.Validate(json);
results.AssertValid();
}
private static string JsonSchemaToDotNetType(string parentName, string nodeName, IJsonSchema schema)
{
if (IsJsonSchemaEnum(schema))
{
return parentName + nodeName;
}
if (schema.Type.Equals("array", StringComparison.OrdinalIgnoreCase))
{
var schemaAsProperty = schema as Property;
if (schemaAsProperty != null)
{
return JsonSchemaToDotNetType(schemaAsProperty.ArrayItemType, null) + "[]";
}
return "object[]";
}
return JsonSchemaToDotNetType(schema.Type, schema.Format);
}
private static bool IsJsonSchemaEnum(IJsonSchema schema) => schema.Type.ToUpperInvariant().Equals("STRING") && schema.Enum != null && schema.Enum.Length > 0;
private static void ParseJsonSchema(IJsonSchema item, JToken node)
{
item.Format = node["format"]?.Value<string>();
item.CollectionFormat = node["collectionFormat"]?.Value<string>();
item.Default = node["default"]?.Value<string>();
item.Maximum = node["maximum"]?.Value<double>();
item.ExclusiveMaximum = node["exclusiveMaximum"]?.Value<bool>() ?? false;
item.Minimum = node["minimum"]?.Value<double>();
item.ExclusiveMinimum = node["exclusiveMinimum"]?.Value<bool>() ?? false;
item.MaxLength = node["maxLength"]?.Value<int>();
item.MinLength = node["minLength"]?.Value<int>();
item.Pattern = node["pattern"]?.Value<string>();
item.MaxItems = node["maxItems"]?.Value<int>();
item.MinItems = node["minItems"]?.Value<int>();
item.UniqueItems = node["uniqueItems"]?.Value<bool>() ?? false;
item.Enum = node["enum"]?.Values<string>().ToArray();
item.MultipleOf = node["multipleOf"]?.Value<double>();
}