Can validate external references now

microsoft · darrelmiller · Apr 10, 2022 · Aug 15, 2021 · Nov 1, 2021 · Nov 25, 2021
commit 45968f3263f39206bc31dbf9f8488e1991a380cf
diff --git a/src/Microsoft.OpenApi.Readers/OpenApiYamlDocumentReader.cs b/src/Microsoft.OpenApi.Readers/OpenApiYamlDocumentReader.cs
@@ -88,7 +88,7 @@ public async Task<ReadResult> ReadAsync(YamlDocument input)
                 // Parse the OpenAPI Document
                 document = context.Parse(input);
 
-                await ResolveReferencesAsync(diagnostic, document);
+                await ResolveReferencesAsync(diagnostic, document, _settings.BaseUrl);
             }
             catch (OpenApiException ex)
             {
@@ -133,7 +133,7 @@ private void ResolveReferences(OpenApiDiagnostic diagnostic, OpenApiDocument doc
             }
         }
 
-        private async Task ResolveReferencesAsync(OpenApiDiagnostic diagnostic, OpenApiDocument document)
+        private async Task ResolveReferencesAsync(OpenApiDiagnostic diagnostic, OpenApiDocument document, Uri baseUrl)
         {
             List<OpenApiError> errors = new List<OpenApiError>();
 
@@ -146,7 +146,7 @@ private async Task ResolveReferencesAsync(OpenApiDiagnostic diagnostic, OpenApiD
                     var openApiWorkSpace = new OpenApiWorkspace();
 
                     // Load this root document into the workspace
-                    var streamLoader = new DefaultStreamLoader();
+                    var streamLoader = new DefaultStreamLoader(baseUrl);
                     var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, _settings.CustomExternalLoader ?? streamLoader, _settings);
                     await workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource = "/" }, document);
 

