public static JiraAssignProjectResult AssignProject(JiraCredentials credential, JiraAssignProjectModel jiraAssignmentModel)
{
var response = JiraUtility.Post <JiraAssignProjectModel, JiraProjectRolesResponseModel>($"project/{jiraAssignmentModel.ProjectIdOrKey}/role/{jiraAssignmentModel.RoleId}",
credential, jiraAssignmentModel, HttpStatusCode.OK);
return(new JiraAssignProjectResult(response));
}
private void CreateEntities(JiraCredentials credential)
{
newUser = TestData.GetJiraUser();
createUserResult = UserSteps.CreateUser(credential, newUser);
project = TestData.GetJiraProject(createUserResult.Data);
createProjectResult = ProjectSteps.CreateProject(credential, project);
}
//private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);//adds logging
static void Main(string[] args)
{
//Log.ConsoleOutput = false;
Log.ExternalOutput = false; //TEMP
DateTime now = DateTime.Now;
if (Log.ExternalOutput)
{
Log.LogName = (string.Format("{0} {1}{2}{3}{4}{5}{6} startup", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond));
}
Program p = new Program();
JiraCredentials jCredentials = new JiraCredentials("IsaacA", "ia"); //login details
Log.LogMessage(string.Format("[username] = {0}\n[password] = {1}", jCredentials.UserName, jCredentials.Password));
string jiraUrl = "http://jira.c660cnc.siemens.cloud:8080"; //jira base url
Log.LogMessage(string.Format("Connecting to \"{0}\"...", jiraUrl));
var jiraConn = Jira.CreateRestClient(jiraUrl, jCredentials.UserName, jCredentials.Password); //connection to jira (doesn't open it here)
Log.LogMessage("Rest Client Created");
jiraConn.Issues.MaxIssuesPerRequest = 1000;
p.Test(jiraConn);
Console.ReadKey();
}
private void TestAssignIssue(JiraCredentials credential)
{
CreateEntities(credential);
if (credential.JiraConnection == JiraConnectionType.JiraCloud)
{
Thread.Sleep(10000); // Jira won't allow to AssignIssue without this pause (after User creating).
}
try
{
var result = ProjectSteps.GetProjectMetadateByKey(credential, project.Key);
JiraProjectMetadataModel projectMetadata = result.Data;
var issue = TestData.GetJiraIssue(projectMetadata.Id, projectMetadata.Issuetypes[0].Id);
JiraCreateIssueResult CreateIssueResult = IssueSteps.CreateIssue(credential, issue);
JiraAssigneeModel Assign = new JiraAssigneeModel
{
AccountId = createUserResult.Data.AccountId,
Key = createUserResult.Data.Key,
IssueIdOrKey = CreateIssueResult.Data.Key
};
BaseJiraResult AssigneResult = IssueSteps.AssignIssue(credential, Assign);
Assert.AreEqual(AssigneResult.Status, JiraResultStatus.Success);
}
finally
{
DeleteEntities(credential);
}
}
private TestableJira(JiraCredentials credentials = null)
: base(new ServiceLocator(), credentials)
{
RestService = new Mock <IJiraRestClient>();
FileSystem = new Mock <IFileSystem>();
Translator = new Mock <IJqlExpressionVisitor>();
IssueTypeService = new Mock <IIssueTypeService>();
IssueFieldService = new Mock <IIssueFieldService>();
IssueFilterService = new Mock <IIssueFilterService>();
IssueService = new Mock <IIssueService>();
IssuePriorityService = new Mock <IIssuePriorityService>();
IssueResolutionService = new Mock <IIssueResolutionService>();
Services.Register <IIssueTypeService>(() => IssueTypeService.Object);
Services.Register <IIssueFieldService>(() => IssueFieldService.Object);
Services.Register <IIssueFilterService>(() => IssueFilterService.Object);
Services.Register <IIssueService>(() => IssueService.Object);
Services.Register <IJqlExpressionVisitor>(() => Translator.Object);
Services.Register <IFileSystem>(() => FileSystem.Object);
Services.Register <IJiraRestClient>(() => RestService.Object);
Services.Register <IIssuePriorityService>(() => IssuePriorityService.Object);
Services.Register <IIssueResolutionService>(() => IssueResolutionService.Object);
Translator.Setup(t => t.Process(It.IsAny <Expression>())).Returns(new JqlData()
{
Expression = "dummy expression"
});
}
private void TestEditUser(JiraCredentials credential)
{
var editedUser = TestData.GetJiraUser();
JiraCreateUserResult createUserResult = UserSteps.CreateUser(credential, editedUser);
JiraUserModel newUserData = new JiraUserModel
{
DisplayName = "edited" + editedUser.DisplayName,
EmailAddress = "edited" + editedUser.EmailAddress,
Name = "edited" + editedUser.Name,
Password = null
};
try
{
var EditUserResult = UserSteps.EditUser(credential, createUserResult.Data.Key, newUserData);
Assert.AreEqual(EditUserResult.Status, JiraResultStatus.Success);
}
finally
{
try
{
UserSteps.DeleteUser(credential, createUserResult.Data.Key); // for Jira server
UserSteps.DeleteUser(credential, createUserResult.Data.AccountId); // for Jira cloud
}
catch { }
}
}
private void TestEditIssue(JiraCredentials credential)
{
CreateEntities(credential);
try
{
var result = ProjectSteps.GetProjectMetadateByKey(credential, project.Key);
JiraProjectMetadataModel projectMetadata = result.Data;
var issue = TestData.GetJiraIssue(projectMetadata.Id, projectMetadata.Issuetypes[0].Id);
JiraCreateIssueResult createIssueResult = IssueSteps.CreateIssue(credential, issue);
issue.IssueIdOrKey = createIssueResult.Data.Key;
issue.Issuetype = null;
issue.Summary = null;
issue.Description = "new edited description";
issue.Project = null;
BaseJiraResult editResult = IssueSteps.EditIssue(credential, issue);
Assert.AreEqual(editResult.Status, JiraResultStatus.Success);
}
finally
{
DeleteEntities(credential);
}
}
public static TestableJira Create(JiraCredentials credentials = null)
{
// switch thread locale to avoid "2016/01/01 does not equal 2016.01.01" errors
Thread.CurrentThread.CurrentCulture = TestCulture;
Thread.CurrentThread.CurrentUICulture = TestCulture;
return(new TestableJira(credentials));
}
public static BaseJiraResult AssignIssue(JiraCredentials credential, JiraAssigneeModel Assign)
{
var response = JiraUtility.Put <JiraAssigneeModel, JiraEmptyResponseModel>($"issue/{Assign.IssueIdOrKey}/assignee", credential, Assign, HttpStatusCode.NoContent);
return(new BaseJiraResult {
ErrorMessage = response.ErrorMessage, Status = response.Status, HttpStatus = response.HttpStatus
});
}
private void DeleteEntities(JiraCredentials credential)
{
try
{
UserSteps.DeleteUser(credential, createUserResult.Data.Key); // for Jira server
UserSteps.DeleteUser(credential, createUserResult.Data.AccountId); // for Jira cloud
}
catch (Exception ex) { _ = ex.Message; }
}
public static JiraCreateIssueResult CreateIssue(JiraCredentials credential, JiraIssueModel newIssue)
{
var DataObj = new ActualJiraIssueModel {
Fields = newIssue
};
var response = JiraUtility.Post <ActualJiraIssueModel, JiraBaseResponseModel>("issue", credential, DataObj, HttpStatusCode.Created);
return(new JiraCreateIssueResult(response));
}
private void TestCreateUser(JiraCredentials credential)
{
var newUser = TestData.GetJiraUser();
JiraCreateUserResult createUserResult = UserSteps.CreateUser(credential, newUser);
Assert.AreEqual(createUserResult.Status, JiraResultStatus.Success);
UserSteps.DeleteUser(credential, createUserResult.Data.AccountId); // for Jira Cloud
UserSteps.DeleteUser(credential, createUserResult.Data.Key); // for Jira server
}
public static JiraCreateUserResult EditUser(JiraCredentials credential, string key, JiraUserModel jiraUserModel)
{
if (credential.JiraConnection != JiraConnectionType.JiraServer)
{
throw new BusinessRuleException("EditUser step can be used only for JiraConnectionType.JiraServer connection");
}
var response = JiraUtility.Put <JiraUserModel, JiraCreateUserResponseModel>($"user?key={key}", credential, jiraUserModel, HttpStatusCode.OK);
return(new JiraCreateUserResult(response));
}
public static BaseJiraResult EditIssue(JiraCredentials credential, JiraIssueModel Issue)
{
var DataObj = new ActualJiraIssueModel {
Fields = Issue
};
var response = JiraUtility.Put <ActualJiraIssueModel, JiraEmptyResponseModel>($"issue/{Issue.IssueIdOrKey}", credential, DataObj, HttpStatusCode.NoContent);
return(new BaseJiraResult {
ErrorMessage = response.ErrorMessage, Status = response.Status, HttpStatus = response.HttpStatus
});
}
public static BaseJiraResult SetUserPassword(JiraCredentials credential, string key, string newPassword)
{
if (credential.JiraConnection != JiraConnectionType.JiraServer)
{
throw new BusinessRuleException("SetUserPassword step can be used only for JiraConnectionType.JiraServer connection");
}
UserPasswordModel password = new UserPasswordModel {
Password = newPassword
};
var response = JiraUtility.Put <UserPasswordModel, JiraEmptyResponseModel>($"user/password?key={key}", credential, password, HttpStatusCode.NoContent);
return(new BaseJiraResult {
ErrorMessage = response.ErrorMessage, Status = response.Status, HttpStatus = response.HttpStatus
});
}
private void TestCreateProject(JiraCredentials credential)
{
CreateEntities(credential);
JiraProjectModel project = TestData.GetJiraProject(createUserResult.Data);
try
{
var response = ProjectSteps.CreateProject(credential, project);
Assert.AreEqual(response.Status, JiraResultStatus.Success);
}
finally
{
ProjectSteps.DeleteProject(credential, project.ProjectIdOrKey);
DeleteEntities(credential);
}
}
private void TestCreateIssue(JiraCredentials credential)
{
CreateEntities(credential);
try
{
var result = ProjectSteps.GetProjectMetadateByKey(credential, project.Key);
JiraProjectMetadataModel projectMetadata = result.Data;
var issue = TestData.GetJiraIssue(projectMetadata.Id, projectMetadata.Issuetypes[0].Id);
JiraCreateIssueResult CreateResult = IssueSteps.CreateIssue(credential, issue);
Assert.AreEqual(CreateResult.Status, JiraResultStatus.Success);
}
finally
{
DeleteEntities(credential);
}
}
private void TestDeleteUser(JiraCredentials credential)
{
var newUser = TestData.GetJiraUser();
JiraCreateUserResult createUserResult = UserSteps.CreateUser(credential, newUser);
BaseJiraResult deleteResult;
if (credential.JiraConnection == JiraConnectionType.JiraCloud)
{
deleteResult = UserSteps.DeleteUser(credential, createUserResult.Data.AccountId);
}
else
{
deleteResult = UserSteps.DeleteUser(credential, createUserResult.Data.Key);
}
Assert.AreEqual(deleteResult.Status, JiraResultStatus.Success);
}
private void TestSetUserPassword(JiraCredentials credential)
{
var editedUser = TestData.GetJiraUser();
JiraCreateUserResult createUserResult = UserSteps.CreateUser(credential, editedUser);
try
{
var serPasswordResult = UserSteps.SetUserPassword(credential, createUserResult.Data.Key, "123");
Assert.AreEqual(serPasswordResult.Status, JiraResultStatus.Success);
}
finally
{
try
{
UserSteps.DeleteUser(credential, createUserResult.Data.Key); // for Jira server
UserSteps.DeleteUser(credential, createUserResult.Data.AccountId); // for Jira cloud
}
catch { }
}
}
public static BaseJiraResult DeleteUser(JiraCredentials credential, string accountIdOrKey)
{
BaseJiraResult response;
if (credential.JiraConnection == JiraConnectionType.JiraCloud)
{
response = JiraUtility.Delete($"user?accountId={accountIdOrKey}", credential, HttpStatusCode.NoContent);
}
else
if (credential.JiraConnection == JiraConnectionType.JiraServer)
{
response = JiraUtility.Delete($"user?key={accountIdOrKey}", credential, HttpStatusCode.NoContent);
}
else
{
throw new NotSupportedException();
}
return(response);
}
private void TestEditProject(JiraCredentials credential)
{
CreateEntities(credential);
JiraProjectModel project = TestData.GetJiraProject(createUserResult.Data);
try
{
var createResponse = ProjectSteps.CreateProject(credential, project);
project.Description = "Test Desc";
project.Name = "Dec_wfh_1";
var editResponse = ProjectSteps.EditProject(credential, project);
Assert.AreEqual(editResponse.Status, JiraResultStatus.Success);
}
finally
{
ProjectSteps.DeleteProject(credential, project.ProjectIdOrKey);
DeleteEntities(credential);
}
}
private void TestAssignProject(JiraCredentials credential)
{
var newUser = TestData.GetJiraUser();
JiraCreateUserResult createUserResult = UserSteps.CreateUser(credential, newUser);
var newProject = TestData.GetJiraProject(createUserResult.Data);
ProjectSteps.CreateProject(credential, newProject);
JiraProjectRolesResult roles = ProjectSteps.GetProjectRoles(credential);
try
{
JiraAssignProjectModel assignProject;
if (credential.JiraConnection == JiraConnectionType.JiraCloud)
{
assignProject = TestData.GetJiraAssignProject(newProject.Key, createUserResult.Data.AccountId, roles.Data[0].Id);
}
else
{
assignProject = TestData.GetJiraAssignProject(newProject.Key, createUserResult.Data.Key, roles.Data[0].Id);
}
JiraAssignProjectResult assignProjectResult = UserSteps.AssignProject(credential, assignProject);
Assert.AreEqual(assignProjectResult.Status, JiraResultStatus.Success);
}
finally
{
try
{
ProjectSteps.DeleteProject(credential, newProject.ProjectIdOrKey);
UserSteps.DeleteUser(credential, createUserResult.Data.Key); // for Jira server
UserSteps.DeleteUser(credential, createUserResult.Data.AccountId); // for Jira cloud
}
catch { }
}
}
private HttpWebRequest BuildHttpRequest(string url,
string method,
string data,
JiraCredentials credentials)
{
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.ContentType = "application/json";
request.Method = method;
if (data != null)
{
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write(data);
}
}
string base64Credentials = credentials.Encode();
request.Headers.Add("Authorization", "Basic " + base64Credentials);
return(request);
}
public JiraApi(string server, JiraCredentials credentials)
{
Server = server;
Credentials = credentials;
}
public static JiraProjectTypeResult GetАccessibleProjectTypeByKey(JiraCredentials credential, string projectTypeKey)
{
var response = JiraUtility.Get <JiraProjectTypeResponseModel>($"project/type/{projectTypeKey}/accessible", credential);
return(new JiraProjectTypeResult(response));
}
public static JiraProjectMetadataResult GetProjectMetadateByKey(JiraCredentials credential, string projectKey)
{
var response = JiraUtility.Get <JiraProjectMetadataResponseModel>($"issue/createmeta?projectKeys={projectKey}", credential);
return(new JiraProjectMetadataResult(response));
}
public static JiraProjectRolesResult GetProjectRoles(JiraCredentials credential)
{
var response = JiraUtility.Get <List <JiraProjectRolesResponseModel> >($"/rest/api/2/role", credential);
return(new JiraProjectRolesResult(response));
}
public static JiraCreateProjectResult CreateProject(JiraCredentials credential, JiraProjectModel newProject)
{
var response = JiraUtility.Post <JiraProjectModel, JiraBaseResponseModel>("project", credential, newProject, HttpStatusCode.Created);
return(new JiraCreateProjectResult(response));
}
public static BaseJiraResult DeleteIssue(JiraCredentials credential, JiraIssueDeleteModel IssueModel)
{
var response = JiraUtility.Delete($"issue/{IssueModel.IssueIdOrKey}?deleteSubtasks={IssueModel.DeleteSubtasks}", credential, HttpStatusCode.NoContent);
return(response);
}
private void CreateEntities(JiraCredentials credential)
{
newUser = TestData.GetJiraUser();
createUserResult = UserSteps.CreateUser(credential, newUser);
}
