public void DeploymentImportXmlMultipleFilesForSameRecordTest() { var type = Entities.jmcg_testentity; PrepareTests(); var workFolder = ClearFilesAndData(type); var recordName1 = CreateTestRecord(TestEntityType, new Dictionary <string, object> { { Fields.jmcg_testentity_.jmcg_name, "TestName1" } }); var recordName2 = CreateTestRecord(TestEntityType, new Dictionary <string, object> { { Fields.jmcg_testentity_.jmcg_name, "TestName2" } }); var exportService = new ExportXmlService(XrmRecordService); var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = new[] { new ExportRecordType() { RecordType = new RecordType(TestEntityType, TestEntityType) } } }; var exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsTrue(exportResponse.Success); recordName1.SetField(Fields.jmcg_testentity_.jmcg_name, "TestName1 - Updated!"); recordName1 = UpdateFieldsAndRetreive(recordName1, Fields.jmcg_testentity_.jmcg_name); exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsTrue(exportResponse.Success); Assert.AreEqual(3, FileUtility.GetFiles(workFolder).Count()); var app = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var dialog = app.NavigateToDialog <ImportXmlModule, ImportXmlDialog>(); var entryViewmodel = app.GetSubObjectEntryViewModel(dialog); //select the excel file with the errors and submit form app.EnterAndSaveObject(importRequest, entryViewmodel); //check validation results displayed var validationResults = dialog.Controller.UiItems.First() as ObjectDisplayViewModel; Assert.IsNotNull(validationResults); Assert.IsTrue(validationResults.GetObject() is ImportXmlValidationDialog.DuplicateImportXmlRecords); Assert.AreEqual(2, ((ImportXmlValidationDialog.DuplicateImportXmlRecords)validationResults.GetObject()).Duplicates.Count()); }
public void DeploymentImportXmlMaskEmailsTest() { PrepareTests(); var workFolder = ClearFilesAndData(); DeleteAll(Entities.account); var entity = CreateAccount(); Assert.IsFalse(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_")); var accountsExport = new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.account, Entities.account) }; var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = new[] { accountsExport } }; var exportService = new ExportXmlService(XrmRecordService); var ecxportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(ecxportResponse.HasError); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder), MaskEmails = true }; var application = CreateAndLoadTestApplication <ImportXmlModule>(); var immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(immportResponse.HasError); entity = XrmService.GetFirst(Entities.account); Assert.IsTrue(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_")); importRequest = new ImportXmlRequest { Folder = new Folder(workFolder), MaskEmails = false }; application = CreateAndLoadTestApplication <ImportXmlModule>(); immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(immportResponse.HasError); entity = XrmService.GetFirst(Entities.account); Assert.IsFalse(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_")); }
public void DeploymentImportXmlCreateMultipleWithSameNameTest() { var type = Entities.jmcg_testentity; PrepareTests(); var workFolder = ClearFilesAndData(type); var recordName1a = CreateTestRecord(TestEntityType, new Dictionary <string, object> { { Fields.jmcg_testentity_.jmcg_name, "TestName1" } }); var recordName1b = CreateTestRecord(TestEntityType, new Dictionary <string, object> { { Fields.jmcg_testentity_.jmcg_name, "TestName1" } }); var recordName2 = CreateTestRecord(TestEntityType, new Dictionary <string, object> { { Fields.jmcg_testentity_.jmcg_name, "TestName2" } }); var exportService = new ExportXmlService(XrmRecordService); var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = new[] { new ExportRecordType() { RecordType = new RecordType(TestEntityType, TestEntityType) } } }; var exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsTrue(exportResponse.Success); DeleteAll(type); var application = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var response = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(response.HasError); var records = XrmRecordService.RetrieveAll(type, new string[0]); Assert.AreEqual(3, records.Count()); }
public void DeploymentImportXmlMultipleTest() { PrepareTests(); var types = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity }; var workFolder = ClearFilesAndData(types); var importService = new ImportXmlService(XrmRecordService); var createRecords = new List <Entity>(); foreach (var type in types) { createRecords.Add(CreateTestRecord(type, importService)); } var exportService = new ExportXmlService(XrmRecordService); var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = types.Select(t => new ExportRecordType() { RecordType = new RecordType(t, t) }) }; var response = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(response.HasError); foreach (var type in types) { DeleteAll(type); } var application = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); }
public void DeploymentImportXmlKnowledgeArticleTest() { PrepareTests(); var type = "knowledgearticle"; if (XrmRecordService.RecordTypeExists(type)) { DeleteAll(type); var workFolder = ClearFilesAndData(); //create or get a knowledge article var knowledgeArticle = XrmService.GetFirst(type, "articlepublicnumber", PopulateStringValue); if (knowledgeArticle == null) { knowledgeArticle = CreateRecordAllFieldsPopulated("knowledgearticle"); } //export to xml var export = new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(type, type) }; var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = new[] { export } }; var exportService = new ExportXmlService(XrmRecordService); var ecxportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(ecxportResponse.HasError); //okay we will delete then create one with the same article number XrmService.Delete(knowledgeArticle); knowledgeArticle = CreateRecordAllFieldsPopulated("knowledgearticle"); var kaCount = XrmService.RetrieveAllEntityType(type).Count(); //import should match them var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder), MaskEmails = true }; var application = CreateAndLoadTestApplication <ImportXmlModule>(); var immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(immportResponse.HasError); Assert.AreEqual(kaCount, XrmService.RetrieveAllEntityType(type).Count()); //now lets just verify for create (delete it prioor to import) XrmService.Delete(knowledgeArticle); importRequest = new ImportXmlRequest { Folder = new Folder(workFolder), MaskEmails = true }; application = CreateAndLoadTestApplication <ImportXmlModule>(); immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(immportResponse.HasError); Assert.AreEqual(kaCount, XrmService.RetrieveAllEntityType(type).Count()); } }
public void DeploymentImportXmlTypesTest() { var query = new QueryExpression(); PrepareTests(); var types = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity }; var workFolder = ClearFilesAndData(types); var importService = new ImportXmlService(XrmRecordService); var t1_1 = CreateTestRecord(Entities.jmcg_testentity, importService); var t1_2 = CreateTestRecord(Entities.jmcg_testentity, importService); var t1_3 = CreateTestRecord(Entities.jmcg_testentity, importService); var t2_1 = CreateTestRecord(Entities.jmcg_testentitytwo, importService); var t2_2 = CreateTestRecord(Entities.jmcg_testentitytwo, importService); var t2_3 = CreateTestRecord(Entities.jmcg_testentitytwo, importService); var t3_1 = CreateTestRecord(Entities.jmcg_testentitythree, importService); var t3_2 = CreateTestRecord(Entities.jmcg_testentitythree, importService); var t3_3 = CreateTestRecord(Entities.jmcg_testentitythree, importService); var t1RequestAll = new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.jmcg_testentity, Entities.jmcg_testentity) }; var t2RequestFetch = new ExportRecordType() { Type = ExportType.FetchXml, RecordType = new RecordType(Entities.jmcg_testentitytwo, Entities.jmcg_testentitytwo), FetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' count='2' > <entity name='" + Entities.jmcg_testentitytwo + @"'> </entity> </fetch>" }; var t3RequestSpecific = new ExportRecordType() { Type = ExportType.SpecificRecords, RecordType = new RecordType(Entities.jmcg_testentitythree, Entities.jmcg_testentitythree), SpecificRecordsToExport = new[] { new LookupSetting() { Record = new Lookup(Entities.jmcg_testentitythree, t3_1.Id.ToString(), "t3_1") }, new LookupSetting() { Record = new Lookup(Entities.jmcg_testentitythree, t3_2.Id.ToString(), "t3_2") }, } }; var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = new[] { t1RequestAll, t2RequestFetch, t3RequestSpecific } }; var exportService = new ExportXmlService(XrmRecordService); var exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(exportResponse.HasError); var entities = importService.LoadEntitiesFromXmlFiles(workFolder); Assert.AreEqual(7, entities.Count()); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var importResponse = importService.Execute(importRequest, new ServiceRequestController(Controller)); Assert.IsFalse(importResponse.HasError); }
public void DeploymentImportXmlSimpleTest() { var type = TestEntityType; PrepareTests(); var workFolder = ClearFilesAndData(type); var importService = new ImportXmlService(XrmRecordService); var fields = GetFields(type, importService); var updateFields = GetUpdateFields(type, importService); var record = CreateTestRecord(type, importService); var createdEntity = XrmService.Retrieve(record.LogicalName, record.Id); var exportService = new ExportXmlService(XrmRecordService); var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = new[] { new ExportRecordType() { RecordType = new RecordType(TestEntityType, TestEntityType) } } }; var exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsTrue(exportResponse.Success); XrmService.Delete(record); var application = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var response = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(response.HasError); var createdRecord = XrmService.Retrieve(type, createdEntity.Id); foreach (var updateField in updateFields) { Assert.IsTrue(XrmEntity.FieldsEqual(createdEntity.GetField(updateField), createdRecord.GetField(updateField))); } foreach (var field in fields) { record.SetField(field, CreateNewEntityFieldValue(field, type, record)); } XrmService.Update(record); record = XrmService.Retrieve(record.LogicalName, record.Id); importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; application = CreateAndLoadTestApplication <ImportXmlModule>(); response = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(response.HasError); var updatedRecord = XrmService.Retrieve(type, record.Id); foreach (var updateField in updateFields) { Assert.IsTrue(XrmEntity.FieldsEqual(createdEntity.GetField(updateField), updatedRecord.GetField(updateField))); } }
public void DeploymentImportXmlAssociationsAndNotesTest() { PrepareTests(); var types = new[] { Entities.jmcg_testentity }; var workFolder = ClearFilesAndData(types); var importService = new ImportXmlService(XrmRecordService); var createRecords = new List <Entity>(); foreach (var type in types) { for (var i = 0; i < 2; i++) { createRecords.Add(CreateTestRecord(type, importService)); } } //if throws error ensure the test entity allows notes XrmService.Associate(Relationships.jmcg_testentity_.jmcg_testentity_jmcg_testentity.Name, Entities.jmcg_testentity, createRecords[0].Id, true, Entities.jmcg_testentity, createRecords[1].Id); var aNote = CreateTestRecord(Entities.annotation, new Dictionary <string, object> { { Fields.annotation_.objectid, createRecords[0].ToEntityReference() }, { Fields.annotation_.subject, "Test Scripting" }, { Fields.annotation_.notetext, "Just For Importing Testing" }, }); var exportService = new ExportXmlService(XrmRecordService); var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), RecordTypesToExport = types.Select(t => new ExportRecordType() { RecordType = new RecordType(t, t) }), IncludeNNRelationshipsBetweenEntities = true, IncludeNotes = true }; var response = exportService.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(response.HasError); foreach (var type in types) { DeleteAll(type); } var application = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); var rMetadata = XrmService.GetRelationshipMetadata(Relationships.jmcg_testentity_.jmcg_testentity_jmcg_testentity.Name); foreach (var record in createRecords) { var loaded = Refresh(record); if (createRecords[0].Id == loaded.Id) { var notes = XrmService.RetrieveAllAndClauses(Entities.annotation, new[] { new ConditionExpression(Fields.annotation_.objectid, ConditionOperator.Equal, loaded.Id) }); Assert.AreEqual(1, notes.Count()); var associated = XrmService.GetAssociatedIds(rMetadata.SchemaName, rMetadata.Entity1IntersectAttribute, loaded.Id, rMetadata.Entity2IntersectAttribute); Assert.AreEqual(1, associated.Count()); Assert.AreEqual(createRecords[1].Id, associated.First()); } } }
public void DeploymentImportXmlPortalTypeConfigTest() { PrepareTests(); var types = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity }; var workFolder = ClearFilesAndData(types); //okay this script is to verify importing microsoft portal types //which aren't so simple as to just match by name //as for example webpage have a root page, and language specific page(s) //create a web page with an access control rule RecreatePortalData(); var parentWebPage = XrmService.RetrieveAllAndClauses(Entities.adx_webpage, new[] { new ConditionExpression(Fields.adx_webpage_.adx_rootwebpageid, ConditionOperator.Null) }).First(); //export to xml var exportApp = new ExportXmlService(XrmRecordService);// CreateAndLoadTestApplication<ExportXmlModule>(); var exportRequest = new ExportXmlRequest { Folder = new Folder(workFolder), IncludeNNRelationshipsBetweenEntities = true, RecordTypesToExport = new[] { new ExportRecordType() { RecordType = new RecordType(Entities.adx_webrole, Entities.adx_webrole) }, new ExportRecordType() { RecordType = new RecordType(Entities.adx_webpage, Entities.adx_webpage) }, new ExportRecordType() { RecordType = new RecordType(Entities.adx_websitelanguage, Entities.adx_websitelanguage) }, new ExportRecordType() { RecordType = new RecordType(Entities.adx_webpageaccesscontrolrule, Entities.adx_webpageaccesscontrolrule) }, new ExportRecordType() { RecordType = new RecordType(Entities.adx_webform, Entities.adx_webform) }, new ExportRecordType() { RecordType = new RecordType(Entities.adx_webformstep, Entities.adx_webformstep) }, new ExportRecordType() { RecordType = new RecordType(Entities.adx_webformmetadata, Entities.adx_webformmetadata) }, } }; var exportResponse = exportApp.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(exportResponse.HasError); //lets recreate all the web page data so the ids don't match when importing //this will verify it matches them based on the root/unique field configs in XrmTypesConfig RecreatePortalData(); var application = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(workFolder) }; var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); VerifyWebPageRecords(); //lets just do several other things which will verify some other matching logic //delete the root page in the import files - this will verify the language specific page //will correctly resolve its parent independently //despite it having a different id and not being part of the import var parentWebPageFile = FileUtility.GetFiles(workFolder).First(f => f.Contains(parentWebPage.Id.ToString().Replace("-", "_"))); File.Delete(parentWebPageFile); importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); VerifyWebPageRecords(); //delete both web pages in the import files - this will verify the web page access contorl rule //will correctly resolve its parent independently //despite it having a different id and not being part of the import var webPageFile = FileUtility.GetFiles(workFolder).Where(f => f.Contains(Entities.adx_webpage + "_")); foreach (var file in webPageFile) { File.Delete(file); } importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); VerifyWebPageRecords(); //lets do the same but delete the web page access control rule //first to verify it also matches the parent when creating XrmService.Delete(XrmService.GetFirst(Entities.adx_webpageaccesscontrolrule)); importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); VerifyWebPageRecords(); }
public void DeploymentImportXmlProductsAndPricingTest() { PrepareTests(); //created csv files for all the relevant data so lets just hook into that to generate test data GenerateProductData(); //export to xml var exportApp = new ExportXmlService(XrmRecordService);// CreateAndLoadTestApplication<ExportXmlModule>(); var exportRequest = new ExportXmlRequest { Folder = new Folder(WorkFolder), IncludeNNRelationshipsBetweenEntities = true, RecordTypesToExport = new[] { new ExportRecordType() { RecordType = new RecordType(Entities.product, Entities.product) }, new ExportRecordType() { RecordType = new RecordType(Entities.pricelevel, Entities.pricelevel) }, new ExportRecordType() { RecordType = new RecordType(Entities.productpricelevel, Entities.productpricelevel) }, new ExportRecordType() { RecordType = new RecordType(Entities.uom, Entities.uom) }, new ExportRecordType() { RecordType = new RecordType(Entities.uomschedule, Entities.uomschedule) }, } }; //verify no errors var exportResponse = exportApp.Execute(exportRequest, new ServiceRequestController(Controller)); Assert.IsFalse(exportResponse.HasError); //delete all the data so when we import the xml it is creating new DeleteProductData(); //import the xml var application = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(WorkFolder) }; //verify no errors var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); //okay lets get the last created price list item var query = XrmService.BuildQuery(Entities.productpricelevel, null, null, null); query.Orders.Add(new OrderExpression(Fields.productpricelevel_.createdon, OrderType.Descending)); var latestPriceListItem = XrmService.RetrieveFirst(query); //verify it has a price var initialPrice = latestPriceListItem.GetMoneyValue(Fields.productpricelevel_.amount); Assert.IsTrue(initialPrice > 0); //now lets set it something else so we can verify it gets updated after the second run latestPriceListItem.SetMoneyField(Fields.productpricelevel_.amount, initialPrice.Value + 1); latestPriceListItem = UpdateFieldsAndRetreive(latestPriceListItem, Fields.productpricelevel_.amount); //rerun the import application = CreateAndLoadTestApplication <ImportXmlModule>(); importRequest = new ImportXmlRequest { Folder = new Folder(WorkFolder) }; importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importResponse.HasError); //verify the price list item we updated is changed latestPriceListItem = Refresh(latestPriceListItem); Assert.AreEqual(initialPrice, latestPriceListItem.GetMoneyValue(Fields.productpricelevel_.amount)); }
public void DeploymentExportXmlModuleTestExportWithSpecificValues() { DeleteAll(Entities.account); var account = CreateRecordAllFieldsPopulated(Entities.account); FileUtility.DeleteFiles(TestingFolder); var accountRecord = XrmRecordService.Get(account.LogicalName, account.Id.ToString()); var application = CreateAndLoadTestApplication <ExportXmlModule>(); application.AddModule <SavedRequestModule>(); var instance = new ExportXmlRequest(); instance.IncludeNotes = true; instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.account, Entities.account), SpecificRecordsToExport = new LookupSetting[0] } }; var entryForm = application.NavigateToDialogModuleEntryForm <ExportXmlModule, ExportXmlDialog>(); application.EnterObject(instance, entryForm); var recordTypesGrid = entryForm.GetEnumerableFieldViewModel(nameof(ExportXmlRequest.RecordTypesToExport)); var row = recordTypesGrid.GridRecords.First(); row.EditRow(); var exportTypeEntry = entryForm.ChildForms.First() as RecordEntryFormViewModel; Assert.IsNotNull(exportTypeEntry); exportTypeEntry.LoadFormSections(); //okay so at this point we aere in the export type form //need to add a row to the explicit value grid which will open the form var specificValuesGrid = exportTypeEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.ExplicitValuesToSet)); specificValuesGrid.AddRow(); var specificValueEntry = exportTypeEntry.ChildForms.First() as RecordEntryFormViewModel; Assert.IsNotNull(specificValueEntry); specificValueEntry.LoadFormSections(); var fieldSelectionViewModel = specificValueEntry.GetRecordFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.FieldToSet)); var clearValueViewModel = specificValueEntry.GetBooleanFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ClearValue)); //select several field types and verify the field control changes to the correct type for that field fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.customertypecode); Assert.IsTrue(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)) is PicklistFieldViewModel); Assert.IsTrue(specificValueEntry.GetPicklistFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).ItemsSource.Any()); fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.primarycontactid); Assert.IsTrue(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)) is LookupFieldViewModel); specificValueEntry.GetLookupFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).Search(); Assert.IsTrue(specificValueEntry.GetLookupFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).LookupGridViewModel.DynamicGridViewModel.GridRecords.Any()); //verify the field value hidden if we select to clear the value clearValueViewModel.Value = true; Assert.IsFalse(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).IsVisible); clearValueViewModel.Value = false; //okay so this is the specific field and value we will set var fakeExplicitExportValue = "fakeExplicitExportValue"; fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.address1_line1); Assert.IsTrue(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)) is StringFieldViewModel); var descriptionViewModel = specificValueEntry.GetStringFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)); descriptionViewModel.Value = fakeExplicitExportValue; Assert.IsTrue(specificValueEntry.Validate()); specificValueEntry.SaveButtonViewModel.Invoke(); Assert.IsFalse(exportTypeEntry.ChildForms.Any()); //okay lets add an explicit lookup value as well specificValuesGrid = exportTypeEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.ExplicitValuesToSet)); specificValuesGrid.AddRow(); specificValueEntry = exportTypeEntry.ChildForms.First() as RecordEntryFormViewModel; Assert.IsNotNull(specificValueEntry); specificValueEntry.LoadFormSections(); fieldSelectionViewModel = specificValueEntry.GetRecordFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.FieldToSet)); fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.primarycontactid); var lookupFieldViewModel = specificValueEntry.GetLookupFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)); lookupFieldViewModel.Search(); Assert.IsTrue(lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.GridRecords.Any()); lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.SelectedRow = lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.GridRecords.First(); lookupFieldViewModel.OnRecordSelected(lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.GridRecords.First().Record); Assert.IsTrue(specificValueEntry.Validate()); specificValueEntry.SaveButtonViewModel.Invoke(); Assert.IsFalse(exportTypeEntry.ChildForms.Any()); //okay lets add an explicit picklist value as well specificValuesGrid = exportTypeEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.ExplicitValuesToSet)); specificValuesGrid.AddRow(); specificValueEntry = exportTypeEntry.ChildForms.First() as RecordEntryFormViewModel; Assert.IsNotNull(specificValueEntry); specificValueEntry.LoadFormSections(); fieldSelectionViewModel = specificValueEntry.GetRecordFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.FieldToSet)); fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.customertypecode); var picklistFieldViewModel = specificValueEntry.GetPicklistFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)); Assert.IsTrue(picklistFieldViewModel.ItemsSource.Any()); picklistFieldViewModel.Value = picklistFieldViewModel.ItemsSource.First(); Assert.IsTrue(specificValueEntry.Validate()); specificValueEntry.SaveButtonViewModel.Invoke(); Assert.IsFalse(exportTypeEntry.ChildForms.Any()); Assert.IsTrue(exportTypeEntry.Validate()); exportTypeEntry.SaveButtonViewModel.Invoke(); Assert.IsFalse(entryForm.ChildForms.Any()); //okay lets verify save and load object as well //initially the dynamic object property for setting san explicit type //did not seralise due to known types in the serialiser //lets remove any saved requests as this part relies on it being the only saved one var savedRequests = new SavedSettings() { SavedRequests = new object[0] }; var settingsManager = application.Controller.ResolveType <ISettingsManager>(); settingsManager.SaveSettingsObject(savedRequests, typeof(ExportXmlRequest)); //trigger save request var saveRequestButton = entryForm.GetButton("SAVEREQUEST"); saveRequestButton.Invoke(); //enter and save details var saveRequestForm = application.GetSubObjectEntryViewModel(entryForm); var detailsEntered = new SaveAndLoadFields() { Name = "TestName" }; application.EnterAndSaveObject(detailsEntered, saveRequestForm); Assert.IsFalse(entryForm.ChildForms.Any()); Assert.IsFalse(entryForm.LoadingViewModel.IsLoading); //trigger load request var loadRequestButton = entryForm.GetButton("LOADREQUEST"); loadRequestButton.Invoke(); var loadRequestForm = application.GetSubObjectEntryViewModel(entryForm); //select and load the saved request var subGrid = loadRequestForm.GetEnumerableFieldViewModel(nameof(SavedSettings.SavedRequests)); Assert.IsTrue(subGrid.GridRecords.Count() == 1); subGrid.GridRecords.First().IsSelected = true; var loadButton = subGrid.DynamicGridViewModel.GetButton("LOADREQUEST"); loadButton.Invoke(); //verify loads Assert.IsFalse(entryForm.ChildForms.Any()); Assert.IsFalse(entryForm.LoadingViewModel.IsLoading); //this one will invoke the export Assert.IsTrue(entryForm.Validate()); entryForm.SaveButtonViewModel.Invoke(); //verify the exported records had the explicit value we set in them var importServoice = new ImportXmlService(XrmRecordService); var loadEntities = importServoice.LoadEntitiesFromXmlFiles(TestingFolder); foreach (var entity in loadEntities) { Assert.AreEqual(fakeExplicitExportValue, entity.GetStringField(Fields.account_.address1_line1)); } }
public void DeploymentExportXmlModuleTestExportWithBulkAddToGridField() { DeleteAll(Entities.account); var account = CreateRecordAllFieldsPopulated(Entities.account); FileUtility.DeleteFiles(TestingFolder); var accountRecord = XrmRecordService.Get(account.LogicalName, account.Id.ToString()); var application = CreateAndLoadTestApplication <ExportXmlModule>(); var instance = new ExportXmlRequest(); instance.IncludeNotes = true; instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.account, Entities.account), SpecificRecordsToExport = new LookupSetting[0] } }; var entryForm = application.NavigateToDialogModuleEntryForm <ExportXmlModule, ExportXmlDialog>(); application.EnterObject(instance, entryForm); var recordTypesGrid = entryForm.GetEnumerableFieldViewModel(nameof(ExportXmlRequest.RecordTypesToExport)); //okay so we will be doing bulk adds on fields in this grid row var row = recordTypesGrid.GridRecords.First(); row.GetPicklistFieldFieldViewModel(nameof(ExportRecordType.Type)).Value = PicklistOption.EnumToPicklistOption(ExportType.SpecificRecords); //first do it for an Enumerable lookup field (specific records for export) var specificRecordsGridField = row.GetEnumerableFieldViewModel(nameof(ExportRecordType.SpecificRecordsToExport)); Assert.IsTrue(string.IsNullOrWhiteSpace(specificRecordsGridField.StringDisplay)); Assert.IsNull(specificRecordsGridField.DynamicGridViewModel); Assert.IsNotNull(specificRecordsGridField.BulkAddButton); //trigger the add multiple option specificRecordsGridField.BulkAddButton.Invoke(); var bulkAddForm = entryForm.ChildForms.First() as QueryViewModel; //verify a quickfind finds a record bulkAddForm.QuickFindText = account.GetStringField(Fields.account_.name); bulkAddForm.QuickFind(); //select and add bulkAddForm.DynamicGridViewModel.GridRecords.First().IsSelected = true; //this triggered by the grid event bulkAddForm.DynamicGridViewModel.OnSelectionsChanged(); //this is supposed to be the add selected button bulkAddForm.DynamicGridViewModel.CustomFunctions.Last().Invoke(); //verify we now have a record selected and displayed for the field Assert.IsFalse(string.IsNullOrWhiteSpace(specificRecordsGridField.StringDisplay)); //now do it for an Enumerable field (fields for inlcusion) //this sets it in context row.GetBooleanFieldFieldViewModel(nameof(ExportRecordType.IncludeAllFields)).Value = false; var excludeFieldsGrid = row.GetEnumerableFieldViewModel(nameof(ExportRecordType.IncludeOnlyTheseFields)); Assert.IsTrue(string.IsNullOrWhiteSpace(excludeFieldsGrid.StringDisplay)); //trigger the add multiple option excludeFieldsGrid.BulkAddButton.Invoke(); bulkAddForm = entryForm.ChildForms.First() as QueryViewModel; Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); bulkAddForm.QuickFindText = Fields.account_.name; bulkAddForm.QuickFind(); Assert.IsFalse(bulkAddForm.DynamicGridViewModel.GridLoadError, bulkAddForm.DynamicGridViewModel.ErrorMessage); Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); bulkAddForm.DynamicGridViewModel.GridRecords.First().IsSelected = true; //this triggered by the grid event bulkAddForm.DynamicGridViewModel.OnSelectionsChanged(); //this is supposed to be the add selected button bulkAddForm.DynamicGridViewModel.CustomFunctions.Last().Invoke(); Assert.IsFalse(entryForm.ChildForms.Any()); //verify we now have a record selected and displayed for the field Assert.IsFalse(string.IsNullOrWhiteSpace(excludeFieldsGrid.StringDisplay)); }
public void DeploymentExportXmlModuleTest() { //script 2 exports //first one with only one specific field var account = CreateAccount(); FileUtility.DeleteFiles(TestingFolder); var application = CreateAndLoadTestApplication <ExportXmlModule>(); var instance = new ExportXmlRequest(); instance.IncludeNotes = true; instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.account, Entities.account), IncludeAllFields = false, IncludeOnlyTheseFields = new [] { new FieldSetting() { RecordField = new RecordField(Fields.account_.createdby, Fields.account_.createdby) } } } }; var response = application.NavigateAndProcessDialog <ExportXmlModule, ExportXmlDialog, ExportXmlResponse>(instance); Assert.IsFalse(response.HasError); Assert.IsTrue(FileUtility.GetFiles(TestingFolder).Any()); var importXmlService = new ImportXmlService(XrmRecordService); var loaded = importXmlService.LoadEntitiesFromXmlFiles(TestingFolder); foreach (var item in loaded) { Assert.IsNull(item.GetField(Fields.account_.createdon)); Assert.IsNotNull(item.GetField(Fields.account_.createdby)); Assert.IsNotNull(item.GetField(Fields.account_.name)); } FileUtility.DeleteFiles(TestingFolder); //first verify when all fields selected application = CreateAndLoadTestApplication <ExportXmlModule>(); instance = new ExportXmlRequest(); instance.IncludeNotes = true; instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.account, Entities.account), IncludeAllFields = true } }; response = application.NavigateAndProcessDialog <ExportXmlModule, ExportXmlDialog, ExportXmlResponse>(instance); Assert.IsFalse(response.HasError); Assert.IsTrue(FileUtility.GetFiles(TestingFolder).Any()); loaded = importXmlService.LoadEntitiesFromXmlFiles(TestingFolder); foreach (var item in loaded) { Assert.IsNotNull(item.GetField(Fields.account_.createdon)); Assert.IsNotNull(item.GetField(Fields.account_.createdby)); Assert.IsNotNull(item.GetField(Fields.account_.name)); } }
public void DeploymentExportXmlModuleTestExportWithBulkAddToGridAndQuery() { DeleteAll(Entities.account); var account = CreateRecordAllFieldsPopulated(Entities.account); FileUtility.DeleteFiles(TestingFolder); var accountRecord = XrmRecordService.Get(account.LogicalName, account.Id.ToString()); //okay create/navigate to a new entry form entering an ExportXmlRequest var application = CreateAndLoadTestApplication <ExportXmlModule>(); var instance = new ExportXmlRequest(); instance.IncludeNotes = true; instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.SpecificRecords, RecordType = new RecordType(Entities.account, Entities.account), SpecificRecordsToExport = new [] { new LookupSetting() { Record = accountRecord.ToLookup() } } } }; var entryForm = application.NavigateToDialogModuleEntryForm <ExportXmlModule, ExportXmlDialog>(); application.EnterObject(instance, entryForm); //get the record types subgrid var recordTypesGrid = entryForm.GetEnumerableFieldViewModel(nameof(ExportXmlRequest.RecordTypesToExport)); var row = recordTypesGrid.GridRecords.First(); //edit the accounts export record row row.EditRow(); var specificRecordEntry = entryForm.ChildForms.First() as RecordEntryFormViewModel; specificRecordEntry.LoadFormSections(); var specificRecordsGrid = specificRecordEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.SpecificRecordsToExport)); //delete the row we added specificRecordsGrid.GridRecords.First().DeleteRow(); Assert.IsFalse(specificRecordsGrid.GridRecords.Any()); //now add using the add multiple option var customFunction = specificRecordsGrid.DynamicGridViewModel.AddMultipleRowButton; customFunction.Invoke(); var bulkAddForm = specificRecordEntry.ChildForms.First() as QueryViewModel; //verify a quickfind finds a record bulkAddForm.QuickFindText = account.GetStringField(Fields.account_.name); bulkAddForm.QuickFind(); Assert.IsFalse(bulkAddForm.DynamicGridViewModel.GridLoadError, bulkAddForm.DynamicGridViewModel.ErrorMessage); Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); //now do an and query on every field in the entity and verify it works bulkAddForm.QueryTypeButton.Invoke(); var lastCondition = bulkAddForm.FilterConditions.Conditions.Last(); Assert.AreEqual(Entities.account, lastCondition.GetRecordTypeFieldViewModel(nameof(ConditionViewModel.QueryCondition.RecordType)).Value.Key); var fieldViewModel = lastCondition.GetRecordFieldFieldViewModel(nameof(ConditionViewModel.QueryCondition.FieldName)); var validSearchFields = fieldViewModel.ItemsSource.Select(i => i.Key).ToArray(); foreach (var field in validSearchFields) { var fieldvalue = accountRecord.GetField(field); if (fieldvalue != null) { lastCondition = bulkAddForm.FilterConditions.Conditions.Last(); Assert.AreEqual(Entities.account, lastCondition.GetRecordTypeFieldViewModel(nameof(ConditionViewModel.QueryCondition.RecordType)).Value.Key); fieldViewModel = lastCondition.GetRecordFieldFieldViewModel(nameof(ConditionViewModel.QueryCondition.FieldName)); fieldViewModel.Value = fieldViewModel.ItemsSource.ToArray().First(i => i.Key == field); var conditionTypeViewModel = lastCondition.GetPicklistFieldFieldViewModel(nameof(ConditionViewModel.QueryCondition.ConditionType)); conditionTypeViewModel.Value = conditionTypeViewModel.ItemsSource.First(i => i.Value == ConditionType.Equal.ToString()); var valueViewModel = lastCondition.GetFieldViewModel(nameof(ConditionViewModel.QueryCondition.Value)); valueViewModel.ValueObject = fieldvalue; //bulkAddForm.QuickFind(); //Assert.IsFalse(bulkAddForm.DynamicGridViewModel.GridLoadError, bulkAddForm.DynamicGridViewModel.ErrorMessage); //Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); } } bulkAddForm.QuickFind(); Assert.IsFalse(bulkAddForm.DynamicGridViewModel.GridLoadError, bulkAddForm.DynamicGridViewModel.ErrorMessage); Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); //select and add bulkAddForm.DynamicGridViewModel.GridRecords.First().IsSelected = true; //this triggered by the grid event bulkAddForm.DynamicGridViewModel.OnSelectionsChanged(); //this is supposed to be the add selected button bulkAddForm.DynamicGridViewModel.CustomFunctions.Last().Invoke(); //and verify the row was added to the records for export Assert.IsTrue(specificRecordsGrid.GridRecords.Any()); //okay now lets do the equivalent for a grid of fields //set this false so the selection of fields is in context specificRecordEntry.GetBooleanFieldFieldViewModel(nameof(ExportRecordType.IncludeAllFields)).Value = false; //get the fields grid and trigger bulk add function var excludeFieldsGrid = specificRecordEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.IncludeOnlyTheseFields)); //now add using the add multiple option excludeFieldsGrid.DynamicGridViewModel.AddMultipleRowButton.Invoke(); bulkAddForm = specificRecordEntry.ChildForms.First() as QueryViewModel; Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); bulkAddForm.QuickFindText = Fields.account_.name; bulkAddForm.QuickFind(); Assert.IsFalse(bulkAddForm.DynamicGridViewModel.GridLoadError, bulkAddForm.DynamicGridViewModel.ErrorMessage); Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); bulkAddForm.DynamicGridViewModel.GridRecords.First().IsSelected = true; //this triggered by the grid event bulkAddForm.DynamicGridViewModel.OnSelectionsChanged(); //this is supposed to be the add selected button bulkAddForm.DynamicGridViewModel.CustomFunctions.Last().Invoke(); Assert.IsFalse(specificRecordEntry.ChildForms.Any()); //and verify the row was added to the records for export Assert.IsTrue(excludeFieldsGrid.GridRecords.Any()); specificRecordEntry.SaveButtonViewModel.Invoke(); Assert.IsFalse(entryForm.ChildForms.Any()); //okay now lets to bulk add on the record types grid var subGrid = entryForm.GetEnumerableFieldViewModel(nameof(ExportXmlRequest.RecordTypesToExport)); subGrid.DynamicGridViewModel.AddMultipleRowButton.Invoke(); bulkAddForm = entryForm.ChildForms.First() as QueryViewModel; Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); bulkAddForm.QuickFindText = Entities.contact; bulkAddForm.QuickFind(); Assert.IsFalse(bulkAddForm.DynamicGridViewModel.GridLoadError, bulkAddForm.DynamicGridViewModel.ErrorMessage); Assert.IsTrue(bulkAddForm.DynamicGridViewModel.GridRecords.Any()); bulkAddForm.DynamicGridViewModel.GridRecords.First().IsSelected = true; //this triggered by the grid event bulkAddForm.DynamicGridViewModel.OnSelectionsChanged(); //this is supposed to be the add selected button bulkAddForm.DynamicGridViewModel.CustomFunctions.Last().Invoke(); Assert.IsFalse(entryForm.ChildForms.Any()); }
public void DeploymentImportActivityPartiesTest() { PrepareTests(); var contact1 = XrmService.GetFirst(Entities.contact, Fields.contact_.fullname, "TESTEMAIL IMPORT 1") ?? CreateTestRecord(Entities.contact, new Dictionary <string, object> { { Fields.contact_.firstname, "TESTEMAIL" }, { Fields.contact_.lastname, "IMPORT 1" }, { Fields.contact_.emailaddress1, "*****@*****.**" } }); var contact2 = XrmService.GetFirst(Entities.contact, Fields.contact_.fullname, "TESTEMAIL IMPORT 2") ?? CreateTestRecord(Entities.contact, new Dictionary <string, object> { { Fields.contact_.firstname, "TESTEMAIL" }, { Fields.contact_.lastname, "IMPORT 2" }, { Fields.contact_.emailaddress1, "*****@*****.**" } }); var account = XrmService.GetFirst(Entities.account, Fields.account_.name, "TESTEMAILIMPORT") ?? CreateTestRecord(Entities.account, new Dictionary <string, object> { { Fields.account_.name, "TESTEMAILIMPORT" }, { Fields.account_.emailaddress1, "*****@*****.**" } }); var queue = XrmService.GetFirst(Entities.queue, Fields.queue_.name, "TESTQUEUE") ?? CreateTestRecord(Entities.queue, new Dictionary <string, object> { { Fields.queue_.name, "TESTQUEUE" }, { Fields.queue_.emailaddress, "*****@*****.**" } }); var email = new Entity(Entities.email); email.SetField(Fields.email_.subject, "Testing Import Email " + DateTime.Now.ToFileTime().ToString()); email.AddFromParty(queue.LogicalName, queue.Id); email.AddToParty(contact1.LogicalName, contact1.Id); email.AddToParty(contact2.LogicalName, contact2.Id); email.AddToParty(account.LogicalName, account.Id); email.AddActivityParty(Fields.email_.to, "*****@*****.**"); email = CreateAndRetrieve(email); XrmService.SetState(email, OptionSets.Email.ActivityStatus.Completed, OptionSets.Email.StatusReason.Sent); //okay lets xml export var exportXmlApplication = CreateAndLoadTestApplication <ExportXmlModule>(); var instance = new ExportXmlRequest(); instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.SpecificRecords, RecordType = new RecordType(Entities.email, Entities.email), SpecificRecordsToExport = new LookupSetting[] { new LookupSetting() { Record = new Lookup(email.LogicalName, email.Id.ToString(), email.GetStringField(Fields.email_.subject)) } } } }; var exportXmlResponse = exportXmlApplication.NavigateAndProcessDialog <ExportXmlModule, ExportXmlDialog, ExportXmlResponse>(instance); Assert.IsFalse(exportXmlResponse.HasError); //okay lets delete the email then import it XrmService.Delete(email); //do an xml import var importXmlApplication = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(TestingFolder) }; var importXmlResponse = importXmlApplication.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importXmlResponse.HasError); Assert.AreEqual(1, importXmlResponse.ImportSummary.Count()); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Created == 1)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.NoChange == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Errors == 0)); var importedEmail = XrmService.Retrieve(email.LogicalName, email.Id); Assert.AreEqual(OptionSets.Email.StatusReason.Sent, importedEmail.GetOptionSetValue(Fields.email_.statuscode)); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.from).Count() == 1); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.from).Count(p => Entities.queue == p.GetLookupType(Fields.activityparty_.partyid)) == 1); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count() == 4); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count(p => Entities.contact == p.GetLookupType(Fields.activityparty_.partyid)) == 2); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count(p => Entities.account == p.GetLookupType(Fields.activityparty_.partyid)) == 1); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count(p => null == p.GetField(Fields.activityparty_.partyid) && p.GetStringField(Fields.activityparty_.addressused) == "*****@*****.**") == 1); importXmlResponse = importXmlApplication.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importXmlResponse.HasError); Assert.AreEqual(1, importXmlResponse.ImportSummary.Count()); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Created == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.NoChange == 1)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Errors == 0)); importedEmail = XrmService.Retrieve(email.LogicalName, email.Id); XrmService.SetState(importedEmail, OptionSets.Email.ActivityStatus.Open); var toParties = importedEmail.GetActivityParties(Fields.email_.to); importedEmail.SetField(Fields.email_.to, toParties.Skip(1).ToArray()); importedEmail = UpdateFieldsAndRetreive(importedEmail, Fields.email_.to); importXmlResponse = importXmlApplication.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importXmlResponse.HasError); Assert.AreEqual(1, importXmlResponse.ImportSummary.Count()); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Created == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Updated == 1)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.NoChange == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Errors == 0)); importedEmail = XrmService.Retrieve(email.LogicalName, email.Id); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.from).Count() == 1); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.from).Count(p => Entities.queue == p.GetLookupType(Fields.activityparty_.partyid)) == 1); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count() == 4); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count(p => Entities.contact == p.GetLookupType(Fields.activityparty_.partyid)) == 2); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count(p => Entities.account == p.GetLookupType(Fields.activityparty_.partyid)) == 1); Assert.IsTrue(importedEmail.GetActivityParties(Fields.email_.to).Count(p => null == p.GetField(Fields.activityparty_.partyid) && p.GetStringField(Fields.activityparty_.addressused) == "*****@*****.**") == 1); }
public void DeploymentImportMultipleCachingTest() { //this script added when refactored to use execute multiples //so that a script covered resolving matches both with and without //caching target records //generally the scripts use a small number of records //which doesnt exceed the standard cache threshold //this uses a caching and non changing threshold for //a spreadsheet which contain various lookup fields //including circular and multi type lookups //runs through for both excel and xml imports //including where ids do and dont match PrepareTests(); var cacheLimits = new[] { 5, 50 }; var setSize = 10; foreach (var cacheLimit in cacheLimits) { FileUtility.DeleteFiles(TestingFolder); FileUtility.DeleteSubFolders(TestingFolder); var workFolder = TestingFolder + @"\TestImportMultiples"; FileUtility.CheckCreateFolder(workFolder); var sourceExcelFile = Path.Combine(workFolder, @"TestImportMultiples.xlsx"); File.Copy(@"TestImportMultiples.xlsx", sourceExcelFile); DeleteAll(Entities.account); DeleteAll(Entities.jmcg_testentity); DeleteAll(Entities.contact); var importExcelApp = CreateAndLoadTestApplication <ImportExcelModule>(); importExcelApp.AddModule <SavedRequestModule>(); ClearSavedRequests <ImportExcelModule, ImportExcelDialog>(importExcelApp); //navigate to the dialog var dialog = importExcelApp.NavigateToDialog <ImportExcelModule, ImportExcelDialog>(); var entryViewmodel = importExcelApp.GetSubObjectEntryViewModel(dialog); //select the excel file with the errors and submit form entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExcelFile)).ValueObject = new FileReference(sourceExcelFile); entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExecuteMultipleSetSize)).ValueObject = setSize; entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.TargetCacheLimit)).ValueObject = cacheLimit; Assert.IsTrue(entryViewmodel.Validate()); entryViewmodel.SaveButtonViewModel.Invoke(); var importExcelResponse = dialog.CompletionItem as ImportExcelResponse; if (importExcelResponse.HasError) { Assert.Fail(importExcelResponse.GetResponseItemsWithError().First().Exception.XrmDisplayString()); } Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Created > 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.NoChange == 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); //lets do another and verify no errors or changes dialog = importExcelApp.NavigateToDialog <ImportExcelModule, ImportExcelDialog>(); entryViewmodel = importExcelApp.GetSubObjectEntryViewModel(dialog); //select the excel file with the errors and submit form entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExcelFile)).ValueObject = new FileReference(sourceExcelFile); entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExecuteMultipleSetSize)).ValueObject = setSize; entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.TargetCacheLimit)).ValueObject = cacheLimit; Assert.IsTrue(entryViewmodel.Validate()); entryViewmodel.SaveButtonViewModel.Invoke(); importExcelResponse = dialog.CompletionItem as ImportExcelResponse; if (importExcelResponse.HasError) { Assert.Fail(importExcelResponse.GetResponseItemsWithError().First().Exception.XrmDisplayString()); } Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Created == 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.NoChange > 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); //okay lets do an xml export var exportXmlApplication = CreateAndLoadTestApplication <ExportXmlModule>(); var instance = new ExportXmlRequest(); instance.IncludeNNRelationshipsBetweenEntities = true; instance.Folder = new Folder(TestingFolder); instance.RecordTypesToExport = new[] { new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.account, Entities.account), }, new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.contact, Entities.contact), }, new ExportRecordType() { Type = ExportType.AllRecords, RecordType = new RecordType(Entities.jmcg_testentity, Entities.jmcg_testentity), }, }; var exportXmlResponse = exportXmlApplication.NavigateAndProcessDialog <ExportXmlModule, ExportXmlDialog, ExportXmlResponse>(instance); Assert.IsFalse(exportXmlResponse.HasError); //do an xml import var importXmlApplication = CreateAndLoadTestApplication <ImportXmlModule>(); var importRequest = new ImportXmlRequest { Folder = new Folder(TestingFolder) }; var importXmlResponse = importXmlApplication.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importXmlResponse.HasError); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Created == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.NoChange > 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); //do another xml import after deleting the data and recreating with different ids (from excel import) DeleteAll(Entities.account); DeleteAll(Entities.jmcg_testentity); DeleteAll(Entities.contact); importExcelApp = CreateAndLoadTestApplication <ImportExcelModule>(); importExcelApp.AddModule <SavedRequestModule>(); ClearSavedRequests <ImportExcelModule, ImportExcelDialog>(importExcelApp); dialog = importExcelApp.NavigateToDialog <ImportExcelModule, ImportExcelDialog>(); entryViewmodel = importExcelApp.GetSubObjectEntryViewModel(dialog); entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExcelFile)).ValueObject = new FileReference(sourceExcelFile); entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExecuteMultipleSetSize)).ValueObject = setSize; entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.TargetCacheLimit)).ValueObject = cacheLimit; Assert.IsTrue(entryViewmodel.Validate()); entryViewmodel.SaveButtonViewModel.Invoke(); importExcelResponse = dialog.CompletionItem as ImportExcelResponse; if (importExcelResponse.HasError) { Assert.Fail(importExcelResponse.GetResponseItemsWithError().First().Exception.XrmDisplayString()); } Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Created > 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.NoChange == 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); importXmlApplication = CreateAndLoadTestApplication <ImportXmlModule>(); importRequest = new ImportXmlRequest { Folder = new Folder(TestingFolder) }; importXmlResponse = importXmlApplication.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importXmlResponse.HasError); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Created == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Updated == 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.NoChange > 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); //okay finally lets delete half the records just for inclusion of a parital import //xml import half deleted DeleteHalfTheRecords(); importXmlApplication = CreateAndLoadTestApplication <ImportXmlModule>(); importRequest = new ImportXmlRequest { Folder = new Folder(TestingFolder) }; importXmlResponse = importXmlApplication.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest); Assert.IsFalse(importXmlResponse.HasError); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Created > 0)); Assert.IsTrue(importXmlResponse.ImportSummary.Any(i => i.NoChange > 0)); Assert.IsTrue(importXmlResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); //excel import half deleted importExcelApp = CreateAndLoadTestApplication <ImportExcelModule>(); importExcelApp.AddModule <SavedRequestModule>(); ClearSavedRequests <ImportExcelModule, ImportExcelDialog>(importExcelApp); DeleteHalfTheRecords(); dialog = importExcelApp.NavigateToDialog <ImportExcelModule, ImportExcelDialog>(); entryViewmodel = importExcelApp.GetSubObjectEntryViewModel(dialog); entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExcelFile)).ValueObject = new FileReference(sourceExcelFile); entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.ExecuteMultipleSetSize)).ValueObject = setSize; entryViewmodel.GetFieldViewModel(nameof(ImportExcelRequest.TargetCacheLimit)).ValueObject = cacheLimit; Assert.IsTrue(entryViewmodel.Validate()); entryViewmodel.SaveButtonViewModel.Invoke(); importExcelResponse = dialog.CompletionItem as ImportExcelResponse; if (importExcelResponse.HasError) { Assert.Fail(importExcelResponse.GetResponseItemsWithError().First().Exception.XrmDisplayString()); } Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Created > 0)); Assert.IsTrue(importExcelResponse.ImportSummary.Any(i => i.NoChange > 0)); Assert.IsTrue(importExcelResponse.ImportSummary.All(i => i.Errors == 0)); ValidateimportedData(); DeleteAll(Entities.account); DeleteAll(Entities.jmcg_testentity); DeleteAll(Entities.contact); } }