Change IOpenApiReferenceable.ResolveReference method to using the JsonPointer class rather than a string for the JSON pointer argument

simon-pearson-lmk · simon-pearson-lmk · commit dda0fe4de39b · 2020-11-13T18:38:19.000Z
diff --git a/src/Microsoft.OpenApi/Extensions/OpenApiReferencableExtensions.cs b/src/Microsoft.OpenApi/Extensions/OpenApiReferencableExtensions.cs
@@ -16,51 +16,46 @@ namespace Microsoft.OpenApi.Extensions
     public static class OpenApiReferencableExtensions
     {
         /// <summary>
-        /// TODO: tmpDbg comment
+        /// Resolves a JSON Pointer with respect to an element, returning the referenced element.
         /// </summary>
         /// <param name="element">The referencable Open API element on which to apply the JSON pointer</param>
-        /// <param name="jsonPointer">a JSON Pointer [RFC 6901](https://tools.ietf.org/html/rfc6901).</param>
+        /// <param name="pointer">a JSON Pointer [RFC 6901](https://tools.ietf.org/html/rfc6901).</param>
         /// <returns>The element pointed to by the JSON pointer.</returns>
-        public static IOpenApiReferenceable ResolveReference(this IOpenApiReferenceable element, string jsonPointer)
+        public static IOpenApiReferenceable ResolveReference(this IOpenApiReferenceable element, JsonPointer pointer)
         {
-            if (jsonPointer == "/")
+            if (!pointer.Tokens.Any())
             {
                 return element;
             }
-            if (string.IsNullOrEmpty(jsonPointer))
-            {
-                throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));
-            }
-            var jsonPointerTokens = jsonPointer.Split('/');
-            var propertyName = jsonPointerTokens.ElementAtOrDefault(1);
-            var mapKey = jsonPointerTokens.ElementAtOrDefault(2);
+            var propertyName = pointer.Tokens.FirstOrDefault();
+            var mapKey = pointer.Tokens.ElementAtOrDefault(1);
             try
             {
                 if (element.GetType() == typeof(OpenApiHeader))
                 {
-                    return ResolveReferenceOnHeaderElement((OpenApiHeader)element, propertyName, mapKey, jsonPointer);
+                    return ResolveReferenceOnHeaderElement((OpenApiHeader)element, propertyName, mapKey, pointer);
                 }
                 if (element.GetType() == typeof(OpenApiParameter))
                 {
-                    return ResolveReferenceOnParameterElement((OpenApiParameter)element, propertyName, mapKey, jsonPointer);
+                    return ResolveReferenceOnParameterElement((OpenApiParameter)element, propertyName, mapKey, pointer);
                 }
                 if (element.GetType() == typeof(OpenApiResponse))
                 {
-                    return ResolveReferenceOnResponseElement((OpenApiResponse)element, propertyName, mapKey, jsonPointer);
+                    return ResolveReferenceOnResponseElement((OpenApiResponse)element, propertyName, mapKey, pointer);
                 }
             }
             catch (KeyNotFoundException)
             {
-                throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));
+                throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));
             }
-            throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));
+            throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));
         }
 
         private static IOpenApiReferenceable ResolveReferenceOnHeaderElement(
             OpenApiHeader headerElement,
             string propertyName,
             string mapKey,
-            string jsonPointer)
+            JsonPointer pointer)
         {
             switch (propertyName)
             {
@@ -69,15 +64,15 @@ private static IOpenApiReferenceable ResolveReferenceOnHeaderElement(
                 case OpenApiConstants.Examples when mapKey != null:
                     return headerElement.Examples[mapKey];
                 default:
-                    throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));
+                    throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));
             }
         }
 
         private static IOpenApiReferenceable ResolveReferenceOnParameterElement(
             OpenApiParameter parameterElement,
             string propertyName,
             string mapKey,
-            string jsonPointer)
+            JsonPointer pointer)
         {
             switch (propertyName)
             {
@@ -86,15 +81,15 @@ private static IOpenApiReferenceable ResolveReferenceOnParameterElement(
                 case OpenApiConstants.Examples when mapKey != null:
                     return parameterElement.Examples[mapKey];
                 default:
-                    throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));
+                    throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));
             }
         }
 
         private static IOpenApiReferenceable ResolveReferenceOnResponseElement(
             OpenApiResponse responseElement,
             string propertyName,
             string mapKey,
-            string jsonPointer)
+            JsonPointer pointer)
         {
             switch (propertyName)
             {
@@ -103,7 +98,7 @@ private static IOpenApiReferenceable ResolveReferenceOnResponseElement(
                 case OpenApiConstants.Links when mapKey != null:
                     return responseElement.Links[mapKey];
                 default:
-                    throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));
+                    throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));
             }
         }
     }
