public void Mapping_FieldMapTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetFieldMap);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result excluding expected mismatches
WitDiffResult result = GetDiffResult();
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH,
FIELD_TITLE, FIELD_DESCRIPTION
});
// Title <-> Description
int targetId = QueryTargetWorkItemID(workitemId);
string srcTitle = SourceAdapter.GetFieldValue(workitemId, FIELD_TITLE);
string srcDesc = SourceAdapter.GetFieldValue(workitemId, FIELD_DESCRIPTION);
string tarTitle = TargetAdapter.GetFieldValue(targetId, FIELD_TITLE);
string tarDesc = TargetAdapter.GetFieldValue(targetId, FIELD_DESCRIPTION);
Assert.AreEqual(srcTitle, tarDesc);
Assert.AreEqual(srcDesc, tarTitle);
}
public void Link_AddParentTest()
{
// add a work item on source side
int workitemId1 = SourceAdapter.AddWorkItem("Bug", "title", "description1");
int workitemId2 = SourceAdapter.AddWorkItem("Bug", "title2", "description2");
Console.WriteLine(String.Format("Source work item Ids: Parent: {0}, Child: {1}", workitemId1, workitemId2));
RunAndNoValidate();
TfsSourceAdapter.AddParentChildLink(workitemId1, workitemId2);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
int mirroredId1 = QueryTargetWorkItemID(workitemId1);
int mirroredId2 = QueryTargetWorkItemID(workitemId2);
Console.WriteLine(String.Format("Target work item Ids: Parent: {0}, Child: {1}", mirroredId1, mirroredId2));
Assert.AreEqual(1, TfsTargetAdapter.GetRelatedLinkCount(mirroredId1));
Assert.AreEqual(false, TfsTargetAdapter.IsLinkLocked(mirroredId1, mirroredId2));
}
public void Mapping_MissingStateReasonFieldMapTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_EnableBypassRulesOnTarget);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetMissingStateReasonFieldMap);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result excluding expected mismatches
WitDiffResult result = GetDiffResult();
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH,
FIELD_TITLE, FIELD_DESCRIPTION
});
}
public void Attachment_BasicTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_EnableBypassRulesOnTarget);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
// update link comment
WITAttachmentChangeAction action1 = new WITAttachmentChangeAction();
action1.AddAttachment(new WITAttachment("attachment1.txt", "comment 1"));
SourceAdapter.UpdateAttachment(workitemId, action1);
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
"System.IterationPath", "System.AreaPath"
});
}
public void BasicWorkItemTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
"System.IterationPath", "System.AreaPath"
});
}
public void Mapping_UserMapTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_EnableBypassRulesOnTarget);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetUserValueMap);
// add a work item on source side
int sourceId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
SourceUser = SourceAdapter.GetFieldValue(sourceId, FIELD_ASSIGNEDTO);
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result excluding expected mismatches
WitDiffResult result = GetDiffResult();
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH, FIELD_ASSIGNEDTO
});
// verify the user mapping
int targetId = QueryTargetWorkItemID(sourceId);
string sourceUser = SourceAdapter.GetFieldValue(sourceId, FIELD_ASSIGNEDTO);
string targetUser = TargetAdapter.GetFieldValue(targetId, FIELD_ASSIGNEDTO);
Assert.AreEqual(sourceUser, SourceUser);
Assert.AreEqual(targetUser, TargetUser);
}
public void Link_AddRelatedLinkTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
string title1 = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId1 = SourceAdapter.AddWorkItem("Bug", title1, "description1");
string title2 = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId2 = SourceAdapter.AddWorkItem("Bug", title1, "description2");
RunAndNoValidate();
TfsSourceAdapter.AddRelatedWorkItemLink(workitemId1, workitemId2);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
int mirroredId = QueryMirroredWorkItemID(workitemId1);
Assert.AreEqual(1, TfsTargetAdapter.GetRelatedLinkCount(mirroredId));
}
public void BasicWorkItemTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// Get migrated workitem ID. This will Fail if it cannot find it.
QueryTargetWorkItemID(workitemId);
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
"System.IterationPath", "System.AreaPath"
});
}
internal WitDiffResult GetDiffResult()
{
ServerDiffEngine diff = new ServerDiffEngine(Guid.Empty, false, true, SessionTypeEnum.WorkItemTracking);
WITDiffComparer witDiffComparer = new WITDiffComparer(diff, true);
diff.RegisterDiffComparer(witDiffComparer);
// Add additional fields for which different values should not cause a failure because
// the tests are configured such that these will be different
HashSet <string> fieldsToIgnore = new HashSet <string>();
fieldsToIgnore.Add("System.AreaPath");
fieldsToIgnore.Add("System.IterationPath");
bool allContentsMatch = witDiffComparer.VerifyContentsMatch(null, null, fieldsToIgnore, fieldsToIgnore);
WitDiffResult result = witDiffComparer.DiffResult;
Trace.TraceInformation("============== Result ===================");
Trace.TraceInformation("Work Item count: {0}", result.WorkItemCount);
Trace.TraceInformation("#Attachments mismatch: {0}", result.AttachmentMismatchCount);
Trace.TraceInformation("#Links mismatch: {0}", result.LinkMismatchCount);
Trace.TraceInformation("#Content mismatch: {0}", result.ContentMismatchCount);
Trace.TraceInformation("#Missing WorkItems: {0}", result.MissingWorkItemCount);
Trace.TraceInformation("All contents match: {0}", allContentsMatch);
return(result);
}
public void LockedLink_BasicSyncTest()
{
// add a work item on source side
int workitemId1 = SourceAdapter.AddWorkItem("Bug", "parent", "description1");
int workitemId2 = SourceAdapter.AddWorkItem("Bug", "child", "description2");
RunAndNoValidate();
TfsSourceAdapter.AddParentChildLink(workitemId1, workitemId2, true);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
int mirroredId1 = QueryTargetWorkItemID(workitemId1);
int mirroredId2 = QueryTargetWorkItemID(workitemId2);
Assert.IsTrue(TfsTargetAdapter.IsLinkLocked(mirroredId1, mirroredId2), "migrated link is not locked");
}
public void WITPagingTest()
{
// Note the size of page is 50
int pageSize = 50;
// add 49 work items (page size - 1)
BatchAddWorkItems(pageSize - 1);
RunAndNoValidate(false);
// add 50 work items
BatchAddWorkItems(pageSize);
RunAndNoValidate(true);
// add 51 work items
BatchAddWorkItems(pageSize + 1);
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches due to test environments
VerifySyncResult(result, new List <string> {
"System.IterationPath", "System.AreaPath"
});
}
public void EditEditConflictIgnoreByFieldChangeTest()
{
int sourceId;
int targetId;
EditEditConflictScenario(out sourceId, out targetId);
string srcTitle = SourceAdapter.GetFieldValue(sourceId, FIELD_TITLE);
string srcDesc = SourceAdapter.GetFieldValue(sourceId, FIELD_DESCRIPTION);
string tarTitle = TargetAdapter.GetFieldValue(targetId, FIELD_TITLE);
string tarDesc = TargetAdapter.GetFieldValue(targetId, FIELD_DESCRIPTION);
Assert.AreNotEqual(srcTitle, tarTitle, "Title should not match due to conflict");
Assert.AreNotEqual(srcDesc, tarDesc, "Description should not match due to conflict");
// verify we have edit/edit conflict
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count >= 1, "There should be edit/edit conflict");
WITEditEditConflictType contentConflict = new WITEditEditConflictType();
Assert.IsTrue(contentConflict.ReferenceName.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName),
"It should be WIT edit/edit conflict");
// resolve the conflict by ignoring conflicts it edits are on different fields
bool isResolved = m_conflictResolver.TryResolveConflict(conflicts[0],
new WITEditEditConflictIgnoreByFieldChangeAction(), "/" + sourceId);
Assert.IsFalse(isResolved, "Conflict resolution should fail as both ends edited a same field");
if (TestEnvironment.MigrationTestType == MigrationTestType.TwoWayRight)
{
isResolved = m_conflictResolver.TryResolveConflict(conflicts[0], new WITEditEditConflictTakeTargetChangesAction(), "/" + targetId);
}
else
{
isResolved = m_conflictResolver.TryResolveConflict(conflicts[0], new WITEditEditConflictTakeSourceChangesAction(), "/" + sourceId);
}
Assert.IsTrue(isResolved, "Conflict resolution should succeed");
// restart the migration tool
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches due to test environments
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
srcDesc = SourceAdapter.GetFieldValue(sourceId, FIELD_DESCRIPTION);
tarDesc = TargetAdapter.GetFieldValue(targetId, FIELD_DESCRIPTION);
Assert.AreEqual(srcDesc, SOURCE_R1_DESC);
Assert.AreEqual(tarDesc, SOURCE_R1_DESC);
}
internal override WitDiffResult VerifySyncResult()
{
WitDiffResult result = GetDiffResult();
Assert.AreEqual(0, result.AttachmentMismatchCount, "# of attachments mismatch");
Assert.AreEqual(0, result.LinkMismatchCount, "# of links mismatch");
Assert.AreEqual(0, result.ContentMismatchCount, "content mismatch");
return(result);
}
internal override WitDiffResult VerifySyncResult()
{
WitDiffResult result = GetDiffResult();
Assert.AreEqual(0, result.AttachmentMismatchCount, "# of attachments mismatch");
Assert.AreEqual(0, result.LinkMismatchCount, "# of links mismatch");
Assert.AreEqual(0, result.ContentMismatchCount, "content mismatch");
//Assert.AreEqual(0, result.MissingWorkItemCount, "WorkItems were not migrated");
//Assert.IsTrue(result.AllContentsMatch, "Contents do not match");
return(result);
}
public void AttachmentAddAddDeleteTest()
{
// add a work item on source side
int sourceId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
// update link comment
WITAttachmentChangeAction add1 = new WITAttachmentChangeAction();
add1.AddAttachment(new WITAttachment("attachment1.txt", "comment 1"));
SourceAdapter.UpdateAttachment(sourceId, add1);
WITAttachmentChangeAction add2 = new WITAttachmentChangeAction();
add2.AddAttachment(new WITAttachment("attachment2.txt", "comment 2"));
SourceAdapter.UpdateAttachment(sourceId, add2);
RunAndNoValidate(true);
WITAttachmentChangeAction delete2 = new WITAttachmentChangeAction();
delete2.DeleteAttachment(new WITAttachment("attachment2.txt", null));
SourceAdapter.UpdateAttachment(sourceId, delete2);
WITAttachmentChangeAction add3 = new WITAttachmentChangeAction();
add3.AddAttachment(new WITAttachment("attachment3.txt", "comment 2"));
SourceAdapter.UpdateAttachment(sourceId, add3);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
int targetId = QueryTargetWorkItemID(sourceId);
int sourceCount = TfsSourceAdapter.GetAttachmentCount(sourceId);
int targetCount = TfsTargetAdapter.GetAttachmentCount(targetId);
Assert.AreEqual(2, sourceCount, "source should have 2 attachments");
Assert.AreEqual(2, targetCount, "target should have 2 attachments");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
"System.IterationPath", "System.AreaPath"
});
}
public void Link_DeleteRelatedLinkFromBothSideTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_SetBidirectionalNoContextSync);
// add a work item on source side
string title1 = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId1 = SourceAdapter.AddWorkItem("Bug", title1, "description1");
string title2 = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId2 = SourceAdapter.AddWorkItem("Bug", title1, "description2");
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetTargetFilterString);
RunAndNoValidate();
int mirroredId1 = QueryMirroredWorkItemID(workitemId1);
int mirroredId2 = QueryMirroredWorkItemID(workitemId2);
// source: add a related link
TfsSourceAdapter.AddRelatedWorkItemLink(workitemId1, workitemId2);
RunAndNoValidate(true);
Assert.AreEqual(1, TfsTargetAdapter.GetRelatedLinkCount(mirroredId1), "RelatedLink count on target system is wrong");
// source: delete the link
TfsSourceAdapter.DeleteRelatedWorkItemLink(workitemId1, workitemId2);
// target: delete the same link
TfsTargetAdapter.DeleteRelatedWorkItemLink(mirroredId1, mirroredId2);
RunAndNoValidate(true);
// now both sides shouldn't have a link
Assert.AreEqual(0, TfsSourceAdapter.GetRelatedLinkCount(workitemId1), "RelatedLink count on source system is wrong");
Assert.AreEqual(0, TfsTargetAdapter.GetRelatedLinkCount(workitemId1), "RelatedLink count on target system is wrong");
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
}
public void Attachment_DeleteTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_EnableBypassRulesOnTarget);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
WITAttachmentChangeAction action1 = new WITAttachmentChangeAction();
WITAttachment attachment1 = new WITAttachment("attachment1.txt", "comment 1");
action1.AddAttachment(attachment1);
SourceAdapter.UpdateAttachment(workitemId, action1);
RunAndNoValidate();
// delete the attachment
WITAttachmentChangeAction action2 = new WITAttachmentChangeAction();
action2.DeleteAttachment(attachment1);
SourceAdapter.UpdateAttachment(workitemId, action2);
WITChangeAction action3 = new WITChangeAction();
action3.Description = "Description change by action 3";
SourceAdapter.UpdateWorkItem(workitemId, action3);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
"System.IterationPath", "System.AreaPath"
});
// TODO: Remove the following verification once ServerDiff supports attachment count diffing.
int mirroredId = QueryMirroredWorkItemID(workitemId);
Assert.AreEqual(TfsSourceAdapter.GetAttachmentCount(workitemId),
TfsTargetAdapter.GetAttachmentCount(mirroredId), "Attachment counts should be same");
}
public void Link_DeleteHyperLinkTest()
{
// TODO: Figure out why this tests fail against TFS 2008 but works in TFS 2010
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title1", "description1");
// add a link
WITLinkChangeAction action1 = new WITLinkChangeAction(LinkChangeActionType.Add);
WITLink link1 = new WITLink("link1");
action1.AddLink(link1);
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// delete the link
action1 = new WITLinkChangeAction(LinkChangeActionType.Delete);
action1.AddLink(link1);
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
RunAndNoValidate(true);
// verify there's no conflicts raised
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
// TODO: Remove the following verification once ServerDiff supports link diffing.
int mirroredId = QueryTargetWorkItemID(workitemId);
Assert.AreEqual(TfsSourceAdapter.GetHyperLinkCount(workitemId),
TfsTargetAdapter.GetHyperLinkCount(mirroredId));
}
public void Link_CyclicLinkBidirectionalTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_SetBidirectionalNoContextSync);
Link_CyclicLinkScenarioTwoWay();
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
}
public void InvalidFieldConflictUseFieldMapTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetInvalidFieldMap);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
WITChangeAction action1 = new WITChangeAction();
action1.Priority = "3";
SourceAdapter.UpdateWorkItem(workitemId, action1);
// sync
RunAndNoValidate();
// verify we have InvalidField conflict
m_conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count >= 1, "There is no active conflict");
Assert.IsTrue(ConflictConstant.InvalidFieldConflictType.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName),
"The first active conflict is not a WIT invalid field conflict");
Dictionary <string, string> dataFields = new Dictionary <string, string>();
dataFields.Add("MapFrom", InvalidFieldRefName);
dataFields.Add("MapTo", FIELD_DESCRIPTION);
dataFields.Add(Constants.DATAKEY_UPDATED_CONFIGURATION_ID, "1");
m_conflictResolver.TryResolveConflict(conflicts[0],
ConflictConstant.InvalidFieldConflictUseFieldMapAction,
conflicts[0].ScopeHint, dataFields);
// restart the migration tool
RunAndNoValidate(true);
conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count == 0, "There should be no conflict");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches due to test environments
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
}
public void Link_BasicTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
WITLinkChangeAction action1 = new WITLinkChangeAction(LinkChangeActionType.Add);
action1.AddLink(new WITLink("link1"));
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// validate the conversion history entries
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
string sourceItemId = workitemId.ToString();
var migrationItemQuery =
from mi in context.RTMigrationItemSet
where mi.ItemId.Equals(sourceItemId) && mi.ItemVersion.Equals("Link")
select mi;
Assert.AreEqual(migrationItemQuery.Count(), 1);
long miId = migrationItemQuery.First().Id;
var itemPairQuery =
from p in context.RTItemRevisionPairSet
where p.LeftMigrationItemId == miId || p.RightMigrationItemId == miId
select p;
Assert.AreEqual(itemPairQuery.Count(), 1);
}
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
}
public void Link_MultipleTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
WITLinkChangeAction action1 = new WITLinkChangeAction(LinkChangeActionType.Add);
action1.AddLink(new WITLink("link1"));
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
RunAndNoValidate();
WITLinkChangeAction action2 = new WITLinkChangeAction(LinkChangeActionType.Add);
action2.AddLink(new WITLink("link2"));
SourceAdapter.UpdateWorkItemLink(workitemId, action2);
RunAndNoValidate(true);
WITLinkChangeAction action3 = new WITLinkChangeAction(LinkChangeActionType.Add);
action3.AddLink(new WITLink("link3"));
SourceAdapter.UpdateWorkItemLink(workitemId, action3);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
int mirroredId = QueryMirroredWorkItemID(workitemId);
Assert.AreEqual(TfsTargetAdapter.GetHyperLinkCount(mirroredId), 3);
}
public void InvalidFieldValueConflict_ResolveByDroppingFieldTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetInvalidFieldValueMap);
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableBypassRulesOnTarget);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
WITChangeAction action1 = new WITChangeAction();
action1.Priority = "1";
SourceAdapter.UpdateWorkItem(workitemId, action1);
// sync
RunAndNoValidate();
// verify we have InvalidField conflict
m_conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count >= 1, "There is no active conflict");
Assert.IsTrue(ConflictConstant.InvalidFieldValueConflictType.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName),
"The first active conflict is not a WIT invalid field value conflict");
Dictionary <string, string> dataFields = new Dictionary <string, string>();
dataFields.Add("InvalidFieldReferenceName", FIELD_PRIORITY);
dataFields.Add(Constants.DATAKEY_UPDATED_CONFIGURATION_ID, "1");
var rslvRslt = m_conflictResolver.TryResolveConflict(
conflicts[0], new Guid("3C8FE19D-3D02-4a19-BC5A-77640B0F5904"), "/", dataFields);
Assert.IsTrue(rslvRslt, "Conflict resolution failed");
// sync again
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches due to test environments
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH, "Priority" /*FIELD_PRIORITY teyang: verification uses field name rather than ref name*/
});
}
private void DeleteHyperLinkScenario()
{
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
// add a link
WITLinkChangeAction action1 = new WITLinkChangeAction(LinkChangeActionType.Add);
WITLink link1 = new WITLink("link1");
action1.AddLink(link1);
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// delete the link
action1 = new WITLinkChangeAction(LinkChangeActionType.Delete);
action1.AddLink(link1);
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
RunAndNoValidate(true);
// verify there's no conflicts raised
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
// TODO: Remove the following verification once ServerDiff supports link diffing.
int mirroredId = QueryMirroredWorkItemID(workitemId);
Assert.AreEqual(TfsSourceAdapter.GetHyperLinkCount(workitemId),
TfsTargetAdapter.GetHyperLinkCount(mirroredId));
}
public void LockedLink_RemoveLockAndDeleteLinkSyncTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
string title1 = string.Format("Parent {0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId1 = SourceAdapter.AddWorkItem("Bug", title1, "description1");
string title2 = string.Format("Child {0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
int workitemId2 = SourceAdapter.AddWorkItem("Bug", title2, "description2");
RunAndNoValidate();
TfsSourceAdapter.AddParentChildLink(workitemId1, workitemId2, true);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
TfsSourceAdapter.UpdateLinkLockOption(workitemId1, workitemId2, false);
TfsSourceAdapter.DeleteParentChildLink(workitemId1, workitemId2);
RunAndNoValidate(true);
// verify there's a conflict raised
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be 1 conflict");
conflictResolver.TryResolveConflict(conflicts[0],
ConflictConstant.TFSModifyLockedWorkItemLinkConflict_ResolveByForceDeleteAction,
conflicts[0].ScopeHint);
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
}
public void Link_UpdateTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title1", "description1");
string location = "link1";
WITLinkChangeAction action1 = new WITLinkChangeAction(LinkChangeActionType.Add);
action1.AddLink(new WITLink(location, "comment1"));
SourceAdapter.UpdateWorkItemLink(workitemId, action1);
// update link comment
string newComment = "new comment 2";
WITLinkChangeAction action2 = new WITLinkChangeAction(LinkChangeActionType.Edit);
action2.AddLink(new WITLink(location, newComment));
SourceAdapter.UpdateWorkItemLink(workitemId, action2);
RunAndNoValidate();
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
// Title <-> Description
int mirroredId = QueryTargetWorkItemID(workitemId);
Assert.AreEqual(TfsTargetAdapter.GetHyperLinkCount(mirroredId), 1);
WITLink tarLink = TargetAdapter.GetHyperLink(mirroredId, location);
Assert.AreEqual(tarLink.Comment, newComment);
}
public void InvalidFieldConflictUseFieldMapCaseInsensitiveTest()
{
// Same as InvalidFieldConflictUseFieldMappTest except testing
// case-sensitivity of the resolution rule
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(SetInvalidFieldMap);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title", "description1");
// sync
RunAndNoValidate();
// verify we have InvalidField conflict
m_conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count >= 1, "There is no active conflict");
Assert.IsTrue(ConflictConstant.InvalidFieldConflictType.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName),
"The first active conflict is not a WIT invalid field conflict");
Dictionary <string, string> dataFields = new Dictionary <string, string>();
dataFields.Add("MapFrom", InvalidFieldRefName.ToUpper()); // use upper case
dataFields.Add("MapTo", FIELD_DESCRIPTION.ToLower()); // use lower case
dataFields.Add(Constants.DATAKEY_UPDATED_CONFIGURATION_ID, "1");
m_conflictResolver.TryResolveConflict(conflicts[0],
ConflictConstant.InvalidFieldConflictUseFieldMapAction,
conflicts[0].ScopeHint, dataFields);
// restart the migration tool
RunAndNoValidate(true);
conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count == 0, "There should be no conflict");
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches due to test environments
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
}
public void EditEditConflictTakeSourceTest()
{
int workitemId, mirroredId;
EditEditConflictScenario(out workitemId, out mirroredId);
string srcTitle = SourceAdapter.GetFieldValue(workitemId, FIELD_TITLE);
string srcDesc = SourceAdapter.GetFieldValue(workitemId, FIELD_DESCRIPTION);
string tarTitle = TargetAdapter.GetFieldValue(mirroredId, FIELD_TITLE);
string tarDesc = TargetAdapter.GetFieldValue(mirroredId, FIELD_DESCRIPTION);
Assert.AreNotEqual(srcTitle, tarTitle, "Title should not match due to conflict");
Assert.AreNotEqual(srcDesc, tarDesc, "Description should not match due to conflict");
// verify we have edit/edit conflict
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count >= 1, "There should be edit/edit conflict");
WITEditEditConflictType contentConflict = new WITEditEditConflictType();
Assert.IsTrue(contentConflict.ReferenceName.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName),
"It should be WIT edit/edit conflict");
// resolve the conflict by taking source side changes
m_conflictResolver.TryResolveConflict(conflicts[0], new WITEditEditConflictTakeSourceChangesAction(), "/" + workitemId);
// restart the migration tool
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches due to test environments
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
srcDesc = SourceAdapter.GetFieldValue(workitemId, FIELD_DESCRIPTION);
tarDesc = TargetAdapter.GetFieldValue(mirroredId, FIELD_DESCRIPTION);
Assert.AreEqual(srcDesc, SOURCE_R1_DESC);
Assert.AreEqual(tarDesc, SOURCE_R1_DESC);
}
internal void VerifySyncResult(WitDiffResult diffResult, List <string> ignoreFieldNames)
{
Assert.AreEqual(0, diffResult.AttachmentMismatchCount, "# of attachments mismatch");
Assert.AreEqual(0, diffResult.LinkMismatchCount, "# of links mismatch");
foreach (WitDiffPair pair in diffResult.WitDiffPairs)
{
int fieldMismatchCount = 0;
foreach (WitDiffField f in pair.DiffFields)
{
if (Contains(ignoreFieldNames, f.FieldName))
{
Trace.TraceInformation("Ignore field mismatch: {0}", f.FieldName);
fieldMismatchCount++;
}
}
Assert.AreEqual(pair.DiffFields.Count, fieldMismatchCount);
}
Trace.TraceInformation("Content match!");
}
public void LockedLink_SkipDeleteLinkSyncTest()
{
// add a work item on source side
int workitemId1 = SourceAdapter.AddWorkItem("Bug", "parent", "description1");
int workitemId2 = SourceAdapter.AddWorkItem("Bug", "child", "description2");
RunAndNoValidate();
TfsSourceAdapter.AddParentChildLink(workitemId1, workitemId2, true);
RunAndNoValidate(true);
// verify there's no conflicts raised
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
TfsSourceAdapter.UpdateLinkLockOption(workitemId1, workitemId2, false);
TfsSourceAdapter.DeleteParentChildLink(workitemId1, workitemId2);
RunAndNoValidate(true);
// verify there's a conflict raised
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be 1 conflict");
conflictResolver.TryResolveConflict(conflicts[0],
new SkipConflictedActionResolutionAction().ReferenceName,
conflicts[0].ScopeHint);
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
//// ignore Area/Iteration path mismatches
//VerifySyncResult(result, new List<string> { FIELD_ITERATION_PATH, FIELD_AREA_PATH });
// TODO: Why does TwoWayRight have only one link mismatch, but the others have 2?
Assert.AreEqual(2, result.LinkMismatchCount);
}
