Merge pull request #8 from microsoft/feature/vnd-types

- adds support for vendor specific content types

Author: baywet

CHANGELOG.md

@@ -11,6 +11,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+## [1.0.0-preview.2] - 2022-03-29
+
+### Added
+
+- Added support for vendor specific serialization in registries
+
 ## [1.0.0-preview.1] - 2022-03-18
 
 ### Added

Microsoft.Kiota.Abstractions.Tests/Serialization/ParseNodeFactoryRegistryTests.cs

@@ -39,6 +39,22 @@ public void ReturnsExpectedRootNodeForRegisteredContentType()
             Assert.NotNull(rootParseNode);
             Assert.Equal(mockParseNode.Object, rootParseNode);
         }
+        [Fact]
+        public void ReturnsExpectedRootNodeForVendorSpecificContentType()
+        {
+            // Arrange
+            var applicationJsonContentType = "application/json";
+            using var testStream = new MemoryStream(Encoding.UTF8.GetBytes("{\"test\": \"input\"}"));
+            var mockParseNodeFactory = new Mock<IParseNodeFactory>();
+            var mockParseNode = new Mock<IParseNode>();
+            mockParseNodeFactory.Setup(parseNodeFactory => parseNodeFactory.GetRootParseNode(applicationJsonContentType, It.IsAny<Stream>())).Returns(mockParseNode.Object);
+            _parseNodeFactoryRegistry.ContentTypeAssociatedFactories.Add(applicationJsonContentType, mockParseNodeFactory.Object);
+            // Act
+            var rootParseNode = _parseNodeFactoryRegistry.GetRootParseNode("application/vnd+json", testStream);
+            // Assert
+            Assert.NotNull(rootParseNode);
+            Assert.Equal(mockParseNode.Object, rootParseNode);
+        }
 
         [Fact]
         public void ThrowsInvalidOperationExceptionForUnregisteredContentType()

Microsoft.Kiota.Abstractions.Tests/Serialization/SerializationWriterFactoryRegistryTests.cs

@@ -38,6 +38,21 @@ public void ReturnsExpectedRootNodeForRegisteredContentType()
             Assert.NotNull(serializationWriter);
             Assert.Equal(mockSerializationWriter.Object, serializationWriter);
         }
+        [Fact]
+        public void ReturnsExpectedSerializationWriterForVendorSpecificContentTyp()
+        {
+            // Arrange
+            var applicationJsonContentType = "application/json";
+            var mockSerializationWriterFactory = new Mock<ISerializationWriterFactory>();
+            var mockSerializationWriter = new Mock<ISerializationWriter>();
+            mockSerializationWriterFactory.Setup(serializationWriterFactory => serializationWriterFactory.GetSerializationWriter(applicationJsonContentType)).Returns(mockSerializationWriter.Object);
+            _serializationWriterFactoryRegistry.ContentTypeAssociatedFactories.Add(applicationJsonContentType, mockSerializationWriterFactory.Object);
+            // Act
+            var serializationWriter = _serializationWriterFactoryRegistry.GetSerializationWriter("application/vnd+json");
+            // Assert
+            Assert.NotNull(serializationWriter);
+            Assert.Equal(mockSerializationWriter.Object, serializationWriter);
+        }
 
         [Fact]
         public void ThrowsInvalidOperationExceptionForUnregisteredContentType()

src/Microsoft.Kiota.Abstractions.csproj

@@ -14,7 +14,7 @@
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
     <Deterministic>true</Deterministic>
     <VersionPrefix>1.0.0</VersionPrefix>
-    <VersionSuffix>preview.1</VersionSuffix>
+    <VersionSuffix>preview.2</VersionSuffix>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <SignAssembly>false</SignAssembly>
     <DelaySign>false</DelaySign>
@@ -23,7 +23,7 @@
     <!-- Enable this line once we go live to prevent breaking changes -->
     <!-- <PackageValidationBaselineVersion>1.0.0</PackageValidationBaselineVersion> -->
     <PackageReleaseNotes>
-        - Initial release
+        - Adds support for vendor specific serialization in registries
     </PackageReleaseNotes>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>

