public void ValidateCtorWithExcludeOptions([Values(true, false)] bool excludeEnvironmentCredential, [Values(true, false)] bool excludeManagedIdentityCredential, [Values(true, false)] bool excludeSharedTokenCacheCredential, [Values(true, false)] bool excludeVisualStudioCredential, [Values(true, false)] bool excludeVisualStudioCodeCredential, [Values(true, false)] bool excludeCliCredential, [Values(true, false)] bool excludeInteractiveBrowserCredential) { var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); bool environmentCredentialIncluded = false; bool managedIdentityCredentialIncluded = false; bool sharedTokenCacheCredentialIncluded = false; bool cliCredentialIncluded = false; bool interactiveBrowserCredentialIncluded = false; bool visualStudioCredentialIncluded = false; bool visualStudioCodeCredentialIncluded = false; credFactory.OnCreateEnvironmentCredential = (_) => environmentCredentialIncluded = true; credFactory.OnCreateAzureCliCredential = (_) => cliCredentialIncluded = true; credFactory.OnCreateInteractiveBrowserCredential = (tenantId, _) => interactiveBrowserCredentialIncluded = true; credFactory.OnCreateVisualStudioCredential = (tenantId, _) => visualStudioCredentialIncluded = true; credFactory.OnCreateVisualStudioCodeCredential = (tenantId, _) => visualStudioCodeCredentialIncluded = true; credFactory.OnCreateManagedIdentityCredential = (clientId, _) => { managedIdentityCredentialIncluded = true; }; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, _) => { sharedTokenCacheCredentialIncluded = true; }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = excludeEnvironmentCredential, ExcludeManagedIdentityCredential = excludeManagedIdentityCredential, ExcludeSharedTokenCacheCredential = excludeSharedTokenCacheCredential, ExcludeAzureCliCredential = excludeCliCredential, ExcludeInteractiveBrowserCredential = excludeInteractiveBrowserCredential, ExcludeVisualStudioCredential = excludeVisualStudioCredential, ExcludeVisualStudioCodeCredential = excludeVisualStudioCodeCredential }; if (excludeEnvironmentCredential && excludeManagedIdentityCredential && excludeSharedTokenCacheCredential && excludeVisualStudioCredential && excludeVisualStudioCodeCredential && excludeCliCredential && excludeInteractiveBrowserCredential) { Assert.Throws <ArgumentException>(() => new DefaultAzureCredential(options)); } else { var cred = new DefaultAzureCredential(credFactory, options); Assert.AreEqual(!excludeEnvironmentCredential, environmentCredentialIncluded); Assert.AreEqual(!excludeManagedIdentityCredential, managedIdentityCredentialIncluded); Assert.AreEqual(!excludeSharedTokenCacheCredential, sharedTokenCacheCredentialIncluded); Assert.AreEqual(!excludeCliCredential, cliCredentialIncluded); Assert.AreEqual(!excludeInteractiveBrowserCredential, interactiveBrowserCredentialIncluded); Assert.AreEqual(!excludeVisualStudioCredential, visualStudioCredentialIncluded); Assert.AreEqual(!excludeVisualStudioCodeCredential, visualStudioCodeCredentialIncluded); } }
public void ValidateCtorOptionsPassedToCredentials() { string expClientId = Guid.NewGuid().ToString(); string expUsername = Guid.NewGuid().ToString(); string expTenantId = Guid.NewGuid().ToString(); string actClientId = null; string actUsername = null; string actTenantId = null; var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateManagedIdentityCredential = (clientId, _) => actClientId = clientId; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, _) => { actTenantId = tenantId; actUsername = username; }; var options = new DefaultAzureCredentialOptions { ManagedIdentityClientId = expClientId, SharedTokenCacheUsername = expUsername, SharedTokenCacheTenantId = expTenantId }; var cred = new DefaultAzureCredential(credFactory, options); Assert.AreEqual(expClientId, actClientId); Assert.AreEqual(expUsername, actUsername); Assert.AreEqual(expTenantId, actTenantId); }
internal MockDefaultAzureCredentialFactory GetMockDefaultAzureCredentialFactory(Type availableCredential, AccessToken expToken, List <Type> calledCredentials) { var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); void SetupMockForException <T>(Mock <T> mock) where T : TokenCredential => mock.Setup(m => m.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.IsAny <CancellationToken>())) .Callback(() => calledCredentials.Add(typeof(T))) .ReturnsAsync(() => { return(availableCredential == typeof(T) ? expToken : throw new CredentialUnavailableException("Unavailable")); }); credFactory.OnCreateEnvironmentCredential = c => SetupMockForException(c); credFactory.OnCreateManagedIdentityCredential = (clientId, c) => SetupMockForException(c); credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, c) => SetupMockForException(c); credFactory.OnCreateAzureCliCredential = c => SetupMockForException(c); credFactory.OnCreateInteractiveBrowserCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateVisualStudioCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateVisualStudioCodeCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateAzurePowerShellCredential = c => SetupMockForException(c); return(credFactory); }
public void ValidateUnhandledException(Type credentialType) { var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); void SetupMockForException <T>(Mock <T> mock) where T : TokenCredential { Exception e; if (typeof(T) != credentialType) { e = new CredentialUnavailableException($"{typeof(T).Name} Unavailable"); } else { e = new MockClientException($"{typeof(T).Name} unhandled exception"); } mock.Setup(m => m.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.IsAny <CancellationToken>())) .Throws(e); } credFactory.OnCreateEnvironmentCredential = c => SetupMockForException(c); credFactory.OnCreateManagedIdentityCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateSharedTokenCacheCredential = (_, _, c) => SetupMockForException(c); credFactory.OnCreateVisualStudioCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateVisualStudioCodeCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateAzureCliCredential = c => SetupMockForException(c); credFactory.OnCreateAzurePowerShellCredential = c => SetupMockForException(c); credFactory.OnCreateInteractiveBrowserCredential = (_, c) => { c.Setup(m => m.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.IsAny <CancellationToken>())) .Throws(new MockClientException("InteractiveBrowserCredential unhandled exception")); }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = false, ExcludeManagedIdentityCredential = false, ExcludeSharedTokenCacheCredential = false, ExcludeAzureCliCredential = false, ExcludeAzurePowerShellCredential = false, ExcludeInteractiveBrowserCredential = false }; var cred = new DefaultAzureCredential(credFactory, options); var ex = Assert.ThrowsAsync <AuthenticationFailedException>(async() => await cred.GetTokenAsync(new TokenRequestContext(MockScopes.Default))); var unhandledException = ex.InnerException is AggregateException ae?ae.InnerExceptions.Last() : ex.InnerException; Assert.AreEqual($"{credentialType.Name} unhandled exception", unhandledException.Message); }
public void ValidateAllUnavailable([Values(true, false)] bool excludeEnvironmentCredential, [Values(true, false)] bool excludeManagedIdentityCredential, [Values(true, false)] bool excludeSharedTokenCacheCredential, [Values(true, false)] bool excludeInteractiveBrowserCredential) { if (excludeEnvironmentCredential && excludeManagedIdentityCredential && excludeSharedTokenCacheCredential && excludeInteractiveBrowserCredential) { Assert.Pass(); } var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateEnvironmentCredential = (c) => { ((MockExtendedTokenCredential)c).TokenFactory = (context, cancel) => { return(new ExtendedAccessToken(new CredentialUnavailableException("EnvironmentCredential Unavailable"))); }; }; credFactory.OnCreateInteractiveBrowserCredential = (c) => { ((MockExtendedTokenCredential)c).TokenFactory = (context, cancel) => { return(new ExtendedAccessToken(new CredentialUnavailableException("InteractiveBrowserCredential Unavailable"))); }; }; credFactory.OnCreateManagedIdentityCredential = (clientId, c) => { ((MockExtendedTokenCredential)c).TokenFactory = (context, cancel) => { return(new ExtendedAccessToken(new CredentialUnavailableException("ManagedIdentityCredential Unavailable"))); }; }; credFactory.OnCreateSharedTokenCacheCredential = (username, c) => { ((MockExtendedTokenCredential)c).TokenFactory = (context, cancel) => { return(new ExtendedAccessToken(new CredentialUnavailableException("SharedTokenCacheCredential Unavailable"))); }; }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = excludeEnvironmentCredential, ExcludeManagedIdentityCredential = excludeManagedIdentityCredential, ExcludeSharedTokenCacheCredential = excludeSharedTokenCacheCredential, ExcludeInteractiveBrowserCredential = excludeInteractiveBrowserCredential }; var cred = new DefaultAzureCredential(credFactory, options); var ex = Assert.ThrowsAsync <AuthenticationFailedException>(async() => await cred.GetTokenAsync(new TokenRequestContext(MockScopes.Default))); if (!excludeEnvironmentCredential) { Assert.True(ex.Message.Contains("EnvironmentCredential Unavailable")); } if (!excludeManagedIdentityCredential) { Assert.True(ex.Message.Contains("ManagedIdentityCredential Unavailable")); } if (!excludeSharedTokenCacheCredential) { Assert.True(ex.Message.Contains("SharedTokenCacheCredential Unavailable")); } if (!excludeInteractiveBrowserCredential) { Assert.True(ex.Message.Contains("InteractiveBrowserCredential Unavailable")); } }
public void ValidateEnvironmentBasedOptionsPassedToCredentials([Values] bool clientIdSpecified, [Values] bool usernameSpecified, [Values] bool tenantIdSpecified) { var expClientId = clientIdSpecified ? Guid.NewGuid().ToString() : null; var expUsername = usernameSpecified ? Guid.NewGuid().ToString() : null; var expTenantId = tenantIdSpecified ? Guid.NewGuid().ToString() : null; bool onCreateSharedCalled = false; bool onCreatedManagedCalled = false; bool onCreateInteractiveCalled = false; using (new TestEnvVar("AZURE_CLIENT_ID", expClientId)) using (new TestEnvVar("AZURE_USERNAME", expUsername)) using (new TestEnvVar("AZURE_TENANT_ID", expTenantId)) { var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateManagedIdentityCredential = (clientId, _) => { onCreatedManagedCalled = true; Assert.AreEqual(expClientId, clientId); }; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, _) => { onCreateSharedCalled = true; Assert.AreEqual(expTenantId, tenantId); Assert.AreEqual(expUsername, username); }; credFactory.OnCreateInteractiveBrowserCredential = (tenantId, _) => { onCreateInteractiveCalled = true; Assert.AreEqual(expTenantId, tenantId); }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = true, ExcludeManagedIdentityCredential = false, ExcludeSharedTokenCacheCredential = false, ExcludeAzureCliCredential = true, ExcludeInteractiveBrowserCredential = false }; var cred = new DefaultAzureCredential(credFactory, options); Assert.IsTrue(onCreateSharedCalled); Assert.IsTrue(onCreatedManagedCalled); Assert.IsTrue(onCreateInteractiveCalled); } }
public void ValidateCtorOptionsPassedToCredentials() { string expClientId = Guid.NewGuid().ToString(); string expUsername = Guid.NewGuid().ToString(); string expCacheTenantId = Guid.NewGuid().ToString(); string expBrowserTenantId = Guid.NewGuid().ToString(); string expVsTenantId = Guid.NewGuid().ToString(); string expCodeTenantId = Guid.NewGuid().ToString(); bool expUseLegacyPowerShell = true; string actClientId = null; string actUsername = null; string actCacheTenantId = null; string actBrowserTenantId = null; string actVsTenantId = null; string actCodeTenantId = null; bool actUseLegacyPowerShell = false; var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateManagedIdentityCredential = (clientId, _) => actClientId = clientId; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, _) => { actCacheTenantId = tenantId; actUsername = username; }; credFactory.OnCreateInteractiveBrowserCredential = (tenantId, _) => { actBrowserTenantId = tenantId; }; credFactory.OnCreateVisualStudioCredential = (tenantId, _) => { actVsTenantId = tenantId; }; credFactory.OnCreateVisualStudioCodeCredential = (tenantId, _) => { actCodeTenantId = tenantId; }; credFactory.OnCreateAzurePowerShellCredential = (useLegacyPowerShell, _) => { actUseLegacyPowerShell = useLegacyPowerShell; }; var options = new DefaultAzureCredentialOptions { ManagedIdentityClientId = expClientId, SharedTokenCacheUsername = expUsername, ExcludeSharedTokenCacheCredential = false, SharedTokenCacheTenantId = expCacheTenantId, VisualStudioTenantId = expVsTenantId, VisualStudioCodeTenantId = expCodeTenantId, InteractiveBrowserTenantId = expBrowserTenantId, ExcludeInteractiveBrowserCredential = false, UseLegacyPowerShell = expUseLegacyPowerShell }; var cred = new DefaultAzureCredential(credFactory, options); Assert.AreEqual(expClientId, actClientId); Assert.AreEqual(expUsername, actUsername); Assert.AreEqual(expCacheTenantId, actCacheTenantId); Assert.AreEqual(expBrowserTenantId, actBrowserTenantId); Assert.AreEqual(expVsTenantId, actVsTenantId); Assert.AreEqual(expCodeTenantId, actCodeTenantId); Assert.AreEqual(expUseLegacyPowerShell, actUseLegacyPowerShell); }
public async Task ValidateSelectedCredentialCaching([Values(typeof(EnvironmentCredential), typeof(ManagedIdentityCredential), typeof(SharedTokenCacheCredential), typeof(AzureCliCredential), typeof(InteractiveBrowserCredential))] Type availableCredential) { var expToken = new AccessToken(Guid.NewGuid().ToString(), DateTimeOffset.MaxValue); var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); List <Type> calledCredentials = new List <Type>(); credFactory.OnCreateEnvironmentCredential = (c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { calledCredentials.Add(typeof(EnvironmentCredential)); return((availableCredential == typeof(EnvironmentCredential)) ? expToken : throw new CredentialUnavailableException("Unavailable")); }; }; credFactory.OnCreateManagedIdentityCredential = (clientId, c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { calledCredentials.Add(typeof(ManagedIdentityCredential)); return((availableCredential == typeof(ManagedIdentityCredential)) ? expToken : throw new CredentialUnavailableException("Unavailable")); }; }; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { calledCredentials.Add(typeof(SharedTokenCacheCredential)); return((availableCredential == typeof(SharedTokenCacheCredential)) ? expToken : throw new CredentialUnavailableException("Unavailable")); }; }; credFactory.OnCreateAzureCliCredential = (c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { calledCredentials.Add(typeof(AzureCliCredential)); return((availableCredential == typeof(AzureCliCredential)) ? expToken : throw new CredentialUnavailableException("Unavailable")); }; }; credFactory.OnCreateInteractiveBrowserCredential = (_, c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { calledCredentials.Add(typeof(InteractiveBrowserCredential)); return((availableCredential == typeof(InteractiveBrowserCredential)) ? expToken : throw new CredentialUnavailableException("Unavailable")); }; }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = false, ExcludeManagedIdentityCredential = false, ExcludeSharedTokenCacheCredential = false, ExcludeAzureCliCredential = false, ExcludeInteractiveBrowserCredential = false }; var cred = new DefaultAzureCredential(credFactory, options); AccessToken actToken = await cred.GetTokenAsync(new TokenRequestContext(MockScopes.Default)); Assert.AreEqual(expToken.Token, actToken.Token); // assert that the available credential was the last credential called Assert.AreEqual(calledCredentials[calledCredentials.Count - 1], availableCredential); calledCredentials.Clear(); actToken = await cred.GetTokenAsync(new TokenRequestContext(MockScopes.Default)); Assert.AreEqual(expToken.Token, actToken.Token); // assert that the available credential was the only credential called Assert.AreEqual(calledCredentials.Count, 1); Assert.AreEqual(calledCredentials[0], availableCredential); }
public void ValidateUnhandledException([Values(0, 1, 2, 3, 4)] int exPossition) { var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateEnvironmentCredential = (c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { if (exPossition > 0) { throw new CredentialUnavailableException("EnvironmentCredential Unavailable"); } else { throw new MockClientException("EnvironmentCredential unhandled exception"); } }; }; credFactory.OnCreateManagedIdentityCredential = (clientId, c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { if (exPossition > 1) { throw new CredentialUnavailableException("ManagedIdentityCredential Unavailable"); } else { throw new MockClientException("ManagedIdentityCredential unhandled exception"); } }; }; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { if (exPossition > 2) { throw new CredentialUnavailableException("SharedTokenCacheCredential Unavailable"); } else { throw new MockClientException("SharedTokenCacheCredential unhandled exception"); } }; }; credFactory.OnCreateAzureCliCredential = (c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { if (exPossition > 3) { throw new CredentialUnavailableException("CliCredential Unavailable"); } else { throw new MockClientException("CliCredential unhandled exception"); } }; }; credFactory.OnCreateInteractiveBrowserCredential = (_, c) => { ((MockTokenCredential)c).TokenFactory = (context, cancel) => { throw new MockClientException("InteractiveBrowserCredential unhandled exception"); }; }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = false, ExcludeManagedIdentityCredential = false, ExcludeSharedTokenCacheCredential = false, ExcludeAzureCliCredential = false, ExcludeInteractiveBrowserCredential = false }; var cred = new DefaultAzureCredential(credFactory, options); var ex = Assert.ThrowsAsync <AuthenticationFailedException>(async() => await cred.GetTokenAsync(new TokenRequestContext(MockScopes.Default))); switch (exPossition) { case 0: Assert.AreEqual(ex.InnerException.Message, "EnvironmentCredential unhandled exception"); break; case 1: Assert.AreEqual(ex.InnerException.Message, "ManagedIdentityCredential unhandled exception"); break; case 2: Assert.AreEqual(ex.InnerException.Message, "SharedTokenCacheCredential unhandled exception"); break; case 3: Assert.AreEqual(ex.InnerException.Message, "CliCredential unhandled exception"); break; case 4: Assert.AreEqual(ex.InnerException.Message, "InteractiveBrowserCredential unhandled exception"); break; default: Assert.Fail(); break; } }
public void ValidateAllUnavailable([Values(true, false)] bool excludeEnvironmentCredential, [Values(true, false)] bool excludeManagedIdentityCredential, [Values(true, false)] bool excludeSharedTokenCacheCredential, [Values(true, false)] bool excludeVisualStudioCredential, [Values(true, false)] bool excludeVisualStudioCodeCredential, [Values(true, false)] bool excludeCliCredential, [Values(true, false)] bool excludePowerShellCredential, [Values(true, false)] bool excludeInteractiveBrowserCredential) { if (excludeEnvironmentCredential && excludeManagedIdentityCredential && excludeSharedTokenCacheCredential && excludeVisualStudioCredential && excludeVisualStudioCodeCredential && excludeCliCredential && excludeInteractiveBrowserCredential) { Assert.Pass(); } var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); void SetupMockForException <T>(Mock <T> mock) where T : TokenCredential => mock.Setup(m => m.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.IsAny <CancellationToken>())) .Throws(new CredentialUnavailableException($"{typeof(T).Name} Unavailable")); credFactory.OnCreateEnvironmentCredential = c => SetupMockForException(c); credFactory.OnCreateInteractiveBrowserCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateManagedIdentityCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateSharedTokenCacheCredential = (_, _, c) => SetupMockForException(c); credFactory.OnCreateAzureCliCredential = c => SetupMockForException(c); credFactory.OnCreateAzurePowerShellCredential = c => SetupMockForException(c); credFactory.OnCreateVisualStudioCredential = (_, c) => SetupMockForException(c); credFactory.OnCreateVisualStudioCodeCredential = (_, c) => SetupMockForException(c); var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = excludeEnvironmentCredential, ExcludeManagedIdentityCredential = excludeManagedIdentityCredential, ExcludeSharedTokenCacheCredential = excludeSharedTokenCacheCredential, ExcludeVisualStudioCredential = excludeVisualStudioCredential, ExcludeVisualStudioCodeCredential = excludeVisualStudioCodeCredential, ExcludeAzureCliCredential = excludeCliCredential, ExcludeAzurePowerShellCredential = excludePowerShellCredential, ExcludeInteractiveBrowserCredential = excludeInteractiveBrowserCredential }; var cred = new DefaultAzureCredential(credFactory, options); var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await cred.GetTokenAsync(new TokenRequestContext(MockScopes.Default))); if (!excludeEnvironmentCredential) { Assert.True(ex.Message.Contains("EnvironmentCredential Unavailable")); } if (!excludeManagedIdentityCredential) { Assert.True(ex.Message.Contains("ManagedIdentityCredential Unavailable")); } if (!excludeSharedTokenCacheCredential) { Assert.True(ex.Message.Contains("SharedTokenCacheCredential Unavailable")); } if (!excludeCliCredential) { Assert.True(ex.Message.Contains("CliCredential Unavailable")); } if (!excludePowerShellCredential) { Assert.True(ex.Message.Contains("PowerShellCredential Unavailable")); } if (!excludeInteractiveBrowserCredential) { Assert.True(ex.Message.Contains("InteractiveBrowserCredential Unavailable")); } if (!excludeVisualStudioCredential) { Assert.True(ex.Message.Contains("VisualStudioCredential Unavailable")); } if (!excludeVisualStudioCodeCredential) { Assert.True(ex.Message.Contains("VisualStudioCodeCredential Unavailable")); } }
public void ValidateEmptyEnvironmentBasedOptionsNotPassedToCredentials([Values] bool clientIdSpecified, [Values] bool usernameSpecified, [Values] bool tenantIdSpecified) { var expClientId = clientIdSpecified ? string.Empty : null; var expUsername = usernameSpecified ? string.Empty : null; var expTenantId = tenantIdSpecified ? string.Empty : null; bool onCreateSharedCalled = false; bool onCreatedManagedCalled = false; bool onCreateInteractiveCalled = false; bool onCreateVsCalled = false; bool onCreateVsCodeCalled = false; using (new TestEnvVar(new Dictionary <string, string> { { "AZURE_CLIENT_ID", expClientId }, { "AZURE_USERNAME", expUsername }, { "AZURE_TENANT_ID", expTenantId } })) { var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateManagedIdentityCredential = (clientId, _) => { onCreatedManagedCalled = true; Assert.IsNull(clientId); }; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, _) => { onCreateSharedCalled = true; Assert.IsNull(tenantId); Assert.IsNull(username); }; credFactory.OnCreateInteractiveBrowserCredential = (tenantId, _) => { onCreateInteractiveCalled = true; Assert.IsNull(tenantId); }; credFactory.OnCreateVisualStudioCredential = (tenantId, _) => { onCreateVsCalled = true; Assert.IsNull(tenantId); }; credFactory.OnCreateVisualStudioCodeCredential = (tenantId, _) => { onCreateVsCodeCalled = true; Assert.IsNull(tenantId); }; var options = new DefaultAzureCredentialOptions { ExcludeEnvironmentCredential = true, ExcludeManagedIdentityCredential = false, ExcludeSharedTokenCacheCredential = false, ExcludeVisualStudioCredential = false, ExcludeVisualStudioCodeCredential = false, ExcludeAzureCliCredential = true, ExcludeInteractiveBrowserCredential = false }; new DefaultAzureCredential(credFactory, options); Assert.IsTrue(onCreateSharedCalled); Assert.IsTrue(onCreatedManagedCalled); Assert.IsTrue(onCreateInteractiveCalled); Assert.IsTrue(onCreateVsCalled); Assert.IsTrue(onCreateVsCodeCalled); } }
public void ValidateCtorOptionsPassedToCredentials([Values(ManagedIdentityIdType.None, ManagedIdentityIdType.ClientId, ManagedIdentityIdType.ResourceId)] ManagedIdentityIdType managedIdentityIdType) { string expClientId = Guid.NewGuid().ToString(); string expUsername = Guid.NewGuid().ToString(); string expCacheTenantId = Guid.NewGuid().ToString(); string expBrowserTenantId = Guid.NewGuid().ToString(); string expVsTenantId = Guid.NewGuid().ToString(); string expCodeTenantId = Guid.NewGuid().ToString(); string expResourceId = $"/subscriptions/{Guid.NewGuid().ToString()}/locations/MyLocation"; string actClientId_ManagedIdentity = null; string actResiurceId_ManagedIdentity = null; string actClientId_InteractiveBrowser = null; string actUsername = null; string actCacheTenantId = null; string actBrowserTenantId = null; string actVsTenantId = null; string actCodeTenantId = null; var credFactory = new MockDefaultAzureCredentialFactory(CredentialPipeline.GetInstance(null)); credFactory.OnCreateManagedIdentityCredential = (options, _) => { actClientId_ManagedIdentity = options.ManagedIdentityClientId; actResiurceId_ManagedIdentity = options.ManagedIdentityResourceId?.ToString(); }; credFactory.OnCreateSharedTokenCacheCredential = (tenantId, username, _) => { actCacheTenantId = tenantId; actUsername = username; }; credFactory.OnCreateInteractiveBrowserCredential = (tenantId, clientId, _) => { actBrowserTenantId = tenantId; actClientId_InteractiveBrowser = clientId; }; credFactory.OnCreateVisualStudioCredential = (tenantId, _) => { actVsTenantId = tenantId; }; credFactory.OnCreateVisualStudioCodeCredential = (tenantId, _) => { actCodeTenantId = tenantId; }; credFactory.OnCreateAzurePowerShellCredential = _ => {}; var options = new DefaultAzureCredentialOptions { InteractiveBrowserCredentialClientId = expClientId, SharedTokenCacheUsername = expUsername, ExcludeSharedTokenCacheCredential = false, SharedTokenCacheTenantId = expCacheTenantId, VisualStudioTenantId = expVsTenantId, VisualStudioCodeTenantId = expCodeTenantId, InteractiveBrowserTenantId = expBrowserTenantId, ExcludeInteractiveBrowserCredential = false, }; switch (managedIdentityIdType) { case ManagedIdentityIdType.ClientId: options.ManagedIdentityClientId = expClientId; break; case ManagedIdentityIdType.ResourceId: options.ManagedIdentityResourceId = new ResourceIdentifier(expResourceId); break; } new DefaultAzureCredential(credFactory, options); Assert.AreEqual(expClientId, actClientId_InteractiveBrowser); Assert.AreEqual(expUsername, actUsername); Assert.AreEqual(expCacheTenantId, actCacheTenantId); Assert.AreEqual(expBrowserTenantId, actBrowserTenantId); Assert.AreEqual(expVsTenantId, actVsTenantId); Assert.AreEqual(expCodeTenantId, actCodeTenantId); switch (managedIdentityIdType) { case ManagedIdentityIdType.ClientId: Assert.AreEqual(expClientId, actClientId_ManagedIdentity); break; case ManagedIdentityIdType.ResourceId: Assert.AreEqual(expResourceId, actResiurceId_ManagedIdentity); break; case ManagedIdentityIdType.None: Assert.IsNull(actClientId_ManagedIdentity); Assert.IsNull(actResiurceId_ManagedIdentity); break; } }