private void TryThisProject(HashSet<DomainObjectDTO> dtos, MockMDCForDataMigration mockMDC, int numOfPubs)
{
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000040, dtos, mockMDC,
@"C:\Path\Not\Used", FwDirectoryFinder.FdoDirectories);
// Do Migration
m_dataMigrationManager.PerformMigration(dtoRepos, 7000041, new DummyProgressDlg());
// Check that the version was updated.
Assert.AreEqual(7000041, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// The LexEntry with ExcludeAsHeadword val="True" should be replaced by
// DoNotShowMainEntryIn with the entire publist as objsur elements.
VerifyReplace(dtoRepos, "7ecbb299-bf35-4795-a5cc-8d38ce8b891c", true, numOfPubs);
// The LexEntry with no ExcludeAsHeadword should have no
// DoNotShowMainEntryIn element.
VerifyReplace(dtoRepos, "77b2397d-19c9-4321-b581-7a4ccfa9fc0e", false, numOfPubs);
// The LexEntry with ExcludeAsHeadword val="False" should have no
// DoNotShowMainEntryIn element.
VerifyReplace(dtoRepos, "a78bb1d7-a86c-40c5-8ad1-8d75b71c4962", false, numOfPubs);
// The LexEntry with ExcludeAsHeadword val="garbled" should have no
// DoNotShowMainEntryIn element.
VerifyReplace(dtoRepos, "1e4ae08a-2672-4df2-9e2d-980be367e893", false, numOfPubs);
}
public void DataMigration7000060Test()
{
var projectFolder = Path.GetTempPath();
var settingsFolder = Path.Combine(projectFolder, FdoFileHelper.ksConfigurationSettingsDir);
var sampleLayout = Path.Combine(settingsFolder, "Test_Layouts.xml");
var otherFile = Path.Combine(settingsFolder, "other.xml");
var newLayoutPath = Path.Combine(settingsFolder, "Test.fwlayout");
// Delete any leftover data from incomplete test (or previous test).
if (Directory.Exists(settingsFolder))
Directory.Delete(settingsFolder, true);
Directory.CreateDirectory(settingsFolder);
File.WriteAllText(sampleLayout, "nonsence", Encoding.UTF8);
File.WriteAllText(otherFile, "rubbish", Encoding.UTF8);
var mockMDC = new MockMDCForDataMigration(); // no classes to migrate here
var dtos = new HashSet<DomainObjectDTO>(); // no objects to migrate
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000059, dtos, mockMDC, projectFolder, FwDirectoryFinder.FdoDirectories);
// Do the migration.
m_dataMigrationManager.PerformMigration(dtoRepos, 7000060, new DummyProgressDlg());
Assert.That(File.Exists(newLayoutPath));
Assert.That(File.Exists(otherFile));
Assert.That(!File.Exists(sampleLayout));
Directory.Delete(settingsFolder, true);
Assert.AreEqual(7000060, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void DowngradeMigrationTest()
{
var mockMDC = new MockMDCForDataMigration();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7100000,
new HashSet<DomainObjectDTO>(), mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000000, null);
}
public void DataMigration7000008Test()
{
// Add at least one ScrScriptureNote which has a null BeginObject prop.
// This ScrScriptureNote should not be removed in this migration.
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000008Tests.xml");
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "CmBaseAnnotation", "LangProject" });
mockMDC.AddClass(2, "LangProject", "CmObject", new List<string>());
mockMDC.AddClass(3, "CmBaseAnnotation", "CmObject", new List<string> { "ScrScriptureNote" });
mockMDC.AddClass(4, "ScrScriptureNote", "CmBaseAnnotation", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000007, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000008, new DummyProgressDlg());
var goners = ((DomainObjectDtoRepository) dtoRepos).Goners;
Assert.AreEqual(4, goners.Count, "Wrong number removed.");
var gonerGuids = new List<string>
{
("54E4A881-23D7-48FC-BD05-14DD0CA86D5B").ToLower(), // Defective Discourse Chart ann.
("22a8431f-f974-412f-a261-8bd1a4e1be1b").ToLower(),
("155B8419-0A9B-44A4-A960-F78983C84768").ToLower(),
("84FC5548-8AB2-4AA0-AFE5-72F64F567982").ToLower()
};
foreach (var goner in goners)
Assert.Contains(goner.Guid.ToLower(), gonerGuids, "Goner guid not found.");
}
public void DataMigration7000015Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000015.xml");
var mockMdc = SetupMdc();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000014, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
// SUT: Do the migration.
m_dataMigrationManager.PerformMigration(dtoRepos, 7000015, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000015, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// PhSimpleContextBdry
var oldClassElementNames = new List<string> { "CmObject", "PhContextOrVar", "PhPhonContext", "PhSimpleContext", "PhSimpleContextBdry" };
var expectedPropertyElements = new List<string> { "Name", "Description", "FeatureStructure" };
VerifyObject(dtoRepos.GetDTO("9719A466-2240-4DEA-9722-9FE0746A30A6"), oldClassElementNames, expectedPropertyElements);
// StText
oldClassElementNames = new List<string> { "CmObject", "StText" };
expectedPropertyElements = new List<string>();
VerifyObject(dtoRepos.GetDTO("C83E33DD-2A79-4A4B-84F6-92343C4F5324"), oldClassElementNames, expectedPropertyElements);
// PhBdryMarker
oldClassElementNames = new List<string> { "CmObject", "PhTerminalUnit", "PhBdryMarker" };
expectedPropertyElements = new List<string>();
VerifyObject(dtoRepos.GetDTO("C83E33DD-2A79-4A4B-84F6-92343C4F5325"), oldClassElementNames, expectedPropertyElements);
}
public void DataMigration7000058Test_SkipNonEmptyGlossAppend()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000058_NonEmptyGlossAppend.xml");
// Set up mock MDC.
var mockMdc = new MockMDCForDataMigration();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000057, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000058, new DummyProgressDlg());
Assert.AreEqual(7000058, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Skip GlossAppend for Irregularly Inflected Form Type (Plural)
{
var iifPlural = dtoRepos.GetDTO(kguidLexTypPluralVar);
var iifNewPluralElt = XElement.Parse(iifPlural.Xml);
Assert.That(iifNewPluralElt.XPathSelectElement("GlossAppend/AUni[@ws='en']").Value,
Is.EqualTo(".pL"));
}
// Skip GlossAppend for Irregularly Inflected Form Type (Past)
{
var iifPast = dtoRepos.GetDTO(kguidLexTypPastVar);
var iifNewPastElt = XElement.Parse(iifPast.Xml);
Assert.That(iifNewPastElt.XPathSelectElement("GlossAppend/AUni[@ws='en']").Value,
Is.EqualTo(".pST"));
}
}
public void DataMigration7000040Test()
{
// Bring in data from xml file.
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000040.xml");
// Create all the Mock classes for the classes in my test data.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "LexEntryRef"});
mockMDC.AddClass(2, "LexEntryRef", "CmObject", new List<string>());
mockMDC.AddClass(3, "LexEntry", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000039, dtos, mockMDC,
FileUtils.ChangePathToPlatform("C:\\WW\\DistFiles\\Projects\\TokPisin"), FwDirectoryFinder.FdoDirectories);
// Do Migration
m_dataMigrationManager.PerformMigration(dtoRepos, 7000040, new DummyProgressDlg());
// Check that the version was updated.
Assert.AreEqual(7000040, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// The empty element should have stayed that way.
VerifyEntryRef(dtoRepos, "82CB0EC6-B542-4FB8-B5B6-41398790DDF9", 0, 0);
// The one with no primary lexemes should have no ShowComplexFormsIn
VerifyEntryRef(dtoRepos, "c1ecaa73-e382-11de-8a39-0800200c9a66", 1, 0);
// The one with one primary lexemes should have one ShowComplexFormsIn (and ComponentLexemes and PrimaryLexemes unchanged)
var osElements = VerifyEntryRef(dtoRepos, "BF274D15-406E-4816-A81F-9B8C70AEF8E5", 2, 1);
Assert.That(osElements.Count(), Is.EqualTo(1));
VerifyObjSur(osElements, 0, "BFC76313-B9E4-4A31-8408-F854D7709E68");
// The one with two primary lexemes should have two in ShowComplexFormsIn (and ComponentLexemes and PrimaryLexemes unchanged)
osElements = VerifyEntryRef(dtoRepos, "B854113C-4B99-46FF-A9F6-ED3F0245E259", 2, 2);
VerifyObjSur(osElements, 0, "6704EB7A-EFEA-42E4-BFAA-9B99B1D45D6F");
VerifyObjSur(osElements, 1, "BFC76313-B9E4-4A31-8408-F854D7709E68");
}
public void DataMigration7000026Test()
{
//Bring in data from xml file.
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000026Tests.xml");
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "CmProject" });
mockMDC.AddClass(2, "CmProject", "CmObject", new List<string> { "LangProject" });
mockMDC.AddClass(3, "LangProject", "CmProject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000025, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
//Before the migration there should be a ExtLinkRootDir element in the project.
var langProjDto = dtoRepos.AllInstancesSansSubclasses("LangProject").First();
var langProjElement = XElement.Parse(langProjDto.Xml);
var langProjExtLinkRootDir = langProjElement.XPathSelectElement("ExtLinkRootDir");
Assert.That(langProjExtLinkRootDir, Is.Not.Null, "Before the migration we should have a 'ExtLinkRootDir' element on LangProj");
m_dataMigrationManager.PerformMigration(dtoRepos, 7000026, new DummyProgressDlg());
//This object should contain a 'LinkedFilesRootDir' property
langProjDto = dtoRepos.AllInstancesSansSubclasses("LangProject").First();
langProjElement = XElement.Parse(langProjDto.Xml);
var langProjLinkedFilesRootDir = langProjElement.XPathSelectElement("LinkedFilesRootDir");
Assert.That(langProjLinkedFilesRootDir, Is.Not.Null, "We should now have a 'LinkedFilesRootDir' element on LangProj");
//This object should not contain an 'AnalysysStatus' property
langProjExtLinkRootDir = langProjElement.XPathSelectElement("ExtLinkRootDir");
Assert.That(langProjExtLinkRootDir, Is.Null, "LangProject ExtLinkRootDir Property should not exist any more");
Assert.AreEqual(7000026, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void DataMigration7000028Test()
{
//Bring in data from xml file.
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000028.xml");
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "CmProject" });
mockMDC.AddClass(2, "CmProject", "CmObject", new List<string> { "LangProject" });
mockMDC.AddClass(3, "LangProject", "CmProject", new List<string>());
mockMDC.AddClass(4, "LexDb", "CmObject", new List<string> ());
mockMDC.AddClass(5, "LexEntry", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000027, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000028, new DummyProgressDlg());
// The Entries property of the LexDb should be gone.
var lexDbDto = dtoRepos.AllInstancesSansSubclasses("LexDb").First();
var lexDbElement = XElement.Parse(lexDbDto.Xml);
var entriesElt = lexDbElement.Element("Entries");
Assert.That(lexDbElement.Name.LocalName, Is.EqualTo("rt"));
Assert.That(entriesElt, Is.Null);
// LexEntries should no longer know owners.
var entryDto = dtoRepos.AllInstancesSansSubclasses("LexEntry").First();
var entryElt = XElement.Parse(entryDto.Xml);
var ownerAttr = entryElt.Attribute("ownerguid");
Assert.That(ownerAttr, Is.Null);
Assert.AreEqual(7000028, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void DataMigration7000065Test()
{
var mockMdc = new MockMDCForDataMigration();
mockMdc.AddClass(1, "CmObject", null, new List<string> { "CmMajorObject", "CmPossibility" });
mockMdc.AddClass(2, "CmMajorObject", "CmObject", new List<string>() { "LexDb", "CmPossibilityList", "ReversalIndex" });
mockMdc.AddClass(3, "LexDb", "CmMajorObject", new List<string>());
mockMdc.AddClass(4, "CmPossibilityList", "CmMajorObject", new List<string>());
mockMdc.AddClass(5, "ReversalIndex", "CmMajorObject", new List<string>());
mockMdc.AddClass(6, "CmPossibility", "CmObject", new List<string>() {"PartOfSpeech"});
mockMdc.AddClass(7, "PartOfSpeech", "CmPossibility", new List<string>());
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000065.xml");
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000064, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000065, new DummyProgressDlg());
var possListsList = dtoRepos.AllInstancesSansSubclasses("CmPossibilityList").ToArray();
Assert.AreEqual(2, possListsList.Length, "Wrong number of Possibility Lists");
var enPoslist = possListsList[0];
var frPoslist = possListsList[1];
var enPoslistElt = XElement.Parse(enPoslist.Xml);
var frPoslistElt = XElement.Parse(frPoslist.Xml);
// Check that English Parts of Speech list's Name didn't change
var enName = enPoslistElt.Element("Name"); // this one shouldn't change
var enNameStrings = enName.Elements("AUni");
Assert.AreEqual(1, enNameStrings.Count(), "Changed number of Name strings.");
var enNameStr = enNameStrings.First().Value;
Assert.AreEqual("RandomEnglish", enNameStr, "Name of list changed");
// Check that French Parts of Speech list's Name got created.
var frName = frPoslistElt.Element("Name"); // should have been created
var frNameStrings = frName.Elements("AUni");
Assert.AreEqual(2, frNameStrings.Count(), "Should have created 2 Name strings.");
var frNameStr1 = frNameStrings.First().Value;
var frNameStr2 = frNameStrings.Last().Value;
Assert.AreEqual(string.Format(Strings.ksReversalIndexPOSListName, "French"), frNameStr1,
"Name1 was not created correctly.");
Assert.AreEqual(string.Format(Strings.ksReversalIndexPOSListName, "German"), frNameStr2,
"Name2 was not created correctly.");
// Check that ItemClsId was added to French parts of speech list
var frItemClsId = frPoslistElt.Element("ItemClsid").Attribute("val").Value;
Assert.AreEqual("5049", frItemClsId, "Migration added wrong ItemClsid.");
// Check that both IsSorted were changed to 'True'
var enIsSorted = enPoslistElt.Element("IsSorted").Attribute("val").Value;
Assert.AreEqual("True", enIsSorted, "English IsSorted didn't get changed.");
var frIsSorted = frPoslistElt.Element("IsSorted").Attribute("val").Value;
Assert.AreEqual("True", frIsSorted, "French IsSorted didn't get changed.");
// Check that both Depths were changed to '127'
var enDepth = enPoslistElt.Element("Depth").Attribute("val").Value;
Assert.AreEqual("127", enDepth, "English Depth didn't get changed.");
var frDepth = frPoslistElt.Element("Depth").Attribute("val").Value;
Assert.AreEqual("127", frDepth, "French Depth didn't get changed.");
Assert.AreEqual(7000065, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void DataMigration7000032Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000033.xml");
IFwMetaDataCacheManaged mockMdc = DataMigrationTests7000020.SetupMdc();
IDomainObjectDTORepository repoDto = new DomainObjectDtoRepository(7000032, dtos, mockMdc,
Path.GetTempPath(), FwDirectoryFinder.FdoDirectories);
var projectFolder = repoDto.ProjectFolder;
var projectName = Path.GetFileNameWithoutExtension(projectFolder);
// This is equivalent to DirectoryFinder.GetConfigSettingsDir(projectFolder) at the time of creating
// the migration, but could conceivably change later.
var targetDir = Path.Combine(projectFolder, "ConfigurationSettings");
Directory.CreateDirectory(targetDir);
var testFilePath = Path.Combine(targetDir, "LexEntry_Layouts.xml");
using (var writer = new StreamWriter(testFilePath))
{
writer.WriteLine(@"<LayoutInventory>" +
"<layout class='LexEntry' type='jtview' name='publishStemPara' css='$fwstyle=Dictionary-Normal' version='9'>" +
" <part ref='Headword' label='Headword' before='' sep=' ' after=' ' ws='vernacular' wsType='vernacular' style='Dictionary-Headword' css='headword' visibility='ifdata' comment='Headword is a smart field. It is the lexeme form unless there is a citation form. Includes Homograph number and affix marking.' />" +
" <part ref='$child' label='testYYY' before='' after=' ' visibility='ifdata' ws='$ws=analysis' wsType='analysis vernacular' sep=' ' showLabels='false'>" +
" <configureMlString field='custom' class='LexEntry' />" +
" </part>" +
"<part ref='$child' label='TestXXX' before='' after=' ' visibility='ifdata'>" +
" <string field='custom1' class='LexEntry' />" +
"</part>" +
" <part ref='$child' label='messed up' before='' after=' ' visibility='ifdata' ws='$ws=analysis' wsType='analysis vernacular' sep=' ' showLabels='false' originalLabel='testBB'>" +
" <configureMlString field='custom' class='LexEntry' />" +
" </part>" +
"<part ref='$child' label='modified' before='' after=' ' visibility='ifdata' originalLabel='TestZZZ'>" +
" <string field='custom1' class='LexEntry' />" +
"</part>" +
" <part ref='$child' before='' after=' ' visibility='ifdata' ws='$ws=analysis' wsType='analysis vernacular' sep=' ' showLabels='false' originalLabel='testCC'>" +
" <configureMlString field='custom' class='LexEntry' />" +
" </part>" +
"<part ref='$child' before='' after=' ' visibility='ifdata' originalLabel='TestD'>" +
" <string field='custom1' class='LexEntry' />" +
"</part>" +
"</layout>" +
"</LayoutInventory>");
writer.Close();
}
// Do the migration.
m_dataMigrationManager.PerformMigration(repoDto, 7000033, new DummyProgressDlg());
Assert.AreEqual(7000033, repoDto.CurrentModelVersion, "Wrong updated version.");
var root = XElement.Load(testFilePath); // layout inventory node
var layout = root.Elements().ToList()[0];
var children = layout.Elements().ToList();
VerifyChild(children[1], "testYYY");
VerifyChild(children[2], "TestXXX");
VerifyChild(children[3], "testBB");
VerifyChild(children[4], "TestZZZ");
VerifyChild(children[5], "testCC");
VerifyChild(children[6], "TestD");
}
public void DataMigration7000023Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000023.xml");
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "LangProject", "DsDiscourseData", "LexDb", "RnResearchNbk",
"CmPossibilityList", "CmFilter", "UserView", "UserAppFeatAct", "CmResource", "ScrCheckRun" });
mockMDC.AddClass(2, "LangProject", "CmObject", new List<string>());
mockMDC.AddClass(3, "DsDiscourseData", "CmObject", new List<string>());
mockMDC.AddClass(4, "LexDb", "CmObject", new List<string>());
mockMDC.AddClass(5, "CmPossibilityList", "CmObject", new List<string>());
mockMDC.AddClass(6, "CmFilter", "CmObject", new List<string>());
mockMDC.AddClass(7, "UserView", "CmObject", new List<string>());
mockMDC.AddClass(8, "UserAppFeatAct", "CmObject", new List<string>());
mockMDC.AddClass(9, "CmResource", "CmObject", new List<string>());
mockMDC.AddClass(10, "ScrCheckRun", "CmObject", new List<string>());
mockMDC.AddClass(11, "RnResearchNbk", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000022, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
//SUT
m_dataMigrationManager.PerformMigration(dtoRepos, 7000023, new DummyProgressDlg());
// Verification section
var dto = dtoRepos.GetDTO("c1ecaa73-e382-11de-8a39-0800200c9a66");
var rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Element("LexDb").Element("objsur").Attribute("guid").Value);
dto = dtoRepos.GetDTO("c1ec5c4c-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Attribute("ownerguid").Value);
dto = dtoRepos.GetDTO("c1Ecaa74-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Attribute("guid").Value);
dto = dtoRepos.GetDTO("AF26D792-EA5E-11DE-8F7E-0013722F8DEC");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Attribute("guid").Value);
dto = dtoRepos.GetDTO("1FBDC211-32E4-4203-9B7F-9CAACBF31DBD");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Attribute("guid").Value);
CheckGuid(rtElement.Element("ListVersion").Attribute("val").Value);
dto = dtoRepos.GetDTO("c1ecaa77-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Element("App").Attribute("val").Value);
dto = dtoRepos.GetDTO("c1ecaa78-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Element("App").Attribute("val").Value);
dto = dtoRepos.GetDTO("c1ecaa79-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Element("ApplicationId").Attribute("val").Value);
dto = dtoRepos.GetDTO("c1ecaa7a-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Element("Version").Attribute("val").Value);
dto = dtoRepos.GetDTO("c1ecd170-e382-11de-8a39-0800200c9a66");
rtElement = XElement.Parse(dto.Xml);
CheckGuid(rtElement.Element("CheckId").Attribute("val").Value);
Assert.AreEqual(7000023, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void NonExistantGuidTest()
{
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(
1,
new HashSet<DomainObjectDTO>(),
m_mdc,
null, FwDirectoryFinder.FdoDirectories);
dtoRepos.GetDTO(Guid.NewGuid().ToString());
}
public void DataMigration7000012_Unneeded_UserViewField_Removed_Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000012_UserViewField.xml");
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "UserViewField" });
mockMDC.AddClass(2, "UserViewField", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000011, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
Assert.AreEqual(40, dtoRepos.AllInstancesWithSubclasses("UserViewField").Count());
// Collect the UserViewField values.
var userViewFieldDtos = new Dictionary<string, DomainObjectDTO>();
foreach (var uvfDto in dtoRepos.AllInstancesWithSubclasses("UserViewField"))
userViewFieldDtos.Add(uvfDto.Guid.ToUpper(), uvfDto);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000012, new DummyProgressDlg());
// Counts for fields that should not have been removed.
int countRequired = 0;
int countStyle = 0;
int countHelpString = 0;
int countFlid = 0;
int countType = 0;
foreach (var userViewField in dtoRepos.AllInstancesSansSubclasses("UserViewField"))
{
var uvfElement = XElement.Parse(userViewField.Xml);
// Confirm that needed fields are still present.
// Increment counter for fields occurring in UserViewField (but some may not always be present).
if (uvfElement.XPathSelectElement("UserViewField/Required") != null)
countRequired++;
if (uvfElement.XPathSelectElement("UserViewField/Style") != null)
countStyle++;
if (uvfElement.XPathSelectElement("UserViewField/HelpString") != null)
countHelpString++;
if (uvfElement.XPathSelectElement("UserViewField/Flid") != null)
countFlid++;
if (uvfElement.XPathSelectElement("UserViewField/Type") != null)
countType++;
// Try to get the unused elements in UserViewField (should be gone)
Assert.IsNull(uvfElement.XPathSelectElement("UserViewField/Details"));
Assert.IsNull(uvfElement.XPathSelectElement("UserViewField/Visibility"));
Assert.IsNull(uvfElement.XPathSelectElement("UserViewField/SubfieldOf"));
Assert.IsNull(uvfElement.XPathSelectElement("UserViewField/IsCustomField"));
}
// Expectations for occurrences of fields that should not have been removed from XML file
Assert.AreEqual(1, countStyle, "Unexpected number of Style fields");
Assert.AreEqual(3, countRequired, "Unexpected number of Required fields");
Assert.AreEqual(36, countHelpString, "Unexpected number of HelpString fields");
Assert.AreEqual(40, countFlid, "Unexpected number of Flid fields");
Assert.AreEqual(40, countType, "Unexpected number of Type fields");
}
public void DataMigration7000009Test()
{
var dtos = new HashSet<DomainObjectDTO>();
var sb = new StringBuilder();
// 1. Add barebones LP.
sb.Append("<rt class=\"LangProject\" guid=\"9719A466-2240-4DEA-9722-9FE0746A30A6\">");
sb.Append("<LangProject>");
sb.Append("<Texts>");
var lpTextsGuids = new StTextAndParaInfo("9719A466-2240-4DEA-9722-9FE0746A30A6", "Normal");
sb.Append("<objsur guid=\"" + lpTextsGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Texts>");
sb.Append("<TranslatedScripture>");
sb.Append("<objsur guid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" t=\"o\" />");
sb.Append("</TranslatedScripture>");
sb.Append("</LangProject>");
sb.Append("</rt>");
var expectedLp = sb.ToString();
var lpDto = new DomainObjectDTO("9719A466-2240-4DEA-9722-9FE0746A30A6",
"LangProject",
expectedLp);
dtos.Add(lpDto);
// 2. Add Scripture
sb = new StringBuilder();
sb.Append(
"<rt class=\"Scripture\" guid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" ownerguid=\"9719A466-2240-4DEA-9722-9FE0746A30A6\"");
int index = sb.Length;
sb.Append(">");
sb.Append("<Scripture>");
sb.Append("<Books>");
sb.Append("<objsur guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" t=\"o\" />");
sb.Append("</Books>");
sb.Append("</Scripture>");
sb.Append("</rt>");
string expected = sb.ToString();
sb.Insert(index, " owningflid=\"6001040\" owningord=\"0\"");
var scrDto = new DomainObjectDTO("2c5c1f5f-1f08-41d7-99fe-23893ee4ceef",
"Scripture",
sb.ToString());
dtos.Add(scrDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "LangProject", "Scripture" });
mockMDC.AddClass(2, "LangProject", "CmObject", new List<string>());
mockMDC.AddClass(4, "Scripture", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000008, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000009, new DummyProgressDlg());
Assert.AreEqual(expected, scrDto.Xml);
Assert.AreEqual(expectedLp, lpDto.Xml);
Assert.AreEqual(7000009, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void DataMigration7000016Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000016.xml");
var mockMdc = SetupMdc();
IDomainObjectDTORepository repoDTO = new DomainObjectDtoRepository(7000015, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
// SUT: Do the migration.
m_dataMigrationManager.PerformMigration(repoDTO, 7000016, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000016, repoDTO.CurrentModelVersion, "Wrong updated version.");
DomainObjectDTO nbkDto = null;
foreach (DomainObjectDTO dot in repoDTO.AllInstancesSansSubclasses("RnResearchNbk"))
{
nbkDto = dot;
break;
}
Assert.NotNull(nbkDto);
XElement nbkElem = XElement.Parse(nbkDto.Xml);
var recTypesGuid = (string)nbkElem.XPathSelectElement("RecTypes/objsur").Attribute("guid");
Assert.AreEqual(recTypesGuid.ToLowerInvariant(), ksguidRecTypesList);
// All we can guarantee being able to check are those items that we create, and to a
// limited degree, those items that are moved to belong to a created item.
bool fFoundEvent = false;
bool fFoundMethod = false;
bool fFoundWeather = false;
foreach (DomainObjectDTO dto in repoDTO.GetDirectlyOwnedDTOs(ksguidRecTypesList))
{
string sguid = dto.Guid.ToLowerInvariant();
Assert.AreNotEqual(sguid, ksguidObservation);
Assert.AreNotEqual(sguid, ksguidConversation);
Assert.AreNotEqual(sguid, ksguidInterview);
Assert.AreNotEqual(sguid, ksguidPerformance);
if (sguid == ksguidEvent)
{
fFoundEvent = true;
CheckEventSubTypes(repoDTO);
}
else if (sguid == ksguidMethodology)
{
fFoundMethod = true;
}
else if (sguid == ksguidWeather)
{
fFoundWeather = true;
}
}
Assert.IsTrue(fFoundEvent);
Assert.IsTrue(fFoundMethod);
Assert.IsTrue(fFoundWeather);
}
public void DataMigration7000056Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000056.xml");
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000055, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000056, new DummyProgressDlg());
Assert.AreEqual(7000056, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// check that PhPhonData has the PhonRuleFeats possibility list
{
var dtosList = dtoRepos.AllInstancesSansSubclasses("PhPhonData");
DomainObjectDTO dtoPhPhonDataTest = dtosList.First();
CheckPhPhonData(dtoPhPhonDataTest, dtoRepos);
}
// In the extremely unlikely event that there is no PhPhonData yet, check that we add it
{
dtos = new HashSet<DomainObjectDTO>();
var sb = new StringBuilder();
// Add WfiMorphBundle that already has a form.
const string sGuid_wmbLangProj = "00b35f9f-86ce-4f07-bde7-b65c28503641";
sb.AppendFormat("<rt class=\"LangProj\" guid=\"{0}\">", sGuid_wmbLangProj);
sb.Append("</rt>");
var dtoLangProj = new DomainObjectDTO(sGuid_wmbLangProj, "LangProj", sb.ToString());
dtos.Add(dtoLangProj);
sb.Length = 0;
mockMDC = new MockMDCForDataMigration();
dtoRepos = new DomainObjectDtoRepository(7000055, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000056, new DummyProgressDlg());
Assert.AreEqual(7000056, dtoRepos.CurrentModelVersion, "Wrong updated version.");
var dtosList = dtoRepos.AllInstancesSansSubclasses("LangProj");
DomainObjectDTO dtoLangProjTest = dtosList.First();
var eltWmbLangProjTest = XElement.Parse(dtoLangProjTest.Xml);
// get phon rule feats
var eltPhonologicalDataTest = eltWmbLangProjTest.Element("PhonologicalData");
Assert.IsNotNull(eltPhonologicalDataTest);
var eltObjsurTest = eltPhonologicalDataTest.Element("objsur");
Assert.IsNotNull(eltObjsurTest);
// get possibility list itself
var guidPhPhonDataTest = eltObjsurTest.Attribute("guid").Value;
Assert.IsNotNull(guidPhPhonDataTest);
DomainObjectDTO dtoPhPhonDataTest;
dtoRepos.TryGetValue(guidPhPhonDataTest, out dtoPhPhonDataTest);
Assert.IsNotNull(dtoPhPhonDataTest);
CheckPhPhonData(dtoPhPhonDataTest, dtoRepos);
}
}
public void DeleteWeatherListAndField()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000017.xml");
var mockMdc = SetupMdc();
IDomainObjectDTORepository repoDTO = new DomainObjectDtoRepository(7000016, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
// SUT: Do the migration.
m_dataMigrationManager.PerformMigration(repoDTO, 7000017, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000017, repoDTO.CurrentModelVersion, "Wrong updated version.");
DomainObjectDTO dtoLP = null;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("LangProject"))
{
Assert.IsNull(dtoLP, "Only one LangProject object should exist");
dtoLP = dto;
}
Assert.NotNull(dtoLP, "The LangProject object should exist");
string sXml = dtoLP.Xml;
Assert.IsFalse(sXml.Contains("<WeatherConditions>"), "The <WeatherConditions> element should have disappeared");
string sLpOwnerGuid = GetGuidAsOwnerGuid(sXml);
DomainObjectDTO dtoNbk = null;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("RnResearchNbk"))
{
Assert.IsNull(dtoNbk, "Only one RnResearchNbk should exist");
Assert.IsTrue(dto.Xml.Contains(sLpOwnerGuid), "The RnResearchNbk should be owned by the LangProject");
dtoNbk = dto;
}
Assert.NotNull(dtoNbk, "The RnResearchNbk should exist");
string sNbkOwnerGuid = GetGuidAsOwnerGuid(dtoNbk.Xml);
int cList = 0;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("CmPossibilityList"))
{
sXml = dto.Xml;
Assert.IsTrue(sXml.Contains(sNbkOwnerGuid), "Possibility List must be owned by Data Notebook");
++cList;
}
Assert.AreEqual(1, cList, "Only one CmPossibilityList should exist");
foreach (DomainObjectDTO dto in repoDTO.AllInstancesWithSubclasses("RnGenericRec"))
{
Assert.IsFalse(dto.Xml.Contains("<Weather"), "Any <Weather> element should have disappeared");
Assert.IsFalse(dto.Xml.Contains("<Custom name="), "No <Custom> element should have been created");
}
// This test file has three overlays; the first refers to a weather item and the weather possibility list,
// and should be delted. The second refers to a non-weather possibility, and the third to a non-weather
// possibility list; they should survive.
Assert.That(repoDTO.AllInstancesSansSubclasses("CmOverlay"), Has.Count.EqualTo(2));
}
public void DataMigration7000059Test()
{
//Bring in data from xml file.
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000059.xml");
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "CmProject" });
mockMDC.AddClass(2, "CmProject", "CmObject", new List<string> { "LangProject" });
mockMDC.AddClass(3, "LangProject", "CmProject", new List<string>());
mockMDC.AddClass(4, "CmMajorObject", "CmObject", new List<string>() { "RnResearchNbk", "Text" });
mockMDC.AddClass(5, "RnResearchNbk", "CmMajorObject", new List<string>());
mockMDC.AddClass(6, "Text", "CmMajorObject", new List<string>());
mockMDC.AddClass(7, "RnGenericRec", "CmObject", new List<string> ());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000058, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000059, new DummyProgressDlg());
// The Texts property of the LangProject should be gone.
var lp = dtoRepos.AllInstancesSansSubclasses("LangProject").First();
var lpElement = XElement.Parse(lp.Xml);
var textsElt = lpElement.Element("Texts");
Assert.That(lpElement.Name.LocalName, Is.EqualTo("rt"));
Assert.That(textsElt, Is.Null);
// The Text property of the RnGenericRec should be Reference Atomic instead of owned.
var rnRec = dtoRepos.AllInstancesSansSubclasses("RnGenericRec").First();
var rnRecElement = XElement.Parse(rnRec.Xml);
var textElt = rnRecElement.Element("Text");
Assert.That(rnRecElement.Name.LocalName, Is.EqualTo("rt"));
Assert.That(textElt, Is.Not.Null);
var objsurType = GetObjsurType(textElt);
Assert.AreEqual("r", objsurType, "Should have changed from owned to reference type");
// Texts should no longer know owners.
// First test the one that was owned by the LangProject
var allTextDtos = dtoRepos.AllInstancesSansSubclasses("Text");
var textDto = allTextDtos.First();
textElt = XElement.Parse(textDto.Xml);
var ownerAttr = textElt.Attribute("ownerguid");
Assert.That(ownerAttr, Is.Null);
// Then test the one that was owned by the DN record
textDto = allTextDtos.Last();
textElt = XElement.Parse(textDto.Xml);
ownerAttr = textElt.Attribute("ownerguid");
Assert.That(ownerAttr, Is.Null);
Assert.AreEqual(7000059, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void AllRegularBasicDataPropertiesExistAfterDataMigration66()
{
var mockMdc = new MockMDCForDataMigration();
mockMdc.AddClass(1, "CmObject", null, new List<string> { "RegularPropertyMagnet" });
mockMdc.AddClass(2, "RegularPropertyMagnet", "CmObject", new List<string>());
// These are all present in the original data file and act as controls.
// They should not be changed.
var currentFlid = 2000;
mockMdc.AddField(++currentFlid, "ExtantOwningAtomic", CellarPropertyType.OwningAtom, 2);
mockMdc.AddField(++currentFlid, "ExtantBooleanProperty", CellarPropertyType.Boolean, 0);
mockMdc.AddField(++currentFlid, "ExtantGenDateProperty", CellarPropertyType.GenDate, 0);
mockMdc.AddField(++currentFlid, "ExtantGuidProperty", CellarPropertyType.Guid, 0);
// Not used in model yet (as of 23 march 2013) mockMdc.AddField(++currentFlid, "ExtantFloatProperty", CellarPropertyType.Float, 0);
mockMdc.AddField(++currentFlid, "ExtantIntegerProperty", CellarPropertyType.Integer, 0);
// Not used in model yet (as of 23 march 2013) var mockMdc.AddField(++currentFlid, "ExtantNumericProperty", CellarPropertyType.Numeric, 0);
mockMdc.AddField(++currentFlid, "ExtantTimeProperty", CellarPropertyType.Time, 0);
// These are all missing in the original data file.
// They should all end up with the default values for the given type of data.
mockMdc.AddField(++currentFlid, "NewBooleanProperty", CellarPropertyType.Boolean, 0);
mockMdc.AddField(++currentFlid, "NewGenDateProperty", CellarPropertyType.GenDate, 0);
mockMdc.AddField(++currentFlid, "NewGuidProperty", CellarPropertyType.Guid, 0);
// Not used in model yet (as of 23 march 2013) mockMdc.AddField(++currentFlid, "NewFloatProperty", CellarPropertyType.Float, 0);
mockMdc.AddField(++currentFlid, "NewIntegerProperty", CellarPropertyType.Integer, 0);
// Not used in model yet (as of 23 march 2013) mockMdc.AddField(++currentFlid, "NewNumericProperty", CellarPropertyType.Numeric, 0);
mockMdc.AddField(++currentFlid, "NewTimeProperty", CellarPropertyType.Time, 0);
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000066_RegularPropertyMagnet.xml");
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000065, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000066, new DummyProgressDlg());
var magnet = XElement.Parse(dtoRepos.AllInstancesSansSubclasses("RegularPropertyMagnet").First().Xml);
// Check the 'control' props to make sure they were not changed.
Assert.AreEqual("e268fe80-5d9d-4f6b-a68f-37db8218b15d", magnet.Element("ExtantOwningAtomic").Element("objsur").Attribute("guid").Value);
Assert.AreEqual("True", GetRegularPropertyValue(magnet, "ExtantBooleanProperty"));
Assert.AreEqual("-201303233", GetRegularPropertyValue(magnet, "ExtantGenDateProperty"));
Assert.AreEqual("c1ee311b-e382-11de-8a39-0800200c9a66", GetRegularPropertyValue(magnet, "ExtantGuidProperty"));
Assert.AreEqual("1", GetRegularPropertyValue(magnet, "ExtantIntegerProperty"));
Assert.AreEqual("2006-3-12 18:19:46.87", GetRegularPropertyValue(magnet, "ExtantTimeProperty"));
// Check the newly added props to make sure they are present and using default values.
Assert.AreEqual("False", GetRegularPropertyValue(magnet, "NewBooleanProperty"));
Assert.AreEqual("-000000000", GetRegularPropertyValue(magnet, "NewGenDateProperty"));
Assert.AreEqual(Guid.Empty.ToString(), GetRegularPropertyValue(magnet, "NewGuidProperty"));
Assert.AreEqual("0", GetRegularPropertyValue(magnet, "NewIntegerProperty"));
Assert.IsNotNull(GetRegularPropertyValue(magnet, "NewTimeProperty"));
}
public void DataMigration7000014Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000014_Evaluations.xml");
var mockMDC = SetupMDC();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000013, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
// SUT; Do the migration.
m_dataMigrationManager.PerformMigration(dtoRepos, 7000014, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000014, dtoRepos.CurrentModelVersion, "Wrong updated version.");
//
var firstAgent = dtoRepos.GetDTO("c1ec8357-e382-11de-8a39-0800200c9a66");
var secondAgent = dtoRepos.GetDTO("c1ec8357-e382-11de-8a39-0800200c9a67");
var thirdAgent = dtoRepos.GetDTO("c1ec8357-e382-11de-8a39-0800200c9a68");
var emptyAgent = dtoRepos.GetDTO("c1ec8357-e382-11de-8a39-0800200c9a6c");
var firstAnalysis = dtoRepos.GetDTO("c84614e6-168b-4304-a025-0d6ae6573086");
var secondAnalysis = dtoRepos.GetDTO("c84614e6-168b-4304-a025-0d6ae6573087");
string firstApprovesGuid,
firstDisapprovesGuid,
secondApprovesGuid,
secondDisapprovesGuid,
thirdApprovesGuid,
thirdDisapprovesGuid,
emptyApprovesGuid,
emptyDisapprovesGuid;
VerifyAgent(firstAgent, dtoRepos, out firstApprovesGuid, out firstDisapprovesGuid);
VerifyAgent(secondAgent, dtoRepos, out secondApprovesGuid, out secondDisapprovesGuid);
VerifyAgent(thirdAgent, dtoRepos, out thirdApprovesGuid, out thirdDisapprovesGuid);
VerifyAgent(emptyAgent, dtoRepos, out emptyApprovesGuid, out emptyDisapprovesGuid);
VerifyAnalysis(firstAnalysis, new string[] {firstApprovesGuid, secondDisapprovesGuid, thirdApprovesGuid});
VerifyAnalysis(secondAnalysis, new string[] { firstApprovesGuid });
var goners = ((DomainObjectDtoRepository)dtoRepos).Goners;
Assert.AreEqual(4, goners.Count, "Wrong number removed.");
var gonerGuids = new List<string>
{
("c84614e6-168b-4304-a025-0d6ae6573085").ToLower(),
("c84614e6-168b-4304-a025-0d6ae6573088").ToLower(),
("8151a002-a32e-476f-9c32-f95ee48fc71c").ToLower(),
("c84614e6-168b-4304-a025-0d6ae657308a").ToLower()
};
foreach (var goner in goners)
Assert.Contains(goner.Guid.ToLower(), gonerGuids, "Goner guid not found.");
}
public void PerformMigration7000018()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000018.xml");
var mockMdc = SetupMdc();
IDomainObjectDTORepository repoDTO = new DomainObjectDtoRepository(7000017, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
// SUT: Do the migration.
m_dataMigrationManager.PerformMigration(repoDTO, 7000018, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000018, repoDTO.CurrentModelVersion, "Wrong updated version.");
DomainObjectDTO dtoLP = null;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("LangProject"))
{
Assert.IsNull(dtoLP, "Only one Language Project object should exist");
dtoLP = dto;
}
Assert.NotNull(dtoLP, "The Language Project object should exist");
DomainObjectDTO dtoNtbk = null;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("RnResearchNbk"))
{
Assert.IsNull(dtoNtbk, "Only one Data Notebook object should exist");
dtoNtbk = dto;
}
Assert.NotNull(dtoNtbk, "The Data Notebook object should exist");
DomainObjectDTO dtoLexDb = null;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("LexDb"))
{
Assert.IsNull(dtoLexDb, "Only one Lexical Database object should exist");
dtoLexDb = dto;
}
Assert.NotNull(dtoLexDb, "The Lexical Database object should exist");
string sLexDbXml = dtoLexDb.Xml;
Assert.False(sLexDbXml.Contains("<Styles>"), "The Styles field should be gone from the Lexical Database object");
string sLpXml = dtoLP.Xml;
Assert.True(sLpXml.Contains("<Styles>"), "The Styles field should still exist in the Language Project object");
VerifyStylesRenamedOrDeleted(repoDTO);
VerifyStyleReferencesUpdated(repoDTO);
VerifyScriptureStylesUnchanged(repoDTO);
VerifyNoDirectFormatting(repoDTO);
}
public void DataMigration7000037Test()
{
// Bring in data from xml file.
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000037.xml");
// Create all the Mock classes for the classes in my test data.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "LexSense", "StPara" });
mockMDC.AddClass(7, "LexSense", "CmObject", new List<string>());
mockMDC.AddClass(15, "StPara", "CmObject", new List<string> { "StTxtPara" });
mockMDC.AddClass(16, "StTxtPara", "StPara", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000036, dtos, mockMDC,
FileUtils.ChangePathToPlatform("C:\\WW\\DistFiles\\Projects\\TokPisin"), FwDirectoryFinder.FdoDirectories);
// Check that the version is correct.
Assert.AreEqual(7000036, dtoRepos.CurrentModelVersion, "Wrong original version.");
// Collect the link values that shouldn't change.
m_cLinks = 0;
CollectionNonSilfwLinks(dtoRepos);
int cLinksOrig = m_cLinks;
Assert.AreEqual(12, m_cLinks, "Should have 12 externalLink attributes in the test data");
// Do Migration
m_dataMigrationManager.PerformMigration(dtoRepos, 7000037, new DummyProgressDlg());
// Check that the version was updated.
Assert.AreEqual(7000037, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Check that all externalLink values are reasonable, and that we find the right
// number of them.
m_cLinks = 0;
foreach (var dto in dtoRepos.AllInstancesWithValidClasses())
{
string xml = dto.Xml;
Assert.IsTrue(xml.Contains("externalLink"), "Every object in the test has an externalLink");
var dtoXML = XElement.Parse(xml);
foreach (var run in dtoXML.XPathSelectElements("//Run"))
{
var externalLinkAttr = run.Attribute("externalLink");
if (externalLinkAttr != null)
{
CheckForValidLinkValue(externalLinkAttr.Value);
++m_cLinks;
}
}
}
Assert.AreEqual(cLinksOrig, m_cLinks, "Migration should not change the number of externalLink attributes");
}
public void DataMigration7000062Test()
{
var mockMdc = new MockMDCForDataMigration();
mockMdc.AddClass(1, "CmObject", null, new List<string> { "LangProject", "StStyle", "CmResource" });
mockMdc.AddClass(2, "LangProject", "CmObject", new List<string>());
mockMdc.AddClass(3, "StStyle", "CmObject", new List<string>());
mockMdc.AddClass(4, "CmResource", "CmObject", new List<string>());
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000062.xml");
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000061, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000062, new DummyProgressDlg());
// Check Step 1.A.
// <rt class="StStyle" guid ="bb68f6bc-f233-4cd4-8894-c33b4b4c43ba">
DomainObjectDTO dto;
dtoRepos.TryGetValue("bb68f6bc-f233-4cd4-8894-c33b4b4c43ba", out dto);
Assert.IsNull(dto);
// Step 1.A. Control
// <rt class="StStyle" guid ="9d28219c-6185-416e-828b-b9e304de141c" ownerguid="88ddebd1-dfad-4033-8b1c-896081469f66">
dtoRepos.TryGetValue("9d28219c-6185-416e-828b-b9e304de141c", out dto);
Assert.IsNotNull(dto);
// Check Step 1.B. (Real + control)
foreach (var resourceDto in dtoRepos.AllInstancesSansSubclasses("CmResource"))
{
var resourceElement = XElement.Parse(resourceDto.Xml);
var name = resourceElement.Element("Name").Element("Uni").Value;
var actualVersion = resourceElement.Element("Version").Attribute("val").Value;
var expectedVersion = "";
switch (name)
{
case "TeStyles":
expectedVersion = "700176e1-4f42-4abd-8fb5-3c586670085d";
break;
case "FlexStyles":
expectedVersion = "13c213b9-e409-41fc-8782-7ca0ee983b2c";
break;
case "ControlResource":
expectedVersion = "c1ede2e2-e382-11de-8a39-0800200c9a66";
break;
}
Assert.AreEqual(expectedVersion, actualVersion);
}
Assert.AreEqual(7000062, dtoRepos.CurrentModelVersion, "Wrong updated version.");
}
public void DataMigration7000057Test_Normal()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000057_Normal.xml");
// Set up mock MDC.
var mockMdc = new MockMDCForDataMigration();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000056, dtos, mockMdc, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000057, new DummyProgressDlg());
Assert.AreEqual(7000057, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// check that Irregularly Inflected Form Type has new class
{
var iifNew = dtoRepos.GetDTO(kguidLexTypIrregInflectionVar);
Assert.That(iifNew.Classname, Is.EqualTo(LexEntryInflTypeTags.kClassName));
var iifNewElt = XElement.Parse(iifNew.Xml);
Assert.That(iifNewElt.XPathSelectElement("Name/AUni").Value,
Is.EqualTo("Irregularly Inflected Form"));
}
// check that we haven't changed another owned object class
{
// Discussion for Irregularly Inflected Form Type
var iifDiscussion = dtoRepos.GetDTO("b6f4c056-ea5e-11de-8a9c-0013722f8dec");
Assert.That(iifDiscussion.Classname, Is.EqualTo(StTextTags.kClassName));
}
// check that Irregularly Inflected Form Type (Plural) has new class
{
var iifNewPlural = dtoRepos.GetDTO(kguidLexTypPluralVar);
Assert.That(iifNewPlural, Is.Not.Null);
Assert.That(iifNewPlural.Classname, Is.EqualTo(LexEntryInflTypeTags.kClassName));
var iifNewPluralElt = XElement.Parse(iifNewPlural.Xml);
Assert.That(iifNewPluralElt.XPathSelectElement("Name/AUni").Value,
Is.EqualTo("Plural"));
}
// check that Irregularly Inflected Form Type (Past) has new class
{
var iifNewPast = dtoRepos.GetDTO(kguidLexTypPastVar);
Assert.That(iifNewPast, Is.Not.Null);
Assert.That(iifNewPast.Classname, Is.EqualTo(LexEntryInflTypeTags.kClassName));
var iifNewPastElt = XElement.Parse(iifNewPast.Xml);
Assert.That(iifNewPastElt.XPathSelectElement("Name/AUni").Value,
Is.EqualTo("Past"));
}
}
public void DataMigration7000010_AnnotationDefns_Removed_Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000010_AnnotationDefns.xml");
dtos.UnionWith(DataMigrationTestServices.ParseProjectFile("DataMigration7000010_CommonData.xml"));
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "CmPossibilityList", "CmAnnotationDefn", "StText", "StTxtPara" });
mockMDC.AddClass(2, "CmPossibilityList", "CmObject", new List<string>());
mockMDC.AddClass(3, "CmAnnotationDefn", "CmObject", new List<string>());
mockMDC.AddClass(4, "StText", "CmObject", new List<string>());
mockMDC.AddClass(5, "StTxtPara", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000009, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
// Collect the various annotation defns.
var annDefnDtos = new Dictionary<string, DomainObjectDTO>();
foreach (var annDto in dtoRepos.AllInstancesSansSubclasses("CmAnnotationDefn"))
annDefnDtos.Add(annDto.Guid.ToUpper(), annDto);
var stTextDtos = new Dictionary<string, DomainObjectDTO>();
foreach (var annDto in dtoRepos.AllInstancesSansSubclasses("StText"))
stTextDtos.Add(annDto.Guid.ToUpper(), annDto);
var stTxtParaDtos = new Dictionary<string, DomainObjectDTO>();
foreach (var annDto in dtoRepos.AllInstancesSansSubclasses("StTxtPara"))
stTxtParaDtos.Add(annDto.Guid.ToUpper(), annDto);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000010, new DummyProgressDlg());
Assert.AreEqual(16, dtoRepos.AllInstancesSansSubclasses("CmAnnotationDefn").Count(), "Wrong number of AnnDefns remaining.");
Assert.AreEqual(1, dtoRepos.AllInstancesSansSubclasses("StText").Count(), "Wrong number of StTexts remaining.");
Assert.AreEqual(1, dtoRepos.AllInstancesSansSubclasses("StTxtPara").Count(), "Wrong number of StTxtParas remaining.");
// Make sure correct annDefns were removed.
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["B63F0702-32F7-4ABB-B005-C1D2265636AD"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["9AC9637A-56B9-4F05-A0E1-4243FBFB57DB"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["B0B1BB21-724D-470A-BE94-3D9A436008B8"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["EB92E50F-BA96-4D1D-B632-057B5C274132"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["CFECB1FE-037A-452D-A35B-59E06D15F4DF"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["084A3AFE-0D00-41DA-BFCF-5D8DEAFA0296"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["A39A1272-38A0-4354-BDAC-8636D64C1EEC"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["50C1A53D-925D-4F55-8ED7-64A297905346"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, annDefnDtos["EC0A4DAD-7E90-4E73-901A-21D25F0692E3"]);
// Make sure owned StText and StTxtPara in deleted annDefn were removed.
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, stTextDtos["70CA84D7-211C-4548-8274-004640B3CA5D"]);
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, stTxtParaDtos["7C02332C-1F8D-4208-B15D-CA8AA89B9324"]);
}
public void DataMigration7000051Test()
{
var dtos = new HashSet<DomainObjectDTO>();
var sb = new StringBuilder();
// Add Lang Project dto.
const string sLpGuid = "9719A466-2240-4DEA-9722-9FE0746A30A6";
const string afxCatGuid = "60ab6c6c-43f3-4a7f-af61-96b4b77648a5";
sb.AppendFormat("<rt class=\"LangProject\" guid=\"{0}\">", sLpGuid);
sb.Append("<AffixCategories>");
sb.AppendFormat("<objsur guid=\"{0}\" t=\"o\" />", afxCatGuid);
sb.Append("</AffixCategories>");
sb.Append("</rt>");
var oldDto = new DomainObjectDTO(sLpGuid, "LangProject", sb.ToString());
dtos.Add(oldDto);
sb.Length = 0;
sb.AppendFormat("<rt class=\"CmPossibilityList\" guid=\"{0}\" ownerguid=\"{1}\" />", afxCatGuid, sLpGuid);
var afxCatDto = new DomainObjectDTO(afxCatGuid, "CmPossibilityList", sb.ToString());
dtos.Add(afxCatDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "LangProject", "CmPossibilityList" }); // Not true, but no matter.
mockMDC.AddClass(2, "LangProject", "CmObject", new List<string>());
mockMDC.AddClass(3, "CmPossibilityList", "CmObject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000050, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000051, new DummyProgressDlg());
Assert.AreEqual(7000051, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Check that the old LP is not present.
DomainObjectDTO gonerDto;
Assert.IsFalse(dtoRepos.TryGetValue(sLpGuid, out gonerDto));
Assert.IsTrue(((DomainObjectDtoRepository)dtoRepos).Goners.Contains(oldDto));
var newDto = dtoRepos.AllInstancesSansSubclasses("LangProject").FirstOrDefault();
Assert.IsNotNull(newDto);
Assert.AreNotSame(oldDto, newDto);
var newDtoGuid = newDto.Guid.ToLowerInvariant();
Assert.AreNotEqual(sLpGuid.ToLowerInvariant(), newDtoGuid);
// Check that ownerguid was changed on afxCatDto.
var afxCatElm = XElement.Parse(afxCatDto.Xml);
Assert.AreEqual(newDtoGuid, afxCatElm.Attribute("ownerguid").Value.ToLowerInvariant());
}
public void DataMigration7000006Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000006Tests.xml");
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "CmProject" });
mockMDC.AddClass(2, "CmProject", "CmObject", new List<string> { "LangProject" });
mockMDC.AddClass(3, "LangProject", "CmProject", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000005, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000006, new DummyProgressDlg());
var cmProjDto = dtoRepos.AllInstancesSansSubclasses("LangProject").First();
var cpElement = XElement.Parse(cmProjDto.Xml);
Assert.AreEqual(7000006, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Get the Description Element in cmProject
Assert.IsNotNull(cpElement.XPathSelectElement("CmProject/Description"));
// Get the Name Element in cmProject (should be gone)
Assert.IsNull(cpElement.XPathSelectElement("CmProject/Name"));
}
public void DataMigration7000007Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000007Tests.xml");
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List<string> { "ScrImportSet", "StPara", "StText"});
mockMDC.AddClass(2, "ScrImportSet", "CmObject", new List<string>());
mockMDC.AddClass(4, "StPara", "CmObject", new List<string> {"StTxtPara"});
mockMDC.AddClass(6, "StText", "CmObject", new List<string> {"StFootnote"});
mockMDC.AddClass(7, "StTxtPara", "StPara", new List<string>());
mockMDC.AddClass(9, "StFootnote", "StText", new List<string> {"ScrFootnote"});
mockMDC.AddClass(10, "ScrFootnote", "StFootnote", new List<string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000006, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000007, new DummyProgressDlg());
var ScrInpDto = dtoRepos.AllInstancesSansSubclasses("ScrImportSet").First();
var ScrInpElement = XElement.Parse(ScrInpDto.Xml);
Assert.AreEqual(7000007, dtoRepos.CurrentModelVersion, "Wrong updated version.");
Assert.IsNull(ScrInpElement.XPathSelectElement("ScrImportSet/ImportSettings"));
// Get the ImportSettings Element in ScrImportSet (should be gone)
Assert.IsNotNull(ScrInpElement.XPathSelectElement("ScrImportSet/ImportType"));
// Get the ImportType Element in ScrImportSet.
var ScrFootDto = dtoRepos.AllInstancesSansSubclasses("ScrFootnote").First();
var ScrFootElement = XElement.Parse(ScrFootDto.Xml);
Assert.IsNull(ScrFootElement.XPathSelectElement("StFootnote/DisplayFootnoteReference"));
// Get the DisplayFootnoteReference Element in StFootnote (should be gone)
Assert.IsNull(ScrFootElement.XPathSelectElement("StFootnote/DisplayFootnoteMarker"));
// Get the DisplayFootnoteMarker Element in StFootnote (should be gone)
var StTxtDto = dtoRepos.AllInstancesSansSubclasses("StTxtPara").First();
var StTxtElement = XElement.Parse(StTxtDto.Xml);
Assert.IsNotNull(StTxtElement.XPathSelectElement("StPara/StyleRules"));
// Get the StyleRules Element in StPara
Assert.IsNull(StTxtElement.XPathSelectElement("StPara/StyleName"));
// Get the StyleName Element in StPara (should be gone)
}
public void DataMigration7000031Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000031Tests.xml");
IFwMetaDataCacheManaged mockMdc = DataMigrationTests7000020.SetupMdc();
IDomainObjectDTORepository repoDto = new DomainObjectDtoRepository(7000030, dtos, mockMdc,
Path.GetTempPath(), FwDirectoryFinder.FdoDirectories);
// Initial check that data was read properly.
var cObjects = repoDto.AllInstances().Count();
Assert.AreEqual(378, cObjects, "Before migrating, should be 378 objects");
var cLangProject = repoDto.AllInstancesSansSubclasses("LangProject").Count();
Assert.AreEqual(1, cLangProject, "Before migrating, should be 1 LangProject object");
var cUserView = repoDto.AllInstancesSansSubclasses("UserView").Count();
Assert.AreEqual(17, cUserView, "Before migrating, should be 17 UserView objects");
var cUserViewRec = repoDto.AllInstancesSansSubclasses("UserViewRec").Count();
Assert.AreEqual(31, cUserViewRec, "Before migrating, should be 31 UserViewRec objects");
var cUserViewField = repoDto.AllInstancesSansSubclasses("UserViewField").Count();
Assert.AreEqual(329, cUserViewField, "Before migrating, should be 329 UserViewField objects");
// Do the migration.
m_dataMigrationManager.PerformMigration(repoDto, 7000031, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000031, repoDto.CurrentModelVersion, "Wrong updated version.");
cObjects = repoDto.AllInstances().Count();
Assert.AreEqual(1, cObjects, "After migrating, should be 1 object");
cLangProject = repoDto.AllInstancesSansSubclasses("LangProject").Count();
Assert.AreEqual(1, cLangProject, "After migrating, should be 1 LangProject object");
cUserView = repoDto.AllInstancesSansSubclasses("UserView").Count();
Assert.AreEqual(0, cUserView, "After migrating, should be 12 UserView objects");
cUserViewRec = repoDto.AllInstancesSansSubclasses("UserViewRec").Count();
Assert.AreEqual(0, cUserViewRec, "After migrating, should be 3 UserViewRec objects");
cUserViewField = repoDto.AllInstancesSansSubclasses("UserViewField").Count();
Assert.AreEqual(0, cUserViewField, "After migrating, should be 15 UserViewField objects");
}
