public void CreateRegressionPlanTest()
{
var regressionPlan = EntityFactory.Create(() => SandboxProject.CreateRegressionPlan(RegressionPlanName));
Assert.AreEqual(SandboxProject, regressionPlan.Project);
Assert.AreEqual(RegressionPlanName, regressionPlan.Name);
}
public void NoThemeAmongWorkitems()
{
var theme = SandboxProject.CreateTheme("A Theme");
ResetInstance();
CollectionAssert.DoesNotContain(DeriveListOfNamesFromAssets(Instance.Get.Workitems(null)), theme.Name);
}
public void Build()
{
const string buildNumber = "10.2.24.1";
var story = SandboxProject.CreateStory("Build Filter");
var task = story.CreateTask("Build Filter");
task.Build = buildNumber;
task.Save();
var not = story.CreateTask("Doesn't match");
ResetInstance();
var filter = new TaskFilter();
filter.Build.Add(buildNumber);
var results = SandboxProject.GetTasks(filter);
Assert.IsTrue(FindRelated(task, results), "Expected to find task that matched filter.");
Assert.IsFalse(FindRelated(not, results), "Expected to NOT find task that doesn't match filter.");
foreach (var result in results)
{
Assert.AreEqual(buildNumber, result.Build);
}
}
public void ActualsWithDateAndMember()
{
Story story = null;
try {
var member = Instance.Get.MemberByID("Member:20");
story = SandboxProject.CreateStory("ActualsWithDateAndMember 2");
var actual = story.CreateEffort(member, new DateTime(2007, 1, 1), 10);
string storyID = story.ID;
string actualID = actual.ID;
ResetInstance();
var newStory = Instance.Get.StoryByID(storyID);
var newActual = Instance.Get.EffortByID(actualID);
var newMember = Instance.Get.MemberByID("Member:20");
Assert.AreEqual(10, newActual.Value);
Assert.AreEqual(newStory, newActual.Workitem);
Assert.AreEqual(new DateTime(2007, 1, 1), newActual.Date);
Assert.AreEqual(newMember, newActual.Member);
} finally {
if (story != null)
{
story.Delete();
}
}
}
public void DoubleEffortEntry()
{
const string storyName = "DoubleEffortEntryStoryTest";
const string taskName = "DoubleEffortEntryTaskTest";
if (!Instance.ApiClient.V1Config.EffortTracking)
{
Assert.Fail("Effort tracking is not enabled.");
}
if (Instance.ApiClient.V1Config.StoryTrackingLevel == APIClient.TrackingLevel.On)
{
Assert.Fail("Task effort tracking is not enabled.");
}
var member = Instance.Get.MemberByID("Member:20");
var story = SandboxProject.CreateStory(storyName);
var task = story.CreateTask(taskName);
task.CreateEffort(member, DateTime.Now, 1.0);
var effortRecords = task.GetEffortRecords(null);
var actual = effortRecords.Aggregate(0.0, (current, effortRecord) => current + effortRecord.Value);
Assert.AreEqual(1.0, actual);
story.Delete();
}
public void ProjectTotalToDo()
{
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
var task1 = storyA.CreateTask("Task 1");
task1.ToDo = 5;
defectB.ToDo = 10;
task1.Save();
defectB.Save();
var rogue = SandboxProject.CreateDefect("Rogue");
rogue.ToDo = 13.37;
rogue.Save();
rogue.Delete();
Assert.AreEqual(15, SandboxProject.GetTotalToDo(null));
Assert.AreEqual(15, SandboxProject.GetTotalToDo(new WorkitemFilter()));
Assert.AreEqual(10, SandboxProject.GetTotalToDo(new PrimaryWorkitemFilter()));
Assert.AreEqual(null, SandboxProject.GetTotalToDo(new StoryFilter()));
Assert.AreEqual(10, SandboxProject.GetTotalToDo(new DefectFilter()));
Assert.AreEqual(5, SandboxProject.GetTotalToDo(new SecondaryWorkitemFilter()));
Assert.AreEqual(5, SandboxProject.GetTotalToDo(new TaskFilter()));
Assert.AreEqual(null, SandboxProject.GetTotalToDo(new TestFilter()));
}
public void StoryOrder()
{
var story1 = SandboxProject.CreateStory("StoryOrder 1");
var story2 = SandboxProject.CreateStory("StoryOrder 2");
var id1 = story1.ID;
var id2 = story2.ID;
story1.RankOrder.SetBelow(story2);
Assert.IsTrue(story1.RankOrder.IsBelow(story2));
Assert.IsTrue(story2.RankOrder.IsAbove(story1));
ResetInstance();
story1 = Instance.Get.StoryByID(id1);
story2 = Instance.Get.StoryByID(id2);
story1.RankOrder.SetAbove(story2);
Assert.IsTrue(story1.RankOrder.IsAbove(story2));
Assert.IsTrue(story2.RankOrder.IsBelow(story1));
story1.Delete();
story2.Delete();
}
public void Customer()
{
var customer = Instance.Members.FirstOrDefault();
var story = SandboxProject.CreateStory("Customer filter");
story.Customer = customer;
story.Save();
ResetInstance();
story = Instance.Get.StoryByID(story.ID);
customer = Instance.Get.MemberByID(customer.ID);
var filter = GetFilter();
filter.Customer.Add(customer);
var results = SandboxProject.GetStories(filter);
Assert.IsTrue(FindRelated(story, results), "Expected to find story that matched filter.");
foreach (var result in results)
{
Assert.AreEqual(customer, result.Customer);
}
}
public void NoEpicAmongStories()
{
var epic = SandboxProject.CreateEpic("War And Piece");
ResetInstance();
CollectionAssert.DoesNotContain(DeriveListOfNamesFromAssets(Instance.Get.Stories(null)), epic.Name);
}
[Test] public void SimpleAttributeHelpers()
{
Story story = SandboxProject.CreateStory("Custom Attribute Helpers");
DateTime expectedBirthday = DateTime.Now.Date;
story.CustomField["ShoeSize"] = 11.5;
story.CustomField["Freckles"] = true;
story.CustomField["Hometown"] = "Pierre Part";
story.CustomField["Birthday"] = expectedBirthday;
story.Save();
ResetInstance();
story = Instance.Get.StoryByID(story.ID);
double?shoeSize = story.CustomField.GetNumeric("ShoeSize");
Assert.AreEqual(11.5, shoeSize);
bool?hasFreckles = story.CustomField.GetBool("Freckles");
Assert.IsTrue(hasFreckles.Value);
DateTime?birthday = story.CustomField.GetDate("Birthday");
Assert.AreEqual(expectedBirthday, birthday.Value);
string hometown = story.CustomField.GetString("Hometown");
Assert.AreEqual("Pierre Part", hometown);
}
public void CreateResponse()
{
Note note = SandboxProject.CreateNote("New Note", "This is a new Note", false);
string noteId = note.ID;
Note response = note.CreateResponse("A Response", "Back to you", true);
string responseID = response.ID;
ResetInstance();
note = Instance.Get.NoteByID(noteId);
response = Instance.Get.NoteByID(responseID);
Assert.IsTrue(note.Responses.Contains(response));
Assert.AreEqual("A Response", response.Name);
Assert.AreEqual("Back to you", response.Content);
Assert.IsTrue(response.Personal);
Assert.AreEqual(note, response.InResponseTo);
ICollection <Note> notes = SandboxProject.GetNotes(null);
Assert.IsTrue(notes.Contains(note));
Assert.IsTrue(notes.Contains(response));
}
public void Type()
{
var story = EntityFactory.CreateStory("Type Filter", SandboxProject);
var test = EntityFactory.CreateTest("Type Filter", story);
var taskType = test.Type.AllValues[0];
test.Type.CurrentValue = taskType;
test.Save();
var not = EntityFactory.CreateTest("Doesn't match", story);
ResetInstance();
var filter = new TestFilter();
filter.Type.Add(taskType);
var results = SandboxProject.GetTests(filter);
Assert.IsTrue(FindRelated(test, results), "Expected to find test that matched filter.");
Assert.IsFalse(FindRelated(not, results), "Expected to NOT find test that doesn't match filter.");
foreach (var result in results)
{
Assert.AreEqual(taskType, result.Type.CurrentValue);
}
}
public void AssignTeamToStory()
{
var team = Instance.Create.Team("Bears");
var teamStory = SandboxProject.CreateStory("For Team");
teamStory.Team = team;
teamStory.Save();
ResetInstance();
team = Instance.Get.TeamByID(team.ID);
teamStory = Instance.Get.StoryByID(teamStory.ID);
var included = false;
foreach (var story in team.GetPrimaryWorkitems(new StoryFilter()))
{
if (story == teamStory)
{
included = true;
break;
}
}
Assert.IsTrue(included, "Expected Story \"{0}\" in team \"{1}\" stories.", team.Name, teamStory.Name);
}
public void CreateRegressionTestWithAttributesTest()
{
const string regressionTestName = "Regression Test from Project";
const string regressionTestDescription = "Regression Test from Project regressionTestDescription";
const string regressionTestTags = "test tags regression";
var attributes = new Dictionary <string, object> {
{ "Description", regressionTestDescription },
{ "Tags", regressionTestTags }
};
var subProject = EntityFactory.Create(() => SandboxProject.CreateSubProject("subproject", DateTime.Now));
var regressionTest = subProject.CreateRegressionTest(regressionTestName, attributes);
EntityFactory.RegisterForDisposal(regressionTest);
ResetInstance();
var regressionTestNew = Instance.Get.RegressionTestByID(regressionTest.ID);
Assert.AreEqual(regressionTestName, regressionTestNew.Name);
Assert.AreEqual(0, regressionTestNew.Owners.Count);
Assert.AreEqual(regressionTestTags, regressionTestNew.Tags);
Assert.AreEqual(regressionTestDescription, regressionTestNew.Description);
}
public void TeamTotalEstimate()
{
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
storyA.Team = SandboxTeam;
defectB.Team = SandboxTeam;
storyA.Estimate = 5;
defectB.Estimate = 10;
storyA.Save();
defectB.Save();
var rogue = SandboxProject.CreateStory("Rogue");
rogue.Team = SandboxTeam;
rogue.Estimate = 13.37;
rogue.Save();
rogue.Delete();
Assert.AreEqual(15, SandboxTeam.GetTotalEstimate(null));
Assert.AreEqual(15, SandboxTeam.GetTotalEstimate(new PrimaryWorkitemFilter()));
Assert.AreEqual(5, SandboxTeam.GetTotalEstimate(new StoryFilter()));
Assert.AreEqual(10, SandboxTeam.GetTotalEstimate(new DefectFilter()));
}
public void BasicAttributes()
{
var retro = SandboxProject.CreateRetrospective("New Retro");
var retroIteration = SandboxProject.CreateIteration("Retro Iteration", DateTime.Now.Date, DateTime.Now.Date.AddDays(7));
var facilitator = Instance.Get.MemberByID("Member:20");
DateTime? retroDate = DateTime.Now.Date;
const string retroSummary = "We did this, we did that...";
retro.Summary = retroSummary;
retro.Date = retroDate;
retro.FacilitatedBy = facilitator;
retro.Iteration = retroIteration;
retro.Save();
ResetInstance();
var newRetro = Instance.Get.RetrospectiveByID(retro.ID);
retroIteration = Instance.Get.IterationByID(retroIteration.ID);
facilitator = Instance.Get.MemberByID(facilitator.ID);
Assert.AreEqual(retroIteration, newRetro.Iteration);
Assert.AreEqual(facilitator, newRetro.FacilitatedBy);
Assert.AreEqual(retroDate, newRetro.Date);
Assert.AreEqual(retroSummary, newRetro.Summary);
}
public void MemberTotalDetailEstimate()
{
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
var task1 = storyA.CreateTask("Task 1");
storyA.Owners.Add(SandboxMember);
defectB.Owners.Add(SandboxMember);
task1.Owners.Add(SandboxMember);
task1.DetailEstimate = 5;
defectB.DetailEstimate = 10;
task1.Save();
storyA.Save();
defectB.Save();
var rogue = SandboxProject.CreateDefect("Rogue");
rogue.Owners.Add(SandboxMember);
rogue.DetailEstimate = 13.37;
rogue.Save();
rogue.Delete();
Assert.AreEqual(15, SandboxMember.GetTotalDetailEstimate(null));
Assert.AreEqual(15, SandboxMember.GetTotalDetailEstimate(new WorkitemFilter()));
Assert.AreEqual(10, SandboxMember.GetTotalDetailEstimate(new PrimaryWorkitemFilter()));
Assert.AreEqual(null, SandboxMember.GetTotalDetailEstimate(new StoryFilter()));
Assert.AreEqual(10, SandboxMember.GetTotalDetailEstimate(new DefectFilter()));
Assert.AreEqual(5, SandboxMember.GetTotalDetailEstimate(new SecondaryWorkitemFilter()));
Assert.AreEqual(5, SandboxMember.GetTotalDetailEstimate(new TaskFilter()));
Assert.AreEqual(null, SandboxMember.GetTotalDetailEstimate(new TestFilter()));
}
public void ProjectTotalDoneAndDown()
{
var childProject = EntityFactory.CreateSubProject("Son of " + SandboxName, DateTime.Now, null, SandboxProject);
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
var storyC = EntityFactory.CreateStory("Story C", childProject);
var defectD = EntityFactory.CreateDefect("Defect D", childProject);
storyA.CreateTask("Task 1").CreateEffort(5);
defectB.CreateEffort(10);
storyC.CreateTest("Test 1").CreateEffort(2);
defectD.CreateEffort(1);
var rogue = SandboxProject.CreateDefect("Rogue");
rogue.CreateEffort(13.37);
rogue.Delete();
Assert.AreEqual(18, SandboxProject.GetTotalDone(null, true));
Assert.AreEqual(18, SandboxProject.GetTotalDone(new WorkitemFilter(), true));
Assert.AreEqual(11, SandboxProject.GetTotalDone(new PrimaryWorkitemFilter(), true));
Assert.AreEqual(null, SandboxProject.GetTotalDone(new StoryFilter(), true));
Assert.AreEqual(11, SandboxProject.GetTotalDone(new DefectFilter(), true));
Assert.AreEqual(7, SandboxProject.GetTotalDone(new SecondaryWorkitemFilter(), true));
Assert.AreEqual(5, SandboxProject.GetTotalDone(new TaskFilter(), true));
Assert.AreEqual(2, SandboxProject.GetTotalDone(new TestFilter(), true));
}
public void CreateDefectWithRequiredAttributes()
{
const string name = "New Defect";
const string description = "Test for Goal creation with required attributes";
var attributes = new Dictionary <string, object>();
attributes.Add("Description", description);
Instance.ValidationEnabled = true;
var defect = SandboxProject.CreateDefect(name, attributes);
Instance.ValidationEnabled = true;
ResetInstance();
defect = Instance.Get.DefectByID(defect.ID);
Assert.AreEqual(name, defect.Name);
Assert.AreEqual(description, defect.Description);
Assert.AreEqual(SandboxProject, defect.Project);
defect.Delete();
Instance.ValidationEnabled = false;
}
public void ProjectTotalEstimateSliceByIteration()
{
var story1 = EntityFactory.CreateStory("Story 1", SandboxProject);
var story2 = EntityFactory.CreateStory("Story 2", SandboxProject);
var iteration = EntityFactory.Create(() => SandboxProject.CreateIteration());
iteration.Name = "Test Iteration";
iteration.Save();
story1.Estimate = 1.0;
story2.Estimate = 2.0;
var inIteration1 = CreateStory("In 1", SandboxProject, iteration);
var inIteration2 = CreateStory("In 2", SandboxProject, iteration);
Assert.AreEqual(SandboxProject, inIteration1.Project);
Assert.AreEqual(SandboxProject, inIteration2.Project);
inIteration1.Estimate = 10.0;
inIteration2.Estimate = 5.0;
story1.Save();
story2.Save();
inIteration1.Save();
inIteration2.Save();
var filter = new PrimaryWorkitemFilter();
filter.Iteration.Add(iteration);
Assert.AreEqual(15.0, SandboxProject.GetTotalEstimate(filter));
}
public void Actuals()
{
Story story = null;
try {
story = SandboxProject.CreateStory("Actuals 1");
var actual = story.CreateEffort(5);
string storyID = story.ID;
string actualID = actual.ID;
ResetInstance();
var newStory = Instance.Get.StoryByID(storyID);
var newActual = Instance.Get.EffortByID(actualID);
Assert.AreEqual(5, newActual.Value);
Assert.AreEqual(newStory, newActual.Workitem);
} finally {
if (story != null)
{
story.Delete();
}
}
}
public void ProjectTotalEstimateAndDown()
{
var childProject = EntityFactory.CreateSubProject("Son of " + SandboxName, DateTime.Now, null, SandboxProject);
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
var storyC = EntityFactory.CreateStory("Story C", childProject);
var defectD = EntityFactory.CreateDefect("Defect D", childProject);
storyA.Estimate = 5;
defectB.Estimate = 10;
storyC.Estimate = 2;
defectD.Estimate = 3;
storyA.Save();
defectB.Save();
storyC.Save();
defectD.Save();
//Epic rogue = SandboxProject.CreateEpic("Rogue");
//rogue.Estimate = 13.37;
//rogue.Save();
Assert.AreEqual(20, SandboxProject.GetTotalEstimate(null, true));
Assert.AreEqual(20, SandboxProject.GetTotalEstimate(new PrimaryWorkitemFilter(), true));
Assert.AreEqual(7, SandboxProject.GetTotalEstimate(new StoryFilter(), true));
Assert.AreEqual(13, SandboxProject.GetTotalEstimate(new DefectFilter(), true));
}
public void CloseAndReactivateWorkitem()
{
const string name = "CloseAndReactivateWorkitemTest";
SandboxProject.CreateStory(name);
var filter = new StoryFilter();
filter.Name.Add(name);
var workitems = SandboxProject.GetPrimaryWorkitems(filter);
Assert.AreEqual(1, workitems.Count);
var story = First(workitems);
Assert.IsFalse(story.CanReactivate);
Assert.IsTrue(story.CanClose);
Assert.IsFalse(story.IsClosed);
Assert.IsTrue(story.IsActive);
story.Close();
Assert.IsTrue(story.CanReactivate);
Assert.IsFalse(story.CanClose);
Assert.IsTrue(story.IsClosed);
Assert.IsFalse(story.IsActive);
story.Reactivate();
Assert.IsFalse(story.CanReactivate);
Assert.IsTrue(story.CanClose);
Assert.IsFalse(story.IsClosed);
Assert.IsTrue(story.IsActive);
story.Delete();
}
public void ProjectTotalEstimateWithClosedChild()
{
var childProject = EntityFactory.CreateSubProject("Son of " + SandboxName, DateTime.Now, null, SandboxProject);
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
var storyC = EntityFactory.CreateStory("Story C", childProject);
var defectD = EntityFactory.CreateDefect("Defect D", childProject);
storyA.Estimate = 5;
defectB.Estimate = 10;
storyC.Estimate = 2;
defectD.Estimate = 3;
storyA.Save();
defectB.Save();
storyC.Save();
defectD.Save();
// Close child project:
childProject.Close();
ResetInstance();
// Expect to exclude Open workitems in closed child projects
Assert.AreEqual(15, SandboxProject.GetTotalEstimate(null, true), "Expect to exclude Open workitems in closed child projects");
Assert.AreEqual(15, SandboxProject.GetTotalEstimate(new PrimaryWorkitemFilter(), true), "Expect to exclude Open workitems in closed child projects");
Assert.AreEqual(5, SandboxProject.GetTotalEstimate(new StoryFilter(), true), "Expect to exclude Open workitems in closed child projects");
Assert.AreEqual(10, SandboxProject.GetTotalEstimate(new DefectFilter(), true), "Expect to exclude Open workitems in closed child projects");
}
public void GetAffectedPrimaryWorkitems()
{
// Create Workitems
var story = SandboxProject.CreateStory("Test Story");
var defect = SandboxProject.CreateDefect("Test Defect");
var notMyStory = SandboxProject.CreateStory("Other Story");
var notMyDefect = SandboxProject.CreateDefect("Other Defect");
// Changesets
var changeSet = Instance.Create.ChangeSet("Test ChangeSet", "123456");
var notMyChangeSet = Instance.Create.ChangeSet("Other ChangeSet", "abcd");
changeSet.PrimaryWorkitems.Add(story);
changeSet.PrimaryWorkitems.Add(defect);
notMyChangeSet.PrimaryWorkitems.Add(notMyStory);
notMyChangeSet.PrimaryWorkitems.Add(notMyDefect);
// BuildRuns
var buildProject = Instance.Create.BuildProject("BP", "1234");
var buildRun = buildProject.CreateBuildRun("BR", DateTime.Now);
var notMyBuildRun = buildProject.CreateBuildRun("Not My BR", DateTime.Now);
buildRun.ChangeSets.Add(changeSet);
notMyBuildRun.ChangeSets.Add(notMyChangeSet);
var buildRunId = buildRun.ID;
ResetInstance();
var theBuildRun = Instance.Get.BuildRunByID(buildRunId);
Assert.AreEqual(2, theBuildRun.GetAffectedPrimaryWorkitems(null).Count);
Assert.AreEqual(1, theBuildRun.GetAffectedPrimaryWorkitems(new DefectFilter()).Count);
}
public void IterationTotalDetailEstimate()
{
var storyA = CreateStory("Story A", SandboxProject, SandboxIteration);
var defectB = CreateDefect("Defect B", SandboxProject, SandboxIteration);
var task1 = storyA.CreateTask("Task 1");
task1.DetailEstimate = 5;
defectB.DetailEstimate = 10;
task1.Save();
defectB.Save();
var rogue = SandboxProject.CreateDefect("Rogue");
rogue.DetailEstimate = 13.37;
rogue.Save();
rogue.Delete();
Assert.AreEqual(15, SandboxIteration.GetTotalDetailEstimate(null));
Assert.AreEqual(15, SandboxIteration.GetTotalDetailEstimate(new WorkitemFilter()));
Assert.AreEqual(10, SandboxIteration.GetTotalDetailEstimate(new PrimaryWorkitemFilter()));
Assert.AreEqual(null, SandboxIteration.GetTotalDetailEstimate(new StoryFilter()));
Assert.AreEqual(10, SandboxIteration.GetTotalDetailEstimate(new DefectFilter()));
Assert.AreEqual(5, SandboxIteration.GetTotalDetailEstimate(new SecondaryWorkitemFilter()));
Assert.AreEqual(5, SandboxIteration.GetTotalDetailEstimate(new TaskFilter()));
Assert.AreEqual(null, SandboxIteration.GetTotalDetailEstimate(new TestFilter()));
}
public void TaskBuildFilter()
{
var story = SandboxProject.CreateStory("Task Builds");
var taskA = story.CreateTask("Task A");
var taskB = story.CreateTask("Task B");
var taskC = story.CreateTask("Task C");
var taskD = story.CreateTask("Task D");
taskA.Build = "Build Alpha";
taskB.Build = "Build Beta";
taskC.Build = "Build Alpha";
taskD.Build = "Build Beta";
taskA.Save();
taskB.Save();
taskC.Save();
taskD.Save();
var filter = new TaskFilter();
filter.Build.Add("Build Beta");
var items = story.GetSecondaryWorkitems(filter);
CollectionAssert.AreEqual(new string[] { "Task B", "Task D" }, DeriveListOfNamesFromAssets(items));
}
public void TeamTotalDone()
{
var storyA = EntityFactory.CreateStory("Story A", SandboxProject);
var defectB = EntityFactory.CreateDefect("Defect B", SandboxProject);
var task1 = storyA.CreateTask("Task 1");
storyA.Team = SandboxTeam;
defectB.Team = SandboxTeam;
storyA.Save();
defectB.Save();
task1.CreateEffort(5);
defectB.CreateEffort(10);
var rogue = SandboxProject.CreateDefect("Rogue");
rogue.Team = SandboxTeam;
rogue.Save();
rogue.CreateEffort(13.37);
rogue.Delete();
Assert.AreEqual(15, SandboxTeam.GetTotalDone(null));
Assert.AreEqual(15, SandboxTeam.GetTotalDone(new WorkitemFilter()));
Assert.AreEqual(10, SandboxTeam.GetTotalDone(new PrimaryWorkitemFilter()));
Assert.AreEqual(null, SandboxTeam.GetTotalDone(new StoryFilter()));
Assert.AreEqual(10, SandboxTeam.GetTotalDone(new DefectFilter()));
Assert.AreEqual(5, SandboxTeam.GetTotalDone(new SecondaryWorkitemFilter()));
Assert.AreEqual(5, SandboxTeam.GetTotalDone(new TaskFilter()));
Assert.AreEqual(null, SandboxTeam.GetTotalDone(new TestFilter()));
}
public void Status()
{
var story = SandboxProject.CreateStory("Status Filter");
var task = story.CreateTask("Status Filter");
var taskStatus = task.Status.AllValues[0];
task.Status.CurrentValue = taskStatus;
task.Save();
var not = story.CreateTask("Doesn't match");
ResetInstance();
var filter = new TaskFilter();
filter.Status.Add(taskStatus);
var results = SandboxProject.GetTasks(filter);
Assert.IsTrue(FindRelated(task, results), "Expected to find task that matched filter.");
Assert.IsFalse(FindRelated(not, results), "Expected to NOT find task that doesn't match filter.");
foreach (var result in results)
{
Assert.AreEqual(taskStatus, result.Status.CurrentValue);
}
}
public void GetRegressionPlanWithValuableFilterTest()
{
var owner = EntityFactory.CreateMember("Paul");
var nobody = EntityFactory.CreateMember("Mike");
var attributes = new Dictionary <string, object> {
{ "Owner", owner.ID.Token }
};
var plan = EntityFactory.CreateRegressionPlan(RegressionPlanName, SandboxProject, attributes);
var filter = new RegressionPlanFilter();
filter.Owners.Add(owner);
var plans = SandboxProject.GetRegressionPlans(filter);
Assert.AreEqual(1, plans.Count);
CollectionAssert.Contains(plans, plan);
filter = new RegressionPlanFilter();
filter.Project.Add(SandboxProject);
filter.Owners.Add(nobody);
plans = SandboxProject.GetRegressionPlans(filter);
Assert.AreEqual(0, plans.Count);
}
