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); }