diff --git a/src/Microsoft.OpenApi/JsonPointer.cs b/src/Microsoft.OpenApi/JsonPointer.cs
@@ -17,7 +17,9 @@ public class JsonPointer
         /// <param name="pointer">Pointer as string.</param>
         public JsonPointer(string pointer)
         {
-            Tokens = pointer.Split('/').Skip(1).Select(Decode).ToArray();
+            Tokens = string.IsNullOrEmpty(pointer) || pointer == "/"
+                ? new string[0]
+                : pointer.Split('/').Skip(1).Select(Decode).ToArray();
         }
 
         /// <summary>
diff --git a/src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs b/src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs
@@ -121,7 +121,7 @@ public IOpenApiReferenceable ResolveReference(OpenApiReference reference)
             }
             else if (_fragments.TryGetValue(new Uri(BaseUrl, reference.ExternalResource), out var fragment))
             {
-                var jsonPointer = $"/{reference.Id ?? string.Empty}";
+                var jsonPointer = new JsonPointer($"/{reference.Id ?? string.Empty}");
                 return fragment.ResolveReference(jsonPointer);
             }
             return null;
diff --git a/test/Microsoft.OpenApi.Tests/Workspaces/OpenApiReferencableTests.cs b/test/Microsoft.OpenApi.Tests/Workspaces/OpenApiReferencableTests.cs
@@ -68,7 +68,7 @@ public class OpenApiReferencableTests
             new object[] { _responseFragment, "/links/link1", _responseFragment.Links["link1"] },
             new object[] { _schemaFragment, "/", _schemaFragment},
             new object[] { _securitySchemeFragment, "/", _securitySchemeFragment},
-            new object[] { _tagFragment, "/", _tagFragment},
+            new object[] { _tagFragment, "/", _tagFragment}
         };
 
         [Theory]
