public static void addCustomFieldValue(string fieldName, string fieldValue)
{
JiraConfiguration config = JiraConfiguration.Instance;
removeCustomFieldValue(fieldName);
config.customFields.Add(fieldName, fieldValue);
}
private void initialConnect()
{
try
{
JiraConfiguration config = JiraConfiguration.Instance;
config.ServerUrl = _JiraServerURL;
config.Password = _JiraPassword;
config.UserName = _JiraUserName;
JiraReporter.ConnectJiraServer();
//Report.Info(JiraReporter.GetServerTitle() + " -- " + JiraReporter.GetServerVersion());
}
catch (Exception e)
{
var inner = e.InnerException;
string str = "";
if (inner != null)
{
var prop = inner.GetType().GetProperty("ErrorResponse");
if (prop != null)
{
str = (string)prop.GetValue(e.InnerException, null);
}
}
Report.Error(e.Message + " (InnerException: " + e.InnerException + " -- " + str + ")");
}
}
public void Run()
{
JiraConfiguration config = JiraConfiguration.Instance;
if (!config.enabled)
{
Report.Debug("Jira integration disabled in config!");
return;
}
ITestContainer tc = checkTestCase();
if (tc.Status == Ranorex.Core.Reporting.ActivityStatus.Failed)
{
string rxField = config.RxAutomationFieldName;
string query = config.jqlQueryToConnectIssues;
config.RxAutomationFieldName = "";
config.jqlQueryToConnectIssues = "";
AutoHandleJiraIntegration ah = new AutoHandleJiraIntegration();
ah.Run();
config.RxAutomationFieldName = rxField;
config.jqlQueryToConnectIssues = query;
}
}
/// <summary>
/// Performs the playback of actions in this module.
/// </summary>
/// <remarks>You should not call this method directly, instead pass the module
/// instance to the <see cref="TestModuleRunner.Run(ITestModule)"/> method
/// that will in turn invoke this method.</remarks>
void ITestModule.Run()
{
Mouse.DefaultMoveTime = 300;
Keyboard.DefaultKeyPressTime = 100;
Delay.SpeedFactor = 1.0;
JiraConfiguration config = JiraConfiguration.Instance;
if (this.JiraProjectKey != null)
{
config.JiraProjectKey = this.JiraProjectKey;
}
if (this.JiraIssueType != null)
{
config.JiraIssueType = this.JiraIssueType;
}
if (this.JiraSummary != null)
{
config.JiraSummary = this.JiraSummary;
}
if (this.JiraDescription != null)
{
config.JiraDescription.Add(new JiraDescriptionItem(this.JiraDescription, null));
}
if (this.JiraLabels != null)
{
config.JiraLabels = this.JiraLabels;
}
if (this.StateClosed != null)
{
config.StateClosed = this.StateClosed;
}
if (this.StateReopen != null)
{
config.StateReopen = this.StateReopen;
}
if (this.RxAutomationFieldName != null && !this.RxAutomationFieldName.Equals(""))
{
config.RxAutomationFieldName = this.RxAutomationFieldName;
}
if (this.jqlQueryToConnectIssues != null)
{
config.jqlQueryToConnectIssues = this.jqlQueryToConnectIssues;
}
if (this.jiraIssuePriority != null)
{
config.JiraIssuePriority = jiraIssuePriority;
}
initialConnect();
}
public static void addCustomCascadingField(string fieldName, string parentValue, string childValue)
{
JiraConfiguration config = JiraConfiguration.Instance;
removeCustomCascadingFieldValue(fieldName);
string[] values = { parentValue, childValue };
config.customCascadingFields.Add(fieldName, values);
}
public static void removeCustomCascadingFieldValue(string fieldName)
{
JiraConfiguration config = JiraConfiguration.Instance;
if (config.customCascadingFields.ContainsKey(fieldName))
{
config.customCascadingFields.Remove(fieldName);
}
}
private static void updateStandardFields(Issue issue, string testCaseName)
{
JiraConfiguration config = JiraConfiguration.Instance;
if (config.JiraIssuePriority != null && config.JiraIssuePriority.Length > 0)
{
updatePriority(issue, config.JiraIssuePriority);
}
if (config.JiraEnvironment != null && config.JiraEnvironment.Length > 0)
{
updateEnvironment(issue, config.JiraEnvironment);
}
issue.Description = ".";
issue.Summary = testCaseName + ": " + config.JiraSummary;
foreach (string label in config.getAllLabels())
{
issue.Labels.Add(label);
}
if (config.AffectsVersions != null && config.AffectsVersions.Length > 0)
{
string[] versions = config.AffectsVersions.Split(';');
issue.AffectsVersions.Clear();
foreach (string version in versions)
{
issue.AffectsVersions.Add(version);
}
}
if (config.Assignee != null && config.Assignee.Length > 0)
{
issue.Assignee = config.Assignee;
}
if (config.DueDate != null && config.DueDate.Length > 0)
{
issue.DueDate = DateTime.Parse(config.DueDate);
}
if (config.FixVersions != null && config.FixVersions.Length > 0)
{
string[] versions = config.FixVersions.Split(';');
issue.FixVersions.Clear();
foreach (string version in versions)
{
issue.FixVersions.Add(version);
}
}
}
/// <summary>
/// Performs the playback of actions in this module.
/// </summary>
/// <remarks>You should not call this method directly, instead pass the module
/// instance to the <see cref="TestModuleRunner.Run(ITestModule)"/> method
/// that will in turn invoke this method.</remarks>
public void Run()
{
ITestContainer tc = checkTestCase();
JiraConfiguration config = JiraConfiguration.Instance;
IEnumerable issues = null;
if ((config.jqlQueryToConnectIssues == null || config.jqlQueryToConnectIssues.Length == 0) &&
(config.RxAutomationFieldName == null || config.RxAutomationFieldName.Length == 0))
{
issues = Enumerable.Empty <Issue>();
}
else if (config.jqlQueryToConnectIssues.Length > 0)
{
issues = JiraReporter.getJiraIssues(config.jqlQueryToConnectIssues);
}
else
{
issues = JiraReporter.getJiraIssues("'" + config.RxAutomationFieldName + "' ~ '" + tc.Name + "'");
}
if (tc.Status == Ranorex.Core.Reporting.ActivityStatus.Failed)
{
bool isEmpty = true;
foreach (Issue issue in issues)
{
if (!issue.Status.Name.Contains(config.StateReopen))
{
reopenIssue(issue.Key.ToString(), config.StateReopen);
}
else
{
Report.Info("Jira issue is already open -- IssueKey: " + issue.Key.ToString() + "; IssueID: " + issue.Key.ToString());
Report.LogHtml(ReportLevel.Info, "<a href=\"" + JiraReporter.ServerURL + "browse/" + issue.Key.ToString() + "\">" + issue.Key.ToString() + "</a>");
}
isEmpty = false;
}
if (isEmpty)
{
createIssue(tc);
}
}
else if (tc.Status == Ranorex.Core.Reporting.ActivityStatus.Success)
{
foreach (Issue issue in issues)
{
if (!issue.Status.Name.Contains(config.StateClosed))
{
resolveIssue(issue.Key.ToString(), config.StateClosed);
}
}
}
}
void ITestModule.Run()
{
JiraConfiguration config = JiraConfiguration.Instance;
if (!config.enabled)
{
Report.Debug("Jira integration disabled in config!");
return;
}
var tc = TestSuite.CurrentTestContainer;
if (tc == null)
{
Report.Error("TestCase is 'null'; this usually happens when the module is used outside of testcases (e.g., global teardown).");
}
if (tc.Status == Ranorex.Core.Reporting.ActivityStatus.Failed)
{
try
{
char delimiterChar = ';';
List <string> labels = null;
if (!string.IsNullOrEmpty(JiraLabels))
{
labels = new List <string>(JiraLabels.Split(delimiterChar));
}
var curIssue = JiraReporter.UpdateIssue(JiraIssueKey, tc.Name, JiraSummary, JiraDescription, labels, true);
Report.Info("Jira issue updated -- IssueKey: " + curIssue.Key + "; IssueID: " + curIssue.Id);
Report.LogHtml(ReportLevel.Info, "<a href=\"" + JiraReporter.ServerURL + "/browse/" + curIssue.Id + "\">" + curIssue.Id + "</a>");
}
catch (Exception e)
{
var inner = e.InnerException;
string str = "";
if (inner != null)
{
var prop = inner.GetType().GetProperty("ErrorResponse");
if (prop != null)
{
str = (string)prop.GetValue(e.InnerException, null);
}
}
Report.Error(e.Message + " (InnerException: " + e.InnerException + " -- " + str + ")");
}
}
}
void writeBatchFile(string batFileName, string reportFileName, string testcaseName)
{
ITestContainer tc = TestSuite.CurrentTestContainer;
JiraConfiguration config = JiraConfiguration.Instance;
var file = File.CreateText(batFileName);
string chageDirectory = String.Format("CD \"{0}\"", JiraCLIFileLocation.Substring(0, JiraCLIFileLocation.LastIndexOf('\\') + 1));
// Jira WebService calls for CLI environment
string jiraCall = String.Format("CALL \"{0}\" {1} {2} {3} {4} ",
JiraCLIFileLocation.Substring(JiraCLIFileLocation.LastIndexOf('\\') + 1), config.ServerUrl, config.UserName, config.Password, tc.Name);
string actionCreateIssue = String.Format("{0} \"{1}\" \"{2}\" \"{3}\" ",
config.JiraProjectKey, config.JiraIssueType, config.JiraSummary, getDescriptionString(config));
if (!string.IsNullOrEmpty(config.JiraLabels))
{
actionCreateIssue = actionCreateIssue + String.Format(" \"{0}\" ", config.JiraLabels);
}
actionCreateIssue += String.Format("\"{0}\" ",
System.IO.Path.Combine(Ranorex.Core.Reporting.TestReport.ReportEnvironment.ReportFileDirectory, reportFileName));
actionCreateIssue += String.Format("\"{0}\" ", attachments);
file.WriteLine("@ECHO off");
file.WriteLine(chageDirectory);
file.WriteLine(String.Format("{0} {1} %* > return_string_{2}.txt", jiraCall, actionCreateIssue, testcaseName));
file.WriteLine(String.Format("type return_string_{0}.txt", testcaseName));
//parse return string from Jira WebService call to get issue ID
file.WriteLine(String.Format("FOR /F \"tokens=2,6,8 delims== \" %%I IN (return_string_{0}.txt) DO ( set KEY=%%I & set ID=%%J & set URL=%%K)", testcaseName));
file.WriteLine("set ID=%ID:~0,-1%");
//prompt if user wants to review the created issue in the default browser
file.WriteLine("if %errorlevel% neq 0 echo ERROR: Something went wrong uploading the issue! & pause");
file.WriteLine("if %errorlevel% neq 0 exit /b %errorlevel%");
file.WriteLine("echo Issue created and report uploaded");
file.WriteLine("set /p answer=Do you want to open the issue in your default browser (Y/[N])?");
file.WriteLine("if /i \"%answer:~,1%\" EQU \"Y\" start %URL%");
file.WriteLine("else exit /b");
file.WriteLine("echo Please type Y for Yes or N for No");
file.Close();
file.Dispose();
}
public static string updateDescription(Issue issue, JiraConfiguration config)
{
string descriptionString = "";
foreach (JiraDescriptionItem item in config.JiraDescription)
{
descriptionString += "\r\n " + item.text;
if (item.isImageEntry())
{
issue.AddAttachment(item.getValue());
descriptionString += "\r\n !" + Path.GetFileName(item.getValue()) + "!";
}
}
return(descriptionString);
}
public void Run()
{
JiraConfiguration config = JiraConfiguration.Instance;
if (!config.enabled)
{
Report.Debug("Jira integration disabled in config!");
return;
}
var tc = checkTestCase();
if (tc.Status == Ranorex.Core.Reporting.ActivityStatus.Success)
{
resolveIssue(JiraIssueKey, TransitionName);
}
}
public static void updateSummary()
{
ITestContainer tc = TestSuite.CurrentTestContainer;
string testCaseName = tc.Name;
Ranorex.Core.Reporting.ActivityStack.Instance.VisitAll(activity => {
if ((activity.GetType().Name.Equals("TestContainerActivity") &&
activity.Status == ActivityStatus.Failed &&
(activity as ITestContainerActivity).ContainerName.Equals(testCaseName))
)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.JiraSummary = getFailedAction(activity);
}
return(true);
});
}
private static void addCustomCascadingFields(Issue issue)
{
JiraConfiguration config = JiraConfiguration.Instance;
foreach (string key in config.customCascadingFields.Keys)
{
string[] value = null;
config.customCascadingFields.TryGetValue(key, out value);
if (key.Equals(""))
{
Ranorex.Report.Log(Ranorex.ReportLevel.Warn, "An invalid custom field is configured for jira. field name: '" + key + "' field value: '" + value + "'");
}
else
{
CascadingSelectCustomField field = new CascadingSelectCustomField(key, value[0], value[1]);
issue.CustomFields.AddCascadingSelectField(field);
}
}
}
string getDescriptionString(JiraConfiguration config)
{
string descriptionString = "";
foreach (JiraDescriptionItem item in config.JiraDescription)
{
descriptionString += "{LB} " + item.text;
if (item.isImageEntry())
{
if (attachments.Length > 0)
{
attachments += ";";
}
attachments += System.IO.Path.Combine(Ranorex.Core.Reporting.TestReport.ReportEnvironment.ReportFileDirectory, item.getValue());
descriptionString += "{LB} !" + Path.GetFileName(item.getValue()) + "!";
}
}
return(descriptionString);
}
public static JiraIssue CreateIssue(string testCaseName, bool attachReport)
{
CheckIfClientConnected();
JiraConfiguration config = JiraConfiguration.Instance;
if (GetIssueType(config.JiraProjectKey, config.JiraIssueType) == null)
{
throw (new Exception(String.Format("Issue Type '{0}' not found!", config.JiraIssueType)));
}
Issue issue = client.CreateIssue(config.JiraProjectKey);
issue.Type = config.JiraIssueType;
updateStandardFields(issue, testCaseName);
addCustomFields(issue, testCaseName);
addCustomCascadingFields(issue);
issue.SaveChanges();
string newDesc = updateDescription(issue, config);
if (newDesc.Length > 0)
{
issue.Description = newDesc;
}
if (attachReport)
{
addRanorexReport(issue);
}
issue.SaveChanges();
var jiraIssue = new JiraIssue(issue.Key.ToString(), issue.JiraIdentifier);
return(jiraIssue);
}
public static void removeLabel(string label)
{
JiraConfiguration config = JiraConfiguration.Instance;
string oldLabels = config.JiraLabels;
string[] labels = oldLabels.Split(';');
string newLabels = "";
foreach (string lab in labels)
{
if (!newLabels.Equals(""))
{
newLabels += ";";
}
if (!lab.Equals(label))
{
newLabels += lab;
}
}
JiraFieldHelper.setLabels(newLabels);
}
public static void removeAffectsVersions(string version)
{
JiraConfiguration config = JiraConfiguration.Instance;
string oldVersions = config.AffectsVersions;
string[] versions = oldVersions.Split(';');
string newVersions = "";
foreach (string ver in versions)
{
if (!newVersions.Equals(""))
{
newVersions += ";";
}
if (!ver.Equals(version))
{
newVersions += ver;
}
}
JiraFieldHelper.setAffectsVersions(newVersions);
}
private static void addCustomFields(Issue issue, string testCaseName)
{
JiraConfiguration config = JiraConfiguration.Instance;
if (config.RxAutomationFieldName != null && !config.RxAutomationFieldName.Equals("") && !config.customFields.ContainsKey(config.RxAutomationFieldName))
{
config.customFields.Add(config.RxAutomationFieldName, testCaseName);
}
foreach (string key in config.customFields.Keys)
{
string value = null;
config.customFields.TryGetValue(key, out value);
if (key.Equals(""))
{
Ranorex.Report.Log(Ranorex.ReportLevel.Warn, "An invalid custom field is configured for jira. field name: '" + key + "' field value: '" + value + "'");
}
else
{
issue.CustomFields.Add(key, value);
}
}
}
public static void addNewLineToDescription(string line)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.JiraDescription.Add(new JiraDescriptionItem("\r\n " + line, null));
}
public static void clearDescription()
{
JiraConfiguration config = JiraConfiguration.Instance;
config.JiraDescription.Clear();
}
public static void setAssignee(string assignee)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.Assignee = assignee;
}
public static void setJiraJQLQuery(string query)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.jqlQueryToConnectIssues = query;
}
public static void setJiraIssueKey(string key)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.transientConfig.JiraIssueKey = key.Trim();
}
public static void addNewLabel(string label)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.JiraLabels += ";" + label;
}
public static void setLabels(string labels)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.JiraLabels = labels;
}
public static void setEnvironment(string environment)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.JiraEnvironment = environment;
}
public static void setAffectsVersions(string versions)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.AffectsVersions = versions;
}
public static void setDueDate(string dueDate)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.DueDate = dueDate;
}
public static void addAffectsVersions(string version)
{
JiraConfiguration config = JiraConfiguration.Instance;
config.AffectsVersions += ";" + version;
}