diff --git a/src/Microsoft.OpenApi.Readers/Services/DefaultStreamLoader.cs b/src/Microsoft.OpenApi.Readers/Services/DefaultStreamLoader.cs
@@ -14,32 +14,41 @@ namespace Microsoft.OpenApi.Readers.Services
     /// </summary>
     internal class DefaultStreamLoader : IStreamLoader
     {
+        private readonly Uri baseUrl;
         private HttpClient _httpClient = new HttpClient();
 
+
+        public DefaultStreamLoader(Uri baseUrl)
+        {
+            this.baseUrl = baseUrl;
+        }
+
         public Stream Load(Uri uri)
         {
+            var absoluteUri = new Uri(baseUrl, uri);
             switch (uri.Scheme)
             {
                 case "file":
-                    return File.OpenRead(uri.AbsolutePath);
+                    return File.OpenRead(absoluteUri.AbsolutePath);
                 case "http":
                 case "https":
-                    return _httpClient.GetStreamAsync(uri).GetAwaiter().GetResult();
-
+                    return _httpClient.GetStreamAsync(absoluteUri).GetAwaiter().GetResult();
                 default:
                     throw new ArgumentException("Unsupported scheme");
             }
         }
 
         public async Task<Stream> LoadAsync(Uri uri)
         {
-            switch (uri.Scheme)
+            var absoluteUri = new Uri(baseUrl, uri);
+
+            switch (absoluteUri.Scheme)
             {
                 case "file":
-                    return File.OpenRead(uri.AbsolutePath);
+                    return File.OpenRead(absoluteUri.AbsolutePath);
                 case "http":
                 case "https":
-                    return await _httpClient.GetStreamAsync(uri);
+                    return await _httpClient.GetStreamAsync(absoluteUri);
                 default:
                     throw new ArgumentException("Unsupported scheme");
             }

diff --git a/src/Microsoft.OpenApi.Readers/V3/OpenApiV3VersionService.cs b/src/Microsoft.OpenApi.Readers/V3/OpenApiV3VersionService.cs
@@ -53,6 +53,8 @@ internal class OpenApiV3VersionService : IOpenApiVersionService
         /// <summary>
         /// Parse the string to a <see cref="OpenApiReference"/> object.
         /// </summary>
+        /// <param name="reference">The URL of the reference</param>
+        /// <param name="type">The type of object refefenced based on the context of the reference</param>
         public OpenApiReference ConvertToOpenApiReference(
             string reference,
             ReferenceType? type)
@@ -95,8 +97,22 @@ public OpenApiReference ConvertToOpenApiReference(
                     // $ref: externalSource.yaml#/Pet
                     if (id.StartsWith("/components/"))
                     {
-                        id = segments[1].Split('/')[3];
-                    } 
+                        var localSegments = segments[1].Split('/');
+                        var referencedType = localSegments[2].GetEnumFromDisplayName<ReferenceType>();
+                        if (type == null)
+                        {
+                            type = referencedType;
+                        } 
+                        else
+                        {
+                            if (type != referencedType)
+                            {
+                                throw new OpenApiException("Referenced type mismatch");
+                            }
+                        }
+                        id = localSegments[3];
+                    }
+
                     return new OpenApiReference
                     {
                         ExternalResource = segments[0],

diff --git a/src/Microsoft.OpenApi.Tool/OpenApiService.cs b/src/Microsoft.OpenApi.Tool/OpenApiService.cs
@@ -5,6 +5,7 @@
 using System.Net;
 using System.Net.Http;
 using System.Text;
+using System.Threading.Tasks;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers;
@@ -29,14 +30,16 @@ public static void ProcessOpenApiDocument(
                 throw new ArgumentNullException("input");
             }
 
-            var stream = GetStream(input);
+            var inputUrl = GetInputUrl(input);
+            var stream = GetStream(inputUrl);
 
             OpenApiDocument document;
 
             var result = new OpenApiStreamReader(new OpenApiReaderSettings
             {
                 ReferenceResolution = resolveExternal == true ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
-                RuleSet = ValidationRuleSet.GetDefaultRuleSet()
+                RuleSet = ValidationRuleSet.GetDefaultRuleSet(),
+                BaseUrl = new Uri(inputUrl.AbsoluteUri)
             }
             ).ReadAsync(stream).GetAwaiter().GetResult();
 
@@ -91,10 +94,22 @@ public static void ProcessOpenApiDocument(
             }
         }
 
-        private static Stream GetStream(string input)
+        private static Uri GetInputUrl(string input)
         {
-            Stream stream;
             if (input.StartsWith("http"))
+            {
+                return new Uri(input);
+            } 
+            else
+            {
+                return new Uri("file://" + Path.GetFullPath(input));
+            }
+        }
+
+        private static Stream GetStream(Uri input)
+        {
+            Stream stream;
+            if (input.Scheme == "http" || input.Scheme == "https")
             {
                 var httpClient = new HttpClient(new HttpClientHandler()
                 {
@@ -105,32 +120,40 @@ private static Stream GetStream(string input)
                 };
                 stream = httpClient.GetStreamAsync(input).Result;
             }
-            else
+            else if (input.Scheme == "file")
             {
-                var fileInput = new FileInfo(input);
+                var fileInput = new FileInfo(input.AbsolutePath);
                 stream = fileInput.OpenRead();
+            } 
+            else
+            {
+                throw new ArgumentException("Unrecognized exception");
             }
 
             return stream;
         }
 
-        internal static void ValidateOpenApiDocument(string input)
+        internal static async Task ValidateOpenApiDocument(string input, bool resolveExternal)
         {
             if (input == null)
             {
                 throw new ArgumentNullException("input");
             }
-
-            var stream = GetStream(input);
+            var inputUrl = GetInputUrl(input);
+            var stream = GetStream(GetInputUrl(input));
 
             OpenApiDocument document;
 
-            document = new OpenApiStreamReader(new OpenApiReaderSettings
+            var result = await new OpenApiStreamReader(new OpenApiReaderSettings
             {
-                //ReferenceResolution = resolveExternal == true ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
-                RuleSet = ValidationRuleSet.GetDefaultRuleSet()
+                ReferenceResolution = resolveExternal == true ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
+                RuleSet = ValidationRuleSet.GetDefaultRuleSet(),
+                BaseUrl = new Uri(inputUrl.AbsoluteUri)
             }
-            ).Read(stream, out var context);
+            ).ReadAsync(stream);
+
+            document = result.OpenApiDocument;
+            var context = result.OpenApiDiagnostic;
 
             if (context.Errors.Count != 0)
             {
@@ -140,11 +163,25 @@ internal static void ValidateOpenApiDocument(string input)
                 }
             }
 
-            var statsVisitor = new StatsVisitor();
-            var walker = new OpenApiWalker(statsVisitor);
-            walker.Walk(document);
+            if (document.Workspace == null) { 
+                var statsVisitor = new StatsVisitor();
+                var walker = new OpenApiWalker(statsVisitor);
+                walker.Walk(document);
+                Console.WriteLine(statsVisitor.GetStatisticsReport());
+            } 
+            else
+            {
+                foreach (var memberDocument in document.Workspace.Documents)
+                {
+                    Console.WriteLine("Stats for " + memberDocument.Info.Title);
+                    var statsVisitor = new StatsVisitor();
+                    var walker = new OpenApiWalker(statsVisitor);
+                    walker.Walk(memberDocument);
+                    Console.WriteLine(statsVisitor.GetStatisticsReport());
+                }
+            }
 
-            Console.WriteLine(statsVisitor.GetStatisticsReport());
+
         }
     }
 }
