public void StartsWithMappingsTest()
{
MigrationItemStrings fileOutSideMapping = new MigrationItemStrings("source-integration/file.txt", null, TestEnvironment, true);
MigrationItemStrings fileUnderMapping = new MigrationItemStrings("source/file.txt", null, TestEnvironment, true);
TestUtils.CreateRandomFile(fileOutSideMapping.LocalPath, 10);
TestUtils.CreateRandomFile(fileUnderMapping.LocalPath, 10);
string mergeComment = "Migration test merge";
SourceWorkspace.PendAdd(fileOutSideMapping.LocalPath);
SourceWorkspace.PendAdd(fileUnderMapping.LocalPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), mergeComment);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "source",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "source",
false);
MappingPair mapping2 = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "source-integration",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "source-integration",
false);
TestEnvironment.Mappings.Clear();
TestEnvironment.AddMapping(mapping);
TestEnvironment.AddMapping(mapping2);
RunAndValidate();
}
private bool Refresh()
{
//motherkeys = this.Mother.Generate(Mother.CurrentETLTools.Take(Mother.CurrentETLTools.IndexOf(this.ETLModule)), false).Take(3).GetKeys().ToList();
// subkeys =
// SubTask.Generate(
// SubTask.CurrentETLTools.Take(RangeStart),false)
// .Take(3).GetKeys().ToList();
var dict =
MappingPairs.Where(
d =>
string.IsNullOrEmpty(d.Target.SelectItem) == false &&
string.IsNullOrEmpty(d.Source.SelectItem) == false).Distinct().GroupBy(d => d.Target.SelectItem).Select(group => group.First())
.ToDictionary(d => d.Target.SelectItem, d => d.Source.SelectItem);
ControlExtended.UIInvoke(() =>
{
MappingPairs.Clear();
foreach (var key in subkeys)
{
var pair = new MappingPair(motherkeys, subkeys);
pair.Target.SelectItem = key;
string value = key;
dict.TryGetValue(key, out value);
pair.Source.SelectItem = value;
MappingPairs.Add(pair);
}
});
return(true);
//var index = Mother.CurrentETLTools.IndexOf(ETLModule);
//if (index == -1)
// return;
//Mother.Generate(Mother.CurrentETLTools.Take(index), false);
}
public void Map(MappingPair mappingPair)
{
var src = mappingPair.Src as IMappingEnumerableObject;
var dest = mappingPair.Dest as IMappingEnumerableObject;
while (src.Next())
{
dest.New();
var currentDestMappingObjectType = MapperConfiguration.MappingObjects.Get(dest.Current);
var currentDest = MapperConfiguration.ObjectFactory.CreateInstance(currentDestMappingObjectType) as IMappingSingleObject;
currentDest.UnderlyingObject = dest.Current;
var currentSrcMappingObjectType = MapperConfiguration.MappingObjects.Get(src.Current);
var currentSrc = MapperConfiguration.ObjectFactory.CreateInstance(currentSrcMappingObjectType) as IMappingSingleObject;
currentSrc.UnderlyingObject = src.Current;
var pair = new MappingPair(currentSrc, currentDest);
var strategyType = MapperConfiguration.MappingStrategies.Get(pair);
var strategy = MapperConfiguration.ObjectFactory.CreateInstance(strategyType) as IMappingStrategy;
strategy.MapperConfiguration = MapperConfiguration;
strategy.PropsMatcher = PropsMatcher;
strategy.PropValueConverter = PropValueConverter;
strategy.Map(pair);
}
}
public static bool CanMap(MappingPair mappingPair)
{
var dataTable = mappingPair.Src.UnderlyingObject as DataTable;
if (dataTable != null)
{
if (dataTable.Namespace.Contains("http://schemas.microsoft.com/office/project/server"))
{
return(true);
}
return(false);
}
var dataRow = mappingPair.Src.UnderlyingObject as DataRow;
if (dataRow != null)
{
if (dataRow.Table.Namespace.Contains("http://schemas.microsoft.com/office/project/server"))
{
return(true);
}
return(false);
}
return(false);
}
public void RenameWithSourceNotMappedTest()
{
MigrationItemStrings folder = new MigrationItemStrings("rename-from", "rename-to", TestEnvironment, true);
MigrationItemStrings file = new MigrationItemStrings("rename-from/fld/file.txt", "rename-to/fld/file.txt", TestEnvironment, true);
// Add the child item
SourceAdapter.AddFile(file.LocalPath);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "rename-from",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "rename-from",
true); // cloaked
TestEnvironment.AddMapping(mapping);
SourceWorkspace.Get(VersionSpec.Latest, GetOptions.Overwrite);
SourceWorkspace.PendRename(folder.ServerPath, folder.NewServerPath);
SourceAdapter.EditFile(file.NewLocalPath);
Run();
VerifyHistory(3, 0);
// Resolve "Branch source path not found conflict" using "$/" scope.
ConflictResolver conflictManager = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictManager.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be only 1 conflict");
conflictManager.TryResolveConflict(conflicts[0], new VCChangeToAddOnBranchSourceNotMappedAction(), "$/"); // Add on branch source not found
RunAndValidate(true, true);
}
public static bool CanMap(MappingPair mappingPair)
{
if (!mappingPair.Dest.CanContainWhitespacesInProperties)
{
return(true);
}
return(false);
}
public void PathSnapshotTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings[] addFiles = new MigrationItemStrings[20];
// Add files
// Create a tree structure so that we can test path compression logic.
int sessionSnapshotChangesetId = 0;
for (int i = 0; i < 20; i++)
{
addFiles[i] = new MigrationItemStrings(string.Format("source/path1/addFile{0}.txt", i), null, TestEnvironment, true);
if (i == 15)
{
sessionSnapshotChangesetId = SourceAdapter.AddFile(addFiles[i].LocalPath);
}
else
{
SourceAdapter.AddFile(addFiles[i].LocalPath);
}
}
int path2SnapshotChangesetId = 0;
for (int i = 0; i < 20; i++)
{
addFiles[i] = new MigrationItemStrings(string.Format("source/path2/addFile{0}.txt", i), null, TestEnvironment, true);
if (i == 15)
{
path2SnapshotChangesetId = SourceAdapter.AddFile(addFiles[i].LocalPath);
}
else
{
SourceAdapter.AddFile(addFiles[i].LocalPath);
}
}
TestEnvironment.SnapshotStartPoints = new Dictionary <string, string>();
TestEnvironment.SnapshotStartPoints.Add(TestEnvironment.SourceTeamProject, sessionSnapshotChangesetId.ToString());
TestEnvironment.SnapshotBatchSize = 3;
// We need to map to the sub item level
MappingPair rootMapping = TestEnvironment.Mappings[0];
TestEnvironment.Mappings.Clear();
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/source/path1", rootMapping.TargetPath + "/source/path1", false));
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/source/path2", rootMapping.TargetPath + "/source/path2", false, path2SnapshotChangesetId.ToString(), null));
Run();
// ToDo, ideally, we should compare content at snapshot changeset and compare history after snapshot changeset.
Assert.IsTrue(VerifyContents());
}
public void BasicCloakTest()
{
MigrationItemStrings cloakedFile = new MigrationItemStrings("cloak" + SourceAdapter.PathSeparator + "file.txt", null, 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 MigrateCloakedFolderItselfTest()
{
MigrationItemStrings cloakedFile = new MigrationItemStrings("cloak", "cloak", TestEnvironment, true);
SourceAdapter.AddFolder(cloakedFile.LocalPath);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "cloak",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "cloak",
true); // cloaked
TestEnvironment.AddMapping(mapping);
SourceAdapter.EditFile(m_extraFile.LocalPath);
Run();
VerifyHistory(0, 0);
}
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 SubTaskModel(SmartETLTool mother, SmartETLTool subTask, ETLBase etlmodule, string[] mother_keys = null, string[] sub_keys = null)
{
MappingPairs =
new ObservableCollection <MappingPair>();
Mother = mother;
SubTask = subTask;
var start = 0;
var end = 0;
ETLBase.GetRange(etlmodule.ETLRange, subTask.AllETLMount, out start, out end);
if (mother_keys != null)
{
motherkeys.AddRange(mother_keys);
}
if (sub_keys != null)
{
subkeys.AddRange(sub_keys);
}
RangeStart = start;
RangeEnd = end;
ETLModule = etlmodule;
if (!string.IsNullOrEmpty(etlmodule.MappingSet))
{
foreach (var item in etlmodule.MappingSet.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
{
var kv = item.Split(':');
string key = "";
string value = "";
if (kv.Length == 1)
{
key = value = kv[1];
}
if (kv.Length > 1)
{
key = kv[0];
value = kv[1];
}
var pair = new MappingPair(motherkeys, subkeys);
pair.Source._SelectItem = key;
pair.Target._SelectItem = value;
MappingPairs.Add(pair);
}
}
// Refresh();
}
public static bool CanMap(MappingPair mappingPair)
{
var src = mappingPair.Src as IMappingEnumerableObject;
if (src == null)
{
return(false);
}
var dest = mappingPair.Dest as IMappingEnumerableObject;
if (dest == null)
{
return(false);
}
return(true);
}
public static bool CanMap(MappingPair mappingObjects)
{
var src = mappingObjects.Src as IMappingSingleObject;
if (src == null)
{
return(false);
}
var dest = mappingObjects.Dest as IMappingSingleObject;
if (dest == null)
{
return(false);
}
return(true);
}
public void Map(MappingPair mappingPair)
{
var src = mappingPair.Src as IMappingSingleObject;
var dest = mappingPair.Dest as IMappingSingleObject;
var props = PropsMatcher.GetPropertiesMap(src.Properties, dest.Properties);
foreach (var prop in props)
{
var propInfo = src.Properties.FirstOrDefault(p => p.Name == prop.Key);
if (propInfo == null)
{
continue;
}
var srcVal = PropValueConverter.GetConvertedValue(propInfo, null, src[prop.Key]);
dest[prop.Value] = srcVal;
}
}
/// <summary>
///
/// </summary>
/// <param name="pairsToSearch"></param>
/// <param name="extensions"></param>
/// <returns>A dictionary that maps hashes to mapping pairs</returns>
public static Dictionary <string, MappingPair> FilterExtensions(MappingPair[] pairsToSearch, string[] extensions)
{
var result = new Dictionary <string, MappingPair>();
for (int i = 0; i < pairsToSearch.Length; i++)
{
MappingPair mappingPair = pairsToSearch[i];
bool hasExtension = extensions.Any((x) => mappingPair.file.ToLower().EndsWith(x));
if (hasExtension)
{
if (!result.ContainsKey(mappingPair.hash))
{
result.Add(mappingPair.hash, mappingPair);
}
}
}
return(result);
}
/// <summary>
/// Given a MappingPair list, returns a AssetPath list filtered by file extensions
/// </summary>
/// <param name="pairsToSearch">The MappingPair list to be filtered and converted</param>
/// <param name="extensions">An array detailing the extensions to filter them</param>
/// <returns>A dictionary that maps hashes to mapping pairs</returns>
public static List <AssetPath> GetPathsFromPairs(string basePath, MappingPair[] pairsToSearch, string[] extensions)
{
var tmpResult = new Dictionary <(string, string), AssetPath>();
for (int i = 0; i < pairsToSearch.Length; i++)
{
MappingPair mappingPair = pairsToSearch[i];
bool hasExtension = extensions.Any((x) => mappingPair.file.ToLower().EndsWith(x));
if (hasExtension)
{
if (!tmpResult.ContainsKey((mappingPair.hash, mappingPair.file)))
{
tmpResult.Add((mappingPair.hash, mappingPair.file), new AssetPath(basePath, mappingPair));
}
}
}
return(tmpResult.Values.ToList());
}
public void BranchMergeDeleteWithSourceNotMappedTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source", "target", TestEnvironment, true);
MigrationItemStrings file = new MigrationItemStrings("source/fld/file.txt", "target/fld/file.txt", TestEnvironment, true);
// Add the parent folder at branch from place
SourceAdapter.AddFolder(branch.LocalPath);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "source",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "source",
true); // cloaked
TestEnvironment.AddMapping(mapping);
// Branch the parent folder
int branchChangeset = SourceAdapter.BranchItem(branch.ServerPath, branch.NewServerPath);
// Add the child item
SourceAdapter.AddFile(file.LocalPath);
SourceWorkspace.Merge(branch.ServerPath, branch.NewServerPath,
VersionSpec.ParseSingleSpec(branchChangeset.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
ResolveConflicts(Resolution.AcceptTheirs);
SourceAdapter.DeleteItem(file.NewServerPath);
Run();
VerifyHistory(4, 0);
// Resolve "Branch source path not found conflict" using "$/" scope.
ConflictResolver conflictManager = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictManager.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be only 1 conflict");
conflictManager.TryResolveConflict(conflicts[0], new VCChangeToAddOnBranchSourceNotMappedAction(), "$/"); // Add on branch source not found
Run(true, true);
Assert.IsTrue(VerifyContents());
}
public void CloakedTargetMappingsTest()
{
MigrationItemStrings file = new MigrationItemStrings("source" + SourceAdapter.PathSeparator + "file.txt",
"target" + SourceAdapter.PathSeparator + "file.txt", TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "target",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "target",
true); // cloaked
TestEnvironment.AddMapping(mapping);
int branchChangeset = SourceAdapter.BranchItem(file.ServerPath, file.NewServerPath);
SourceAdapter.EditFile(m_extraFile.LocalPath);
SourceAdapter.EditFile(file.LocalPath);
int mergeChangset = SourceAdapter.MergeItem(file, branchChangeset);
RunAndValidate();
}
public void DeleteUnmappedTest()
{
MigrationItemStrings cloakedFile = new MigrationItemStrings("cloak" + SourceAdapter.PathSeparator + "file.txt", null, 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(cloakedFile.LocalPath);
SourceWorkspace.Get(VersionSpec.Latest, GetOptions.Overwrite);
TestUtils.EditRandomFile(cloakedFile.LocalPath);
SourceWorkspace.PendDelete(cloakedFile.LocalPath);
// Extra file and deleted file will be checked in together.
SourceAdapter.EditFile(m_extraFile.LocalPath);
RunAndValidate();
}
public void CloakedSourceMappingsTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source", "target", TestEnvironment, true);
MigrationItemStrings file = new MigrationItemStrings("source" + SourceAdapter.PathSeparator + "file.txt",
"source" + SourceAdapter.PathSeparator + "renamedFile.txt", TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "source",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "source",
true); // cloaked
TestEnvironment.AddMapping(mapping);
int branchChangeset = SourceAdapter.BranchItem(branch.ServerPath, branch.NewServerPath);
SourceAdapter.EditFile(m_extraFile.LocalPath);
SourceAdapter.EditFile(file.LocalPath);
SourceAdapter.RenameItem(file.ServerPath, file.NewServerPath);
SourceWorkspace.Merge(branch.ServerPath, branch.NewServerPath,
VersionSpec.ParseSingleSpec(branchChangeset.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
ResolveConflicts(Resolution.AcceptTheirs);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), MergeComment);
Run();
VerifyHistory(5, 0);
// Resolve "Branch source path not found conflict" using "$/" scope.
ConflictResolver conflictManager = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictManager.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be only 1 conflict");
conflictManager.TryResolveConflict(conflicts[0], new VCChangeToAddOnBranchSourceNotMappedAction(), "$/"); // Add on branch source not found
RunAndValidate(true, true);
}
public void PartialCloakedChangesetTest()
{
MigrationItemStrings file1 = new MigrationItemStrings("folder/file1.txt", null, TestEnvironment, true);
MigrationItemStrings file2 = new MigrationItemStrings("cloakfolder/file2.txt", null, TestEnvironment, true);
MappingPair mapping = new MappingPair(TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "cloakfolder",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "cloakfolder",
true);
TestEnvironment.AddMapping(mapping);
SourceAdapter.AddFile(file1.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
TestUtils.EditRandomFile(file1.LocalPath);
TestUtils.EditRandomFile(file2.LocalPath);
SourceWorkspace.PendEdit(file1.LocalPath);
SourceWorkspace.PendEdit(file2.LocalPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "Multiple edits.");
RunAndValidate();
}
public void Map <TSrc, TDest>(TSrc src, TDest dest,
IPropNamesMatcher propsMatcher = null,
IPropValueConverter propertyValueConverter = null,
IMappingStrategy mappingStrategy = null,
Dictionary <string, object> externalData = null)
{
if (src == null)
{
throw new ArgumentNullException("src", "Source can not be null, specify valid source for mapping");
}
propertyValueConverter = propertyValueConverter ?? new NopPropertyValueConverter();
externalData = externalData ?? new Dictionary <string, object>();
var srcMappingObjectType = _mapperConfiguration.MappingObjects.Get(src);
var srcMappingObject = _mapperConfiguration.ObjectFactory.CreateInstance(srcMappingObjectType) as IMappingObject;
srcMappingObject.UnderlyingObject = src;
srcMappingObject.ExternalData = externalData;
var destMappingObjectType = _mapperConfiguration.MappingObjects.Get(dest);
var destMappingObject = _mapperConfiguration.ObjectFactory.CreateInstance(destMappingObjectType) as IMappingObject;
destMappingObject.UnderlyingObject = dest;
destMappingObject.ExternalData = externalData;
var mappingPair = new MappingPair(srcMappingObject, destMappingObject);
var strategyType = _mapperConfiguration.MappingStrategies.Get(mappingPair);
var strategy = mappingStrategy ?? _mapperConfiguration.ObjectFactory.CreateInstance(strategyType) as IMappingStrategy;
strategy.MapperConfiguration = _mapperConfiguration;
strategy.PropValueConverter = propertyValueConverter;
strategy.PropsMatcher = propsMatcher ?? _mapperConfiguration.ObjectFactory.CreateInstance(_mapperConfiguration.PropertyNameConverters.Get(mappingPair)) as IPropNamesMatcher;
strategy.Map(mappingPair);
}
public void SnapshotMergeUndeleteRenameTest()
{
// scenario
// branch from source to target where source is cloaked
// item1 on source was edited, deleted
// item1 on source was undelete, renamed (case-only rename) (snapshot start point)
// item1 was merged to target
// migration uses a snapshot start point which skips migrating deletion
// hence undelete, rename becomes add, rename
// cloak branch from path
MappingPair mapping = new MappingPair(
TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "source",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "source",
true);
TestEnvironment.AddMapping(mapping);
MigrationItemStrings file1 = new MigrationItemStrings("source/folder/file1.txt", "source/Folder/File1.txt", TestEnvironment, true);
MigrationItemStrings file2 = new MigrationItemStrings("source/folder/file2.txt", "source/folder/File2.txt", TestEnvironment, true);
MigrationItemStrings file3 = new MigrationItemStrings("source/folder/file3.txt", null, TestEnvironment, true);
// branch
SourceAdapter.AddFile(file1.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
SourceAdapter.AddFile(file3.LocalPath);
int changesetId = SourceAdapter.BranchItem(source.ServerPath, target.ServerPath);
// merge edit
// merge delete
SourceAdapter.EditFile(file1.LocalPath);
int deletionId = SourceTfsClient.GetChangeset(SourceAdapter.DeleteItem(file1.ServerPath)).Changes[0].Item.DeletionId;
SourceWorkspace.Merge(source.LocalPath, target.LocalPath,
VersionSpec.ParseSingleSpec(changesetId.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
changesetId = SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "edit -> delete");
// pend undelete
SourceWorkspace.PendUndelete(file1.ServerPath, deletionId);
// pend rename
SourceWorkspace.PendRename(file1.LocalPath, file1.NewLocalPath);
SourceWorkspace.PendRename(file2.LocalPath, file2.NewLocalPath);
TestUtils.EditRandomFile(file3.LocalPath);
SourceWorkspace.PendEdit(file3.LocalPath);
changesetId = SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "undelete rename");
int snapshotChangesetId = changesetId;
// merge undelete,rename skipping deletion
// migrating merge,undelete,rename becomes add,rename
SourceWorkspace.Merge(source.LocalPath, target.LocalPath,
VersionSpec.ParseSingleSpec(changesetId.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
resolveConflictAcceptThiers();
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "merge undelete rename");
// snapshot
TestEnvironment.SnapshotStartPoints = new Dictionary <string, string>();
TestEnvironment.SnapshotStartPoints.Add(TestEnvironment.SourceTeamProject, snapshotChangesetId.ToString());
TestEnvironment.SnapshotBatchSize = 100;
Run();
// Resolve "Branch source path not found conflict" using "$/" scope.
ConflictResolver conflictManager = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictManager.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be only 1 conflict");
conflictManager.TryResolveConflict(conflicts[0], new VCChangeToAddOnBranchSourceNotMappedAction(), "$/"); // Add on branch source not found
Run();
Assert.IsTrue(VerifyContents());
}
public void SnapshotMergeRenameEditTest()
{
// scenario
// branch from source to target where source is cloaked
// take the snapshot of target branch
// item1 on source renamed,edited
// item1 was merged to target
// VC session converts merge,rename,edit to add,edit
// cloak branch from path
MappingPair mapping = new MappingPair(
TestEnvironment.FirstSourceServerPath + SrcPathSeparator + "source",
TestEnvironment.FirstTargetServerPath + TarPathSeparator + "source",
true);
TestEnvironment.AddMapping(mapping);
MigrationItemStrings file1 = new MigrationItemStrings(
string.Format("source{0}folder1{1}file1.txt", SrcPathSeparator, SrcPathSeparator),
string.Format("source{0}folder2{1}file1.txt", SrcPathSeparator, SrcPathSeparator),
TestEnvironment, true);
MigrationItemStrings file2 = new MigrationItemStrings(
string.Format("source{0}folder2{1}file2.txt", SrcPathSeparator, SrcPathSeparator),
null, TestEnvironment, true);
MigrationItemStrings file3 = new MigrationItemStrings(
string.Format("source{0}folder1{1}file3.txt", SrcPathSeparator, SrcPathSeparator),
string.Format("source{0}folder2{1}file3.txt", SrcPathSeparator, SrcPathSeparator),
TestEnvironment, true);
// branch
SourceAdapter.AddFile(file1.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
SourceAdapter.AddFile(file3.LocalPath);
int changesetId = SourceAdapter.BranchItem(source.ServerPath, target.ServerPath);
int snapshotChangesetId = SourceAdapter.EditFile(file2.LocalPath);
// pend edit on file1
SourceWorkspace.PendEdit(file1.LocalPath);
TestUtils.EditRandomFile(file1.LocalPath);
// pend rename (file1 is moved to a different location)
SourceWorkspace.PendRename(file1.LocalPath, file1.NewLocalPath);
// pend edit on file2
SourceWorkspace.PendEdit(file2.LocalPath);
TestUtils.EditRandomFile(file2.LocalPath);
// pend rename (file3 is moved to a different location)
SourceWorkspace.PendEdit(file3.LocalPath);
SourceWorkspace.PendRename(file3.LocalPath, file3.NewLocalPath);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "rename, edit");
// merge changes from source to target
// - merge,rename,edit on file1
// - merge,edit on file2
// - merge,rename on file3
SourceWorkspace.Merge(source.LocalPath, target.LocalPath,
VersionSpec.ParseSingleSpec(changesetId.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
resolveConflictAcceptThiers();
changesetId = SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "merge,rename,edit");
// snapshot
TestEnvironment.SnapshotStartPoints = new Dictionary <string, string>();
TestEnvironment.SnapshotStartPoints.Add(TestEnvironment.SourceTeamProject, snapshotChangesetId.ToString());
TestEnvironment.SnapshotBatchSize = 100;
Run();
// Resolve "Branch source path not found conflict" using "$/" scope.
ConflictResolver conflictManager = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictManager.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be only 1 conflict");
conflictManager.TryResolveConflict(conflicts[0], new VCChangeToAddOnBranchSourceNotMappedAction(), "$/"); // Add on branch source not found
Run();
Assert.IsTrue(VerifyContents());
}
public void PathSnapshotBranchTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings branch2 = new MigrationItemStrings("source/", "target2/", TestEnvironment, true);
MigrationItemStrings[] addFiles = new MigrationItemStrings[10];
// Add files
// Create a tree structure so that we can test path compression logic.
int sessionSnapshotChangesetId = 1;
for (int i = 0; i < 10; i++)
{
addFiles[i] = new MigrationItemStrings(
string.Format("source/addFile{0}.txt", i),
string.Format("source/addFile{0}-rename.txt", i),
TestEnvironment,
true);
SourceAdapter.AddFile(addFiles[i].LocalPath);
}
int editBeforeSnapshotChangesetId = SourceAdapter.EditFile(addFiles[2].LocalPath);
int editBeforeSnapshotChangesetId2 = SourceAdapter.EditFile(addFiles[2].LocalPath);
SourceAdapter.RenameItem(addFiles[3].ServerPath, addFiles[3].NewServerPath, "Rename before snapshot");
int deleteChangesetID = SourceAdapter.DeleteItem(addFiles[4].ServerPath);
SourceAdapter.DeleteItem(addFiles[5].ServerPath);
SourceAdapter.UndeleteFile(addFiles[4].ServerPath, deleteChangesetID);
int path2SnapshotChangesetId = SourceAdapter.RenameItem(addFiles[6].ServerPath, addFiles[6].NewServerPath, "Rename before snapshot");
int editAfterSnapshotChangesetId = SourceAdapter.EditFile(addFiles[6].NewLocalPath);
int editAfterSnapshotChangesetId2 = SourceAdapter.EditFile(addFiles[6].NewLocalPath);
SourceAdapter.DeleteItem(addFiles[4].ServerPath);
SourceAdapter.RenameItem(addFiles[3].NewServerPath, addFiles[3].ServerPath, "Rename after snapshot");
// Branch from a version before the snapshot
SourceWorkspace.Get(VersionSpec.Latest, GetOptions.Overwrite);
SourceWorkspace.PendBranch(branch.ServerPath, branch.NewServerPath, new ChangesetVersionSpec(editBeforeSnapshotChangesetId));
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), "Branch from a version before snapshot");
SourceAdapter.BranchItem(branch2.ServerPath, branch2.NewServerPath);
TestEnvironment.SnapshotStartPoints = new Dictionary <string, string>();
TestEnvironment.SnapshotStartPoints.Add(TestEnvironment.SourceTeamProject, sessionSnapshotChangesetId.ToString());
TestEnvironment.SnapshotBatchSize = 3;
// We need to map to the sub item level
MappingPair rootMapping = TestEnvironment.Mappings[0];
TestEnvironment.Mappings.Clear();
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/target", rootMapping.TargetPath + "/target", false));
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/target2", rootMapping.TargetPath + "/target2", false));
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/source", rootMapping.TargetPath + "/source", false, path2SnapshotChangesetId.ToString(), null));
Run();
ConflictResolver conflictManager = new ConflictResolver(Configuration);
List <RTConflict> conflicts = conflictManager.GetConflicts();
Assert.AreEqual(1, conflicts.Count, "There should be only 1 conflict");
conflictManager.TryResolveConflict(conflicts[0], ConflictConstant.TFSHistoryNotFoundSkipAction, "1-" + path2SnapshotChangesetId);
Run(true, true);
// ToDo, ideally, we should compare content at snapshot changeset and compare history after snapshot changeset.
Assert.IsTrue(VerifyContents());
}
public void PathSnapshotCRUDTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings[] path1AddFiles = new MigrationItemStrings[10];
MigrationItemStrings[] path2AddFiles = new MigrationItemStrings[10];
// Add files
// Create a tree structure so that we can test path compression logic.
int sessionSnapshotChangesetId = 0;
for (int i = 0; i < 10; i++)
{
path1AddFiles[i] = new MigrationItemStrings(string.Format("source/path1/addFile{0}.txt", i), null, TestEnvironment, true);
if (i == 7)
{
sessionSnapshotChangesetId = SourceAdapter.AddFile(path1AddFiles[i].LocalPath);
}
else
{
SourceAdapter.AddFile(path1AddFiles[i].LocalPath);
}
}
for (int i = 0; i < 10; i++)
{
path2AddFiles[i] = new MigrationItemStrings(string.Format("source/path2/file{0}.txt", i), string.Format("source/path2/file-rename{0}.txt", i), TestEnvironment, true);
SourceAdapter.AddFile(path2AddFiles[i].LocalPath);
}
SourceAdapter.EditFile(path2AddFiles[2].LocalPath);
SourceAdapter.RenameItem(path2AddFiles[3].ServerPath, path2AddFiles[3].NewServerPath, "Rename before snapshot");
int deleteChangesetID = SourceAdapter.DeleteItem(path2AddFiles[4].ServerPath);
SourceAdapter.DeleteItem(path2AddFiles[5].ServerPath);
SourceAdapter.UndeleteFile(path2AddFiles[4].ServerPath, deleteChangesetID);
int path2SnapshotChangesetId = SourceAdapter.RenameItem(path2AddFiles[6].ServerPath, path2AddFiles[6].NewServerPath, "Rename before snapshot");
SourceAdapter.EditFile(path2AddFiles[6].NewLocalPath);
SourceAdapter.DeleteItem(path2AddFiles[4].ServerPath);
SourceAdapter.RenameItem(path2AddFiles[3].NewServerPath, path2AddFiles[3].ServerPath, "Rename after snapshot");
TestEnvironment.SnapshotStartPoints = new Dictionary <string, string>();
TestEnvironment.SnapshotStartPoints.Add(TestEnvironment.SourceTeamProject, sessionSnapshotChangesetId.ToString());
TestEnvironment.SnapshotBatchSize = 3;
// We need to map to the sub item level
MappingPair rootMapping = TestEnvironment.Mappings[0];
TestEnvironment.Mappings.Clear();
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/source/path1", rootMapping.TargetPath + "/source/path1", false));
TestEnvironment.Mappings.Add(new MappingPair(rootMapping.SourcePath + "/source/path2", rootMapping.TargetPath + "/source/path2", false, path2SnapshotChangesetId.ToString(), null));
Run();
// ToDo, ideally, we should compare content at snapshot changeset and compare history after snapshot changeset.
Assert.IsTrue(VerifyContents());
}
public void PathPeerSnapshotTest()
{
// Add files
// Create a tree structure so that we can test path compression logic.
int snapshotChangesetId1 = 0;
int peerSnapshotChangesetId1 = 0;
for (int i = 0; i < 4; i++)
{
MigrationItemStrings sourceFile = new MigrationItemStrings(string.Format("source/path1/addFile{0}.txt", i), null, TestEnvironment, true);
MigrationItemStrings targetFile = new MigrationItemStrings(string.Format("source/path1/addFile{0}.txt", i), null, TestEnvironment, false);
if (i < 2)
{
snapshotChangesetId1 = SourceAdapter.AddFile(sourceFile.LocalPath);
TargetAdapter.AddFile(targetFile.LocalPath);
peerSnapshotChangesetId1 = TargetAdapter.EditFile(targetFile.LocalPath, sourceFile.LocalPath);
}
else
{
SourceAdapter.AddFile(sourceFile.LocalPath);
}
}
int snapshotChangesetId2 = 0;
int peerSnapshotChangesetId2 = 0;
for (int i = 0; i < 4; i++)
{
MigrationItemStrings sourceFile = new MigrationItemStrings(string.Format("source/path2/addFile{0}.txt", i), null, TestEnvironment, true);
MigrationItemStrings targetFile = new MigrationItemStrings(string.Format("source/path2/addFile{0}.txt", i), null, TestEnvironment, false);
if (i < 3)
{
snapshotChangesetId2 = SourceAdapter.AddFile(sourceFile.LocalPath);
TargetAdapter.AddFile(targetFile.LocalPath);
peerSnapshotChangesetId2 = TargetAdapter.EditFile(targetFile.LocalPath, sourceFile.LocalPath);
}
else
{
SourceAdapter.AddFile(sourceFile.LocalPath);
}
}
// We need to map to the sub item level
MappingPair rootMapping = TestEnvironment.Mappings[0];
TestEnvironment.Mappings.Clear();
TestEnvironment.Mappings.Add(
new MappingPair(
rootMapping.SourcePath + "/source/path1",
rootMapping.TargetPath + "/source/path1",
false,
snapshotChangesetId1.ToString(),
peerSnapshotChangesetId1.ToString(),
null,
null,
peerSnapshotChangesetId1.ToString(),
snapshotChangesetId1.ToString()));
TestEnvironment.Mappings.Add(
new MappingPair(
rootMapping.SourcePath + "/source/path2",
rootMapping.TargetPath + "/source/path2",
false,
snapshotChangesetId2.ToString(),
peerSnapshotChangesetId2.ToString(),
null,
null,
peerSnapshotChangesetId2.ToString(),
snapshotChangesetId2.ToString()));
Run();
MigrationItemStrings newFile = new MigrationItemStrings("source/path1/newFile.txt", null, TestEnvironment, true);
SourceAdapter.AddFile(newFile.LocalPath);
Run();
Assert.IsTrue(VerifyContents());
}
public static bool CanMap(MappingPair mappingPair)
{
return(PsToCamelCasePropsMatcher.CanMap(new MappingPair(mappingPair.Dest, mappingPair.Src)));
}
