private void resolveResolution(IssueDto dbIssue, DefaultIssue issue) { issue.setResolution(dbIssue.getResolution()); }
public boolean setResolution(DefaultIssue issue, @Nullable String resolution, IssueChangeContext context) { if (!Objects.equals(resolution, issue.resolution())) { issue.setFieldChange(context, RESOLUTION, issue.resolution(), resolution); issue.setResolution(resolution); issue.setUpdateDate(context.date()); issue.setChanged(true); issue.setSendNotifications(true); return true; } return false; }
@Test public void support_only_unresolved_issues() { assertThat(underTest.supports(new DefaultIssue().setResolution(null))).isTrue(); assertThat(underTest.supports(new DefaultIssue().setResolution(Issue.RESOLUTION_FIXED))).isFalse(); }
@Test public void should_support_all_issues() { assertThat(action.supports(new DefaultIssue().setResolution(null))).isTrue(); assertThat(action.supports(new DefaultIssue().setResolution(Issue.RESOLUTION_FIXED))).isTrue(); }
@Test public void should_support_all_issues() { assertThat(action.supports(new DefaultIssue().setResolution(null))).isTrue(); assertThat(action.supports(new DefaultIssue().setResolution(Issue.RESOLUTION_FIXED))).isTrue(); }
@Test public void not_change_resolution() { issue.setResolution("FIXED"); boolean updated = underTest.setResolution(issue, "FIXED", context); assertThat(updated).isFalse(); assertThat(issue.resolution()).isEqualTo("FIXED"); assertThat(issue.currentChange()).isNull(); assertThat(issue.mustSendNotifications()).isFalse(); }
@Test public void support_only_unresolved_issues() { IssueDto issueDto = newIssue().setSeverity(MAJOR); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); assertThat(action.supports(issue.setResolution(null))).isTrue(); assertThat(action.supports(issue.setResolution(Issue.RESOLUTION_FIXED))).isFalse(); }
@Test public void support_only_unresolved_issues() { IssueDto issueDto = newIssue().setType(BUG); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); assertThat(action.supports(issue.setResolution(null))).isTrue(); assertThat(action.supports(issue.setResolution(Issue.RESOLUTION_FIXED))).isFalse(); }
private static DefaultIssue newDefaultIssue(String projectUuid) { DefaultIssue defaultIssue = new DefaultIssue(); defaultIssue.setKey("issue_" + issueIdCounter++); defaultIssue.setProjectUuid(projectUuid); defaultIssue.setType(RuleType.values()[new Random().nextInt(RuleType.values().length)]); defaultIssue.setStatus(POSSIBLE_STATUSES[new Random().nextInt(POSSIBLE_STATUSES.length)]); String[] possibleResolutions = possibleResolutions(defaultIssue.getStatus()); if (possibleResolutions.length > 0) { defaultIssue.setResolution(possibleResolutions[new Random().nextInt(possibleResolutions.length)]); } return defaultIssue; }
@Test public void execute() { loginAndAddProjectPermission("john", ISSUE_ADMIN); issue.setStatus(Issue.STATUS_RESOLVED); issue.setResolution(Issue.RESOLUTION_FIXED); action.execute(ImmutableMap.of("transition", "reopen"), context); assertThat(issue.status()).isEqualTo(Issue.STATUS_REOPENED); assertThat(issue.resolution()).isNull(); }
@Test public void support_only_issues_with_issue_admin_permission() { IssueDto authorizedIssueDto = newIssue().setType(BUG); DefaultIssue authorizedIssue = authorizedIssueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(authorizedIssueDto); DefaultIssue unauthorizedIssue = newIssue().setType(BUG).toDefaultIssue(); assertThat(action.supports(authorizedIssue.setResolution(null))).isTrue(); assertThat(action.supports(unauthorizedIssue.setResolution(null))).isFalse(); }
@Test public void support_only_issues_with_issue_admin_permission() { IssueDto authorizedIssue = newIssue().setSeverity(MAJOR); setUserWithBrowseAndAdministerIssuePermission(authorizedIssue); IssueDto unauthorizedIssue = newIssue().setSeverity(MAJOR); assertThat(action.supports(authorizedIssue.toDefaultIssue().setResolution(null))).isTrue(); assertThat(action.supports(unauthorizedIssue.toDefaultIssue().setResolution(null))).isFalse(); }
private static DefaultIssue createIssue(@Nullable String resolution, String status, String severity, RuleType ruleType, long creationDate) { return new DefaultIssue() .setResolution(resolution).setStatus(status) .setSeverity(severity).setRuleKey(RuleTesting.XOO_X1) .setType(ruleType) .setCreationDate(new Date(creationDate)); }
private DefaultIssue init(DefaultIssue issue) { issue.setResolution(null); issue.setStatus(Issue.STATUS_OPEN); issue.setComponentUuid(component.getUuid()); issue.setComponentKey(component.getKey()); issue.setProjectUuid(treeRootHolder.getRoot().getUuid()); issue.setProjectKey(treeRootHolder.getRoot().getKey()); return issue; }
@Test public void fail_if_unknown_status_on_automatic_trans() { workflow.start(); DefaultIssue issue = new DefaultIssue() .setKey("ABCDE") .setResolution(RESOLUTION_FIXED) .setStatus("xxx") .setNew(false) .setBeingClosed(true); try { workflow.doAutomaticTransition(issue, IssueChangeContext.createScan(new Date())); fail(); } catch (IllegalStateException e) { assertThat(e).hasMessage("Unknown status: xxx [issue=ABCDE]"); } }
private static DefaultIssue createIssue(String key, RuleKey ruleKey, String status, @Nullable String resolution, Date creationDate) { DefaultIssue issue = new DefaultIssue(); issue.setKey(key); issue.setRuleKey(ruleKey); issue.setMessage("msg"); issue.setLine(1); issue.setStatus(status); issue.setResolution(resolution); issue.setCreationDate(creationDate); issue.setChecksum("checksum"); return issue; }
@Test public void mergeExistingOpenIssue_with_base_changed() { DefaultIssue raw = new DefaultIssue() .setNew(true) .setKey("RAW_KEY") .setRuleKey(XOO_X1); DefaultIssue base = new DefaultIssue() .setChanged(true) .setKey("BASE_KEY") .setResolution(RESOLUTION_FALSE_POSITIVE) .setStatus(STATUS_RESOLVED); underTest.mergeExistingOpenIssue(raw, base); assertThat(raw.isChanged()).isTrue(); }
@Test public void sum_reliability_effort_of_unresolved_issues() { DefaultIssue unresolved1 = newBugIssue(10); DefaultIssue unresolved2 = newBugIssue(30); DefaultIssue unresolvedWithoutEffort = newBugIssueWithoutEffort(); DefaultIssue resolved = newBugIssue(50).setResolution(RESOLUTION_FIXED); underTest.beforeComponent(FILE); underTest.onIssue(FILE, unresolved1); underTest.onIssue(FILE, unresolved2); underTest.onIssue(FILE, unresolvedWithoutEffort); underTest.onIssue(FILE, resolved); underTest.afterComponent(FILE); assertMeasure(FILE, RELIABILITY_REMEDIATION_EFFORT_KEY, 10L + 30L); }
@Test public void sum_security_effort_of_unresolved_issues() { DefaultIssue unresolved1 = newVulnerabilityIssue(10); DefaultIssue unresolved2 = newVulnerabilityIssue(30); DefaultIssue unresolvedWithoutEffort = newVulnerabilityIssueWithoutEffort(); DefaultIssue resolved = newVulnerabilityIssue(50).setResolution(RESOLUTION_FIXED); underTest.beforeComponent(FILE); underTest.onIssue(FILE, unresolved1); underTest.onIssue(FILE, unresolved2); underTest.onIssue(FILE, unresolvedWithoutEffort); underTest.onIssue(FILE, resolved); underTest.afterComponent(FILE); assertMeasure(FILE, SECURITY_REMEDIATION_EFFORT_KEY, 10L + 30L); }
@Test public void sum_maintainability_effort_of_unresolved_issues() { DefaultIssue unresolved1 = newCodeSmellIssue(10); DefaultIssue unresolved2 = newCodeSmellIssue(30); DefaultIssue unresolvedWithoutEffort = newCodeSmellIssueWithoutEffort(); DefaultIssue resolved = newCodeSmellIssue(50).setResolution(RESOLUTION_FIXED); underTest.beforeComponent(FILE); underTest.onIssue(FILE, unresolved1); underTest.onIssue(FILE, unresolved2); underTest.onIssue(FILE, unresolvedWithoutEffort); underTest.onIssue(FILE, resolved); underTest.afterComponent(FILE); // total maintainability effort assertMeasure(FILE, TECHNICAL_DEBT_KEY, 10L + 30L); }