src/serialization/ParseNodeFactoryRegistry.cs

@@ -5,6 +5,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace Microsoft.Kiota.Abstractions.Serialization
 {
@@ -24,13 +26,14 @@ public string ValidContentType
             }
         }
         /// <summary>
-        /// Default singleton instance of the registry to be used when registring new factories that should be available by default.
+        /// Default singleton instance of the registry to be used when registering new factories that should be available by default.
         /// </summary>
         public static readonly ParseNodeFactoryRegistry DefaultInstance = new();
         /// <summary>
         /// List of factories that are registered by content type.
         /// </summary>
         public Dictionary<string, IParseNodeFactory> ContentTypeAssociatedFactories { get; set; } = new Dictionary<string, IParseNodeFactory>();
+        internal static readonly Regex contentTypeVendorCleanupRegex = new(@"[^/]+\+", RegexOptions.Compiled);
         /// <summary>
         /// Get the <see cref="IParseNode"/> instance that is the root of the content
         /// </summary>
@@ -43,10 +46,15 @@ public IParseNode GetRootParseNode(string contentType, Stream content)
                 throw new ArgumentNullException(nameof(contentType));
             _ = content ?? throw new ArgumentNullException(nameof(content));
 
-            if(ContentTypeAssociatedFactories.ContainsKey(contentType))
-                return ContentTypeAssociatedFactories[contentType].GetRootParseNode(contentType, content);
-            else
-                throw new InvalidOperationException($"Content type {contentType} does not have a factory registered to be parsed");
+            var vendorSpecificContentType = contentType.Split(";", StringSplitOptions.RemoveEmptyEntries).First();
+            if(ContentTypeAssociatedFactories.ContainsKey(vendorSpecificContentType))
+                return ContentTypeAssociatedFactories[vendorSpecificContentType].GetRootParseNode(vendorSpecificContentType, content);
+
+            var cleanedContentType = contentTypeVendorCleanupRegex.Replace(vendorSpecificContentType, string.Empty);
+            if(ContentTypeAssociatedFactories.ContainsKey(cleanedContentType))
+                return ContentTypeAssociatedFactories[cleanedContentType].GetRootParseNode(cleanedContentType, content);
+            
+            throw new InvalidOperationException($"Content type {cleanedContentType} does not have a factory registered to be parsed");
         }
     }
 }

src/serialization/SerializationWriterFactoryRegistry.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Microsoft.Kiota.Abstractions.Serialization
 {
@@ -23,7 +24,7 @@ public string ValidContentType
             }
         }
         /// <summary>
-        /// Default singleton instance of the registry to be used when registring new factories that should be available by default.
+        /// Default singleton instance of the registry to be used when registering new factories that should be available by default.
         /// </summary>
         public static readonly SerializationWriterFactoryRegistry DefaultInstance = new();
         /// <summary>
@@ -40,10 +41,15 @@ public ISerializationWriter GetSerializationWriter(string contentType)
             if(string.IsNullOrEmpty(contentType))
                 throw new ArgumentNullException(nameof(contentType));
 
-            if(ContentTypeAssociatedFactories.ContainsKey(contentType))
-                return ContentTypeAssociatedFactories[contentType].GetSerializationWriter(contentType);
-            else
-                throw new InvalidOperationException($"Content type {contentType} does not have a factory registered to be parsed");
+            var vendorSpecificContentType = contentType.Split(";", StringSplitOptions.RemoveEmptyEntries).First();
+            if(ContentTypeAssociatedFactories.ContainsKey(vendorSpecificContentType))
+                return ContentTypeAssociatedFactories[vendorSpecificContentType].GetSerializationWriter(vendorSpecificContentType);
+            
+            var cleanedContentType = ParseNodeFactoryRegistry.contentTypeVendorCleanupRegex.Replace(vendorSpecificContentType, string.Empty);
+            if(ContentTypeAssociatedFactories.ContainsKey(cleanedContentType))
+                return ContentTypeAssociatedFactories[cleanedContentType].GetSerializationWriter(cleanedContentType);
+
+            throw new InvalidOperationException($"Content type {cleanedContentType} does not have a factory registered to be parsed");
         }
 
     }