How to use

diffs

method

in

org.sonar.core.issue.FieldDiffs

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());
}

@Test
public void test_parse_encoded_assignee() {
 diffs = FieldDiffs.parse("severity=BLOCKER|INFO,assignee=oldValue|" + ENCODED_NAME_WITH_RESERVED_CHARS);
 assertThat(diffs.diffs()).hasSize(2);
 FieldDiffs.Diff diff = diffs.diffs().get("severity");
 assertThat(diff.oldValue()).isEqualTo("BLOCKER");
 assertThat(diff.newValue()).isEqualTo("INFO");
 diff = diffs.diffs().get("assignee");
 assertThat(diff.oldValue()).isEqualTo("oldValue");
 assertThat(diff.newValue()).isEqualTo(NAME_WITH_RESERVED_CHARS);
}

@Test
public void test_diff() {
 diffs.setDiff("severity", "BLOCKER", "INFO");
 diffs.setDiff("resolution", "OPEN", "FIXED");
 assertThat(diffs.diffs()).hasSize(2);
 FieldDiffs.Diff diff = diffs.diffs().get("severity");
 assertThat(diff.oldValue()).isEqualTo("BLOCKER");
 assertThat(diff.newValue()).isEqualTo("INFO");
 diff = diffs.diffs().get("resolution");
 assertThat(diff.oldValue()).isEqualTo("OPEN");
 assertThat(diff.newValue()).isEqualTo("FIXED");
}

@Test
public void test_parse_empty_values() {
 diffs = FieldDiffs.parse("severity=INFO,resolution=");
 assertThat(diffs.diffs()).hasSize(2);
 FieldDiffs.Diff diff = diffs.diffs().get("severity");
 assertThat(diff.oldValue()).isEqualTo(null);
 assertThat(diff.newValue()).isEqualTo("INFO");
 diff = diffs.diffs().get("resolution");
 assertThat(diff.oldValue()).isEqualTo(null);
 assertThat(diff.newValue()).isEqualTo(null);
}

@Test
public void test_diff_by_key() {
 diffs.setDiff("severity", "BLOCKER", "INFO");
 diffs.setDiff("resolution", "OPEN", "FIXED");
 assertThat(diffs.diffs()).hasSize(2);
 FieldDiffs.Diff diff = diffs.diffs().get("severity");
 assertThat(diff.oldValue()).isEqualTo("BLOCKER");
 assertThat(diff.newValue()).isEqualTo("INFO");
 diff = diffs.diffs().get("resolution");
 assertThat(diff.oldValue()).isEqualTo("OPEN");
 assertThat(diff.newValue()).isEqualTo("FIXED");
}

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

@Test
public void diffs_should_be_empty_by_default() {
 assertThat(diffs.diffs()).isEmpty();
}

@Test
public void diff_with_long_values() {
 diffs.setDiff("technicalDebt", 50L, "100");
 FieldDiffs.Diff diff = diffs.diffs().get("technicalDebt");
 assertThat(diff.oldValueLong()).isEqualTo(50L);
 assertThat(diff.newValueLong()).isEqualTo(100L);
}

@Test
public void should_keep_old_value() {
 diffs.setDiff("severity", "BLOCKER", "INFO");
 diffs.setDiff("severity", null, "MAJOR");
 FieldDiffs.Diff diff = diffs.diffs().get("severity");
 assertThat(diff.oldValue()).isEqualTo("BLOCKER");
 assertThat(diff.newValue()).isEqualTo("MAJOR");
}

@Test
public void insert_entry_in_changelog_when_setting_severity() {
 IssueDto issueDto = issueDbTester.insertIssue(newIssue().setSeverity(MAJOR));
 setUserWithBrowseAndAdministerIssuePermission(issueDto);
 call(issueDto.getKey(), MINOR);
 List<FieldDiffs> fieldDiffs = dbClient.issueChangeDao().selectChangelogByIssue(dbTester.getSession(), issueDto.getKey());
 assertThat(fieldDiffs).hasSize(1);
 assertThat(fieldDiffs.get(0).diffs()).hasSize(1);
 assertThat(fieldDiffs.get(0).diffs().get("severity").newValue()).isEqualTo(MINOR);
 assertThat(fieldDiffs.get(0).diffs().get("severity").oldValue()).isEqualTo(MAJOR);
}

