An OpenApi (swagger) parser to generate MappingModel or mapping.json file (#479)

* wip

* .

* .

* nuget

* .

* .

* WithMappingModel

* tests

* json

* codefactor

* sign

* .

* interface

* sln

* comments

src/WireMock.Net.OpenApiParser/Extensions/OpenApiSchemaExtensions.cs

@@ -0,0 +1,92 @@
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models;
+using WireMock.Net.OpenApiParser.Types;
+
+namespace WireMock.Net.OpenApiParser.Extensions
+{
+    internal static class OpenApiSchemaExtensions
+    {
+        /// <summary>
+        /// https://stackoverflow.com/questions/48111459/how-to-define-a-property-that-can-be-string-or-null-in-openapi-swagger
+        /// </summary>
+        public static bool TryGetXNullable(this OpenApiSchema schema, out bool value)
+        {
+            value = false;
+
+            if (schema.Extensions.TryGetValue("x-nullable", out IOpenApiExtension e) && e is OpenApiBoolean openApiBoolean)
+            {
+                value = openApiBoolean.Value;
+                return true;
+            }
+
+            return false;
+        }
+
+        public static SchemaType GetSchemaType(this OpenApiSchema schema)
+        {
+            switch (schema?.Type)
+            {
+                case "object":
+                    return SchemaType.Object;
+
+                case "array":
+                    return SchemaType.Array;
+
+                case "integer":
+                    return SchemaType.Integer;
+
+                case "number":
+                    return SchemaType.Number;
+
+                case "boolean":
+                    return SchemaType.Boolean;
+
+                case "string":
+                    return SchemaType.String;
+
+                case "file":
+                    return SchemaType.File;
+
+                default:
+                    return SchemaType.Unknown;
+            }
+        }
+
+        public static SchemaFormat GetSchemaFormat(this OpenApiSchema schema)
+        {
+            switch (schema?.Format)
+            {
+                case "float":
+                    return SchemaFormat.Float;
+
+                case "double":
+                    return SchemaFormat.Double;
+
+                case "int32":
+                    return SchemaFormat.Int32;
+
+                case "int64":
+                    return SchemaFormat.Int64;
+
+                case "date":
+                    return SchemaFormat.Date;
+
+                case "date-time":
+                    return SchemaFormat.DateTime;
+
+                case "password":
+                    return SchemaFormat.Password;
+
+                case "byte":
+                    return SchemaFormat.Byte;
+
+                case "binary":
+                    return SchemaFormat.Binary;
+
+                default:
+                    return SchemaFormat.Undefined;
+            }
+        }
+    }
+}

src/WireMock.Net.OpenApiParser/Extensions/WireMockServerExtensions.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Linq;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+using WireMock.Server;
+
+namespace WireMock.Net.OpenApiParser.Extensions
+{
+    public static class WireMockServerExtensions
+    {
+        /// <summary>
+        /// Register the mappings via an OpenAPI (swagger) V2 or V3 file.
+        /// </summary>
+        /// <param name="server">The WireMockServer instance</param>
+        /// <param name="path">Path containing OpenAPI file to parse and use the mappings.</param>
+        /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
+        public static IWireMockServer WithMappingFromOpenApiFile(this IWireMockServer server, string path, out OpenApiDiagnostic diagnostic)
+        {
+            if (server == null)
+            {
+                throw new ArgumentNullException(nameof(server));
+            }
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException(nameof(path));
+            }
+
+            var mappings = new WireMockOpenApiParser().FromFile(path, out diagnostic);
+
+            return server.WithMapping(mappings.ToArray());
+        }
+
+        /// <summary>
+        /// Register the mappings via an OpenAPI (swagger) V2 or V3 stream.
+        /// </summary>
+        /// <param name="server">The WireMockServer instance</param>
+        /// <param name="stream">Stream containing OpenAPI description to parse and use the mappings.</param>
+        /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
+        public static IWireMockServer WithMappingFromOpenApiStream(this IWireMockServer server, Stream stream, out OpenApiDiagnostic diagnostic)
+        {
+            var mappings = new WireMockOpenApiParser().FromStream(stream, out diagnostic);
+
+            return server.WithMapping(mappings.ToArray());
+        }
+
+        /// <summary>
+        /// Register the mappings via an OpenAPI (swagger) V2 or V3 document.
+        /// </summary>
+        /// <param name="server">The WireMockServer instance</param>
+        /// <param name="document">The OpenAPI document to use as mappings.</param>
+        public static IWireMockServer WithMappingFromOpenApiDocument(this IWireMockServer server, OpenApiDocument document)
+        {
+            var mappings = new WireMockOpenApiParser().FromDocument(document);
+
+            return server.WithMapping(mappings.ToArray());
+        }
+    }
+}

