Merge pull request #841 from microsoftgraph/dependabot/nuget/xunit-2.8.1

github-actions[bot] · web-flow · commit 0b109dabb6e9 · 2024-05-28T10:36:36.000+03:00
chore(deps): bump xunit from 2.8.0 to 2.8.1
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,12 @@ and this project does adheres to [Semantic Versioning](https://semver.org/spec/v
 
 ## [Unreleased]
 
+## [3.1.12] - 2024-05-28
+
+### Changed
+
+- Updates the Kiota dependencies to the latest version.
+
 ## [3.1.11] - 2024-04-30
 
 ### Changed
diff --git a/src/Microsoft.Graph.Core/Extensions/IDecryptableContentExtensions.cs b/src/Microsoft.Graph.Core/Extensions/IDecryptableContentExtensions.cs
@@ -37,8 +37,8 @@ public static class IDecryptableContentExtensions
             var stringContent = await encryptedContent.DecryptAsync(certificateProvider).ConfigureAwait(false);
             using var contentStream = new MemoryStream(Encoding.UTF8.GetBytes(stringContent));
             var parseNodeFactory = ParseNodeFactoryRegistry.DefaultInstance;
-            var rootNode = parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, contentStream);
-            return rootNode.GetObjectValue<T>((parsable) => new T()); ;
+            var rootNode = await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, contentStream);
+            return rootNode.GetObjectValue<T>((parsable) => new T());
         }
 
         /// <summary>
diff --git a/src/Microsoft.Graph.Core/Microsoft.Graph.Core.csproj b/src/Microsoft.Graph.Core/Microsoft.Graph.Core.csproj
@@ -20,7 +20,7 @@
     <DelaySign>false</DelaySign>
     <AssemblyOriginatorKeyFile>35MSSharedLib1024.snk</AssemblyOriginatorKeyFile>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <VersionPrefix>3.1.11</VersionPrefix>
+    <VersionPrefix>3.1.12</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <PackageReleaseNotes>
 - https://github.com/microsoftgraph/msgraph-sdk-dotnet-core/blob/dev/CHANGELOG.md
@@ -57,15 +57,15 @@
     </None>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="7.5.1" />
+    <PackageReference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="7.6.0" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.Kiota.Abstractions" Version="1.8.4" />
-    <PackageReference Include="Microsoft.Kiota.Authentication.Azure" Version="1.1.5" />
-    <PackageReference Include="Microsoft.Kiota.Serialization.Json" Version="1.2.3" />
-    <PackageReference Include="Microsoft.Kiota.Serialization.Text" Version="1.1.5" />
-    <PackageReference Include="Microsoft.Kiota.Serialization.Form" Version="1.1.6" />
-    <PackageReference Include="Microsoft.Kiota.Http.HttpClientLibrary" Version="1.4.0" />
-    <PackageReference Include="Microsoft.Kiota.Serialization.Multipart" Version="1.1.4" />
+    <PackageReference Include="Microsoft.Kiota.Abstractions" Version="[1.9.1, 2.0.0)" />
+    <PackageReference Include="Microsoft.Kiota.Authentication.Azure" Version="[1.1.7, 2.0.0)" />
+    <PackageReference Include="Microsoft.Kiota.Serialization.Json" Version="[1.3.3, 2.0.0)" />
+    <PackageReference Include="Microsoft.Kiota.Serialization.Text" Version="[1.2.2, 2.0.0)" />
+    <PackageReference Include="Microsoft.Kiota.Serialization.Form" Version="[1.2.4, 2.0.0)" />
+    <PackageReference Include="Microsoft.Kiota.Http.HttpClientLibrary" Version="[1.4.3, 2.0.0)" />
+    <PackageReference Include="Microsoft.Kiota.Serialization.Multipart" Version="[1.1.5, 2.0.0)" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net462' ">
     <PackageReference Include="System.Net.Http.WinHttpHandler" Version="[6.0,9.0)" />
