@Test public void should_sort_by_severity() { IssueDto issue1 = new IssueDto().setId(1L).setSeverity("INFO"); IssueDto issue2 = new IssueDto().setId(2L).setSeverity("BLOCKER"); IssueDto issue3 = new IssueDto().setId(3L).setSeverity("MAJOR"); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_SEVERITY).asc(true).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getSeverity()).isEqualTo("INFO"); assertThat(result.get(1).getSeverity()).isEqualTo("MAJOR"); assertThat(result.get(2).getSeverity()).isEqualTo("BLOCKER"); }
@Test public void should_sort_by_desc_severity() { IssueDto issue1 = new IssueDto().setId(1L).setSeverity("INFO"); IssueDto issue2 = new IssueDto().setId(2L).setSeverity("BLOCKER"); IssueDto issue3 = new IssueDto().setId(3L).setSeverity("MAJOR"); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_SEVERITY).asc(false).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getSeverity()).isEqualTo("BLOCKER"); assertThat(result.get(1).getSeverity()).isEqualTo("MAJOR"); assertThat(result.get(2).getSeverity()).isEqualTo("INFO"); }
@Test public void support_only_issues_with_issue_admin_permission() { IssueDto authorizedIssue = newIssue().setSeverity(MAJOR); setUserWithBrowseAndAdministerIssuePermission(authorizedIssue); IssueDto unauthorizedIssue = newIssue().setSeverity(MAJOR); assertThat(action.supports(authorizedIssue.toDefaultIssue().setResolution(null))).isTrue(); assertThat(action.supports(unauthorizedIssue.toDefaultIssue().setResolution(null))).isFalse(); }
@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); }
@Test public void support_only_unresolved_issues() { IssueDto issueDto = newIssue().setSeverity(MAJOR); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); assertThat(action.supports(issue.setResolution(null))).isTrue(); assertThat(action.supports(issue.setResolution(Issue.RESOLUTION_FIXED))).isFalse(); }
@Test public void doesnt_support_security_hotspots() { IssueDto issueDto = newIssue().setSeverity(MAJOR); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); assertThat(action.supports(issue.setType(RuleType.CODE_SMELL))).isTrue(); assertThat(action.supports(issue.setType(RuleType.SECURITY_HOTSPOT))).isFalse(); }
@Test public void set_severity() { IssueDto issueDto = newIssue().setSeverity(MAJOR); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); BulkChangeAction.ActionContext context = new BulkChangeAction.ActionContext(issue, IssueChangeContext.createUser(NOW, userSession.getUuid()), null); action.execute(ImmutableMap.of("severity", MINOR), context); assertThat(issue.severity()).isEqualTo(MINOR); assertThat(issue.isChanged()).isTrue(); assertThat(issue.manualSeverity()).isTrue(); assertThat(issue.updateDate()).isEqualTo(NOW); assertThat(issue.mustSendNotifications()).isTrue(); Map<String, FieldDiffs.Diff> change = issue.currentChange().diffs(); assertThat(change.get("severity").newValue()).isEqualTo(MINOR); assertThat(change.get("severity").oldValue()).isEqualTo(MAJOR); }
@Test public void set_severity() { IssueDto issueDto = issueDbTester.insertIssue(newIssue().setSeverity(MAJOR)); setUserWithBrowseAndAdministerIssuePermission(issueDto); call(issueDto.getKey(), MINOR); verify(responseWriter).write(eq(issueDto.getKey()), preloadedSearchResponseDataCaptor.capture(), any(Request.class), any(Response.class)); verifyContentOfPreloadedSearchResponseData(issueDto); IssueDto issueReloaded = dbClient.issueDao().selectByKey(dbTester.getSession(), issueDto.getKey()).get(); assertThat(issueReloaded.getSeverity()).isEqualTo(MINOR); assertThat(issueReloaded.isManualSeverity()).isTrue(); assertThat(issueChangePostProcessor.calledComponents()) .extracting(ComponentDto::uuid) .containsExactlyInAnyOrder(issueDto.getComponentUuid()); }
@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 verify_notification_on_branch() { RuleDto rule = db.rules().insertRule(); ComponentDto project = db.components().insertMainBranch(); ComponentDto branch = db.components().insertProjectBranch(project); ComponentDto file = db.components().insertComponent(newFileDto(branch)); RuleType randomTypeExceptHotspot = RuleType.values()[nextInt(RuleType.values().length - 1)]; DefaultIssue issue = db.issues().insertIssue(IssueTesting.newIssue(rule.getDefinition(), branch, file) .setType(randomTypeExceptHotspot)).setSeverity(MAJOR).toDefaultIssue(); IssueChangeContext context = IssueChangeContext.createUser(new Date(), "user_uuid"); issueFieldsSetter.setSeverity(issue, BLOCKER, context); underTest.saveIssue(db.getSession(), issue, context, "increase severity"); verify(notificationManager).scheduleForSending(notificationArgumentCaptor.capture()); IssueChangeNotification issueChangeNotification = notificationArgumentCaptor.getValue(); assertThat(issueChangeNotification.getFieldValue("key")).isEqualTo(issue.key()); assertThat(issueChangeNotification.getFieldValue("projectKey")).isEqualTo(project.getDbKey()); assertThat(issueChangeNotification.getFieldValue("projectName")).isEqualTo(project.name()); assertThat(issueChangeNotification.getFieldValue("branch")).isEqualTo(branch.getBranch()); }
@Test public void saveIssue_populates_specified_SearchResponseData_with_no_rule_but_with_project_and_component_if_rule_is_removed() { RuleDto rule = db.rules().insertRule(r -> r.setStatus(RuleStatus.REMOVED)); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); IssueDto issueDto = IssueTesting.newIssue(rule.getDefinition(), project, file); DefaultIssue issue = db.issues().insertIssue(issueDto).setSeverity(MAJOR).toDefaultIssue(); IssueChangeContext context = IssueChangeContext.createUser(new Date(), "user_uuid"); issueFieldsSetter.setSeverity(issue, BLOCKER, context); SearchResponseData preloadedSearchResponseData = underTest.saveIssueAndPreloadSearchResponseData(db.getSession(), issue, context, null, false); assertThat(preloadedSearchResponseData.getIssues()) .hasSize(1); assertThat(preloadedSearchResponseData.getIssues().iterator().next()) .isNotSameAs(issueDto); assertThat(preloadedSearchResponseData.getRules()).isNullOrEmpty(); assertThat(preloadedSearchResponseData.getComponents()) .extracting(ComponentDto::uuid) .containsOnly(project.uuid(), file.uuid()); }
@Test public void fail_if_bad_severity() { IssueDto issueDto = issueDbTester.insertIssue(newIssue().setSeverity("unknown")); setUserWithBrowseAndAdministerIssuePermission(issueDto); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Value of parameter 'severity' (unknown) must be one of: [INFO, MINOR, MAJOR, CRITICAL, BLOCKER]"); call(issueDto.getKey(), "unknown"); }
@Test public void verify_notification_when_issue_is_linked_on_removed_rule() { RuleDto rule = db.rules().insertRule(r -> r.setStatus(RuleStatus.REMOVED)); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); RuleType randomTypeExceptHotspot = RuleType.values()[nextInt(RuleType.values().length - 1)]; DefaultIssue issue = db.issues().insertIssue(IssueTesting.newIssue(rule.getDefinition(), project, file) .setType(randomTypeExceptHotspot)).setSeverity(MAJOR).toDefaultIssue(); IssueChangeContext context = IssueChangeContext.createUser(new Date(), "user_uuid"); issueFieldsSetter.setSeverity(issue, BLOCKER, context); underTest.saveIssue(db.getSession(), issue, context, null); verify(notificationManager).scheduleForSending(notificationArgumentCaptor.capture()); assertThat(notificationArgumentCaptor.getValue().getFieldValue("ruleName")).isNull(); }
@Test public void saveIssue_populates_specified_SearchResponseData_with_rule_project_and_component_retrieved_from_DB() { RuleDto rule = db.rules().insertRule(); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); IssueDto issueDto = IssueTesting.newIssue(rule.getDefinition(), project, file); DefaultIssue issue = db.issues().insertIssue(issueDto).setSeverity(MAJOR).toDefaultIssue(); IssueChangeContext context = IssueChangeContext.createUser(new Date(), "user_uuid"); issueFieldsSetter.setSeverity(issue, BLOCKER, context); SearchResponseData preloadedSearchResponseData = underTest.saveIssueAndPreloadSearchResponseData(db.getSession(), issue, context, null, true); assertThat(preloadedSearchResponseData.getIssues()) .hasSize(1); assertThat(preloadedSearchResponseData.getIssues().iterator().next()) .isNotSameAs(issueDto); assertThat(preloadedSearchResponseData.getRules()) .extracting(RuleDefinitionDto::getKey) .containsOnly(rule.getKey()); assertThat(preloadedSearchResponseData.getComponents()) .extracting(ComponentDto::uuid) .containsOnly(project.uuid(), file.uuid()); assertThat(issueChangePostProcessor.calledComponents()).containsExactlyInAnyOrder(file); }
@Test public void severity_changed_by_user_should_be_kept() { DefaultIssue issue = new DefaultIssue() .setKey("ABCDE") .setRuleKey(RuleKey.of("squid", "AvoidCycles")) .setComponentKey("struts:org.apache.struts.Action") .setNew(false) .setStatus(STATUS_OPEN); // Changed by scan issue.setSeverity(Severity.BLOCKER); issue.setManualSeverity(false); // Issue as seen and changed by end-user IssueDto dbIssue = new IssueDto() .setKee("ABCDE") .setStatus(STATUS_OPEN) .setSeverity(Severity.INFO) .setManualSeverity(true); new UpdateConflictResolver().mergeFields(dbIssue, issue); assertThat(issue.severity()).isEqualTo(Severity.INFO); assertThat(issue.manualSeverity()).isTrue(); } }
@Test public void set_severity() { UserDto user = db.users().insertUser(); userSession.logIn(user); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); addUserProjectPermissions(user, project, USER, ISSUE_ADMIN); RuleDefinitionDto rule = db.rules().insert(); IssueDto issue = db.issues().insert(rule, project, file, i -> i.setSeverity(MAJOR) .setStatus(STATUS_OPEN).setResolution(null)); BulkChangeWsResponse response = call(builder() .setIssues(singletonList(issue.getKey())) .setSetSeverity(MINOR) .build()); checkResponse(response, 1, 1, 0, 0); IssueDto reloaded = getIssueByKeys(issue.getKey()).get(0); assertThat(reloaded.getSeverity()).isEqualTo(MINOR); assertThat(reloaded.getUpdatedAt()).isEqualTo(NOW); verifyPostProcessorCalled(file); }
@Test public void verify_no_notification_on_hotspot() { UserDto assignee = db.users().insertUser(); RuleDto rule = db.rules().insertRule(); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); DefaultIssue issue = db.issues().insertIssue(IssueTesting.newIssue(rule.getDefinition(), project, file) .setType(RuleType.SECURITY_HOTSPOT)) .setSeverity(MAJOR) .setAssigneeUuid(assignee.getUuid()) .toDefaultIssue(); UserDto changeAuthor = db.users().insertUser(); IssueChangeContext context = IssueChangeContext.createUser(new Date(), changeAuthor.getUuid()); issueFieldsSetter.setSeverity(issue, BLOCKER, context); underTest.saveIssue(db.getSession(), issue, context, "increase severity"); verify(notificationManager, never()).scheduleForSending(any()); }
private void addBaseIssue(RuleKey ruleKey) { ComponentDto project = ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert(), PROJECT_UUID).setDbKey(PROJECT_KEY); ComponentDto file = ComponentTesting.newFileDto(project, null, FILE_UUID).setDbKey(FILE_KEY); dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project, file); RuleDto ruleDto = RuleTesting.newDto(ruleKey); dbTester.rules().insertRule(ruleDto); ruleRepositoryRule.add(ruleKey); IssueDto issue = IssueTesting.newDto(ruleDto, file, project) .setKee("ISSUE") .setStatus(Issue.STATUS_OPEN) .setSeverity(Severity.MAJOR); dbTester.getDbClient().issueDao().insert(dbTester.getSession(), issue); dbTester.getSession().commit(); }
private void addBaseIssueOnBranch(RuleKey ruleKey) { ComponentDto project = ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert(), PROJECT_UUID_ON_BRANCH).setDbKey(PROJECT_KEY); ComponentDto file = ComponentTesting.newFileDto(project, null, FILE_UUID_ON_BRANCH).setDbKey(FILE_KEY); dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project, file); RuleDto ruleDto = RuleTesting.newDto(ruleKey); dbTester.rules().insertRule(ruleDto); ruleRepositoryRule.add(ruleKey); IssueDto issue = IssueTesting.newDto(ruleDto, file, project) .setKee("ISSUE") .setStatus(Issue.STATUS_OPEN) .setSeverity(Severity.MAJOR); dbTester.getDbClient().issueDao().insert(dbTester.getSession(), issue); dbTester.getSession().commit(); } }
@Test public void issue_on_removed_file() { RuleDto rule = newRule(); OrganizationDto organization = db.organizations().insert(o -> o.setKey("my-org-2")); ComponentDto project = db.components().insertComponent(ComponentTesting.newPublicProjectDto(organization, "PROJECT_ID").setDbKey("PROJECT_KEY")); indexPermissions(); ComponentDto removedFile = db.components().insertComponent(newFileDto(project, null).setUuid("REMOVED_FILE_ID") .setDbKey("REMOVED_FILE_KEY") .setEnabled(false)); IssueDto issue = newDto(rule, removedFile, project) .setKee("82fd47d4-b650-4037-80bc-7b112bd4eac2") .setComponent(removedFile) .setStatus("OPEN").setResolution("OPEN") .setSeverity("MAJOR") .setIssueCreationDate(parseDateTime("2014-09-04T00:00:00+0100")) .setIssueUpdateDate(parseDateTime("2017-12-04T00:00:00+0100")); dbClient.issueDao().insert(session, issue); session.commit(); indexIssues(); ws.newRequest() .execute() .assertJson(this.getClass(), "issue_on_removed_file.json"); }