public int CheckIn(IEnumerable <ITfsWorkItem> workItemAssociations, string changesetComment)
{
return(TfsWorkspace.CheckIn(
TfsWorkspace.GetPendingChangesEnumerable().ToArray(),
changesetComment, null,
workItemAssociations.Select(
wia => new WorkItemCheckinInfo(Repository.Instance.TfsBridgeProvider.GetWorkItemById(wia.Id).WorkItem, WorkItemCheckinAction.Associate)).ToArray(),
null));
}
public void Policy_failed_and_Force_without_an_OverrideReason()
{
var logger = new StringWriter();
Trace.Listeners.Add(new TextWriterTraceListener(logger));
IWorkspace workspace = MockRepository.GenerateStub <IWorkspace>();
string localDirectory = string.Empty;
TfsChangesetInfo contextVersion = MockRepository.GenerateStub <TfsChangesetInfo>();
IGitTfsRemote remote = MockRepository.GenerateStub <IGitTfsRemote>();
remote.Repository = MockRepository.GenerateStub <IGitRepository>();
CheckinOptions checkinOptions = new CheckinOptions();
ITfsHelper tfsHelper = MockRepository.GenerateStub <ITfsHelper>();
CheckinPolicyEvaluator policyEvaluator = new CheckinPolicyEvaluator();
TfsWorkspace tfsWorkspace = new TfsWorkspace(workspace, localDirectory, contextVersion, remote, checkinOptions, tfsHelper, policyEvaluator);
IPendingChange pendingChange = MockRepository.GenerateStub <IPendingChange>();
IPendingChange[] allPendingChanges = new IPendingChange[] { pendingChange };
workspace.Stub(w => w.GetPendingChanges()).Return(allPendingChanges);
ICheckinEvaluationResult checkinEvaluationResult =
new StubbedCheckinEvaluationResult()
.WithPoilicyFailure("No work items associated.");
checkinOptions.Force = true;
workspace.Stub(w => w.EvaluateCheckin(
Arg <TfsCheckinEvaluationOptions> .Is.Anything,
Arg <IPendingChange[]> .Is.Anything,
Arg <IPendingChange[]> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <ICheckinNote> .Is.Anything,
Arg <IEnumerable <IWorkItemCheckinInfo> > .Is.Anything))
.Return(checkinEvaluationResult);
workspace.Expect(w => w.Checkin(
Arg <IPendingChange[]> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <ICheckinNote> .Is.Anything,
Arg <IEnumerable <IWorkItemCheckinInfo> > .Is.Anything,
Arg <TfsPolicyOverrideInfo> .Is.Anything,
Arg <bool> .Is.Anything))
.Return(0);
var ex = Assert.Throws <GitTfsException>(() =>
{
var result = tfsWorkspace.Checkin(checkinOptions);
});
Assert.Equal("A reason must be supplied (-f REASON) to override the policy violations.", ex.Message);
Assert.Contains("[ERROR] Policy: No work items associated.", logger.ToString());
}
public void RefreshConflictsWorker(CancellationToken cts = default(CancellationToken))
{
string[] conflictPaths = new string[1];
conflictPaths[0] = TargetFolder;
// targetBranch.Name;
var result = new List <ITfsMergeConflict>();
Conflict[] conflicts = TfsWorkspace.QueryConflicts(conflictPaths, true);
if (conflicts.Length > 0)
{
foreach (var conflict in conflicts)
{
bool resolved = false;
cts.ThrowIfCancellationRequested();
if (TfsWorkspace.MergeContent(conflict, false))
{
if (conflict.ContentMergeSummary.TotalConflicting == 0)
{
conflict.Resolution = Resolution.AcceptMerge;
try
{
TfsWorkspace.ResolveConflict(conflict);
}
catch (Exception ex)
{
// Ignore exception "This conflict was not found on the server. Another user might have already resolved this conflict."
if (!ex.Message.Contains("TF10167"))
{
throw ex;
}
resolved = true;
}
if (!resolved)
{
resolved = conflict.IsResolved;
}
}
}
if (!resolved)
{
result.Add(new TfsMergeConflict(conflict));
}
}
}
Conflicts = result;
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
RaiseConflictsChanged();
return(true);
});
}
public void Policy_failed_and_Force_with_an_OverrideReason()
{
IWorkspace workspace = MockRepository.GenerateStub <IWorkspace>();
string localDirectory = string.Empty;
TextWriter writer = new StringWriter();
TfsChangesetInfo contextVersion = MockRepository.GenerateStub <TfsChangesetInfo>();
IGitTfsRemote remote = MockRepository.GenerateStub <IGitTfsRemote>();
remote.Repository = MockRepository.GenerateStub <IGitRepository>();
CheckinOptions checkinOptions = new CheckinOptions();
ITfsHelper tfsHelper = MockRepository.GenerateStub <ITfsHelper>();
CheckinPolicyEvaluator policyEvaluator = new CheckinPolicyEvaluator();
TfsWorkspace tfsWorkspace = new TfsWorkspace(workspace, localDirectory, writer, contextVersion, remote, checkinOptions, tfsHelper, policyEvaluator);
IPendingChange pendingChange = MockRepository.GenerateStub <IPendingChange>();
IPendingChange[] allPendingChanges = new IPendingChange[] { pendingChange };
workspace.Stub(w => w.GetPendingChanges()).Return(allPendingChanges);
ICheckinEvaluationResult checkinEvaluationResult =
new StubbedCheckinEvaluationResult()
.WithPoilicyFailure("No work items associated.");
checkinOptions.Force = true;
checkinOptions.OverrideReason = "no work items";
workspace.Stub(w => w.EvaluateCheckin(
Arg <TfsCheckinEvaluationOptions> .Is.Anything,
Arg <IPendingChange[]> .Is.Anything,
Arg <IPendingChange[]> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <ICheckinNote> .Is.Anything,
Arg <IEnumerable <IWorkItemCheckinInfo> > .Is.Anything))
.Return(checkinEvaluationResult);
workspace.Expect(w => w.Checkin(
Arg <IPendingChange[]> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <ICheckinNote> .Is.Anything,
Arg <IEnumerable <IWorkItemCheckinInfo> > .Is.Anything,
Arg <TfsPolicyOverrideInfo> .Is.Anything,
Arg <bool> .Is.Anything))
.Return(1);
var result = tfsWorkspace.Checkin(checkinOptions);
Assert.Contains("[OVERRIDDEN] Policy: No work items associated.", writer.ToString());
}
public void Checkin_failed()
{
IWorkspace workspace = MockRepository.GenerateStub <IWorkspace>();
string localDirectory = string.Empty;
TextWriter writer = new StringWriter();
TfsChangesetInfo contextVersion = MockRepository.GenerateStub <TfsChangesetInfo>();
IGitTfsRemote remote = MockRepository.GenerateStub <IGitTfsRemote>();
remote.Repository = MockRepository.GenerateStub <IGitRepository>();
CheckinOptions checkinOptions = new CheckinOptions();
ITfsHelper tfsHelper = MockRepository.GenerateStub <ITfsHelper>();
CheckinPolicyEvaluator policyEvaluator = new CheckinPolicyEvaluator();
TfsWorkspace tfsWorkspace = new TfsWorkspace(workspace, localDirectory, writer, contextVersion, remote, checkinOptions, tfsHelper, policyEvaluator);
IPendingChange pendingChange = MockRepository.GenerateStub <IPendingChange>();
IPendingChange[] allPendingChanges = new IPendingChange[] { pendingChange };
workspace.Stub(w => w.GetPendingChanges()).Return(allPendingChanges);
ICheckinEvaluationResult checkinEvaluationResult =
new StubbedCheckinEvaluationResult();
workspace.Stub(w => w.EvaluateCheckin(
Arg <TfsCheckinEvaluationOptions> .Is.Anything,
Arg <IPendingChange[]> .Is.Anything,
Arg <IPendingChange[]> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <ICheckinNote> .Is.Anything,
Arg <IEnumerable <IWorkItemCheckinInfo> > .Is.Anything))
.Return(checkinEvaluationResult);
workspace.Expect(w => w.Checkin(
Arg <IPendingChange[]> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <ICheckinNote> .Is.Anything,
Arg <IEnumerable <IWorkItemCheckinInfo> > .Is.Anything,
Arg <TfsPolicyOverrideInfo> .Is.Anything,
Arg <bool> .Is.Anything))
.Return(0);
var ex = Assert.Throws <GitTfsException>(() =>
{
var result = tfsWorkspace.Checkin(checkinOptions);
});
Assert.Equal("Checkin failed!", ex.Message);
}
public TfsWorkspaceTests()
{
workspace = new Mock <IWorkspace>();
string localDirectory = string.Empty;
TfsChangesetInfo contextVersion = new Mock <TfsChangesetInfo>().Object;
var remoteMock = new Mock <IGitTfsRemote>();
remoteMock.SetupAllProperties();
remoteMock.SetupGet(x => x.Repository).Returns(new Mock <IGitRepository>().Object);
IGitTfsRemote remote = remoteMock.Object;
ITfsHelper tfsHelper = new Mock <ITfsHelper>().Object;
CheckinPolicyEvaluator policyEvaluator = new CheckinPolicyEvaluator();
tfsWorkspace = new TfsWorkspace(workspace.Object, localDirectory, contextVersion, remote, checkinOptions,
tfsHelper, policyEvaluator);
}
void RefreshPendingChangesWorker(CancellationToken cts)
{
var pendingChanges = new List <ITfsPendingChange>();
var pendingChangesTfs = TfsWorkspace.GetPendingChangesEnumerable();
foreach (var pendingChange in pendingChangesTfs)
{
cts.ThrowIfCancellationRequested();
pendingChanges.Add(new TfsPendingChange(pendingChange));
}
PendingChanges = pendingChanges;
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
RaisePendingChangesChanged();
return(true);
});
}
public void Nothing_to_checkin()
{
IWorkspace workspace = MockRepository.GenerateStub <IWorkspace>();
string localDirectory = string.Empty;
TextWriter writer = new StringWriter();
TfsChangesetInfo contextVersion = MockRepository.GenerateStub <TfsChangesetInfo>();
IGitTfsRemote remote = MockRepository.GenerateStub <IGitTfsRemote>();
CheckinOptions checkinOptions = new CheckinOptions();
ITfsHelper tfsHelper = MockRepository.GenerateStub <ITfsHelper>();
CheckinPolicyEvaluator policyEvaluator = new CheckinPolicyEvaluator();
TfsWorkspace tfsWorkspace = new TfsWorkspace(workspace, localDirectory, writer, contextVersion, remote, checkinOptions, tfsHelper, policyEvaluator);
workspace.Stub(w => w.GetPendingChanges()).Return(null);
var ex = Assert.Throws <GitTfsException>(() =>
{
var result = tfsWorkspace.Checkin(checkinOptions);
});
Assert.Equal("Nothing to checkin!", ex.Message);
}
public void UndoAllPendingChanges()
{
TfsWorkspace.Undo("$/", RecursionType.Full);
}
public bool Merge(ITfsBranch targetBranch, string pathFilter, IEnumerable <ITfsChangeset> changesetsAsEnumerable, ITrackProgress trackProgress = null)
{
SimpleLogger.Checkpoint("Merge: {0}, {1}", targetBranch != null ? targetBranch.Name : null, pathFilter);
if (pathFilter != null && !SourceBranch.Name.StartsWith(pathFilter, StringComparison.InvariantCultureIgnoreCase))
{
throw new ArgumentException("If a PathFilter is provided, it needs to be below the SourceBranch");
}
var changesets = new List <ITfsChangeset>(changesetsAsEnumerable);
var files = new List <string>();
if (trackProgress != null)
{
trackProgress.MaxProgress = changesets.Count * 2 + 2;
trackProgress.CurrentProgress = 0;
trackProgress.ProgressInfo = "Acquiring file list ...";
}
foreach (var changeset in changesets)
{
SimpleLogger.Checkpoint("Merge: Processing changeset #{0}", changeset != null ? changeset.Changeset.ChangesetId : -1);
foreach (var change in changeset.Changes.Select(c => c.Change))
{
SimpleLogger.Checkpoint("Merge: change {0}, filter {1}", change.Item.ServerItem, pathFilter);
if (pathFilter != null && change.Item.ServerItem.StartsWith(pathFilter, StringComparison.InvariantCultureIgnoreCase) == false)
{
continue;
}
files.Add(change.Item.ServerItem);
}
++trackProgress.CurrentProgress;
}
GetRequest[] getRequests =
files.Distinct().Select(file => new GetRequest(file, RecursionType.None, VersionSpec.Latest)).ToArray();
if (trackProgress != null)
{
trackProgress.ProgressInfo = "Getting files ...";
++trackProgress.CurrentProgress;
}
SimpleLogger.Checkpoint("Merge: Getting files");
GetStatus gs = TfsWorkspace.Get(getRequests, GetOptions.None);
if (trackProgress != null)
{
trackProgress.ProgressInfo = "Performing merges ...";
++trackProgress.CurrentProgress;
}
var resultingConflicts = new List <ITfsMergeConflict>();
foreach (var changeset in changesets)
{
if (trackProgress != null)
{
++trackProgress.CurrentProgress;
}
var csvs = new ChangesetVersionSpec(changeset.Changeset.ChangesetId);
SimpleLogger.Checkpoint("Merge: Performing merge on CS# {0}", changeset != null ? changeset.Changeset.ChangesetId : -1);
var mergeResult = TfsWorkspace.Merge(
pathFilter ?? SourceBranch.Name,
targetBranch.Name,
csvs, csvs, LockLevel.None, RecursionType.Full, MergeOptions.ForceMerge);
if (mergeResult.NumFailures > 0)
{
foreach (var failure in mergeResult.GetFailures())
{
if (failure.Code == "TF14078" || failure.Message.Contains("TF14078"))
{
throw new LocalPathTooLongException(failure.Message);
}
throw new InvalidOperationException(failure.Message);
}
}
}
if (trackProgress != null)
{
trackProgress.CurrentProgress = trackProgress.MaxProgress;
}
SimpleLogger.Checkpoint("Merge: Refreshing conflicts");
RefreshConflictsWorker(default(CancellationToken));
SimpleLogger.Checkpoint("Merge: Finished");
return(Conflicts.Count != 0);
}
