public void ParseValidVersionStringWorksAsExpected(string version)
{
string json = @"{""$Version"":""" + version + @"""}";
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlModel csdlModel = CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
Assert.Equal(version == "4.0" ? EdmConstants.EdmVersion4 : EdmConstants.EdmVersion401, csdlModel.CsdlVersion);
}
/// <summary>
/// Load and parse the referenced model but ignored any further referenced model.
/// </summary>
/// <param name="csdlModel">The main CSDL model.</param>
/// <param name="context">The parser context.</param>
/// <returns>A list of CsdlModel (no semantics) of the referenced models.</returns>
private static List <CsdlModel> LoadReferencedCsdl(CsdlModel csdlModel, JsonParserContext context)
{
List <CsdlModel> referencedAstModels = new List <CsdlModel>();
if (context.Settings.JsonSchemaReaderFactory == null)
{
// don't try to load CSDL-JSON doc, but this.edmReferences's namespace-alias need to be used later.
return(referencedAstModels);
}
foreach (var edmReference in csdlModel.CurrentModelReferences)
{
// If nothing included, why does it exist?
if (!edmReference.Includes.Any() && !edmReference.IncludeAnnotations.Any())
{
continue;
}
// Skip the built-in vocabulary annotation model
if (edmReference.Uri != null && (edmReference.Uri.OriginalString.EndsWith("/Org.OData.Core.V1.json", StringComparison.Ordinal) ||
edmReference.Uri.OriginalString.EndsWith("/Org.OData.Capabilities.V1.json", StringComparison.Ordinal) ||
edmReference.Uri.OriginalString.EndsWith("/Org.OData.Authorization.V1.json", StringComparison.Ordinal) ||
edmReference.Uri.OriginalString.EndsWith("/Org.OData.Validation.V1.json", StringComparison.Ordinal) ||
edmReference.Uri.OriginalString.EndsWith("/Org.OData.Community.V1.json", StringComparison.Ordinal) ||
edmReference.Uri.OriginalString.EndsWith("/OData.Community.Keys.V1.json", StringComparison.Ordinal)))
{
continue;
}
Utf8JsonReader referencedJsonReader = context.Settings.JsonSchemaReaderFactory(edmReference.Uri, out bool skip);
if (!skip)
{
string source = edmReference.Uri != null ? edmReference.Uri.OriginalString : null;
CsdlJsonReaderSettings newSettings = context.Settings.Clone();
// set it to null to make sure stop the next level reference parsing.
newSettings.JsonSchemaReaderFactory = null;
JsonParserContext subContext = new JsonParserContext(newSettings, source);
CsdlModel subCsdlModel = CsdlJsonParser.ParseCsdlDocument(ref referencedJsonReader, subContext);
if (subCsdlModel != null && subContext.IsSucceeded())
{
// Should we compare the referenced version with the main CSDL version and report error if mismatching?
// So far, it's fine to ignore, because there may be scenarios where referenced schemas are at a different version.
subCsdlModel.AddParentModelReferences(edmReference);
referencedAstModels.Add(subCsdlModel);
}
context.AddRange(subContext.Errors);
}
}
return(referencedAstModels);
}
public void InvalidVersionValueKindReportingUnexpectedValueKind()
{
string json = @" { ""$Version"": 4.01 }";
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
EdmError error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.UnexpectedValueKind, error.ErrorCode);
Assert.Equal("An unexpected 'Number' value kind was found when parsing the JSON path '$.$Version'. A 'String' value kind was expected.", error.ErrorMessage);
}
public void MissingVersionReportingMissingRequiredPropertyError()
{
string json = @" { }";
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
EdmError error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.MissingRequiredProperty, error.ErrorCode);
Assert.Equal("A property '$Version' is missing when parsing the JSON path '$'.", error.ErrorMessage);
}
public void UnexpectedJsonMemberReportingJsonUnexpectedJsonMemberError()
{
string json = @" {""$Version"": ""4.01"", ""Anything"": 1.0 }";
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
EdmError error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.UnexpectedElement, error.ErrorCode);
Assert.Equal("A member '$.Anything' with value type 'Number' is unexpected.", error.ErrorMessage);
}
public void InvalidCsdlDocumentJsonValueKindReportingJsonInvalidValueKindError()
{
string json = @" [ {""$Version"": ""4.01""} ]";
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
EdmError error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.UnexpectedValueKind, error.ErrorCode);
Assert.Equal("An unexpected 'Array' value kind was found when parsing the JSON path '$'. A 'Object' value kind was expected.", error.ErrorMessage);
}
public void InvalidVersionValueReportingUnexpectedValueKind()
{
string json = @" { ""$Version"": ""5.0"" }";
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
EdmError error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.InvalidVersionNumber, error.ErrorCode);
Assert.Equal("The version specified at '$.$Version' is not valid. It should be a string containing either '4.0' or '4.01'.", error.ErrorMessage);
}
public void InvalidJsonReportingJsonInvalidError()
{
string json = @" { ""$Version"": ""4.01"" "; // missing a }
Utf8JsonReader jsonReader = GetJsonReader(json);
JsonParserContext context = new JsonParserContext();
CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context);
EdmError error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.InvalidJson, error.ErrorCode);
Assert.Equal("$ LineNumber:0 BytePositionInLine:22 Path:N/A ActualMessage:Expected depth to be zero at the end of the JSON payload." +
" There is an open JSON object or array that should be closed. LineNumber: 0 | BytePositionInLine: 22.", error.ErrorMessage);
}
public void ParseIncludeWorksAsExpected()
{
string json = @" {
""$Namespace"": ""org.example.display"",
""$Alias"": ""UI"" }";
using (JsonDocument document = JsonDocument.Parse(json))
{
JsonElement rootElement = document.RootElement;
JsonParserContext context = new JsonParserContext();
CsdlInclude include = CsdlJsonParser.ParseInclude(rootElement, context);
Assert.NotNull(include);
Assert.Equal("UI", include.Alias);
Assert.Equal("org.example.display", include.Namespace);
}
}
/// <summary>
/// Tries parsing the given CSDL-JSON artifact for an IEdmModel.
/// </summary>
/// <param name="reader">The given JSON reader containing the CSDL artifact.</param>
/// <param name="settings">CSDL-JSON reader settings for current parser.</param>
/// <param name="model">The model generated by parsing</param>
/// <param name="errors">Errors reported while parsing.</param>
/// <returns>Success of the parse operation.</returns>
public static bool TryParse(ref Utf8JsonReader reader, CsdlJsonReaderSettings settings, out IEdmModel model, out IEnumerable <EdmError> errors)
{
EdmUtil.CheckArgumentNull(settings, nameof(settings));
model = null;
JsonParserContext context = new JsonParserContext(settings, source: null);
CsdlModel mainModel = CsdlJsonParser.ParseCsdlDocument(ref reader, context);
if (mainModel != null && !context.HasIntolerableError())
{
Debug.Assert(mainModel.CsdlVersion != null, "csdlVersion != null");
List <CsdlModel> referencedAstModels = LoadReferencedCsdl(mainModel, context);
if (!context.HasIntolerableError())
{
CsdlSemanticsModel tmp = new CsdlSemanticsModel(mainModel,
new CsdlSemanticsDirectValueAnnotationsManager(),
referencedAstModels,
settings.IncludeDefaultVocabularies);
// add more referenced IEdmModels in addition to the above loaded CsdlModels.
if (settings.ReferencedModels != null)
{
tmp.AddToReferencedModels(settings.ReferencedModels);
}
model = tmp;
model.SetEdmxVersion(mainModel.CsdlVersion);
Version edmVersion;
if (CsdlConstants.EdmxToEdmVersions.TryGetValue(mainModel.CsdlVersion, out edmVersion))
{
model.SetEdmVersion(edmVersion);
}
}
}
errors = context.Errors;
return(!context.HasIntolerableError());
}
public void ParseIncludeAnnotationsWorksAsExpected()
{
string json = @" {
""$TermNamespace"": ""org.example.hcm"",
""$Qualifier"": ""Tablet"",
""$TargetNamespace"": ""com.example.Person"" }";
using (JsonDocument document = JsonDocument.Parse(json))
{
JsonElement rootElement = document.RootElement;
JsonParserContext context = new JsonParserContext();
CsdlIncludeAnnotations includeAnnotations = CsdlJsonParser.ParseIncludeAnnotations(rootElement, context);
Assert.NotNull(includeAnnotations);
Assert.Equal("org.example.hcm", includeAnnotations.TermNamespace);
Assert.Equal("Tablet", includeAnnotations.Qualifier);
Assert.Equal("com.example.Person", includeAnnotations.TargetNamespace);
}
}
public void ParseIncludeReportUnExpectedMember()
{
string json = @" {
""$Namespace"": ""org.example.display"",
""$Unknown"": ""UI"" }";
using (JsonDocument document = JsonDocument.Parse(json))
{
JsonElement rootElement = document.RootElement;
JsonParserContext context = new JsonParserContext();
CsdlInclude include = CsdlJsonParser.ParseInclude(rootElement, context);
Assert.NotNull(include);
Assert.Equal("org.example.display", include.Namespace);
var error = Assert.Single(context.Errors);
Assert.Equal(EdmErrorCode.UnexpectedElement, error.ErrorCode);
Assert.Equal("$.$Unknown", error.ErrorLocation.ToString());
Assert.Equal("A member '$.$Unknown' with value type 'String' is unexpected.", error.ErrorMessage);
}
}
