Come creare un'esecuzione di prova e un risultato utilizzando l'API di Team Foundation Server?

Question

Ho trovato diversi esempi sul recupero dei risultati del test utilizzando l'API TFS, ma nessuna documentazione sulla creazione di risultati a livello di programmazione. Il mio obiettivo è creare un'alternativa leggera all'utilizzo di Microsoft Test Manager per l'esecuzione di test manuali. Qualcuno ha esperienza con questo? Ci sono degli esempi là fuori che mi mancano?

Ecco quello che ho finora:

ITestCaseResult CreateNewTestCaseResult(ITestSuiteEntry testCaseEntry) 
{ 
    var run = testCaseEntry.TestSuite.Plan.CreateTestRun(false /* not automated */); 
    run.AddTest(testCaseEntry.TestCase.Id, suiteEntry.TestSuite.DefaultConfigurations[0].Id, suiteEntry.TestSuite.Plan.Owner); 
    run.Save(); // so that results object is created 
    return run.QueryResults()[0]; 
} 

io non sono sicuro se questo è il modo corretto di initate una nuova corsa, e non sono sicuro come registrare i risultati per ogni azione del test.

Answer 1

Aggiornamento 15 agosto 2012:

L'esempio riportato di seguito è stato ora integrato nella mia aperta source TFS Test Editor degli strumenti. Nell'ultima versione ha ottenuto la possibilità di pubblicare i risultati dei test su TFS. Vedi la fonte su GitHub.

---

