org.sonar.core.issue.FieldDiffs.get java code examples

private Set<String> getFileUuids(List<FieldDiffs> changes) {
 return changes.stream()
  .filter(diffs -> diffs.diffs().containsKey(FILE))
  .flatMap(diffs -> Stream.of(diffs.get(FILE).newValue().toString(), diffs.get(FILE).oldValue().toString()))
  .collect(MoreCollectors.toSet());
}

@CheckForNull
private StatusAndResolutionDiffs parse(FieldDiffs fieldDiffs) {
 FieldDiffs.Diff status = fieldDiffs.get("status");
 if (status == null) {
  return null;
 }
 FieldDiffs.Diff resolution = fieldDiffs.get("resolution");
 if (resolution == null) {
  return new StatusAndResolutionDiffs(Issue.STATUS_CLOSED.equals(status.newValue()), null, null);
 }
 return new StatusAndResolutionDiffs(Issue.STATUS_CLOSED.equals(status.newValue()), (String) resolution.oldValue(), (String) resolution.newValue());
}

@Test
public void get_with_assignee() {
 diffs.setDiff("assignee", "oldAssignee", NAME_WITH_RESERVED_CHARS);
 FieldDiffs.Diff diff = diffs.get("assignee");
 assertThat(diff.oldValue()).isEqualTo("oldAssignee");
 assertThat(diff.newValue()).isEqualTo(NAME_WITH_RESERVED_CHARS);
}

@Test
public void set_new_assignee() {
 boolean updated = underTest.setNewAssignee(issue, "user_uuid", context);
 assertThat(updated).isTrue();
 assertThat(issue.assignee()).isEqualTo("user_uuid");
 assertThat(issue.mustSendNotifications()).isTrue();
 FieldDiffs.Diff diff = issue.currentChange().get(ASSIGNEE);
 assertThat(diff.oldValue()).isEqualTo(UNUSED);
 assertThat(diff.newValue()).isEqualTo("user_uuid");
}

@Test
public void set_resolution() {
 boolean updated = underTest.setResolution(issue, "OPEN", context);
 assertThat(updated).isTrue();
 assertThat(issue.resolution()).isEqualTo("OPEN");
 FieldDiffs.Diff diff = issue.currentChange().get(RESOLUTION);
 assertThat(diff.oldValue()).isNull();
 assertThat(diff.newValue()).isEqualTo("OPEN");
 assertThat(issue.mustSendNotifications()).isTrue();
}

@Test
public void set_manual_severity() {
 issue.setSeverity("BLOCKER");
 boolean updated = underTest.setManualSeverity(issue, "MINOR", context);
 assertThat(updated).isTrue();
 assertThat(issue.severity()).isEqualTo("MINOR");
 assertThat(issue.manualSeverity()).isTrue();
 assertThat(issue.mustSendNotifications()).isTrue();
 FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY);
 assertThat(diff.oldValue()).isEqualTo("BLOCKER");
 assertThat(diff.newValue()).isEqualTo("MINOR");
}

@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 update_severity() {
 issue.setSeverity("BLOCKER");
 boolean updated = underTest.setSeverity(issue, "MINOR", context);
 assertThat(updated).isTrue();
 assertThat(issue.severity()).isEqualTo("MINOR");
 assertThat(issue.mustSendNotifications()).isFalse();
 FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY);
 assertThat(diff.oldValue()).isEqualTo("BLOCKER");
 assertThat(diff.newValue()).isEqualTo("MINOR");
}

@Test
public void set_new_author() {
 boolean updated = underTest.setNewAuthor(issue, "simon", context);
 assertThat(updated).isTrue();
 FieldDiffs.Diff diff = issue.currentChange().get("author");
 assertThat(diff.oldValue()).isNull();
 assertThat(diff.newValue()).isEqualTo("simon");
 assertThat(issue.mustSendNotifications()).isFalse();
}

@Test
public void set_new_attribute_value() {
 boolean updated = underTest.setAttribute(issue, "JIRA", "FOO-123", context);
 assertThat(updated).isTrue();
 assertThat(issue.attribute("JIRA")).isEqualTo("FOO-123");
 assertThat(issue.currentChange().diffs()).hasSize(1);
 assertThat(issue.currentChange().get("JIRA").oldValue()).isNull();
 assertThat(issue.currentChange().get("JIRA").newValue()).isEqualTo("FOO-123");
 assertThat(issue.mustSendNotifications()).isFalse();
}

@Test
public void set_severity() {
 boolean updated = underTest.setSeverity(issue, "BLOCKER", context);
 assertThat(updated).isTrue();
 assertThat(issue.severity()).isEqualTo("BLOCKER");
 assertThat(issue.manualSeverity()).isFalse();
 assertThat(issue.mustSendNotifications()).isFalse();
 FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY);
 assertThat(diff.oldValue()).isNull();
 assertThat(diff.newValue()).isEqualTo("BLOCKER");
}

