public async Task ProcessRunnerSucceeded([Values(true, false)] bool logPII)
{
var output = "Test output";
var fileName = "someFileName.exe";
var args = "arg1 arg2";
var pi = new ProcessStartInfo(fileName, args);
var process = new TestProcess {
StartInfo = pi, Output = output
};
string result;
string log = string.Empty;
using AzureEventSourceListener listener = new AzureEventSourceListener((args, s) =>
{
log = $"{args.EventName} {s}";
}, EventLevel.Verbose);
using var runner = new ProcessRunner(process, TimeSpan.FromSeconds(30), logPII, default);
result = await Run(runner);
Assert.AreEqual(output, result);
if (logPII)
{
Assert.That(log, Contains.Substring(fileName));
Assert.That(log, Contains.Substring(args));
Assert.That(log, Contains.Substring(nameof(AzureIdentityEventSource.ProcessRunnerInformational)));
}
else
{
Assert.That(log, Does.Not.Contain(fileName));
Assert.That(log, Does.Not.Contain(args));
Assert.That(log, Does.Not.Contain(nameof(AzureIdentityEventSource.ProcessRunnerInformational)));
}
}
public void ProcessRunnerFailedWithErrorMessage([Values(true, false)] bool logPII)
{
string log = string.Empty;
using AzureEventSourceListener listener = new AzureEventSourceListener((args, s) =>
{
log = $"{args.EventName} {s}";
}, EventLevel.Verbose);
var error = "Test error";
var process = new TestProcess {
Error = error
};
using var runner = new ProcessRunner(process, TimeSpan.FromSeconds(30), logPII, default);
var exception = Assert.CatchAsync <InvalidOperationException>(async() => await Run(runner));
Assert.AreEqual(error, exception.Message);
if (logPII)
{
Assert.That(log, Contains.Substring(error));
Assert.That(log, Contains.Substring(nameof(AzureIdentityEventSource.ProcessRunnerError)));
}
else
{
Assert.That(log, Does.Not.Contain(error));
Assert.That(log, Does.Not.Contain(nameof(AzureIdentityEventSource.ProcessRunnerError)));
}
}
public async Task DefaultAzureCredential_UseAzureCliCredential()
{
var options = Recording.InstrumentClientOptions(new DefaultAzureCredentialOptions
{
ExcludeEnvironmentCredential = true,
ExcludeInteractiveBrowserCredential = true,
ExcludeSharedTokenCacheCredential = true,
VisualStudioCodeTenantId = TestEnvironment.TestTenantId
});
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForAzureCli();
var testProcess = new TestProcess {
Output = processOutput
};
var vscAdapter = new TestVscAdapter(ExpectedServiceName, "Azure", null);
var fileSystem = CredentialTestHelpers.CreateFileSystemForVisualStudioCode(TestEnvironment);
var factory = new TestDefaultAzureCredentialFactory(options, fileSystem, new TestProcessService(testProcess), vscAdapter);
var credential = InstrumentClient(new DefaultAzureCredential(factory, options));
AccessToken token = await credential.GetTokenAsync(new TokenRequestContext(new[] { "https://vault.azure.net/.default" }), CancellationToken.None);
Assert.AreEqual(token.Token, expectedToken);
Assert.AreEqual(token.ExpiresOn, expectedExpiresOn);
}
public async Task AuthenticateWithCliCredential(
[Values(null, TenantIdHint)] string tenantId,
[Values(true)] bool allowMultiTenantAuthentication,
[Values(null, TenantId)] string explicitTenantId)
{
var context = new TokenRequestContext(new[] { Scope }, tenantId: tenantId);
var options = new AzureCliCredentialOptions {
TenantId = explicitTenantId, AllowMultiTenantAuthentication = allowMultiTenantAuthentication
};
string expectedTenantId = TenantIdResolver.Resolve(explicitTenantId, context, options.AllowMultiTenantAuthentication);
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForAzureCli();
var testProcess = new TestProcess {
Output = processOutput
};
AzureCliCredential credential =
InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess, true), options));
AccessToken actualToken = await credential.GetTokenAsync(context);
Assert.AreEqual(expectedToken, actualToken.Token);
Assert.AreEqual(expectedExpiresOn, actualToken.ExpiresOn);
var expectTenantId = expectedTenantId != null;
if (expectTenantId)
{
Assert.That(testProcess.StartInfo.Arguments, Does.Contain($"-tenant {expectedTenantId}"));
}
else
{
Assert.That(testProcess.StartInfo.Arguments, Does.Not.Contain("-tenant"));
}
}
public async Task HandlesAlternateDateTimeFormats([Values("en-US", "nl-NL")] string culture)
{
CultureInfo curCulture = CultureInfo.CurrentCulture;
CultureInfo.CurrentCulture = new CultureInfo(culture);
try
{
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForAzurePowerShell(TimeSpan.FromSeconds(30));
TestContext.WriteLine(processOutput);
var testProcess = new TestProcess
{
Output = processOutput,
};
AzurePowerShellCredential credential = InstrumentClient(
new AzurePowerShellCredential(
new AzurePowerShellCredentialOptions(),
CredentialPipeline.GetInstance(null),
new TestProcessService(testProcess, true)));
await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default));
}
finally
{
CultureInfo.CurrentCulture = new CultureInfo(curCulture.Name);
}
}
[RunOnlyOnPlatforms(Windows = true, OSX = true)] // Comment this attribute to run this tests on Linux with Libsecret enabled
public async Task DefaultAzureCredential_UseVisualStudioCodeCredential()
{
var options = Recording.InstrumentClientOptions(new DefaultAzureCredentialOptions
{
ExcludeEnvironmentCredential = true,
ExcludeInteractiveBrowserCredential = true,
ExcludeSharedTokenCacheCredential = true,
VisualStudioCodeTenantId = TestEnvironment.TestTenantId
});
var cloudName = Guid.NewGuid().ToString();
var fileSystem = CredentialTestHelpers.CreateFileSystemForVisualStudioCode(TestEnvironment, cloudName);
var process = new TestProcess {
Error = "Error"
};
var factory = new TestDefaultAzureCredentialFactory(options, fileSystem, new TestProcessService(process), default);
var credential = InstrumentClient(new DefaultAzureCredential(factory, options));
AccessToken token;
using (await CredentialTestHelpers.CreateRefreshTokenFixtureAsync(TestEnvironment, Mode, ExpectedServiceName, cloudName))
{
token = await credential.GetTokenAsync(new TokenRequestContext(new[] { "https://vault.azure.net/.default" }), CancellationToken.None);
}
Assert.IsNotNull(token.Token);
}
public async Task FallsBackToLegacyPowershell()
{
bool fellBackToPowerShell = false;
//var testProcess = new TestProcess { Output = "'pwsh' is not recognized as an internal or external command," };
var testProcess = new TestProcess
{
Output = "'pwsh' is not recognized as an internal or external command,",
ExceptionOnStartHandler = (p) =>
{
if (p.StartInfo.Arguments.Contains("pwsh"))
{
p.Output = tokenXML;
fellBackToPowerShell = true;
}
}
};
AzurePowerShellCredential credential = InstrumentClient(
new AzurePowerShellCredential(
new AzurePowerShellCredentialOptions(),
CredentialPipeline.GetInstance(null),
new TestProcessService(testProcess, true)));
await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default));
Assert.IsTrue(fellBackToPowerShell);
}
public void AuthenticateWithCliCredential_InvalidJsonOutput([Values("", "{}", "{\"Some\": false}", "{\"accessToken\": \"token\"}", "{\"expiresOn\" : \"1900-01-01 00:00:00.123456\"}")] string jsonContent)
{
var testProcess = new TestProcess {
Output = jsonContent
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
Assert.CatchAsync <AuthenticationFailedException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
}
public void ProcessRunnerProcessFailsToStart()
{
var process = new TestProcess {
FailedToStart = true
};
var runner = new ProcessRunner(process, TimeSpan.FromSeconds(30), default);
Assert.CatchAsync <InvalidOperationException>(async() => await Run(runner));
}
public async Task AuthenticateWithVsCredential()
{
var fileSystem = CredentialTestHelpers.CreateFileSystemForVisualStudio();
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForVisualStudio();
var testProcess = new TestProcess {
Output = processOutput
};
var credential = InstrumentClient(new VisualStudioCredential(default, default, fileSystem, new TestProcessService(testProcess)));
public void ProcessRunnerCreatedOnCanceled()
{
var process = new TestProcess {
Output = "Test output", Timeout = 5000
};
var cancellationToken = new CancellationToken(true);
var runner = new ProcessRunner(process, TimeSpan.FromMilliseconds(5000), cancellationToken);
Assert.CatchAsync <OperationCanceledException>(async() => await Run(runner));
}
public void ProcessRunnerCanceledByTimeout()
{
var cts = new CancellationTokenSource();
var process = new TestProcess {
Output = "Test output", Timeout = 5000
};
var runner = new ProcessRunner(process, TimeSpan.FromMilliseconds(100), cts.Token);
Assert.CatchAsync <OperationCanceledException>(async() => await Run(runner));
}
public void AuthenticateWithAzurePowerShellCredential_AzurePowerShellModuleNotInstalled([Values("NoAzAccountModule")] string message)
{
var testProcess = new TestProcess {
Output = message
};
AzurePowerShellCredential credential = InstrumentClient(new AzurePowerShellCredential(new AzurePowerShellCredentialOptions(), CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(AzurePowerShellCredential.AzurePowerShellModuleNotInstalledError, ex.Message);
}
public void AuthenticateWithAzurePowerShellCredential_PwshNotInstalled([Values("'pwsh' is not recognized", "pwsh: command not found", "pwsh: not found")] string errorMessage)
{
var testProcess = new TestProcess {
Error = errorMessage
};
AzurePowerShellCredential credential = InstrumentClient(new AzurePowerShellCredential(new AzurePowerShellCredentialOptions(), CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(AzurePowerShellCredential.PowerShellNotInstalledError, ex.Message);
}
public async Task AuthenticateWithVsCredential([Values(null, TenantIdHint)] string tenantId, [Values(true)] bool allowMultiTenantAuthentication)
{
var fileSystem = CredentialTestHelpers.CreateFileSystemForVisualStudio();
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForVisualStudio();
var testProcess = new TestProcess {
Output = processOutput
};
var options = new VisualStudioCredentialOptions();
var credential = InstrumentClient(new VisualStudioCredential(TenantId, default, fileSystem, new TestProcessService(testProcess, true), options));
public void AuthenticateWithCliCredential_AzureCliUnknownError()
{
string mockResult = "mock-result";
var testProcess = new TestProcess {
Error = mockResult
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
Assert.ThrowsAsync <AuthenticationFailedException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
}
public void AuthenticateWithCliCredential_ExceptionScenarios(string errorMessage, string expectedMessage, Type exceptionType)
{
var testProcess = new TestProcess {
Error = errorMessage
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync(exceptionType, async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(expectedMessage, ex.Message);
}
public void AuthenticateWithAzurePowerShellCredential_ErrorScenarios(string errorMessage, string expectedError)
{
var testProcess = new TestProcess {
Error = errorMessage
};
AzurePowerShellCredential credential = InstrumentClient(
new AzurePowerShellCredential(new AzurePowerShellCredentialOptions(), CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(expectedError, ex.Message);
}
public void AuthenticateWithCliCredential_AzNotLogIn()
{
string expectedExMessage = $"Please run 'az login' to set up account";
var testProcess = new TestProcess {
Error = "Please run 'az login'"
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(expectedExMessage, ex.Message);
}
public void AuthenticateWithCliCredential_AzureCliNotInstalled([Values("'az' is not recognized", "az: command not found", "az: not found")] string errorMessage)
{
string expectedMessage = "Azure CLI not installed";
var testProcess = new TestProcess {
Error = errorMessage
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(expectedMessage, ex.Message);
}
public async Task AuthenticateWithCliCredential()
{
var expectedToken = "mock-cli-access-token";
var testProcess = new TestProcess {
Output = $"{{ \"accessToken\": \"{expectedToken}\", \"expiresOn\": \"1900-01-01 00:00:00.123456\" }}"
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
AccessToken actualToken = await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default));
Assert.AreEqual(expectedToken, actualToken.Token);
}
public async Task ProcessRunnerSucceeded()
{
var output = "Test output";
var process = new TestProcess {
Output = output
};
var runner = new ProcessRunner(process, TimeSpan.FromSeconds(30), default);
var result = await Run(runner);
Assert.AreEqual(output, result);
}
public void AuthenticateWithCliCredential_CanceledByUser()
{
var cts = new CancellationTokenSource();
var testProcess = new TestProcess {
Timeout = 10000
};
testProcess.Started += (o, e) => cts.Cancel();
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
Assert.CatchAsync <OperationCanceledException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default), cts.Token));
}
public void AuthenticateWithAzurePowerShellCredential_RunConnectAzAccount([Values("Run Connect-AzAccount to login")] string errorMessage)
{
var testProcess = new TestProcess {
Error = errorMessage
};
AzurePowerShellCredential credential = InstrumentClient(new AzurePowerShellCredential(new AzurePowerShellCredentialOptions {
UseLegacyPowerShell = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
}, CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
var ex = Assert.ThrowsAsync <CredentialUnavailableException>(async() => await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default)));
Assert.AreEqual(AzurePowerShellCredential.AzurePowerShellNotLogInError, ex.Message);
}
public void ProcessRunnerFailedWithErrorMessage()
{
var error = "Test error";
var process = new TestProcess {
Error = error
};
var runner = new ProcessRunner(process, TimeSpan.FromSeconds(30), default);
var exception = Assert.CatchAsync <InvalidOperationException>(async() => await Run(runner));
Assert.AreEqual(error, exception.Message);
}
public void ProcessRunnerFailedOnKillProcess()
{
var output = "Test output";
var process = new TestProcess {
Output = output, ExceptionOnProcessKill = new Win32Exception(1), Timeout = 5000
};
var runner = new ProcessRunner(process, TimeSpan.FromMilliseconds(50), default);
var exception = Assert.CatchAsync <Win32Exception>(async() => await Run(runner));
Assert.AreEqual(1, exception.NativeErrorCode);
}
public async Task ProcessRunnerCanceledFinished()
{
var cts = new CancellationTokenSource();
var process = new TestProcess {
Output = "Test output"
};
using var runner = new ProcessRunner(process, TimeSpan.FromSeconds(5000), false, cts.Token);
await Run(runner);
cts.Cancel();
}
public async Task AuthenticateWithCliCredential_ExpiresIn()
{
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForAzureCliExpiresIn(1800);
var testProcess = new TestProcess {
Output = processOutput
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
AccessToken actualToken = await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default));
Assert.AreEqual(expectedToken, actualToken.Token);
Assert.LessOrEqual(expectedExpiresOn, actualToken.ExpiresOn);
}
public async Task AuthenticateWithCliCredential_ExpiresIn()
{
var expectedToken = "mock-cli-access-token";
var expectedTime = DateTimeOffset.Now.AddMinutes(30);
var testProcess = new TestProcess {
Output = $"{{ \"accessToken\": \"{expectedToken}\", \"expiresIn\": 1800 }}"
};
AzureCliCredential credential = InstrumentClient(new AzureCliCredential(CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
AccessToken actualToken = await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default));
Assert.AreEqual(expectedToken, actualToken.Token);
Assert.LessOrEqual(expectedTime, actualToken.ExpiresOn);
}
public async Task AuthenticateWithAzurePowerShellCredential()
{
var(expectedToken, expectedExpiresOn, processOutput) = CredentialTestHelpers.CreateTokenForAzurePowerShell(TimeSpan.FromSeconds(30));
var testProcess = new TestProcess {
Output = processOutput
};
AzurePowerShellCredential credential = InstrumentClient(new AzurePowerShellCredential
(new AzurePowerShellCredentialOptions(), CredentialPipeline.GetInstance(null), new TestProcessService(testProcess)));
AccessToken actualToken = await credential.GetTokenAsync(new TokenRequestContext(MockScopes.Default));
Assert.AreEqual(expectedToken, actualToken.Token);
Assert.AreEqual(expectedExpiresOn, actualToken.ExpiresOn);
}
