private SchemaVersion mapSchemaVersion(JsonSchemaVersion version)
{
SchemaVersion mappedVersion = SchemaVersion.None;
if (version == JsonSchemaVersion.All)
{
mappedVersion = SchemaVersion.All;
}
if (version == JsonSchemaVersion.Draft04)
{
mappedVersion = SchemaVersion.Draft04;
}
if (version == JsonSchemaVersion.Draft06)
{
mappedVersion = SchemaVersion.Draft06;
}
if (version == JsonSchemaVersion.Draft07)
{
mappedVersion = SchemaVersion.Draft07;
}
if (version == JsonSchemaVersion.Draft2019_09)
{
mappedVersion = SchemaVersion.Draft08;
}
return(mappedVersion);
}
/// <summary>
/// Creates a new <see cref="Format"/> instance using a validation function.
/// </summary>
/// <param name="key">The name of the format. This is the value that will appear in the schema.</param>
/// <param name="supportedBy">The schema drafts supported by this keyword.</param>
/// <param name="validate">The function by which the value is validated.</param>
public Format(string key, JsonSchemaVersion supportedBy, Func <JsonValue, bool> validate)
{
ValidationFunction = validate;
Key = key;
SupportedBy = supportedBy;
_lookup[key] = this;
}
/// <summary>
/// Creates a new <see cref="StringFormat"/> instance using a validation function.
/// </summary>
/// <param name="key">The name of the format. This is the value that will appear in the schema.</param>
/// <param name="supportedBy">The schema drafts supported by this keyword.</param>
/// <param name="validate">The function by which the string is validated.</param>
public StringFormat(string key, JsonSchemaVersion supportedBy, Func <string, bool> validate)
{
ValidationFunction = validate;
Key = key;
SupportedBy = supportedBy;
_lookup.Add(key, this);
}
/// <summary>
/// Creates a new <see cref="Format"/> instance using a regular expression.
/// </summary>
/// <param name="key">The name of the format. This is the value that will appear in the schema.</param>
/// <param name="supportedBy">The schema drafts supported by this keyword.</param>
/// <param name="regex">The validation regular expression.</param>
/// <param name="isCaseSensitive">(optional) Whether the regular expression is to be processed as case-sensitive; the default is `false`.</param>
public Format(string key, JsonSchemaVersion supportedBy, [RegexPattern] string regex, bool isCaseSensitive = false)
{
Key = key;
SupportedBy = supportedBy;
if (regex != null)
{
ValidationRegex = new Regex(regex, isCaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase);
}
_lookup[key] = this;
}
/// <summary>
/// Creates a new <see cref="StringFormat"/> instance using a regular expression.
/// </summary>
/// <param name="key">The name of the format. This is the value that will appear in the schema.</param>
/// <param name="supportedBy">The schema drafts supported by this keyword.</param>
/// <param name="regex">The validation regular expression.</param>
/// <param name="isCaseSensitive">Whether the regular expression is to be processed as case-sensitive.</param>
public StringFormat(string key, JsonSchemaVersion supportedBy, string regex, bool isCaseSensitive = false)
{
Key = key;
SupportedBy = supportedBy;
if (regex != null)
{
ValidationRegex = new Regex(regex, isCaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase);
}
_lookup.Add(key, this);
}
private void _ResolveLocalReference(Uri baseUri, JsonSchemaVersion supportedVersions)
{
if (!_resolvedFragment.Any())
{
Resolved = _resolvedRoot;
return;
}
Log.Schema(() => $"Resolving local reference {_resolvedFragment}");
Resolved = _resolvedRoot !.ResolveSubschema(_resolvedFragment !, baseUri, supportedVersions);
}
public static string GetSchemaUri(this JsonSchemaVersion version)
{
return(version switch
{
JsonSchemaVersion.Draft201909 => Draft201909,
JsonSchemaVersion.Draft07 => Draft07,
JsonSchemaVersion.Draft06 => Draft06,
JsonSchemaVersion.Draft04 => Draft04,
JsonSchemaVersion.Draft03 => Draft03,
_ => throw new NotSupportedException(),
});
/// <summary>
/// Resolves any subschemas during resolution of a `$ref` during validation.
/// </summary>
/// <param name="pointer">A <see cref="JsonPointer"/> to the target schema.</param>
/// <param name="baseUri">The current base URI.</param>
/// <param name="supportedVersions">Indicates the root schema's supported versions.</param>
/// <returns>The referenced schema, if it exists; otherwise null.</returns>
public JsonSchema?ResolveSubschema(JsonPointer pointer, Uri baseUri, JsonSchemaVersion supportedVersions)
{
var first = pointer.FirstOrDefault();
if (first == null)
{
return(null);
}
var keyword = this.FirstOrDefault(k => k.PropertyName == first);
return(keyword?.ResolveSubschema(new JsonPointer(pointer.Skip(1)), baseUri, supportedVersions));
}
/// <summary>
/// Resolves any subschemas during resolution of a `$ref` during validation.
/// </summary>
/// <param name="pointer">A <see cref="JsonPointer"/> to the target schema.</param>
/// <param name="baseUri">The current base URI.</param>
/// <param name="supportedVersions">Indicates the root schema's supported versions.</param>
/// <returns>The referenced schema, if it exists; otherwise null.</returns>
public JsonSchema?ResolveSubschema(JsonPointer pointer, Uri baseUri, JsonSchemaVersion supportedVersions)
{
var first = pointer.FirstOrDefault();
if (first == null)
{
return(null);
}
if (!int.TryParse(first, out var index) || index < 0 || index >= Count)
{
return(null);
}
return(this[index].ResolveSubschema(new JsonPointer(pointer.Skip(1)), baseUri, supportedVersions));
}
/// <summary>
/// Resolves any subschemas during resolution of a `$ref` during validation.
/// </summary>
/// <param name="pointer">A <see cref="JsonPointer"/> to the target schema.</param>
/// <param name="baseUri">The current base URI.</param>
/// <param name="supportedVersions">Indicates the root schema's supported versions.</param>
/// <returns>The referenced schema, if it exists; otherwise null.</returns>
public JsonSchema?ResolveSubschema(JsonPointer pointer, Uri baseUri, JsonSchemaVersion supportedVersions)
{
var first = pointer.FirstOrDefault();
if (first == null)
{
return(null);
}
if (!TryGetValue(first, out var schema))
{
return(null);
}
return(schema.ResolveSubschema(new JsonPointer(pointer.Skip(1)), baseUri, supportedVersions));
}
private static IEnumerable <TestCaseData> _LoadSchemaJson(string draft, JsonSchemaVersion version)
{
var testsPath = System.IO.Path.Combine(TestContext.CurrentContext.WorkDirectory, RootTestsFolder, $"{draft}\\").AdjustForOS();
if (!Directory.Exists(testsPath))
{
return(Enumerable.Empty <TestCaseData>());
}
var fileNames = Directory.GetFiles(testsPath, "*.json", SearchOption.AllDirectories);
var allTests = new List <TestCaseData>();
foreach (var fileName in fileNames)
{
var shortFileName = System.IO.Path.GetFileNameWithoutExtension(fileName);
var contents = File.ReadAllText(fileName);
var json = JsonValue.Parse(contents);
foreach (var testSet in json.Array)
{
var schemaJson = testSet.Object["schema"];
foreach (var testJson in testSet.Object["tests"].Array)
{
var isOptional = fileName.Contains("optional");
var testName = $"{shortFileName}.{testSet.Object["description"].String}.{testJson.Object["description"].String}.{draft}".Replace(' ', '_');
if (isOptional)
{
testName = $"optional.{testName}";
}
allTests.Add(new TestCaseData(fileName, testSet.Object["description"].String, testJson, schemaJson, version, isOptional, testName)
{
TestName = testName
});
}
}
}
return(allTests);
}
/// <summary>
/// Resolves any subschemas during resolution of a `$ref` during validation.
/// </summary>
/// <param name="pointer">A <see cref="JsonPointer"/> to the target schema.</param>
/// <param name="baseUri">The current base URI.</param>
/// <param name="supportedVersions">Indicates the root schema's supported versions.</param>
/// <returns>The referenced schema, if it exists; otherwise null.</returns>
/// <implementationNotes>
/// If the keyword contains no subschemas, simply return null.
/// If the keyword contains a subschema, simply pass the call to <see cref="JsonSchema.ResolveSubschema"/>.
/// </implementationNotes>
public JsonSchema?ResolveSubschema(JsonPointer pointer, Uri baseUri, JsonSchemaVersion supportedVersions)
{
return(null);
}
/// <summary>
/// Resolves any subschemas during resolution of a `$ref` during validation.
/// </summary>
/// <param name="pointer">A <see cref="JsonPointer"/> to the target schema.</param>
/// <param name="baseUri">The current base URI.</param>
/// <param name="supportedVersions">Indicates the root schema's supported versions.</param>
/// <returns>The referenced schema, if it exists; otherwise null.</returns>
public JsonSchema?ResolveSubschema(JsonPointer pointer, Uri baseUri, JsonSchemaVersion supportedVersions)
{
return(Value.ResolveSubschema(pointer, baseUri, supportedVersions));
}
private static void _Run(string fileName, string setDescription, JsonValue testJson, JsonValue schemaJson, JsonSchemaVersion version, bool isOptional)
{
using (new TestExecutionContext.IsolatedContext())
{
try
{
var test = _serializer.Deserialize <SchemaTest>(testJson);
var schema = _serializer.Deserialize <JsonSchema>(schemaJson);
schema.ProcessingVersion = version;
var results = schema.Validate(test.Data, new JsonSchemaOptions {
OutputFormat = SchemaValidationOutputFormat.Verbose
});
if (test.Valid != results.IsValid)
{
Console.WriteLine(string.Join("\n", _serializer.Serialize(results).GetIndentedString()));
}
Assert.AreEqual(test.Valid, results.IsValid);
if (test.Output != null)
{
Assert.AreEqual(test.Output.Basic, results.Flatten());
Assert.AreEqual(test.Output.Detailed, results.Condense());
Assert.AreEqual(test.Output.Verbose, results);
}
if (!fileName.Contains("draft2019-09"))
{
return;
}
var exportTestsValue = Environment.GetEnvironmentVariable("EXPORT_JSON_TEST_SUITE_RESULTS");
if (!bool.TryParse(exportTestsValue, out var exportTests) || !exportTests)
{
return;
}
test.OutputGeneration = results;
List <SchemaTestSet> testSets = null;
SchemaTestSet testSet = null;
var outputFile = System.IO.Path.Combine(OutputFolder, System.IO.Path.GetFileName(fileName));
if (File.Exists(outputFile))
{
var fileContents = File.ReadAllText(outputFile);
var fileJson = JsonValue.Parse(fileContents);
testSets = _serializer.Deserialize <List <SchemaTestSet> >(fileJson);
testSet = testSets.FirstOrDefault(s => s.Description == setDescription);
}
if (testSets == null)
{
testSets = new List <SchemaTestSet>();
}
if (testSet == null)
{
testSet = new SchemaTestSet
{
Description = setDescription,
Schema = schema,
Tests = new List <SchemaTest>()
};
testSets.Add(testSet);
}
testSet.Tests.Add(test);
var outputJson = _serializer.Serialize(testSets);
File.WriteAllText(outputFile, outputJson.GetIndentedString());
}
catch (Exception e)
{
if (e is SchemaLoadException sle)
{
Console.WriteLine(sle.MetaValidation.ToJson(new JsonSerializer()).GetIndentedString());
}
Console.WriteLine(fileName);
Console.WriteLine("\nSchema");
Console.WriteLine(schemaJson.GetIndentedString());
Console.WriteLine("\nTest");
Console.WriteLine(testJson.GetIndentedString());
if (isOptional)
{
Assert.Inconclusive("This is an acceptable failure. Test case failed, but was marked as 'optional'.");
}
throw;
}
}
}
public void Run(string fileName, string setDescription, JsonValue testJson, JsonValue schemaJson, JsonSchemaVersion version, bool isOptional, string testName)
{
Console.WriteLine(testName);
Console.WriteLine();
//if (testName == "ref.escaped_pointer_ref.slash_invalid.draft2019-09")
// Debugger.Break();
_Run(fileName, setDescription, testJson, schemaJson, version, isOptional);
}
private void WriteSchemaVersion(JsonSchemaVersion version)
{
var uri = version.GetSchemaUri();
writer.WriteString(Keys.Schema, uri);
}
