How to use

org.sonar.core.issue.FieldDiffs

constructor

public DefaultIssue setFieldChange(IssueChangeContext context, String field, @Nullable Serializable oldValue, @Nullable Serializable newValue) {
 if (!Objects.equals(oldValue, newValue)) {
  if (currentChange == null) {
   currentChange = new FieldDiffs();
   currentChange.setUserUuid(context.userUuid());
   currentChange.setCreationDate(context.date());
  }
  currentChange.setDiff(field, oldValue, newValue);
 }
 addChange(currentChange);
 return this;
}

private void addResolutionChange(DefaultIssue issue, Date creationDate,
 @Nullable String previousResolution, @Nullable String newResolution) {
 checkArgument(previousResolution != null || newResolution != null, "At least one resolution must be non null");
 FieldDiffs fieldDiffs = new FieldDiffs().setCreationDate(creationDate)
  .setDiff("resolution", emptyIfNull(previousResolution), emptyIfNull(newResolution));
 issue.addChange(fieldDiffs);
}

private IssueChangeDto insertToClosedDiff(IssueDto issue, Date creationDate, String previousStatus, String nextStatus) {
 FieldDiffs diffs = new FieldDiffs()
  .setCreationDate(creationDate);
 IntStream.range(0, random.nextInt(3)).forEach(i -> diffs.setDiff("key_b" + i, "old_" + i, "new_" + i));
 diffs.setDiff("status", previousStatus, nextStatus);
 IntStream.range(0, random.nextInt(3)).forEach(i -> diffs.setDiff("key_a" + i, "old_" + i, "new_" + i));
 IssueChangeDto changeDto = IssueChangeDto.of(issue.getKey(), diffs);
 dbTester.getDbClient().issueChangeDao().insert(dbSession, changeDto);
 return changeDto;
}

private void addResolutionAndStatusChange(DefaultIssue issue, Date creationDate,
 String previousStatus, String newStatus,
 @Nullable String previousResolution, @Nullable String newResolution) {
 checkArgument(previousResolution != null || newResolution != null, "At least one resolution must be non null");
 FieldDiffs fieldDiffs = new FieldDiffs().setCreationDate(creationDate)
  .setDiff("status", previousStatus, newStatus)
  .setDiff("resolution", emptyIfNull(previousResolution), emptyIfNull(newResolution));
 issue.addChange(fieldDiffs);
}

private static void addStatusChange(DefaultIssue issue, Date date, String previousStatus, String newStatus) {
 issue.addChange(new FieldDiffs().setCreationDate(date).setDiff("status", previousStatus, newStatus));
}

@Test
public void create_from_diff() {
 FieldDiffs diffs = new FieldDiffs();
 diffs.setDiff("severity", "INFO", "BLOCKER");
 diffs.setUserUuid("user_uuid");
 diffs.setCreationDate(parseDate("2015-01-13"));
 IssueChangeDto dto = IssueChangeDto.of("ABCDE", diffs);
 assertThat(dto.getChangeData()).isEqualTo("severity=INFO|BLOCKER");
 assertThat(dto.getChangeType()).isEqualTo("diff");
 assertThat(dto.getCreatedAt()).isNotNull();
 assertThat(dto.getUpdatedAt()).isNotNull();
 assertThat(dto.getIssueKey()).isEqualTo("ABCDE");
 assertThat(dto.getUserUuid()).isEqualTo("user_uuid");
 assertThat(dto.getIssueChangeCreationDate()).isEqualTo(parseDate("2015-01-13").getTime());
}

private static FieldDiffs newToClosedDiffsWithLine(Date creationDate, @Nullable Integer oldLineValue) {
 FieldDiffs fieldDiffs = new FieldDiffs().setCreationDate(addDays(creationDate, -5))
  .setDiff("status", randomNonCloseStatus(), STATUS_CLOSED);
 if (oldLineValue != null) {
  fieldDiffs.setDiff("line", oldLineValue, "");
 }
 return fieldDiffs;
}

@Test
public void create_from_diff_with_created_at() {
 FieldDiffs diffs = new FieldDiffs();
 diffs.setDiff("severity", "INFO", "BLOCKER");
 diffs.setUserUuid("user_uuid");
 diffs.setCreationDate(parseDate("2015-01-13"));
 IssueChangeDto dto = IssueChangeDto.of("ABCDE", diffs);
 assertThat(dto.getIssueChangeCreationDate()).isEqualTo(parseDate("2015-01-13").getTime());
}

@Test
public void return_changelog_not_having_user() {
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(null).setDiff("severity", "MAJOR", "BLOCKER").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).hasUser()).isFalse();
 assertThat(result.getChangelogList().get(0).hasUserName()).isFalse();
 assertThat(result.getChangelogList().get(0).hasAvatar()).isFalse();
 assertThat(result.getChangelogList().get(0).getDiffsList()).isNotEmpty();
}