src/WireMock.Net.OpenApiParser/IWireMockOpenApiParser.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+using WireMock.Admin.Mappings;
+
+namespace WireMock.Net.OpenApiParser
+{
+    /// <summary>
+    /// Parse a OpenApi/Swagger/V2/V3 or Raml to WireMock MappingModels.
+    /// </summary>
+    public interface IWireMockOpenApiParser
+    {
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from an <seealso cref="OpenApiDocument"/>.
+        /// </summary>
+        /// <param name="document">The source OpenApiDocument</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromDocument(OpenApiDocument document);
+
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from a <seealso cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">The source stream</param>
+        /// <param name="diagnostic">OpenApiDiagnostic output</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromStream(Stream stream, out OpenApiDiagnostic diagnostic);
+
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from a file-path.
+        /// </summary>
+        /// <param name="path">The path to read the OpenApi/Swagger/V2/V3 or Raml file.</param>
+        /// <param name="diagnostic">OpenApiDiagnostic output</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromFile(string path, out OpenApiDiagnostic diagnostic);
+    }
+}

src/WireMock.Net.OpenApiParser/Types/SchemaFormat.cs

@@ -0,0 +1,25 @@
+namespace WireMock.Net.OpenApiParser.Types
+{
+    internal enum SchemaFormat
+    {
+        Float,
+
+        Double,
+
+        Int32,
+
+        Int64,
+
+        Date,
+
+        DateTime,
+
+        Password,
+
+        Byte,
+
+        Binary,
+
+        Undefined
+    }
+}

src/WireMock.Net.OpenApiParser/Types/SchemaType.cs

@@ -0,0 +1,21 @@
+namespace WireMock.Net.OpenApiParser.Types
+{
+    internal enum SchemaType
+    {
+        Object,
+
+        Array,
+
+        String,
+
+        Integer,
+
+        Number,
+
+        Boolean,
+
+        File,
+
+        Unknown
+    }
+}

src/WireMock.Net.OpenApiParser/Utils/DateTimeUtils.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Globalization;
+
+namespace WireMock.Net.OpenApiParser.Utils
+{
+    internal static class DateTimeUtils
+    {
+        public static string ToRfc3339DateTime(DateTime dateTime)
+        {
+            return dateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz", DateTimeFormatInfo.InvariantInfo);
+        }
+
+        public static string ToRfc3339Date(DateTime dateTime)
+        {
+            return dateTime.ToString("yyyy-MM-dd", DateTimeFormatInfo.InvariantInfo);
+        }
+    }
+}

src/WireMock.Net.OpenApiParser/Utils/ExampleValueGenerator.cs

@@ -0,0 +1,51 @@
+using System;
+using Microsoft.OpenApi.Models;
+using WireMock.Net.OpenApiParser.Extensions;
+using WireMock.Net.OpenApiParser.Types;
+
+namespace WireMock.Net.OpenApiParser.Utils
+{
+    internal static class ExampleValueGenerator
+    {
+        public static object GetExampleValue(OpenApiSchema schema)
+        {
+            switch (schema?.GetSchemaType())
+            {
+                case SchemaType.Boolean:
+                    return true;
+
+                case SchemaType.Integer:
+                    return 42;
+
+                case SchemaType.Number:
+                    switch (schema?.GetSchemaFormat())
+                    {
+                        case SchemaFormat.Float:
+                            return 4.2f;
+
+                        default:
+                            return 4.2d;
+                    }
+
+                default:
+                    switch (schema?.GetSchemaFormat())
+                    {
+                        case SchemaFormat.Date:
+                            return DateTimeUtils.ToRfc3339Date(DateTime.UtcNow);
+
+                        case SchemaFormat.DateTime:
+                            return DateTimeUtils.ToRfc3339DateTime(DateTime.UtcNow);
+
+                        case SchemaFormat.Byte:
+                            return new byte[] { 48, 49, 50 };
+
+                        case SchemaFormat.Binary:
+                            return "example-object";
+
+                        default:
+                            return "example-string";
+                    }
+            }
+        }
+    }
+}

src/WireMock.Net.OpenApiParser/WireMock.Net.OpenApiParser.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>An OpenApi (swagger) parser to generate MappingModel or mapping.json file.</Description>
+    <VersionPrefix>1.2.4-preview-01</VersionPrefix>
+    <TargetFrameworks>net46;netstandard2.0</TargetFrameworks>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <PackageTags>wiremock;openapi;OAS;converter;parser;openapiparser</PackageTags>
+    <ProjectGuid>{D3804228-91F4-4502-9595-39584E5AADAD}</ProjectGuid>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+    <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
+    <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.2.0" />
+    <PackageReference Include="RamlToOpenApiConverter" Version="0.1.1" />
+    <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Options\" />
+  </ItemGroup>
+
+</Project>

