private static async Task AttachReportToBuildTestRunAsync(string collectionUri, string teamProjectName, string releaseUri, string releaseEnvironmentUri, string reportFile, string personalAccessToken)
{
var connection = GetConnection(collectionUri, personalAccessToken);
var testManagementClient = connection.GetClient <TestManagementHttpClient>();
var projectClient = connection.GetClient <ProjectHttpClient>();
Console.WriteLine("Attaching Report");
var queryModel = new QueryModel(query: "SELECT * FROM TestRun WHERE ReleaseUri = '" + releaseUri + "' and ReleaseEnvironmentUri in ('" + releaseEnvironmentUri + "')");
var testRunResult = await testManagementClient.GetTestRunsByQueryAsync(queryModel, teamProjectName);
TestRun testRun;
if (testRunResult == null || testRunResult.Count == 0)
{
var runCreateModel = new RunCreateModel("OWASP ZAP Security Tests", isAutomated: true, releaseUri: releaseUri, releaseEnvironmentUri: releaseEnvironmentUri);
var project = await projectClient.GetProject(teamProjectName);
string projectId = project.Id.ToString();
testRun = await testManagementClient.CreateTestRunAsync(projectId, runCreateModel);
}
else
{
testRun = testRunResult.FirstOrDefault();
}
string stream = File.ReadAllText(reportFile);
var attachmentModel = new TestAttachmentRequestModel(stream: Base64Encode(stream), fileName: "OwaspZapTestResultsReport.html");
var testAttachmentResult = await testManagementClient.CreateTestRunAttachmentAsync(attachmentModel, teamProjectName, testRun.Id);
}
/// <summary>
/// Create failed test results
/// </summary>
/// <param name="TeamProjectName"></param>
private static void CreateTestResultFailed(string TeamProjectName)
{
RunCreateModel runCreate = new RunCreateModel(
name: "Test run from console - failed",
startedDate: DateTime.Now.ToString("o"),
isAutomated: true
);
TestRun testRun = TestManagementClient.CreateTestRunAsync(runCreate, TeamProjectName).Result;
TestCaseResult testCaseResult = new TestCaseResult();
testCaseResult.AutomatedTestName = "MyTestSuite.TestName";
testCaseResult.TestCaseTitle = "Check my function";
testCaseResult.StackTrace = "Add StackTrace here";
testCaseResult.ErrorMessage = "Test 'MyTestSuite.TestName' failed";
testCaseResult.Outcome = Enum.GetName(typeof(TestOutcome), TestOutcome.Failed);
testCaseResult.CompletedDate = DateTime.Now;
testCaseResult.State = Enum.GetName(typeof(TestRunState), TestRunState.Completed);
TestManagementClient.AddTestResultsToTestRunAsync(new TestCaseResult[] { testCaseResult }, TeamProjectName, testRun.Id).Wait();
RunUpdateModel runUpdateModel = new RunUpdateModel(
completedDate: DateTime.Now.ToString("o"),
state: Enum.GetName(typeof(TestRunState), TestRunState.NeedsInvestigation)
);
testRun = TestManagementClient.UpdateTestRunAsync(runUpdateModel, TeamProjectName, testRun.Id).Result;
PrintBasicRunInfo(testRun);
}
public async Task <TestRun> CreateTestRunAsync(
string projectName,
RunCreateModel testRunData,
CancellationToken cancellationToken = default(CancellationToken))
{
return(await TestHttpClient.CreateTestRunAsync(testRunData, projectName, cancellationToken));
}
/// <summary>
/// Create successed test run
/// </summary>
/// <param name="TeamProjectName"></param>
/// <param name="TestPlanId"></param>
/// <param name="StaticSuitePath"></param>
/// <param name="TestCaseIds"></param>
private static void CreateTestResultCompleted(string TeamProjectName, int TestPlanId, string StaticSuitePath, int[] TestCaseIds)
{
TestPlan testPlan = TestManagementClient.GetPlanByIdAsync(TeamProjectName, TestPlanId).Result;
var testPlanRef = new Microsoft.TeamFoundation.TestManagement.WebApi.ShallowReference(testPlan.Id.ToString(), testPlan.Name, testPlan.Url);
RunCreateModel runCreate = new RunCreateModel(
name: "Test run from console - completed",
plan: testPlanRef,
startedDate: DateTime.Now.ToString("o"),
isAutomated: true
);
TestRun testRun = TestManagementClient.CreateTestRunAsync(runCreate, TeamProjectName).Result;
List <TestCaseResult> testResults = new List <TestCaseResult>();
foreach (int testCaseId in TestCaseIds)
{
testResults.Add(PassedTest(TeamProjectName, TestPlanId, StaticSuitePath, testCaseId));
}
testResults = TestManagementClient.AddTestResultsToTestRunAsync(testResults.ToArray(), TeamProjectName, testRun.Id).Result;
RunUpdateModel runUpdateModel = new RunUpdateModel(
completedDate: DateTime.Now.ToString("o"),
state: Enum.GetName(typeof(TestRunState), TestRunState.Completed)
);
testRun = TestManagementClient.UpdateTestRunAsync(runUpdateModel, TeamProjectName, testRun.Id).Result;
PrintBasicRunInfo(testRun);
}
static void Main(string[] args)
{
try
{
//System.Diagnostics.Debugger.Launch();
string collectionUrl = args[0]; // $(System.TeamFoundationCollectionUri)
var connection = new VssConnection(new Uri(collectionUrl), new Microsoft.VisualStudio.Services.OAuth.VssOAuthAccessTokenCredential(args[4]));
var testClient = new TestManagementHttpClient(new Uri(collectionUrl), new Microsoft.VisualStudio.Services.OAuth.VssOAuthAccessTokenCredential(args[4]));
string buildurl = args[1]; // $(BUILD.BUILDURI)
string projectName = args[2]; // $(SYSTEM.TEAMPROJECT)
string folder = args[3];
int buildId = int.Parse(args[5]); //$(Build.BuildId)
bool useNewStore = false;
string projectId = string.Empty;
try
{
bool.TryParse(args[6], out useNewStore);
projectId = args[7]; //$(System.TeamProjectId)
}
catch (Exception e)
{
}
// Create test run
RunCreateModel runCreationModel = new RunCreateModel("somename", buildId: buildId,
startedDate: DateTime.UtcNow.ToString(), completedDate: DateTime.UtcNow.ToString(),
state: TestRunState.InProgress.ToString(), isAutomated: true);
var testRun = testClient.CreateTestRunAsync(runCreationModel, projectName).Result;
TestCaseResult result = new TestCaseResult
{
AutomatedTestName = "TestOne",
AutomatedTestStorage = "foo.dll",
Build = new ShallowReference {
Url = buildurl
},
TestCaseTitle = "TestOne"
};
testClient.AddTestResultsToTestRunAsync(new TestCaseResult[] { result }, projectName, testRun.Id).Wait();
testClient.UpdateTestRunAsync(new RunUpdateModel("somename", state: TestRunState.Completed.ToString()), projectName, testRun.Id).Wait();
if (useNewStore)
{
UploadCodeCoverageAttachmentsToNewStore(folder, connection, buildId, projectId);
}
else
{
UploadCodeCoverageAttachmentsToOldStore(testClient, buildurl, projectName, folder);
}
}
catch (AggregateException e)
{
Console.WriteLine(e.InnerException);
Console.WriteLine(e);
}
}
private bool ValidatePipelineReference(RunCreateModel run)
{
bool pipelineId = run.PipelineReference.PipelineId.Equals(1);
bool stageReference = run.PipelineReference.StageReference.Attempt.Equals(1) && run.PipelineReference.StageReference.StageName.Equals("Stage1");
bool phaseReference = run.PipelineReference.PhaseReference.Attempt.Equals(1) && run.PipelineReference.PhaseReference.PhaseName.Equals("Phase1");
bool jobReference = run.PipelineReference.JobReference.Attempt.Equals(1) && run.PipelineReference.JobReference.JobName.Equals("Job1");
return(pipelineId && stageReference && phaseReference && jobReference);
}
public async Task <List <string> > LogResults(List <VstsTestCaseResult> results)
{
var orgUri = new Uri(OrganizationUrl);
VssCredentials credentials = new VssCredentials(new Microsoft.VisualStudio.Services.Common.VssBasicCredential(string.Empty, Personalaccesstoken));
var connection = new VssConnection(orgUri, credentials);
using (var testClient = connection.GetClient <TestManagementHttpClient>())
{
var resultPointIds = results.Where(p => _testCaseToPointMap.Keys.Contains(p.Id)).Select(p => GetPointIdByCaseId(p.Id)).ToArray();
List <TestCaseResult> testcaseResults = new List <TestCaseResult>();
foreach (var pointId in resultPointIds)
{
TestCaseResult temp = new TestCaseResult()
{
State = "Completed"
};
temp.Id = GenerateTestResultID();
temp.TestPoint = new ShallowReference(pointId.ToString());
var current = results.Where(p => p.Id == GetCaseIdByPointId(pointId)).First();
temp.Outcome = current.Outcome;
if (current.AssociatedBugs != null)
{
var tempDefects = new List <ShallowReference>();
foreach (var defect in current.AssociatedBugs)
{
tempDefects.Add(new ShallowReference(defect));
}
temp.AssociatedBugs = tempDefects;
}
temp.Comment = current.Comment;
testcaseResults.Add(temp);
}
RunCreateModel run = new RunCreateModel(name: "Mvt", plan: new ShallowReference(PlanId.ToString()), pointIds: resultPointIds);
TestRun testrun = await testClient.CreateTestRunAsync(run, ProjectName);
var testResults = await testClient.UpdateTestResultsAsync(testcaseResults.ToArray(), ProjectName, testrun.Id);
RunUpdateModel runmodel = new RunUpdateModel(state: "Completed", deleteUnexecutedResults: true); //, deleteUnexecutedResults: true);
TestRun testRunResult = await testClient.UpdateTestRunAsync(runmodel, ProjectName, testrun.Id); //, runmodel);
var loggedCases = await testClient.GetTestResultsAsync(ProjectName, testRunResult.Id);
return(loggedCases.Select(p => p.TestCase.Id).ToList());
//TestRunState.Completed;
//TestRunOutcome.Passed.ToString();
}
}
/// <summary>
/// Create failed test results for all tests in test suite
/// </summary>
/// <param name="TeamProjectName"></param>
/// <param name="TestPlanId"></param>
/// <param name="StaticSuitePath"></param>
private static void CreateTestResultFailed(string TeamProjectName, int TestPlanId, string StaticSuitePath)
{
TestPlan testPlan = TestManagementClient.GetPlanByIdAsync(TeamProjectName, TestPlanId).Result;
int testSuiteId = GetSuiteId(TeamProjectName, TestPlanId, StaticSuitePath);
var testPlanRef = new Microsoft.TeamFoundation.TestManagement.WebApi.ShallowReference(testPlan.Id.ToString(), testPlan.Name, testPlan.Url);
RunCreateModel runCreate = new RunCreateModel(
name: "Test run from console - failed",
plan: testPlanRef,
startedDate: DateTime.Now.ToString("o"),
isAutomated: true
);
TestRun testRun = TestManagementClient.CreateTestRunAsync(runCreate, TeamProjectName).Result;
List <TestCaseResult> testResults = new List <TestCaseResult>();
List <SuiteTestCase> testCases = TestManagementClient.GetTestCasesAsync(TeamProjectName, TestPlanId, testSuiteId).Result; //Get all test cases from suite
foreach (var testCase in testCases)
{
testResults.Add(FailedTest(TeamProjectName, TestPlanId, testSuiteId, testCase.Workitem.Id, testRun.Id));
}
testResults = TestManagementClient.AddTestResultsToTestRunAsync(testResults.ToArray(), TeamProjectName, testRun.Id).Result;
var definedTestResults = TestManagementClient.GetTestResultsAsync(TeamProjectName, testRun.Id).Result; // Get test result
TestManagementClient.CreateTestResultAttachmentAsync(GetAttachmentModel(@"img\iconfinder_Insect-robot_131435.png"), TeamProjectName, testRun.Id, definedTestResults.ElementAt(0).Id).Wait();
RunUpdateModel runUpdateModel = new RunUpdateModel(
errorMessage: "Test failed",
completedDate: DateTime.Now.ToString("o"),
state: Enum.GetName(typeof(TestRunState), TestRunState.NeedsInvestigation)
);
testRun = TestManagementClient.UpdateTestRunAsync(runUpdateModel, TeamProjectName, testRun.Id).Result;
TestManagementClient.CreateTestRunAttachmentAsync(GetAttachmentModel(@"img\Screen_Shot_2018-01-16.jpg"), TeamProjectName, testRun.Id).Wait();
PrintBasicRunInfo(testRun);
}
// Adds Target Branch Name info to run create model
private void AddTargetBranchInfoToRunCreateModel(RunCreateModel runCreateModel, string pullRequestTargetBranchName)
{
if (string.IsNullOrEmpty(pullRequestTargetBranchName) ||
!string.IsNullOrEmpty(runCreateModel.BuildReference?.TargetBranchName))
{
return;
}
if (runCreateModel.BuildReference == null)
{
runCreateModel.BuildReference = new BuildConfiguration()
{
TargetBranchName = pullRequestTargetBranchName
};
}
else
{
runCreateModel.BuildReference.TargetBranchName = pullRequestTargetBranchName;
}
}
private static void updateTestResultsInAzure(string testPlanId, List <Tuple <int, string> > resultList)
{
try{
VssConnection connection = new VssConnection(new Uri(TFUrl), new VssBasicCredential(string.Empty, UserPAT));
DateTime utcDate = DateTime.UtcNow; //getting time for the run report name
var culture = new CultureInfo("en-US");
string reportName = "Katalon Automated Tests: " + utcDate.ToString(culture) + " " + utcDate.Kind;
int[] excPointIds = new int[resultList.Count];
TestCaseResult[] excTestCases = new TestCaseResult[resultList.Count];
for (int i = 0; i < resultList.Count; i++)
{
excPointIds[i] = resultList[i].Item1;
string extrapolatedOutcome = resultList[i].Item2 == "PASSED" ? "Passed" : "Failed"; //we only care if the test passed or not
TestCaseResult caseResult = new TestCaseResult()
{
State = "Completed", Outcome = extrapolatedOutcome, Id = 100000 + i
};
excTestCases[i] = caseResult;
}
TestManagementClient = connection.GetClient <TestManagementHttpClient>();
RunCreateModel run = new RunCreateModel(
name: reportName,
plan: new Microsoft.TeamFoundation.TestManagement.WebApi.ShallowReference(testPlanId),
pointIds: excPointIds
);
TestRun testrun = TestManagementClient.CreateTestRunAsync(run, teamProjectName).Result;
var testResults = TestManagementClient.UpdateTestResultsAsync(excTestCases, teamProjectName, testrun.Id).Result;
RunUpdateModel runmodel = new RunUpdateModel(state: "Completed");
TestRun testRunResult = TestManagementClient.UpdateTestRunAsync(runmodel, teamProjectName, testrun.Id, runmodel).Result;
}
catch (Exception e) { //catch exception with writing test case results, don't make this kill the whole process
Console.WriteLine(e.Message.ToString());
Console.WriteLine(e.StackTrace.ToString());
}
}
private static async Task CreateBugFromPenTestAsync(string collectionUri, string teamProjectName, string team, string releaseUri, string releaseEnvironmentUri, string filePath, bool failOnHigh, string personalAccessToken)
{
var connection = GetConnection(collectionUri, personalAccessToken);
var testManagementClient = connection.GetClient <TestManagementHttpClient>();
var projectClient = connection.GetClient <ProjectHttpClient>();
var witClient = connection.GetClient <WorkItemTrackingHttpClient>();
var workClient = connection.GetClient <WorkHttpClient>();
var queryModel = new QueryModel(query: "SELECT * FROM TestRun WHERE ReleaseUri = '" + releaseUri + "' and ReleaseEnvironmentUri in ('" + releaseEnvironmentUri + "')");
var testRunResult = await testManagementClient.GetTestRunsByQueryAsync(queryModel, teamProjectName);
var project = await projectClient.GetProject(teamProjectName);
string projectId = project.Id.ToString();
var teamContext = new TeamContext(teamProjectName, team);
var teamSettings = await workClient.GetTeamSettingsAsync(teamContext);
var teamFieldValues = await workClient.GetTeamFieldValuesAsync(teamContext);
var teamIteration = await workClient.GetTeamIterationAsync(teamContext, teamSettings.BacklogIteration.Id);
var teamIterations = await workClient.GetTeamIterationsAsync(teamContext, "current");
string areaPath = teamFieldValues.DefaultValue;
string iterationPath = "";
if (teamIterations.Count > 0)
{
iterationPath = teamIterations[0].Path;
}
else
{
iterationPath = teamIteration.Path;
}
TestRun testRun;
if (testRunResult == null || testRunResult.Count == 0)
{
var runCreateModel = new RunCreateModel("OWASP ZAP Security Tests", isAutomated: true, releaseUri: releaseUri, releaseEnvironmentUri: releaseEnvironmentUri);
testRun = await testManagementClient.CreateTestRunAsync(projectId, runCreateModel);
}
else
{
testRun = testRunResult.FirstOrDefault();
}
var targetUrl = System.Environment.GetEnvironmentVariable("targeturl");
var report = GetReport(filePath, targetUrl);
string title = String.Empty;
bool testsPassed = true;
bool highFailure = false;
var results = new List <TestResultCreateModel>();
if (report != null && report.Issues != null && report.Issues.Count() > 0)
{
foreach (Issue issue in report.Issues)
{
if (issue.RiskDescription.Contains("Information"))
{
continue;
}
testsPassed = false;
//create bug
if (issue.RiskDescription.Contains("High"))
{
highFailure = true;
}
title = issue.IssueDescription;
await CreateBugAsync(collectionUri, teamProjectName, team, title, areaPath, iterationPath, personalAccessToken);
results.Add(new TestResultCreateModel
{
AutomatedTestName = title,
Outcome = testsPassed ? "Passed" : "Failed",
TestCaseTitle = title,
State = "Completed"
});
}
var testResults = await testManagementClient.AddTestResultsToTestRunAsync(results.ToArray(), teamProjectName, testRun.Id);
}
// TODO CloseFixedBugs()
var updateProperties = new RunUpdateModel(state: "Completed", completedDate: DateTime.Today.ToShortDateString());
var updateResults = await testManagementClient.UpdateTestRunAsync(projectId, testRun.Id, updateProperties);
if (highFailure && failOnHigh)
{
Console.WriteLine("High Issue Found. Deployment Failed.");
throw new Exception("High Issue Found. Deployment Failed.");
}
}
/// <inheritdoc />
public async Task <TestRun> PublishAsync(TestRun testRun)
{
using (var timer = new SimpleTimer("PublishTestRun", _logger,
new TelemetryDataWrapper(_telemetry, TelemetryConstants.PipelineTestRunPublisherEventArea, TelemetryConstants.PublishTestRun),
TimeSpan.FromMilliseconds(int.MaxValue)))
{
var runCreateModel = new RunCreateModel(name: testRun.TestRunName, buildId: _pipelineConfig.BuildId,
state: TestRunState.InProgress.ToString(), isAutomated: true, type: RunType.NoConfigRun.ToString());
runCreateModel.PipelineReference = new PipelineReference()
{
PipelineId = _pipelineConfig.BuildId,
StageReference = new StageReference()
{
StageName = _pipelineConfig.StageName, Attempt = _pipelineConfig.StageAttempt
},
PhaseReference = new PhaseReference()
{
PhaseName = _pipelineConfig.PhaseName, Attempt = _pipelineConfig.PhaseAttempt
},
JobReference = new JobReference()
{
JobName = _pipelineConfig.JobName, Attempt = _pipelineConfig.JobAttempt
}
};
// Create the test run on the server
var run = await _httpClient.CreateTestRunAsync(runCreateModel, _pipelineConfig.Project);
_logger.Info($"PipelineTestRunPublisher : PublishAsync : Created test run with id {run.Id}.");
_telemetry.AddAndAggregate(TelemetryConstants.TestRunIds, new List <int> {
run.Id
},
TelemetryConstants.PipelineTestRunPublisherEventArea);
_telemetry.AddAndAggregate($"{testRun.ParserUri.Split('/')[0]}RunsCount", 1,
TelemetryConstants.PipelineTestRunPublisherEventArea);
// Populate test reulsts
var testResults = new List <TestCaseResult>();
foreach (var passedTest in testRun.PassedTests)
{
testResults.Add(new TestCaseResult
{
TestCaseTitle = passedTest.Name,
AutomatedTestName = passedTest.Name,
DurationInMs = passedTest.ExecutionTime.TotalMilliseconds,
State = "Completed",
AutomatedTestType = "NoConfig",
Outcome = TestOutcome.Passed.ToString()
});
}
foreach (var failedTest in testRun.FailedTests)
{
testResults.Add(new TestCaseResult
{
TestCaseTitle = failedTest.Name,
AutomatedTestName = failedTest.Name,
DurationInMs = failedTest.ExecutionTime.TotalMilliseconds,
State = "Completed",
AutomatedTestType = "NoConfig",
Outcome = TestOutcome.Failed.ToString(),
StackTrace = failedTest.StackTrace
});
}
foreach (var skippedTest in testRun.SkippedTests)
{
testResults.Add(new TestCaseResult
{
TestCaseTitle = skippedTest.Name,
AutomatedTestName = skippedTest.Name,
DurationInMs = skippedTest.ExecutionTime.TotalMilliseconds,
State = "Completed",
AutomatedTestType = "NoConfig",
Outcome = TestOutcome.NotExecuted.ToString()
});
}
var batchedResults = testResults.Batch(BatchSize);
foreach (var batch in batchedResults)
{
// Update the run with test results
await _httpClient.AddTestResultsToTestRunAsync(batch.ToArray(), _pipelineConfig.Project, run.Id);
}
var runUpdateModel = new RunUpdateModel(state: TestRunState.Completed.ToString())
{
RunSummary = new List <RunSummaryModel>()
};
runUpdateModel.RunSummary.Add(new RunSummaryModel(resultCount: testRun.TestRunSummary.TotalFailed, testOutcome: TestOutcome.Failed));
runUpdateModel.RunSummary.Add(new RunSummaryModel(resultCount: testRun.TestRunSummary.TotalPassed, testOutcome: TestOutcome.Passed));
runUpdateModel.RunSummary.Add(new RunSummaryModel(resultCount: testRun.TestRunSummary.TotalSkipped, testOutcome: TestOutcome.NotExecuted));
// Complete the run
await _httpClient.UpdateTestRunAsync(runUpdateModel, _pipelineConfig.Project, run.Id);
return(new PipelineTestRun(testRun.ParserUri, testRun.RunNamePrefix, testRun.TestRunId, run.Id));
}
}
static void Main(string[] args)
{
string collectionUri;
//set to Uri of the TFS collection
//if this scipt is running in Build/Release workflow, we will fetch collection Uri from environment variable
//See https://www.visualstudio.com/en-us/docs/build/define/variables for full list of agent environment variables
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
collectionUri = Environment.GetEnvironmentVariable("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI");
Console.WriteLine("Fetched Collection (or VSTS account) from environment variable SYSTEM_TEAMFOUNDATIONCOLLECTIONURI: {0}", collectionUri);
}
else // set it to TFS instance of your choice
{
//collectionUri = "http://buildmachine1:8080/tfs/TestDefault";
collectionUri = "https://manojbableshwar.visualstudio.com";
Console.WriteLine("Using Collection (or VSTS account): {0}", collectionUri);
}
//authentication..
VssConnection connection = new VssConnection(new Uri(collectionUri), new VssCredentials());
//set the team project name in which the test results must be published...
// get team project name from the agent environment variables if the script is running in Build workflow..
string teamProject;
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
teamProject = Environment.GetEnvironmentVariable("SYSTEM_TEAMPROJECT");
Console.WriteLine("Fetched team project from environment variable SYSTEM_TEAMPROJECT: {0}", teamProject);
}
else //else set it the team project of your choice...
{
teamProject = "PartsUnlimited";
Console.WriteLine("Using team project: {0}", teamProject);
}
//Client to use test run and test result APIs...
TestManagementHttpClient client = connection.GetClient <TestManagementHttpClient>();
//Test run model to initialize test run parameters..
//For automated test runs, isAutomated must be set.. Else manual test run will be created..
//<<Q: do we want to mark run in progress here?>>
RunCreateModel TestRunModel = new RunCreateModel(name: "Sample test run from CSV file", isAutomated: true,
startedDate: DateTime.Now.ToString(), comment: "create run comment");
//Since we are doing a Asycn call, .Result will wait for the call to complete...
TestRun testRun = client.CreateTestRunAsync(teamProject, TestRunModel).Result;
Console.WriteLine("Step 1: test run created -> {0}: {1}; Run url: {2} ", testRun.Id, testRun.Name, testRun.WebAccessUrl);
string resultsFilePath;
if (args.Length == 0)
{
resultsFilePath = "Results.csv";
}
else
{
resultsFilePath = args[0];
}
//List to hold results from parsed from CSV file...
List <TestResultCreateModel> testResultsFromCsv = new List <TestResultCreateModel>();
var reader = new StreamReader(File.OpenRead(resultsFilePath));
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
Console.WriteLine("Publishing test {0}", values[0]);
//Assign values from each line in CSV to result model...
TestResultCreateModel testResultModel = new TestResultCreateModel();
testResultModel.TestCaseTitle = testResultModel.AutomatedTestName = values[0];
testResultModel.Outcome = values[1];
//Setting state to completed since we are only publishing results.
//In advanced scenarios, you can choose to create a test result,
// move it into in progress state while test test acutally runs and finally update the outcome with state as completed
testResultModel.State = "Completed";
testResultModel.ErrorMessage = values[2];
testResultModel.StackTrace = values[3];
testResultModel.StartedDate = values[4];
testResultModel.CompletedDate = values[5];
//Add the result ot the results list...
testResultsFromCsv.Add(testResultModel);
}
//Publish the results...
List <TestCaseResult> resultObj = client.AddTestResultsToTestRunAsync(testResultsFromCsv.ToArray(), teamProject, testRun.Id).Result;
Console.WriteLine("Step 2: test results published...");
//Mark the run complete...
RunUpdateModel testRunUpdate = new RunUpdateModel(completedDate: DateTime.Now.ToString(), state: "Completed");
TestRun RunUpdateResult = client.UpdateTestRunAsync(teamProject, testRun.Id, testRunUpdate).Result;
Console.WriteLine("Step 3: Test run completed: {0} ", RunUpdateResult.WebAccessUrl);
}
/// <inheritdoc />
public async Task PublishAsync(TestRun testRun)
{
var runUri = testRun.ParserUri.Split("/");
var r = new RunCreateModel(name: $"{runUri[0]} test run {testRun.TestRunId} - automatically inferred results", buildId: _pipelineConfig.BuildId,
state: TestRunState.InProgress.ToString(), isAutomated: true, type: RunType.NoConfigRun.ToString());
var run = await _httpClient.CreateTestRunAsync(r, _pipelineConfig.Project);
var testResults = new List <TestCaseResult>();
foreach (var passedTest in testRun.PassedTests)
{
testResults.Add(new TestCaseResult
{
TestCaseTitle = passedTest.Name,
AutomatedTestName = passedTest.Name,
DurationInMs = passedTest.ExecutionTime.TotalMilliseconds,
State = "Completed",
AutomatedTestType = "NoConfig",
Outcome = TestOutcome.Passed.ToString()
});
}
foreach (var failedTest in testRun.FailedTests)
{
testResults.Add(new TestCaseResult
{
TestCaseTitle = failedTest.Name,
AutomatedTestName = failedTest.Name,
DurationInMs = failedTest.ExecutionTime.TotalMilliseconds,
State = "Completed",
AutomatedTestType = "NoConfig",
Outcome = TestOutcome.Failed.ToString(),
StackTrace = failedTest.StackTrace
});
}
foreach (var skippedTest in testRun.SkippedTests)
{
testResults.Add(new TestCaseResult
{
TestCaseTitle = skippedTest.Name,
AutomatedTestName = skippedTest.Name,
DurationInMs = skippedTest.ExecutionTime.TotalMilliseconds,
State = "Completed",
AutomatedTestType = "NoConfig",
Outcome = TestOutcome.NotExecuted.ToString()
});
}
await _httpClient.AddTestResultsToTestRunAsync(testResults.ToArray(), _pipelineConfig.Project, run.Id);
// var runUpdateModel = new RunUpdateModel(state: TestRunState.Completed.ToString());
var runUpdateModel = new RunUpdateModel(state: TestRunState.Completed.ToString())
{
RunSummary = new List <RunSummaryModel>()
};
runUpdateModel.RunSummary.Add(new RunSummaryModel(resultCount: testRun.TestRunSummary.TotalFailed, testOutcome: TestOutcome.Failed));
runUpdateModel.RunSummary.Add(new RunSummaryModel(resultCount: testRun.TestRunSummary.TotalPassed, testOutcome: TestOutcome.Passed));
runUpdateModel.RunSummary.Add(new RunSummaryModel(resultCount: testRun.TestRunSummary.TotalSkipped, testOutcome: TestOutcome.NotExecuted));
await _httpClient.UpdateTestRunAsync(runUpdateModel, _pipelineConfig.Project, run.Id);
}
static void Main(string[] args)
{
string collectionUri;
//set to Uri of the TFS collection
//if this code is running in Build/Release workflow, we will fetch collection Uri from environment variable
//See https://www.visualstudio.com/en-us/docs/build/define/variables for full list of agent environment variables
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
collectionUri = Environment.GetEnvironmentVariable("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI");
Console.WriteLine("Fetched Collection (or VSTS account) from environment variable SYSTEM_TEAMFOUNDATIONCOLLECTIONURI: {0}", collectionUri);
}
else // set it to TFS instance of your choice
{
collectionUri = "http://buildmachine1:8080/tfs/TestDefault";
Console.WriteLine("Using Collection (or VSTS account): {0}", collectionUri);
}
//authentication..
VssConnection connection = new VssConnection(new Uri(collectionUri), new VssCredentials());
//set the team project name in which the test results must be published...
// get team project name from the agent environment variables if the script is running in Build workflow..
string teamProject;
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
teamProject = Environment.GetEnvironmentVariable("SYSTEM_TEAMPROJECT");
Console.WriteLine("Fetched team project from environment variable SYSTEM_TEAMPROJECT: {0}", teamProject);
}
else //else set it the team project of your choice...
{
teamProject = "DefaultAgileGitProject";
Console.WriteLine("Using team project: {0}", teamProject);
}
// get the build number to publish results against...
string buildNumber, buildUri; int buildId;
// if this code is running in build workflow, BUILD_BUILDNUMBER and BUILD_BUILDID environment variables have the build info...
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
//build number is human readable format of the build name, you can confiure it's format in build options..
buildNumber = Environment.GetEnvironmentVariable("BUILD_BUILDNUMBER");
Console.WriteLine("Fetched build number from environment variable BUILD_BUILDNUMBER: {0}", buildNumber);
//build id is the id associated with the build number, which we will use to associate the test run with...
buildId = Convert.ToInt32(Environment.GetEnvironmentVariable("BUILD_BUILDID"));
Console.WriteLine("Fetched build id from environment variable BUILD_BUILDID: {0}", buildId);
//build uri is a more elaborate form of build id, in the vstfs:///Build/Build/<id> format...
//We will use this for querying test runs against this build...
buildUri = Environment.GetEnvironmentVariable("BUILD_BUILDURI");
Console.WriteLine("Fetched build uri from environment variable BUILD_BUILDURI: {0}", buildUri);
}
else //if the code is running in standalone mode, you'll have to use Build APIs to fetch the build number...
//see https://www.visualstudio.com/en-us/docs/integrate/api/build/overview for build APIs...
{
buildNumber = "20161124.2";
buildId = 40;
buildUri = "vstfs:///Build/Build/40";
Console.WriteLine("Using build number: {0}; build id: {1}; build uri: {2}", buildNumber, buildId, buildUri);
}
//Client to use test run and test result APIs...
TestManagementHttpClient client = connection.GetClient <TestManagementHttpClient>();
//Test run model to initialize test run parameters..
//For automated test runs, isAutomated must be set.. Else manual test run will be created..
//<<Q: do we want to mark run in progress here?>>
RunCreateModel TestRunModel = new RunCreateModel(name: "Sample test run from CSV file against buildNumber: " + buildNumber, isAutomated: true,
startedDate: DateTime.Now.ToString(), buildId: buildId);
//Since we are doing a Asycn call, .Result will wait for the call to complete...
TestRun testRun = client.CreateTestRunAsync(teamProject, TestRunModel).Result;
Console.WriteLine("Step 1: test run created -> {0}: {1}; Run url: {2} ", testRun.Id, testRun.Name, testRun.WebAccessUrl);
string resultsFilePath;
if (args.Length == 0)
{
resultsFilePath = "Results.csv";
}
else
{
resultsFilePath = args[0];
}
//List to hold results from parsed from CSV file...
List <TestResultCreateModel> testResultsFromCsv = new List <TestResultCreateModel>();
var reader = new StreamReader(File.OpenRead(resultsFilePath));
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
Console.WriteLine("Publishing test {0}", values[0]);
//Assign values from each line in CSV to result model...
TestResultCreateModel testResultModel = new TestResultCreateModel();
testResultModel.TestCaseTitle = testResultModel.AutomatedTestName = values[0];
testResultModel.Outcome = values[1];
//Setting state to completed since we are only publishing results.
//In advanced scenarios, you can choose to create a test result,
// move it into in progress state while test test acutally runs and finally update the outcome with state as completed
testResultModel.State = "Completed";
testResultModel.ErrorMessage = values[2];
testResultModel.StackTrace = values[3];
testResultModel.StartedDate = values[4];
testResultModel.CompletedDate = values[5];
//Add the result ot the results list...
testResultsFromCsv.Add(testResultModel);
}
//Publish the results...
List <TestCaseResult> publishedResults = client.AddTestResultsToTestRunAsync(testResultsFromCsv.ToArray(), teamProject, testRun.Id).Result;
Console.WriteLine("Step 2: test results published...");
//Mark the run complete...
RunUpdateModel testRunUpdate = new RunUpdateModel(completedDate: DateTime.Now.ToString(), state: "Completed");
TestRun RunUpdateResult = client.UpdateTestRunAsync(teamProject, testRun.Id, testRunUpdate).Result;
Console.WriteLine("Step 3: Test run completed: {0}", RunUpdateResult.WebAccessUrl);
}
static void Main(string[] args)
{
string collectionUri;
//set to Uri of the TFS collection
//if this code is running in Build/Release workflow, we will fetch collection Uri from environment variable
//See https://www.visualstudio.com/en-us/docs/build/define/variables for full list of agent environment variables
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
collectionUri = Environment.GetEnvironmentVariable("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI");
Console.WriteLine("Fetched Collection (or VSTS account) from environment variable SYSTEM_TEAMFOUNDATIONCOLLECTIONURI: {0}", collectionUri);
}
else // set it to TFS instance of your choice
{
collectionUri = "http://buildmachine1:8080/tfs/DefaultCollection";
Console.WriteLine("Using Collection (or VSTS account): {0}", collectionUri);
}
//authentication..
VssConnection connection = new VssConnection(new Uri(collectionUri), new VssCredentials());
//set the team project name in which the test results must be published...
// get team project name from the agent environment variables if the script is running in Build/Release workflow..
string teamProject;
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
teamProject = Environment.GetEnvironmentVariable("SYSTEM_TEAMPROJECT");
Console.WriteLine("Fetched team project from environment variable SYSTEM_TEAMPROJECT: {0}", teamProject);
}
else //else set it the team project of your choice...
{
teamProject = "FabrikamFiber";
Console.WriteLine("Using team project: {0}", teamProject);
}
// get the build number to publish results against...
string buildNumber = null, buildUri = null, releaseUri = null, releaseEnvironmentUri = null; int buildId;
// if this code is running in build/release workflow, we will use agent environment variables for fetch build/release Uris to associate information
if (Environment.GetEnvironmentVariable("TF_BUILD") == "True")
{
//If RELEASE_RELEASEURI variable is set, then this code is running in the Release workflow, so we fetch release details
if (Environment.GetEnvironmentVariable("RELEASE_RELEASEURI") != "")
{
releaseUri = Environment.GetEnvironmentVariable("RELEASE_RELEASEURI");
Console.WriteLine("Fetched release uri from environment variable RELEASE_RELEASEURI: {0}", releaseUri);
releaseEnvironmentUri = Environment.GetEnvironmentVariable("RELEASE_ENVIRONMENTURI");
Console.WriteLine("Fetched release environemnt uri from environment variable RELEASE_ENVIRONMENTURI: {0}", releaseEnvironmentUri);
}
//note that the build used to deploy and test a Release is an Aritfact.
//If you have multiple builds or are using external artifacts like Jenkins, make sure you use Aritfact variables to find the build information
//See https://www.visualstudio.com/en-us/docs/release/author-release-definition/understanding-tasks#predefvariables for pre-defined variables available in release
//See https://www.visualstudio.com/en-us/docs/release/author-release-definition/understanding-artifacts#variables for artifact variables documentation
//For example, you'll have to use RELEASE_ARTIFACTS_<aftifactname>_BUILDID to find the build number.
//Here we are assuming a simple setup, where we are working with Team Build and using Build variables instead...
//build number is human readable format of the build name, you can confiure it's format in build options..
buildNumber = Environment.GetEnvironmentVariable("BUILD_BUILDNUMBER");
Console.WriteLine("Fetched build number from environment variable BUILD_BUILDNUMBER: {0}", buildNumber);
//build id is the id associated with the build number, which we will use to associate the test run with...
buildId = Convert.ToInt32(Environment.GetEnvironmentVariable("BUILD_BUILDID"));
Console.WriteLine("Fetched build id from environment variable BUILD_BUILDID: {0}", buildId);
//build uri is a more elaborate form of build id, in the vstfs:///Build/Build/<id> format...
//We will use this for querying test runs against this build...
buildUri = Environment.GetEnvironmentVariable("BUILD_BUILDURI");
Console.WriteLine("Fetched build uri from environment variable BUILD_BUILDURI: {0}", buildUri);
}
else //if the code is running in standalone mode, you'll have to use Build and Release APIs to fetch the build and release information...
//see https://www.visualstudio.com/en-us/docs/integrate/api/build/overview for build APIs...
//and https://www.visualstudio.com/en-us/docs/release/overview for release APIs...
{
buildNumber = "20161124.2";
buildId = 3;
buildUri = "vstfs:///Build/Build/40";
releaseUri = "vstfs:///ReleaseManagement/Release/2";
releaseEnvironmentUri = "vstfs:///ReleaseManagement/Environment/2";
Console.WriteLine("Using build number: {0}; build id: {1}; build uri: {2}; release uri: {3}; release environment uri: {4}", buildNumber, buildId, buildUri, releaseUri, releaseEnvironmentUri);
}
//Client to use test run and test result APIs...
TestManagementHttpClient client = connection.GetClient <TestManagementHttpClient>();
//Test run model to initialize test run parameters..
//For automated test runs, isAutomated must be set.. Else manual test run will be created..
//<<Q: do we want to mark run in progress here?>>
RunCreateModel TestRunModel = new RunCreateModel(name: "Sample test run from CSV file against buildNumber: " + buildNumber, isAutomated: true,
startedDate: DateTime.Now.ToString(), buildId: buildId, releaseUri: releaseUri, releaseEnvironmentUri: releaseEnvironmentUri);
//Since we are doing a Asycn call, .Result will wait for the call to complete...
TestRun testRun = client.CreateTestRunAsync(teamProject, TestRunModel).Result;
Console.WriteLine("Step 1: test run created -> {0}: {1}; Run url: {2} ", testRun.Id, testRun.Name, testRun.WebAccessUrl);
string resultsFilePath;
if (args.Length == 0)
{
resultsFilePath = "Results.csv";
}
else
{
resultsFilePath = args[0];
}
TestAttachmentRequestModel fileAttachment = GetAttachmentRequestModel(resultsFilePath);
TestAttachmentReference testAttachment = client.CreateTestRunAttachmentAsync(fileAttachment, teamProject, testRun.Id).Result;
Console.WriteLine("Created test run attachment -> Id: {0}, Url: {2}", testAttachment.Id, testAttachment.Url);
//List to hold results from parsed from CSV file...
List <TestResultCreateModel> testResultsFromCsv = new List <TestResultCreateModel>();
//TestMethodName, Outcome, ErrorMessage, StackTrace, StartedDate, CompletedDate
string traceFilePath;
List <string> resultLogFiles = new List <string>();
var reader = new StreamReader(File.OpenRead(resultsFilePath));
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
Console.WriteLine("Publishing test {0}", values[0]);
//Assign values from each line in CSV to result model...
TestResultCreateModel testResultModel = new TestResultCreateModel();
testResultModel.TestCaseTitle = testResultModel.AutomatedTestName = values[0];
testResultModel.Outcome = values[1];
//Setting state to completed since we are only publishing results.
//In advanced scenarios, you can choose to create a test result,
// move it into in progress state while test test acutally runs and finally update the outcome with state as completed
testResultModel.State = "Completed";
testResultModel.ErrorMessage = values[2];
testResultModel.StackTrace = values[3];
testResultModel.StartedDate = values[4];
testResultModel.CompletedDate = values[5];
//store the path of the attachment in a list. We will publish attachments to results after we publish results and obtain result ids.
traceFilePath = values[6]; resultLogFiles.Add(traceFilePath);
//Add the result ot the results list...
testResultsFromCsv.Add(testResultModel);
}
//Publish the results...
List <TestCaseResult> publishedResults = client.AddTestResultsToTestRunAsync(testResultsFromCsv.ToArray(), teamProject, testRun.Id).Result;
Console.WriteLine("Step 2: test results published...");
//results are published in the order they were submitted. H
//We will now loop through the results file and publish the attachments for each test result.
//Path of the attachment for each result (sample trace log) is in last column of the result csv file...
int i = 0;
foreach (TestCaseResult r in publishedResults)
{
Console.WriteLine("Adding attachment for Test Result -> Id: {0}", r.Id);
fileAttachment = GetAttachmentRequestModel(resultLogFiles.ElementAt(i++));
testAttachment = client.CreateTestResultAttachmentAsync(fileAttachment, teamProject, testRun.Id, r.Id).Result;
Console.WriteLine("Created test result attachment -> Id: {0}, Url: {1}", testAttachment.Id, testAttachment.Url);
}
//Mark the run complete...
RunUpdateModel testRunUpdate = new RunUpdateModel(completedDate: DateTime.Now.ToString(), state: "Completed");
TestRun RunUpdateResult = client.UpdateTestRunAsync(teamProject, testRun.Id, testRunUpdate).Result;
Console.WriteLine("Step 3: Test run completed: {0}", RunUpdateResult.WebAccessUrl);
}
