public void SetUp()
{
TestDataSetup.CreateTestData(Context);
dbAuthProvider = (DbAuthenticationProvider)AuthenticationFactory.GetAuthenticationProvider("DbAuthenticationProviderName");
password = ASCIIEncoding.ASCII.GetBytes("Password");
username = "******";
}
public async Task GetApplicationData_ConvertsExcelToTheCorrectApplicationData()
{
Account account = TestDataSetup.CreateAccount();
Category category = TestDataSetup.CreateCategory();
AccountTransaction accountTransaction = TestDataSetup.CreateAccountTransaction();
var excelPackage = new ExcelPackage();
excelPackage.Workbook.Worksheets.Add(AccountsWorksheetName);
excelPackage.Workbook.Worksheets[AccountsWorksheetName].Cells[2, 1].Value = account.Id;
excelPackage.Workbook.Worksheets[AccountsWorksheetName].Cells[2, 2].Value = account.Name;
excelPackage.Workbook.Worksheets.Add(CategoriesWorksheetName);
excelPackage.Workbook.Worksheets[CategoriesWorksheetName].Cells[2, 1].Value = category.Id;
excelPackage.Workbook.Worksheets[CategoriesWorksheetName].Cells[2, 2].Value = category.Name;
excelPackage.Workbook.Worksheets[CategoriesWorksheetName].Cells[2, 3].Value = category.Budgeted;
excelPackage.Workbook.Worksheets.Add(AccountTransactionsWorksheetName);
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 2].Value = accountTransaction.AccountId;
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 3].Value = accountTransaction.Date;
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 4].Value = accountTransaction.Payee;
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 5].Value = accountTransaction.CategoryId;
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 6].Value = accountTransaction.Memo;
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 7].Value = accountTransaction.Outflow;
excelPackage.Workbook.Worksheets[AccountTransactionsWorksheetName].Cells[2, 8].Value = accountTransaction.Inflow;
excelFileProcessor.Setup(efp => efp.LoadExcelPackageFromFile())
.Returns(() => excelPackage);
ApplicationData applicationData = await excelPersistenceService.GetApplicationData();
Assert.AreEqual(1, applicationData.Accounts.Count);
Assert.AreEqual(1, applicationData.Categories.Count);
Assert.AreEqual(1, applicationData.AccountTransactions.Count);
TestValidationHelper.ValidateAccountsAreEqual(account, applicationData.Accounts.FirstOrDefault());
TestValidationHelper.ValidateCategoriesAreEqual(category, applicationData.Categories.FirstOrDefault());
TestValidationHelper.ValidateAccountTransactionsAreEqual(accountTransaction, applicationData.AccountTransactions.FirstOrDefault());
}
public async Task SaveApplicationData_TriesToSaveTheCorrectDataToFile()
{
var appData = new ApplicationData();
Account account = TestDataSetup.CreateAccount();
Category category = TestDataSetup.CreateCategory();
AccountTransaction accountTransaction = TestDataSetup.CreateAccountTransaction();
appData.Accounts.Add(account);
appData.Categories.Add(category);
appData.AccountTransactions.Add(accountTransaction);
excelFileProcessor.Setup(efp => efp.SaveAs(It.IsAny <ExcelPackage>()))
.Callback <ExcelPackage>(ep => {
ValidateExcelPackageContainsAccount(ep, account);
ValidateExcelPackageContainsCategory(ep, category);
ValidateExcelPackageContainsAccountTransaction(ep, accountTransaction);
});
await excelPersistenceService.SaveApplicationData(appData);
excelFileProcessor.Verify(efp => efp.SaveAs(It.IsAny <ExcelPackage>()), Times.Once);
}
static void Main(string[] args)
{
// configure more open connections to graph, so we can leverage concurrency.
ServicePointManager.DefaultConnectionLimit = 32;
ServicePointManager.ReusePort = true;
try
{
// set up authentication based on the config specified in AuthSettings.cs (you should have a local git-ignoder AuthSettingsLocal.cs file where you initialize the values
var authProvider = AuthSettings.isUserAuthentication ? (MyAuthenticationProvider) new UserAuthenticationProvider() : (MyAuthenticationProvider) new AppOnlyAuthenticationProvider();
GraphServiceClient client = GetAuthenticatedClient(authProvider);
// set up logging
EfficientRequestHandling.Logger.SetLogger(new OutputLogger(Console.OpenStandardOutput(), System.IO.File.Open("log.txt", FileMode.Create, FileAccess.Write, FileShare.Read)));
// go to a specific scenario
goto getAllGroupsWithMembers;
#pragma warning disable CS0164
#pragma warning disable CS0162
#region User scenarios
getAllUsers : ExecuteScenarioWithPerfMeasurement(client,
$"Downloading all users using parallelization.",
(requestManager) =>
{
var users = UserScenarios.GetAllUsers(requestManager).ToArray();
return($"Finished downloading users: {users.Length}.");
}, batchSize: 1); // using batchSize=1 since this is more optimal with the paritioning approach used by this scenario.
return;
getAllUsersBasic : ExecuteScenarioWithPerfMeasurement(client,
$"Downloading all users using non-optimized paging pattern.",
(requestManager) =>
{
var users = UserScenarios.GetAllUsersBasic(client).ToArray();
return($"Finished downloading users: {users.Length}.");
});
return;
#endregion
#region Group scenarios
getAllGroupsWithMembers : ExecuteScenarioWithPerfMeasurement(client,
$"Geting all groups with members.",
(requestManager) =>
{
var groups = GroupScenarios.GetAllGroupsWithMembers(requestManager).ToArray();
return($"Finished downloading groups with members: {groups.Length}.");
}, batchSize: 1); // using batchSize=1 since this is more optimal with the paritioning approach used by this scenario.
return;
#endregion
#region Device scenarios
getDeviceReport : ExecuteScenarioWithPerfMeasurement(client,
$"Downloading all device state to generate a report.",
(requestManager) =>
{
var report = DeviceScenarios.GetDeviceReport(requestManager);
return($"Finished generating device report:\n{report}");
}, batchSize: 1);
return;
#endregion
#region Email scenarios
getAllEmailsForOneUser : ExecuteScenarioWithPerfMeasurement(client,
$"Geting all emails for a single user.",
(requestManager) =>
{
var emails = EmailScenarios.GetEmailsForSingleUser(requestManager, client.Me.Request().GetAsync().Result.Id).ToArray();
return($"Finished downloading emails for one user: {emails.Length}.");
});
return;
getAllEmailsForAllUsers : ExecuteScenarioWithPerfMeasurement(client,
$"Geting all emails for all users.",
(requestManager) =>
{
var emails = EmailScenarios.GetAllUsersWithCompleteMailboxes(requestManager).ToArray();
return($"Finished downloading emails for all users: {emails.Length}.");
});
return;
#endregion
#region Delta query scenarios
deltaQueryOptimized : ExecuteScenarioWithPerfMeasurement(client,
$"Executing efficient delta query cycle on user collection",
(requestManager) =>
{
DeltaQueryScenarios.UsersDeltaQueryEfficient(requestManager);
return($"Delta cycle complete.");
});
deltaQueryBasic : ExecuteScenarioWithPerfMeasurement(client,
$"Executing traditional delta query cycle on user collection",
(requestManager) =>
{
DeltaQueryScenarios.UserDeltaQueryTraditional(client);
return($"Delta cycle complete.");
});
return;
#endregion
#region License management scenarios
assignLicenses:
var usersTemp = UserScenarios.GetAllUsersBasic(client).Take(1000).ToArray();
ExecuteScenarioWithPerfMeasurement(client,
$"Assigning licenses.",
(requestManager) =>
{
var results = LicenseManagementScenarios.AssignLicensesToUsers(requestManager, usersTemp, "POWER_BI_STANDARD").ToArray();
var errors = results.Where(r => r.IsSuccessful == false).GroupBy(r => r.ErrorDetails.Error.Message).ToArray();
return($"Processed {results.Length}.");
});
return;
removeAllLicenses : ExecuteScenarioWithPerfMeasurement(client,
$"Removing licenses.",
(requestManager) =>
{
var users = UserScenarios.GetAllUsers(requestManager);
var results = LicenseManagementScenarios.RemoveLicensesFromUsers(requestManager, users, "POWER_BI_STANDARD").ToArray();
var errors = results.Where(r => r.IsSuccessful == false).GroupBy(r => r.ErrorDetails.Error.Message).ToArray();
return($"Processed {results.Length}.");
});
return;
assignLicensesBasic : ExecuteScenarioWithPerfMeasurement(client,
$"Assigning licenses the basic way.",
(requestManager) =>
{
var users = UserScenarios.GetAllUsers(requestManager).Take(1000).ToArray();
var results = LicenseManagementScenarios.AssignLicensesToUsersBasic(client, "POWER_BI_STANDARD",
users).ToArray();
return($"Processed {results.Length}.");
});
return;
#endregion
#region Test data setup
createUsers : int usersToCreate = 5195;
ExecuteScenarioWithPerfMeasurement(client,
$"Creating random users: {usersToCreate}",
(requestManager) =>
{
var createdUsers = TestDataSetup.CreateRandomUsers(requestManager, usersToCreate, "petersgraphtest.onmicrosoft.com").ToArray();
return($"User creation complete. Created: {createdUsers.Length}");
}, concurrencyLimit: 16);
return;
createGroups:
User[] usersToAdd = null;
ExecuteScenarioWithPerfMeasurement(client,
$"Downloading all users with optimizations.",
(requestManager) =>
{
usersToAdd = UserScenarios.GetAllUsers(requestManager).ToArray();
return($"Downloaded {usersToAdd.Length}.");
}, batchSize: 1);
int groupsToCreate = 100;
int memberCount = 100;
ExecuteScenarioWithPerfMeasurement(client,
$"Creating random groups: {groupsToCreate}",
(requestManager) =>
{
var createdGroups = TestDataSetup.CreateGroupsWithRandomMembersOptimized(requestManager, usersToAdd, groupsToCreate, memberCount).ToArray();
return($"User creation complete. Created: {createdGroups.Length}");
}, concurrencyLimit: 2);
return;
#endregion
#pragma warning restore CS0164
#pragma warning restore CS0162
}
finally
{
EfficientRequestHandling.Logger.FlushAndCloseLogs();
}
}
public void TearDown()
{
TestDataSetup.DeleteTestData(Context);
dbAuthProvider = null;
}