src/WireMock.Net.OpenApiParser/WireMockOpenApiParser.cs

@@ -0,0 +1,289 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using JetBrains.Annotations;
+using Microsoft.OpenApi;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+using Microsoft.OpenApi.Writers;
+using Newtonsoft.Json.Linq;
+using RamlToOpenApiConverter;
+using WireMock.Admin.Mappings;
+using WireMock.Net.OpenApiParser.Extensions;
+using WireMock.Net.OpenApiParser.Types;
+using WireMock.Net.OpenApiParser.Utils;
+
+namespace WireMock.Net.OpenApiParser
+{
+    /// <summary>
+    /// Parse a OpenApi/Swagger/V2/V3 or Raml to WireMock MappingModels.
+    /// </summary>
+    public class WireMockOpenApiParser : IWireMockOpenApiParser
+    {
+        private const int ArrayItems = 3;
+
+        private readonly OpenApiStreamReader _reader = new OpenApiStreamReader();
+
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromFile" />
+        [PublicAPI]
+        public IEnumerable<MappingModel> FromFile(string path, out OpenApiDiagnostic diagnostic)
+        {
+            OpenApiDocument document;
+            if (Path.GetExtension(path).EndsWith("raml", StringComparison.OrdinalIgnoreCase))
+            {
+                diagnostic = new OpenApiDiagnostic();
+                document = new RamlConverter().ConvertToOpenApiDocument(path);
+            }
+            else
+            {
+                var reader = new OpenApiStreamReader();
+                document = reader.Read(File.OpenRead(path), out diagnostic);
+            }
+
+            return FromDocument(document);
+        }
+
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromStream" />
+        [PublicAPI]
+        public IEnumerable<MappingModel> FromStream(Stream stream, out OpenApiDiagnostic diagnostic)
+        {
+            return FromDocument(_reader.Read(stream, out diagnostic));
+        }
+
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromDocument" />
+        [PublicAPI]
+        public IEnumerable<MappingModel> FromDocument(OpenApiDocument openApiDocument)
+        {
+            return MapPaths(openApiDocument.Paths);
+        }
+
+        private static IEnumerable<MappingModel> MapPaths(OpenApiPaths paths)
+        {
+            return paths.Select(p => MapPath(p.Key, p.Value)).SelectMany(x => x);
+        }
+
+        private static IEnumerable<MappingModel> MapPath(string path, OpenApiPathItem pathItem)
+        {
+            return pathItem.Operations.Select(o => MapOperationToMappingModel(path, o.Key.ToString().ToUpperInvariant(), o.Value));
+        }
+
+        private static MappingModel MapOperationToMappingModel(string path, string httpMethod, OpenApiOperation operation)
+        {
+            var queryParameters = operation.Parameters.Where(p => p.In == ParameterLocation.Query);
+            var pathParameters = operation.Parameters.Where(p => p.In == ParameterLocation.Path);
+            var response = operation.Responses.FirstOrDefault();
+            TryGetContent(response.Value?.Content, out OpenApiMediaType responseContent, out string responseContentType);
+            var responseSchema = response.Value?.Content?.FirstOrDefault().Value?.Schema;
+            var responseExample = responseContent?.Example;
+
+            var body = responseExample != null ? MapOpenApiAnyToJToken(responseExample) : MapSchemaToObject(responseSchema);
+
+            if (int.TryParse(response.Key, out var httpStatusCode))
+            {
+                httpStatusCode = 200;
+            }
+
+            return new MappingModel
+            {
+                Guid = Guid.NewGuid(),
+                Request = new RequestModel
+                {
+                    Methods = new[] { httpMethod },
+                    Path = MapPathWithParameters(path, pathParameters),
+                    Params = MapQueryParameters(queryParameters)
+                },
+                Response = new ResponseModel
+                {
+                    StatusCode = httpStatusCode,
+                    Headers = MapHeaders(responseContentType, response.Value?.Headers),
+                    BodyAsJson = body
+                }
+            };
+        }
+
+        private static bool TryGetContent(IDictionary<string, OpenApiMediaType> contents, out OpenApiMediaType openApiMediaType, out string contentType)
+        {
+            openApiMediaType = null;
+            contentType = null;
+
+            if (contents == null || contents.Values.Count == 0)
+            {
+                return false;
+            }
+
+            if (contents.TryGetValue("application/json", out var content))
+            {
+                openApiMediaType = content;
+                contentType = "application/json";
+            }
+            else
+            {
+                var first = contents.FirstOrDefault();
+                openApiMediaType = first.Value;
+                contentType = first.Key;
+            }
+
+            return true;
+        }
+
+        private static object MapSchemaToObject(OpenApiSchema schema, string name = null)
+        {
+            if (schema == null)
+            {
+                return null;
+            }
+
+            switch (schema.GetSchemaType())
+            {
+                case SchemaType.Array:
+                    var jArray = new JArray();
+                    for (int i = 0; i < ArrayItems; i++)
+                    {
+                        if (schema.Items.Properties.Count > 0)
+                        {
+                            var arrayItem = new JObject();
+                            foreach (var property in schema.Items.Properties)
+                            {
+                                var objectValue = MapSchemaToObject(property.Value, property.Key);
+                                if (objectValue is JProperty jp)
+                                {
+                                    arrayItem.Add(jp);
+                                }
+                                else
+                                {
+                                    arrayItem.Add(new JProperty(property.Key, objectValue));
+                                }
+                            }
+
+                            jArray.Add(arrayItem);
+                        }
+                        else
+                        {
+                            jArray.Add(MapSchemaToObject(schema.Items, name));
+                        }
+                    }
+
+                    return jArray;
+
+                case SchemaType.Boolean:
+                case SchemaType.Integer:
+                case SchemaType.Number:
+                case SchemaType.String:
+                    return ExampleValueGenerator.GetExampleValue(schema);
+
+                case SchemaType.Object:
+                    var propertyAsJObject = new JObject();
+                    foreach (var schemaProperty in schema.Properties)
+                    {
+                        string propertyName = schemaProperty.Key;
+                        var openApiSchema = schemaProperty.Value;
+                        if (openApiSchema.GetSchemaType() == SchemaType.Object)
+                        {
+                            var mapped = MapSchemaToObject(schemaProperty.Value, schemaProperty.Key);
+                            if (mapped is JProperty jp)
+                            {
+                                propertyAsJObject.Add(jp);
+                            }
+                        }
+                        else
+                        {
+                            bool propertyIsNullable = openApiSchema.Nullable || (openApiSchema.TryGetXNullable(out bool x) && x);
+
+                            propertyAsJObject.Add(new JProperty(propertyName, ExampleValueGenerator.GetExampleValue(openApiSchema)));
+                        }
+                    }
+
+                    return name != null ? new JProperty(name, propertyAsJObject) : (JToken)propertyAsJObject;
+
+                default:
+                    return null;
+            }
+        }
+
+        private static string MapPathWithParameters(string path, IEnumerable<OpenApiParameter> parameters)
+        {
+            if (parameters == null)
+            {
+                return path;
+            }
+
+            string newPath = path;
+            foreach (var parameter in parameters)
+            {
+                newPath = newPath.Replace($"{{{parameter.Name}}}", ExampleValueGenerator.GetExampleValue(parameter.Schema).ToString());
+            }
+
+            return newPath;
+        }
+
+        private static JToken MapOpenApiAnyToJToken(IOpenApiAny any)
+        {
+            if (any == null)
+            {
+                return null;
+            }
+
+            using (var outputString = new StringWriter())
+            {
+                var writer = new OpenApiJsonWriter(outputString);
+                any.Write(writer, OpenApiSpecVersion.OpenApi3_0);
+
+                return JObject.Parse(outputString.ToString());
+            }
+        }
+
+        private static IDictionary<string, object> MapHeaders(string responseContentType, IDictionary<string, OpenApiHeader> headers)
+        {
+            var mappedHeaders = headers.ToDictionary(item => item.Key, item => ExampleValueGenerator.GetExampleValue(null));
+            if (!string.IsNullOrEmpty(responseContentType))
+            {
+                if (!mappedHeaders.ContainsKey("Content-Type"))
+                {
+                    mappedHeaders.Add("Content-Type", responseContentType);
+                }
+                else
+                {
+                    mappedHeaders["Content-Type"] = responseContentType;
+                }
+            }
+
+            return mappedHeaders.Keys.Any() ? mappedHeaders : null;
+        }
+
+        private static IList<ParamModel> MapQueryParameters(IEnumerable<OpenApiParameter> queryParameters)
+        {
+            var list = queryParameters
+                .Select(qp => new ParamModel
+                {
+                    Name = qp.Name,
+                    Matchers = new[]
+                    {
+                        new MatcherModel
+                        {
+                            Name = "ExactMatcher",
+                            Pattern = GetDefaultValueAsStringForSchemaType(qp.Schema)
+                        }
+                    }
+                })
+                .ToList();
+
+            return list.Any() ? list : null;
+        }
+
+        private static string GetDefaultValueAsStringForSchemaType(OpenApiSchema schema)
+        {
+            var value = ExampleValueGenerator.GetExampleValue(schema);
+
+            switch (value)
+            {
+                case string valueAsString:
+                    return valueAsString;
+
+                default:
+                    return value.ToString();
+            }
+        }
+    }
+}