private void CreateEntities(JiraCredentials credential)
{
newUser = TestData.GetJiraUser();
createUserResult = UserSteps.CreateUser(credential, newUser);
project = TestData.GetJiraProject(createUserResult.Data);
createProjectResult = ProjectSteps.CreateProject(credential, project);
}
public async Task UpdateSuite_ShouldReturnOK()
{
//Arrange
SetAuthorization();
var suiteModel = SuiteFactory.GetSuiteModel();
var projectModel = ProjectFactory.GetProjectModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
var suite = await SuiteService.AddSuite(projectId, suiteModel);
var suiteId = SuiteSteps.GetSuiteId(suite);
var updateSuiteModel = SuiteFactory.GetSuiteModel();
//Act
var response = await SuiteService.UpdateSuite(suiteId, updateSuiteModel);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
var responseSuite = response.GetResponseSuiteModel();
SuiteAssert.ValidateSuiteResult(updateSuiteModel, responseSuite);
}
public async Task UpdateSuite_WhenFieldMoreThanMaxLengthValue_ShouldReturnBadRequest(
string serializedSuite, string typeOfError)
{
//Arrange
SetAuthorization();
var projectModel = ProjectFactory.GetProjectModel();
var suiteModel = SuiteFactory.GetSuiteModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
var suite = await SuiteService.AddSuite(projectId, suiteModel);
var suiteId = SuiteSteps.GetSuiteId(suite);
var updateSuiteModel = NewtonsoftJsonSerializer.DefaultDeserialize <RequestSuiteModel>(serializedSuite);
//Act
var response = await SuiteService.UpdateSuite(suiteId, updateSuiteModel);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var errorResponse = response.GetErrors();
ErrorAssert.ValidateErrorMessage(errorResponse, typeOfError);
}
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 async Task <IActionResult> Edit(int id, [Bind("Id,PlananIslem")] ProjectSteps projectSteps)
{
if (id != projectSteps.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(projectSteps);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectStepsExists(projectSteps.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(projectSteps));
}
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);
}
}
public void AddProjectNegativeTest()
{
project.Identifier = incorrectIdentifier;
logger.Info($"Test AddProject started with parameters:\n project name: {project.Name}, identifier {project.Identifier}");
ProjectSteps.AddProject(browser, project);
Assert.IsFalse(ProjectSteps.IsProjectCreated(browser));
}
private void DeleteEntities(JiraCredentials credential)
{
try
{
ProjectSteps.DeleteProject(credential, project.ProjectIdOrKey);
UserSteps.DeleteUser(credential, createUserResult.Data.Key); // for Jira server
UserSteps.DeleteUser(credential, createUserResult.Data.AccountId); // for Jira cloud
}
catch (Exception ex) { _ = ex.Message; }
}
public async Task <IActionResult> Create([Bind("Id,PlananIslem")] ProjectSteps projectSteps)
{
if (ModelState.IsValid)
{
_context.Add(projectSteps);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(projectSteps));
}
protected BaseTest(ITestOutputHelper outputHelper)
{
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.ClearProviders()
.AddXUnit(outputHelper);
});
ClientExtended = ClientConfiguration.ConfigureHttpClient(loggerFactory);
ProjectService = new ProjectService(ClientExtended);
ProjectSteps = new ProjectSteps(ProjectService);
SuiteService = new SuiteService(ClientExtended);
SuiteSteps = new SuiteSteps(SuiteService);
}
public async Task DeleteProject_WhenProject_ShouldReturnOK()
{
//Arrange
SetAuthorization();
var projectModel = ProjectFactory.GetProjectModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
//Act
var response = await ProjectService.DeleteProject(projectId);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
}
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);
}
}
protected BaseTest(ITestOutputHelper testOutputHelper)
{
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.ClearProviders()
.AddXUnit(testOutputHelper);
});
_client = new HttpClient(new LoggingHandler(new HttpClientHandler(), loggerFactory))
{
BaseAddress = new Uri(Startup.AppSettings.Services.TestRailApp.AppUrl)
};
_projectService = new ProjectService(_client);
_projectSteps = new ProjectSteps(_projectService);
_suiteService = new SuiteService(_client);
_suiteSteps = new SuiteSteps(_suiteService);
}
public async Task DeleteProject_WhenUnauthorized_ShouldReturnUnauthorized()
{
//Arrange
ClientExtended.ClearAuthorization();
var projectModel = ProjectFactory.GetProjectModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
//Act
var response = await ProjectService.DeleteProject(projectId);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
var errorMessage = response.GetErrors();
ErrorAssert.ValidateErrorMessage(errorMessage, ErrorMessage.FailedAuthentication);
}
public async Task AddSuite_WhenRequiredFieldHasIncorrectValue_ShouldReturnBadRequest(string serializedProject,
string typeOfError)
{
//Arrange
SetAuthorization();
var projectModel = ProjectFactory.GetProjectModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
var suiteModel = NewtonsoftJsonSerializer.DefaultDeserialize <RequestSuiteModel>(serializedProject);
//Act
var response = await SuiteService.AddSuite(projectId, suiteModel);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var responseMessage = response.GetErrors();
ErrorAssert.ValidateErrorMessage(responseMessage, typeOfError);
}
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);
}
}
public async Task DeleteProject_WhenDeleteProjectHasAlreadyBeenDeleted_ShouldReturnBadRequest()
{
//Arrange
SetAuthorization();
var projectModel = ProjectFactory.GetProjectModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
await ProjectService.DeleteProject(projectId);
//Act
var response = await ProjectService.DeleteProject(projectId);
await ProjectService.GetProject(projectId);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var responseMessage = response.GetErrors();
ErrorAssert.ValidateErrorMessage(responseMessage, ErrorMessage.IncorrectProjectId);
}
public async Task AddSuite_WhenProjectDoesNotExist_ShouldReturnBadRequest()
{
//Arrange
SetAuthorization();
var suiteModel = SuiteFactory.GetSuiteModel();
var projectModel = ProjectFactory.GetProjectModel();
var project = await ProjectService.AddProject(projectModel);
var projectId = ProjectSteps.GetProjectId(project);
await ProjectService.DeleteProject(projectId);
//Act
var response = await SuiteService.AddSuite(projectId, suiteModel);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var responseMessage = response.GetErrors();
ErrorAssert.ValidateErrorMessage(responseMessage, ErrorMessage.IncorrectProjectId);
}
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 { }
}
}
// Use this for initialization
void Awake()
{
instance = this;
}
public void AddProjectPositiveTest()
{
logger.Info($"Test AddProject started with parameters:\n project name: {project.Name}, identifier {project.Identifier}");
ProjectSteps.AddProject(browser, project);
Assert.IsTrue(ProjectSteps.IsProjectCreated(browser));
}