@Test
public void return_changelog_on_none_existing_user() {
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid("UNKNOWN").setDiff("severity", "MAJOR", "BLOCKER").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).hasUser()).isFalse();
 assertThat(result.getChangelogList().get(0).hasUserName()).isFalse();
 assertThat(result.getChangelogList().get(0).hasAvatar()).isFalse();
 assertThat(result.getChangelogList().get(0).getDiffsList()).isNotEmpty();
}

@Test
public void set_issue_with_current_change_having_no_new_value() {
 DefaultIssue issue = new DefaultIssue()
  .setKey("ABCD")
  .setAssigneeUuid("simon")
  .setMessage("Remove this useless method")
  .setComponentKey("MyService");
 IssueChangeNotification result = notification.setIssue(issue.setCurrentChange(new FieldDiffs().setDiff("assignee", "john", null)));
 assertThat(result.getFieldValue("old.assignee")).isEqualTo("john");
 assertThat(result.getFieldValue("new.assignee")).isNull();
 result = notification.setIssue(issue.setCurrentChange(new FieldDiffs().setDiff("assignee", "john", "")));
 assertThat(result.getFieldValue("old.assignee")).isEqualTo("john");
 assertThat(result.getFieldValue("new.assignee")).isNull();
}

@Test
public void set_issue_with_current_change_having_no_old_value() {
 DefaultIssue issue = new DefaultIssue()
  .setKey("ABCD")
  .setAssigneeUuid("simon")
  .setMessage("Remove this useless method")
  .setComponentKey("MyService");
 IssueChangeNotification result = notification.setIssue(issue.setCurrentChange(new FieldDiffs().setDiff("resolution", null, "FIXED")));
 assertThat(result.getFieldValue("old.resolution")).isNull();
 assertThat(result.getFieldValue("new.resolution")).isEqualTo("FIXED");
 result = notification.setIssue(issue.setCurrentChange(new FieldDiffs().setDiff("resolution", "", "FIXED")));
 assertThat(result.getFieldValue("old.resolution")).isNull();
 assertThat(result.getFieldValue("new.resolution")).isEqualTo("FIXED");
}

@Test
public void return_changelog_when_no_new_value() {
 UserDto user = insertUser();
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(user.getUuid()).setDiff("severity", "MAJOR", null).setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).getDiffsList().get(0).hasNewValue()).isFalse();
}

@Test
public void return_changelog_when_no_old_value() {
 UserDto user = insertUser();
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(user.getUuid()).setDiff("severity", null, "BLOCKER").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).getDiffsList().get(0).hasOldValue()).isFalse();
}

@Test
public void return_changelog_on_user_without_email() {
 UserDto user = db.users().insertUser(UserTesting.newUserDto("john", "John", null));
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(user.getUuid()).setDiff("severity", "MAJOR", "BLOCKER").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).getUser()).isNotNull().isEqualTo(user.getLogin());
 assertThat(result.getChangelogList().get(0).getUserName()).isNotNull().isEqualTo(user.getName());
 assertThat(result.getChangelogList().get(0).hasAvatar()).isFalse();
}

@Test
public void return_many_changelog() {
 UserDto user = insertUser();
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto,
  new FieldDiffs().setUserUuid(user.getUuid()).setDiff("severity", "MAJOR", "BLOCKER").setCreationDate(new Date()),
  new FieldDiffs().setDiff("status", "RESOLVED", "CLOSED").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(2);
}

@Test
public void changelog_of_file_move_is_empty_when_files_does_not_exists() {
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setDiff("file", "UNKNOWN_1", "UNKNOWN_2").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).getDiffsList()).extracting(Diff::getKey, Diff::hasOldValue, Diff::hasNewValue)
  .containsOnly(tuple("file", false, false));
}

@Test
public void return_empty_changelog_when_not_member() {
 UserDto user = insertUser();
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(user.getUuid()).setDiff("severity", "MAJOR", "BLOCKER").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(0);
}

@Test
public void replace_technical_debt_key_by_effort() {
 UserDto user = insertUser();
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(user.getUuid()).setDiff("technicalDebt", "10", "20").setCreationDate(new Date()));
 ChangelogWsResponse result = call(issueDto.getKey());
 assertThat(result.getChangelogList()).hasSize(1);
 assertThat(result.getChangelogList().get(0).getDiffsList()).extracting(Diff::getKey, Diff::getOldValue, Diff::getNewValue).containsOnly(tuple("effort", "10", "20"));
}

@Test
public void test_example() {
 UserDto user = db.users().insertUser(newUserDto("john.smith", "John Smith", "john@smith.com"));
 IssueDto issueDto = db.issues().insertIssue(newIssue());
 userSession.logIn("john")
  .addMembership(db.getDefaultOrganization())
  .addProjectPermission(USER, project, file);
 db.issues().insertFieldDiffs(issueDto, new FieldDiffs()
  .setUserUuid(user.getUuid())
  .setDiff("severity", "MAJOR", "BLOCKER").setCreationDate(new Date())
  .setCreationDate(DateUtils.parseDateTime("2014-03-04T23:03:44+0100")));
 String result = tester.newRequest().setParam("issue", issueDto.getKey()).execute().getInput();
 assertJson(result).isSimilarTo(getClass().getResource("changelog-example.json"));
}