public void OneHopQueryReturnsATwoLevelTreeOfWorkItems()
{
// Arrange
QueryDefinition query = new QueryDefinition("Test", TestHelper.OneHopQuery);
// Act
WorkItemTree ans = this.sut.QueryRunner.QueryForWorkItems(query, new CancellationToken());
// Assert
int count = 0;
int maxLevel = int.MinValue;
int minLevel = int.MaxValue;
foreach (WorkItemTreeNode node in ans.DepthFirstNodes())
{
count++;
maxLevel = Math.Max(maxLevel, node.Level);
minLevel = Math.Min(minLevel, node.Level);
}
VerifyAndDumpWorkItemTree(ans.RootNodes, 0);
Assert.IsTrue(count > 0, "The query did not return any work items.");
Assert.AreEqual <int>(0, minLevel, "The root nodes should be at level 0.");
Assert.AreEqual <int>(1, maxLevel, "There should be more than no more than two levels in the result.");
}
/// <summary>
/// Sets up a dialog sequence for importing that confirms all the dialogues and returns a dummy set of work items.
/// </summary>
/// <returns>
/// The mock team project that is created.
/// </returns>
private Mock <ITeamProject> SetupGoodImportDialogSequenceWithAnyWorkItems()
{
Mock <ITeamProject> mockProject = this.SetupGoodImportDialogSequence();
WorkItemTree workItems = new WorkItemTree();
mockProject.Setup(project => project.QueryRunner.QueryForWorkItems(It.IsAny <QueryDefinition>(), It.IsAny <CancellationToken>())).Returns(workItems);
return(mockProject);
}
public void CanGetFullHistoryOfAWorkItem()
{
// Arrange
QueryDefinition query = new QueryDefinition("Test", TestHelper.AllFieldTypesQuery + " WHERE [System.Id] = 21406");
// Act
WorkItemTree ans = this.sut.QueryRunner.QueryForWorkItems(query, new CancellationToken());
// Assert
ITfsWorkItem item = ans.DepthFirstNodes().First().WorkItem;
string expect = @"<html><head/><body>11/03/2011 10:25:11 Resolved with changeset 24111.<br>11/03/2011 10:19:43 <no comment><br>10/03/2011 10:16:27 Associated with changeset 23952.<br>10/03/2011 10:14:22 Did some research and need some advice from the Word Product Group. Have sent email and now awaiting response.<br>10/03/2011 09:21:46 <no comment><br></body></html>";
Assert.AreEqual(expect, item["System.History"], "History not correct");
}
public void TreeQueryModifiesQueryToWorkItemStoreToJustGetDisplayFields()
{
// Arrange
Tuple <int, int>[] links = new Tuple <int, int> [0];
ITfsWorkItem[] workItems = new ITfsWorkItem[0];
QueryDefinition qd = this.SetupTreeQuery(links, workItems, new string[] { "[field1]", "[field2]" });
// Act
WorkItemTree ans = this.sut.QueryForWorkItems(qd, new CancellationToken());
// Assert
this.mockQuery.Verify(q => q.WorkItemStore.Query(It.IsAny <int[]>(), It.Is <string>(s => s == "SELECT [field1], [field2] FROM WorkItems")));
}
public void TreeQueryReturnsItemsInTreeStructure()
{
// Arrange
Tuple <int, int>[] links = new Tuple <int, int>[]
{
new Tuple <int, int>(0, 1),
new Tuple <int, int>(0, 2),
new Tuple <int, int>(0, 3),
new Tuple <int, int>(1, 4),
new Tuple <int, int>(1, 5),
new Tuple <int, int>(4, 6),
new Tuple <int, int>(3, 7)
};
ITfsWorkItem w1 = CreateWorkItem(1);
ITfsWorkItem w2 = CreateWorkItem(2);
ITfsWorkItem w3 = CreateWorkItem(3);
ITfsWorkItem w4 = CreateWorkItem(4);
ITfsWorkItem w5 = CreateWorkItem(5);
ITfsWorkItem w6 = CreateWorkItem(6);
ITfsWorkItem w7 = CreateWorkItem(7);
ITfsWorkItem[] workItems = new ITfsWorkItem[] { w1, w2, w3, w4, w5, w6, w7 };
QueryDefinition qd = this.SetupTreeQuery(links, workItems);
// Act
WorkItemTree ans = this.sut.QueryForWorkItems(qd, new CancellationToken());
// Assert
Assert.AreEqual <int>(3, ans.RootNodes.Count, "Incorrect number of root nodes returned");
Assert.AreEqual <int>(1, ans.RootNodes[0].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(2, ans.RootNodes[0].Children.Count, "Invalid tree structure returned");
Assert.AreEqual <int>(4, ans.RootNodes[0].Children[0].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(1, ans.RootNodes[0].Children[0].Children.Count, "Invalid tree structure returned");
Assert.AreEqual <int>(6, ans.RootNodes[0].Children[0].Children[0].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(0, ans.RootNodes[0].Children[0].Children[0].Children.Count, "Invalid tree structure returned");
Assert.AreEqual <int>(5, ans.RootNodes[0].Children[1].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(2, ans.RootNodes[1].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(0, ans.RootNodes[1].Children.Count, "Invalid tree structure returned");
Assert.AreEqual <int>(3, ans.RootNodes[2].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(1, ans.RootNodes[2].Children.Count, "Invalid tree structure returned");
Assert.AreEqual <int>(7, ans.RootNodes[2].Children[0].WorkItem.Id, "Invalid tree structure returned");
Assert.AreEqual <int>(0, ans.RootNodes[2].Children[0].Children.Count, "Invalid tree structure returned");
}
public void HtmlFieldGetsHtmlTagWrapper()
{
// Arrange
QueryDefinition query = new QueryDefinition("Test", TestHelper.AllFieldTypesQuery + " WHERE [System.Id] = 21404");
// Act
WorkItemTree ans = this.sut.QueryRunner.QueryForWorkItems(query, new CancellationToken());
// Assert
ITfsWorkItem item = ans.DepthFirstNodes().First().WorkItem;
string actual = item["Microsoft.VSTS.TCM.ReproSteps"].ToString();
Assert.IsTrue(actual.StartsWith("<html><head/><body><P"), "Field is not well-formed HTML, field content is: " + actual);
Assert.IsTrue(actual.EndsWith("</P></body></html>"), "Field is not well-formed HTML, field content is: " + actual);
}
public void FlatQueryReturnsWorkItemsInFlatStructure()
{
// Arrange
ITfsWorkItem w1 = CreateWorkItem(1);
ITfsWorkItem w2 = CreateWorkItem(2);
ITfsWorkItem w3 = CreateWorkItem(3);
QueryDefinition qd = this.SetupFlatQuery(w1, w2, w3);
// Act
WorkItemTree ans = this.sut.QueryForWorkItems(qd, new CancellationToken());
// Assert
Assert.AreEqual <int>(3, ans.RootNodes.Count, "Incorrect number of root nodes returned");
Assert.AreEqual <int>(w1.Id, ans.RootNodes[0].WorkItem.Id);
Assert.AreEqual <int>(w2.Id, ans.RootNodes[1].WorkItem.Id);
Assert.AreEqual <int>(w3.Id, ans.RootNodes[2].WorkItem.Id);
}
public void ImportEventFromTheRibbonPresenterCreatesTheProjectPickerFromTheManagerActiveContainer()
{
// Arrange
Mock <ITeamProject> mockProject = this.SetupGoodImportDialogSequence();
WorkItemTree workItems = new WorkItemTree();
mockProject.Setup(project => project.QueryRunner.QueryForWorkItems(It.IsAny <QueryDefinition>(), It.IsAny <CancellationToken>())).Returns(workItems);
// Act
this.MockRibbonPresenter.Raise(ribbonPresenter => ribbonPresenter.Import += null, EventArgs.Empty);
// Assert
int expected = 3;
#if DEBUG
expected++;
#endif
this.MockTeamProjectDocumentManager.Verify(manager => manager.ActiveContainer, Times.Exactly(expected), "The number of times the active container is used does not reflect the number of resolutions the presenter must perform on the document-specific child container");
}
public void FlatListQueryReturnsAFlatListOfWorkItems()
{
// Arrange
QueryDefinition query = new QueryDefinition("Test", TestHelper.FlatQuery);
// Act
WorkItemTree ans = this.sut.QueryRunner.QueryForWorkItems(query, new CancellationToken());
// Assert
int count = 0;
foreach (WorkItemTreeNode node in ans.DepthFirstNodes())
{
count++;
Assert.AreEqual <int>(0, node.Level, "Flat list nodes should all be level 0");
}
Assert.IsTrue(count > 0, "The query did not return any work items");
VerifyAndDumpWorkItemTree(ans.RootNodes, 0);
}
public void TreeQueryWithDuplicateLinkIdsPassedDedupedArrayToWorkItemStoreQuery()
{
// Arrange
Tuple <int, int>[] links = new Tuple <int, int>[]
{
new Tuple <int, int>(0, 3),
new Tuple <int, int>(0, 1),
new Tuple <int, int>(0, 2),
new Tuple <int, int>(0, 1),
new Tuple <int, int>(0, 2)
};
ITfsWorkItem[] workItems = new ITfsWorkItem[] { CreateWorkItem(1), CreateWorkItem(2), CreateWorkItem(3) };
QueryDefinition qd = this.SetupTreeQuery(links, workItems);
// Act
WorkItemTree ans = this.sut.QueryForWorkItems(qd, new CancellationToken());
// Assert
this.mockQuery.Verify(q => q.WorkItemStore.Query(TestHelper.UnorderedUniqueArray <int>(1, 2, 3), It.IsAny <string>()));
}
public void TreeQueryBuildsTreeCorrectlyEvenIfWorkItemsReturnedInADifferentOrder()
{
// Arrange
Tuple <int, int>[] links = new Tuple <int, int>[]
{
new Tuple <int, int>(0, 1),
new Tuple <int, int>(0, 2),
new Tuple <int, int>(0, 3)
};
ITfsWorkItem[] workItems = new ITfsWorkItem[] { CreateWorkItem(3), CreateWorkItem(2), CreateWorkItem(1) };
QueryDefinition qd = this.SetupTreeQuery(links, workItems);
// Act
WorkItemTree ans = this.sut.QueryForWorkItems(qd, new CancellationToken());
// Assert
Assert.AreEqual <int>(3, ans.RootNodes.Count, "Incorrect number of root nodes returned");
Assert.AreEqual <int>(1, ans.RootNodes[0].WorkItem.Id);
Assert.AreEqual <int>(2, ans.RootNodes[1].WorkItem.Id);
Assert.AreEqual <int>(3, ans.RootNodes[2].WorkItem.Id);
}
public void ImportWritesProjectAndQueryAndLayoutAndWorkItemsToTheDocument()
{
// Arrange
string[] fields = new string[] { "A.B", "A.C" };
Mock <ITeamProject> mockProject = this.SetupDummyPickedProject();
Mock <ITeamProjectQuery> mockTeamProjectQuery = new Mock <ITeamProjectQuery>();
mockProject.Setup(teamProject => teamProject.QueryRunner).Returns(mockTeamProjectQuery.Object);
this.SetupDummyPickedQueryAndLayout(mockProject, fields);
WorkItemTree workItems = new WorkItemTree();
mockTeamProjectQuery.Setup(q => q.QueryForWorkItems(It.IsAny <QueryDefinition>(), It.IsAny <CancellationToken>())).Returns(workItems);
// Act
this.RunTheImport();
// Assert
this.AssertProjectInformationSaved();
this.AssertQueryAndLayoutInformationSaved();
this.AssertWorkItemsSaved(workItems, fields);
this.AssertNoErrrorsDisplayed();
}
public void DepthFirstIterationTest()
{
// Arrange
WorkItemTreeNode node0 = new WorkItemTreeNode(null, 0);
WorkItemTreeNode node0_0 = new WorkItemTreeNode(null, 1);
WorkItemTreeNode node0_0_0 = new WorkItemTreeNode(null, 2);
WorkItemTreeNode node0_0_1 = new WorkItemTreeNode(null, 2);
WorkItemTreeNode node1 = new WorkItemTreeNode(null, 0);
WorkItemTreeNode node1_0 = new WorkItemTreeNode(null, 0);
node0.Children.Add(node0_0);
node0_0.Children.Add(node0_0_0);
node0_0.Children.Add(node0_0_1);
node1.Children.Add(node1_0);
WorkItemTree sut = new WorkItemTree();
sut.RootNodes.Add(node0);
sut.RootNodes.Add(node1);
// Act
IEnumerator <WorkItemTreeNode> e = sut.DepthFirstNodes().GetEnumerator();
// Assert
Assert.IsTrue(e.MoveNext());
Assert.AreSame(node0, e.Current);
Assert.IsTrue(e.MoveNext());
Assert.AreSame(node0_0, e.Current);
Assert.IsTrue(e.MoveNext());
Assert.AreSame(node0_0_0, e.Current);
Assert.IsTrue(e.MoveNext());
Assert.AreSame(node0_0_1, e.Current);
Assert.IsTrue(e.MoveNext());
Assert.AreSame(node1, e.Current);
Assert.IsTrue(e.MoveNext());
Assert.AreSame(node1_0, e.Current);
}
/// <summary>
/// Asserts that work items were saved.
/// </summary>
/// <param name="workItems">The work items that are expected to have been saved.</param>
/// <param name="fields">The fields to be included in the list of fields saved.</param>
protected void AssertWorkItemsSaved(WorkItemTree workItems, string[] fields)
{
this.MockTeamProjectDocument.Verify(document => document.SaveWorkItems(workItems, fields, It.IsAny <CancellationToken>()), Times.Once());
}
private void HandleTeamRibbonImport(object sender, System.EventArgs e)
{
this.Logger.Log(TraceEventType.Information, "Flow controller HandleTeamRibbonImport called");
Debug.Assert(this.Manager.ActiveContainer != null, "There should be an active container in the team project document manager");
Debug.Assert(this.Manager.ActiveDocument != null, "There should be an active document in the team project document manager");
ITeamProject teamProject = null;
ITeamProjectPickerPresenter projectPickerPresenter = null;
if (!this.Manager.ActiveDocument.IsInsertable)
{
this.TeamRibbonPresenter.DisplayError(FlowControllerResources.DocumentNotInsertable, string.Empty);
}
else if (!this.Manager.ActiveDocument.IsConnected)
{
projectPickerPresenter = this.Manager.ActiveContainer.Resolve <ITeamProjectPickerPresenter>();
teamProject = projectPickerPresenter.ChooseTeamProject();
}
else
{
teamProject = this.Manager.ActiveDocument.TeamProject;
}
if (teamProject != null)
{
this.Manager.ActiveContainer.RegisterInstance <ITeamProject>(teamProject);
IWorkItemQueryAndLayoutPickerWizardPresenter workItemAndLayoutPickerWizardPresenter = this.Manager.ActiveContainer.Resolve <IWorkItemQueryAndLayoutPickerWizardPresenter>();
workItemAndLayoutPickerWizardPresenter.Initialise();
workItemAndLayoutPickerWizardPresenter.Start();
QueryAndLayoutInformation queryAndLayout = workItemAndLayoutPickerWizardPresenter.QueryAndLayout;
if (queryAndLayout != null)
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
TaskScheduler scheduler = this.UnityContainer.Resolve <TaskScheduler>();
Task <WorkItemTree> runQueryTask = new Task <WorkItemTree>(
() =>
{
this.Logger.Log(TraceEventType.Information, "Starting query for work items");
WorkItemTree ans = teamProject.QueryRunner.QueryForWorkItems(queryAndLayout.Query, cancellationTokenSource.Token);
this.Logger.Log(TraceEventType.Information, "Finished querying for work items");
return(ans);
},
cancellationTokenSource.Token);
Task queryErrorTask = runQueryTask.ContinueWith(
antecedent =>
{
this.Logger.Log(TraceEventType.Error, "Query execution failed: {0}", antecedent.Exception.InnerException.Message);
},
cancellationTokenSource.Token,
TaskContinuationOptions.OnlyOnFaulted,
scheduler);
Task queryDoneTask = runQueryTask.ContinueWith(
(antecedent) =>
{
this.Logger.Log(TraceEventType.Information, "Adding work items to document");
this.TeamRibbonPresenter.UpdateCancellableOperation(
FlowControllerResources.AddingWorkItemsToDocument);
if (projectPickerPresenter != null)
{
projectPickerPresenter.SaveTeamProject();
}
workItemAndLayoutPickerWizardPresenter.SaveQueryAndLayout();
this.Manager.ActiveDocument.SaveWorkItems(antecedent.Result, queryAndLayout.Layout.FieldNames.ToArray(), cancellationTokenSource.Token);
this.Manager.ActiveDocument.MapWorkItemsIntoDocument(queryAndLayout.Layout, queryAndLayout.Index, cancellationTokenSource.Token);
this.Logger.Log(TraceEventType.Information, "Finished adding work items to document");
},
cancellationTokenSource.Token,
TaskContinuationOptions.OnlyOnRanToCompletion,
scheduler);
this.AddFinalErrorHandlingTask(scheduler, runQueryTask, queryErrorTask, queryDoneTask);
runQueryTask.Start(scheduler);
this.TeamRibbonPresenter.StartCancellableOperation(FlowControllerResources.StartQueryExecution, cancellationTokenSource);
}
}
this.TeamRibbonPresenter.UpdateState();
}
