@Test public void should_sort_by_close_date() { Date date = new Date(); Date date1 = DateUtils.addDays(date, -3); Date date2 = DateUtils.addDays(date, -2); Date date3 = DateUtils.addDays(date, -1); IssueDto issue1 = new IssueDto().setId(1L).setIssueCloseDate(date1); IssueDto issue2 = new IssueDto().setId(2L).setIssueCloseDate(date3); IssueDto issue3 = new IssueDto().setId(3L).setIssueCloseDate(date2); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(false).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getIssueCloseDate()).isEqualTo(date3); assertThat(result.get(1).getIssueCloseDate()).isEqualTo(date2); assertThat(result.get(2).getIssueCloseDate()).isEqualTo(date1); }
private static void setBranch(IssueQuery.Builder builder, ComponentDto component, @Nullable String branch, @Nullable String pullRequest) { builder.branchUuid(branch == null && pullRequest == null ? null : component.projectUuid()); builder.mainBranch(UNKNOWN_COMPONENT.equals(component) || (branch == null && pullRequest == null) || (branch != null && !branch.equals(component.getBranch())) || (pullRequest != null && !pullRequest.equals(component.getPullRequest()))); } }
builder.componentUuids(singleton(UNKNOWN)); return; break; case Qualifiers.PROJECT: builder.projectUuids(components.stream().map(IssueQueryFactory::toProjectUuid).collect(toList())); break; case Qualifiers.MODULE: builder.moduleRootUuids(components.stream().map(ComponentDto::uuid).collect(toList())); break; case Qualifiers.DIRECTORY: case Qualifiers.FILE: case Qualifiers.UNIT_TEST_FILE: builder.fileUuids(components.stream().map(ComponentDto::uuid).collect(toList())); break; default:
@Test public void collection_params_should_not_be_null_but_empty() { IssueQuery query = IssueQuery.builder() .issueKeys(null) .projectUuids(null) .componentUuids(null) .moduleUuids(null) .statuses(null) .assigneeUuids(null) .resolutions(null) .rules(null) .severities(null) .languages(null) .tags(null) .types(null) .owaspTop10(null) .sansTop25(null) .cwe(null) .createdAfterByProjectUuids(null) .build(); assertThat(query.issueKeys()).isEmpty(); assertThat(query.projectUuids()).isEmpty();
assertThatSearchReturnsOnly(IssueQuery.builder().createdAfter(parseDate("2014-09-19")).createdBefore(parseDate("2014-09-25")), "I1", "I2"); .createdAfter(parseDate("2014-09-20")).createdBefore(parseDate("2014-09-25")), "I1", "I2"); .createdAfter(parseDate("2014-09-21")).createdBefore(parseDate("2014-09-25")), "I2"); .createdAfter(parseDate("2014-09-21")).createdBefore(parseDate("2014-09-24")), "I2"); .createdAfter(parseDate("2014-09-21")).createdBefore(parseDate("2014-09-23"))); .createdAfter(parseDate("2014-09-19")).createdBefore(parseDate("2014-09-21")), "I1"); .createdAfter(parseDate("2014-09-20")).createdBefore(parseDate("2014-09-20")) .build(), new SearchOptions());
.createdAfterByProjectUuids(ImmutableMap.of(project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -15), true))), project1Issue1.key()); .createdAfterByProjectUuids(ImmutableMap.of( project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -14), true), project2.uuid(), new IssueQuery.PeriodStart(addDays(now, -25), true))), .createdAfterByProjectUuids(ImmutableMap.of( project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -30), true))), project1Issue1.key(), project1Issue2.key()); .createdAfterByProjectUuids(ImmutableMap.of( project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -5), true), project2.uuid(), new IssueQuery.PeriodStart(addDays(now, -5), true))));
public IssueQuery create(SearchRequest request) { try (DbSession dbSession = dbClient.openSession(false)) { IssueQuery.Builder builder = IssueQuery.builder() .issueKeys(request.getIssues()) .severities(request.getSeverities()) .statuses(request.getStatuses()) .resolutions(request.getResolutions()) .resolved(request.getResolved()) .rules(ruleKeysToRuleId(dbSession, request.getRules())) .assigneeUuids(request.getAssigneeUuids()) .authors(request.getAuthors()) .languages(request.getLanguages()) .tags(request.getTags()) .types(request.getTypes()) .owaspTop10(request.getOwaspTop10()) .sansTop25(request.getSansTop25()) .cwe(request.getCwe()) .assigned(request.getAssigned()) .createdAt(parseDateOrDateTime(request.getCreatedAt())) .createdBefore(parseEndingDateOrDateTime(request.getCreatedBefore())) .facetMode(request.getFacetMode()) .organizationUuid(convertOrganizationKeyToUuid(dbSession, request.getOrganization())); String sort = request.getSort(); if (!Strings.isNullOrEmpty(sort)) { builder.sort(sort); builder.asc(request.getAsc()); return builder.build();
@Test public void filter_by_application_branch_having_project_branches() { ComponentDto application = db.components().insertMainBranch(c -> c.setQualifier(APP).setDbKey("app")); ComponentDto applicationBranch1 = db.components().insertProjectBranch(application, a -> a.setKey("app-branch1")); ComponentDto applicationBranch2 = db.components().insertProjectBranch(application, a -> a.setKey("app-branch2")); ComponentDto project1 = db.components().insertPrivateProject(p -> p.setDbKey("prj1")); ComponentDto project1Branch1 = db.components().insertProjectBranch(project1); ComponentDto fileOnProject1Branch1 = db.components().insertComponent(newFileDto(project1Branch1)); ComponentDto project1Branch2 = db.components().insertProjectBranch(project1); ComponentDto project2 = db.components().insertPrivateProject(p -> p.setDbKey("prj2")); indexView(applicationBranch1.uuid(), asList(project1Branch1.uuid(), project2.uuid())); indexView(applicationBranch2.uuid(), singletonList(project1Branch2.uuid())); IssueDoc issueOnProject1 = newDoc(project1); IssueDoc issueOnProject1Branch1 = newDoc(project1Branch1); IssueDoc issueOnFileOnProject1Branch1 = newDoc(fileOnProject1Branch1); IssueDoc issueOnProject1Branch2 = newDoc(project1Branch2); IssueDoc issueOnProject2 = newDoc(project2); indexIssues(issueOnProject1, issueOnProject1Branch1, issueOnFileOnProject1Branch1, issueOnProject1Branch2, issueOnProject2); assertThatSearchReturnsOnly(IssueQuery.builder().viewUuids(singletonList(applicationBranch1.uuid())).branchUuid(applicationBranch1.uuid()).mainBranch(false), issueOnProject1Branch1.key(), issueOnFileOnProject1Branch1.key(), issueOnProject2.key()); assertThatSearchReturnsOnly( IssueQuery.builder().viewUuids(singletonList(applicationBranch1.uuid())).projectUuids(singletonList(project1.uuid())).branchUuid(applicationBranch1.uuid()).mainBranch(false), issueOnProject1Branch1.key(), issueOnFileOnProject1Branch1.key()); assertThatSearchReturnsOnly( IssueQuery.builder().viewUuids(singletonList(applicationBranch1.uuid())).fileUuids(singletonList(fileOnProject1Branch1.uuid())).branchUuid(applicationBranch1.uuid()) .mainBranch(false), issueOnFileOnProject1Branch1.key()); assertThatSearchReturnsEmpty( IssueQuery.builder().viewUuids(singletonList(applicationBranch1.uuid())).projectUuids(singletonList("unknown")).branchUuid(applicationBranch1.uuid()).mainBranch(false)); }
@Test public void test_default_query() { IssueQuery query = IssueQuery.builder().build(); assertThat(query.issueKeys()).isEmpty(); assertThat(query.projectUuids()).isEmpty(); assertThat(query.componentUuids()).isEmpty(); assertThat(query.moduleUuids()).isEmpty(); assertThat(query.statuses()).isEmpty(); assertThat(query.assignees()).isEmpty(); assertThat(query.resolutions()).isEmpty(); assertThat(query.rules()).isEmpty(); assertThat(query.severities()).isEmpty(); assertThat(query.languages()).isEmpty(); assertThat(query.tags()).isEmpty(); assertThat(query.types()).isEmpty(); assertThat(query.organizationUuid()).isNull(); assertThat(query.branchUuid()).isNull(); assertThat(query.assigned()).isNull(); assertThat(query.createdAfter()).isNull(); assertThat(query.createdBefore()).isNull(); assertThat(query.resolved()).isNull(); assertThat(query.sort()).isNull(); assertThat(query.createdAfterByProjectUuids()).isEmpty(); }
@Test public void list_tags() { RuleDefinitionDto r1 = db.rules().insert(); RuleDefinitionDto r2 = db.rules().insert(); ruleIndexer.commitAndIndex(db.getSession(), asList(r1.getId(), r2.getId())); OrganizationDto org = db.organizations().insert(); OrganizationDto anotherOrg = db.organizations().insert(); ComponentDto project = newPrivateProjectDto(newOrganizationDto()); ComponentDto file = newFileDto(project, null); indexIssues( newDoc("I42", file).setOrganizationUuid(anotherOrg.getUuid()).setRuleId(r1.getId()).setTags(of("another")), newDoc("I1", file).setOrganizationUuid(org.getUuid()).setRuleId(r1.getId()).setTags(of("convention", "java8", "bug")), newDoc("I2", file).setOrganizationUuid(org.getUuid()).setRuleId(r1.getId()).setTags(of("convention", "bug")), newDoc("I3", file).setOrganizationUuid(org.getUuid()).setRuleId(r2.getId()), newDoc("I4", file).setOrganizationUuid(org.getUuid()).setRuleId(r1.getId()).setTags(of("convention"))); assertThat(underTest.searchTags(IssueQuery.builder().organizationUuid(org.getUuid()).build(), null, 100)).containsOnly("convention", "java8", "bug"); assertThat(underTest.searchTags(IssueQuery.builder().organizationUuid(org.getUuid()).build(), null, 2)).containsOnly("bug", "convention"); assertThat(underTest.searchTags(IssueQuery.builder().organizationUuid(org.getUuid()).build(), "vent", 100)).containsOnly("convention"); assertThat(underTest.searchTags(IssueQuery.builder().organizationUuid(org.getUuid()).build(), null, 1)).containsOnly("bug"); assertThat(underTest.searchTags(IssueQuery.builder().organizationUuid(org.getUuid()).build(), null, 100)).containsOnly("convention", "java8", "bug"); assertThat(underTest.searchTags(IssueQuery.builder().organizationUuid(org.getUuid()).build(), "invalidRegexp[", 100)).isEmpty(); assertThat(underTest.searchTags(IssueQuery.builder().build(), null, 100)).containsExactlyInAnyOrder("another", "convention", "java8", "bug"); }
@Test public void filter_by_application_branch() { ComponentDto application = db.components().insertMainBranch(c -> c.setQualifier(APP)); ComponentDto branch1 = db.components().insertProjectBranch(application); ComponentDto branch2 = db.components().insertProjectBranch(application); ComponentDto project1 = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project1)); ComponentDto project2 = db.components().insertPrivateProject(); indexView(branch1.uuid(), singletonList(project1.uuid())); indexView(branch2.uuid(), singletonList(project2.uuid())); IssueDoc issueOnProject1 = newDoc(project1); IssueDoc issueOnFile = newDoc(file); IssueDoc issueOnProject2 = newDoc(project2); indexIssues(issueOnProject1, issueOnFile, issueOnProject2); assertThatSearchReturnsOnly(IssueQuery.builder().viewUuids(singletonList(branch1.uuid())).branchUuid(branch1.uuid()).mainBranch(false), issueOnProject1.key(), issueOnFile.key()); assertThatSearchReturnsOnly( IssueQuery.builder().viewUuids(singletonList(branch1.uuid())).projectUuids(singletonList(project1.uuid())).branchUuid(branch1.uuid()).mainBranch(false), issueOnProject1.key(), issueOnFile.key()); assertThatSearchReturnsOnly(IssueQuery.builder().viewUuids(singletonList(branch1.uuid())).fileUuids(singletonList(file.uuid())).branchUuid(branch1.uuid()).mainBranch(false), issueOnFile.key()); assertThatSearchReturnsEmpty(IssueQuery.builder().branchUuid("unknown")); }
@Test public void sort_by_file_and_line() { ComponentDto project = newPrivateProjectDto(newOrganizationDto()); ComponentDto file1 = newFileDto(project, null, "F1").setPath("src/main/xoo/org/sonar/samples/File.xoo"); ComponentDto file2 = newFileDto(project, null, "F2").setPath("src/main/xoo/org/sonar/samples/File2.xoo"); indexIssues( // file F1 newDoc("F1_2", file1).setLine(20), newDoc("F1_1", file1).setLine(null), newDoc("F1_3", file1).setLine(25), // file F2 newDoc("F2_1", file2).setLine(9), newDoc("F2_2", file2).setLine(109), // two issues on the same line -> sort by key newDoc("F2_3", file2).setLine(109)); // ascending sort -> F1 then F2. Line "0" first. IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_FILE_LINE).asc(true); assertThatSearchReturnsOnly(query, "F1_1", "F1_2", "F1_3", "F2_1", "F2_2", "F2_3"); // descending sort -> F2 then F1 query = IssueQuery.builder().sort(IssueQuery.SORT_BY_FILE_LINE).asc(false); assertThatSearchReturnsOnly(query, "F2_3", "F2_2", "F2_1", "F1_3", "F1_2", "F1_1"); }
private List<String> searchTags(Optional<OrganizationDto> organization, Optional<ComponentDto> project, Request request) { IssueQuery.Builder issueQueryBuilder = IssueQuery.builder(); organization.ifPresent(o -> issueQueryBuilder.organizationUuid(o.getUuid())); project.ifPresent(p -> { switch (p.qualifier()) { case Qualifiers.PROJECT: issueQueryBuilder.projectUuids(ImmutableSet.of(p.uuid())); return; case Qualifiers.APP: case Qualifiers.VIEW: issueQueryBuilder.viewUuids(ImmutableSet.of(p.uuid())); return; default: throw new IllegalArgumentException(String.format("Component of type '%s' is not supported", p.qualifier())); } }); return issueIndex.searchTags( issueQueryBuilder.build(), request.param(TEXT_QUERY), request.mandatoryParamAsInt(PAGE_SIZE)); }
private List<String> getAuthors(OrganizationDto organization, Optional<ComponentDto> project, Request request) { IssueQuery.Builder issueQueryBuilder = IssueQuery.builder() .organizationUuid(organization.getUuid()); project.ifPresent(p -> { switch (p.qualifier()) { case Qualifiers.PROJECT: issueQueryBuilder.projectUuids(ImmutableSet.of(p.uuid())); return; case Qualifiers.APP: case Qualifiers.VIEW: issueQueryBuilder.viewUuids(ImmutableSet.of(p.uuid())); return; default: throw new IllegalArgumentException(String.format("Component of type '%s' is not supported", p.qualifier())); } }); return issueIndex.searchAuthors( issueQueryBuilder.build(), request.param(TEXT_QUERY), request.mandatoryParamAsInt(PAGE_SIZE)); }
@Test public void issues_from_branch_component_children() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto projectModule = db.components().insertComponent(newModuleDto(project)); ComponentDto projectFile = db.components().insertComponent(newFileDto(projectModule)); ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setKey("my_branch")); ComponentDto branchModule = db.components().insertComponent(newModuleDto(branch)); ComponentDto branchFile = db.components().insertComponent(newFileDto(branchModule)); indexIssues( newDoc("I1", project), newDoc("I2", projectFile), newDoc("I3", projectModule), newDoc("I4", branch), newDoc("I5", branchModule), newDoc("I6", branchFile)); assertThatSearchReturnsOnly(IssueQuery.builder().branchUuid(branch.uuid()).mainBranch(false), "I4", "I5", "I6"); assertThatSearchReturnsOnly(IssueQuery.builder().moduleUuids(singletonList(branchModule.uuid())).branchUuid(branch.uuid()).mainBranch(false), "I5", "I6"); assertThatSearchReturnsOnly(IssueQuery.builder().fileUuids(singletonList(branchFile.uuid())).branchUuid(branch.uuid()).mainBranch(false), "I6"); assertThatSearchReturnsEmpty(IssueQuery.builder().fileUuids(singletonList(branchFile.uuid())).mainBranch(false).branchUuid("unknown")); }
@Test public void paging() { ComponentDto project = newPrivateProjectDto(newOrganizationDto()); ComponentDto file = newFileDto(project, null); for (int i = 0; i < 12; i++) { indexIssues(newDoc("I" + i, file)); } IssueQuery.Builder query = IssueQuery.builder(); // There are 12 issues in total, with 10 issues per page, the page 2 should only contain 2 elements SearchResponse result = underTest.search(query.build(), new SearchOptions().setPage(2, 10)); assertThat(result.getHits().hits()).hasSize(2); assertThat(result.getHits().getTotalHits()).isEqualTo(12); result = underTest.search(IssueQuery.builder().build(), new SearchOptions().setOffset(0).setLimit(5)); assertThat(result.getHits().hits()).hasSize(5); assertThat(result.getHits().getTotalHits()).isEqualTo(12); result = underTest.search(IssueQuery.builder().build(), new SearchOptions().setOffset(2).setLimit(0)); assertThat(result.getHits().hits()).hasSize(10); assertThat(result.getHits().getTotalHits()).isEqualTo(12); }
private void addComponentParameters(IssueQuery.Builder builder, DbSession session, boolean onComponentOnly, List<ComponentDto> components, SearchRequest request) { builder.onComponentOnly(onComponentOnly); if (onComponentOnly) { builder.componentUuids(components.stream().map(ComponentDto::uuid).collect(toList())); setBranch(builder, components.get(0), request.getBranch(), request.getPullRequest()); return; } List<String> projectKeys = request.getProjectKeys(); if (projectKeys != null) { List<ComponentDto> projects = getComponentsFromKeys(session, projectKeys, request.getBranch(), request.getPullRequest()); builder.projectUuids(projects.stream().map(IssueQueryFactory::toProjectUuid).collect(toList())); setBranch(builder, projects.get(0), request.getBranch(), request.getPullRequest()); } builder.moduleUuids(request.getModuleUuids()); builder.directories(request.getDirectories()); builder.fileUuids(request.getFileUuids()); addComponentsBasedOnQualifier(builder, session, components, request); }
@Test public void facet_on_created_at_with_less_than_20_days() { SearchOptions options = fixtureForCreatedAtFacet(); IssueQuery query = IssueQuery.builder() .createdAfter(parseDateTime("2014-09-01T00:00:00+0100")) .createdBefore(parseDateTime("2014-09-08T00:00:00+0100")) .build(); SearchResponse result = underTest.search(query, options); Map<String, Long> buckets = new Facets(result, system2.getDefaultTimeZone()).get("createdAt"); assertThat(buckets).containsOnly( entry("2014-08-31", 0L), entry("2014-09-01", 2L), entry("2014-09-02", 1L), entry("2014-09-03", 0L), entry("2014-09-04", 0L), entry("2014-09-05", 1L), entry("2014-09-06", 0L), entry("2014-09-07", 0L)); }
@Test public void filter_one_issue_by_project_and_branch() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto branch = db.components().insertProjectBranch(project); ComponentDto anotherbBranch = db.components().insertProjectBranch(project); IssueDoc issueOnProject = newDoc(project); IssueDoc issueOnBranch = newDoc(branch); IssueDoc issueOnAnotherBranch = newDoc(anotherbBranch); indexIssues(issueOnProject, issueOnBranch, issueOnAnotherBranch); assertThatSearchReturnsOnly(IssueQuery.builder().branchUuid(branch.uuid()).mainBranch(false), issueOnBranch.key()); assertThatSearchReturnsOnly(IssueQuery.builder().componentUuids(singletonList(branch.uuid())).branchUuid(branch.uuid()).mainBranch(false), issueOnBranch.key()); assertThatSearchReturnsOnly(IssueQuery.builder().projectUuids(singletonList(project.uuid())).branchUuid(branch.uuid()).mainBranch(false), issueOnBranch.key()); assertThatSearchReturnsOnly( IssueQuery.builder().componentUuids(singletonList(branch.uuid())).projectUuids(singletonList(project.uuid())).branchUuid(branch.uuid()).mainBranch(false), issueOnBranch.key()); assertThatSearchReturnsEmpty(IssueQuery.builder().branchUuid("unknown")); }
@Test public void should_sort_by_update_date() { Date date = new Date(); Date date1 = DateUtils.addDays(date, -3); Date date2 = DateUtils.addDays(date, -2); Date date3 = DateUtils.addDays(date, -1); IssueDto issue1 = new IssueDto().setId(1L).setIssueUpdateDate(date1); IssueDto issue2 = new IssueDto().setId(2L).setIssueUpdateDate(date3); IssueDto issue3 = new IssueDto().setId(3L).setIssueUpdateDate(date2); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(false).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getIssueUpdateDate()).isEqualTo(date3); assertThat(result.get(1).getIssueUpdateDate()).isEqualTo(date2); assertThat(result.get(2).getIssueUpdateDate()).isEqualTo(date1); }