/// <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}");
}
/// <summary>
/// Create the JiraApi, using OAuth 1 for the communication, here the HttpClient is configured
/// </summary>
/// <param name="baseUri">Base URL, e.g. https://yourjiraserver</param>
/// <param name="jiraOAuthSettings">JiraOAuthSettings</param>
/// <param name="httpSettings">IHttpSettings or null for default</param>
public static IJiraClient Create(Uri baseUri, JiraOAuthSettings jiraOAuthSettings, IHttpSettings httpSettings = null)
{
JiraClient client = JiraClient.Create(baseUri, httpSettings) as JiraClient;
var jiraOAuthUri = client.JiraBaseUri.AppendSegments("plugins", "servlet", "oauth");
var oAuthSettings = new OAuth1Settings
{
TokenUrl = jiraOAuthUri.AppendSegments("request-token"),
TokenMethod = HttpMethod.Post,
AccessTokenUrl = jiraOAuthUri.AppendSegments("access-token"),
AccessTokenMethod = HttpMethod.Post,
CheckVerifier = false,
SignatureType = OAuth1SignatureTypes.RsaSha1,
Token = jiraOAuthSettings.Token,
ClientId = jiraOAuthSettings.ConsumerKey,
CloudServiceName = jiraOAuthSettings.CloudServiceName,
RsaSha1Provider = jiraOAuthSettings.RsaSha1Provider,
AuthorizeMode = jiraOAuthSettings.AuthorizeMode,
AuthorizationUri = jiraOAuthUri.AppendSegments("authorize")
.ExtendQuery(new Dictionary <string, string>
{
{
OAuth1Parameters.Token.EnumValueOf(), "{RequestToken}"
},
{
OAuth1Parameters.Callback.EnumValueOf(), "{RedirectUrl}"
}
})
};
// Configure the OAuth1Settings
client.Behaviour = client.ConfigureBehaviour(OAuth1HttpBehaviourFactory.Create(oAuthSettings), httpSettings);
return(client);
}
public async Task Test_SearchSnippet()
{
// begin-snippet: SearchExample
var client = JiraClient.Create(TestJiraUri);
// Preferably use a "bot" user for maintenance
var username = Environment.GetEnvironmentVariable("jira_test_username");
var password = Environment.GetEnvironmentVariable("jira_test_password");
client.SetBasicAuthentication(username, password);
const string unavailableUser = "******";
// Find all issues in a certain state and assigned to a user who is not available
var searchResult = await client.Issue.SearchAsync(Where.And(Where.Assignee.Is(unavailableUser), Where.Status.Is("Building")));
foreach (var issue in searchResult.Issues)
{
// Remote the assignment, to make clear no-one is working on it
await issue.AssignAsync(User.Nobody);
// Comment the reason to the issue
await issue.AddCommentAsync($"{unavailableUser} is currently not available.");
}
// end-snippet
}
public JiraConnector(IJiraConfiguration jiraConfiguration, JiraMonitor jiraMonitor)
{
jiraConfiguration.Url = jiraConfiguration.Url.Replace(DefaultPostfix, "");
_jiraConfiguration = jiraConfiguration;
_jiraMonitor = jiraMonitor;
_jiraClient = JiraClient.Create(new Uri(jiraConfiguration.Url));
}
public async Task StartupAsync(CancellationToken cancellationToken = new CancellationToken())
{
Log.Debug().WriteLine("StartAsync called!");
var serverInfo = await JiraClient.Create(new Uri("https://greenshot.atlassian.net")).Server.GetInfoAsync(cancellationToken).ConfigureAwait(false);
Log.Debug().WriteLine("Jira server version {0}", serverInfo.Version);
await Task.Delay(100, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Override the BeginProcessingAsync to connect to our jira
/// </summary>
protected override Task BeginProcessingAsync()
{
JiraApi = JiraClient.Create(JiraUri);
if (Username != null)
{
JiraApi.SetBasicAuthentication(Username, Password);
}
return(Task.FromResult(true));
}
/// <summary>
/// Creates a bug based on this RhinoTestCase.
/// </summary>
/// <param name="testCase">RhinoTestCase by which to create a bug.</param>
/// <returns>Bug creation results from Jira.</returns>
public static JToken CreateBug(this RhinoTestCase testCase, JiraClient jiraClient)
{
// setup
var issueBody = testCase.BugMarkdown(jiraClient);
// post
var response = jiraClient.Create(issueBody);
if (response == default)
{
return(default);
public JiraConnector(
IJiraConfiguration jiraConfiguration,
JiraMonitor jiraMonitor,
ICoreConfiguration coreConfiguration,
INetworkConfiguration networkConfiguration)
{
jiraConfiguration.Url = jiraConfiguration.Url.Replace(DefaultPostfix, "");
_jiraConfiguration = jiraConfiguration;
_jiraMonitor = jiraMonitor;
_coreConfiguration = coreConfiguration;
_jiraClient = JiraClient.Create(new Uri(jiraConfiguration.Url), networkConfiguration);
}
/// <summary>
/// Default test setup, can also take care of setting the authentication
/// </summary>
/// <param name="testOutputHelper"></param>
/// <param name="doLogin"></param>
protected TestBase(ITestOutputHelper testOutputHelper, bool doLogin = true)
{
// For tests, make sure we get everything
DefaultJsonHttpContentConverter.Instance.Value.LogThreshold = 0;
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
Client = JiraClient.Create(TestJiraUri);
Username = Environment.GetEnvironmentVariable("jira_test_username");
Password = Environment.GetEnvironmentVariable("jira_test_password");
if (doLogin && !string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password))
{
Client.SetBasicAuthentication(Username, Password);
}
}
private JToken CreateTestOnJira(RhinoTestCase testCase)
{
// shortcuts
var onProject = Configuration.ConnectorConfiguration.Project;
var testType = $"{capabilities[AtlassianCapabilities.TestType]}";
// setup context
testCase.Context["issuetype-id"] = $"{jiraClient.GetIssueTypeFields(idOrKey: testType, path: "id")}";
testCase.Context["project-key"] = onProject;
// setup request body
var issue = jiraClient.Create(testCase.ToJiraCreateRequest()).AsJObject();
if (issue == default || !issue.ContainsKey("id"))
{
logger?.Fatal("Was not able to create a test case.");
return(default);
/// <summary>
/// Default test setup, can also take care of setting the authentication
/// </summary>
/// <param name="testOutputHelper"></param>
/// <param name="doLogin"></param>
protected TestBase(ITestOutputHelper testOutputHelper, bool doLogin = true)
{
var defaultJsonHttpContentConverterConfiguration = new DefaultJsonHttpContentConverterConfiguration
{
LogThreshold = 0
};
HttpBehaviour.Current.SetConfig(defaultJsonHttpContentConverterConfiguration);
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
Client = JiraClient.Create(TestJiraUri);
Username = Environment.GetEnvironmentVariable("jira_test_username");
Password = Environment.GetEnvironmentVariable("jira_test_password");
if (doLogin && !string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password))
{
Client.SetBasicAuthentication(Username, Password);
}
}
public OAuthTests(ITestOutputHelper testOutputHelper)
{
// A demo Private key, to create a RSACryptoServiceProvider.
// This was created from a .pem via a tool here http://www.jensign.com/opensslkey/index.html
const string privateKeyXml = @"<RSAKeyValue><Modulus>tGIwsCH2KKa6vxUDupW92rF68S5SRbgr7Yp0xeadBsb0BruTt4GMrVL7QtiZWM8qUkY1ccMa7LkXD93uuNUnQEsH65s8ryID9P
DeEtCBcxFEZFdcKfyKR+5B+NRLW5lJq10sHzWbJ0EROUmEjoYfi3CtsMkJHYHDL9dZeCqAZHM=</Modulus><Exponent>AQAB</Exponent><P>14DdDg26
CrLhAFQIQLT1KrKVPYr0Wusi2ovZApz2/RnM7a7CWUJuDR3ClW5g9hdi+KQ0ceD5oJYX5Vexv2uk+w==</P><Q>1kfU0+DkXc6I/jXHJ6pDLA5s7dBHzWgDs
BzplSdkVQbKT3MbeYjeByOxzXhulOWLBQW/vxmW4HwU95KTRlj06Q==</Q><DP>SPoBYY3yb0cN/J94P/lHgJMDCNkyUEuJ/PoYndLrrN/8zow8kh91xwlJ6
HJ9cTiQMmTgwaOOxPuu0eI1df4M2w==</DP><DQ>klJaspRPXP877NssM5nAZMU0/O/NGCZ+3jPgDUno6WbJn5cqm8MqWhW1xGkImgRk+fkDBquiq4gPiT89
8jusgQ==</DQ><InverseQ>d5Zrr6Q8AO/0isr/3aa6O6NLQxISLKcPDk2NOccAfS/xOtfOz4sJYM3+Bs4Io9+dZGSDCA54Lw03eHTNQghS0A==</Inverse
Q><D>WFlbZXlM2r5G6z48tE+RTKLvB1/btgAtq8vLw/5e3KnnbcDD6fZO07m4DRaPjRryrJdsp8qazmUdcY0O1oK4FQfpprknDjP+R1XHhbhkQ4WEwjmxPst
ZMUZaDWF58d3otc23mCzwh3YcUWFu09KnMpzZsK59OfyjtkS44EDWpbE=</D></RSAKeyValue>";
// Create the RSACryptoServiceProvider for the XML above
var rsaCryptoServiceProvider = new RSACryptoServiceProvider();
rsaCryptoServiceProvider.FromXmlString(privateKeyXml);
// Configure the XUnitLogger for logging
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
// Only a few settings for the Jira OAuth are important
var oAuthSettings = new JiraOAuthSettings
{
// Is specified on the linked-applications as consumer key
ConsumerKey = "lInXLgx6HbF9FFq1ZQN8iSEnhzO3JVuf",
// This needs to have the private key, the represented public key is set in the linked-applications
RsaSha1Provider = rsaCryptoServiceProvider,
// Use a server at Localhost to redirect to, alternative an embedded browser can be used
AuthorizeMode = AuthorizeModes.LocalhostServer,
// When using the embbed browser this is directly visible, with the LocalhostServer it's in the info notice after a redirect
CloudServiceName = "Greenshot Jira",
// the IOAuth1Token implementation, here it's this, gets the tokens to store & retrieve for later
Token = this
};
// Create the JiraApi for the Uri and the settings
_jiraApi = JiraClient.Create(TestJiraUri, oAuthSettings);
}
/// <summary>
/// Internal login which catches the exceptions
/// </summary>
/// <returns>true if login was done sucessfully</returns>
private async Task <bool> DoLoginAsync(string user, string password, CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrEmpty(user) || string.IsNullOrEmpty(password))
{
return(false);
}
_jiraClient = JiraClient.Create(new Uri(JiraConfig.Url));
_jiraClient.Behaviour.SetConfig(new SvgConfiguration {
Width = CoreConfig.IconSize.Width, Height = CoreConfig.IconSize.Height
});
_issueTypeBitmapCache = new IssueTypeBitmapCache(_jiraClient);
LoginInfo loginInfo;
try
{
loginInfo = await _jiraClient.Session.StartAsync(user, password, cancellationToken);
Monitor = new JiraMonitor();
await Monitor.AddJiraInstanceAsync(_jiraClient, cancellationToken);
var favIconUri = _jiraClient.JiraBaseUri.AppendSegments("favicon.ico");
try
{
FavIcon = await _jiraClient.Server.GetUriContentAsync <Bitmap>(favIconUri, cancellationToken);
}
catch (Exception ex)
{
Log.WarnFormat("Couldn't load favicon from {0}", favIconUri);
Log.Warn("Exception details: ", ex);
}
}
catch (Exception)
{
return(false);
}
return(loginInfo != null);
}
public void TestConstructor()
{
Assert.Throws <ArgumentNullException>(() => JiraClient.Create(null));
}
private JiraClient CreateClient()
{
var client = JiraClient.Create(this.BaseUrl, this.UserName, this.Password, this, this.ApiType);
return(client);
}
public bool Connect(Credential credentials)
{
client = JiraClient.Create(new Uri(credentials.Uri));
client.SetBasicAuthentication(credentials.Username, credentials.Password);
return(true);
}
