private void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
if (writer == null)
{
throw Error.ArgumentNull(nameof(writer));
}
writer.WriteStartObject();
// name
writer.WriteProperty(OpenApiConstants.Name, Name);
// namespace
writer.WriteProperty(OpenApiConstants.Namespace, Namespace?.AbsoluteUri);
// prefix
writer.WriteProperty(OpenApiConstants.Prefix, Prefix);
// attribute
writer.WriteProperty(OpenApiConstants.Attribute, Attribute, false);
// wrapped
writer.WriteProperty(OpenApiConstants.Wrapped, Wrapped, false);
// extensions
writer.WriteExtensions(Extensions, specVersion);
writer.WriteEndObject();
}
public void BasicEdmModelToOpenApiJsonWorks(OpenApiSpecVersion specVersion)
{
// Arrange
IEdmModel model = EdmModelHelper.BasicEdmModel;
var openApiConvertSettings = new OpenApiConvertSettings
{
OpenApiSpecVersion = specVersion,
ShowSchemaExamples = true // test for schema examples
};
// Act
string json = WriteEdmModelAsOpenApi(model, OpenApiFormat.Json, openApiConvertSettings);
_output.WriteLine(json);
// Assert
if (specVersion == OpenApiSpecVersion.OpenApi2_0)
{
Assert.Equal(Resources.GetString("Basic.OpenApi.V2.json").ChangeLineBreaks(), json);
}
else
{
Assert.Equal(Resources.GetString("Basic.OpenApi.json").ChangeLineBreaks(), json);
}
}
public void TripServiceMetadataToOpenApiYamlWorks(OpenApiSpecVersion specVersion)
{
// Arrange
IEdmModel model = EdmModelHelper.TripServiceModel;
OpenApiConvertSettings settings = new OpenApiConvertSettings
{
EnableKeyAsSegment = true,
Version = new Version(1, 0, 1),
ServiceRoot = new Uri("http://services.odata.org/TrippinRESTierService"),
IEEE754Compatible = true,
OpenApiSpecVersion = specVersion,
AddSingleQuotesForStringParameters = true,
AddEnumDescriptionExtension = true,
AppendBoundOperationsOnDerivedTypeCastSegments = true
};
// Act
string yaml = WriteEdmModelAsOpenApi(model, OpenApiFormat.Yaml, settings);
_output.WriteLine(yaml);
// Assert
if (specVersion == OpenApiSpecVersion.OpenApi2_0)
{
Assert.Equal(Resources.GetString("TripService.OpenApi.V2.yaml").ChangeLineBreaks(), yaml);
}
else
{
Assert.Equal(Resources.GetString("TripService.OpenApi.yaml").ChangeLineBreaks(), yaml);
}
}
public void MultipleSchemasEdmModelToOpenApiYamlWorks(OpenApiSpecVersion specVersion)
{
// Arrange
IEdmModel model = EdmModelHelper.MultipleSchemasEdmModel;
var openApiConvertSettings = new OpenApiConvertSettings
{
OpenApiSpecVersion = specVersion,
ShowLinks = true, // test Links
ShowSchemaExamples = true
};
// Act
string yaml = WriteEdmModelAsOpenApi(model, OpenApiFormat.Yaml, openApiConvertSettings);
_output.WriteLine(yaml);
// Assert
if (specVersion == OpenApiSpecVersion.OpenApi2_0)
{
Assert.Equal(Resources.GetString("Multiple.Schema.OpenApi.V2.yaml").ChangeLineBreaks(), yaml);
}
else
{
Assert.Equal(Resources.GetString("Multiple.Schema.OpenApi.yaml").ChangeLineBreaks(), yaml);
}
}
/// <summary>
/// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
/// </summary>
/// <param name="input">TextReader containing OpenAPI description to parse.</param>
/// <param name="version">Version of the OpenAPI specification that the fragment conforms to.</param>
/// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
/// <returns>Instance of newly created OpenApiDocument</returns>
public T ReadFragment <T>(YamlDocument input, OpenApiSpecVersion version, out OpenApiDiagnostic diagnostic) where T : IOpenApiElement
{
diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic)
{
ExtensionParsers = _settings.ExtensionParsers
};
IOpenApiElement element = null;
try
{
// Parse the OpenAPI element
element = context.ParseFragment <T>(input, version);
}
catch (OpenApiException ex)
{
diagnostic.Errors.Add(new OpenApiError(ex));
}
// Validate the element
if (_settings.RuleSet != null && _settings.RuleSet.Rules.Count > 0)
{
var errors = element.Validate(_settings.RuleSet);
foreach (var item in errors)
{
diagnostic.Errors.Add(item);
}
}
return((T)element);
}
/// <summary>
/// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
/// </summary>
/// <param name="input">Stream containing OpenAPI description to parse.</param>
/// <param name="version">Version of the OpenAPI specification that the fragment conforms to.</param>
/// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
/// <returns>Instance of newly created OpenApiDocument</returns>
public T ReadFragment <T>(Stream input, OpenApiSpecVersion version, out OpenApiDiagnostic diagnostic) where T : IOpenApiElement
{
using (var reader = new StreamReader(input))
{
return(new OpenApiTextReaderReader(_settings).ReadFragment <T>(reader, version, out diagnostic));
}
}
internal byte[] ConvertOpenApiDocument(string inputFileContent, OpenApiSpecVersion apiSpecVersion, OpenApiFormat apiFormat)
{
using (Stream stream = this.CreateStream(inputFileContent))
{
var document = new OpenApiStreamReader().Read(stream, out var context);
this.codeGeneratorProgress?.Progress(50, 100);
var outputStream = new MemoryStream();
document.Serialize(outputStream, apiSpecVersion, apiFormat);
this.codeGeneratorProgress?.Progress(100, 100);
var encoding = Encoding.GetEncoding(Encoding.UTF8.WindowsCodePage);
//Get the preamble (byte-order mark) for our encoding
byte[] preamble = encoding.GetPreamble();
int preambleLength = preamble.Length;
outputStream.Position = 0;
//Convert the writer contents to a byte array
byte[] body = encoding.GetBytes(new StreamReader(outputStream).ReadToEnd());
//Prepend the preamble to body (store result in resized preamble array)
Array.Resize(ref preamble, preambleLength + body.Length);
Array.Copy(body, 0, preamble, preambleLength, body.Length);
//Return the combined byte array
return(preamble);
}
}
protected override void WriteBody(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
base.WriteBody(writer, specVersion);
writer.WriteOptionalObject("schema", Schema, specVersion);
writer.WriteProperty("separator", Separator);
}
/// <summary>
/// Serializes the <see cref="IOpenApiSerializable"/> to Open API document using the given specification version and writer.
/// </summary>
/// <typeparam name="T">the <see cref="IOpenApiSerializable"/></typeparam>
/// <param name="element">The Open API element.</param>
/// <param name="writer">The output writer.</param>
/// <param name="specVersion">The Open API specification version.</param>
public static void Serialize <T>(this T element, IOpenApiWriter writer, OpenApiSpecVersion specVersion)
where T : IOpenApiSerializable
{
if (element == null)
{
throw Error.ArgumentNull(nameof(element));
}
if (writer == null)
{
throw Error.ArgumentNull(nameof(writer));
}
switch (specVersion)
{
case OpenApiSpecVersion.OpenApi3_0:
element.SerializeAsV3(writer);
break;
case OpenApiSpecVersion.OpenApi2_0:
element.SerializeAsV2(writer);
break;
default:
throw new OpenApiException(string.Format(SRResource.OpenApiSpecVersionNotSupported, specVersion));
}
writer.Flush();
}
public void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
writer.WriteStartObject();
writer.WriteProperty("baz", Baz);
writer.WriteProperty("bar", Bar);
writer.WriteEndObject();
}
/// <summary>
/// Serializes the <see cref="IOpenApiSerializable"/> to the Open API document using
/// the given stream, specification version and the format.
/// </summary>
/// <typeparam name="T">the <see cref="IOpenApiSerializable"/></typeparam>
/// <param name="element">The Open API element.</param>
/// <param name="stream">The given stream.</param>
/// <param name="specVersion">The Open API specification version.</param>
/// <param name="format">The output format (JSON or YAML).</param>
public static void Serialize <T>(
this T element,
Stream stream,
OpenApiSpecVersion specVersion,
OpenApiFormat format)
where T : IOpenApiSerializable
{
if (stream == null)
{
throw Error.ArgumentNull(nameof(stream));
}
IOpenApiWriter writer;
switch (format)
{
case OpenApiFormat.Json:
writer = new OpenApiJsonWriter(new StreamWriter(stream));
break;
case OpenApiFormat.Yaml:
writer = new OpenApiYamlWriter(new StreamWriter(stream));
break;
default:
throw new OpenApiException(string.Format(SRResource.OpenApiFormatNotSupported, format));
}
element.Serialize(writer, specVersion);
}
/// <summary>
/// Serializes the <see cref="IOpenApiSerializable"/> to the Open API document as a string in YAML format.
/// </summary>
/// <typeparam name="T">the <see cref="IOpenApiSerializable"/></typeparam>
/// <param name="element">The Open API element.</param>
/// <param name="specVersion">The Open API specification version.</param>
public static string SerializeAsYaml <T>(
this T element,
OpenApiSpecVersion specVersion)
where T : IOpenApiSerializable
{
return(element.Serialize(specVersion, OpenApiFormat.Yaml));
}
public void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
writer.WriteStartObject();
writer.WriteProperty("page", PageParameterName);
writer.WriteProperty("pageSize", PageSizeParameterName);
writer.WriteEndObject();
}
/// <inheritdoc />
public async Task <string> RenderAsync(OpenApiSpecVersion version, OpenApiFormat format)
{
var result = await Task.Factory
.StartNew(() => this.Render(version, format))
.ConfigureAwait(false);
return(result);
}
/// <summary>
/// Writes this endpoint description to an OpenAPI document.
/// </summary>
/// <param name="writer">The write to write to.</param>
/// <param name="specVersion">The OpenAPI Spec version to use.</param>
protected virtual void WriteBody(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
if (!string.IsNullOrEmpty(Kind))
{
writer.WriteProperty("kind", Kind);
}
writer.WriteProperty("uri", Uri);
writer.WriteProperty("description", Description);
}
/// <summary>
/// Serializes the <see cref="IOpenApiSerializable"/> to the Open API document using
/// the given stream, specification version and the format.
/// </summary>
/// <typeparam name="T">the <see cref="IOpenApiSerializable"/></typeparam>
/// <param name="element">The Open API element.</param>
/// <param name="stream">The given stream.</param>
/// <param name="specVersion">The Open API specification version.</param>
/// <param name="format">The output format (JSON or YAML).</param>
public static void Serialize <T>(
this T element,
Stream stream,
OpenApiSpecVersion specVersion,
OpenApiFormat format)
where T : IOpenApiSerializable
{
element.Serialize(stream, specVersion, format, null);
}
public override void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
writer.WriteStartObject();
foreach (var item in Children)
{
writer.WriteOptionalObject(item.Key, item.Value, specVersion);
}
writer.WriteEndObject();
}
private string Render(OpenApiSpecVersion version, OpenApiFormat format)
{
using (var sw = new StringWriter())
{
this._document.Serialise(sw, version, format);
return(sw.ToString());
}
}
/// <summary>
/// Writes this endpoint description to an OpenAPI document.
/// </summary>
/// <param name="writer">The write to write to.</param>
/// <param name="specVersion">The OpenAPI Spec version to use.</param>
protected virtual void WriteBody(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
if (!string.IsNullOrEmpty(Type))
{
writer.WriteProperty("type", Type);
}
writer.WriteProperty("description", Description);
writer.WriteProperty("uri", Uri);
writer.WriteOptionalMap("children", Children, specVersion);
}
public void SerializeBasicResponseWorks(
OpenApiSpecVersion version,
OpenApiFormat format)
{
// Arrange & Act
var actual = BasicResponse.Serialize(version, format);
// Assert
actual.Should().Be("{ }");
}
public void SerializeBasicInfoAsYamlWorks(OpenApiSpecVersion version, string expected)
{
// Arrange & Act
var actual = BasicInfo.SerializeAsYaml(version);
// Assert
actual = actual.MakeLineBreaksEnvironmentNeutral();
expected = expected.MakeLineBreaksEnvironmentNeutral();
actual.Should().Be(expected);
}
/// <summary>
/// Write out contents of OpenApiArray to passed writer
/// </summary>
/// <param name="writer">Instance of JSON or YAML writer.</param>
/// <param name="specVersion">Version of the OpenAPI specification that that will be output.</param>
public void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
writer.WriteStartArray();
foreach (var item in this)
{
writer.WriteAny(item);
}
writer.WriteEndArray();
}
public void SerializeBasicXmlWorks(
OpenApiSpecVersion version,
OpenApiFormat format)
{
// Act
var actual = BasicXml.Serialize(version, format);
// Assert
actual = actual.MakeLineBreaksEnvironmentNeutral();
actual.Should().Be("{ }");
}
public void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
NullGuard.NotNull(writer, nameof(writer))
.NotNull(specVersion, nameof(specVersion));
writer.WriteStartArray();
foreach (IOpenApiExtension errorCode in ErrorCodes)
{
errorCode.Write(writer, specVersion);
}
writer.WriteEndArray();
}
public void CreateEdmTypeSchemaReturnSchemaForEnumType(bool isNullable, OpenApiSpecVersion specVersion)
{
// Arrange
IEdmModel model = EdmModelHelper.TripServiceModel;
IEdmEnumType enumType = model.SchemaElements.OfType <IEdmEnumType>().First(c => c.Name == "PersonGender");
Assert.NotNull(enumType); // guard
IEdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, isNullable);
ODataContext context = new ODataContext(model);
context.Settings.OpenApiSpecVersion = specVersion;
// Act
var schema = context.CreateEdmTypeSchema(enumTypeReference);
// & Assert
Assert.NotNull(schema);
if (specVersion == OpenApiSpecVersion.OpenApi2_0)
{
Assert.NotNull(schema.Reference);
Assert.Null(schema.AnyOf);
Assert.Equal(ReferenceType.Schema, schema.Reference.Type);
Assert.Equal(enumType.FullTypeName(), schema.Reference.Id);
Assert.Equal(isNullable, schema.Nullable);
}
else
{
if (isNullable)
{
Assert.NotNull(schema.AnyOf);
Assert.NotEmpty(schema.AnyOf);
Assert.Null(schema.Reference);
Assert.Equal(2, schema.AnyOf.Count);
var anyOfRef = schema.AnyOf.FirstOrDefault();
Assert.NotNull(anyOfRef.Reference);
Assert.Equal(ReferenceType.Schema, anyOfRef.Reference.Type);
Assert.Equal(enumType.FullTypeName(), anyOfRef.Reference.Id);
var anyOfNull = schema.AnyOf.Skip(1).FirstOrDefault();
Assert.NotNull(anyOfNull.Type);
Assert.Equal("object", anyOfNull.Type);
Assert.True(anyOfNull.Nullable);
}
else
{
Assert.Null(schema.AnyOf);
Assert.NotNull(schema.Reference);
Assert.Equal(ReferenceType.Schema, schema.Reference.Type);
Assert.Equal(enumType.FullTypeName(), schema.Reference.Id);
}
}
}
/// <summary>
/// Serialize OpenApiObject to writer
/// </summary>
/// <param name="writer"></param>
/// <param name="specVersion">Version of the OpenAPI specification that that will be output.</param>
public void Write(IOpenApiWriter writer, OpenApiSpecVersion specVersion)
{
writer.WriteStartObject();
foreach (var item in this)
{
writer.WritePropertyName(item.Key);
writer.WriteAny(item.Value);
}
writer.WriteEndObject();
}
/// <summary>
/// Reads the string input and parses it into an Open API element.
/// </summary>
public T ReadFragment <T>(string input, OpenApiSpecVersion version, out OpenApiDiagnostic diagnostic) where T : IOpenApiElement
{
using (var memoryStream = new MemoryStream())
{
var writer = new StreamWriter(memoryStream);
writer.Write(input);
writer.Flush();
memoryStream.Position = 0;
return(new OpenApiStreamReader(_settings).ReadFragment <T>(memoryStream, version, out diagnostic));
}
}
public IOpenApiExtension Parse([NotNull] IOpenApiAny data, OpenApiSpecVersion specVersion)
{
if (!(data is OpenApiObject objData))
{
throw new FormatException($"{EndpointList.ExtensionKey} is not an object.");
}
var result = new EndpointList();
result.Parse(objData, this);
return(result);
}
public void SerializeBasicLicenseAsYamlWorks(OpenApiSpecVersion version)
{
// Arrange
var expected = "name: Apache 2.0";
// Act
var actual = BasicLicense.SerializeAsYaml(version);
// Assert
actual = actual.MakeLineBreaksEnvironmentNeutral();
expected = expected.MakeLineBreaksEnvironmentNeutral();
actual.Should().Be(expected);
}
public void SerializeBasicContactWorks(
OpenApiSpecVersion version,
OpenApiFormat format,
string expected)
{
// Arrange & Act
var actual = BasicContact.Serialize(version, format);
// Assert
actual = actual.MakeLineBreaksEnvironmentNeutral();
expected = expected.MakeLineBreaksEnvironmentNeutral();
actual.Should().Be(expected);
}
