/// <summary>
/// Creates a new test case under the specified automation provider.
/// </summary>
/// <param name="testCase">Rhino.Api.Contracts.AutomationProvider.RhinoTestCase by which to create automation provider test case.</param>
/// <returns>The ID of the newly created entity.</returns>
public override string CreateTestCase(RhinoTestCase testCase)
{
// shortcuts
var onProject = Configuration.ConnectorConfiguration.Project;
testCase.Context[ContextEntry.Configuration] = Configuration;
var testType = $"{testCase.GetCapability(AtlassianCapabilities.TestType, "Test")}";
// setup context
testCase.Context["issuetype-id"] = $"{jiraClient.GetIssueTypeFields(idOrKey: testType, path: "id")}";
testCase.Context["project-key"] = onProject;
testCase.Context["test-sets-custom-field"] = jiraClient.GetCustomField(schema: TestSetSchema);
testCase.Context["manual-test-steps-custom-field"] = jiraClient.GetCustomField(schema: ManualTestStepSchema);
testCase.Context["test-plan-custom-field"] = jiraClient.GetCustomField(schema: AssociatedPlanSchema);
// setup request body
var requestBody = testCase.ToJiraXrayIssue();
var issue = jiraClient.Create(requestBody);
// comment
var comment = Utilities.GetActionSignature(action: "created");
jiraClient.AddComment(idOrKey: $"{issue.SelectToken("key")}", comment);
// success
Logger?.InfoFormat($"Create-Test -Project [{onProject}] -Set [{string.Join(",", testCase?.TestSuites)}] = true");
// results
return($"{issue}");
}
private static object GetUpdateBugPayload(RhinoTestCase testCase, JToken onBug, JiraClient jiraClient)
{
// setup
var comment =
$"{RhinoUtilities.GetActionSignature("updated")} " +
$"Bug status on execution [{testCase.TestRunKey}] is *{onBug.SelectToken("fields.status.name")}*.";
// verify if bug is already open
var template = testCase.BugMarkdown(jiraClient);
var description = $"{JToken.Parse(template).SelectToken("fields.description")}";
// setup
return(new
{
Update = new
{
Comment = new[]
{
new
{
Add = new
{
Body = comment
}
}
}
},
Fields = new
{
Description = description
}
});
}
/// <summary>
/// Creates an automation provider test run entity. Use this method to implement the automation
/// provider test run creation and to modify the loaded Rhino.Api.Contracts.AutomationProvider.RhinoTestRun.
/// </summary>
/// <param name="testRun">Rhino.Api.Contracts.AutomationProvider.RhinoTestRun object to modify before creating.</param>
/// <returns>Rhino.Api.Contracts.AutomationProvider.RhinoTestRun based on provided test cases.</returns>
public override RhinoTestRun OnCreateTestRun(RhinoTestRun testRun)
{
// setup: request body
var customField = jiraClient.GetCustomField(TestExecutionSchema);
var testCases = JsonConvert.SerializeObject(testRun.TestCases.Select(i => i.Key));
// load JSON body
var comment = Utilities.GetActionSignature("created");
var requestBody = Assembly.GetExecutingAssembly().ReadEmbeddedResource("create_test_execution_xray.txt")
.Replace("[project-key]", Configuration.ConnectorConfiguration.Project)
.Replace("[run-title]", TestRun.Title)
.Replace("[custom-1]", customField)
.Replace("[tests-repository]", testCases)
.Replace("[type-name]", $"{capabilities[AtlassianCapabilities.ExecutionType]}")
.Replace("[assignee]", Configuration.ConnectorConfiguration.UserName);
var responseBody = jiraClient.Create(requestBody, comment);
// setup
testRun.Key = $"{responseBody["key"]}";
testRun.Link = $"{responseBody["self"]}";
testRun.Context["runtimeid"] = $"{responseBody["id"]}";
testRun.Context[ContextEntry.Configuration] = Configuration;
// test steps handler
foreach (var testCase in TestRun.TestCases)
{
testCase.SetRuntimeKeys(testRun.Key);
}
return(testRun);
}
/// <summary>
/// Completes automation provider test run results, if any were missed or bypassed.
/// </summary>
/// <param name="testRun">Rhino.Api.Contracts.AutomationProvider.RhinoTestRun results object to complete by.</param>
public override void CompleteTestRun(RhinoTestRun testRun)
{
// exit conditions
if (Configuration.IsDryRun())
{
return;
}
// setup: failed to update
var inStatus = new[] { "TODO", "EXECUTING" };
// get all test keys to re-assign outcome
var testResults = testRun
.GetTests()
.Where(i => inStatus.Contains($"{i["status"]}"))
.Select(i => $"{i["key"]}");
// iterate: pass/fail
foreach (var testCase in testRun.TestCases.Where(i => testResults.Contains(i.Key) && !i.Inconclusive))
{
DoUpdateTestResult(testCase, inline: false);
}
// iterate: align all runs
var dataTests = testRun.TestCases.Where(i => i.Iteration > 0).Select(i => i.Key).Distinct();
var options = new ParallelOptions {
MaxDegreeOfParallelism = 1
};
Parallel.ForEach(dataTests, options, testCase =>
{
var outcome = testRun.TestCases.Any(i => i.Key.Equals(testCase) && !i.Actual) ? "FAIL" : "PASS";
if (outcome == "FAIL")
{
testRun.TestCases.FirstOrDefault(i => !i.Actual && i.Key.Equals(testCase))?.SetOutcomeByRun(outcome);
return;
}
testRun.TestCases.FirstOrDefault(i => i.Actual && i.Key.Equals(testCase))?.SetOutcomeByRun(outcome);
});
// iterate: inconclusive
foreach (var testCase in testRun.TestCases.Where(i => i.Inconclusive))
{
DoUpdateTestResult(testCase, inline: true);
}
// test plan
AttachToTestPlan(testRun);
// close
var comment = Utilities.GetActionSignature("closed");
jiraClient.CreateTransition(idOrKey: testRun.Key, transition: "Closed", resolution: "Done", comment);
}
/// <summary>
/// Creates a new test case under the specified automation provider.
/// </summary>
/// <param name="testCase">Rhino.Api.Contracts.AutomationProvider.RhinoTestCase by which to create automation provider test case.</param>
/// <returns>The ID of the newly created entity.</returns>
public override string CreateTestCase(RhinoTestCase testCase)
{
// constants: logging
const string M = "Create-Test -Project [{0}] -Set [{1}] = true";
// create jira issue
var issue = CreateTestOnJira(testCase);
// apply to context
testCase.Key = $"{issue["key"]}";
testCase.Context["jira-issue-id"] = issue == default ? string.Empty : $"{issue["id"]}";
// create test steps
CreateTestSteps(testCase);
// create & apply preconditions
var precondition = CreatePrecondition(testCase.Key, testCase.DataSource);
if (precondition != null)
{
xpandClient.AddPrecondition($"{precondition.SelectToken("id")}", testCase.Key);
}
// add to test sets
var testSets = jiraClient
.Get(idsOrKeys: testCase.TestSuites)
.Select(i => (id: $"{i.SelectToken("id")}", key: $"{i.SelectToken("key")}"));
Parallel.ForEach(testSets, options, testSet
=> xpandClient.AddTestsToSet(idAndKey: testSet, new[] { $"{issue.SelectToken("id")}" }));
// comment
var comment = Utilities.GetActionSignature(action: "created");
jiraClient.AddComment(idOrKey: issue["key"].ToString(), comment);
// success
Logger?.InfoFormat(M, Configuration.ConnectorConfiguration.Project, string.Join(", ", testCase?.TestSuites));
// results
return($"{issue}");
}
/// <summary>
/// Executes a routie of post bug creation.
/// </summary>
/// <param name="testCase">RhinoTestCase to execute routine on.</param>
public override void PostCreateBug(RhinoTestCase testCase)
{
// exit conditions
if (!testCase.Context.ContainsKey("lastBugKey"))
{
return;
}
// setup
var format = $"{Utilities.GetActionSignature("{0}")} On execution [{testCase.TestRunKey}]";
var key = $"{testCase.Context["lastBugKey"]}";
var id = GetExecution(testCase);
// put
testCase.CreateInwardLink(jiraClient, key, linkType: "Blocks", string.Format(format, "created"));
// post
var command = RavenCommandsRepository.AddDefectToExecution(keyBug: key, idExecution: id);
jiraExecutor.SendCommand(command);
}