feat: Add credential type parameter to CredentialFactory

Author: robertvoinescu-work

Src/Support/Google.Apis.Auth.Tests/OAuth2/GoogleCredentialTests.cs

@@ -846,6 +846,105 @@ public async Task UniverseDomain_DifferentCustomInRequestAndCredential()
             Assert.Null(request.Headers.Authorization?.Parameter);
         }
 
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Success_Data))]
+        public void FromFile_WithType(string json, string credentialType, Type expectedType)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var credential = CredentialFactory.FromFile(tempFile, credentialType);
+                Assert.IsType(expectedType, credential.UnderlyingCredential);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Failure_Data))]
+        public void FromFile_WithType_Failure(string json, string credentialType, string expectedMessage)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var ex = Assert.Throws<InvalidOperationException>(() => CredentialFactory.FromFile(tempFile, credentialType));
+                Assert.Equal(expectedMessage, ex.Message);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Success_Data))]
+        public void FromJson_WithType(string json, string credentialType, Type expectedType)
+        {
+            var credential = CredentialFactory.FromJson(json, credentialType);
+            Assert.IsType(expectedType, credential.UnderlyingCredential);
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Failure_Data))]
+        public void FromJson_WithType_Failure(string json, string credentialType, string expectedMessage)
+        {
+            var ex = Assert.Throws<InvalidOperationException>(() => CredentialFactory.FromJson(json, credentialType));
+            Assert.Equal(expectedMessage, ex.Message);
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Success_Data))]
+        public async Task FromFileAsync_WithType(string json, string credentialType, Type expectedType)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var credential = await CredentialFactory.FromFileAsync(tempFile, credentialType, CancellationToken.None);
+                Assert.IsType(expectedType, credential.UnderlyingCredential);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Failure_Data))]
+        public async Task FromFileAsync_WithType_Failure(string json, string credentialType, string expectedMessage)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => CredentialFactory.FromFileAsync(tempFile, credentialType, CancellationToken.None));
+                Assert.Equal(expectedMessage, ex.Message);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        public static TheoryData<string, string, Type> CredentialFactory_Success_Data() =>
+            new TheoryData<string, string, Type>
+            {
+                { FakeUserCredentialFileContents, JsonCredentialParameters.AuthorizedUserCredentialType, typeof(UserCredential) },
+                { FakeServiceAccountCredentialFileContents, JsonCredentialParameters.ServiceAccountCredentialType, typeof(ServiceAccountCredential) }
+            };
+
+        public static TheoryData<string, string, string> CredentialFactory_Failure_Data() =>
+            new TheoryData<string, string, string>
+            {
+                { FakeUserCredentialFileContents, JsonCredentialParameters.ServiceAccountCredentialType, "The credential type authorized_user is not compatible with the requested type service_account" },
+                { FakeUserCredentialFileContents, "invalid_type", "The credential type authorized_user is not compatible with the requested type invalid_type" },
+                { "invalid_json", "any_type", "Error deserializing JSON credential data." }
+            };
+
         [Fact]
         public void FromStream_WrapsDeserializationException_WithBadJson()
         {

Src/Support/Google.Apis.Auth/OAuth2/CredentialFactory.cs

@@ -16,7 +16,6 @@ limitations under the License.
 
 using System;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -50,6 +49,19 @@ public static async Task<T> FromFileAsync<T>(string credentialPath, Cancellation
         return await FromStreamAsync<T>(fileStream, cancellationToken).ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a file that contains JSON credential data.
+    /// </summary>
+    /// <param name="credentialPath">The path to the credential file.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The created credential.</returns>
+    public static async Task<GoogleCredential> FromFileAsync(string credentialPath, string credentialType, CancellationToken cancellationToken)
+    {
+        using FileStream fileStream = File.OpenRead(credentialPath);
+        return await FromStreamAsync(fileStream, credentialType, cancellationToken).ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from a file that contains JSON credential data.
     /// </summary>
@@ -62,6 +74,18 @@ public static T FromFile<T>(string credentialPath)
         return FromStream<T>(fileStream);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a file that contains JSON credential data.
+    /// </summary>
+    /// <param name="credentialPath">The path to the credential file.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    public static GoogleCredential FromFile(string credentialPath, string credentialType)
+    {
+        using FileStream fileStream = File.OpenRead(credentialPath);
+        return FromStream(fileStream, credentialType);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from a stream that contains JSON credential data.
     /// </summary>
@@ -83,6 +107,27 @@ public static async Task<T> FromStreamAsync<T>(Stream stream, CancellationToken
         return FromJsonParameters<T>(jsonCredentialParameters);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a stream that contains JSON credential data.
+    /// </summary>
+    /// <param name="stream">The stream that contains the JSON credential data.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The created credential.</returns>
+    private static async Task<GoogleCredential> FromStreamAsync(Stream stream, string credentialType, CancellationToken cancellationToken)
+    {
+        JsonCredentialParameters jsonCredentialParameters;
+        try
+        {
+            jsonCredentialParameters = await NewtonsoftJsonSerializer.Instance.DeserializeAsync<JsonCredentialParameters>(stream, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
+        }
+        return FromJsonParameters(jsonCredentialParameters, credentialType);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from a stream that contains JSON credential data.
     /// </summary>
@@ -103,6 +148,26 @@ public static T FromStream<T>(Stream stream)
         return FromJsonParameters<T>(jsonCredentialParameters);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a stream that contains JSON credential data.
+    /// </summary>
+    /// <param name="stream">The stream that contains the JSON credential data.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    private static GoogleCredential FromStream(Stream stream, string credentialType)
+    {
+        JsonCredentialParameters jsonCredentialParameters;
+        try
+        {
+            jsonCredentialParameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(stream);
+        }
+        catch (Exception e)
+        {
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
+        }
+        return FromJsonParameters(jsonCredentialParameters, credentialType);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from a string that contains JSON credential data.
     /// </summary>
@@ -123,6 +188,26 @@ public static T FromJson<T>(string json)
         return FromJsonParameters<T>(jsonCredentialParameters);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a string that contains JSON credential data.
+    /// </summary>
+    /// <param name="json">The string that contains the JSON credential data.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    public static GoogleCredential FromJson(string json, string credentialType)
+    {
+        JsonCredentialParameters jsonCredentialParameters;
+        try
+        {
+            jsonCredentialParameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(json);
+        }
+        catch (Exception e)
+        {
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
+        }
+        return FromJsonParameters(jsonCredentialParameters, credentialType);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from JSON credential parameters.
     /// </summary>
@@ -136,27 +221,53 @@ public static T FromJson<T>(string json)
     /// </exception>
     internal static T FromJsonParameters<T>(JsonCredentialParameters credentialParameters)
     {
-        if (CreateCredential(credentialParameters, typeof(T)) is T credentialAsT)
+        credentialParameters.ThrowIfNull(nameof(credentialParameters));
+        if (FromJsonParameters(credentialParameters, typeof(T)) is T credentialAsT)
         {
             return credentialAsT;
         }
 
         throw new InvalidOperationException(
             $"Found incompatible credential types, '{credentialParameters.Type}' and '{typeof(T).FullName}, even though a check" 
           + " should have already taken place. We should never reach here, there's a bug in the code.");
+    }
 
-        static IGoogleCredential CreateCredential(JsonCredentialParameters credentialParameters, Type targetCredentialType) =>
-            credentialParameters.ThrowIfNull(nameof(credentialParameters)).Type switch
-            {
-                JsonCredentialParameters.AuthorizedUserCredentialType => CreateUserCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ServiceAccountCredentialType => CreateServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ExternalAccountCredentialType => CreateExternalCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ImpersonatedServiceAccountCredentialType => CreateImpersonatedServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ExternalAccountAuthorizedUserCredentialType => CreateExternalAccountAuthorizedUserCredentialFromParameters(credentialParameters, targetCredentialType),
-                _ => throw new InvalidOperationException($"Error creating credential from JSON or JSON parameters. Unrecognized credential type {credentialParameters.Type}."),
-            };
+    /// <summary>
+    /// Creates a credential of the specified type from JSON credential parameters.
+    /// </summary>
+    /// <param name="credentialParameters">The JSON credential parameters.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the <paramref name="credentialType"/> is unrecognized,
+    /// or if the credential data is incompatible with the requested type.
+    /// </exception>
+    private static GoogleCredential FromJsonParameters(JsonCredentialParameters credentialParameters, string credentialType)
+    {
+        credentialParameters.ThrowIfNull(nameof(credentialParameters));
+        if (credentialParameters.Type != credentialType)
+        {
+            throw new InvalidOperationException($"The credential type {credentialParameters.Type} is not compatible with the requested type {credentialType}");
+        }
+
+        // Type checking has already occurred so target type may be set to the generic IGoogleCredential which all credentials implement.
+        Type targetType = typeof(IGoogleCredential);
+        var rawCredentialType = FromJsonParameters(credentialParameters, targetType);
+
+        return rawCredentialType.ToGoogleCredential();
     }
 
+    private static IGoogleCredential FromJsonParameters(JsonCredentialParameters credentialParameters, Type targetCredentialType) =>
+        credentialParameters.ThrowIfNull(nameof(credentialParameters)).Type switch
+        {
+            JsonCredentialParameters.AuthorizedUserCredentialType => CreateUserCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ServiceAccountCredentialType => CreateServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ExternalAccountCredentialType => CreateExternalCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ImpersonatedServiceAccountCredentialType => CreateImpersonatedServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ExternalAccountAuthorizedUserCredentialType => CreateExternalAccountAuthorizedUserCredentialFromParameters(credentialParameters, targetCredentialType),
+            _ => throw new InvalidOperationException($"Error creating credential from JSON or JSON parameters. Unrecognized credential type {credentialParameters.Type}.")
+        };
+
     /// <summary>
     /// Validates actual type can be cast to target type.
     /// </summary>