@@ -79,7 +79,7 @@ public void ResolveReferenceCanResolveValidJsonPointers(
             IOpenApiElement expectedResolvedElement)
         {
             // Act
-            var actualResolvedElement = element.ResolveReference(jsonPointer);
+            var actualResolvedElement = element.ResolveReference(new JsonPointer(jsonPointer));
 
             // Assert
             Assert.Same(expectedResolvedElement, actualResolvedElement);
@@ -88,30 +88,22 @@ public void ResolveReferenceCanResolveValidJsonPointers(
         public static IEnumerable<object[]> ResolveReferenceShouldThrowOnInvalidReferenceIdTestData =>
         new List<object[]>
         {
-            new object[] { _callbackFragment, null },
-            new object[] { _callbackFragment, "" },
             new object[] { _callbackFragment, "/a" },
-            new object[] { _headerFragment, null },
-            new object[] { _headerFragment, "" },
             new object[] { _headerFragment, "/a" },
             new object[] { _headerFragment, "/examples" },
             new object[] { _headerFragment, "/examples/" },
             new object[] { _headerFragment, "/examples/a" },
-            new object[] { _parameterFragment, null },
-            new object[] { _parameterFragment, "" },
             new object[] { _parameterFragment, "/a" },
             new object[] { _parameterFragment, "/examples" },
             new object[] { _parameterFragment, "/examples/" },
             new object[] { _parameterFragment, "/examples/a" },
-            new object[] { _responseFragment, null },
-            new object[] { _responseFragment, "" },
             new object[] { _responseFragment, "/a" },
             new object[] { _responseFragment, "/headers" },
             new object[] { _responseFragment, "/headers/" },
             new object[] { _responseFragment, "/headers/a" },
             new object[] { _responseFragment, "/content" },
             new object[] { _responseFragment, "/content/" },
-            new object[] { _responseFragment, "/content/a" },
+            new object[] { _responseFragment, "/content/a" }
 
         };
 
@@ -120,7 +112,7 @@ public void ResolveReferenceCanResolveValidJsonPointers(
         public void ResolveReferenceShouldThrowOnInvalidReferenceId(IOpenApiReferenceable element, string jsonPointer)
         {
             // Act
-            Action resolveReference = () => element.ResolveReference(jsonPointer);
+            Action resolveReference = () => element.ResolveReference(new JsonPointer(jsonPointer));
 
             // Assert
             var exception = Assert.Throws<OpenApiException>(resolveReference);

Original file line number	Diff line number	Diff line change
`@@ -16,51 +16,46 @@ namespace Microsoft.OpenApi.Extensions`
`16`	`16`	`public static class OpenApiReferencableExtensions`
`17`	`17`	`{`
`18`	`18`	`/// <summary>`
`19`		`- /// TODO: tmpDbg comment`
	`19`	`+ /// Resolves a JSON Pointer with respect to an element, returning the referenced element.`
`20`	`20`	`/// </summary>`
`21`	`21`	`/// <param name="element">The referencable Open API element on which to apply the JSON pointer</param>`
`22`		`- /// <param name="jsonPointer">a JSON Pointer [RFC 6901](https://tools.ietf.org/html/rfc6901).</param>`
	`22`	`+ /// <param name="pointer">a JSON Pointer [RFC 6901](https://tools.ietf.org/html/rfc6901).</param>`
`23`	`23`	`/// <returns>The element pointed to by the JSON pointer.</returns>`
`24`		`- public static IOpenApiReferenceable ResolveReference(this IOpenApiReferenceable element, string jsonPointer)`
	`24`	`+ public static IOpenApiReferenceable ResolveReference(this IOpenApiReferenceable element, JsonPointer pointer)`
`25`	`25`	`{`
`26`		`- if (jsonPointer == "/")`
	`26`	`+ if (!pointer.Tokens.Any())`
`27`	`27`	`{`
`28`	`28`	`return element;`
`29`	`29`	`}`
`30`		`- if (string.IsNullOrEmpty(jsonPointer))`
`31`		`- {`
`32`		`- throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));`
`33`		`- }`
`34`		`- var jsonPointerTokens = jsonPointer.Split('/');`
`35`		`- var propertyName = jsonPointerTokens.ElementAtOrDefault(1);`
`36`		`- var mapKey = jsonPointerTokens.ElementAtOrDefault(2);`
	`30`	`+ var propertyName = pointer.Tokens.FirstOrDefault();`
	`31`	`+ var mapKey = pointer.Tokens.ElementAtOrDefault(1);`
`37`	`32`	`try`
`38`	`33`	`{`
`39`	`34`	`if (element.GetType() == typeof(OpenApiHeader))`
`40`	`35`	`{`
`41`		`- return ResolveReferenceOnHeaderElement((OpenApiHeader)element, propertyName, mapKey, jsonPointer);`
	`36`	`+ return ResolveReferenceOnHeaderElement((OpenApiHeader)element, propertyName, mapKey, pointer);`
`42`	`37`	`}`
`43`	`38`	`if (element.GetType() == typeof(OpenApiParameter))`
`44`	`39`	`{`
`45`		`- return ResolveReferenceOnParameterElement((OpenApiParameter)element, propertyName, mapKey, jsonPointer);`
	`40`	`+ return ResolveReferenceOnParameterElement((OpenApiParameter)element, propertyName, mapKey, pointer);`
`46`	`41`	`}`
`47`	`42`	`if (element.GetType() == typeof(OpenApiResponse))`
`48`	`43`	`{`
`49`		`- return ResolveReferenceOnResponseElement((OpenApiResponse)element, propertyName, mapKey, jsonPointer);`
	`44`	`+ return ResolveReferenceOnResponseElement((OpenApiResponse)element, propertyName, mapKey, pointer);`
`50`	`45`	`}`
`51`	`46`	`}`
`52`	`47`	`catch (KeyNotFoundException)`
`53`	`48`	`{`
`54`		`- throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));`
	`49`	`+ throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));`
`55`	`50`	`}`
`56`		`- throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));`
	`51`	`+ throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));`
`57`	`52`	`}`
`58`	`53`
`59`	`54`	`private static IOpenApiReferenceable ResolveReferenceOnHeaderElement(`
`60`	`55`	`OpenApiHeader headerElement,`
`61`	`56`	`string propertyName,`
`62`	`57`	`string mapKey,`
`63`		`- string jsonPointer)`
	`58`	`+ JsonPointer pointer)`
`64`	`59`	`{`
`65`	`60`	`switch (propertyName)`
`66`	`61`	`{`
`@@ -69,15 +64,15 @@ private static IOpenApiReferenceable ResolveReferenceOnHeaderElement(`
`69`	`64`	`case OpenApiConstants.Examples when mapKey != null:`
`70`	`65`	`return headerElement.Examples[mapKey];`
`71`	`66`	`default:`
`72`		`- throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));`
	`67`	`+ throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));`
`73`	`68`	`}`
`74`	`69`	`}`
`75`	`70`
`76`	`71`	`private static IOpenApiReferenceable ResolveReferenceOnParameterElement(`
`77`	`72`	`OpenApiParameter parameterElement,`
`78`	`73`	`string propertyName,`
`79`	`74`	`string mapKey,`
`80`		`- string jsonPointer)`
	`75`	`+ JsonPointer pointer)`
`81`	`76`	`{`
`82`	`77`	`switch (propertyName)`
`83`	`78`	`{`
`@@ -86,15 +81,15 @@ private static IOpenApiReferenceable ResolveReferenceOnParameterElement(`
`86`	`81`	`case OpenApiConstants.Examples when mapKey != null:`
`87`	`82`	`return parameterElement.Examples[mapKey];`
`88`	`83`	`default:`
`89`		`- throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));`
	`84`	`+ throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));`
`90`	`85`	`}`
`91`	`86`	`}`
`92`	`87`
`93`	`88`	`private static IOpenApiReferenceable ResolveReferenceOnResponseElement(`
`94`	`89`	`OpenApiResponse responseElement,`
`95`	`90`	`string propertyName,`
`96`	`91`	`string mapKey,`
`97`		`- string jsonPointer)`
	`92`	`+ JsonPointer pointer)`
`98`	`93`	`{`
`99`	`94`	`switch (propertyName)`
`100`	`95`	`{`
`@@ -103,7 +98,7 @@ private static IOpenApiReferenceable ResolveReferenceOnResponseElement(`
`103`	`98`	`case OpenApiConstants.Links when mapKey != null:`
`104`	`99`	`return responseElement.Links[mapKey];`
`105`	`100`	`default:`
`106`		`- throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, jsonPointer));`
	`101`	`+ throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));`
`107`	`102`	`}`
`108`	`103`	`}`
`109`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,9 @@ public class JsonPointer`
`17`	`17`	`/// <param name="pointer">Pointer as string.</param>`
`18`	`18`	`public JsonPointer(string pointer)`
`19`	`19`	`{`
`20`		`- Tokens = pointer.Split('/').Skip(1).Select(Decode).ToArray();`
	`20`	`+ Tokens = string.IsNullOrEmpty(pointer) \|\| pointer == "/"`
	`21`	`+ ? new string[0]`
	`22`	`+ : pointer.Split('/').Skip(1).Select(Decode).ToArray();`
`21`	`23`	`}`
`22`	`24`
`23`	`25`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ public IOpenApiReferenceable ResolveReference(OpenApiReference reference)`
`121`	`121`	`}`
`122`	`122`	`else if (_fragments.TryGetValue(new Uri(BaseUrl, reference.ExternalResource), out var fragment))`
`123`	`123`	`{`
`124`		`- var jsonPointer = $"/{reference.Id ?? string.Empty}";`
	`124`	`+ var jsonPointer = new JsonPointer($"/{reference.Id ?? string.Empty}");`
`125`	`125`	`return fragment.ResolveReference(jsonPointer);`
`126`	`126`	`}`
`127`	`127`	`return null;`