Fixed location normalization

darrelmiller · darrelmiller · commit f64e23e89ea7 · 2018-10-29T09:23:17.000-04:00
diff --git a/src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs b/src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs
@@ -45,35 +45,102 @@ public IEnumerable<OpenApiDocument> Documents {
         /// </summary>
         public IEnumerable<Stream> Artifacts { get; }
 
+        /// <summary>
+        /// Initialize workspace pointing to a base URL to allow resolving relative document locations.  Use a file:// url to point to a folder
+        /// </summary>
+        /// <param name="baseUrl"></param>
+        public OpenApiWorkspace(Uri baseUrl)
+        {
+            BaseUrl = baseUrl;
+        }
+
+        /// <summary>
+        /// Initialize workspace using current directory as the default location.
+        /// </summary>
+        public OpenApiWorkspace()
+        {
+            BaseUrl = new Uri("file://" + Environment.CurrentDirectory + "\\" );
+        }
+
+        /// <summary>
+        /// Verify if workspace contains a document based on its URL. 
+        /// </summary>
+        /// <param name="location">A relative or absolute URL of the file.  Use file:// for folder locations.</param>
+        /// <returns>Returns true if a matching document is found.</returns>
         public bool Contains(string location)
         {
-            return _documents.ContainsKey(ToLocationUrl(location));
+            Uri key = ToLocationUrl(location);
+            return _documents.ContainsKey(key) || _fragments.ContainsKey(key) || _artifacts.ContainsKey(key);
         }
 
+        /// <summary>
+        /// Add an OpenApiDocument to the workspace.
+        /// </summary>
+        /// <param name="location"></param>
+        /// <param name="document"></param>
         public void AddDocument(string location, OpenApiDocument  document)
         {
             document.Workspace = this;
             _documents.Add(ToLocationUrl(location), document);
         }
 
-        public void AddFragment(string location, IOpenApiElement fragment)
+        /// <summary>
+        /// Adds a fragment of an OpenApiDocument to the workspace.
+        /// </summary>
+        /// <param name="location"></param>
+        /// <param name="fragment"></param>
+        /// <remarks>Not sure how this is going to work.  Does the reference just point to the fragment as a whole, or do we need to 
+        /// to be able to point into the fragment.  Keeping it private until we figure it out.
+        /// </remarks>
+        private void AddFragment(string location, IOpenApiElement fragment)
         {
             _fragments.Add(ToLocationUrl(location), fragment);
         }
 
+        /// <summary>
+        /// Add a stream based artificat to the workspace.  Useful for images, examples, alternative schemas.
+        /// </summary>
+        /// <param name="location"></param>
+        /// <param name="artifact"></param>
         public void AddArtifact(string location, Stream artifact)
         {
             _artifacts.Add(ToLocationUrl(location), artifact);
         }
 
+        /// <summary>
+        /// Returns the target of an OpenApiReference from within the workspace.
+        /// </summary>
+        /// <param name="reference">An instance of an OpenApiReference</param>
+        /// <returns></returns>
         public IOpenApiReferenceable ResolveReference(OpenApiReference reference)
         {
-            if (!_documents.TryGetValue(new Uri(reference.ExternalResource,UriKind.RelativeOrAbsolute),out var doc))
+            if (_documents.TryGetValue(new Uri(BaseUrl,reference.ExternalResource),out var doc))
             {
-                return null;
+                return doc.ResolveReference(reference, true); 
             }
-            
-            return doc.ResolveReference(reference,true);
+            else if (_fragments.TryGetValue(new Uri(BaseUrl, reference.ExternalResource), out var fragment))
+            {
+                var frag = fragment as IOpenApiReferenceable;
+                if (frag != null)
+                {
+                    return null; // frag.ResolveReference(reference, true); // IOpenApiElement needs to implement ResolveReference
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="location"></param>
+        /// <returns></returns>
+        public Stream GetArtifact(string location)
+        {
+            return _artifacts[ToLocationUrl(location)];
         }
 
         private Uri ToLocationUrl(string location)
diff --git a/test/Microsoft.OpenApi.SmokeTests/GraphTests.cs b/test/Microsoft.OpenApi.SmokeTests/GraphTests.cs
@@ -0,0 +1,70 @@
+﻿using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+using Microsoft.OpenApi.Services;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.OpenApi.SmokeTests
+{
+    public class GraphTests
+    {
+        OpenApiDocument _graphOpenApi;
+        HttpClient _httpClient;
+        private readonly ITestOutputHelper _output;
+        const string graphOpenApiUrl = "https://github.com/microsoftgraph/microsoft-graph-openapi/blob/master/v1.0.json?raw=true";
+
+        public GraphTests(ITestOutputHelper output)
+        {
+            _output = output;
+            System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
+            _httpClient = new HttpClient(new HttpClientHandler()
+            {                AutomaticDecompression = DecompressionMethods.GZip
+            });
+            _httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new System.Net.Http.Headers.StringWithQualityHeaderValue("gzip"));
+            _httpClient.DefaultRequestHeaders.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue("OpenApi.Net.Tests", "1.0"));
+
+            var response = _httpClient.GetAsync(graphOpenApiUrl)
+                                .GetAwaiter().GetResult();
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _output.WriteLine($"Couldn't load graph openapi");
+                return;
+            }
+
+            var stream = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult(); ;
+
+            var reader = new OpenApiStreamReader();
+            _graphOpenApi = reader.Read(stream, out var diagnostic);
+
+            if (diagnostic.Errors.Count > 0)
+            {
+                _output.WriteLine($"Errors parsing");
+                _output.WriteLine(String.Join("\n", diagnostic.Errors));
+                //               Assert.True(false);  // Uncomment to identify descriptions with errors.
+            }
+
+
+        }
+
+        [Fact]
+        public void LoadOpen()
+        {
+            var operations = new[] { "foo","bar" };
+            var workspace = new OpenApiWorkspace();
+            workspace.AddDocument(graphOpenApiUrl, _graphOpenApi);
+            var subset = new OpenApiDocument();
+            workspace.AddDocument("subset", subset);
+            subset.
+
+            Assert.NotNull(_graphOpenApi);
+        }
+    }
+}
diff --git a/test/Microsoft.OpenApi.Tests/Workspaces/OpenApiWorkspaceTests.cs b/test/Microsoft.OpenApi.Tests/Workspaces/OpenApiWorkspaceTests.cs
@@ -125,34 +125,25 @@ public void OpenApiWorkspacesAllowDocumentsToReferenceEachOther_short()
             });
 
             workspace.AddDocument("root", doc);
