@Override public Function.Context setAssignee(@Nullable UserDto user) { updater.assign(issue, user, changeContext); return this; }
@Override public Function.Context setResolution(@Nullable String s) { updater.setResolution(issue, s, changeContext); return this; }
public void doAutomaticTransition(DefaultIssue issue, IssueChangeContext issueChangeContext) { Transition transition = stateOf(issue).outAutomaticTransition(issue); if (transition != null) { functionExecutor.execute(transition.functions(), issue, issueChangeContext); updater.setStatus(issue, transition.to(), issueChangeContext); } }
private Collection<? extends DefaultIssue> migrateIssuesToTheRoot(List<DefaultIssue> issuesOnModule, String modulePath) { for (DefaultIssue i : issuesOnModule) { // changes the issue's component uuid, add a change and set issue as changed to enforce it is persisted to DB IssueChangeContext context = IssueChangeContext.createUser(new Date(analysisMetadataHolder.getAnalysisDate()), null); if (StringUtils.isNotBlank(modulePath)) { issueUpdater.setMessage(i, "[" + modulePath + "] " + i.getMessage(), context); } issueUpdater.setIssueMoved(i, component.getUuid(), context); // other fields (such as module, modulePath, componentKey) are read-only and set/reset for consistency only i.setComponentKey(component.getKey()); i.setModuleUuid(null); i.setModuleUuidPath(null); } return issuesOnModule; } }
updater.setType(raw, RuleType.SECURITY_HOTSPOT, changeContext); updater.setStatus(raw, Issue.STATUS_REOPENED, changeContext); updater.setResolution(raw, null, changeContext); raw.setSeverity(base.severity()); } else { updater.setPastSeverity(raw, base.severity(), changeContext); updater.setPastLine(raw, base.getLine()); updater.setPastLocations(raw, base.getLocations()); updater.setPastMessage(raw, base.getMessage(), changeContext); updater.setPastGap(raw, base.gap(), changeContext); updater.setPastEffort(raw, base.effort(), changeContext);
.containsOnly(entry("file", new FieldDiffs.Diff("A", "B"))); verify(updater).setPastSeverity(raw, BLOCKER, issueChangeContext); verify(updater).setPastLine(raw, 10); verify(updater).setPastMessage(raw, "message", issueChangeContext); verify(updater).setPastEffort(raw, Duration.create(15L), issueChangeContext); verify(updater).setPastLocations(raw, issueLocations);
public boolean setPastSeverity(DefaultIssue issue, @Nullable String previousSeverity, IssueChangeContext context) { String currentSeverity = issue.severity(); issue.setSeverity(previousSeverity); return setSeverity(issue, currentSeverity, context); }
@Override public Function.Context setType(RuleType type) { updater.setType(issue, type, changeContext); return this; } }
public boolean setPastMessage(DefaultIssue issue, @Nullable String previousMessage, IssueChangeContext context) { String currentMessage = issue.message(); issue.setMessage(previousMessage); return setMessage(issue, currentMessage, context); }
@Test public void set_past_technical_debt_without_previous_value() { Duration newDebt = Duration.create(15 * 8 * 60); issue.setEffort(newDebt); boolean updated = underTest.setPastEffort(issue, null, context); assertThat(updated).isTrue(); assertThat(issue.effort()).isEqualTo(newDebt); assertThat(issue.mustSendNotifications()).isFalse(); FieldDiffs.Diff diff = issue.currentChange().get(TECHNICAL_DEBT); assertThat(diff.oldValue()).isNull(); assertThat(diff.newValue()).isEqualTo(15L * 8 * 60); }
@Test public void set_past_line() { issue.setLine(42); boolean updated = underTest.setPastLine(issue, 123); assertThat(updated).isTrue(); assertThat(issue.isChanged()).isTrue(); assertThat(issue.line()).isEqualTo(42); assertThat(issue.mustSendNotifications()).isFalse(); // do not save change assertThat(issue.currentChange()).isNull(); }
@Test public void set_past_severity() { issue.setSeverity("BLOCKER"); boolean updated = underTest.setPastSeverity(issue, "INFO", context); assertThat(updated).isTrue(); assertThat(issue.severity()).isEqualTo("BLOCKER"); assertThat(issue.mustSendNotifications()).isFalse(); FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY); assertThat(diff.oldValue()).isEqualTo("INFO"); assertThat(diff.newValue()).isEqualTo("BLOCKER"); }
@Test public void set_past_message() { issue.setMessage("new message"); boolean updated = underTest.setPastMessage(issue, "past message", context); assertThat(updated).isTrue(); assertThat(issue.message()).isEqualTo("new message"); // do not save change assertThat(issue.currentChange()).isNull(); assertThat(issue.mustSendNotifications()).isFalse(); }
assertThat(raw.isChanged()).isTrue(); verify(updater).setType(raw, RuleType.SECURITY_HOTSPOT, issueChangeContext); verify(updater).setStatus(raw, Issue.STATUS_REOPENED, issueChangeContext); verify(updater).setResolution(raw, null, issueChangeContext); verify(updater).setPastSeverity(raw, BLOCKER, issueChangeContext); verify(updater).setPastLine(raw, 10); verify(updater).setPastMessage(raw, "message", issueChangeContext); verify(updater).setPastEffort(raw, Duration.create(15L), issueChangeContext); verify(updater).setPastLocations(raw, issueLocations);
public void mergeExistingOpenIssue(DefaultIssue raw, DefaultIssue base) { raw.setKey(base.key()); raw.setNew(false); copyFields(raw, base); if (base.manualSeverity()) { raw.setManualSeverity(true); raw.setSeverity(base.severity()); } else { updater.setPastSeverity(raw, base.severity(), changeContext); } // set component/module related fields from base in case current component has been moved // (in which case base issue belongs to original file and raw issue to component) raw.setComponentUuid(base.componentUuid()); raw.setComponentKey(base.componentKey()); raw.setModuleUuid(base.moduleUuid()); raw.setModuleUuidPath(base.moduleUuidPath()); // fields coming from raw updater.setPastLine(raw, base.getLine()); updater.setPastLocations(raw, base.getLocations()); updater.setPastMessage(raw, base.getMessage(), changeContext); updater.setPastGap(raw, base.gap(), changeContext); updater.setPastEffort(raw, base.effort(), changeContext); }
@Test public void not_revert_manual_severity() { issue.setSeverity("MINOR").setManualSeverity(true); try { underTest.setSeverity(issue, "MAJOR", context); } catch (IllegalStateException e) { assertThat(e).hasMessage("Severity can't be changed"); } }
@Override public boolean execute(Map<String, Object> properties, Context context) { String type = verifyTypeParameter(properties); return issueUpdater.setType(context.issue(), RuleType.valueOf(type), context.issueChangeContext()); }
@Test public void set_message() { boolean updated = underTest.setMessage(issue, "the message", context); assertThat(updated).isTrue(); assertThat(issue.isChanged()).isTrue(); assertThat(issue.message()).isEqualTo("the message"); assertThat(issue.mustSendNotifications()).isFalse(); }
@Test public void set_past_technical_debt() { Duration newDebt = Duration.create(15 * 8 * 60); Duration previousDebt = Duration.create(10 * 8 * 60); issue.setEffort(newDebt); boolean updated = underTest.setPastEffort(issue, previousDebt, context); assertThat(updated).isTrue(); assertThat(issue.effort()).isEqualTo(newDebt); assertThat(issue.mustSendNotifications()).isFalse(); FieldDiffs.Diff diff = issue.currentChange().get(TECHNICAL_DEBT); assertThat(diff.oldValue()).isEqualTo(10L * 8 * 60); assertThat(diff.newValue()).isEqualTo(15L * 8 * 60); }
@Test public void set_past_line_has_no_effect_if_line_already_had_value() { issue.setLine(42); boolean updated = underTest.setPastLine(issue, 42); assertThat(updated).isFalse(); assertThat(issue.isChanged()).isFalse(); assertThat(issue.line()).isEqualTo(42); assertThat(issue.mustSendNotifications()).isFalse(); // do not save change assertThat(issue.currentChange()).isNull(); }