/// <summary>
/// Removes the test case internal.
/// </summary>
/// <param name="testCaseToRemove">The test case to be removed.</param>
/// <param name="suitesToSearch">The suites which will be searched.</param>
private static void RemoveTestCaseInternal(ITestCase testCaseToRemove, ITestSuiteCollection suitesToSearch)
{
foreach (ITestSuiteBase currentSuite in suitesToSearch)
{
if (currentSuite != null)
{
if (currentSuite is IRequirementTestSuite)
{
IRequirementTestSuite suite = currentSuite as IRequirementTestSuite;
if (suite.TestCases.Where(x => x.Id.Equals(testCaseToRemove.Id)).ToList().Count == 0)
{
suite.TestCases.RemoveEntries(new List <ITestSuiteEntry>()
{
testCaseToRemove.TestSuiteEntry
});
}
}
else if (currentSuite is IStaticTestSuite)
{
foreach (var currentTestCase in currentSuite.TestCases)
{
if (currentTestCase.Id.Equals(testCaseToRemove.Id))
{
((IStaticTestSuite)currentSuite).Entries.Remove(testCaseToRemove);
}
}
IStaticTestSuite suite1 = currentSuite as IStaticTestSuite;
if (suite1 != null && (suite1.SubSuites.Count > 0))
{
RemoveTestCaseInternal(testCaseToRemove, suite1.SubSuites);
}
}
}
}
}
public void AddTestCasesToSuite(IEnumerable <ITestCase> testCases, ITestSuiteBase destinationSuite)
{
if (destinationSuite.TestSuiteType == TestSuiteType.StaticTestSuite)
{
IStaticTestSuite staticTestSuite = destinationSuite as IStaticTestSuite;
if (staticTestSuite != null)
{
staticTestSuite.Entries.AddCases(testCases);
}
}
else if (destinationSuite.TestSuiteType == TestSuiteType.RequirementTestSuite)
{
IRequirementTestSuite requirementTestSuite = destinationSuite as IRequirementTestSuite;
if (requirementTestSuite != null)
{
WorkItemStore store = requirementTestSuite.Project.WitProject.Store;
WorkItem tfsRequirement = store.GetWorkItem(requirementTestSuite.RequirementId);
foreach (ITestCase testCase in testCases)
{
tfsRequirement.Links.Add(new RelatedLink(store.WorkItemLinkTypes.LinkTypeEnds["Tested By"],
testCase.WorkItem.Id));
}
tfsRequirement.Save();
}
}
destinationSuite.Plan.Save();
}
void WriteRootSuite(IRequirementTestSuite testSuite, XmlDocument xmlDoc)
{
XmlNode rootNode = xmlDoc.CreateElement("suite");
xmlDoc.AppendChild(rootNode);
XmlNode idNode = xmlDoc.CreateElement("id");
rootNode.AppendChild(idNode);
XmlNode rootnameNode = xmlDoc.CreateElement("name");
rootnameNode.InnerText = testSuite.Plan.Name;
rootNode.AppendChild(rootnameNode);
XmlNode rootdescNode = xmlDoc.CreateElement("description");
rootdescNode.InnerText = testSuite.Plan.Description;
rootNode.AppendChild(rootdescNode);
XmlNode sectionsNode = xmlDoc.CreateElement("sections");
rootNode.AppendChild(sectionsNode);
GetTestCases(testSuite, xmlDoc, sectionsNode);
}
/// <summary>
/// Initializes a new instance of the <see cref="TfsTestSuite"/> class.
/// </summary>
/// <param name="testSuite">The test suite.</param>
/// <param name="associatedTestPlan">The associated test plan.</param>
public TfsTestSuite(IRequirementTestSuite testSuite, ITfsTestPlan associatedTestPlan)
{
AssociatedTestPlan = associatedTestPlan;
OriginalRequirementTestSuite = testSuite;
Id = OriginalRequirementTestSuite.Id;
Title = OriginalRequirementTestSuite.Title;
InitializeChildSuites();
}
/// <summary>
/// Pastes the test cases to suite.
/// </summary>
/// <param name="testManagementTeamProject">The test management team project.</param>
/// <param name="testPlan">The test plan.</param>
/// <param name="suiteToAddInId">The suite automatic add information unique identifier.</param>
/// <param name="clipBoardTestCase">The clip board test case.</param>
/// <exception cref="System.ArgumentException">New test cases cannot be added to requirement based suites!</exception>
public static void PasteTestCasesToSuite(ITestManagementTeamProject testManagementTeamProject, ITestPlan testPlan, int suiteToAddInId, ClipBoardTestCase clipBoardTestCase)
{
ITestSuiteBase suiteToAddIn = testManagementTeamProject.TestSuites.Find(suiteToAddInId);
if (suiteToAddIn is IRequirementTestSuite)
{
throw new ArgumentException("New test cases cannot be added to requirement based suites!");
}
IStaticTestSuite suiteToAddInStatic = suiteToAddIn as IStaticTestSuite;
ITestSuiteBase oldSuite;
List <TestCase> allTestCasesInPlan = null;
if (clipBoardTestCase.TestCases[0].TestSuiteId != null)
{
oldSuite = testManagementTeamProject.TestSuites.Find((int)clipBoardTestCase.TestCases[0].TestSuiteId);
}
else
{
oldSuite = null;
}
foreach (TestCase currentTestCase in clipBoardTestCase.TestCases)
{
ITestCase testCaseCore = null;
if (oldSuite is IRequirementTestSuite)
{
IRequirementTestSuite suite = oldSuite as IRequirementTestSuite;
testCaseCore = suite.TestCases.Where(x => x.TestCase != null && x.TestCase.Id.Equals(currentTestCase.TestCaseId)).FirstOrDefault().TestCase;
}
else if (oldSuite is IStaticTestSuite)
{
IStaticTestSuite suite = oldSuite as IStaticTestSuite;
testCaseCore = suite.Entries.Where(x => x.TestCase != null && x.TestCase.Id.Equals(currentTestCase.TestCaseId)).FirstOrDefault().TestCase;
}
else if (oldSuite == null)
{
if (allTestCasesInPlan == null)
{
allTestCasesInPlan = TestCaseManager.GetAllTestCasesInTestPlan(testManagementTeamProject, testPlan);
}
testCaseCore = allTestCasesInPlan.Where(t => t.TestCaseId.Equals(currentTestCase.TestCaseId)).FirstOrDefault().ITestCase;
}
if (!suiteToAddInStatic.Entries.Contains(testCaseCore))
{
suiteToAddInStatic.Entries.Add(testCaseCore);
}
if (clipBoardTestCase.ClipBoardCommand.Equals(ClipBoardCommand.Cut))
{
if (oldSuite is IStaticTestSuite)
{
IStaticTestSuite suite = oldSuite as IStaticTestSuite;
suite.Entries.Remove(testCaseCore);
}
}
}
testPlan.Save();
}
private void GetTestCases(IRequirementTestSuite requirementTestSuite, XmlDocument xmlDoc, XmlNode node) //sectionsNode has to be "sections"
{
var casesNode = WriteSuite(requirementTestSuite, xmlDoc, node); //WriteSuite sectionsNode has to be "sections"
foreach (var testCase in requirementTestSuite.AllTestCases)
{
var caseNode = WriteTestCase(testCase, xmlDoc);
casesNode.AppendChild(caseNode);
}
}
private void GetTestCases(IRequirementTestSuite requirementTestSuite, ExcelWorksheet worksheet)
{
WriteSuiteToExcel(requirementTestSuite, worksheet);
_i++;
foreach (var testCase in requirementTestSuite.AllTestCases)
{
WriteTestCaseToExcel(testCase, worksheet, _testProject);
_i++;
}
}
private List <TestObjectViewModel> RecursiveSuiteCollector(TestObjectViewModel item, ITestSuiteBase suite,
List <TestObjectViewModel> selectedItems)
{
IStaticTestSuite staticSuite = null;
IDynamicTestSuite dynamicSuite = null;
IRequirementTestSuite requirmentSuite = null;
ITestSuiteBase suiteBase = TfsShared.Instance.SourceTestProject.TestSuites.Find(item.ID);
if (suiteBase.TestSuiteType == TestSuiteType.StaticTestSuite)
{
staticSuite = (IStaticTestSuite)suiteBase;
if (item.IsChecked)
{
selectedItems.AddRange(staticSuite.TestCases.Select(test => new TestObjectViewModel(test)
{
TestSuiteId = suite.Id
}));
if (staticSuite.SubSuites.Count > 0)
{
foreach (ITestSuiteBase subSuite in staticSuite.SubSuites)
{
var children = item.Children.Where(t => t.ID > 0 && t.ID == subSuite.Id);
if (children.Count() > 0)
{
RecursiveSuiteCollector(children.First(), subSuite, selectedItems);
}
}
}
}
}
else if ((suite.TestSuiteType == TestSuiteType.DynamicTestSuite) && (item.IsChecked))
{
dynamicSuite = (IDynamicTestSuite)suite;
selectedItems.AddRange(dynamicSuite.TestCases.Select(test => new TestObjectViewModel(test)
{
TestSuiteId = suite.Id
}));
}
else if ((suite.TestSuiteType == TestSuiteType.RequirementTestSuite) && (item.IsChecked))
{
requirmentSuite = (IRequirementTestSuite)suite;
selectedItems.AddRange(requirmentSuite.TestCases.Select(test => new TestObjectViewModel(test)
{
TestSuiteId = suite.Id
}));
}
return(selectedItems);
}
void WriteSuiteToExcel(IRequirementTestSuite testSuite, ExcelWorksheet worksheet)
{
worksheet.Cells[_i, 1].Style.Fill.PatternType = ExcelFillStyle.Solid;
worksheet.Cells[_i, 1].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
worksheet.Cells[_i, 1].Style.Font.Bold = true;
worksheet.Cells[_i, 2].Style.Fill.PatternType = ExcelFillStyle.Solid;
worksheet.Cells[_i, 2].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
worksheet.Cells[_i, 3].Style.Fill.PatternType = ExcelFillStyle.Solid;
worksheet.Cells[_i, 3].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
worksheet.Cells[_i, 4].Style.Fill.PatternType = ExcelFillStyle.Solid;
worksheet.Cells[_i, 4].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
worksheet.Cells[_i, 5].Style.Fill.PatternType = ExcelFillStyle.Solid;
worksheet.Cells[_i, 5].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
worksheet.Cells[_i, 6].Style.Fill.PatternType = ExcelFillStyle.Solid;
worksheet.Cells[_i, 6].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
//worksheet.Cells[_i, 1].Value = FindRootSuite(testSuite, testSuite.Title);
}
static string FindRootSuite(IRequirementTestSuite currentSuite, string suiteTreePath)
{
var parentSuite = currentSuite.Parent;
if (parentSuite == null)
{
return(suiteTreePath);
}
if (parentSuite.IsRoot)
{
return(suiteTreePath);
}
suiteTreePath = currentSuite.Parent.Title + ">" + suiteTreePath;
var path = FindRootSuite(parentSuite, suiteTreePath);
return(path);
}
XmlNode WriteSuite(IRequirementTestSuite testSuite, XmlDocument xmlDoc, XmlNode node) //sectionsNode has to be "sections"
{
XmlNode sectionNode = xmlDoc.CreateElement("section");
node.AppendChild(sectionNode);
XmlNode nameNode = xmlDoc.CreateElement("name");
nameNode.InnerText = testSuite.Title;
sectionNode.AppendChild(nameNode);
XmlNode descNode = xmlDoc.CreateElement("description");
sectionNode.AppendChild(descNode);
XmlNode casesNode = xmlDoc.CreateElement("cases");
sectionNode.AppendChild(casesNode);
return(casesNode);
}
/// <summary>
/// Removes the test case internal.
/// </summary>
/// <param name="testCaseToRemove">The test case automatic remove.</param>
/// <param name="currentSuite">The current suite.</param>
private static void RemoveTestCaseInternal(ITestCase testCaseToRemove, ITestSuiteBase currentSuite)
{
if (currentSuite != null)
{
log.InfoFormat("Remove Test Case with id= {0}, Title = {1} from Suite with id= {2}, Title= {3}", testCaseToRemove.Id, testCaseToRemove.Title, currentSuite.Id, currentSuite.Title);
if (currentSuite is IRequirementTestSuite)
{
IRequirementTestSuite suite = currentSuite as IRequirementTestSuite;
suite.AllTestCases.Remove(testCaseToRemove);
suite.TestCases.RemoveCases(new List <ITestCase>()
{
testCaseToRemove
});
}
else if (currentSuite is IStaticTestSuite)
{
IStaticTestSuite suite = currentSuite as IStaticTestSuite;
suite.Entries.Remove(testCaseToRemove);
}
}
}
/// <summary>
/// Adds a test case to the suite.
/// </summary>
/// <param name="currentSuite">The current suite.</param>
/// <param name="testCaseToAdd">The test case to be added.</param>
public static void AddTestCase(this ITestSuiteBase currentSuite, ITestCase testCaseToAdd)
{
if (currentSuite is IRequirementTestSuite)
{
IRequirementTestSuite suite = currentSuite as IRequirementTestSuite;
if (suite.TestCases.Where(x => x.Id.Equals(testCaseToAdd.Id)).ToList().Count == 0)
{
suite.TestCases.AddCases(new List <ITestCase>()
{
testCaseToAdd
});
}
}
else if (currentSuite is IStaticTestSuite)
{
IStaticTestSuite suite = currentSuite as IStaticTestSuite;
if (suite.Entries.Where(x => x.Id.Equals(testCaseToAdd.Id)).ToList().Count == 0)
{
suite.Entries.Add(testCaseToAdd);
}
}
}
private async Task DuplicateTestCases(List <TestObjectViewModel> selectedItems, bool duplicate)
{
await Task.Factory.StartNew(() =>
{
TestObjectViewModel selectedSuite = null;
selectedSuite = HasSelectedItem(_mappingViewModel.TestPlans, selectedSuite);
ITestPlan plan =
TfsShared.Instance.TargetTestProject.TestPlans.Find(selectedSuite._testObject.TestPlanID);
try
{
foreach (TestObjectViewModel test in selectedItems)
{
var parentTestSuites = new Stack();
ITestSuiteBase sourceSuite =
TfsShared.Instance.SourceTestProject.TestSuites.Find(test.TestSuiteId);
ITestCase testCase = TfsShared.Instance.SourceTestProject.TestCases.Find(test.ID);
WorkItem targetWorkItem = null;
#region Create duplicate test cases
if (duplicate)
{
WorkItem duplicateWorkItem = null;
//if (!DuplicatedTestCase.Any(t => t.OldID.Equals(test.ID)))
//{
if ((sourceSuite.TestSuiteType != TestSuiteType.RequirementTestSuite) && (sourceSuite.TestSuiteType != TestSuiteType.DynamicTestSuite))
{
duplicateWorkItem = testCase.WorkItem.Copy(TfsShared.Instance.TargetProjectWorkItemType,
WorkItemCopyFlags.CopyFiles);
//duplicateWorkItem.WorkItemLinks.Clear();
if (!duplicateWorkItem.IsValid())
{
Logger = "Cannot Save Work Item - Stoping Migration\n" + Logger;
ArrayList badFields = duplicateWorkItem.Validate();
foreach (Field field in badFields)
{
Logger =
string.Format("Name: {0}, Reference Name: {1}, Invalid Value: {2}\n",
field.Name, field.ReferenceName, field.Value) + Logger;
}
break;
}
else
{
duplicateWorkItem.Save();
//App.Current.Dispatcher.Invoke(() =>
//{
// DuplicatedTestCase.Add(new TestCaseOldNewMapping()
// {
// OldID = testCase.Id,
// NewID = duplicateWorkItem.Id
// });
//});
Logger =
string.Format("Duplicate Test Case: {0} completed, new Test Case ID: {1}\n",
test.ID,
duplicateWorkItem.Id) + Logger;
}
}
//}
//else
//{
// TestCaseOldNewMapping mapping =
// DuplicatedTestCase.FirstOrDefault(t => t.OldID.Equals(test.ID));
// if (mapping == null) throw new NullReferenceException("Cannot locate new id");
// duplicateWorkItem =
// TfsShared.Instance.TargetTestProject.TestCases.Find(mapping.NewID).WorkItem;
// Logger =
// string.Format("Test Case: {0} already exists, Test Case ID: {1}\n", test.ID,
// duplicateWorkItem.Id) + Logger;
//}
targetWorkItem = duplicateWorkItem;
}
else
{
targetWorkItem = testCase.WorkItem;
}
#endregion
ITestSuiteBase suite = sourceSuite;
while (suite != null)
{
parentTestSuites.Push(suite);
suite = suite.TestSuiteEntry.ParentTestSuite;
}
parentTestSuites.Pop(); //Source tree parent suites
var parentSuite = (IStaticTestSuite)selectedSuite._testObject.TestSuiteBase; //Selected target suite
bool isTestCaseParentRequirementTestSuite = false;
bool isTestCaseParentDynamicTestSuite = false;
foreach (ITestSuiteBase testSuite in parentTestSuites)
{
ITestSuiteBase existingSuite = null;
isTestCaseParentRequirementTestSuite = false;
isTestCaseParentDynamicTestSuite = false;
if (testSuite.TestSuiteType == TestSuiteType.RequirementTestSuite)
{
isTestCaseParentRequirementTestSuite = true;
}
if (testSuite.TestSuiteType == TestSuiteType.DynamicTestSuite)
{
isTestCaseParentDynamicTestSuite = true;
}
if (parentSuite.Title.Equals(testSuite.Title))
{
existingSuite = parentSuite;
}
else if (parentSuite.SubSuites.FirstOrDefault(t => t.Title.Equals(testSuite.Title)) != null)
{
var subSuite = parentSuite.SubSuites.FirstOrDefault(t => t.Title.Equals(testSuite.Title));
if (subSuite.TestSuiteType == TestSuiteType.StaticTestSuite)
{
parentSuite = (IStaticTestSuite)parentSuite.SubSuites.FirstOrDefault(t => t.Title.Equals(testSuite.Title));
}
continue;
}
if (existingSuite == null)
{
Logger = "Creating new suite called - " + testSuite.Title + "\n" + Logger;
#region New Feature
switch (testSuite.TestSuiteType)
{
case TestSuiteType.RequirementTestSuite:
var store = ((IRequirementTestSuite)testSuite).Project.WitProject.Store;
var tfsRequirement = store.GetWorkItem(((IRequirementTestSuite)testSuite).RequirementId);
IRequirementTestSuite newRequirementSuite = TfsShared.Instance.TargetTestProject.TestSuites.CreateRequirement(tfsRequirement);
newRequirementSuite.Title = testSuite.Title;
newRequirementSuite.Description = testSuite.Description;
newRequirementSuite.State = testSuite.State;
tfsRequirement.Save();
parentSuite.Entries.Add(newRequirementSuite);
break;
case TestSuiteType.StaticTestSuite:
IStaticTestSuite newStaticSuite = TfsShared.Instance.TargetTestProject.TestSuites.CreateStatic();
newStaticSuite.Title = testSuite.Title;
newStaticSuite.State = testSuite.State;
newStaticSuite.Description = testSuite.Description;
parentSuite.Entries.Add(newStaticSuite);
parentSuite = newStaticSuite;
break;
case TestSuiteType.DynamicTestSuite:
IDynamicTestSuite newDynamicSuite = TfsShared.Instance.TargetTestProject.TestSuites.CreateDynamic();
newDynamicSuite.Query = TfsShared.Instance.TargetTestProject.CreateTestQuery(((IDynamicTestSuite)testSuite).Query.QueryText);
newDynamicSuite.Title = testSuite.Title;
newDynamicSuite.State = testSuite.State;
newDynamicSuite.Description = testSuite.Description;
parentSuite.Entries.Add(newDynamicSuite);
break;
}
#endregion
}
else
{
Logger = string.Format("Suite '{0}' already exists.\n{1}", existingSuite.Title, Logger);
}
plan.Save();
}
if ((parentSuite.TestSuiteType == TestSuiteType.StaticTestSuite) && (isTestCaseParentRequirementTestSuite == false) && (isTestCaseParentDynamicTestSuite == false))
{
ITestCase targetTestCase =
TfsShared.Instance.TargetTestProject.TestCases.Find(targetWorkItem.Id);
if (!parentSuite.Entries.Contains(targetTestCase))
{
ITestSuiteEntry entry = parentSuite.Entries.Add(targetTestCase);
entry.Configurations.Add(test.Configuration);
Logger = "Adding duplicated test case completed.\n" + Logger;
}
}
}
}
catch (Exception ex)
{
Logger = string.Format("** ERROR ** : {0}\n", ex.Message) + Logger;
}
});
}
public void CreateSprint1TestPlan()
{
TfsTeamProjectCollection tpc = TfsConnect();
ITestManagementTeamProject project = tpc.GetService <ITestManagementService>().GetTeamProject(TeamProject);
// Create test plan if none exist
//
// See http://bit.ly/2dup2XY for why we can't delete Test Plans or Suites at this point in time
//
// If this routine isn't creating the test plan and/or test suites for you, you'll need to manually
// delete the Test Plan and Test Suites using witadmin
WorkItemStore store = new WorkItemStore(tpc);
string wiql = "SELECT [System.Id] FROM WorkItems " + "WHERE [System.TeamProject] = '" + TeamProject + "' AND [System.WorkItemType] ='Test Plan' AND [System.Title] = 'Sprint 1'";
WorkItemCollection workItems = store.Query(wiql);
int testPlanCount = workItems.Count;
wiql = "SELECT [System.Id] FROM WorkItems " + "WHERE [System.TeamProject] = '" + TeamProject + "' AND [System.WorkItemType] ='Test Suite'";
int testSuiteCount = store.Query(wiql).Count;
ITestPlan testPlan;
if (testPlanCount == 0)
{
testPlan = project.TestPlans.Create();
testPlan.Name = "Sprint 1";
testPlan.Iteration = @"Fabrikam\Release 1\Sprint 1";
testPlan.Save();
Console.WriteLine(" . (1 plan created)");
}
else
{
testPlan = project.TestPlans.Find(workItems[0].Id);
Console.WriteLine(" . (plan exists)");
}
// Create Test Suites if non exist
if (testSuiteCount <= 10) // May create duplicate test suites
{
Console.Write(" Creating sprint 1 test suites ");
// suites
int count = 0;
IStaticTestSuite staticSuite = project.TestSuites.CreateStatic();
staticSuite.Title = "Automated";
testPlan.RootSuite.Entries.Add(staticSuite);
testPlan.Save();
Console.Write(".");
count++;
staticSuite = project.TestSuites.CreateStatic();
staticSuite.Title = "Regression";
testPlan.RootSuite.Entries.Add(staticSuite);
testPlan.Save();
Console.Write(".");
count++;
// Requirement-based suites
// Get PBI work items
wiql = "SELECT [System.Id] FROM WorkItems " + "WHERE [System.TeamProject] = '" + TeamProject + "' AND [System.WorkItemType] ='Product Backlog Item'";
workItems = store.Query(wiql);
for (int i = 0; i < workItems.Count; i++)
{
WorkItem pbi = workItems[i];
// Link Test Case to PBI
int testCaseID = (int)TestCases[pbi.Title.ToLower()];
WorkItemLinkTypeEnd testedByLink = store.WorkItemLinkTypes.LinkTypeEnds["Tested By"];
pbi.WorkItemLinks.Add(new WorkItemLink(testedByLink, testCaseID));
pbi.Save();
// Create Requirement-based test suite
IRequirementTestSuite reqSuite = project.TestSuites.CreateRequirement(pbi);
reqSuite.Title = pbi.Title;
testPlan.RootSuite.Entries.Add(reqSuite);
testPlan.Save();
Console.Write(".");
count++;
}
// Query-based suites
IDynamicTestSuite querySuite = project.TestSuites.CreateDynamic();
querySuite.Title = "UI Tests";
querySuite.Query = project.CreateTestQuery(@"SELECT [System.Id],[System.WorkItemType],[System.Title],[Microsoft.VSTS.Common.Priority],[System.AssignedTo],[System.AreaPath] FROM WorkItems WHERE [System.TeamProject] = @project AND [System.WorkItemType] IN GROUP 'Microsoft.TestCaseCategory' AND [System.AreaPath] UNDER 'Fabrikam' AND [System.IterationPath] UNDER 'Fabrikam\Release 1\Sprint 1' AND [System.Title] CONTAINS 'ui'");
testPlan.RootSuite.Entries.Add(querySuite);
testPlan.Save();
Console.Write(".");
count++;
querySuite = project.TestSuites.CreateDynamic();
querySuite.Title = "Bug Existence Tests";
querySuite.Query = project.CreateTestQuery(@"SELECT [System.Id],[System.WorkItemType],[System.Title],[Microsoft.VSTS.Common.Priority],[System.AssignedTo],[System.AreaPath] FROM WorkItems WHERE [System.TeamProject] = @project AND [System.WorkItemType] IN GROUP 'Microsoft.TestCaseCategory' AND [System.AreaPath] UNDER 'Fabrikam' AND [System.IterationPath] UNDER 'Fabrikam\Release 1\Sprint 1' AND [System.Title] CONTAINS 'bug'");
testPlan.RootSuite.Entries.Add(querySuite);
testPlan.Save();
Console.Write(".");
count++;
Console.WriteLine(string.Format(" ({0} suites created)", count));
}
}
