private void CheckEventSubTypes(IDomainObjectDTORepository repoDTO)
{
DomainObjectDTO dtoObs = GetDTOIfItExists(repoDTO, ksguidObservation);
if (dtoObs != null)
{
VerifyOwner(repoDTO, dtoObs, ksguidEvent);
}
DomainObjectDTO dtoCon = GetDTOIfItExists(repoDTO, ksguidConversation);
if (dtoCon != null)
{
VerifyOwner(repoDTO, dtoCon, ksguidEvent);
}
DomainObjectDTO dtoInt = GetDTOIfItExists(repoDTO, ksguidInterview);
if (dtoInt != null)
{
VerifyOwner(repoDTO, dtoInt, ksguidEvent);
}
DomainObjectDTO dtoPer = GetDTOIfItExists(repoDTO, ksguidPerformance);
if (dtoPer != null)
{
VerifyOwner(repoDTO, dtoPer, ksguidEvent);
}
}
private string GetCmFileGuid(DomainObjectDTO fileDto)
{
XElement cmFileXML = XElement.Parse(fileDto.Xml);
var cmFileGuid = cmFileXML.Attribute("guid").Value;
return(cmFileGuid);
}
private static void CheckPhPhonData(DomainObjectDTO dtoPhPhonDataTest, IDomainObjectDTORepository dtoRepos)
{
var eltWmbPhPhonDataTest = XElement.Parse(dtoPhPhonDataTest.Xml);
// get phon rule feats
var eltPhonRuleFeatsTest = eltWmbPhPhonDataTest.Element("PhonRuleFeats");
Assert.IsNotNull(eltPhonRuleFeatsTest);
var eltObjsurTest = eltPhonRuleFeatsTest.Element("objsur");
Assert.IsNotNull(eltObjsurTest);
// get possibility list itself
var guidPossibilityListTest = eltObjsurTest.Attribute("guid").Value;
Assert.IsNotNull(guidPossibilityListTest);
DomainObjectDTO dtoCmPossiblityTest;
dtoRepos.TryGetValue(guidPossibilityListTest, out dtoCmPossiblityTest);
Assert.IsNotNull(dtoCmPossiblityTest);
var eltWmbCmPossibilityListTest = XElement.Parse(dtoCmPossiblityTest.Xml);
Assert.IsNotNull(eltWmbCmPossibilityListTest);
var attrCmPossiblityListClassTest = eltWmbCmPossibilityListTest.Attribute("class").Value;
Assert.AreEqual("CmPossibilityList", attrCmPossiblityListClassTest);
var attrCmPossiblityListOwnerGuidTest = eltWmbCmPossibilityListTest.Attribute("ownerguid").Value;
Assert.AreEqual(dtoPhPhonDataTest.Guid, attrCmPossiblityListOwnerGuidTest);
}
private string GetCmFilePath(DomainObjectDTO fileDto)
{
XElement cmFileXML = XElement.Parse(fileDto.Xml);
var filePathMoreDirect = cmFileXML.XPathSelectElement("InternalPath").XPathSelectElement("Uni").Value;
return(filePathMoreDirect);
}
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 DataMigration7000016Test()
{
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000016.xml");
var mockMdc = SetupMdc();
IDomainObjectDTORepository repoDTO = new DomainObjectDtoRepository(7000015, dtos, mockMdc, null);
// 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);
}
internal static void CheckDtoRemoved(IDomainObjectDTORepository dtoRepos, DomainObjectDTO goner)
{
DomainObjectDTO dto;
if (dtoRepos.TryGetValue(goner.Guid, out dto))
{
Assert.Fail("Still has deleted (or zombie) DTO.");
}
Assert.IsTrue(((DomainObjectDtoRepository)dtoRepos).Goners.Contains(goner));
}
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 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 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);
}
}
private void VerifyAgent(DomainObjectDTO agent, IDomainObjectDTORepository dtoRepos, out string approvesGuid, out string disapprovesGuid)
{
var rtElement = XElement.Parse(agent.Xml);
var agentElement = rtElement.Element("CmAgent");
//Assert.AreEqual(0, agentElement.Elements("Evaluations").Count(), "old evaluations should be deleted");
Assert.IsNull(agentElement.Element("Evaluations"));
var approves = agentElement.Element("Approves");
VerifyAgentEvaluation(approves, dtoRepos, out approvesGuid);
var disapproves = agentElement.Element("Disapproves");
VerifyAgentEvaluation(disapproves, dtoRepos, out disapprovesGuid);
}
private void VerifyOwner(IDomainObjectDTORepository repoDTO, DomainObjectDTO dtoTest, string sguidOwner)
{
bool fFound = false;
foreach (DomainObjectDTO dto in repoDTO.GetDirectlyOwnedDTOs(sguidOwner))
{
if (dto.Guid == dtoTest.Guid && dto.Xml == dtoTest.Xml)
{
fFound = true;
break;
}
}
Assert.IsTrue(fFound);
}
private void VerifyAnalysis(DomainObjectDTO analysis, string[] evaluations)
{
var rtElement = XElement.Parse(analysis.Xml);
var agentElt = rtElement.Element("WfiAnalysis");
var evaluationsElt = agentElt.Element("Evaluations");
Assert.IsNotNull(evaluationsElt);
Assert.AreEqual(evaluations.Length, evaluationsElt.Elements().Count());
var wanted = new HashSet <string>(evaluations);
foreach (var objsur in evaluationsElt.Elements())
{
VerifyReference(objsur, wanted);
}
}
public void UpdateUnknownDtoTest()
{
var dtos = new HashSet <DomainObjectDTO>();
// 1. Add barebones LP.
const string lpGuid = "9719A466-2240-4DEA-9722-9FE0746A30A6";
CreatoDTO(dtos, lpGuid, "LangProject", null);
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(1, dtos,
m_mdc, null, FwDirectoryFinder.FdoDirectories);
var newGuid = Guid.NewGuid();
var newby = new DomainObjectDTO(newGuid.ToString(), "LexEntry", "<rt />");
dtoRepos.Update(newby);
}
private static DomainObjectDTO CreatoDTO(ICollection <DomainObjectDTO> dtos, string guid, string classname, string ownerGuid)
{
var xml = ownerGuid == null
? string.Format("<rt class=\"{0}\" guid=\"{1}\" />", classname, guid)
: string.Format("<rt class=\"{0}\" guid=\"{1}\" ownerguid=\"{2}\" />", classname, guid, ownerGuid);
var dto = new DomainObjectDTO(
guid,
classname,
xml);
dtos.Add(dto);
return(dto);
}
private void VerifySubpossibilities(IDomainObjectDTORepository repoDto, DomainObjectDTO dtoPoss)
{
var xePoss = XElement.Parse(dtoPoss.Xml);
foreach (var objsur in xePoss.XPathSelectElements("SubPossibilities/objsur"))
{
var xaGuid = objsur.Attribute("guid");
Assert.IsNotNull(xaGuid, "objsur elements should always have a guid attribute.");
var guid = xaGuid.Value;
string name;
DomainObjectDTO dtoSub;
Assert.IsTrue(repoDto.TryGetValue(guid, out dtoSub), "SubPossibility Lists should point to valid objects.");
VerifySubpossibilities(repoDto, dtoSub);
}
}
/// <summary>
/// Verify that every LexEntryType points back to a valid owner after migration, and that
/// the owner points to the LexEntryType.
/// </summary>
/// <param name="repoDto"></param>
private static void VerifyEntryTypeOwners(IDomainObjectDTORepository repoDto)
{
foreach (var dto in repoDto.AllInstancesWithSubclasses("LexEntryType"))
{
DomainObjectDTO dtoOwner;
Assert.IsTrue(repoDto.TryGetOwner(dto.Guid, out dtoOwner), "All entry types should have valid owners!");
DomainObjectDTO dtoOwnedOk = null;
foreach (var dtoT in repoDto.GetDirectlyOwnedDTOs(dtoOwner.Guid))
{
if (dtoT == dto)
{
dtoOwnedOk = dtoT;
break;
}
}
Assert.AreEqual(dto, dtoOwnedOk, "The owner should own the entry type!");
}
}
private static void VerifyObject(DomainObjectDTO dto, IEnumerable <string> oldClassElements, ICollection <string> expectedPropertyElements)
{
// Make sure the old class elements are gone.
var rtElement = XElement.Parse(dto.Xml);
foreach (var oldClassElement in oldClassElements)
{
Assert.IsNull(rtElement.Element(oldClassElement));
}
// Make sure the prop elements are child elements of <rt> element.
var propElements = rtElement.Elements();
Assert.AreEqual(expectedPropertyElements.Count, propElements.Count(), "Wrong number of property child elements.");
foreach (var propElement in propElements)
{
Assert.IsTrue(expectedPropertyElements.Contains(propElement.Name.LocalName));
}
}
private static void CheckStringWsIds(IWritingSystemManager wsManager, DomainObjectDTO dto)
{
XElement objElem = XElement.Parse(dto.Xml);
foreach (XElement elem in objElem.Descendants())
{
switch (elem.Name.LocalName)
{
case "Run":
case "AStr":
case "AUni":
XAttribute wsAttr = elem.Attribute("ws");
if (wsAttr != null)
{
Assert.IsTrue(wsManager.Exists(wsAttr.Value));
}
break;
}
}
}
public void AddNewDtoTest()
{
var dtos = new HashSet <DomainObjectDTO>();
// 1. Add barebones LP.
const string lpGuid = "9719A466-2240-4DEA-9722-9FE0746A30A6";
CreatoDTO(dtos, lpGuid, "LangProject", null);
const string lexDbGuid = "6C84F84A-5B99-4CF5-A7D5-A308DDC604E0";
CreatoDTO(dtos, lexDbGuid, "LexDb", null);
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(1, dtos,
m_mdc, null, FwDirectoryFinder.FdoDirectories);
// Create new DTO and add it.
var newGuid = Guid.NewGuid();
var newby = new DomainObjectDTO(newGuid.ToString(), "LexEntry", "<rt />");
dtoRepos.Add(newby);
Assert.AreSame(newby, dtoRepos.GetDTO(newGuid.ToString()), "Wrong new DTO from guid.");
Assert.AreSame(newby, dtoRepos.AllInstancesSansSubclasses("LexEntry").First(), "Wrong new DTO from class.");
Assert.IsTrue(((DomainObjectDtoRepository)dtoRepos).Newbies.Contains(newby), "Newby not in newbies set.");
}
public void DataMigration7000003Test()
{
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("<TranslatedScripture>");
sb.Append("<objsur guid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" t=\"o\" />");
sb.Append("</TranslatedScripture>");
sb.Append("</LangProject>");
sb.Append("</rt>");
var lpDto = new DomainObjectDTO("9719A466-2240-4DEA-9722-9FE0746A30A6",
"LangProject",
sb.ToString());
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\" owningflid=\"6001040\" owningord=\"0\">");
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>");
var scrDto = new DomainObjectDTO("2c5c1f5f-1f08-41d7-99fe-23893ee4ceef",
"Scripture",
sb.ToString());
dtos.Add(scrDto);
// 3. Add a ScrBook
sb = new StringBuilder();
sb.Append("<rt class=\"ScrBook\" guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" ownerguid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" owningflid=\"3001001\" owningord=\"0\">");
sb.Append("<ScrBook>");
sb.Append("<Name>");
sb.Append("<AUni ws=\"fr\">Genesis</AUni>");
sb.Append("</Name>");
sb.Append("<Footnotes>");
var footnoteGuids = new StTextAndParaInfo("StFootnote", "f213db11-7007-4a2f-9b94-06d6c96014ca", "Title Main");
sb.Append("<objsur guid=\"" + footnoteGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Footnotes>");
sb.Append("</ScrBook>");
sb.Append("</rt>");
var bookDto = new DomainObjectDTO("f213db11-7007-4a2f-9b94-06d6c96014ca",
"ScrBook",
sb.ToString());
dtos.Add(bookDto);
// Add footnote
var footnoteDto = new DomainObjectDTO(footnoteGuids.textGuid.ToString(),
"StFootnote",
footnoteGuids.textXml);
dtos.Add(footnoteDto);
// Footnote para
var footnoteParaDto = new DomainObjectDTO(footnoteGuids.paraGuid.ToString(),
"StTxtPara",
footnoteGuids.paraXml);
dtos.Add(footnoteParaDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"LangProject", "StText",
"Scripture", "ScrBook", "StPara"
});
mockMDC.AddClass(2, "LangProject", "CmObject", new List <string>());
mockMDC.AddClass(3, "StText", "CmObject", new List <string> {
"StFootnote"
});
mockMDC.AddClass(4, "Scripture", "CmObject", new List <string>());
mockMDC.AddClass(5, "ScrBook", "CmObject", new List <string>());
mockMDC.AddClass(6, "StFootnote", "CmObject", new List <string> {
"ScrFootnote"
});
mockMDC.AddClass(8, "StTxtPara", "CmObject", new List <string> {
"ScrTxtPara"
});
mockMDC.AddClass(9, "ScrFootnote", "CmObject", new List <string>());
mockMDC.AddClass(10, "ScrTxtPara", "CmObject", new List <string>());
mockMDC.AddClass(11, "StPara", "CmObject", new List <string> {
"StTxtPara"
});
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000002, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000003, new DummyProgressDlg());
Assert.AreEqual(7000003, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Check the footnote to make sure it is the correct class
XElement footnoteElement = XElement.Parse(footnoteDto.Xml);
Assert.AreEqual("ScrFootnote", footnoteDto.Classname, "Oops. Class was not changed.");
Assert.AreEqual("ScrFootnote", footnoteElement.Attribute("class").Value, "Oops. Class was not changed.");
Assert.IsNotNull(footnoteElement.Element("ScrFootnote"));
Assert.IsTrue(footnoteElement.Element("ScrFootnote").IsEmpty);
}
public void DataMigration7000036Test()
{
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("<Texts>");
StTextAndParaInfo lpTextsGuids = new StTextAndParaInfo("9719A466-2240-4DEA-9722-9FE0746A30A6", "Normal", false, false);
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("</rt>");
var lpDto = new DomainObjectDTO("9719A466-2240-4DEA-9722-9FE0746A30A6",
"LangProject", sb.ToString());
dtos.Add(lpDto);
// Add text dto.
var txtDto = new DomainObjectDTO(lpTextsGuids.textGuid.ToString(), "StText",
lpTextsGuids.textXml);
dtos.Add(txtDto);
// Add text para dto.
var txtParaDto = new DomainObjectDTO(lpTextsGuids.paraGuid.ToString(), "ScrTxtPara",
lpTextsGuids.paraXml);
dtos.Add(txtParaDto);
// 2. Add Scripture
sb = new StringBuilder();
sb.Append("<rt class=\"Scripture\" guid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" ownerguid=\"9719A466-2240-4DEA-9722-9FE0746A30A6\" owningflid=\"6001040\" owningord=\"0\">");
sb.Append("<Books>");
sb.Append("<objsur guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" t=\"o\" />");
sb.Append("</Books>");
sb.Append("</rt>");
var scrDto = new DomainObjectDTO("2c5c1f5f-1f08-41d7-99fe-23893ee4ceef", "Scripture",
sb.ToString());
dtos.Add(scrDto);
// 3. Add a ScrBook
sb = new StringBuilder();
sb.Append("<rt class=\"ScrBook\" guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" ownerguid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" owningflid=\"3001001\" owningord=\"0\">");
sb.Append("<Name>");
sb.Append("<AUni ws=\"fr\">Genesis</AUni>");
sb.Append("</Name>");
sb.Append("<Title>");
StTextAndParaInfo titleTextGuids = new StTextAndParaInfo("f213db11-7007-4a2f-9b94-06d6c96014ca", "Title Main", true, false);
sb.Append("<objsur guid=\"" + titleTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Title>");
sb.Append("<Sections>");
sb.Append("<objsur guid=\"834e1bf8-3a25-47d6-9f92-806b38b5f815\" t=\"o\" />");
sb.Append("</Sections>");
sb.Append("<Footnotes>");
// This footnote should also have its ParaContainingOrc property set, but this test really doesn't care.
StTextAndParaInfo footnoteGuids = new StTextAndParaInfo("ScrFootnote", "f213db11-7007-4a2f-9b94-06d6c96014ca", "Note General Paragraph", null, true, false);
sb.Append("<objsur guid=\"" + footnoteGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Footnotes>");
sb.Append("</rt>");
var bookDto = new DomainObjectDTO("f213db11-7007-4a2f-9b94-06d6c96014ca", "ScrBook", sb.ToString());
dtos.Add(bookDto);
// Add title
var titleDto = new DomainObjectDTO(titleTextGuids.textGuid.ToString(), "StText",
titleTextGuids.textXml);
dtos.Add(titleDto);
// Title para
var titleParaDto = new DomainObjectDTO(titleTextGuids.paraGuid.ToString(), "ScrTxtPara",
titleTextGuids.paraXml);
dtos.Add(titleParaDto);
// Add footnote
var footnoteDto = new DomainObjectDTO(footnoteGuids.textGuid.ToString(), "ScrFootnote",
footnoteGuids.textXml);
dtos.Add(footnoteDto);
// Footnote para
var footnoteParaDto = new DomainObjectDTO(footnoteGuids.paraGuid.ToString(), "ScrTxtPara",
footnoteGuids.paraXml);
dtos.Add(footnoteParaDto);
// 4. Add a section to the book
sb = new StringBuilder();
sb.Append("<rt class=\"ScrSection\" guid=\"834e1bf8-3a25-47d6-9f92-806b38b5f815\" ownerguid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" owningflid=\"3002001\" owningord=\"0\">");
sb.Append("<Content>");
StTextAndParaInfo contentsTextGuids = new StTextAndParaInfo("StText", "834e1bf8-3a25-47d6-9f92-806b38b5f815", "Paragraph",
"<Run ws=\"fr\" link=\"" + footnoteGuids.textGuid + "\"></Run>", true, false,
"<Run ws=\"en\" link=\"" + footnoteGuids.textGuid + "\"></Run>");
sb.Append("<objsur guid=\"" + contentsTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Content>");
sb.Append("<Heading>");
StTextAndParaInfo headingTextGuids = new StTextAndParaInfo("834e1bf8-3a25-47d6-9f92-806b38b5f815", "Section Head", true, false);
sb.Append("<objsur guid=\"" + headingTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Heading>");
sb.Append("</rt>");
var sectionDto = new DomainObjectDTO("834e1bf8-3a25-47d6-9f92-806b38b5f815", "ScrSection",
sb.ToString());
dtos.Add(sectionDto);
sb.Length = 0;
sb.Append("<rt class=\"StJournalText\" guid=\"c1ecd177-e382-11de-8a39-0800200c9a66\">");
sb.Append("<DateCreated val=\"2009-12-31 23:59:59.000\" />");
sb.Append("<DateModified val=\"2010-01-01 23:59:59.000\" />");
sb.Append("</rt>");
var journalTextDto = new DomainObjectDTO("c1ecd177-e382-11de-8a39-0800200c9a66", "StJounalText",
sb.ToString());
dtos.Add(journalTextDto);
// Add the contents
var contentsDto = new DomainObjectDTO(contentsTextGuids.textGuid.ToString(), "StText",
contentsTextGuids.textXml);
dtos.Add(contentsDto);
// Contents para
var contentsParaDto = new DomainObjectDTO(contentsTextGuids.paraGuid.ToString(), "ScrTxtPara",
contentsTextGuids.paraXml);
dtos.Add(contentsParaDto);
// BT of para
var btDto = new DomainObjectDTO(contentsTextGuids.btGuid.ToString(), "CmTranslation",
contentsTextGuids.btXml);
dtos.Add(btDto);
// Add the heading to the xml
var headingDto = new DomainObjectDTO(headingTextGuids.textGuid.ToString(), "StText",
headingTextGuids.textXml);
dtos.Add(headingDto);
// heading para
var headingParaDto = new DomainObjectDTO(headingTextGuids.paraGuid.ToString(), "ScrTxtPara",
headingTextGuids.paraXml);
dtos.Add(headingParaDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"LangProject", "StText", "Scripture",
"ScrBook", "StFootnote", "ScrSection", "StPara"
});
mockMDC.AddClass(2, "LangProject", "CmObject", new List <string>());
mockMDC.AddClass(3, "StText", "CmObject", new List <string> {
"StFootnote", "StJounalText"
});
mockMDC.AddClass(4, "Scripture", "CmObject", new List <string>());
mockMDC.AddClass(5, "ScrBook", "CmObject", new List <string>());
mockMDC.AddClass(6, "StFootnote", "StText", new List <string> {
"ScrFootnote"
});
mockMDC.AddClass(7, "ScrSection", "CmObject", new List <string>());
mockMDC.AddClass(8, "StTxtPara", "StPara", new List <string> {
"ScrTxtPara"
});
mockMDC.AddClass(9, "ScrFootnote", "StFootnote", new List <string>());
mockMDC.AddClass(10, "ScrTxtPara", "StTxtPara", new List <string>());
mockMDC.AddClass(11, "StPara", "CmObject", new List <string> {
"StTxtPara"
});
mockMDC.AddClass(12, "StJounalText", "StText", new List <string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000035, dtos, mockMDC, null);
DateTime beforeMigration = DateTime.Now.AddSeconds(-1); // avoid tick problem
m_dataMigrationManager.PerformMigration(dtoRepos, 7000036, new DummyProgressDlg());
Assert.AreEqual(7000036, dtoRepos.CurrentModelVersion, "Wrong updated version.");
int cJournalTexts = 0;
foreach (DomainObjectDTO stTextDTO in dtoRepos.AllInstancesWithSubclasses("StText"))
{
XElement stText = XElement.Parse(stTextDTO.Xml);
Assert.AreEqual(1, stText.Elements("DateModified").Count());
XElement dateModified = stText.Element("DateModified");
Assert.IsNotNull(dateModified);
if (stTextDTO.Classname == "StJounalText")
{
Assert.AreEqual(new DateTime(2010, 1, 1, 23, 59, 59).ToLocalTime(), ReadWriteServices.LoadDateTime(dateModified));
cJournalTexts++;
}
else
{
Assert.GreaterOrEqual(ReadWriteServices.LoadDateTime(dateModified), beforeMigration);
}
}
Assert.AreEqual(1, cJournalTexts);
}
private void VerifyStylesRenamedOrDeleted(IDomainObjectDTORepository repoDTO)
{
int cHyperlink = 0;
int cWrtSysAbbr = 0;
int cExternalLink = 0;
int cInternalLink = 0;
int cLanguageCode = 0;
int cStrong = 0;
int cBuiltIn = 0;
int cCustom = 0;
bool gotHeading3 = false;
bool gotHeading5 = false;
foreach (DomainObjectDTO dto in repoDTO.AllInstancesSansSubclasses("StStyle"))
{
Assert.That(dto.Guid.ToUpper(), Is.Not.EqualTo("71B2233D-8B14-42D5-A625-AAC8EDE7503B"),
"Heading 3 in LexDb duplicates one in LangProj and should have been deleted");
if (dto.Guid.ToUpper() == "B82D12DE-EA5E-11DE-88CD-0013722F8DEC") // Keeper Heading 3
{
gotHeading3 = true;
var h3Elt = XElement.Parse(dto.Xml);
Assert.That(h3Elt.Element("Rules").Element("Prop").Attribute("fontFamily").Value, Is.EqualTo("Times New Roman"),
"should transfer font family setting from lexDB version of heading 3 to lang proj");
Assert.That(h3Elt.Element("Rules").Element("Prop").Attribute("fontsize").Value, Is.EqualTo("11000"),
"should transfer font size setting from lexDB version of heading 3 to lang proj");
Assert.That(h3Elt.Element("BasedOn").Element("objsur").Attribute("guid").Value.ToUpperInvariant, Is.EqualTo("B8238980-EA5E-11DE-86E1-0013722F8DEC"),
"should transfer based-on information to corresponding style in langproj");
Assert.That(h3Elt.Element("Next").Element("objsur").Attribute("guid").Value.ToUpperInvariant, Is.EqualTo("B8179DD2-EA5E-11DE-8537-0013722F8DEC"),
"should transfer next information to corresponding style in langproj");
}
if (dto.Guid.ToUpper() == "44944544-DF17-4553-94B8-A5E13C3392C5") // keeper Heading 5
{
gotHeading5 = true;
var h5Elt = XElement.Parse(dto.Xml);
Assert.That(h5Elt.Element("BasedOn").Element("objsur").Attribute("guid").Value.ToUpperInvariant, Is.EqualTo("B8238980-EA5E-11DE-86E1-0013722F8DEC"),
"should transfer based-on information to corresponding style in langproj");
Assert.That(h5Elt.Element("Next").Element("objsur").Attribute("guid").Value.ToUpperInvariant, Is.EqualTo("B8179DD2-EA5E-11DE-8537-0013722F8DEC"),
"should transfer next information to corresponding style in langproj");
}
string sXml = dto.Xml;
string sName = GetStyleName(sXml);
DomainObjectDTO dtoOwner = repoDTO.GetOwningDTO(dto);
if (dtoOwner.Classname != "LangProject")
{
Assert.AreEqual(dtoOwner.Classname, "Scripture", "Either LangProject or Scripture owns the style");
if (sName == "External Link")
{
++cExternalLink;
}
else if (sName == "Internal Link")
{
++cInternalLink;
}
else if (sName == "Language Code")
{
++cLanguageCode;
}
}
else
{
Assert.AreNotEqual(sName, "External Link", "The External Link style should no longer exist");
Assert.AreNotEqual(sName, "Internal Link", "The Internal Link style should no longer exist");
Assert.AreNotEqual(sName, "Language Code", "The Language Code style should no longer exist");
if (sName == "Hyperlink")
{
++cHyperlink;
}
else if (sName == "Writing System Abbreviation")
{
++cWrtSysAbbr;
}
else if (sName == "Strong")
{
++cStrong;
}
if (sXml.Contains("<BasedOn>") || sXml.Contains("<Next>"))
{
XElement xeStyle = XElement.Parse(sXml);
ValidateStyleReference(repoDTO, xeStyle, "BasedOn");
ValidateStyleReference(repoDTO, xeStyle, "Next");
}
switch (sName)
{
case "Normal":
case "Numbered List":
case "Bulleted List":
case "Heading 1":
case "Heading 2":
case "Heading 3":
case "Block Quote":
case "Title Text":
case "Emphasized Text":
case "Writing System Abbreviation":
case "Added Text":
case "Deleted Text":
case "Hyperlink":
case "Strong":
case "Dictionary-Normal":
case "Classified-MainEntry":
case "Classified-Item":
Assert.IsTrue(IsBuiltInStyle(sXml), sName + " should be marked as built-in");
++cBuiltIn;
break;
default:
// "Heading 4" and "Dictionary-Custom" should pass through here, plus 7 more
// created from direct formatting.
Assert.IsFalse(IsBuiltInStyle(sXml), sName + " should not be marked as built-in");
++cCustom;
break;
}
}
}
Assert.That(gotHeading3, "should have kept the LangProj Heading3");
Assert.That(gotHeading5, "should have kept the LangProj Heading4");
Assert.AreEqual(1, cHyperlink, "The Hyperlink style should exist (once)");
Assert.AreEqual(1, cWrtSysAbbr, "The Writing System Abbreviation style should exist (once)");
Assert.AreEqual(1, cStrong, "The Strong style should exist (once)");
Assert.AreEqual(1, cExternalLink, "The External Link style should exist (once) in the Scripture stylesheet");
Assert.AreEqual(1, cInternalLink, "The Internal Link style should exist (once) in the Scripture stylesheet");
Assert.AreEqual(1, cLanguageCode, "The Language Code style should exist (once) in the Scripture stylesheet");
Assert.AreEqual(17, cBuiltIn, "There should be 17 built-in LangProject styles.");
Assert.AreEqual(9, cCustom, "There should be 9 custom LangProject styles.");
}
public void DataMigration7000019Test()
{
string storePath = Path.Combine(Path.GetTempPath(), FdoFileHelper.ksWritingSystemsDir);
PrepareStore(storePath);
string globalStorePath = DirectoryFinder.GlobalWritingSystemStoreDirectory;
PrepareStore(globalStorePath);
var dtos = DataMigrationTestServices.ParseProjectFile("DataMigration7000019Tests.xml");
IFwMetaDataCacheManaged mockMdc = SetupMdc();
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000018, dtos, mockMdc, Path.GetTempPath(), FwDirectoryFinder.FdoDirectories);
// Do the migration.
m_dataMigrationManager.PerformMigration(dtoRepos, 7000019, new DummyProgressDlg());
// Verification Phase
Assert.AreEqual(7000019, dtoRepos.CurrentModelVersion, "Wrong updated version.");
Assert.AreEqual(0, dtoRepos.AllInstancesSansSubclasses("LgWritingSystem").Count());
Assert.AreEqual(0, dtoRepos.AllInstancesSansSubclasses("LgCollation").Count());
Assert.AreEqual(0, dtoRepos.AllInstancesSansSubclasses("CmSortSpec").Count());
DomainObjectDTO lpDto = dtoRepos.AllInstancesSansSubclasses("LangProject").First();
XElement lpElem = XElement.Parse(lpDto.Xml);
var kalabaPath = Path.Combine(storePath, "x-kal.ldml"); // Note this migration does NOT yet convert to qaa-x-kal
var kalabaNode = XDocument.Parse(Encoding.UTF8.GetString(File.ReadAllBytes(kalabaPath))).Root;
Assert.That(kalabaNode.Name.LocalName, Is.EqualTo("ldml"));
var identityNode = kalabaNode.Element("identity");
Assert.That(identityNode.Element("language").Attribute("type").Value, Is.EqualTo("x-kal"));
var specialNode = kalabaNode.Element("special");
XNamespace xmlns = "http://www.w3.org/2000/xmlns/";
Assert.That(specialNode.Attribute(xmlns + "palaso").Value, Is.EqualTo("urn://palaso.org/ldmlExtensions/v1"));
XNamespace palaso = "urn://palaso.org/ldmlExtensions/v1";
Assert.That(specialNode.Element(palaso + "languageName").Attribute("value").Value, Is.EqualTo("Kalaba"));
Assert.That(specialNode.Element(palaso + "abbreviation").Attribute("value").Value, Is.EqualTo("Kal"));
// Todo: check a lot more things.
//Assert.AreEqual(1033, kalaba.LCID);
//IWritingSystem frIpa = wsManager.Get("fr-fonipa-x-etic");
//Assert.AreEqual("FrnI", frIpa.Abbreviation);
//Assert.AreEqual("IPA Unicode 1.0", frIpa.Keyboard);
var analysisWss = (string)lpElem.Element("AnalysisWss");
//foreach (string id in analysisWss.Split(' '))
// Assert.IsTrue(wsManager.Exists(id));
//var vernWss = (string)lpElem.Element("VernWss");
//foreach (string id in vernWss.Split(' '))
// Assert.IsTrue(wsManager.Exists(id));
//CheckWsProperty(dtoRepos.AllInstancesWithSubclasses("CmPossibilityList"), wsManager);
//foreach (DomainObjectDTO dto in dtoRepos.AllInstancesWithValidClasses())
// CheckStringWsIds(wsManager, dto);
DomainObjectDTO importSourceDto = dtoRepos.AllInstancesWithSubclasses("ScrImportSource").First();
XElement importSourceElem = XElement.Parse(importSourceDto.Xml);
Assert.AreEqual("x-kal", (string)importSourceElem.Element("WritingSystem").Element("Uni"));
Assert.IsNull(importSourceElem.Element("ICULocale"));
DomainObjectDTO mappingDto = dtoRepos.AllInstancesWithSubclasses("ScrMarkerMapping").First();
XElement mappingElem = XElement.Parse(mappingDto.Xml);
Assert.AreEqual("fr-fonipa-x-etic", (string)mappingElem.Element("WritingSystem").Element("Uni"));
Assert.IsNull(mappingElem.Element("ICULocale"));
DomainObjectDTO styleDto = dtoRepos.AllInstancesWithSubclasses("StStyle").First();
XElement styleElem = XElement.Parse(styleDto.Xml);
Assert.AreEqual("<default font>", (string)styleElem.Element("Rules").Element("Prop").Attribute("fontFamily"));
}
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);
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 DataMigration7000052Test()
{
var dtos = new HashSet <DomainObjectDTO>();
var sb = new StringBuilder();
// Add WfiMorphBundle that already has a form.
const string sGuid_wmbWithForm = "00b35f9f-86ce-4f07-bde7-b65c28503641";
sb.AppendFormat("<rt class=\"WfiMorphBundle\" guid=\"{0}\">", sGuid_wmbWithForm);
sb.Append("<Form>");
sb.Append("<AStr ws=\"wsForm0\">");
sb.AppendFormat("<Run ws=\"wsForm0\">{0}</Run>", "form1");
sb.Append("</AStr>");
sb.Append("</Form>");
sb.Append("</rt>");
var dtoWithForm = new DomainObjectDTO(sGuid_wmbWithForm, "WfiMorphBundle", sb.ToString());
dtos.Add(dtoWithForm);
sb.Length = 0;
const string sGuid_moAffixAllomorph = "f2f9a52f-b07e-4a09-9259-5f6333445eb9";
sb.AppendFormat("<rt class=\"MoAffixAllomorph\" guid=\"{0}\">", sGuid_moAffixAllomorph);
sb.Append("<Form>");
sb.AppendFormat("<AUni ws=\"wsMorph0\">{0}</AUni>", "morphForm&0");
sb.AppendFormat("<AUni ws=\"wsMorph1\">{0}</AUni>", "morphForm1");
sb.Append("</Form>");
sb.Append("</rt>");
var dtoMoAffix = new DomainObjectDTO(sGuid_moAffixAllomorph, "MoAffixAllomorph", sb.ToString());
dtos.Add(dtoMoAffix);
sb.Length = 0;
const string sGuid_wmbNoForm = "0110541a-c93e-4f01-8eec-9d24e1b08d3a";
sb.AppendFormat("<rt class=\"WfiMorphBundle\" guid=\"{0}\">", sGuid_wmbNoForm);
sb.Append("<Form>");
sb.Append("<AStr ws=\"wsMorphPrexisting\">");
sb.AppendFormat("<Run ws=\"wsMorphPrexisting\">{0}</Run>", "morphFormPrexisting&0");
sb.Append("</AStr>");
sb.Append("</Form>");
sb.Append("<Morph>");
sb.AppendFormat("<objsur guid=\"{0}\" t=\"r\" />", sGuid_moAffixAllomorph);
sb.Append("</Morph>");
sb.Append("</rt>");
var dtoNoForm = new DomainObjectDTO(sGuid_wmbNoForm, "WfiMorphBundle", sb.ToString());
dtos.Add(dtoNoForm);
sb.Length = 0;
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"WfiMorphBundle", "MoAffixAllomorph"
}); // Not true, but no matter.
mockMDC.AddClass(2, "WfiMorphBundle", "CmObject", new List <string>());
mockMDC.AddClass(3, "MoAffixAllomorph", "CmObject", new List <string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000051, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000052, new DummyProgressDlg());
Assert.AreEqual(7000052, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// check that MorphBundle with form still has its form.
{
DomainObjectDTO dtoWithFormTest;
dtoRepos.TryGetValue(sGuid_wmbWithForm, out dtoWithFormTest);
var eltWmbWithFormTest = XElement.Parse(dtoWithFormTest.Xml);
var eltFormTest = eltWmbWithFormTest.Element("Form");
// get form
Assert.IsNotNull(eltFormTest);
var eltRunTest = eltFormTest.Element("AStr").Element("Run");
Assert.AreEqual("form1", eltRunTest.Value);
// now check that ws of the new Form matches the Morph Form ws.
var eltWsTest = eltFormTest.Element("AStr").Attribute("ws");
Assert.AreEqual("wsForm0", eltWsTest.Value);
eltWsTest = eltFormTest.Element("AStr").Element("Run").Attribute("ws");
Assert.AreEqual("wsForm0", eltWsTest.Value);
}
// check that MorphBundle without form now has a new alternative forms,
// identical to the Morph alternative Form.
{
DomainObjectDTO dtoNewFormTest;
dtoRepos.TryGetValue(sGuid_wmbNoForm, out dtoNewFormTest);
var eltWmbNewFormTest = XElement.Parse(dtoNewFormTest.Xml);
var eltFormTest = eltWmbNewFormTest.Element("Form");
// get form
Assert.IsNotNull(eltFormTest);
var eltRunTest = eltFormTest.Element("AStr").Element("Run");
Assert.AreEqual("morphForm&0", eltRunTest.Value);
// now check that ws of the new Form matches the Morph Form ws.
var eltWsTest = eltFormTest.Element("AStr").Attribute("ws");
Assert.AreEqual("wsMorph0", eltWsTest.Value);
eltWsTest = eltFormTest.Element("AStr").Element("Run").Attribute("ws");
Assert.AreEqual("wsMorph0", eltWsTest.Value);
// prexisting form should have been deleted. should only have two ws strings now.
Assert.AreEqual(2, eltFormTest.Elements("AStr").Count());
var aStrTest = eltFormTest.Elements("AStr").ToList()[1];
eltRunTest = aStrTest.Element("Run");
Assert.AreEqual("morphForm1", eltRunTest.Value);
eltWsTest = aStrTest.Attribute("ws");
Assert.AreEqual("wsMorph1", eltWsTest.Value);
eltWsTest = aStrTest.Element("Run").Attribute("ws");
Assert.AreEqual("wsMorph1", eltWsTest.Value);
}
}
public void DataMigration7000002Test()
{
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>");
StTextAndParaInfo 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 lpDto = new DomainObjectDTO("9719A466-2240-4DEA-9722-9FE0746A30A6",
"LangProject",
sb.ToString());
dtos.Add(lpDto);
// Add text dto.
var txtDto = new DomainObjectDTO(lpTextsGuids.textGuid.ToString(),
"StText",
lpTextsGuids.textXml);
dtos.Add(txtDto);
// Add text para dto.
var txtParaDto = new DomainObjectDTO(lpTextsGuids.paraGuid.ToString(),
"StTxtPara",
lpTextsGuids.paraXml);
dtos.Add(txtParaDto);
// 2. Add Scripture
sb = new StringBuilder();
sb.Append("<rt class=\"Scripture\" guid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" ownerguid=\"9719A466-2240-4DEA-9722-9FE0746A30A6\" owningflid=\"6001040\" owningord=\"0\">");
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>");
var scrDto = new DomainObjectDTO("2c5c1f5f-1f08-41d7-99fe-23893ee4ceef",
"Scripture",
sb.ToString());
dtos.Add(scrDto);
// 3. Add a ScrBook
sb = new StringBuilder();
sb.Append("<rt class=\"ScrBook\" guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" ownerguid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" owningflid=\"3001001\" owningord=\"0\">");
sb.Append("<ScrBook>");
sb.Append("<Name>");
sb.Append("<AUni ws=\"fr\">Genesis</AUni>");
sb.Append("</Name>");
sb.Append("<Title>");
StTextAndParaInfo titleTextGuids = new StTextAndParaInfo("f213db11-7007-4a2f-9b94-06d6c96014ca", "Title Main");
sb.Append("<objsur guid=\"" + titleTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Title>");
sb.Append("<Sections>");
sb.Append("<objsur guid=\"834e1bf8-3a25-47d6-9f92-806b38b5f815\" t=\"o\" />");
sb.Append("</Sections>");
sb.Append("<Footnotes>");
StTextAndParaInfo footnoteGuids = new StTextAndParaInfo("StFootnote", "f213db11-7007-4a2f-9b94-06d6c96014ca", "Title Main");
sb.Append("<objsur guid=\"" + footnoteGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Footnotes>");
sb.Append("</ScrBook>");
sb.Append("</rt>");
var bookDto = new DomainObjectDTO("f213db11-7007-4a2f-9b94-06d6c96014ca",
"ScrBook",
sb.ToString());
dtos.Add(bookDto);
// Add title
var titleDto = new DomainObjectDTO(titleTextGuids.textGuid.ToString(),
"StText",
titleTextGuids.textXml);
dtos.Add(titleDto);
// Title para
var titleParaDto = new DomainObjectDTO(titleTextGuids.paraGuid.ToString(),
"StTxtPara",
titleTextGuids.paraXml);
dtos.Add(titleParaDto);
// Add footnote
var footnoteDto = new DomainObjectDTO(footnoteGuids.textGuid.ToString(),
"StFootnote",
footnoteGuids.textXml);
dtos.Add(footnoteDto);
// Footnote para
var footnoteParaDto = new DomainObjectDTO(footnoteGuids.paraGuid.ToString(),
"StTxtPara",
footnoteGuids.paraXml);
dtos.Add(footnoteParaDto);
// 4. Add a section to the book
sb = new StringBuilder();
sb.Append("<rt class=\"ScrSection\" guid=\"834e1bf8-3a25-47d6-9f92-806b38b5f815\" ownerguid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" owningflid=\"3002001\" owningord=\"0\">");
sb.Append("<CmObject />");
sb.Append("<ScrSection>");
sb.Append("<Content>");
StTextAndParaInfo contentsTextGuids = new StTextAndParaInfo("834e1bf8-3a25-47d6-9f92-806b38b5f815", "Paragraph");
sb.Append("<objsur guid=\"" + contentsTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Content>");
sb.Append("<Heading>");
StTextAndParaInfo headingTextGuids = new StTextAndParaInfo("834e1bf8-3a25-47d6-9f92-806b38b5f815", "Section Head");
sb.Append("<objsur guid=\"" + headingTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Heading>");
sb.Append("</ScrSection>");
sb.Append("</rt>");
var sectionDto = new DomainObjectDTO("834e1bf8-3a25-47d6-9f92-806b38b5f815",
"ScrSection",
sb.ToString());
dtos.Add(sectionDto);
// Add the contents
var contentsDto = new DomainObjectDTO(contentsTextGuids.textGuid.ToString(),
"StText",
contentsTextGuids.textXml);
dtos.Add(contentsDto);
// Contents para
var contentsParaDto = new DomainObjectDTO(contentsTextGuids.paraGuid.ToString(),
"StTxtPara",
contentsTextGuids.paraXml);
dtos.Add(contentsParaDto);
// Add the heading to the xml
var headingDto = new DomainObjectDTO(headingTextGuids.textGuid.ToString(),
"StText",
headingTextGuids.textXml);
dtos.Add(headingDto);
// heading para
var headingParaDto = new DomainObjectDTO(headingTextGuids.paraGuid.ToString(),
"StTxtPara",
headingTextGuids.paraXml);
dtos.Add(headingParaDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"LangProject", "StText",
"Scripture", "ScrBook", "StFootnote", "ScrSection", "StPara"
});
mockMDC.AddClass(2, "LangProject", "CmObject", new List <string>());
mockMDC.AddClass(3, "StText", "CmObject", new List <string>());
mockMDC.AddClass(4, "Scripture", "CmObject", new List <string>());
mockMDC.AddClass(5, "ScrBook", "CmObject", new List <string>());
mockMDC.AddClass(6, "StFootnote", "CmObject", new List <string> {
"ScrFootnote"
});
mockMDC.AddClass(7, "ScrSection", "CmObject", new List <string>());
mockMDC.AddClass(8, "StTxtPara", "CmObject", new List <string> {
"ScrTxtPara"
});
mockMDC.AddClass(9, "ScrFootnote", "CmObject", new List <string>());
mockMDC.AddClass(10, "ScrTxtPara", "CmObject", new List <string>());
mockMDC.AddClass(11, "StPara", "CmObject", new List <string> {
"StTxtPara"
});
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000001, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000002, new DummyProgressDlg());
Assert.AreEqual(7000002, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Check the paragraphs to make sure they are the correct class
Assert.AreEqual("StTxtPara", txtParaDto.Classname, "Oops. Class was changed.");
XElement paraElement = XElement.Parse(txtParaDto.Xml);
Assert.AreEqual("StTxtPara", paraElement.Attribute("class").Value, "Oops. Class was changed.");
paraElement = XElement.Parse(titleParaDto.Xml);
Assert.AreEqual("ScrTxtPara", titleParaDto.Classname, "Oops. Class was not changed.");
Assert.AreEqual("ScrTxtPara", paraElement.Attribute("class").Value, "Oops. Class was not changed.");
Assert.IsNotNull(paraElement.Element("ScrTxtPara"));
Assert.IsTrue(paraElement.Element("ScrTxtPara").IsEmpty);
Assert.AreEqual("ScrTxtPara", contentsParaDto.Classname, "Oops. Class was not changed.");
Assert.AreEqual("ScrTxtPara", headingParaDto.Classname, "Oops. Class was not changed.");
Assert.AreEqual("ScrTxtPara", footnoteParaDto.Classname, "Oops. Class was not changed.");
}
public void DataMigration7000035Test()
{
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("<Texts>");
StTextAndParaInfo lpTextsGuids = new StTextAndParaInfo("9719A466-2240-4DEA-9722-9FE0746A30A6", "Normal", false, false);
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("</rt>");
var lpDto = new DomainObjectDTO("9719A466-2240-4DEA-9722-9FE0746A30A6",
"LangProject", sb.ToString());
dtos.Add(lpDto);
// Add text dto.
var txtDto = new DomainObjectDTO(lpTextsGuids.textGuid.ToString(), "StText",
lpTextsGuids.textXml);
dtos.Add(txtDto);
// Add text para dto.
var txtParaDto = new DomainObjectDTO(lpTextsGuids.paraGuid.ToString(), "ScrTxtPara",
lpTextsGuids.paraXml);
dtos.Add(txtParaDto);
// 2. Add Scripture
sb = new StringBuilder();
sb.Append("<rt class=\"Scripture\" guid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" ownerguid=\"9719A466-2240-4DEA-9722-9FE0746A30A6\" owningflid=\"6001040\" owningord=\"0\">");
sb.Append("<Books>");
sb.Append("<objsur guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" t=\"o\" />");
sb.Append("</Books>");
sb.Append("</rt>");
var scrDto = new DomainObjectDTO("2c5c1f5f-1f08-41d7-99fe-23893ee4ceef", "Scripture",
sb.ToString());
dtos.Add(scrDto);
// 3. Add a ScrBook
sb = new StringBuilder();
sb.Append("<rt class=\"ScrBook\" guid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" ownerguid=\"2c5c1f5f-1f08-41d7-99fe-23893ee4ceef\" owningflid=\"3001001\" owningord=\"0\">");
sb.Append("<Name>");
sb.Append("<AUni ws=\"fr\">Genesis</AUni>");
sb.Append("</Name>");
sb.Append("<Title>");
StTextAndParaInfo titleTextGuids = new StTextAndParaInfo("f213db11-7007-4a2f-9b94-06d6c96014ca", "Title Main", true, false);
sb.Append("<objsur guid=\"" + titleTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Title>");
sb.Append("<Sections>");
sb.Append("<objsur guid=\"834e1bf8-3a25-47d6-9f92-806b38b5f815\" t=\"o\" />");
sb.Append("</Sections>");
sb.Append("<Footnotes>");
// This footnote should also have its ParaContainingOrc property set, but this test really doesn't care.
StTextAndParaInfo footnoteGuids = new StTextAndParaInfo("ScrFootnote", "f213db11-7007-4a2f-9b94-06d6c96014ca", "Note General Paragraph", null, true, false);
sb.Append("<objsur guid=\"" + footnoteGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Footnotes>");
sb.Append("</rt>");
var bookDto = new DomainObjectDTO("f213db11-7007-4a2f-9b94-06d6c96014ca", "ScrBook", sb.ToString());
dtos.Add(bookDto);
// Add title
var titleDto = new DomainObjectDTO(titleTextGuids.textGuid.ToString(), "StText",
titleTextGuids.textXml);
dtos.Add(titleDto);
// Title para
var titleParaDto = new DomainObjectDTO(titleTextGuids.paraGuid.ToString(), "ScrTxtPara",
titleTextGuids.paraXml);
dtos.Add(titleParaDto);
// Add footnote
var footnoteDto = new DomainObjectDTO(footnoteGuids.textGuid.ToString(), "ScrFootnote",
footnoteGuids.textXml);
dtos.Add(footnoteDto);
// Footnote para
var footnoteParaDto = new DomainObjectDTO(footnoteGuids.paraGuid.ToString(), "ScrTxtPara",
footnoteGuids.paraXml);
dtos.Add(footnoteParaDto);
// 4. Add a section to the book
sb = new StringBuilder();
sb.Append("<rt class=\"ScrSection\" guid=\"834e1bf8-3a25-47d6-9f92-806b38b5f815\" ownerguid=\"f213db11-7007-4a2f-9b94-06d6c96014ca\" owningflid=\"3002001\" owningord=\"0\">");
sb.Append("<Content>");
StTextAndParaInfo contentsTextGuids = new StTextAndParaInfo("StText", "834e1bf8-3a25-47d6-9f92-806b38b5f815", "Paragraph",
"<Run ws=\"fr\" link=\"" + footnoteGuids.textGuid + "\"></Run>", true, false,
"<Run ws=\"en\" link=\"" + footnoteGuids.textGuid + "\"></Run>");
sb.Append("<objsur guid=\"" + contentsTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Content>");
sb.Append("<Heading>");
StTextAndParaInfo headingTextGuids = new StTextAndParaInfo("834e1bf8-3a25-47d6-9f92-806b38b5f815", "Section Head", true, false);
sb.Append("<objsur guid=\"" + headingTextGuids.textGuid + "\" t=\"o\" />");
sb.Append("</Heading>");
sb.Append("</rt>");
var sectionDto = new DomainObjectDTO("834e1bf8-3a25-47d6-9f92-806b38b5f815", "ScrSection",
sb.ToString());
dtos.Add(sectionDto);
// Add the contents
var contentsDto = new DomainObjectDTO(contentsTextGuids.textGuid.ToString(), "StText",
contentsTextGuids.textXml);
dtos.Add(contentsDto);
// Contents para
var contentsParaDto = new DomainObjectDTO(contentsTextGuids.paraGuid.ToString(), "ScrTxtPara",
contentsTextGuids.paraXml);
dtos.Add(contentsParaDto);
// BT of para
var btDto = new DomainObjectDTO(contentsTextGuids.btGuid.ToString(), "CmTranslation",
contentsTextGuids.btXml);
dtos.Add(btDto);
// Add the heading to the xml
var headingDto = new DomainObjectDTO(headingTextGuids.textGuid.ToString(), "StText",
headingTextGuids.textXml);
dtos.Add(headingDto);
// heading para
var headingParaDto = new DomainObjectDTO(headingTextGuids.paraGuid.ToString(), "ScrTxtPara",
headingTextGuids.paraXml);
dtos.Add(headingParaDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"LangProject", "StText", "Scripture",
"ScrBook", "StFootnote", "ScrSection", "StPara"
});
mockMDC.AddClass(2, "LangProject", "CmObject", new List <string>());
mockMDC.AddClass(3, "StText", "CmObject", new List <string> {
"StFootnote"
});
mockMDC.AddClass(4, "Scripture", "CmObject", new List <string>());
mockMDC.AddClass(5, "ScrBook", "CmObject", new List <string>());
mockMDC.AddClass(6, "StFootnote", "StText", new List <string> {
"ScrFootnote"
});
mockMDC.AddClass(7, "ScrSection", "CmObject", new List <string>());
mockMDC.AddClass(8, "StTxtPara", "StPara", new List <string> {
"ScrTxtPara"
});
mockMDC.AddClass(9, "ScrFootnote", "StFootnote", new List <string>());
mockMDC.AddClass(10, "ScrTxtPara", "StTxtPara", new List <string>());
mockMDC.AddClass(11, "StPara", "CmObject", new List <string> {
"StTxtPara"
});
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000034, dtos, mockMDC, null, FwDirectoryFinder.FdoDirectories);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000035, new DummyProgressDlg());
Assert.AreEqual(7000035, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Check that the link to the footnote has been changed to an owniing link
DomainObjectDTO paraDTO = dtoRepos.GetDTO(contentsTextGuids.paraGuid.ToString());
XElement para = XElement.Parse(paraDTO.Xml);
XElement contents = para.Element("Contents");
XElement str = contents.Element("Str");
XElement run = str.Element("Run");
Assert.IsNull(run.Attribute("link"));
XAttribute linkAttr = run.Attribute("ownlink");
Assert.IsNotNull(linkAttr);
Assert.AreEqual(footnoteGuids.textGuid.ToString(), linkAttr.Value);
Assert.AreEqual(contentsTextGuids.btGuid.ToString(), para.Element("Translations").Element("objsur").Attribute("guid").Value);
DomainObjectDTO btDTO = dtoRepos.GetDTO(contentsTextGuids.btGuid.ToString());
XElement bt = XElement.Parse(btDTO.Xml);
XElement btStr = bt.Element("Translation").Element("AStr");
XElement btRun = btStr.Element("Run");
Assert.IsNull(btRun.Attribute("ownlink"));
XAttribute btLinkAttr = btRun.Attribute("link");
Assert.IsNotNull(btLinkAttr);
Assert.AreEqual(footnoteGuids.textGuid.ToString(), btLinkAttr.Value);
}
public void DataMigration7000011Test()
{
var dtos = new HashSet <DomainObjectDTO>();
var sb = new StringBuilder();
// 1. Add barebones Notebook.
sb.Append("<rt class=\"RnResearchNbk\" guid=\"2E237D40-853C-49D5-AAC6-EFF01121AC25\">");
sb.Append("<RnResearchNbk>");
sb.Append("<RecTypes><objsur t=\"o\" guid=\"513B370D-8EFC-4C94-8192-7707677A6F98\" /></RecTypes>");
sb.Append("<Records>");
sb.Append("<objsur t=\"o\" guid=\"C84B721B-3617-43DE-A436-9E0538837A66\" />");
sb.Append("</Records>");
sb.Append("</RnResearchNbk>");
sb.Append("</rt>");
var nbkDto = new DomainObjectDTO("2E237D40-853C-49D5-AAC6-EFF01121AC25", "RnResearchNbk", sb.ToString());
dtos.Add(nbkDto);
sb = new StringBuilder();
// 2. Add barebones RecTypes List
sb.Append("<rt class=\"CmPossibilityList\" guid=\"513B370D-8EFC-4C94-8192-7707677A6F98\" ownerguid=\"2E237D40-853C-49D5-AAC6-EFF01121AC25\">");
sb.Append("<CmPossibilityList>");
sb.Append("<Possibilities>");
sb.Append("<objsur t=\"o\" guid=\"27C32299-3B41-4FAD-A85C-F47657BCF95A\" />");
sb.Append("<objsur t=\"o\" guid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\" />");
sb.Append("</Possibilities>");
sb.Append("</CmPossibilityList>");
sb.Append("</rt>");
var recTypesDto = new DomainObjectDTO("513B370D-8EFC-4C94-8192-7707677A6F98", "CmPossibilityList", sb.ToString());
dtos.Add(recTypesDto);
sb = new StringBuilder();
// 3. Add barebones Conversation
sb.Append("<rt class=\"CmPossibility\" guid=\"27C32299-3B41-4FAD-A85C-F47657BCF95A\" ownerguid=\"513B370D-8EFC-4C94-8192-7707677A6F98\">");
sb.Append("<CmPossibility>");
sb.Append("<Abbreviation><AUni ws=\"en\">Con</AUni></Abbreviation>");
sb.Append("</CmPossibility>");
sb.Append("</rt>");
var conDto = new DomainObjectDTO("27C32299-3B41-4FAD-A85C-F47657BCF95A", "CmPossibility", sb.ToString());
dtos.Add(conDto);
sb = new StringBuilder();
// 4. Add barebones Observation
sb.Append("<rt class=\"CmPossibility\" guid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\" ownerguid=\"513B370D-8EFC-4C94-8192-7707677A6F98\">");
sb.Append("<CmPossibility>");
sb.Append("<Abbreviation><AUni ws=\"en\">Obs</AUni></Abbreviation>");
sb.Append("<SubPossibilities>");
sb.Append("<objsur t=\"o\" guid=\"9827CBE0-31F3-434E-80F7-5D5354C110B0\" />");
sb.Append("</SubPossibilities>");
sb.Append("</CmPossibility>");
sb.Append("</rt>");
var obsDto = new DomainObjectDTO("5E3D9C56-404C-44C5-B3CB-99BF390E322E", "CmPossibility", sb.ToString());
dtos.Add(obsDto);
sb = new StringBuilder();
// 5. Add barebones Performance
sb.Append("<rt class=\"CmPossibility\" guid=\"9827CBE0-31F3-434E-80F7-5D5354C110B0\" ownerguid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\">");
sb.Append("<CmPossibility>");
sb.Append("<Abbreviation><AUni ws=\"en\">Per</AUni></Abbreviation>");
sb.Append("</CmPossibility>");
sb.Append("</rt>");
var perDto = new DomainObjectDTO("9827CBE0-31F3-434E-80F7-5D5354C110B0", "CmPossibility", sb.ToString());
dtos.Add(perDto);
sb = new StringBuilder();
// 6. Add barebones RnGenericRec
sb.Append("<rt class=\"RnGenericRec\" guid=\"c84b721b-3617-43de-a436-9e0538837a66\" ownerguid=\"2E237D40-853C-49D5-AAC6-EFF01121AC25\">");
sb.Append("<RnGenericRec>");
sb.Append("<Type><objsur guid=\"27c32299-3b41-4fad-a85c-f47657bcf95a\" t=\"r\" /></Type>");
sb.Append("</RnGenericRec>");
sb.Append("</rt>");
var recDto = new DomainObjectDTO("c84b721b-3617-43de-a436-9e0538837a66", "RnGenericRec", sb.ToString());
dtos.Add(recDto);
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"RnResearchNbk", "CmPossibilityList", "CmPossibility", "RnGenericRec"
});
mockMDC.AddClass(2, "RnResearchNbk", "CmObject", new List <string>());
mockMDC.AddClass(3, "CmPossibilityList", "CmObject", new List <string>());
mockMDC.AddClass(4, "CmPossibility", "CmObject", new List <string>());
mockMDC.AddClass(5, "RnGenericRec", "CmObject", new List <string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000010, dtos, mockMDC, null);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000011, new DummyProgressDlg());
XElement nbkElem = XElement.Parse(nbkDto.Xml);
Assert.AreEqual("D9D55B12-EA5E-11DE-95EF-0013722F8DEC",
(string)nbkElem.XPathSelectElement("RnResearchNbk/RecTypes/objsur").Attribute("guid"));
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, recTypesDto);
recTypesDto = dtoRepos.GetDTO("D9D55B12-EA5E-11DE-95EF-0013722F8DEC");
XElement recTypesElem = XElement.Parse(recTypesDto.Xml);
List <XElement> objSurElems = recTypesElem.XPathSelectElements("CmPossibilityList/Possibilities/objsur").ToList();
Assert.AreEqual(2, objSurElems.Count);
Assert.AreEqual("B7B37B86-EA5E-11DE-80E9-0013722F8DEC", (string)objSurElems[0].Attribute("guid"));
Assert.AreEqual("B7EA5156-EA5E-11DE-9F9C-0013722F8DEC", (string)objSurElems[1].Attribute("guid"));
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, conDto);
conDto = dtoRepos.GetDTO("B7B37B86-EA5E-11DE-80E9-0013722F8DEC");
XElement conElem = XElement.Parse(conDto.Xml);
Assert.AreEqual("Con", (string)conElem.XPathSelectElement("CmPossibility/Abbreviation/AUni[@ws='en']"));
Assert.AreEqual("D9D55B12-EA5E-11DE-95EF-0013722F8DEC", (string)conElem.Attribute("ownerguid"));
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, obsDto);
obsDto = dtoRepos.GetDTO("B7EA5156-EA5E-11DE-9F9C-0013722F8DEC");
XElement obsElem = XElement.Parse(obsDto.Xml);
Assert.AreEqual("Obs", (string)obsElem.XPathSelectElement("CmPossibility/Abbreviation/AUni[@ws='en']"));
Assert.AreEqual("B7F63D0E-EA5E-11DE-9F02-0013722F8DEC",
(string)obsElem.XPathSelectElement("CmPossibility/SubPossibilities/objsur").Attribute("guid"));
Assert.AreEqual("D9D55B12-EA5E-11DE-95EF-0013722F8DEC", (string)obsElem.Attribute("ownerguid"));
DataMigrationTestServices.CheckDtoRemoved(dtoRepos, perDto);
perDto = dtoRepos.GetDTO("B7F63D0E-EA5E-11DE-9F02-0013722F8DEC");
XElement perElem = XElement.Parse(perDto.Xml);
Assert.AreEqual("Per", (string)perElem.XPathSelectElement("CmPossibility/Abbreviation/AUni[@ws='en']"));
Assert.AreEqual("B7EA5156-EA5E-11DE-9F9C-0013722F8DEC", (string)perElem.Attribute("ownerguid"));
XElement recElem = XElement.Parse(recDto.Xml);
Assert.AreEqual("B7B37B86-EA5E-11DE-80E9-0013722F8DEC", (string)recElem.XPathSelectElement("RnGenericRec/Type/objsur").Attribute("guid"));
}
public void DataMigration7000047Test()
{
var dtos = new HashSet <DomainObjectDTO>();
var sb = new StringBuilder();
// Add Lang Project dto.
const string sLpGuid = "9719A466-2240-4DEA-9722-9FE0746A30A6";
sb.Append("<rt class=\"LangProject\" guid=\"" + sLpGuid + "\">");
sb.Append("<CheckLists>");
sb.Append("<objsur guid=\"" + LangProjectTags.kguidChkKeyTermsList + "\" t=\"o\" />");
sb.Append("</CheckLists>");
sb.Append("</rt>");
dtos.Add(new DomainObjectDTO(sLpGuid, "LangProject", sb.ToString()));
sb.Length = 0;
// Add Key Terms List dto.
sb.Append("<rt class=\"CmPossibilityList\" guid=\"" + LangProjectTags.kguidChkKeyTermsList + "\" ownerguid=\"" + sLpGuid + "\">");
sb.Append("<Possibilities>");
sb.Append("<objsur t=\"o\" guid=\"27C32299-3B41-4FAD-A85C-F47657BCF95A\" />");
sb.Append("<objsur t=\"o\" guid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\" />");
sb.Append("</Possibilities>");
sb.Append("</rt>");
dtos.Add(new DomainObjectDTO(LangProjectTags.kguidChkKeyTermsList.ToString(), "CmPossibilityList", sb.ToString()));
sb.Length = 0;
// Add Key Term 1 dto.
sb.Append("<rt class=\"ChkTerm\" guid=\"22E6AF17-34BD-4433-BFDA-16C736E1F3F0\" ownerguid=\"" + LangProjectTags.kguidChkKeyTermsList + "\">");
sb.Append("<Renderings>");
sb.Append("<objsur t=\"o\" guid=\"27C32299-3B41-4FAD-A85C-F47657BCF95A\" />"); // bogus rendering 1
sb.Append("<objsur t=\"o\" guid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\" />"); // valid rendering
sb.Append("</Renderings>");
sb.Append("</rt>");
DomainObjectDTO term1 = new DomainObjectDTO("22E6AF17-34BD-4433-BFDA-16C736E1F3F0", "ChkTerm", sb.ToString());
dtos.Add(term1);
sb.Length = 0;
// Add Key Term 2 dto.
sb.Append("<rt class=\"ChkTerm\" guid=\"B6C6C9B1-664A-4033-9937-DDA00C4000A7\" ownerguid=\"" + LangProjectTags.kguidChkKeyTermsList + "\">");
sb.Append("<Renderings>");
sb.Append("<objsur t=\"o\" guid=\"5FB86AAE-5E05-4d57-92B8-FFD0B67545CA\" />"); // bogus rendering 2
sb.Append("<objsur t=\"o\" guid=\"B86AD2DF-98D0-4ec7-93DC-723D90A209EC\" />"); // bogus rendering 3
sb.Append("</Renderings>");
sb.Append("</rt>");
DomainObjectDTO term2 = new DomainObjectDTO("B6C6C9B1-664A-4033-9937-DDA00C4000A7", "ChkTerm", sb.ToString());
dtos.Add(term2);
sb.Length = 0;
// Add bogus ChkRendering 1 dto.
DomainObjectDTO bogusRendering1 = new DomainObjectDTO("27C32299-3B41-4FAD-A85C-F47657BCF95A", "ChkRendering",
"<rt class=\"ChkRendering\" guid=\"27C32299-3B41-4FAD-A85C-F47657BCF95A\" ownerguid=\"22E6AF17-34BD-4433-BFDA-16C736E1F3F0\"/>");
dtos.Add(bogusRendering1);
// Add valid ChkRendering dto.
sb.Append("<rt class=\"ChkRendering\" guid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\" ownerguid=\"22E6AF17-34BD-4433-BFDA-16C736E1F3F0\">");
sb.Append("<SurfaceForm>");
sb.Append("<objsur guid=\"BD8B2BE2-BDC7-476a-A627-5B59480A6490\" t=\"r\" />");
sb.Append("</SurfaceForm>");
sb.Append("</rt>");
DomainObjectDTO validRendering = new DomainObjectDTO("5E3D9C56-404C-44C5-B3CB-99BF390E322E", "ChkRendering", sb.ToString());
dtos.Add(validRendering);
sb.Length = 0;
// Add bogus ChkRendering 2 dto.
DomainObjectDTO bogusRendering2 = new DomainObjectDTO("5FB86AAE-5E05-4d57-92B8-FFD0B67545CA", "ChkRendering",
"<rt class=\"ChkRendering\" guid=\"5FB86AAE-5E05-4d57-92B8-FFD0B67545CA\" ownerguid=\"B6C6C9B1-664A-4033-9937-DDA00C4000A7\"/>");
dtos.Add(bogusRendering2);
// Add bogus ChkRendering 3 dto.
DomainObjectDTO bogusRendering3 = new DomainObjectDTO("B86AD2DF-98D0-4ec7-93DC-723D90A209EC", "ChkRendering",
"<rt class=\"ChkRendering\" guid=\"B86AD2DF-98D0-4ec7-93DC-723D90A209EC\" ownerguid=\"B6C6C9B1-664A-4033-9937-DDA00C4000A7\"/>");
dtos.Add(bogusRendering3);
// Add valid WfiWordform dto.
sb.Append("<rt class=\"WfiWordform\" guid=\"BD8B2BE2-BDC7-476a-A627-5B59480A6490\" ownerguid=\"DC93551D-0DFB-48fd-8BF4-46FF9BF03BCD\">");
sb.Append("<Form>");
sb.Append("<AUni ws=\"es\">carro</AUni>");
sb.Append("</Form>");
sb.Append("</rt>");
DomainObjectDTO wordForm = new DomainObjectDTO("BD8B2BE2-BDC7-476a-A627-5B59480A6490", "WfiWordform", sb.ToString());
dtos.Add(wordForm);
sb.Length = 0;
// Set up mock MDC.
var mockMDC = new MockMDCForDataMigration();
mockMDC.AddClass(1, "CmObject", null, new List <string> {
"LangProject", "CmPossibilityList", "CmPossibility",
"CkRendering", "WfiWordform"
});
mockMDC.AddClass(2, "LangProject", "CmObject", new List <string>());
mockMDC.AddClass(3, "CmPossibilityList", "CmObject", new List <string>());
mockMDC.AddClass(4, "CmPossibility", "CmObject", new List <string> {
"ChkTerm"
});
mockMDC.AddClass(5, "ChkTerm", "CmObject", new List <string>());
mockMDC.AddClass(6, "CkRendering", "CmObject", new List <string>());
mockMDC.AddClass(7, "WfiWordform", "CmObject", new List <string>());
IDomainObjectDTORepository dtoRepos = new DomainObjectDtoRepository(7000046, dtos, mockMDC, null);
m_dataMigrationManager.PerformMigration(dtoRepos, 7000047, new DummyProgressDlg());
Assert.AreEqual(7000047, dtoRepos.CurrentModelVersion, "Wrong updated version.");
// Check that ChkTerm references to the bogus ChkRenderings have been removed
Assert.IsFalse(term1.Xml.Contains("<objsur t=\"o\" guid=\"27C32299-3B41-4FAD-A85C-F47657BCF95A\" />"));
Assert.IsTrue(term1.Xml.Contains("<objsur t=\"o\" guid=\"5E3D9C56-404C-44C5-B3CB-99BF390E322E\" />"));
Assert.IsFalse(term2.Xml.Contains("<objsur t=\"o\" guid=\"5FB86AAE-5E05-4d57-92B8-FFD0B67545CA\" />"));
Assert.IsFalse(term2.Xml.Contains("<objsur t=\"o\" guid=\"B86AD2DF-98D0-4ec7-93DC-723D90A209EC\" />"));
// Check that the bogus ChkRenderings have been removed
Assert.IsFalse(dtos.Contains(bogusRendering1));
Assert.IsTrue(dtos.Contains(validRendering));
Assert.IsFalse(dtos.Contains(bogusRendering2));
Assert.IsFalse(dtos.Contains(bogusRendering3));
}