Ora ho un codice funzionante per la pubblicazione dei risultati dei test. Nota: il seguente codice accetta ITestPoint (questo rappresenta un caso di test all'interno di una particolare suite) e ha alcune delle mie classi interne (non incluse) che forniscono solo percorsi di risultati e allegati per ogni passaggio.

var tfsRun = _testPoint.Plan.CreateTestRun(false); 

tfsRun.DateStarted = DateTime.Now; 
tfsRun.AddTestPoint(_testPoint, _currentIdentity); 
tfsRun.DateCompleted = DateTime.Now; 
tfsRun.Save(); // so results object is created 

var result = tfsRun.QueryResults()[0]; 
result.Owner = _currentIdentity; 
result.RunBy = _currentIdentity; 
result.State = TestResultState.Completed; 
result.DateStarted = DateTime.Now; 
result.Duration = new TimeSpan(0L); 
result.DateCompleted = DateTime.Now.AddMinutes(0.0); 

var iteration = result.CreateIteration(1); 
iteration.DateStarted = DateTime.Now; 
iteration.DateCompleted = DateTime.Now; 
iteration.Duration = new TimeSpan(0L); 
iteration.Comment = "Run from TFS Test Steps Editor by " + _currentIdentity.DisplayName; 

for (int actionIndex = 0; actionIndex < _testEditInfo.TestCase.Actions.Count; actionIndex++) 
{ 
    var testAction = _testEditInfo.TestCase.Actions[actionIndex]; 
    if (testAction is ISharedStepReference) 
     continue; 

    var userStep = _testEditInfo.SimpleSteps[actionIndex]; 

    var stepResult = iteration.CreateStepResult(testAction.Id); 
    stepResult.ErrorMessage = String.Empty; 
    stepResult.Outcome = userStep.Outcome; 

    foreach (var attachmentPath in userStep.AttachmentPaths) 
    { 
     var attachment = stepResult.CreateAttachment(attachmentPath); 
     stepResult.Attachments.Add(attachment); 
    } 

    iteration.Actions.Add(stepResult); 
} 

var overallOutcome = _testEditInfo.SimpleSteps.Any(s => s.Outcome != TestOutcome.Passed) 
    ? TestOutcome.Failed 
    : TestOutcome.Passed; 

iteration.Outcome = overallOutcome; 

result.Iterations.Add(iteration); 

result.Outcome = overallOutcome; 
result.Save(false); 

Answer 2

L'azione di test non sembra avere proprietà per l'impostazione pass/fail o per aggiungere allegati.

public interface ITestAction : INotifyPropertyChanged { 
    int Id { get; } 
    ITestBase Owner { get; } 
    ITestActionGroup Parent { get; } 

    ITestAction CopyToNewOwner(ITestBase newOwner); 
    void MoveToNewOwner(ITestBase newOwner); } 

Questo viene eseguito a livello di genitore (TestCase).

ITestCaseResult result = run.QueryResults()[0]; 
IAttachmentCollection collection = result.Attachments; 
string x = result.Comment; 

Ecco come si avvia correttamente una nuova corsa:

namespace SampleRunCreation 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      TfsTeamProjectCollection tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri("http://pradeepn-tcm:8080/tfs/DefaultCollection")); 
      ITestManagementTeamProject project = tfs.GetService<ITestManagementService>().GetTeamProject("Pradeep"); 

      // Create a test case. 
      ITestCase testCase = CreateTestCase(project, "My test case"); 

      // Create test plan. 
      ITestPlan plan = CreateTestPlan(project, "My test plan"); 

      // Create test configuration. You can reuse this instead of creating a new config everytime. 
      ITestConfiguration config = CreateTestConfiguration(project, string.Format("My test config {0}", DateTime.Now)); 

      // Create test points. 
      IList<ITestPoint> testPoints = CreateTestPoints(project, 
                  plan, 
                  new List<ITestCase>(){testCase}, 
                  new IdAndName[] { new IdAndName(config.Id, config.Name) }); 

      // Create test run using test points. 
      ITestRun run = CreateTestRun(project, plan, testPoints); 

      // Query results from the run. 
      ITestCaseResult result = run.QueryResults()[0]; 

      // Fail the result. 
      result.Outcome = TestOutcome.Failed; 
      result.State = TestResultState.Completed; 
      result.Save(); 

      Console.WriteLine("Run {0} completed", run.Id); 
     } 

     private static ITestCase CreateTestCase(ITestManagementTeamProject project, 
               string title) 
     { 
      // Create a test case. 
      ITestCase testCase = project.TestCases.Create(); 
      testCase.Owner = null; 
      testCase.Title = title; 
      testCase.Save(); 
      return testCase; 
     } 

     private static ITestPlan CreateTestPlan(ITestManagementTeamProject project, string title) 
     { 
      // Create a test plan. 
      ITestPlan testPlan = project.TestPlans.Create(); 
      testPlan.Name = title; 
      testPlan.Save(); 
      return testPlan; 
     } 

     private static ITestConfiguration CreateTestConfiguration(ITestManagementTeamProject project, string title) 
     { 
      ITestConfiguration configuration = project.TestConfigurations.Create(); 
      configuration.Name = title; 
      configuration.Description = "DefaultConfig"; 
      configuration.Values.Add(new KeyValuePair<string, string>("Browser", "IE")); 
      configuration.Save(); 
      return configuration; 
     } 

     public static IList<ITestPoint> CreateTestPoints(ITestManagementTeamProject project, 
                 ITestPlan testPlan, 
                 IList<ITestCase> testCases, 
                 IList<IdAndName> testConfigs) 
     { 
      // Create a static suite within the plan and add all the test cases. 
      IStaticTestSuite testSuite = CreateTestSuite(project); 
      testPlan.RootSuite.Entries.Add(testSuite); 
      testPlan.Save(); 

      testSuite.Entries.AddCases(testCases); 
      testPlan.Save(); 

      testSuite.SetEntryConfigurations(testSuite.Entries, testConfigs); 
      testPlan.Save(); 

      ITestPointCollection tpc = testPlan.QueryTestPoints("SELECT * FROM TestPoint WHERE SuiteId = " + testSuite.Id); 
      return new List<ITestPoint>(tpc); 
     } 

     private static IStaticTestSuite CreateTestSuite(ITestManagementTeamProject project) 
     { 
      // Create a static test suite. 
      IStaticTestSuite testSuite = project.TestSuites.CreateStatic(); 
      testSuite.Title = "Static Suite"; 
      return testSuite; 
     } 

     private static ITestRun CreateTestRun(ITestManagementTeamProject project, 
              ITestPlan plan, 
              IList<ITestPoint> points) 
     { 
      ITestRun run = plan.CreateTestRun(false); 
      foreach (ITestPoint tp in points) 
      { 
       run.AddTestPoint(tp, null); 
      } 

      run.Save(); 
      return run; 
     } 
    } 
} 

Reference