Add test case file

Author: msJinLei

src/Accounts/Authentication/Factories/AuthenticationFactoryTest.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using System.Security;
+using System.Threading.Tasks;
+using Microsoft.Azure.Commands.Common.Authentication;
+using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
+using Microsoft.Azure.Commands.Common.Authentication.Models;
+using Microsoft.Azure.Commands.Profile.Models;
+using Microsoft.Identity.Client;
+using Microsoft.Rest;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Azure.Commands.Common.Authentication.Factories.Test
+{
+    public class AuthenticationFactoryTest
+    {
+        private Mock<IAzureAccount> _mockAccount;
+        private Mock<IAzureEnvironment> _mockEnvironment;
+        private Mock<IAzureSubscription> _mockSubscription;
+        private Mock<IAzureTenant> _mockTenant;
+        private Mock<IAzureTokenCache> _mockTokenCache;
+        private Mock<ICmdletContext> _mockCmdletContext;
+        private Mock<IAccessToken> _mockAccessToken;
+        private Mock<IAuthenticatorBuilder> _mockAuthenticatorBuilder;
+        private Mock<IAuthenticator> _mockAuthenticator;
+        
+        public AuthenticationFactoryTest()
+        {
+            _mockAccount = new Mock<IAzureAccount>();
+            _mockEnvironment = new Mock<IAzureEnvironment>();
+            _mockSubscription = new Mock<IAzureSubscription>();
+            _mockTenant = new Mock<IAzureTenant>();
+            _mockTokenCache = new Mock<IAzureTokenCache>();
+            _mockCmdletContext = new Mock<ICmdletContext>();
+            _mockAccessToken = new Mock<IAccessToken>();
+            _mockAuthenticatorBuilder = new Mock<IAuthenticatorBuilder>();
+            _mockAuthenticator = new Mock<IAuthenticator>();
+        }
+
+        [Fact]
+        public void ConstructorInitializesProperties()
+        {
+            // Arrange & Act
+            var factory = new AuthenticationFactory();
+
+            // Assert
+            Assert.NotNull(factory);
+            Assert.Null(factory.KeyStore);
+            Assert.Null(factory.TokenProvider);
+        }
+
+        [Fact]
+        public void KeyStoreGetterShouldCallAzureSessionTryGetComponent()
+        {
+            // Arrange
+            var mockKeyStore = new Mock<AzKeyStore>();
+            var factory = new AuthenticationFactory();
+
+            // Mock AzureSession's TryGetComponent to return our mock
+            var originalInstance = AzureSession.Instance;
+            try
+            {
+                var mockAzureSession = new Mock<IAzureSession>();
+                mockAzureSession.Setup(s => s.TryGetComponent(AzKeyStore.Name, out It.Ref<AzKeyStore>.IsAny))
+                    .Callback(new MockTryGetComponentCallback<AzKeyStore>((string name, out AzKeyStore component) =>
+                    {
+                        component = mockKeyStore.Object;
+                        return true;
+                    }))
+                    .Returns(true);
+                AzureSession.Instance = mockAzureSession.Object;
+
+                // Act
+                var result = factory.KeyStore;
+
+                // Assert
+                Assert.Equal(mockKeyStore.Object, result);
+            }
+            finally
+            {
+                // Restore original instance
+                AzureSession.Instance = originalInstance;
+            }
+        }
+
+        [Fact]
+        public void AuthenticateShouldCallAuthenticator()
+        {
+            // Arrange
+            var factory = new AuthenticationFactory();
+            var tenant = "tenant";
+            var password = new SecureString();
+            var promptBehavior = "auto";
+            Action<string> promptAction = s => { };
+            var resourceId = "resourceId";
+
+            // Setup mocks
+            _mockAccessToken.Setup(t => t.UserId).Returns("userId");
+            _mockAccessToken.Setup(t => t.HomeAccountId).Returns("homeAccountId");
+
+            _mockAuthenticator.Setup(a => a.TryAuthenticate(It.IsAny<IDictionary<string, object>>(), out It.Ref<Task<IAccessToken>>.IsAny))
+                .Callback(new MockTryAuthenticateCallback((IDictionary<string, object> parameters, out Task<IAccessToken> accessToken) =>
+                {
+                    accessToken = Task.FromResult(_mockAccessToken.Object);
+                }))
+                .Returns(true);
+            _mockAuthenticator.Setup(a => a.Next).Returns((IAuthenticator)null);
+            
+            _mockAuthenticatorBuilder.Setup(b => b.Authenticator).Returns(_mockAuthenticator.Object);
+
+            // Mock AzureSession setup
+            var originalInstance = AzureSession.Instance;
+            try
+            {
+                var mockAzureSession = new Mock<IAzureSession>();
+                var mockTokenCacheProvider = new Mock<PowerShellTokenCacheProvider>();
+                
+                mockAzureSession.Setup(s => s.TryGetComponent(PowerShellTokenCacheProvider.PowerShellTokenCacheProviderKey, out It.Ref<PowerShellTokenCacheProvider>.IsAny))
+                    .Callback(new MockTryGetComponentCallback<PowerShellTokenCacheProvider>((string name, out PowerShellTokenCacheProvider component) =>
+                    {
+                        component = mockTokenCacheProvider.Object;
+                        return true;
+                    }))
+                    .Returns(true);
+                
+                mockAzureSession.Setup(s => s.TryGetComponent(AuthenticatorBuilder.AuthenticatorBuilderKey, out It.Ref<IAuthenticatorBuilder>.IsAny))
+                    .Callback(new MockTryGetComponentCallback<IAuthenticatorBuilder>((string name, out IAuthenticatorBuilder component) =>
+                    {
+                        component = _mockAuthenticatorBuilder.Object;
+                        return true;
+                    }))
+                    .Returns(true);
+                
+                AzureSession.Instance = mockAzureSession.Object;
+
+                // Act
+                var result = factory.Authenticate(_mockAccount.Object, _mockEnvironment.Object, tenant, password, promptBehavior, promptAction, _mockTokenCache.Object, resourceId);
+
+                // Assert
+                Assert.NotNull(result);
+                Assert.Equal("userId", result.UserId);
+                _mockAuthenticator.Verify(a => a.TryAuthenticate(It.IsAny<IDictionary<string, object>>(), out It.Ref<Task<IAccessToken>>.IsAny), Times.Once);
+                _mockAccount.Verify(a => a.SetProperty(AzureAccount.Property.HomeAccountId, "homeAccountId"), Times.Once);
+            }
+            finally
+            {
+                // Restore original instance
+                AzureSession.Instance = originalInstance;
+            }
+        }
+
+        // More tests would be added for other methods and edge cases
+        
+        // Helper delegate for mocking TryGetComponent
+        public delegate void MockTryGetComponentCallback<T>(string name, out T component);
+        
+        // Helper delegate for mocking TryAuthenticate
+        public delegate void MockTryAuthenticateCallback(IDictionary<string, object> parameters, out Task<IAccessToken> accessToken);
+    }
+}