private static void setChanges(Map<String, List<IssueChangeDto>> changeDtoByIssueKey, DefaultIssue i) { changeDtoByIssueKey.computeIfAbsent(i.key(), k -> emptyList()) .forEach(c -> addChangeOrComment(i, c)); }
private ComponentDto getComponent(DbSession dbSession, DefaultIssue issue, @Nullable String componentUuid) { String issueKey = issue.key(); checkState(componentUuid != null, "Issue '%s' has no component", issueKey); ComponentDto component = dbClient.componentDao().selectByUuid(dbSession, componentUuid).orElse(null); checkState(component != null, "Component uuid '%s' for issue key '%s' cannot be found", componentUuid, issueKey); return component; }
private State stateOf(DefaultIssue issue) { String status = issue.status(); State state = machine.state(status); String issueKey = issue.key(); checkState(state != null, "Unknown status: %s [issue=%s]", status, issueKey); return state; }
public Map<ShortBranchIssue, DefaultIssue> loadDefaultIssuesWithChanges(Collection<ShortBranchIssue> lightIssues) { if (lightIssues.isEmpty()) { return Collections.emptyMap(); } Map<String, ShortBranchIssue> issuesByKey = lightIssues.stream().collect(Collectors.toMap(ShortBranchIssue::getKey, i -> i)); try (DbSession session = dbClient.openSession(false)) { List<DefaultIssue> issues = dbClient.issueDao().selectByKeys(session, issuesByKey.keySet()) .stream() .map(IssueDto::toDefaultIssue) .collect(toList(issuesByKey.size())); componentIssuesLoader.loadChanges(session, issues); return issues.stream() .collect(uniqueIndex(i -> issuesByKey.get(i.key()), i -> i, issues.size())); } }
private ChangedIssueImpl(DefaultIssue issue) { this.key = issue.key(); this.status = statusOf(issue); this.type = issue.type(); }
public void resolve(DefaultIssue issue, IssueDto dbIssue, IssueMapper mapper) { LOG.debug("Resolve conflict on issue {}", issue.key()); mergeFields(dbIssue, issue); mapper.update(IssueDto.toDtoForUpdate(issue, System.currentTimeMillis())); }
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; }
private static Consumer<Action> applyAction(ActionContext actionContext, BulkChangeData bulkChangeData, BulkChangeResult result) { return action -> { DefaultIssue issue = actionContext.issue(); try { if (action.supports(issue) && action.execute(bulkChangeData.getProperties(action.key()), actionContext)) { result.increaseSuccess(issue); } } catch (Exception e) { result.increaseFailure(); LOG.error(format("An error occur when trying to apply the action : %s on issue : %s. This issue has been ignored. Error is '%s'", action.key(), issue.key(), e.getMessage()), e); } }; }
public void addComment(DefaultIssue issue, String text, IssueChangeContext context) { issue.addComment(DefaultIssueComment.create(issue.key(), context.userUuid(), text)); issue.setUpdateDate(context.date()); issue.setChanged(true); }
private void assertInitializedExternalIssue(DefaultIssue issue) { assertThat(issue.projectKey()).isEqualTo(PROJECT.getKey()); assertThat(issue.componentKey()).isEqualTo(FILE.getKey()); assertThat(issue.componentUuid()).isEqualTo(FILE.getUuid()); assertThat(issue.resolution()).isNull(); assertThat(issue.status()).isEqualTo(Issue.STATUS_OPEN); assertThat(issue.key()).isNull(); assertThat(issue.authorLogin()).isNull(); }
@Test public void close_issue() { String fileUuid = "FILE1"; String issueUuid = "ABCD"; when(componentsWithUnprocessedIssues.getUuids()).thenReturn(newHashSet(fileUuid)); DefaultIssue issue = new DefaultIssue().setKey(issueUuid); when(issuesLoader.loadOpenIssues(fileUuid)).thenReturn(Collections.singletonList(issue)); underTest.visit(ReportComponent.builder(PROJECT, 1).build()); verify(issueLifecycle).doAutomaticTransition(issue); CloseableIterator<DefaultIssue> issues = issueCache.traverse(); assertThat(issues.hasNext()).isTrue(); DefaultIssue result = issues.next(); assertThat(result.key()).isEqualTo(issueUuid); assertThat(result.isBeingClosed()).isTrue(); assertThat(result.isOnDisabledRule()).isFalse(); }
@Test public void merge_confirmed_issues() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); DefaultIssue newIssue = createIssue("issue2", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch1")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue1"); }
private void assertInitializedIssue(DefaultIssue issue) { assertThat(issue.projectKey()).isEqualTo(PROJECT.getKey()); assertThat(issue.componentKey()).isEqualTo(FILE.getKey()); assertThat(issue.componentUuid()).isEqualTo(FILE.getUuid()); assertThat(issue.resolution()).isNull(); assertThat(issue.status()).isEqualTo(Issue.STATUS_OPEN); assertThat(issue.key()).isNull(); assertThat(issue.authorLogin()).isNull(); assertThat(issue.effort()).isNull(); assertThat(issue.effortInMinutes()).isNull(); }
private void verifyListenerCalled(QGChangeEventListener listener, QGChangeEvent changeEvent, DefaultIssue... issues) { ArgumentCaptor<Set<ChangedIssue>> changedIssuesCaptor = newSetCaptor(); verify(listener).onIssueChanges(same(changeEvent), changedIssuesCaptor.capture()); Set<ChangedIssue> changedIssues = changedIssuesCaptor.getValue(); Tuple[] expected = Arrays.stream(issues) .map(issue -> tuple(issue.key(), ChangedIssueImpl.statusOf(issue), issue.type())) .toArray(Tuple[]::new); assertThat(changedIssues) .hasSize(issues.length) .extracting(ChangedIssue::getKey, t -> t.getStatus(), ChangedIssue::getType) .containsOnly(expected); }
@Override public void handle(Request request, Response response) { userSession.checkLoggedIn(); AddCommentRequest wsRequest = toWsRequest(request); try (DbSession dbSession = dbClient.openSession(false)) { IssueDto issueDto = issueFinder.getByKey(dbSession, wsRequest.getIssue()); IssueChangeContext context = IssueChangeContext.createUser(new Date(system2.now()), userSession.getUuid()); DefaultIssue defaultIssue = issueDto.toDefaultIssue(); issueFieldsSetter.addComment(defaultIssue, wsRequest.getText(), context); SearchResponseData preloadedSearchResponseData = issueUpdater.saveIssueAndPreloadSearchResponseData(dbSession, defaultIssue, context, wsRequest.getText(), false); responseWriter.write(defaultIssue.key(), preloadedSearchResponseData, request, response); } }
@Test public void update_issue() { DefaultIssue issue = db.issues().insertIssue(i -> i.setSeverity(MAJOR)).toDefaultIssue(); IssueChangeContext context = IssueChangeContext.createUser(new Date(), "user_uuid"); issueFieldsSetter.setSeverity(issue, BLOCKER, context); underTest.saveIssue(db.getSession(), issue, context, null); IssueDto issueReloaded = dbClient.issueDao().selectByKey(db.getSession(), issue.key()).get(); assertThat(issueReloaded.getSeverity()).isEqualTo(BLOCKER); }
@Test public void prefer_confirmed_issues_if_no_resolved() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_REOPENED).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch2Dto, fileOnBranch2Dto).setKee("issue2").setStatus(Issue.STATUS_OPEN).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch3Dto, fileOnBranch3Dto).setKee("issue3").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); DefaultIssue newIssue = createIssue("newIssue", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch3")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue3"); }
@Test public void prefer_resolved_issues() { db.issues().insertIssue(IssueTesting.newIssue(rule, branch1Dto, fileOnBranch1Dto).setKee("issue1").setStatus(Issue.STATUS_REOPENED).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch2Dto, fileOnBranch2Dto).setKee("issue2").setStatus(Issue.STATUS_CONFIRMED).setLine(1).setChecksum("checksum")); db.issues().insertIssue(IssueTesting.newIssue(rule, branch3Dto, fileOnBranch3Dto).setKee("issue3").setStatus(Issue.STATUS_RESOLVED) .setResolution(Issue.RESOLUTION_FALSE_POSITIVE).setLine(1).setChecksum("checksum")); DefaultIssue newIssue = createIssue("newIssue", rule.getKey(), Issue.STATUS_OPEN, null, new Date()); copier.tryMerge(FILE_1, Collections.singleton(newIssue)); ArgumentCaptor<DefaultIssue> issueToMerge = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeConfirmedOrResolvedFromShortLivingBranch(eq(newIssue), issueToMerge.capture(), eq("myBranch3")); assertThat(issueToMerge.getValue().key()).isEqualTo("issue3"); }
private TrackedIssue toTrackedIssue(DefaultIssue issue) { TrackedIssue trackedIssue = new TrackedIssue(); trackedIssue.setKey(issue.key()); trackedIssue.setRuleKey(issue.ruleKey()); trackedIssue.setComponentKey(issue.componentKey()); trackedIssue.setSeverity(issue.severity()); trackedIssue.setResolution(issue.resolution()); return trackedIssue; } }