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;
}
}