diff --git a/src/Microsoft.OpenApi.Tool/Program.cs b/src/Microsoft.OpenApi.Tool/Program.cs
@@ -36,9 +36,10 @@ static async Task<int> Main(string[] args)
 
             var validateCommand = new Command("validate")
             {
-                new Option("--input", "Input OpenAPI description file path or URL", typeof(string) )
+                new Option("--input", "Input OpenAPI description file path or URL", typeof(string) ),
+                new Option("--resolveExternal","Resolve external $refs", typeof(bool))
             };
-            validateCommand.Handler = CommandHandler.Create<string>(OpenApiService.ValidateOpenApiDocument);
+            validateCommand.Handler = CommandHandler.Create<string,bool>(OpenApiService.ValidateOpenApiDocument);
 
             var transformCommand = new Command("transform")
             {

diff --git a/src/Microsoft.OpenApi/Models/OpenApiReference.cs b/src/Microsoft.OpenApi/Models/OpenApiReference.cs
@@ -54,7 +54,7 @@ public string ReferenceV3
             {
                 if (IsExternal)
                 {
-                    return GetExternalReference();
+                    return GetExternalReferenceV3();
                 }
 
                 if (!Type.HasValue)
@@ -85,7 +85,7 @@ public string ReferenceV2
             {
                 if (IsExternal)
                 {
-                    return GetExternalReference();
+                    return GetExternalReferenceV2();
                 }
 
                 if (!Type.HasValue)
@@ -171,11 +171,21 @@ public void SerializeAsV2(IOpenApiWriter writer)
             writer.WriteEndObject();
         }
 
-        private string GetExternalReference()
+        private string GetExternalReferenceV3()
         {
             if (Id != null)
             {
-                return ExternalResource + "#/" + Id;
+                    return ExternalResource + "#/components/" + Type.GetDisplayName() + "/"+ Id;
+            }
+
+            return ExternalResource;
+        }
+
+        private string GetExternalReferenceV2()
+        {
+            if (Id != null)
+            {
+                return ExternalResource + "#/" + GetReferenceTypeNameAsV2((ReferenceType)Type) + "/" + Id;
             }
 
             return ExternalResource;

diff --git a/test/Microsoft.OpenApi.Readers.Tests/OpenApiWorkspaceTests/OpenApiWorkspaceStreamTests.cs b/test/Microsoft.OpenApi.Readers.Tests/OpenApiWorkspaceTests/OpenApiWorkspaceStreamTests.cs
@@ -19,7 +19,7 @@ public class OpenApiWorkspaceStreamTests
         // Use OpenApiWorkspace to load a document and a referenced document
 
         [Fact]
-        public async Task LoadDocumentIntoWorkspace()
+        public async Task LoadingDocumentWithResolveAllReferencesShouldLoadDocumentIntoWorkspace()
         {
             // Create a reader that will resolve all references
             var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
@@ -48,7 +48,7 @@ public async Task LoadDocumentIntoWorkspace()
 
 
         [Fact]
-        public async Task LoadTodoDocumentIntoWorkspace()
+        public async Task LoadDocumentWithExternalReferenceShouldLoadBothDocumentsIntoWorkspace()
         {
             // Create a reader that will resolve all references
             var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
@@ -65,6 +65,7 @@ public async Task LoadTodoDocumentIntoWorkspace()
 
             Assert.NotNull(result.OpenApiDocument.Workspace);
             Assert.True(result.OpenApiDocument.Workspace.Contains("TodoComponents.yaml"));
+
             var referencedSchema = result.OpenApiDocument
                                             .Paths["/todos"]
                                             .Operations[OperationType.Get]