diff --git a/src/Microsoft.Graph.Core/Requests/AsyncMonitor.cs b/src/Microsoft.Graph.Core/Requests/AsyncMonitor.cs
@@ -24,7 +24,7 @@ namespace Microsoft.Graph
 
         internal string monitorUrl;
 
-        private readonly IParseNodeFactory parseNodeFactory;
+        private readonly IAsyncParseNodeFactory parseNodeFactory;
         /// <summary>
         /// Construct an Async Monitor.
         /// </summary>
@@ -35,7 +35,7 @@ public AsyncMonitor(IBaseClient client, string monitorUrl, IParseNodeFactory par
         {
             this.client = client;
             this.monitorUrl = monitorUrl;
-            this.parseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;
+            this.parseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;
         }
         
         /// <summary>
@@ -59,12 +59,12 @@ public async Task<T> PollForOperationCompletionAsync(IProgress<AsyncOperationSta
                 if (responseMessage.StatusCode != HttpStatusCode.Accepted && responseMessage.IsSuccessStatusCode)
                 {
                     using var responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return responseStream.Length > 0 ? parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, responseStream).GetObjectValue(_ => new T()) : default;
+                    return responseStream.Length > 0 ? (await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, responseStream, cancellationToken)).GetObjectValue(_ => new T()) : default;
                 }
 
                 using (var responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false))
                 {
-                    this.asyncOperationStatus = responseStream.Length > 0 ? parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, responseStream).GetObjectValue(_ => new AsyncOperationStatus()) : null;
+                    this.asyncOperationStatus = responseStream.Length > 0 ? (await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, responseStream, cancellationToken).ConfigureAwait(false)).GetObjectValue(_ => new AsyncOperationStatus()) : null;
 
                     if (this.asyncOperationStatus == null)
                     {
diff --git a/src/Microsoft.Graph.Core/Requests/DeltaResponseHandler.cs b/src/Microsoft.Graph.Core/Requests/DeltaResponseHandler.cs
@@ -29,15 +29,15 @@ namespace Microsoft.Graph
     /// </summary>
     public class DeltaResponseHandler<T> : IResponseHandler where T : IParsable, new()
     {
-        private readonly IParseNodeFactory parseNodeFactory;
+        private readonly IAsyncParseNodeFactory parseNodeFactory;
 
         /// <summary>
         /// Constructs a new <see cref="DeltaResponseHandler{T}"/>.
         /// </summary>
         /// <param name="parseNodeFactory"> The <see cref="IParseNodeFactory"/> to use for response handling</param>
         public DeltaResponseHandler(IParseNodeFactory parseNodeFactory = null)
         {
-            this.parseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;
+            this.parseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;
         }
 
         /// <summary>
@@ -61,7 +61,7 @@ public async Task<ModelType> HandleResponseAsync<NativeResponseType, ModelType>(
                 var responseWithChangeList = await GetResponseBodyWithChangelist(responseString).ConfigureAwait(false);
                 using var responseWithChangeListStream = new MemoryStream(Encoding.UTF8.GetBytes(responseWithChangeList));
 
-                var responseParseNode = parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, responseWithChangeListStream);
+                var responseParseNode = await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, responseWithChangeListStream);
                 return (ModelType)(object)responseParseNode.GetObjectValue<T>((parsable) => new T());
             }
 