public IssueChangeNotification setIssue(DefaultIssue issue) {
 setFieldValue("key", issue.key());
 setFieldValue("message", issue.message());
 FieldDiffs currentChange = issue.currentChange();
 if (currentChange != null) {
  for (Map.Entry<String, FieldDiffs.Diff> entry : currentChange.diffs().entrySet()) {
   String type = entry.getKey();
   FieldDiffs.Diff diff = entry.getValue();
   setFieldValue("old." + type, neverEmptySerializableToString(diff.oldValue()));
   setFieldValue("new." + type, neverEmptySerializableToString(diff.newValue()));
  }
 }
 return this;
}

 @Test
 public void test_parse_empty() {
  diffs = FieldDiffs.parse("");
  assertThat(diffs.diffs()).isEmpty();
 }
}

@Test
public void insert_entry_in_changelog_when_setting_tags() {
 IssueDto issueDto = db.issues().insertIssue(newIssue().setTags(singletonList("old-tag")));
 logIn(issueDto);
 call(issueDto.getKey(), "new-tag");
 List<FieldDiffs> fieldDiffs = dbClient.issueChangeDao().selectChangelogByIssue(db.getSession(), issueDto.getKey());
 assertThat(fieldDiffs).hasSize(1);
 assertThat(fieldDiffs.get(0).diffs()).hasSize(1);
 assertThat(fieldDiffs.get(0).diffs().get("tags").oldValue()).isEqualTo("old-tag");
 assertThat(fieldDiffs.get(0).diffs().get("tags").newValue()).isEqualTo("new-tag");
}

@Test
public void test_parse_null() {
 diffs = FieldDiffs.parse(null);
 assertThat(diffs.diffs()).isEmpty();
}

@Test
public void insert_entry_in_changelog_when_setting_type() {
 IssueDto issueDto = issueDbTester.insertIssue(newIssue().setType(CODE_SMELL));
 setUserWithBrowseAndAdministerIssuePermission(issueDto);
 call(issueDto.getKey(), BUG.name());
 List<FieldDiffs> fieldDiffs = dbClient.issueChangeDao().selectChangelogByIssue(dbTester.getSession(), issueDto.getKey());
 assertThat(fieldDiffs).hasSize(1);
 assertThat(fieldDiffs.get(0).diffs()).hasSize(1);
 assertThat(fieldDiffs.get(0).diffs().get("type").newValue()).isEqualTo(BUG.name());
 assertThat(fieldDiffs.get(0).diffs().get("type").oldValue()).isEqualTo(CODE_SMELL.name());
}

@Test
public void select_issue_changelog_from_issue_key() {
 IssueDto issue1 = db.issues().insertIssue();
 db.issues().insertChange(issue1, c -> c.setChangeType(TYPE_FIELD_CHANGE).setChangeData("severity=MAJOR|BLOCKER"));
 IssueDto issue2 = db.issues().insertIssue();
 db.issues().insertChange(issue2);
 List<FieldDiffs> changelog = underTest.selectChangelogByIssue(db.getSession(), issue1.getKey());
 assertThat(changelog).hasSize(1);
 assertThat(changelog.get(0).diffs()).hasSize(1);
 assertThat(changelog.get(0).diffs().get("severity").newValue()).isEqualTo("BLOCKER");
 assertThat(changelog.get(0).diffs().get("severity").oldValue()).isEqualTo("MAJOR");
 assertThat(underTest.selectChangelogByIssue(db.getSession(), "unknown")).isEmpty();
}

@Test
public void unset_line() {
 int line = 1 + new Random().nextInt(500);
 issue.setLine(line);
 boolean updated = underTest.unsetLine(issue, context);
 assertThat(updated).isTrue();
 assertThat(issue.isChanged()).isTrue();
 assertThat(issue.line()).isNull();
 assertThat(issue.mustSendNotifications()).isFalse();
 assertThat(issue.currentChange())
  .extracting(FieldDiffs::diffs)
  .hasSize(1);
 FieldDiffs.Diff diff = issue.currentChange().diffs().get("line");
 assertThat(diff.oldValue()).isEqualTo(line);
 assertThat(diff.newValue()).isEqualTo("");
}

@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 diff_with_empty_long_values() {
 diffs.setDiff("technicalDebt", null, "");
 FieldDiffs.Diff diff = diffs.diffs().get("technicalDebt");
 assertThat(diff.oldValueLong()).isNull();
 assertThat(diff.newValueLong()).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();
}