public void MergeExtraTargetItemTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings mergeFile = new MigrationItemStrings(TestUtils.URIPathCombine(branch.Name, "mergeFile.txt"), null, TestEnvironment, true);
MigrationItemStrings targetFile = new MigrationItemStrings(TestUtils.URIPathCombine(branch.NewName, "targetFile.txt"), null, TestEnvironment, true);
SourceAdapter.AddFile(mergeFile.LocalPath);
int branchChangeset = SourceAdapter.BranchItem(branch);
SourceAdapter.EditFile(mergeFile.LocalPath);
SourceAdapter.AddFile(targetFile.LocalPath);
SourceAdapter.MergeItem(branch, branchChangeset);
RunAndValidate();
}
public void ReverseMergeTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings file = new MigrationItemStrings("source/file.txt", "target/file.txt", TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
int branchChangeset = SourceAdapter.BranchItem(branch);
SourceAdapter.EditFile(file.NewLocalPath);
SourceWorkspace.Merge(branch.NewServerPath, branch.ServerPath,
VersionSpec.ParseSingleSpec(branchChangeset.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), MergeComment);
RunAndValidate();
}
public void UndeleteParentButNotChildTest()
{
MigrationItemStrings file = new MigrationItemStrings("folder/file.txt", "folder/file.txt", TestEnvironment, true);
MigrationItemStrings folder = new MigrationItemStrings("folder", "folder", TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
int deleteChangesetId = SourceAdapter.DeleteItem(folder.ServerPath);
Item item = SourceTfsClient.GetChangeset(deleteChangesetId).Changes[0].Item;
SourceWorkspace.Get();
SourceWorkspace.PendUndelete(folder.ServerPath, item.DeletionId);
SourceWorkspace.Undo(file.ServerPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "Migration Test undelete");
RunAndValidate();
}
public void Link_TwoParentsInHistoryTest()
{
// Legend: x->y (y is a parent of x)
// T1: Source: b->c
// T2: Sync
// T3: Target: b->c
// T4: Source: delete b->c, add b->a
// T5: Sync
// add a work item on source side
int sourceIdA = SourceAdapter.AddWorkItem("Bug", "A", "A");
int sourceIdB = SourceAdapter.AddWorkItem("Bug", "B", "B");
int sourceIdC = SourceAdapter.AddWorkItem("Bug", "C", "C");
RunAndNoValidate();
// T1
TfsSourceAdapter.AddParentChildLink(sourceIdC, sourceIdB);
RunAndNoValidate(true);
// T4:
// Source: delete c->b, add a->c ==> b->a->c (a is the child of c)
TfsSourceAdapter.DeleteParentChildLink(sourceIdC, sourceIdB);
TfsSourceAdapter.AddParentChildLink(sourceIdA, sourceIdB);
RunAndNoValidate(true);
// verify the expected conflict
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflict");
Assert.AreEqual(1, TfsSourceAdapter.GetRelatedLinkCount(sourceIdA));
Assert.AreEqual(1, TfsSourceAdapter.GetRelatedLinkCount(sourceIdB));
Assert.AreEqual(0, TfsSourceAdapter.GetRelatedLinkCount(sourceIdC));
// Target: delete b->a, add a->b ==> a->b, c->b (a is the child of b)
int targetId1 = QueryTargetWorkItemID(sourceIdA);
int targetId2 = QueryTargetWorkItemID(sourceIdB);
int targetIdC = QueryTargetWorkItemID(sourceIdC);
Assert.AreEqual(1, TfsTargetAdapter.GetRelatedLinkCount(targetId1));
Assert.AreEqual(1, TfsTargetAdapter.GetRelatedLinkCount(targetId2));
Assert.AreEqual(0, TfsTargetAdapter.GetRelatedLinkCount(targetIdC));
}
public void Link_BasicTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
int workitemId = SourceAdapter.AddWorkItem("Bug", "title1", "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 AddAddConflictTakeLocalTest()
{
// initial migration
MigrationItemStrings file1 = new MigrationItemStrings("1.txt", "1.txt", TestEnvironment, true);
SourceAdapter.AddFile(file1.LocalPath);
RunAndValidate();
// add a same file on both ends
string fileName = "a.txt";
MigrationItemStrings sourceFile = new MigrationItemStrings(fileName, fileName, TestEnvironment, true);
MigrationItemStrings targetFile = new MigrationItemStrings(fileName, fileName, TestEnvironment, false);
int sourceAdd = SourceAdapter.AddFile(sourceFile.LocalPath);
TargetAdapter.AddFile(targetFile.LocalPath);
Run();
VerifyHistory(2, 1);
// resolve conflicts
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be 1 conflict");
VCContentConflictType contentConflict = new VCContentConflictType();
Assert.AreEqual(contentConflict.ReferenceName, conflicts[0].ConflictTypeReference.Value.ReferenceName, "It should be vc content conflict");
// resolve the vc content conflict. The chained conflict will be resolved automatically
conflictResolver.TryResolveConflict(conflicts[0], new VCContentConflictTakeLocalChangeAction(), "$/");
// continue migration
Run();
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be 0 conflict");
Assert.IsFalse(VerifyContents(), "Content should be different as we skip the add from source system.");
SourceAdapter.EditFile(sourceFile.LocalPath);
Run();
Assert.IsTrue(VerifyContents());
}
public void BasicCloakTest()
{
MigrationItemStrings cloakedFile = new MigrationItemStrings("cloak/file.txt", "cloak/file.txt", TestEnvironment, true);
SourceAdapter.AddFile(cloakedFile.LocalPath);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "cloak",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "cloak",
true); // cloaked
TestEnvironment.AddMapping(mapping);
SourceAdapter.EditFile(m_extraFile.LocalPath);
SourceAdapter.EditFile(cloakedFile.LocalPath);
RunAndValidate();
}
public void MergeCyclicRenameTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings folder1 = new MigrationItemStrings("source/folder1/", null, TestEnvironment, true);
MigrationItemStrings folder2 = new MigrationItemStrings("source/folder2/", null, TestEnvironment, true);
MigrationItemStrings temp = new MigrationItemStrings("source/temp/", null, TestEnvironment, true);
MigrationItemStrings file1 = new MigrationItemStrings("source/folder1/file1.txt", null, TestEnvironment, true);
MigrationItemStrings file2 = new MigrationItemStrings("source/folder2/file2.txt", null, TestEnvironment, true);
SourceAdapter.AddFolder(folder1.LocalPath);
SourceAdapter.AddFolder(folder2.LocalPath);
SourceAdapter.AddFile(file1.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
int branchChangeset = SourceAdapter.BranchItem(branch);
SourceAdapter.EditFile(m_extraFile.LocalPath);
SourceWorkspace.PendRename(folder1.ServerPath, temp.ServerPath);
SourceWorkspace.PendRename(folder2.ServerPath, folder1.ServerPath);
SourceWorkspace.PendRename(temp.ServerPath, folder2.ServerPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), RenameComment);
SourceWorkspace.Merge(branch.ServerPath, branch.NewServerPath,
VersionSpec.ParseSingleSpec(branchChangeset.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.AlwaysAcceptMine);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), MergeComment);
Run();
if (TestEnvironment.SourceEndPoint.AdapterType == AdapterType.TFS2008VC)
{
VerifyHistory(0, 0);
// For orcas, there should be no difference.
}
else
{
VerifyHistory(1, 1);
// Need more comparison here.
// On dev 10 server, rename becomes sourceDelete+targetbranch. So the rename-from-name will exist in the original place as a deleted item.
// The merge will then merge the item as a Merge|Delete. We will skip the change in this case.
}
}
public void HistoryNotFound_ResolveByUpdateConvHistory()
{
this.TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_EnableBypassRulesOnTarget);
this.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");
WITChangeAction action = new WITChangeAction();
action.Priority = "3";
SourceAdapter.UpdateWorkItem(workitemId, action);
action = new WITChangeAction();
action.Priority = "2";
SourceAdapter.UpdateWorkItem(workitemId, action);
// sync again and expect conflict
RunAndNoValidate();
// check conflicts
m_conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count >= 1, "There is no active conflict");
Assert.IsTrue(ConflictConstant.WitHistoryNotFoundConflictType.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName),
"The first active conflict is not a history-not-found conflict");
Dictionary <string, string> dataFields = new Dictionary <string, string>();
dataFields.Add("Source Item Id", workitemId.ToString());
dataFields.Add("Source Revisions", "1");
dataFields.Add("Target Item Id", "17526" /*"@@PLACE_HOLDER@@"*/);
dataFields.Add("Target Revisions", "1");
m_conflictResolver.TryResolveConflict(conflicts[0],
ConflictConstant.HistoryNotFoundUpdateConversionHistoryAction,
conflicts[0].ScopeHint, dataFields);
RunAndNoValidate(true);
m_conflictResolver = new ConflictResolver(Configuration);
conflicts = m_conflictResolver.GetConflicts();
Assert.IsTrue(conflicts.Count == 0, "There is unresolved conflict");
}
public void TwoWay_AddAddConflictTakeOtherTest()
{
// continuous manual, bi-directional sync
TestEnvironment.WorkFlowType = new WorkFlowType();
TestEnvironment.WorkFlowType.DirectionOfFlow = DirectionOfFlow.Bidirectional;
TestEnvironment.WorkFlowType.Frequency = Frequency.ContinuousManual;
TestEnvironment.WorkFlowType.SyncContext = SyncContext.Disabled;
// 1. migrate a.txt -> a.txt
string fileName1 = "a.txt";
string fileName2 = "b.txt";
string sameFileName = "same.txt";
MigrationItemStrings sourceFile1 = new MigrationItemStrings(fileName1, null, TestEnvironment, true);
MigrationItemStrings sourceSameFile = new MigrationItemStrings(sameFileName, null, TestEnvironment, true);
MigrationItemStrings targetFile1 = new MigrationItemStrings(fileName2, null, TestEnvironment, false);
MigrationItemStrings targetSameFile = new MigrationItemStrings(sameFileName, null, TestEnvironment, false);
SourceAdapter.AddFiles(new string[] { sourceFile1.LocalPath, sourceSameFile.LocalPath });
TargetAdapter.AddFiles(new string[] { targetFile1.LocalPath, targetSameFile.LocalPath });
// 4. Migration will detect a conflict
Run();
// 5. resolve conflicts
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be 1 conflict");
VCContentConflictType contentConflict = new VCContentConflictType();
Assert.IsTrue(contentConflict.ReferenceName.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName), "It should be vc content conflict");
conflictResolver.TryResolveConflict(conflicts[0], new VCContentConflictTakeOtherChangesAction(), conflicts[0].ScopeHint);
// sync
Run(true, true);
// validation
// no remaining conflicts
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be NO conflict");
// content should match
Assert.IsTrue(VerifyContents(), "The latest content should match.");
}
public void Link_DeleteRelatedLinkFromOtherSideTest()
{
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");
// target: delete the mirrored link
TfsTargetAdapter.DeleteRelatedWorkItemLink(mirroredId1, mirroredId2);
RunAndNoValidate(true);
// now source side shouldn't have any link
Assert.AreEqual(0, TfsSourceAdapter.GetRelatedLinkCount(workitemId1), "RelatedLink count on source 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 Link_UpdateTest()
{
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");
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 = QueryMirroredWorkItemID(workitemId);
Assert.AreEqual(TfsTargetAdapter.GetHyperLinkCount(mirroredId), 1);
WITLink tarLink = TargetAdapter.GetHyperLink(mirroredId, location);
Assert.AreEqual(tarLink.Comment, newComment);
}
public void LockedLink_SyncUnlockedFirstThenUpdateLocked()
{
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, false);
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, true);
RunAndNoValidate(true);
// verify there's no conflict raised
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
RunAndNoValidate(true);
// verify sync result
WitDiffResult result = GetDiffResult();
// ignore Area/Iteration path mismatches
VerifySyncResult(result, new List <string> {
FIELD_ITERATION_PATH, FIELD_AREA_PATH
});
int mirroredId1 = QueryMirroredWorkItemID(workitemId1);
int mirroredId2 = QueryMirroredWorkItemID(workitemId2);
Assert.IsTrue(TfsTargetAdapter.IsLinkLocked(mirroredId1, mirroredId2), "migrated link is not locked");
}
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
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.AreEqual(1, conflicts.Count, "There should be one active conflict");
Assert.AreEqual(ConflictConstant.InvalidFieldValueConflictType, 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*/
});
}
public void Link_DeleteRelatedLinkFromBothSideTest()
{
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(ConfigCustomizer.CustomActions_DisableContextSync);
// add a work item on source side
int workitemId1 = SourceAdapter.AddWorkItem("Bug", "title1", "description1");
int workitemId2 = SourceAdapter.AddWorkItem("Bug", "title2", "description2");
RunAndNoValidate();
int mirroredId1 = QueryTargetWorkItemID(workitemId1);
int mirroredId2 = QueryTargetWorkItemID(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(mirroredId1), "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 MergeCrudOutOfScopeTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings addedFile = new MigrationItemStrings("source/Addedfile.txt", null, TestEnvironment, true);
MigrationItemStrings editFile = new MigrationItemStrings("source/Editedfile.txt", null, TestEnvironment, true);
MigrationItemStrings deleteFile = new MigrationItemStrings("source/DeletedFile.txt", null, TestEnvironment, true);
MigrationItemStrings undeleteFile = new MigrationItemStrings("source/UndeletedFile.txt", null, TestEnvironment, true);
MigrationItemStrings branchedFile = new MigrationItemStrings("source/folder/branchedFile.txt", "source/folder2/branchFile.txt", TestEnvironment, true);
MigrationItemStrings mergeFile = new MigrationItemStrings("source/folder/mergeFile.txt", "source/folder2/mergeFile.txt", TestEnvironment, true);
#region Setup before the branch
//All the files except for the Added file should exist before the branch
SourceAdapter.AddFile(editFile.LocalPath);
SourceAdapter.AddFile(deleteFile.LocalPath);
SourceAdapter.AddFile(undeleteFile.LocalPath);
SourceAdapter.AddFile(branchedFile.LocalPath);
SourceAdapter.AddFile(mergeFile.LocalPath);
int deletetionChangeset = SourceAdapter.DeleteItem(undeleteFile.ServerPath);
int mergeFileChangeset = SourceAdapter.BranchItem(mergeFile.ServerPath, mergeFile.NewServerPath);
SourceAdapter.EditFile(mergeFile.LocalPath);
#endregion
int branchChangeset = SourceAdapter.BranchItem(branch.ServerPath, branch.NewServerPath);
#region Setup after Branch operation
SourceAdapter.AddFile(addedFile.LocalPath);
SourceAdapter.EditFile(editFile.LocalPath);
SourceAdapter.DeleteItem(deleteFile.ServerPath);
SourceAdapter.UndeleteFile(undeleteFile.ServerPath, deletetionChangeset);
SourceAdapter.BranchItem(branchedFile.ServerPath, branchedFile.NewServerPath);
SourceAdapter.MergeItem(mergeFile, mergeFileChangeset);
#endregion Setup after Branch operation
//The big merge
SourceAdapter.MergeItem(branch, branchChangeset);
// Add the mapping scope
MappingPair rootMapping = TestEnvironment.Mappings[0];
TestEnvironment.Mappings.Clear();
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath, rootMapping.TargetPath, false, null, null,
rootMapping.SourcePath + '/' + "target/", rootMapping.TargetPath + '/' + "target/"));
RunAndValidate(true, true);
}
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
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
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 EditEditConflictTakeLocalTest()
{
// 1. migrate a.txt -> a.txt
string fileName = "a.txt";
MigrationItemStrings sourceFile = new MigrationItemStrings(fileName, null, TestEnvironment, true);
MigrationItemStrings targetFile = new MigrationItemStrings(fileName, null, TestEnvironment, false);
SourceAdapter.AddFile(sourceFile.LocalPath);
RunAndValidate();
// 2. source system: a.txt -> edit
SourceAdapter.EditFile(sourceFile.LocalPath);
// 3. target system: a.txt -> edit
TargetAdapter.EditFile(targetFile.LocalPath);
// 4. Migration will detect a conflict
Run();
VerifyHistory(2, 1);
// 5. resolve conflicts
ConflictResolver conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be 1 conflict");
VCContentConflictType contentConflict = new VCContentConflictType();
Assert.IsTrue(contentConflict.ReferenceName.Equals(conflicts[0].ConflictTypeReference.Value.ReferenceName), "It should be vc content conflict");
conflictResolver.TryResolveConflict(conflicts[0], new VCContentConflictTakeLocalChangeAction(), "$/");
// 6. restart
Run(true, true);
// 7. validation
// no remaining conflicts
conflicts = conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be NO conflict");
// content should match
Assert.IsFalse(VerifyContents(), "The latest content should be different as a.txt is not migrated.");
SourceAdapter.EditFile(sourceFile.LocalPath);
Run(true, true);
Assert.IsTrue(VerifyContents());
}
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
});
}
protected void BranchParitalScenario()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings file1 = new MigrationItemStrings("source/file1.txt", null, TestEnvironment, true);
MigrationItemStrings file2 = new MigrationItemStrings("source/file2.txt", null, TestEnvironment, true);
SourceAdapter.AddFolder(branch.LocalPath);
SourceAdapter.AddFile(file1.LocalPath);
int branchFrom = SourceAdapter.AddFile(file2.LocalPath);
SourceAdapter.EditFile(file2.LocalPath);
SourceAdapter.EditFile(file1.LocalPath);
SourceWorkspace.Get(VersionSpec.Latest, GetOptions.Overwrite);
SourceWorkspace.PendBranch(branch.ServerPath, branch.NewServerPath, VersionSpec.ParseSingleSpec(branchFrom.ToString(), Environment.UserName));
RunAndValidate();
}
public void RenameParentAddSubFolderTest()
{
MigrationItemStrings parentFolder = new MigrationItemStrings("parent", "new-parent", TestEnvironment, true);
MigrationItemStrings file = new MigrationItemStrings("filea.txt", null, TestEnvironment, true);
MigrationItemStrings subFolder = new MigrationItemStrings("new-parent/subdir", null, TestEnvironment, true);
SourceAdapter.AddFolder(parentFolder.LocalPath);
SourceAdapter.AddFile(Path.Combine(parentFolder.LocalPath, file.Name));
SourceWorkspace.PendRename(parentFolder.ServerPath, parentFolder.NewServerPath);
Directory.CreateDirectory(subFolder.LocalPath);
SourceWorkspace.PendAdd(subFolder.LocalPath);
SourceWorkspace.PendRename(Path.Combine(parentFolder.NewServerPath, file.Name), Path.Combine(subFolder.ServerPath, file.Name));
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "added a new sub folder. moved an item to the sub folder. rename parent folder");
RunAndValidate();
}
public void RenameParentMoveToBelowItselfTest()
{
MigrationItemStrings file = new MigrationItemStrings("parent/file.txt", null, TestEnvironment, true);
MigrationItemStrings parentFolder = new MigrationItemStrings("parent", null, TestEnvironment, true);
MigrationItemStrings newParentFolder = new MigrationItemStrings("newparent", null, TestEnvironment, true);
MigrationItemStrings subFolder = new MigrationItemStrings("parent/subFolder", null, TestEnvironment, true);
MigrationItemStrings newFileLocation = new MigrationItemStrings("parent/subFolder/file.txt", null, TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
Directory.CreateDirectory(subFolder.LocalPath);
SourceWorkspace.PendRename(file.ServerPath, newFileLocation.ServerPath);
SourceWorkspace.PendRename(parentFolder.ServerPath, newParentFolder.ServerPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "Move a folder below itsself");
RunAndValidate();
}
public void AddWorkItemTest()
{
// 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 migration result
VerifySyncResult();
}
/// Single Edit/Edit conflict
///
/// 1. Source (S) and Target (T) are in sync
///
/// Both ends have changes
/// 2. Source revisions: A1 -> B
/// 3. Target revisions: A2
///
/// 4. Start Bi-directional migration (1st round)
/// 5. Tool generates 1 edit/edit conflict with chained conflicts
/// Raise edit/edit conflicts for S:A1 and T:A2
/// Raise chained conflicts for S:B
///
private void EditEditConflictScenario(out int workitemId, out int mirroredId)
{
// test edit/edit conflit in bi-directional work flow
TestEnvironment.WorkFlowType = new WorkFlowType();
TestEnvironment.WorkFlowType.DirectionOfFlow = DirectionOfFlow.Bidirectional;
TestEnvironment.WorkFlowType.Frequency = Frequency.ContinuousManual;
TestEnvironment.WorkFlowType.SyncContext = SyncContext.Disabled;
TestEnvironment.CustomActions += new MigrationTestEnvironment.Customize(CustomizeTargetFilterString);
// add a work item on source side
string title = string.Format("{0} {1}", TestContext.TestName, DateTime.Now.ToString("HH'_'mm'_'ss"));
workitemId = SourceAdapter.AddWorkItem("Bug", title, "description1");
// sync
RunAndNoValidate();
// verify there's no conflicts raised
m_conflictResolver = new ConflictResolver(Configuration);
List <RTConflict> conflicts = m_conflictResolver.GetConflicts();
Assert.AreEqual(0, conflicts.Count, "There should be no conflicts");
// update work items on both sides
WITChangeAction action1 = new WITChangeAction();
WITChangeAction action2 = new WITChangeAction();
mirroredId = QueryMirroredWorkItemID(workitemId);
action1.Description = SOURCE_R1_DESC; // S:A1
SourceAdapter.UpdateWorkItem(workitemId, action1);
action1.Title = SOURCE_R2_TITLE; // S:B
SourceAdapter.UpdateWorkItem(workitemId, action1);
action2.Description = TARGET_R1_DESC; // T:A2
TargetAdapter.UpdateWorkItem(mirroredId, action2);
//WITChangeAction action3 = new WITChangeAction();
//action3.Title = TestContext.TestName + " title T:D"; // T:D
//TargetAdapter.UpdateWorkItem(mirroredId, action3);
// sync again
// 1 edit/edit conflict with chained conflicts
RunAndNoValidate(true);
}
protected void TwoDeleteUnDeleteScenario(bool useSource)
{
MigrationItemStrings file1 = new MigrationItemStrings("file.txt", null, TestEnvironment, useSource);
MigrationItemStrings file2 = new MigrationItemStrings("file.txt", null, TestEnvironment, useSource);
SourceAdapter.AddFile(file1.LocalPath);
int file1ChangeSetId = SourceAdapter.DeleteItem(file1.ServerPath);
SourceAdapter.AddFile(file2.LocalPath);
int file2ChangeSetId = SourceAdapter.DeleteItem(file2.ServerPath);
SourceAdapter.UndeleteFile(file1.ServerPath, file1ChangeSetId);
SourceAdapter.DeleteItem(file1.ServerPath);
SourceAdapter.UndeleteFile(file2.ServerPath, file2ChangeSetId);
}
protected void DeleteFolderRenameToSourceScenario(bool useSoruce)
{
MigrationItemStrings parent = new MigrationItemStrings("Parent/", "newParent/", TestEnvironment, useSoruce);
MigrationItemStrings file1 = new MigrationItemStrings("child/def.txt", "Parent/child/def.txt", TestEnvironment, useSoruce);
MigrationItemStrings file2 = new MigrationItemStrings("Parent/child/def.txt", null, TestEnvironment, useSoruce);
MigrationItemStrings child = new MigrationItemStrings("child/", "Parent/child/", TestEnvironment, useSoruce);
SourceAdapter.AddFolder(parent.LocalPath);
SourceAdapter.AddFile(file1.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
SourceWorkspace.PendDelete(child.NewServerPath);
SourceWorkspace.PendRename(child.ServerPath, child.NewServerPath);
SourceWorkspace.PendRename(parent.ServerPath, parent.NewServerPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), RenameComment);
}
protected void ChainedRenameEdit(bool useSource)
{
MigrationItemStrings file1 = new MigrationItemStrings("CodeGenProject.vb", null, TestEnvironment, useSource);
MigrationItemStrings file2 = new MigrationItemStrings("CodeGenSolution.vb", null, TestEnvironment, useSource);
MigrationItemStrings file3 = new MigrationItemStrings("CodeGenTable.vb", null, TestEnvironment, useSource);
SourceAdapter.AddFile(file1.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
SourceWorkspace.Get(VersionSpec.Latest, GetOptions.Overwrite);
TestUtils.EditRandomFile(file1.LocalPath);
SourceWorkspace.PendEdit(file1.LocalPath);
TestUtils.EditRandomFile(file2.LocalPath);
SourceWorkspace.PendEdit(file2.LocalPath);
SourceWorkspace.PendRename(file1.LocalPath, file3.LocalPath);
SourceWorkspace.PendRename(file2.LocalPath, file1.LocalPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "ChainedRenameEdit test");
}
public void RenameNamespaceReuseMergeTest()
{
MigrationItemStrings sourceFolder = new MigrationItemStrings("source/folder", "source/folder-rename", TestEnvironment, true);
MigrationItemStrings sourceFile = new MigrationItemStrings("source/folder/file.txt", "source/folder/file.txt", TestEnvironment, true);
MigrationItemStrings branchItem = new MigrationItemStrings("source", "target", TestEnvironment, true);
SourceAdapter.AddFile(sourceFile.LocalPath);
SourceAdapter.BranchItem(branchItem);
int deleteChangeset = SourceAdapter.DeleteItem(sourceFile.ServerPath);
SourceAdapter.AddFile(sourceFile.LocalPath);
SourceAdapter.RenameItem(sourceFolder.ServerPath, sourceFolder.NewServerPath);
SourceAdapter.MergeItem(branchItem, deleteChangeset);
RunAndValidate();
}
public void AddMappingRoot()
{
MigrationItemStrings folderOnSource = new MigrationItemStrings("folder", "folder", TestEnvironment, true);
MigrationItemStrings folderOnTarget = new MigrationItemStrings("folder", "folder", TestEnvironment, false);
SourceAdapter.AddFolder(folderOnSource.LocalPath);
TargetAdapter.AddFolder(folderOnTarget.LocalPath);
//Remap the migration
string source = TestEnvironment.FirstSourceServerPath;
string target = TestEnvironment.FirstTargetServerPath;
TestEnvironment.Mappings.Clear();
TestEnvironment.AddMapping(new MappingPair(
source + SrcPathSeparator + folderOnSource.Name,
target + TarPathSeparator + folderOnTarget.Name, false));
RunAndValidate();
}
public void BranchMergeEditTest()
{
file = new MigrationItemStrings(source.Name + "file.txt", target.Name + "file.txt", TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
SourceWorkspace.Merge(file.ServerPath, file.NewServerPath, VersionSpec.Latest, VersionSpec.Latest);
int mergeChangeset = SourceAdapter.EditFile(file.NewLocalPath);
RunAndValidate();
/* TfsServerDiff diff = RunNoValidate();
* Assert.AreEqual(1, diff.SourceChanges.Count, "The source system should have 1 unmatched change");
* Assert.AreEqual(1, diff.TargetChanges.Count, "The target system should have 1 unmatched change");
* Assert.AreEqual(diff.TargetChanges[0].Changes[1].ChangeType, ChangeType.Encoding | ChangeType.Branch | ChangeType.Edit | ChangeType.Merge, "Wrong change type");
* Assert.AreEqual(mergeChangeset, diff.SourceChanges[0].ChangesetId, "Wrong changeset");
*/
}