diff --git a/src/Microsoft.Graph.Core/Requests/ResponseHandler.cs b/src/Microsoft.Graph.Core/Requests/ResponseHandler.cs
@@ -18,15 +18,15 @@ namespace Microsoft.Graph
     /// </summary>
     public class ResponseHandler<T> : IResponseHandler where T : IParsable,new()
     {
-        private readonly IParseNodeFactory _jsonParseNodeFactory;
+        private readonly IAsyncParseNodeFactory _jsonParseNodeFactory;
 
         /// <summary>
         /// Constructs a new <see cref="ResponseHandler{T}"/>.
         /// </summary>
         /// <param name="parseNodeFactory"> The <see cref="IParseNodeFactory"/> to use for response handling</param>
         public ResponseHandler(IParseNodeFactory parseNodeFactory = null)
         {
-            _jsonParseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance; ;
+            _jsonParseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance; ;
         }
 
         /// <summary>
@@ -43,7 +43,7 @@ public async Task<ModelType> HandleResponseAsync<NativeResponseType, ModelType>(
             {
                 await ValidateSuccessfulResponse(responseMessage, errorMappings).ConfigureAwait(false);
                 using var responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                var jsonParseNode = _jsonParseNodeFactory.GetRootParseNode(responseMessage.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
+                var jsonParseNode = await _jsonParseNodeFactory.GetRootParseNodeAsync(responseMessage.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
                 return (ModelType)(object)jsonParseNode.GetObjectValue<T>((parsable) => new T());
             }
 
@@ -64,7 +64,7 @@ private async Task ValidateSuccessfulResponse(HttpResponseMessage httpResponseMe
             var statusCodeAsInt = (int)httpResponseMessage.StatusCode;
             var statusCodeAsString = statusCodeAsInt.ToString();
             using var responseStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
-            var rootNode = _jsonParseNodeFactory.GetRootParseNode(httpResponseMessage.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
+            var rootNode = await _jsonParseNodeFactory.GetRootParseNodeAsync(httpResponseMessage.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
             ParsableFactory <IParsable> errorFactory;
             if (errorMapping == null ||
                 !errorMapping.TryGetValue(statusCodeAsString, out errorFactory) &&
diff --git a/src/Microsoft.Graph.Core/Requests/Upload/UploadResponseHandler.cs b/src/Microsoft.Graph.Core/Requests/Upload/UploadResponseHandler.cs
@@ -17,15 +17,15 @@ namespace Microsoft.Graph
     /// </summary>
     internal class UploadResponseHandler
     {
-        private readonly IParseNodeFactory _parseNodeFactory;
+        private readonly IAsyncParseNodeFactory _parseNodeFactory;
 
         /// <summary>
         /// Constructs a new <see cref="UploadResponseHandler"/>.
         /// </summary>
         /// <param name="parseNodeFactory"> The <see cref="IParseNodeFactory"/> to use for response handling</param>
         public UploadResponseHandler(IParseNodeFactory parseNodeFactory = null)
         {
-            _parseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;
+            _parseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;
         }
 
         /// <summary>
@@ -63,7 +63,7 @@ public async Task<UploadResult<T>> HandleResponse<T>(HttpResponseMessage respons
                 {
                     if (responseStream.Length > 0) //system.text.json wont deserialize an empty string
                     {
-                        var jsonParseNode = _parseNodeFactory.GetRootParseNode(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
+                        var jsonParseNode = await _parseNodeFactory.GetRootParseNodeAsync(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
                         uploadResult.ItemResponse = jsonParseNode.GetObjectValue<T>((parsable) => new T());
                     }
                     uploadResult.Location = response.Headers.Location;
@@ -76,7 +76,7 @@ public async Task<UploadResult<T>> HandleResponse<T>(HttpResponseMessage respons
                      * However, successful upload completion for a DriveItem the response could also come in a 200 response and
                      * hence we validate this by checking the NextExpectedRanges parameter which is present in an ongoing upload
                      */
-                    var uploadSessionParseNode = _parseNodeFactory.GetRootParseNode(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
+                    var uploadSessionParseNode = await _parseNodeFactory.GetRootParseNodeAsync(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
                     UploadSession uploadSession = uploadSessionParseNode.GetObjectValue<UploadSession>(UploadSession.CreateFromDiscriminatorValue);
                     if (uploadSession?.NextExpectedRanges != null)
                     {
@@ -86,7 +86,7 @@ public async Task<UploadResult<T>> HandleResponse<T>(HttpResponseMessage respons
                     {
                         //Upload is most likely done as DriveItem info may come in a 200 response
                         responseStream.Position = 0; //reset 
-                        var objectParseNode = _parseNodeFactory.GetRootParseNode(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
+                        var objectParseNode = await _parseNodeFactory.GetRootParseNodeAsync(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);
                         uploadResult.ItemResponse = objectParseNode.GetObjectValue<T>((parsable) => new T());
                     }
                 }
diff --git a/tests/Microsoft.Graph.DotnetCore.Core.Test/Microsoft.Graph.DotnetCore.Core.Test.csproj b/tests/Microsoft.Graph.DotnetCore.Core.Test/Microsoft.Graph.DotnetCore.Core.Test.csproj
@@ -25,7 +25,7 @@
     </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
     <PackageReference Include="Moq" Version="4.20.70" />
-    <PackageReference Include="xunit" Version="2.8.0" />
+    <PackageReference Include="xunit" Version="2.8.1" />
     <ProjectReference Include="..\..\src\Microsoft.Graph.Core\Microsoft.Graph.Core.csproj" />
   </ItemGroup>
    <ItemGroup>

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace Microsoft.Graph`
`24`	`24`
`25`	`25`	`internal string monitorUrl;`
`26`	`26`
`27`		`- private readonly IParseNodeFactory parseNodeFactory;`
	`27`	`+ private readonly IAsyncParseNodeFactory parseNodeFactory;`
`28`	`28`	`/// <summary>`
`29`	`29`	`/// Construct an Async Monitor.`
`30`	`30`	`/// </summary>`
`@@ -35,7 +35,7 @@ public AsyncMonitor(IBaseClient client, string monitorUrl, IParseNodeFactory par`
`35`	`35`	`{`
`36`	`36`	`this.client = client;`
`37`	`37`	`this.monitorUrl = monitorUrl;`
`38`		`- this.parseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;`
	`38`	`+ this.parseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`/// <summary>`
`@@ -59,12 +59,12 @@ public async Task<T> PollForOperationCompletionAsync(IProgress<AsyncOperationSta`
`59`	`59`	`if (responseMessage.StatusCode != HttpStatusCode.Accepted && responseMessage.IsSuccessStatusCode)`
`60`	`60`	`{`
`61`	`61`	`using var responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);`
`62`		`- return responseStream.Length > 0 ? parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, responseStream).GetObjectValue(_ => new T()) : default;`
	`62`	`+ return responseStream.Length > 0 ? (await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, responseStream, cancellationToken)).GetObjectValue(_ => new T()) : default;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`using (var responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false))`
`66`	`66`	`{`
`67`		`- this.asyncOperationStatus = responseStream.Length > 0 ? parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, responseStream).GetObjectValue(_ => new AsyncOperationStatus()) : null;`
	`67`	`+ this.asyncOperationStatus = responseStream.Length > 0 ? (await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, responseStream, cancellationToken).ConfigureAwait(false)).GetObjectValue(_ => new AsyncOperationStatus()) : null;`
`68`	`68`
`69`	`69`	`if (this.asyncOperationStatus == null)`
`70`	`70`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,15 +29,15 @@ namespace Microsoft.Graph`
`29`	`29`	`/// </summary>`
`30`	`30`	`public class DeltaResponseHandler<T> : IResponseHandler where T : IParsable, new()`
`31`	`31`	`{`
`32`		`- private readonly IParseNodeFactory parseNodeFactory;`
	`32`	`+ private readonly IAsyncParseNodeFactory parseNodeFactory;`
`33`	`33`
`34`	`34`	`/// <summary>`
`35`	`35`	`/// Constructs a new <see cref="DeltaResponseHandler{T}"/>.`
`36`	`36`	`/// </summary>`
`37`	`37`	`/// <param name="parseNodeFactory"> The <see cref="IParseNodeFactory"/> to use for response handling</param>`
`38`	`38`	`public DeltaResponseHandler(IParseNodeFactory parseNodeFactory = null)`
`39`	`39`	`{`
`40`		`- this.parseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;`
	`40`	`+ this.parseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`/// <summary>`
`@@ -61,7 +61,7 @@ public async Task<ModelType> HandleResponseAsync<NativeResponseType, ModelType>(`
`61`	`61`	`var responseWithChangeList = await GetResponseBodyWithChangelist(responseString).ConfigureAwait(false);`
`62`	`62`	`using var responseWithChangeListStream = new MemoryStream(Encoding.UTF8.GetBytes(responseWithChangeList));`
`63`	`63`
`64`		`- var responseParseNode = parseNodeFactory.GetRootParseNode(CoreConstants.MimeTypeNames.Application.Json, responseWithChangeListStream);`
	`64`	`+ var responseParseNode = await parseNodeFactory.GetRootParseNodeAsync(CoreConstants.MimeTypeNames.Application.Json, responseWithChangeListStream);`
`65`	`65`	`return (ModelType)(object)responseParseNode.GetObjectValue<T>((parsable) => new T());`
`66`	`66`	`}`
`67`	`67`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ namespace Microsoft.Graph`
`17`	`17`	`/// </summary>`
`18`	`18`	`internal class UploadResponseHandler`
`19`	`19`	`{`
`20`		`- private readonly IParseNodeFactory _parseNodeFactory;`
	`20`	`+ private readonly IAsyncParseNodeFactory _parseNodeFactory;`
`21`	`21`
`22`	`22`	`/// <summary>`
`23`	`23`	`/// Constructs a new <see cref="UploadResponseHandler"/>.`
`24`	`24`	`/// </summary>`
`25`	`25`	`/// <param name="parseNodeFactory"> The <see cref="IParseNodeFactory"/> to use for response handling</param>`
`26`	`26`	`public UploadResponseHandler(IParseNodeFactory parseNodeFactory = null)`
`27`	`27`	`{`
`28`		`- _parseNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;`
	`28`	`+ _parseNodeFactory = parseNodeFactory as IAsyncParseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance;`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/// <summary>`
`@@ -63,7 +63,7 @@ public async Task<UploadResult<T>> HandleResponse<T>(HttpResponseMessage respons`
`63`	`63`	`{`
`64`	`64`	`if (responseStream.Length > 0) //system.text.json wont deserialize an empty string`
`65`	`65`	`{`
`66`		`- var jsonParseNode = _parseNodeFactory.GetRootParseNode(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);`
	`66`	`+ var jsonParseNode = await _parseNodeFactory.GetRootParseNodeAsync(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);`
`67`	`67`	`uploadResult.ItemResponse = jsonParseNode.GetObjectValue<T>((parsable) => new T());`
`68`	`68`	`}`
`69`	`69`	`uploadResult.Location = response.Headers.Location;`
`@@ -76,7 +76,7 @@ public async Task<UploadResult<T>> HandleResponse<T>(HttpResponseMessage respons`
`76`	`76`	`* However, successful upload completion for a DriveItem the response could also come in a 200 response and`
`77`	`77`	`* hence we validate this by checking the NextExpectedRanges parameter which is present in an ongoing upload`
`78`	`78`	`*/`
`79`		`- var uploadSessionParseNode = _parseNodeFactory.GetRootParseNode(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);`
	`79`	`+ var uploadSessionParseNode = await _parseNodeFactory.GetRootParseNodeAsync(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);`
`80`	`80`	`UploadSession uploadSession = uploadSessionParseNode.GetObjectValue<UploadSession>(UploadSession.CreateFromDiscriminatorValue);`
`81`	`81`	`if (uploadSession?.NextExpectedRanges != null)`
`82`	`82`	`{`
`@@ -86,7 +86,7 @@ public async Task<UploadResult<T>> HandleResponse<T>(HttpResponseMessage respons`
`86`	`86`	`{`
`87`	`87`	`//Upload is most likely done as DriveItem info may come in a 200 response`
`88`	`88`	`responseStream.Position = 0; //reset`
`89`		`- var objectParseNode = _parseNodeFactory.GetRootParseNode(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);`
	`89`	`+ var objectParseNode = await _parseNodeFactory.GetRootParseNodeAsync(response.Content.Headers?.ContentType?.MediaType?.ToLowerInvariant(), responseStream);`
`90`	`90`	`uploadResult.ItemResponse = objectParseNode.GetObjectValue<T>((parsable) => new T());`
`91`	`91`	`}`
`92`	`92`	`}`