-
             workspace.AddDocument("common", CreateCommonDocument());
-
             doc.ResolveReferences(true);
 
             var schema = doc.Paths["/"].Operations[OperationType.Get].Responses["200"].Content["application/json"].Schema;
             Assert.False(schema.UnresolvedReference);
         }
 
-
         [Fact]
         public void OpenApiWorkspacesShouldNormalizeDocumentLocations()
         {
-            // what does normalize mean?
-            // If we use Urls as locators then normalization happens automatically.
-
-            // How do we set a base location for a workspace?
-                // A base could be a folder.  Should we use file://
-                // A base could be a root url
-                // Are absolute locations allowed?
-                // Can a base URI change once a workspace has been created?
-                // What should be the default base URL?
-            // Can we infer it from a root document?
-                // Is the root document the first document loaded?
-                // Can we load multiple APIs into a Workspace?  Does root document make sense?
-            // What data type should "location" really be?  Is it a Uri?
-                //             
-            Assert.True(false);
+            var workspace = new OpenApiWorkspace();
+            workspace.AddDocument("hello", new OpenApiDocument());
+            workspace.AddDocument("hi", new OpenApiDocument());
+
+            Assert.True(workspace.Contains("./hello"));
+            Assert.True(workspace.Contains("./foo/../hello"));
+            Assert.True(workspace.Contains("file://" + Environment.CurrentDirectory + "/./foo/../hello"));
+
+            Assert.False(workspace.Contains("./goodbye"));
         }
 
         // Enable Workspace to load from any reader, not just streams.
@@ -163,6 +154,7 @@ public void OpenApiWorkspacesShouldLoadDocumentFragments()
             Assert.True(false);
         }
 
+
         // Test artifacts
 
         private static OpenApiDocument CreateCommonDocument()
@@ -182,9 +174,6 @@ private static OpenApiDocument CreateCommonDocument()
         }
     }
 
-
-
-
     public static class OpenApiFactoryExtensions {
 
     public static OpenApiDocument CreatePathItem(this OpenApiDocument document, string path, Action<OpenApiPathItem> config)
