public void RelativePointerRefToObject(string desc, string data, bool expected)
{
// relative pointer ref to object
Console.Error.WriteLine(desc);
string schemaData = "{ 'properties':{ 'bar':{ '$ref':'#/properties/foo' }, 'foo':{ 'type':'integer' } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void ValidationOfEMailAddresses(string desc, string data, bool expected)
{
// validation of e-mail addresses
Console.Error.WriteLine(desc);
string schemaData = "{ 'format':'email' }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RootPointerRef(string desc, string data, bool expected)
{
// root pointer ref
Console.Error.WriteLine(desc);
string schemaData = "{ 'additionalProperties':false, 'properties':{ 'foo':{ '$ref':'#' } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void LocationIndependentIdentifierWithBaseURIChangeInSubschema(string desc, string data, bool expected)
{
// Location-independent identifier with base URI change in subschema
Console.Error.WriteLine(desc);
string schemaData = "{ '$id':'http://localhost:1234/root', 'allOf':[ { '$ref':'http://localhost:1234/nested.json#foo' } ], 'definitions':{ 'A':{ '$id':'nested.json', 'definitions':{ 'B':{ '$id':'#foo', 'type':'integer' } } } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RefsWithQuote(string desc, string data, bool expected)
{
// refs with quote
Console.Error.WriteLine(desc);
string schemaData = @"{ 'definitions':{ 'foo\""bar':{ 'type':'number' } }, 'properties':{ 'foo\""bar':{ '$ref':'#/definitions/foo%22bar' } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void LocationIndependentIdentifier(string desc, string data, bool expected)
{
// Location-independent identifier
Console.Error.WriteLine(desc);
string schemaData = "{ 'allOf':[ { '$ref':'#foo' } ], 'definitions':{ 'A':{ '$id':'#foo', 'type':'integer' } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RefToBooleanSchemaFalse(string desc, string data, bool expected)
{
// $ref to boolean schema false
Console.Error.WriteLine(desc);
string schemaData = "{ '$ref':'#/definitions/bool', 'definitions':{ 'bool':false } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RecursiveReferencesBetweenSchemas(string desc, string data, bool expected)
{
// Recursive references between schemas
Console.Error.WriteLine(desc);
string schemaData = "{ '$id':'http://localhost:1234/tree', 'definitions':{ 'node':{ '$id':'http://localhost:1234/node', 'description':'node', 'properties':{ 'subtree':{ '$ref':'tree' }, 'value':{ 'type':'number' } }, 'required':[ 'value' ], 'type':'object' } }, 'description':'tree of nodes', 'properties':{ 'meta':{ 'type':'string' }, 'nodes':{ 'items':{ '$ref':'node' }, 'type':'array' } }, 'required':[ 'meta', 'nodes' ], 'type':'object' }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RemoteRefContainingRefsItself(string desc, string data, bool expected)
{
// remote ref, containing refs itself
Console.Error.WriteLine(desc);
string schemaData = "{ '$ref':'http://json-schema.org/draft-06/schema#' }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void PropertyNamedRefThatIsNotAReference(string desc, string data, bool expected)
{
// property named $ref that is not a reference
Console.Error.WriteLine(desc);
string schemaData = "{ 'properties':{ '$ref':{ 'type':'string' } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RefOverridesAnySiblingKeywords(string desc, string data, bool expected)
{
// ref overrides any sibling keywords
Console.Error.WriteLine(desc);
string schemaData = "{ 'definitions':{ 'reffed':{ 'type':'array' } }, 'properties':{ 'foo':{ '$ref':'#/definitions/reffed', 'maxItems':2 } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void NestedRefs(string desc, string data, bool expected)
{
// nested refs
Console.Error.WriteLine(desc);
string schemaData = "{ '$ref':'#/definitions/c', 'definitions':{ 'a':{ 'type':'integer' }, 'b':{ '$ref':'#/definitions/a' }, 'c':{ '$ref':'#/definitions/b' } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void EscapedPointerRef(string desc, string data, bool expected)
{
// escaped pointer ref
Console.Error.WriteLine(desc);
string schemaData = "{ 'percent%field':{ 'type':'integer' }, 'properties':{ 'percent':{ '$ref':'#/percent%25field' }, 'slash':{ '$ref':'#/slash~1field' }, 'tilda':{ '$ref':'#/tilda~0field' } }, 'slash/field':{ 'type':'integer' }, 'tilda~field':{ 'type':'integer' } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void EnumsInProperties(string desc, string data, bool expected)
{
// enums in properties
Console.Error.WriteLine(desc);
string schemaData = "{ 'properties':{ 'bar':{ 'enum':[ 'bar' ] }, 'foo':{ 'enum':[ 'foo' ] } }, 'required':[ 'bar' ], 'type':'object' }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void EnumWith1DoesNotMatchTrue(string desc, string data, bool expected)
{
// enum with 1 does not match true
Console.Error.WriteLine(desc);
string schemaData = "{ 'enum':[ 1 ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void TypeArrayOrObject(string desc, string data, bool expected)
{
// type: array or object
Console.Error.WriteLine(desc);
string schemaData = "{ 'type':[ 'array', 'object' ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void NullTypeMatchesOnlyTheNullObject(string desc, string data, bool expected)
{
// null type matches only the null object
Console.Error.WriteLine(desc);
string schemaData = "{ 'type':'null' }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void MultipleTypesCanBeSpecifiedInAnArray(string desc, string data, bool expected)
{
// multiple types can be specified in an array
Console.Error.WriteLine(desc);
string schemaData = "{ 'type':[ 'integer', 'string' ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void MinPropertiesValidation(string desc, string data, bool expected)
{
// minProperties validation
Console.Error.WriteLine(desc);
string schemaData = "{ 'minProperties':1 }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void BooleanTypeMatchesBooleans(string desc, string data, bool expected)
{
// boolean type matches booleans
Console.Error.WriteLine(desc);
string schemaData = "{ 'type':'boolean' }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RequiredDefaultValidation(string desc, string data, bool expected)
{
// required default validation
Console.Error.WriteLine(desc);
string schemaData = "{ 'properties':{ 'foo':{ } } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void MaxLengthValidation(string desc, string data, bool expected)
{
// maxLength validation
Console.Error.WriteLine(desc);
string schemaData = "{ 'maxLength':2 }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft201909
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void IgnoreThenWithoutIf(string desc, string data, bool expected)
{
// ignore then without if
Console.Error.WriteLine(desc);
string schemaData = "{ 'then':{ 'const':0 } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void SimpleEnumValidation(string desc, string data, bool expected)
{
// simple enum validation
Console.Error.WriteLine(desc);
string schemaData = "{ 'enum':[ 1, 2, 3 ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void ValidateAgainstCorrectBranchThenVsElse(string desc, string data, bool expected)
{
// validate against correct branch, then vs else
Console.Error.WriteLine(desc);
string schemaData = "{ 'else':{ 'multipleOf':2 }, 'if':{ 'exclusiveMaximum':0 }, 'then':{ 'minimum':-10 } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void NonInterferenceAcrossCombinedSchemas(string desc, string data, bool expected)
{
// non-interference across combined schemas
Console.Error.WriteLine(desc);
string schemaData = "{ 'allOf':[ { 'if':{ 'exclusiveMaximum':0 } }, { 'then':{ 'minimum':-10 } }, { 'else':{ 'multipleOf':2 } } ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void IfAndElseWithoutThen(string desc, string data, bool expected)
{
// if and else without then
Console.Error.WriteLine(desc);
string schemaData = "{ 'else':{ 'multipleOf':2 }, 'if':{ 'exclusiveMaximum':0 } }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void HeterogeneousEnumValidation(string desc, string data, bool expected)
{
// heterogeneous enum validation
Console.Error.WriteLine(desc);
string schemaData = "{ 'enum':[ 6, 'foo', [ ], true, { 'foo':12 } ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void TypeAsArrayWithOneItem(string desc, string data, bool expected)
{
// type as array with one item
Console.Error.WriteLine(desc);
string schemaData = "{ 'type':[ 'string' ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft6
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public void RequiredWithEscapedCharacters(string desc, string data, bool expected)
{
// required with escaped characters
Console.Error.WriteLine(desc);
string schemaData = @"{ 'required':[ 'foo\nbar', 'foo\'bar', 'foo\\bar', 'foo\rbar', 'foo\tbar', 'foo\fbar' ] }";
MPJson schemaJson = MPJson.Parse(schemaData);
MPJson json = MPJson.Parse(data);
MPSchema schema = schemaJson;
var validator = new JsonValidator {
Strict = true, Version = SchemaVersion.Draft7
};
bool actual = validator.Validate(schema, json);
Assert.Equal(expected, actual);
}
public JsonValidatorOperation(string keyToValidate, string resultKey, bool negated)
: base(keyToValidate, resultKey) {
Validator = new JsonValidator(keyToValidate, negated);
}
public EmbededValidatorRule(FieldSelector selector, string alias, JsonValidator validator)
{
Selector = selector;
Alias = alias;
this.validator = validator;
}
public JsonValidatorDescription(JsonValidator validator, List<JsonFieldValidatorDescription> descriptions)
{
this.validator = validator;
this.descriptions = descriptions;
}