@Test
public void set_status() {
 boolean updated = underTest.setStatus(issue, "OPEN", context);
 assertThat(updated).isTrue();
 assertThat(issue.status()).isEqualTo("OPEN");
 FieldDiffs.Diff diff = issue.currentChange().get(STATUS);
 assertThat(diff.oldValue()).isNull();
 assertThat(diff.newValue()).isEqualTo("OPEN");
 assertThat(issue.mustSendNotifications()).isTrue();
}

@Test
public void set_author() {
 boolean updated = underTest.setAuthorLogin(issue, "eric", context);
 assertThat(updated).isTrue();
 assertThat(issue.authorLogin()).isEqualTo("eric");
 FieldDiffs.Diff diff = issue.currentChange().get("author");
 assertThat(diff.oldValue()).isNull();
 assertThat(diff.newValue()).isEqualTo("eric");
 assertThat(issue.mustSendNotifications()).isFalse();
}

@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_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 assign() {
 UserDto user = newUserDto().setLogin("emmerik").setName("Emmerik");
 boolean updated = underTest.assign(issue, user, context);
 assertThat(updated).isTrue();
 assertThat(issue.assignee()).isEqualTo(user.getUuid());
 assertThat(issue.mustSendNotifications()).isTrue();
 FieldDiffs.Diff diff = issue.currentChange().get(ASSIGNEE);
 assertThat(diff.oldValue()).isEqualTo(UNUSED);
 assertThat(diff.newValue()).isEqualTo(user.getName());
}

@Test
public void change_assignee() {
 UserDto user = newUserDto().setLogin("emmerik").setName("Emmerik");
 issue.setAssigneeUuid("user_uuid");
 boolean updated = underTest.assign(issue, user, context);
 assertThat(updated).isTrue();
 assertThat(issue.assignee()).isEqualTo(user.getUuid());
 assertThat(issue.mustSendNotifications()).isTrue();
 FieldDiffs.Diff diff = issue.currentChange().get(ASSIGNEE);
 assertThat(diff.oldValue()).isEqualTo(UNUSED);
 assertThat(diff.newValue()).isEqualTo(user.getName());
}

@Test
public void unassign() {
 issue.setAssigneeUuid("user_uuid");
 boolean updated = underTest.assign(issue, null, context);
 assertThat(updated).isTrue();
 assertThat(issue.assignee()).isNull();
 assertThat(issue.mustSendNotifications()).isTrue();
 FieldDiffs.Diff diff = issue.currentChange().get(ASSIGNEE);
 assertThat(diff.oldValue()).isEqualTo(UNUSED);
 assertThat(diff.newValue()).isNull();
}

@Test
public void set_past_technical_debt_with_null_new_value() {
 issue.setEffort(null);
 Duration previousDebt = Duration.create(10 * 8 * 60);
 boolean updated = underTest.setPastEffort(issue, previousDebt, context);
 assertThat(updated).isTrue();
 assertThat(issue.effort()).isNull();
 assertThat(issue.mustSendNotifications()).isFalse();
 FieldDiffs.Diff diff = issue.currentChange().get(TECHNICAL_DEBT);
 assertThat(diff.oldValue()).isEqualTo(10L * 8 * 60);
 assertThat(diff.newValue()).isNull();
}

@Test
public void unset_attribute() {
 issue.setAttribute("JIRA", "FOO-123");
 boolean updated = underTest.setAttribute(issue, "JIRA", null, context);
 assertThat(updated).isTrue();
 assertThat(issue.attribute("JIRA")).isNull();
 assertThat(issue.currentChange().diffs()).hasSize(1);
 assertThat(issue.currentChange().get("JIRA").oldValue()).isEqualTo("FOO-123");
 assertThat(issue.currentChange().get("JIRA").newValue()).isNull();
 assertThat(issue.mustSendNotifications()).isFalse();
}

Popular methods of FieldDiffs

Popular in Java

Making http requests using okhttp
setContentView (Activity)
getSupportFragmentManager (FragmentActivity)
getSystemService (Context)
FlowLayout (java.awt)
A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
Rectangle (java.awt)
A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
FileNotFoundException (java.io)
Thrown when a file specified by a program cannot be found.
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
Top plugins for WebStorm

How to use getmethodin org.sonar.core.issue.FieldDiffs

Best Java code snippets using org.sonar.core.issue.FieldDiffs.get (Showing top 20 results out of 315)

How to use
get
method
in
org.sonar.core.issue.FieldDiffs