public async Task <CacheProgramResults> ExecuteAsync(IEnumerable <LabUserData> labUserData, CancellationToken cancellationToken)
{
var testInputData = new TestInputData
{
ResultsFilePath = ResultsFilePath,
StorageType = CacheStorageType,
LabUserDatas = labUserData.ToList()
};
var inputDataJson = JsonConvert.SerializeObject(testInputData);
string inputFilePath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
File.WriteAllText(inputFilePath, inputDataJson);
var sb = new StringBuilder();
sb.Append($"--inputPath {inputFilePath.EncloseQuotes()} ");
string arguments = sb.ToString();
var processUtils = new ProcessUtils();
try
{
var processRunResults = await processUtils.RunProcessAsync(ExecutablePath, arguments, cancellationToken).ConfigureAwait(false);
return(CacheProgramResults.CreateFromResultsFile(ResultsFilePath, processRunResults));
}
catch (ProcessRunException ex)
{
return(CacheProgramResults.CreateWithFailedExecution(ex));
}
}
protected override Task InternalExecuteAsync(TestInputData testInputData)
{
return(LanguageRunner.ExecuteAsync(
new JavaLanguageExecutor("TestConsoleApp"),
testInputData,
CancellationToken.None));
}
protected override Task InternalExecuteAsync(TestInputData testInputData)
{
return(LanguageRunner.ExecuteAsync(
new NodeLanguageExecutor(),
testInputData,
default));
}
public void HackerRankTest11()
{
TestInputData oData = BadVibes(_sTestDataRootDir + "hackerrank11_input.txt");
long result = JourneyToTheMoon.journeyToMoon(oData.numAstronauts, oData.astronautPairData);
long expected = 4999949998;
Assert.AreEqual(expected, result);
}
public void SampleTest2()
{
TestInputData oData = BadVibes(_sTestDataRootDir + "sample2_input.txt");
long result = JourneyToTheMoon.journeyToMoon(oData.numAstronauts, oData.astronautPairData);
int expected = 5;
Assert.AreEqual(expected, result);
}
public LanguageTestInputData(TestInputData testInputData, string scope, string cacheFilePath)
{
LabUserDatas = testInputData.LabUserDatas;
ResultsFilePath = testInputData.ResultsFilePath;
StorageType = testInputData.StorageType;
Scope = scope;
CacheFilePath = cacheFilePath;
}
protected override Task InternalExecuteAsync(TestInputData testInputData)
{
string scriptFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "TestMsalPython.py");
return(LanguageRunner.ExecuteAsync(
new PythonLanguageExecutor(scriptFilePath),
testInputData,
CancellationToken.None));
}
protected override Task InternalExecuteAsync(TestInputData testInputData)
{
// TODO: figure out how we setup the public main program, compile it from .java to .class, and execute it
// May need to have the JavaLanguageExecutor take a .java file and then have a separate compile
// step on that class to build the java code and run it.
string javaClassFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "SomeJavaClass.class");
return(LanguageRunner.ExecuteAsync(
new JavaLanguageExecutor(javaClassFilePath),
testInputData,
CancellationToken.None));
}
/// <inheritdoc />
protected override async Task <IEnumerable <CacheExecutorAccountResult> > InternalExecuteAsync(TestInputData testInputData)
{
LoggerCallbackHandler.LogCallback = (LogLevel level, string message, bool containsPii) =>
{
Console.WriteLine("{0}: {1}", level, message);
};
var results = new List <CacheExecutorAccountResult>();
foreach (var labUserData in testInputData.LabUserDatas)
{
var tokenCache = new FileBasedTokenCache(
testInputData.StorageType,
CommonCacheTestUtils.AdalV3CacheFilePath,
CommonCacheTestUtils.MsalV2CacheFilePath);
var authenticationContext = new AuthenticationContext(labUserData.Authority, tokenCache);
try
{
var result = await authenticationContext.AcquireTokenSilentAsync(
TestInputData.MsGraph,
labUserData.ClientId,
new UserIdentifier(labUserData.Upn, UserIdentifierType.RequiredDisplayableId)).ConfigureAwait(false);
Console.WriteLine($"got token for '{result.UserInfo.DisplayableId}' from the cache");
results.Add(new CacheExecutorAccountResult(
labUserData.Upn,
result.UserInfo.DisplayableId,
true));
}
catch (AdalSilentTokenAcquisitionException)
{
var result = await authenticationContext.AcquireTokenAsync(
TestInputData.MsGraph,
labUserData.ClientId,
new UserPasswordCredential(labUserData.Upn, labUserData.Password)).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(result.AccessToken))
{
results.Add(new CacheExecutorAccountResult(labUserData.Upn, string.Empty, false));
}
else
{
Console.WriteLine($"got token for '{result.UserInfo.DisplayableId}' without the cache");
results.Add(new CacheExecutorAccountResult(
labUserData.Upn,
result.UserInfo.DisplayableId,
false));
}
}
}
return(results);
}
public LanguageTestInputData(TestInputData testInputData)
{
LabUserDatas = testInputData.LabUserDatas;
ResultsFilePath = testInputData.ResultsFilePath;
StorageType = testInputData.StorageType;
}
public static void ClassInit(TestContext context)
{
_geniusClient = GeniusClientInitializer.GetClient();
_inputData = TestInputData.GetFromJsonFile();
}
/// <inheritdoc />
protected override async Task <IEnumerable <CacheExecutorAccountResult> > InternalExecuteAsync(TestInputData testInputData)
{
string resource = TestInputData.MsGraph;
string[] scopes = new[]
{
resource + "/user.read"
};
var results = new List <CacheExecutorAccountResult>();
foreach (var labUserData in testInputData.LabUserDatas)
{
var app = PublicClientApplicationBuilder
.Create(labUserData.ClientId)
.WithAuthority(new Uri(labUserData.Authority), true)
.WithLogging((LogLevel level, string message, bool containsPii) =>
{
Console.WriteLine("{0}: {1}", level, message);
})
.WithTelemetry(new TraceTelemetryConfig())
.Build();
FileBasedTokenCacheHelper.ConfigureUserCache(
testInputData.StorageType,
app.UserTokenCache,
CommonCacheTestUtils.AdalV3CacheFilePath,
CommonCacheTestUtils.MsalV2CacheFilePath,
CommonCacheTestUtils.MsalV3CacheFilePath);
IEnumerable <IAccount> accounts = await app.GetAccountsAsync().ConfigureAwait(false);
IAccount accountToReference = accounts.FirstOrDefault(x => x.Username.Equals(labUserData.Upn, StringComparison.OrdinalIgnoreCase));
try
{
var result = await app
.AcquireTokenSilent(scopes, accountToReference)
.WithAuthority(app.Authority)
.WithForceRefresh(false)
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
Console.WriteLine($"got token for '{result.Account.Username}' from the cache");
results.Add(new CacheExecutorAccountResult(labUserData.Upn, result.Account.Username, true));
}
catch (MsalUiRequiredException)
{
var result = await app
.AcquireTokenByUsernamePassword(scopes, labUserData.Upn, labUserData.Password.ToSecureString())
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(result.AccessToken))
{
results.Add(new CacheExecutorAccountResult(labUserData.Upn, string.Empty, false));
}
else
{
Console.WriteLine($"got token for '{result.Account.Username}' without the cache");
results.Add(new CacheExecutorAccountResult(labUserData.Upn, result.Account.Username, false));
}
}
}
return(results);
}
/// <inheritdoc />
protected override async Task <IEnumerable <CacheExecutorAccountResult> > InternalExecuteAsync(TestInputData testInputData)
{
var v1App = PreRegisteredApps.CommonCacheTestV1;
string resource = PreRegisteredApps.MsGraph;
string[] scopes = new[]
{
resource + "/user.read"
};
Logger.LogCallback = (LogLevel level, string message, bool containsPii) =>
{
Console.WriteLine("{0}: {1}", level, message);
};
var tokenCache = new TokenCache();
FileBasedTokenCacheHelper.ConfigureUserCache(
testInputData.StorageType,
tokenCache,
CommonCacheTestUtils.AdalV3CacheFilePath,
CommonCacheTestUtils.MsalV2CacheFilePath);
var app = new PublicClientApplication(v1App.ClientId, v1App.Authority, tokenCache)
{
ValidateAuthority = true
};
IEnumerable <IAccount> accounts = await app.GetAccountsAsync().ConfigureAwait(false);
var results = new List <CacheExecutorAccountResult>();
foreach (var labUserData in testInputData.LabUserDatas)
{
IAccount accountToReference = accounts.FirstOrDefault(x => x.Username.Equals(labUserData.Upn, StringComparison.OrdinalIgnoreCase));
try
{
var result = await app.AcquireTokenSilentAsync(
scopes,
accountToReference,
app.Authority,
false).ConfigureAwait(false);
Console.WriteLine($"got token for '{result.Account.Username}' from the cache");
results.Add(new CacheExecutorAccountResult(labUserData.Upn, result.Account.Username, true));
}
catch (MsalUiRequiredException)
{
var result = await app.AcquireTokenByUsernamePasswordAsync(
scopes,
labUserData.Upn,
labUserData.Password.ToSecureString()).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(result.AccessToken))
{
results.Add(new CacheExecutorAccountResult(labUserData.Upn, string.Empty, false));
}
else
{
Console.WriteLine($"got token for '{result.Account.Username}' without the cache");
results.Add(new CacheExecutorAccountResult(labUserData.Upn, result.Account.Username, false));
}
}
}
return(results);
}
