From: Julien Lancelot Date: Wed, 16 Sep 2015 13:23:30 +0000 (+0200) Subject: Move remaining ITs of IssueWorkflowTest X-Git-Tag: 5.2-RC1~369 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=18c1eac42c17d11e296d6065112736732e2f76f2;p=sonarqube.git Move remaining ITs of IssueWorkflowTest --- diff --git a/it/it-tests/src/test/java/issue/suite/IssueTestSuite.java b/it/it-tests/src/test/java/issue/suite/IssueTestSuite.java index 7f765a62ec6..a4eb333301d 100644 --- a/it/it-tests/src/test/java/issue/suite/IssueTestSuite.java +++ b/it/it-tests/src/test/java/issue/suite/IssueTestSuite.java @@ -6,11 +6,17 @@ package issue.suite; import com.sonar.orchestrator.Orchestrator; +import java.util.List; import org.junit.ClassRule; import org.junit.runner.RunWith; import org.junit.runners.Suite; +import org.sonar.wsclient.issue.Issue; +import org.sonar.wsclient.issue.IssueClient; +import org.sonar.wsclient.issue.IssueQuery; import util.ItUtils; +import static org.assertj.core.api.Assertions.assertThat; + @RunWith(Suite.class) @Suite.SuiteClasses({ CommonRulesTest.class, IssueWorkflowTest.class, ManualRulesTest.class, @@ -22,4 +28,27 @@ public class IssueTestSuite { .setSonarVersion("DEV") .addPlugin(ItUtils.xooPlugin()) .build(); + + static IssueClient adminIssueClient() { + return ORCHESTRATOR.getServer().adminWsClient().issueClient(); + } + + static Issue searchRandomIssue() { + List issues = searchIssues(IssueQuery.create()); + assertThat(issues).isNotEmpty(); + return issues.get(0); + } + + static List searchIssues(IssueQuery issueQuery) { + issueQuery.urlParams().put("additionalFields", "_all"); + return adminIssueClient().find(issueQuery).list(); + } + + static Issue searchIssueByKey(String issueKey) { + IssueQuery query = IssueQuery.create().issues(issueKey); + query.urlParams().put("additionalFields", "_all"); + List issues = searchIssues(query); + assertThat(issues).hasSize(1); + return issues.get(0); + } } diff --git a/it/it-tests/src/test/java/issue/suite/IssueWorkflowTest.java b/it/it-tests/src/test/java/issue/suite/IssueWorkflowTest.java index 4e8b67e2c3c..7070e1d74dc 100644 --- a/it/it-tests/src/test/java/issue/suite/IssueWorkflowTest.java +++ b/it/it-tests/src/test/java/issue/suite/IssueWorkflowTest.java @@ -8,9 +8,12 @@ import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; import org.sonar.wsclient.issue.Issue; -import org.sonar.wsclient.issue.IssueClient; import org.sonar.wsclient.issue.IssueQuery; +import static issue.suite.IssueTestSuite.adminIssueClient; +import static issue.suite.IssueTestSuite.searchIssueByKey; +import static issue.suite.IssueTestSuite.searchIssues; +import static issue.suite.IssueTestSuite.searchRandomIssue; import static org.assertj.core.api.Assertions.assertThat; import static util.ItUtils.projectDir; @@ -19,9 +22,21 @@ public class IssueWorkflowTest { @ClassRule public static Orchestrator orchestrator = IssueTestSuite.ORCHESTRATOR; + Issue issue; + SonarRunner scan; + @Before - public void setUp() { + public void resetData() { orchestrator.resetData(); + + orchestrator.getServer().restoreProfile(FileLocation.ofClasspath("/issue/suite/IssueWorkflowTest/xoo-one-issue-per-line-profile.xml")); + orchestrator.getServer().provisionProject("workflow", "Workflow"); + orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "xoo-one-issue-per-line-profile"); + + scan = SonarRunner.create(projectDir("issue/workflow")); + orchestrator.executeBuild(scan); + + issue = searchRandomIssue(); } /** @@ -30,26 +45,242 @@ public class IssueWorkflowTest { */ @Test public void issue_is_closed_as_removed_when_rule_is_disabled() throws Exception { - orchestrator.getServer().restoreProfile(FileLocation.ofClasspath("/issue/suite/IssueWorkflowTest/xoo-one-issue-per-line-profile.xml")); - orchestrator.getServer().provisionProject("workflow", "Workflow"); - orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "xoo-one-issue-per-line-profile"); - - SonarRunner analysis = SonarRunner.create(projectDir("issue/workflow")); - orchestrator.executeBuild(analysis); - - IssueClient issueClient = orchestrator.getServer().wsClient().issueClient(); - List issues = issueClient.find(IssueQuery.create().rules("xoo:OneIssuePerLine")).list(); + List issues = searchIssues(IssueQuery.create().rules("xoo:OneIssuePerLine")); assertThat(issues).isNotEmpty(); // re-analyze with profile "empty". The rule is disabled so the issues must be closed orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "empty"); - analysis = SonarRunner.create(projectDir("issue/workflow")); - orchestrator.executeBuild(analysis); - issues = issueClient.find(IssueQuery.create().rules("xoo:OneIssuePerLine").componentRoots("workflow")).list(); + orchestrator.executeBuild(scan); + issues = searchIssues(IssueQuery.create().rules("xoo:OneIssuePerLine")); assertThat(issues).isNotEmpty(); for (Issue issue : issues) { assertThat(issue.status()).isEqualTo("CLOSED"); assertThat(issue.resolution()).isEqualTo("REMOVED"); } } + + /** + * SONAR-4329 + */ + @Test + public void user_should_confirm_issue() { + // mark as confirmed + adminIssueClient().doTransition(issue.key(), "confirm"); + + Issue confirmed = searchIssueByKey(issue.key()); + assertThat(confirmed.status()).isEqualTo("CONFIRMED"); + assertThat(confirmed.resolution()).isNull(); + assertThat(confirmed.creationDate()).isEqualTo(issue.creationDate()); + + // user unconfirm the issue + assertThat(adminIssueClient().transitions(confirmed.key())).contains("unconfirm"); + adminIssueClient().doTransition(confirmed.key(), "unconfirm"); + + Issue unconfirmed = searchIssueByKey(issue.key()); + assertThat(unconfirmed.status()).isEqualTo("REOPENED"); + assertThat(unconfirmed.resolution()).isNull(); + assertThat(unconfirmed.creationDate()).isEqualTo(confirmed.creationDate()); + } + + /** + * SONAR-4329 + */ + @Test + public void user_should_mark_as_false_positive_confirmed_issue() { + // mark as confirmed + adminIssueClient().doTransition(issue.key(), "confirm"); + + Issue confirmed = searchIssueByKey(issue.key()); + assertThat(confirmed.status()).isEqualTo("CONFIRMED"); + assertThat(confirmed.resolution()).isNull(); + assertThat(confirmed.creationDate()).isEqualTo(issue.creationDate()); + + // user mark the issue as false-positive + assertThat(adminIssueClient().transitions(confirmed.key())).contains("falsepositive"); + adminIssueClient().doTransition(confirmed.key(), "falsepositive"); + + Issue falsePositive = searchIssueByKey(issue.key()); + assertThat(falsePositive.status()).isEqualTo("RESOLVED"); + assertThat(falsePositive.resolution()).isEqualTo("FALSE-POSITIVE"); + assertThat(falsePositive.creationDate()).isEqualTo(confirmed.creationDate()); + } + + /** + * SONAR-4329 + */ + @Test + public void scan_should_close_no_more_existing_confirmed() { + // mark as confirmed + adminIssueClient().doTransition(issue.key(), "confirm"); + Issue falsePositive = searchIssueByKey(issue.key()); + assertThat(falsePositive.status()).isEqualTo("CONFIRMED"); + assertThat(falsePositive.resolution()).isNull(); + assertThat(falsePositive.creationDate()).isEqualTo(issue.creationDate()); + + // scan without any rules -> confirmed is closed + orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "empty"); + orchestrator.executeBuild(scan); + Issue closed = searchIssueByKey(issue.key()); + assertThat(closed.status()).isEqualTo("CLOSED"); + assertThat(closed.resolution()).isEqualTo("REMOVED"); + assertThat(closed.creationDate()).isEqualTo(issue.creationDate()); + } + + /** + * SONAR-4288 + */ + @Test + public void scan_should_reopen_unresolved_issue_but_marked_as_resolved() { + // mark as resolved + adminIssueClient().doTransition(issue.key(), "resolve"); + Issue resolvedIssue = searchIssueByKey(issue.key()); + assertThat(resolvedIssue.status()).isEqualTo("RESOLVED"); + assertThat(resolvedIssue.resolution()).isEqualTo("FIXED"); + assertThat(resolvedIssue.creationDate()).isEqualTo(issue.creationDate()); + assertThat(resolvedIssue.updateDate().before(resolvedIssue.creationDate())).isFalse(); + assertThat(resolvedIssue.updateDate().before(issue.updateDate())).isFalse(); + + // re-execute scan, with the same Q profile -> the issue has not been fixed + orchestrator.executeBuild(scan); + + // reload issue + Issue reopenedIssue = searchIssueByKey(issue.key()); + + // the issue has been reopened + assertThat(reopenedIssue.status()).isEqualTo("REOPENED"); + assertThat(reopenedIssue.resolution()).isNull(); + assertThat(reopenedIssue.creationDate()).isEqualTo(issue.creationDate()); + assertThat(reopenedIssue.updateDate().before(issue.updateDate())).isFalse(); + } + + /** + * SONAR-4288 + */ + @Test + public void scan_should_close_resolved_issue() { + // mark as resolved + adminIssueClient().doTransition(issue.key(), "resolve"); + Issue resolvedIssue = searchIssueByKey(issue.key()); + assertThat(resolvedIssue.status()).isEqualTo("RESOLVED"); + assertThat(resolvedIssue.resolution()).isEqualTo("FIXED"); + assertThat(resolvedIssue.creationDate()).isEqualTo(issue.creationDate()); + assertThat(resolvedIssue.closeDate()).isNull(); + + // re-execute scan without rules -> the issue is removed with resolution "REMOVED" + orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "empty"); + orchestrator.executeBuild(scan); + + // reload issue + Issue closedIssue = searchIssueByKey(issue.key()); + assertThat(closedIssue.status()).isEqualTo("CLOSED"); + assertThat(closedIssue.resolution()).isEqualTo("REMOVED"); + assertThat(closedIssue.creationDate()).isEqualTo(issue.creationDate()); + assertThat(closedIssue.updateDate().before(resolvedIssue.updateDate())).isFalse(); + assertThat(closedIssue.closeDate()).isNotNull(); + assertThat(closedIssue.closeDate().before(closedIssue.creationDate())).isFalse(); + } + + /** + * SONAR-4288 + */ + @Test + public void user_should_reopen_issue_marked_as_resolved() { + // user marks issue as resolved + adminIssueClient().doTransition(issue.key(), "resolve"); + Issue resolved = searchIssueByKey(issue.key()); + assertThat(resolved.status()).isEqualTo("RESOLVED"); + assertThat(resolved.resolution()).isEqualTo("FIXED"); + assertThat(resolved.creationDate()).isEqualTo(issue.creationDate()); + + // user reopens the issue + assertThat(adminIssueClient().transitions(resolved.key())).contains("reopen"); + adminIssueClient().doTransition(resolved.key(), "reopen"); + + Issue reopened = searchIssueByKey(resolved.key()); + assertThat(reopened.status()).isEqualTo("REOPENED"); + assertThat(reopened.resolution()).isNull(); + assertThat(reopened.creationDate()).isEqualTo(resolved.creationDate()); + assertThat(reopened.updateDate().before(resolved.updateDate())).isFalse(); + } + + /** + * SONAR-4286 + */ + @Test + public void scan_should_not_reopen_or_close_false_positives() { + // user marks issue as false-positive + adminIssueClient().doTransition(issue.key(), "falsepositive"); + + Issue falsePositive = searchIssueByKey(issue.key()); + assertThat(falsePositive.status()).isEqualTo("RESOLVED"); + assertThat(falsePositive.resolution()).isEqualTo("FALSE-POSITIVE"); + assertThat(falsePositive.creationDate()).isEqualTo(issue.creationDate()); + + // re-execute the same scan + orchestrator.executeBuild(scan); + + // refresh + Issue reloaded = searchIssueByKey(falsePositive.key()); + assertThat(reloaded.status()).isEqualTo("RESOLVED"); + assertThat(reloaded.resolution()).isEqualTo("FALSE-POSITIVE"); + assertThat(reloaded.creationDate()).isEqualTo(issue.creationDate()); + // TODO check that update date has not been changed + } + + /** + * SONAR-4286 + */ + @Test + public void scan_should_close_no_more_existing_false_positive() { + // user marks as false-positive + adminIssueClient().doTransition(issue.key(), "falsepositive"); + Issue falsePositive = searchIssueByKey(issue.key()); + assertThat(falsePositive.status()).isEqualTo("RESOLVED"); + assertThat(falsePositive.resolution()).isEqualTo("FALSE-POSITIVE"); + assertThat(falsePositive.creationDate()).isEqualTo(issue.creationDate()); + + // scan without any rules -> false-positive is closed + orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "empty"); + orchestrator.executeBuild(scan); + Issue closed = searchIssueByKey(issue.key()); + assertThat(closed.status()).isEqualTo("CLOSED"); + assertThat(closed.resolution()).isEqualTo("REMOVED"); + assertThat(closed.creationDate()).isEqualTo(issue.creationDate()); + } + + /** + * SONAR-4286 + */ + @Test + public void user_should_reopen_false_positive() { + // user marks as false-positive + adminIssueClient().doTransition(issue.key(), "falsepositive"); + + Issue falsePositive = searchIssueByKey(issue.key()); + assertThat(falsePositive.status()).isEqualTo("RESOLVED"); + assertThat(falsePositive.resolution()).isEqualTo("FALSE-POSITIVE"); + assertThat(falsePositive.creationDate()).isEqualTo(issue.creationDate()); + + // user reopens the issue + assertThat(adminIssueClient().transitions(falsePositive.key())).contains("reopen"); + adminIssueClient().doTransition(falsePositive.key(), "reopen"); + + Issue reopened = searchIssueByKey(issue.key()); + assertThat(reopened.status()).isEqualTo("REOPENED"); + assertThat(reopened.resolution()).isNull(); + assertThat(reopened.creationDate()).isEqualTo(falsePositive.creationDate()); + } + + @Test + public void user_should_not_reopen_closed_issue() { + adminIssueClient().doTransition(issue.key(), "resolve"); + + // re-execute scan without rules -> the issue is closed + orchestrator.getServer().associateProjectToQualityProfile("workflow", "xoo", "empty"); + orchestrator.executeBuild(scan); + + // user try to reopen the issue + assertThat(adminIssueClient().transitions(issue.key())).isEmpty(); + } + }