public void TfsWorkItemCtorShouldThrowIfWorkItemIsInvalid()
{
// ReSharper disable once UnusedVariable
Action action = () => { var x = new TfsWorkItem(23); };
action.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("workItem");
}
public override async void GetIssuesAndResolvePortedTfsIssue(TfsWorkItem item, string title)
{
if (_gettingIssues)
{
return;
}
_gettingIssues = true;
AllIssues.Clear();
OnPropertyChanged("Issues");
var wrapper = Repository;
if (wrapper != null && wrapper.Repository != null)
{
var repository = wrapper.Repository;
var request = new RepositoryIssueRequest();
request.State = ItemState.Open;
request.Filter = IssueFilter.All;
await GetIssues(repository.Owner.Login, repository.Name, request);
// Resolve and close TFS issue
var matchingIssues = AllIssues.Where(i => i.Title == title);
if (matchingIssues.Any())
{
var number = matchingIssues.Max(i => i.Number);
var issue = matchingIssues.FirstOrDefault(i => i.Number == number);
if (issue != null)
{
item.Resolve(issue);
}
}
}
_gettingIssues = false;
}
public void TfsWorkItemCtorShouldThrowIfWorkItemIsNull()
{
// ReSharper disable once UnusedVariable
Action action = () => { var x = new TfsWorkItem(null); };
action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("workItem");
}
private Issue GetIssueFromTfsWorkItem(TfsWorkItem wi)
{
return(new Issue
{
Id = wi.Id.ToString(),
Url = _tfsApi.ConnectionUri + "/web/wi.aspx?id=" + wi.Id
});
}
public void SerializesTheTypeOfTheWorkItemByReferenceName()
{
// Arrange
Mock <ITfsWorkItem> mockItem = CreateMockWorkItem();
AddFieldToMockItem(mockItem, Constants.SystemWorkItemTypeFieldReferenceName, "wit");
// Act
XElement ans = TfsWorkItem.Serialize(mockItem.Object);
// Assert
TestHelper.AssertXmlNodeContent("wit", ans, "/wi:WorkItem/wi:Field[@name='System.WorkItemType']", "Work item type not serialized correctly or missing");
}
private ExternalIssueDetails GetDetails(TfsWorkItem wi)
{
var eid = new ExternalIssueDetails
{
Id = wi.Id.ToString(),
Created = wi.Created.ToString("dd-MM-yyyy HH:mm:ss"),
Comments = wi.HistoryComments,
Status = wi.State,
Summary = wi.Title,
Description = wi.Description,
};
return(eid);
}
public void SerializesOtherFieldsAsRequested()
{
// Arrange
Mock <ITfsWorkItem> mockItem = CreateMockWorkItem();
AddFieldToMockItem(mockItem, "A.B", "ab");
AddFieldToMockItem(mockItem, "A.C", "ac");
// Act
XElement ans = TfsWorkItem.Serialize(mockItem.Object, "A.B", "A.C");
// Assert
TestHelper.AssertXmlNodeContent("ab", ans, "/wi:WorkItem/wi:Field[@name='A.B']", "Work item field not serialized correctly or missing");
TestHelper.AssertXmlNodeContent("ac", ans, "/wi:WorkItem/wi:Field[@name='A.C']", "Work item field not serialized correctly or missing");
}
public void DoesNotSerializeRequestedFieldsNotInTheWorkItem()
{
// Arrange
Mock <ITfsWorkItem> mockItem = CreateMockWorkItem();
AddFieldToMockItem(mockItem, "A.B", "ab");
AddFieldToMockItem(mockItem, "A.C", "ac");
mockItem.Setup(wi => wi["A.D"]).Throws(new Exception("should not try to access this field"));
// Act
XElement ans = TfsWorkItem.Serialize(mockItem.Object, "A.B", "A.C", "A.D");
// Assert
TestHelper.AssertXmlNodeMissing(ans, "/wi:WorkItem/wi:A.D", "Work item field should not be serialized");
}
/// <summary>
/// Saves the work items currently in the work item manager.
/// </summary>
/// <param name="fields">The fields to be extracted from the work items.</param>
/// <param name="cancellationToken">Used to cancel the operation.</param>
private void SaveWorkItemsInWorkItemManager(string[] fields, CancellationToken cancellationToken)
{
List <XElement> workItemElements = new List <XElement>();
foreach (ITfsWorkItem wi in this.workItemManager.WorkItems)
{
workItemElements.Add(TfsWorkItem.Serialize(wi, fields));
cancellationToken.ThrowIfCancellationRequested();
}
XElement root = new XElement(this.workItemsXName, workItemElements);
this.wordDocument.DeleteXmlPart(Constants.WorkItemNamespace);
this.wordDocument.AddXmlPart(root.ToString());
}
private void SetTfsIssueAssignee(TfsWorkItem item)
{
var assignedTo = TfsGitBridge.MapTfsUserNameToGitUserName(item.AssignedTo);
if (assignedTo != null)
{
foreach (var assignee in Assignees)
{
if (assignee.Login == assignedTo)
{
Assignee = assignee;
break;
}
}
}
}
public async Task <IEnumerable <TfsWorkItem> > GetCurrentSprintAsync()
{
var workItems = await _client.QueryByWiqlAsync(new Wiql { Query = _getWorkItemsQry }, new TeamContext("STDrive"));
return((await _client
.GetWorkItemsAsync(workItems.WorkItems.Select(i => i.Id)))
.Select(item =>
{
var tfsItem = new TfsWorkItem
{
Id = item.Id ?? 0,
IterationPath = item.Fields["System.IterationPath"].ToString(),
Title = item.Fields["System.Title"].ToString(),
WorkItemType = item.Fields["System.WorkItemType"].ToString(),
AssignedTo = item.Fields["System.AssignedTo"].ToString(),
State = item.Fields["System.State"].ToString()
};
return tfsItem;
}));
}
public void AddIssue()
{
var add = Factory.Get <IIssueEditor>();
TfsWorkItem tfsBugToPort = null;
if (!string.IsNullOrEmpty(TFSBugIDToPort))
{
var savedSearchId = TfsApi.SearchId;
TfsApi.SearchId = TFSBugIDToPort;
tfsBugToPort = TfsApi.Issues.SingleOrDefault();
TfsApi.SearchId = savedSearchId;
add.SetTfsIssue(tfsBugToPort);
}
else
{
add.SetIssue(null);
}
add.ShowModal();
}
public void SetTfsIssue(TfsWorkItem item)
{
if (item == null)
{
SetIssue(null);
return;
}
Title = item.Title;
Body = MarkdownConverter.ConvertHtmlToMarkdown(item.Body);
TfsGitBridge.ShowMessageBox = ShowMessageBox;
var gitMilestone = TfsGitBridge.MapTfsMilestoneToGitMilestone(item.Milestone);
foreach (var milestone in Milestones)
{
if (string.Equals(milestone.Title, gitMilestone, StringComparison.OrdinalIgnoreCase))
{
Milestone = milestone;
break;
}
}
foreach (var labelName in TfsGitBridge.GetGitLabels(item))
{
foreach (var label in Labels)
{
if (label.Name.Equals(labelName, StringComparison.OrdinalIgnoreCase))
{
label.Checked = true;
}
}
}
_portedTfsItem = item;
LoadAssignees();
}
/// <inheritdoc/>
public void SaveWorkItem(TfsWorkItem tfsWorkItem)
{
var workItem = tfsWorkItem.Item as InMemoryWorkItem;
if (workItem == null)
{
throw new InvalidOperationException("Invalid TfsWorkItem type.");
}
if (this.workItems.Contains(workItem))
{
var parentWorkItem = this.workItems.Single(w => w.Id == this.parentWorkItemId);
var workItemLink = parentWorkItem.Links.Single(l => l.RelatedWorkItemId == workItem.Id);
workItemLink.Comment = tfsWorkItem.IssueSignature;
}
else
{
workItem.Validate();
this.workItems.Add(workItem);
this.AddLinkToWorkItem(this.parentWorkItemId, workItem.Id, tfsWorkItem.IssueSignature);
}
}
public abstract void GetIssuesAndResolvePortedTfsIssue(TfsWorkItem item, string title);
public void SetTfsIssue(TfsWorkItem issue)
{
throw new NotImplementedException();
}
public override void GetIssuesAndResolvePortedTfsIssue(TfsWorkItem item, string title)
{
throw new NotImplementedException();
}
/// <inheritdoc/>
public void SaveWorkItem(TfsWorkItem tfsWorkItem)
{
var workItem = tfsWorkItem.Item as InMemoryWorkItem;
if (workItem == null)
{
throw new InvalidOperationException("Invalid TfsWorkItem type.");
}
if (this.workItems.Contains(workItem))
{
var parentWorkItem = this.workItems.Single(w => w.Id == this.parentWorkItemId);
var workItemLink = parentWorkItem.Links.Single(l => l.RelatedWorkItemId == workItem.Id);
workItemLink.Comment = tfsWorkItem.IssueSignature;
}
else
{
workItem.Validate();
this.workItems.Add(workItem);
this.AddLinkToWorkItem(this.parentWorkItemId, workItem.Id, tfsWorkItem.IssueSignature);
}
}
private void GetWorkItemsRelevantForTheseTests()
{
_requirement = (TfsWorkItem)_adapter.WorkItems.Find(CommonConfiguration.RequirementId);
_issue = (TfsWorkItem)_adapter.WorkItems.Find(CommonConfiguration.IssueId);
}
public void SetTfsIssue(TfsWorkItem issue)
{
_gitHubViewModel.SetTfsIssue(issue);
PreviewTab.Focus();
}
public void SerializeThrowsExceptionForNullArgument()
{
TestHelper.TestForArgumentNullException(() => TfsWorkItem.Serialize(null), "workItem");
}
