public void ReadSpecTest(SchemaSpecTest schemaSpecTest)
{
Console.WriteLine("Running reader JSON Schema {0} test {1}: {2}", schemaSpecTest.Version, schemaSpecTest.TestNumber, schemaSpecTest);
IList<string> errorMessages = new List<string>();
JSchemaPreloadedResolver resolver = GetResolver();
JSchema s = JSchema.Load(schemaSpecTest.Schema.CreateReader(), resolver);
JsonReader jsonReader = schemaSpecTest.Data.CreateReader();
using (JSchemaValidatingReader reader = new JSchemaValidatingReader(jsonReader))
{
reader.Schema = s;
reader.ValidationEventHandler += (sender, args) => errorMessages.Add(args.Message);
while (reader.Read())
{
}
}
bool isValid = (errorMessages.Count == 0);
Assert.AreEqual(schemaSpecTest.IsValid, isValid, schemaSpecTest.TestCaseDescription + " - " + schemaSpecTest.TestDescription + " - errors: " + StringHelpers.Join(", ", errorMessages));
}
public MapInfo GetByName(string name)
{
var path = Path.Combine(_directory, name);
Map map;
string comments;
using (var file = File.OpenRead(path + ".json"))
{
var reader = new JSchemaValidatingReader(new JsonTextReader(new StreamReader(file)))
{
Schema = _schema
};
map = _json.Deserialize<Map>(reader);
}
try
{
using (var file = File.OpenRead(path + ".txt"))
{
comments = new StreamReader(file).ReadToEnd().TrimEnd();
}
}
catch (FileNotFoundException)
{
comments = null;
}
return new MapInfo(name, name + ".pie", comments, map);
}
public void ValidateStream()
{
#region ValidateStream
string schemaJson = @"{
'description': 'A person',
'type': 'object',
'properties': {
'name': {'type': 'string'},
'hobbies': {
'type': 'array',
'items': {'type': 'string'}
}
}
}";
JSchema schema = JSchema.Parse(schemaJson);
using (StreamReader s = File.OpenText(@"c:\bigdata.json"))
using (JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(s)))
{
// assign schema and setup event handler
reader.Schema = schema;
reader.ValidationEventHandler += (sender, args) =>
{
Console.WriteLine(args.Message);
};
// bigdata.json will be validated without loading the entire document into memory
while (reader.Read())
{
}
}
#endregion
}
public JsonBrowserResponse AdheresToSchema([NotNull] JSchema schema)
{
var validatingReader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(ResponseBody)));
validatingReader.Schema = schema;
var validationErrors = new List<SchemaValidationEventArgs>();
validatingReader.ValidationEventHandler += (sender, args) => validationErrors.Add(args);
var serializer = new JsonSerializer();
try
{
serializer.Deserialize(validatingReader);
}
catch (JsonReaderException)
{
Assert.True(false, "The response body did not contain JSON.");
}
if (!validationErrors.Any())
{
return this;
}
var messages = validationErrors.Select(e => e.Message).ToList();
var message = string.Join(Environment.NewLine, messages);
Assert.True(
false,
$"Encountered validation errors against schema: {message}.{Environment.NewLine}Response body: {ResponseBody}");
return this;
}
public static void LoadConfiguration(string configFile)
{
JsonTextReader reader = new JsonTextReader(File.OpenText(configFile));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
JSchemaGenerator generator = new JSchemaGenerator();
validatingReader.Schema = generator.Generate(typeof(ConfigurationJson));
JsonSerializer serializer = new JsonSerializer();
configJson = serializer.Deserialize<ConfigurationJson>(validatingReader);
ConfigFileName = configFile;
}
private JSchemaValidatingReader CreateReader(string json, JSchema schema, out IList<SchemaValidationEventArgs> errors)
{
JsonReader reader = new JsonTextReader(new StringReader(json));
List<SchemaValidationEventArgs> localErrors = new List<SchemaValidationEventArgs>();
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.ValidationEventHandler += (sender, args) => { localErrors.Add(args); };
validatingReader.Schema = schema;
errors = localErrors;
return validatingReader;
}
public void Sample()
{
JSchema schema = JSchema.Parse(@"{
'type': 'array',
'items': {'type':'string'}
}");
JsonTextReader reader = new JsonTextReader(new StringReader(@"[
'Developer',
'Administrator'
]"));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = schema;
validatingReader.ValidationEventHandler += (sender, args) => { throw new Exception(args.Message); };
JsonSerializer serializer = new JsonSerializer();
List<string> roles = serializer.Deserialize<List<string>>(validatingReader);
}
/// <summary>
/// Validates the specified <see cref="JToken"/>.
/// </summary>
/// <param name="source">The source <see cref="JToken"/> to test.</param>
/// <param name="schema">The schema to test with.</param>
/// <param name="validationEventHandler">The validation event handler.</param>
public static void Validate(this JToken source, JSchema schema, SchemaValidationEventHandler?validationEventHandler)
{
ValidationUtils.ArgumentNotNull(source, nameof(source));
ValidationUtils.ArgumentNotNull(schema, nameof(schema));
using (JSchemaValidatingReader reader = new JSchemaValidatingReader(source.CreateReader()))
{
reader.Schema = schema;
if (validationEventHandler != null)
{
reader.ValidationEventHandler += validationEventHandler;
}
while (reader.Read())
{
}
}
}
public void FloatIsNotInEnum()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""number"",
""enum"":[1.1,2.2]
},
""maxItems"":3
}";
string json = "[1.1,2.2,3.0]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(@"Value 3.0 is not defined in enum. Path '[2]', line 1, position 12.", validationEventArgs.Message);
Assert.AreEqual(3.0d, validationEventArgs.ValidationError.Value);
Assert.AreEqual("[2]", validationEventArgs.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsNotNull(validationEventArgs);
}
public void IntegerLessThanMinimumValue()
{
string schemaJson = @"{
""type"":""integer"",
""minimum"":5
}";
string json = "1";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual("Integer 1 is less than minimum value of 5. Path '', line 1, position 1.", validationEventArgs.Message);
Assert.AreEqual(1, validationEventArgs.ValidationError.Value);
Assert.AreEqual("#", validationEventArgs.ValidationError.SchemaId.ToString());
Assert.AreEqual(ErrorType.Minimum, validationEventArgs.ValidationError.ErrorType);
Assert.IsNotNull(validationEventArgs);
}
public void FloatLessThanMinimumValue()
{
string schemaJson = @"{
""type"":""number"",
""minimum"":5
}";
string json = "1.1";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual("Float 1.1 is less than minimum value of 5. Path '', line 1, position 3.", validationEventArgs.Message);
Assert.AreEqual(1.1d, validationEventArgs.ValidationError.Value);
Assert.IsNotNull(validationEventArgs);
}
public void ThrowExceptionWhenNoValidationEventHandler()
{
ExceptionAssert.Throws<JSchemaException>(() =>
{
string schemaJson = @"{
""type"":""integer"",
""maximum"":5
}";
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader("10")));
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
}, "Integer 10 exceeds maximum value of 5. Path '', line 1, position 2.");
}
public void ReadAsInt32InArray()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""integer""
},
""maxItems"":1
}";
string json = "[1,2]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
reader.Read();
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
reader.ReadAsInt32();
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
reader.ReadAsInt32();
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
reader.ReadAsInt32();
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.AreEqual("Array item count 2 exceeds maximum count of 1. Path '', line 1, position 5.", validationEventArgs.Message);
Assert.AreEqual(2, validationEventArgs.ValidationError.Value);
Assert.AreEqual("", validationEventArgs.Path);
}
public void ReadAsInt32FromSerializer()
{
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader("[1,2,3]")));
reader.Schema = new JSchemaGenerator().Generate(typeof(int[]));
int[] values = new JsonSerializer().Deserialize<int[]>(reader);
Assert.AreEqual(3, values.Length);
Assert.AreEqual(1, values[0]);
Assert.AreEqual(2, values[1]);
Assert.AreEqual(3, values[2]);
}
public void IntegerGreaterThanMaximumValue_BigInteger()
{
string schemaJson = @"{
""type"":""integer"",
""maximum"":5
}";
string json = "99999999999999999999999999999999999999999999999999999999999999999999";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual("Integer 99999999999999999999999999999999999999999999999999999999999999999999 exceeds maximum value of 5. Path '', line 1, position 68.", validationEventArgs.Message);
Assert.AreEqual(BigInteger.Parse("99999999999999999999999999999999999999999999999999999999999999999999"), validationEventArgs.ValidationError.Value);
Assert.AreEqual("", validationEventArgs.Path);
Assert.IsNotNull(validationEventArgs);
}
public void BigIntegerDivisibleBy_Fraction()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""number"",
""divisibleBy"":1.1
}
}";
string json = "[999999999999999999999999999999999999999999999999999999999]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual(@"Integer 999999999999999999999999999999999999999999999999999999999 is not a multiple of 1.1. Path '[0]', line 1, position 58.", validationEventArgs.Message);
Assert.AreEqual(BigInteger.Parse("999999999999999999999999999999999999999999999999999999999"), validationEventArgs.ValidationError.Value);
Assert.AreEqual("[0]", validationEventArgs.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
}
public ReaderValidator(JSchemaValidatingReader reader)
: base(reader)
{
_reader = reader;
}
public void StringLessThanMinimumLength()
{
string schemaJson = @"{
""type"":""string"",
""minLength"":5,
""maxLength"":50,
}";
string json = "'pie'";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("String 'pie' is less than minimum length of 5. Path '', line 1, position 5.", validationEventArgs.Message);
Assert.AreEqual("pie", validationEventArgs.ValidationError.Value);
Assert.IsNotNull(validationEventArgs);
}
public void FloatDivisibleBy()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""number"",
""divisibleBy"":0.1
}
}";
string json = "[1.1,2.2,4.001]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(@"Float 4.001 is not a multiple of 0.1. Path '[2]', line 1, position 14.", validationEventArgs.Message);
Assert.AreEqual(4.001d, validationEventArgs.ValidationError.Value);
Assert.AreEqual("[2]", validationEventArgs.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsNotNull(validationEventArgs);
}
public void ValidateUnrestrictedArray()
{
string schemaJson = @"{
""type"":""array""
}";
string json = "['pie','cake',['nested1','nested2'],{'nestedproperty1':1.1,'nestedproperty2':[null]}]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("pie", reader.Value.ToString());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("cake", reader.Value.ToString());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("nested1", reader.Value.ToString());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("nested2", reader.Value.ToString());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.AreEqual("nestedproperty1", reader.Value.ToString());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(1.1, reader.Value);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.AreEqual("nestedproperty2", reader.Value.ToString());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Null, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsNull(validationEventArgs);
}
public void ValidateTypes()
{
string schemaJson = @"{
""description"":""A person"",
""type"":""object"",
""properties"":
{
""name"":{""type"":""string""},
""hobbies"":
{
""type"":""array"",
""items"": {""type"":""string""}
}
}
}";
string json = @"{'name':""James"",'hobbies':[""pie"",'cake']}";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
JSchema schema = JSchema.Parse(schemaJson);
reader.Schema = schema;
Assert.AreEqual(schema, reader.Schema);
Assert.AreEqual(0, reader.Depth);
Assert.AreEqual("", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.AreEqual("", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.AreEqual("name", reader.Value.ToString());
Assert.AreEqual("name", reader.Path);
Assert.AreEqual(1, reader.Depth);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("James", reader.Value.ToString());
Assert.AreEqual(typeof(string), reader.ValueType);
Assert.AreEqual('"', reader.QuoteChar);
Assert.AreEqual("name", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.AreEqual("hobbies", reader.Value.ToString());
Assert.AreEqual('\'', reader.QuoteChar);
Assert.AreEqual("hobbies", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.AreEqual("hobbies", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("pie", reader.Value.ToString());
Assert.AreEqual('"', reader.QuoteChar);
Assert.AreEqual("hobbies[0]", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("cake", reader.Value.ToString());
Assert.AreEqual("hobbies[1]", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.AreEqual("hobbies", reader.Path);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.AreEqual("", reader.Path);
Assert.IsFalse(reader.Read());
Assert.IsNull(validationEventArgs);
}
public void SchemaPath()
{
string schema = @"{
""$schema"" : ""http://json-schema.org/draft-04/schema#"",
""title"" : ""listing/update"",
""type"" : ""object"",
""id"" : ""http://test.com/update.json"",
""required"" : [""derp""]
}";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader("{}")));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schema);
reader.Read();
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
reader.Read();
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.AreNotEqual(null, validationEventArgs);
Console.WriteLine(validationEventArgs.ValidationError.SchemaId);
Console.WriteLine(JsonConvert.SerializeObject(validationEventArgs.ValidationError, Formatting.Indented));
}
public void ReadAsInt32InArrayIncomplete()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""integer""
},
""maxItems"":1
}";
string json = "[1,2";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
reader.Read();
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
reader.ReadAsInt32();
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
reader.ReadAsInt32();
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
reader.ReadAsInt32();
Assert.AreEqual(JsonToken.None, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
}
public void CheckInnerReader()
{
string json = "{'name':'James','hobbies':['pie','cake']}";
JsonReader reader = new JsonTextReader(new StringReader(json));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
Assert.AreEqual(reader, validatingReader.Reader);
}
public void BigIntegerDivisibleBy_Success()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""number"",
""divisibleBy"":2
}
}";
string json = "[999999999999999999999999999999999999999999999999999999998]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.IsNull(validationEventArgs);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
}
public void JSchemaValidatingReader()
{
string schemaJson = "{}";
#region JSchemaValidatingReader
string json = @"{
'name': 'James',
'hobbies': ['.NET', 'Blogging', 'Reading', 'Xbox', 'LOLCATS']
}";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = JSchema.Parse(schemaJson);
IList<string> messages = new List<string>();
validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message);
JsonSerializer serializer = new JsonSerializer();
Person p = serializer.Deserialize<Person>(validatingReader);
#endregion
Assert.AreEqual(0, messages.Count);
}
public void ReadDateTimes_DateParseHandling()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""string"",
""minLength"":21
}
}";
string json = @"[
""2000-12-02T05:06:02+00:00"",
""2000-12-02T05:06:02Z"",
1 // hi
]";
SchemaValidationEventArgs a = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json))
{
DateParseHandling = DateParseHandling.DateTimeOffset
});
reader.ValidationEventHandler += (sender, args) => { a = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsNull(a);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Date, reader.TokenType);
Assert.IsNull(a);
reader.ReadAsString();
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.IsNotNull(a);
StringAssert.AreEqual(@"String '2000-12-02T05:06:02Z' is less than minimum length of 21. Path '[1]', line 3, position 25.", a.Message);
Assert.AreEqual("2000-12-02T05:06:02Z", a.ValidationError.Value);
a = null;
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.IsNotNull(a);
StringAssert.AreEqual("Invalid type. Expected String but got Integer. Path '[2]', line 4, position 4.", a.Message);
Assert.AreEqual(1, a.ValidationError.Value);
a = null;
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
Assert.IsNull(a);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsNull(a);
}
public void StringDoesNotMatchPattern()
{
string schemaJson = @"{
""type"":""string"",
""pattern"":""foo""
}";
string json = "'The quick brown fox jumps over the lazy dog.'";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("String 'The quick brown fox jumps over the lazy dog.' does not match regex pattern 'foo'. Path '', line 1, position 46.", validationEventArgs.Message);
Assert.AreEqual("The quick brown fox jumps over the lazy dog.", validationEventArgs.ValidationError.Value);
Assert.AreEqual("", validationEventArgs.Path);
Assert.IsNotNull(validationEventArgs);
}
public void StringGreaterThanMaximumLength()
{
string schemaJson = @"{
""type"":""string"",
""minLength"":5,
""maxLength"":10
}";
string json = "'The quick brown fox jumps over the lazy dog.'";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("String 'The quick brown fox jumps over the lazy dog.' exceeds maximum length of 10. Path '', line 1, position 46.", validationEventArgs.Message);
Assert.AreEqual("The quick brown fox jumps over the lazy dog.", validationEventArgs.ValidationError.Value);
Assert.AreEqual(null, validationEventArgs.ValidationError.SchemaBaseUri);
Assert.IsNotNull(validationEventArgs);
}
public void ReadAsDecimalFailure()
{
ExceptionAssert.Throws<JSchemaException>(() =>
{
JSchema s = new JSchemaGenerator().Generate(typeof(decimal));
s.MultipleOf = 1;
JsonReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(@"5.5")))
{
Schema = s
};
reader.ReadAsDecimal();
}, "Float 5.5 is not a multiple of 1. Path '', line 1, position 3.");
}
public ReaderValidator(JSchemaValidatingReader reader)
: base(reader)
{
_reader = reader;
}
public void StringIsNotInEnum()
{
string schemaJson = @"{
""type"":""array"",
""items"":{
""type"":""string"",
""enum"":[""one"",""two""]
},
""maxItems"":3
}";
string json = "['one','two','THREE']";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual(null, validationEventArgs);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual(@"Value ""THREE"" is not defined in enum. Path '[2]', line 1, position 20.", validationEventArgs.Message);
Assert.AreEqual("THREE", validationEventArgs.ValidationError.Value);
Assert.AreEqual("[2]", validationEventArgs.Path);
}