@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 build_query_without_dates() { IssueQuery query = IssueQuery.builder() .issueKeys(newArrayList("ABCDE")) .createdAfter(null) .createdBefore(null) .createdAt(null) .build(); assertThat(query.issueKeys()).containsOnly("ABCDE"); assertThat(query.createdAfter()).isNull(); assertThat(query.createdBefore()).isNull(); assertThat(query.createdAt()).isNull(); }
private static void addBranchComponentRelatedFilters(IssueQuery query, Map<String, QueryBuilder> filters) { if (BooleanUtils.isTrue(query.onComponentOnly())) { return; } QueryBuilder branchFilter = createTermFilter(FIELD_ISSUE_BRANCH_UUID, query.branchUuid()); filters.put("__is_main_branch", createTermFilter(FIELD_ISSUE_IS_MAIN_BRANCH, Boolean.toString(query.isMainBranch()))); filters.put(FIELD_ISSUE_BRANCH_UUID, branchFilter); }
private static void addViewRelatedFilters(IssueQuery query, Map<String, QueryBuilder> filters) { if (BooleanUtils.isTrue(query.onComponentOnly())) { return; } Collection<String> viewUuids = query.viewUuids(); String branchUuid = query.branchUuid(); boolean onApplicationBranch = branchUuid != null && !viewUuids.isEmpty(); if (onApplicationBranch) { filters.put("__view", createViewFilter(singletonList(query.branchUuid()))); } else { filters.put("__is_main_branch", createTermFilter(FIELD_ISSUE_IS_MAIN_BRANCH, Boolean.toString(true))); filters.put("__view", createViewFilter(viewUuids)); } }
assertThat(query.issueKeys()).containsOnly("anIssueKey"); assertThat(query.severities()).containsOnly("MAJOR", "MINOR"); assertThat(query.statuses()).containsOnly("CLOSED"); assertThat(query.resolutions()).containsOnly("FALSE-POSITIVE"); assertThat(query.resolved()).isTrue(); assertThat(query.projectUuids()).containsOnly(project.uuid()); assertThat(query.moduleUuids()).containsOnly(module.uuid()); assertThat(query.fileUuids()).containsOnly(file.uuid()); assertThat(query.assignees()).containsOnly(user.getUuid()); assertThat(query.languages()).containsOnly("xoo"); assertThat(query.tags()).containsOnly("tag1", "tag2"); assertThat(query.organizationUuid()).isEqualTo(organization.getUuid()); assertThat(query.onComponentOnly()).isFalse(); assertThat(query.assigned()).isTrue(); assertThat(query.rules()).hasSize(2); assertThat(query.directories()).containsOnly("aDirPath"); assertThat(query.createdAfter().date()).isEqualTo(DateUtils.parseDateTime("2013-04-16T09:08:24+0200")); assertThat(query.createdAfter().inclusive()).isTrue(); assertThat(query.createdBefore()).isEqualTo(DateUtils.parseDateTime("2013-04-17T09:08:24+0200")); assertThat(query.sort()).isEqualTo(IssueQuery.SORT_BY_CREATION_DATE); assertThat(query.asc()).isTrue();
if (BooleanUtils.isTrue(query.assigned())) { filters.put(IS_ASSIGNED_FILTER, existsQuery(FIELD_ISSUE_ASSIGNEE_UUID)); } else if (BooleanUtils.isFalse(query.assigned())) { filters.put(IS_ASSIGNED_FILTER, boolQuery().mustNot(existsQuery(FIELD_ISSUE_ASSIGNEE_UUID))); if (BooleanUtils.isTrue(query.resolved())) { filters.put(isResolved, existsQuery(FIELD_ISSUE_RESOLUTION)); } else if (BooleanUtils.isFalse(query.resolved())) { filters.put(isResolved, boolQuery().mustNot(existsQuery(FIELD_ISSUE_RESOLUTION))); filters.put(FIELD_ISSUE_KEY, createTermsFilter(FIELD_ISSUE_KEY, query.issueKeys())); filters.put(FIELD_ISSUE_ASSIGNEE_UUID, createTermsFilter(FIELD_ISSUE_ASSIGNEE_UUID, query.assignees())); filters.put(FIELD_ISSUE_LANGUAGE, createTermsFilter(FIELD_ISSUE_LANGUAGE, query.languages())); filters.put(FIELD_ISSUE_TAGS, createTermsFilter(FIELD_ISSUE_TAGS, query.tags())); filters.put(FIELD_ISSUE_TYPE, createTermsFilter(FIELD_ISSUE_TYPE, query.types())); filters.put(FIELD_ISSUE_RESOLUTION, createTermsFilter(FIELD_ISSUE_RESOLUTION, query.resolutions())); filters.put(FIELD_ISSUE_AUTHOR_LOGIN, createTermsFilter(FIELD_ISSUE_AUTHOR_LOGIN, query.authors())); filters.put(FIELD_ISSUE_RULE_ID, createTermsFilter( FIELD_ISSUE_RULE_ID, query.rules().stream().map(RuleDefinitionDto::getId).collect(Collectors.toList()))); filters.put(FIELD_ISSUE_SEVERITY, createTermsFilter(FIELD_ISSUE_SEVERITY, query.severities())); filters.put(FIELD_ISSUE_STATUS, createTermsFilter(FIELD_ISSUE_STATUS, query.statuses())); filters.put(FIELD_ISSUE_ORGANIZATION_UUID, createTermFilter(FIELD_ISSUE_ORGANIZATION_UUID, query.organizationUuid())); filters.put(FIELD_ISSUE_OWASP_TOP_10, createTermsFilter(FIELD_ISSUE_OWASP_TOP_10, query.owaspTop10())); filters.put(FIELD_ISSUE_SANS_TOP_25, createTermsFilter(FIELD_ISSUE_SANS_TOP_25, query.sansTop25())); filters.put(FIELD_ISSUE_CWE, createTermsFilter(FIELD_ISSUE_CWE, query.cwe()));
@Test public void collection_params_should_not_be_null_but_empty() { IssueQuery query = IssueQuery.builder() .issueKeys(null) .projectUuids(null) .createdAfterByProjectUuids(null) .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.owaspTop10()).isEmpty(); assertThat(query.sansTop25()).isEmpty(); assertThat(query.cwe()).isEmpty(); assertThat(query.createdAfterByProjectUuids()).isEmpty();
@Test public void query_without_any_parameter() { SearchRequest request = new SearchRequest(); IssueQuery query = underTest.create(request); assertThat(query.componentUuids()).isEmpty(); assertThat(query.projectUuids()).isEmpty(); assertThat(query.moduleUuids()).isEmpty(); assertThat(query.moduleRootUuids()).isEmpty(); assertThat(query.directories()).isEmpty(); assertThat(query.fileUuids()).isEmpty(); assertThat(query.viewUuids()).isEmpty(); assertThat(query.organizationUuid()).isNull(); assertThat(query.branchUuid()).isNull(); }
private static void addCommonComponentRelatedFilters(IssueQuery query, Map<String, QueryBuilder> filters) { QueryBuilder componentFilter = createTermsFilter(FIELD_ISSUE_COMPONENT_UUID, query.componentUuids()); QueryBuilder projectFilter = createTermsFilter(FIELD_ISSUE_PROJECT_UUID, query.projectUuids()); QueryBuilder moduleRootFilter = createTermsFilter(FIELD_ISSUE_MODULE_PATH, query.moduleRootUuids()); QueryBuilder moduleFilter = createTermsFilter(FIELD_ISSUE_MODULE_UUID, query.moduleUuids()); QueryBuilder directoryFilter = createTermsFilter(FIELD_ISSUE_DIRECTORY_PATH, query.directories()); QueryBuilder fileFilter = createTermsFilter(FIELD_ISSUE_COMPONENT_UUID, query.fileUuids()); if (BooleanUtils.isTrue(query.onComponentOnly())) { filters.put(FIELD_ISSUE_COMPONENT_UUID, componentFilter); } else { filters.put(FIELD_ISSUE_PROJECT_UUID, projectFilter); filters.put("__module", moduleRootFilter); filters.put(FIELD_ISSUE_MODULE_UUID, moduleFilter); filters.put(FIELD_ISSUE_DIRECTORY_PATH, directoryFilter); filters.put(FIELD_ISSUE_COMPONENT_UUID, fileFilter != null ? fileFilter : componentFilter); } }
private Builder newQueryBuilder() { return IssueQuery.builder().facetMode(FACET_MODE_EFFORT); } }
private void addDatesFilter(Map<String, QueryBuilder> filters, IssueQuery query) { PeriodStart createdAfter = query.createdAfter(); Date createdBefore = query.createdBefore(); validateCreationDateBounds(createdBefore, createdAfter != null ? createdAfter.date() : null); if (createdAfter != null) { filters.put("__createdAfter", QueryBuilders .rangeQuery(FIELD_ISSUE_FUNC_CREATED_AT) .from(BaseDoc.dateToEpochSeconds(createdAfter.date()), createdAfter.inclusive())); } if (createdBefore != null) { filters.put("__createdBefore", QueryBuilders .rangeQuery(FIELD_ISSUE_FUNC_CREATED_AT) .lt(BaseDoc.dateToEpochSeconds(createdBefore))); } Date createdAt = query.createdAt(); if (createdAt != null) { filters.put("__createdAt", termQuery(FIELD_ISSUE_FUNC_CREATED_AT, BaseDoc.dateToEpochSeconds(createdAt))); } }
@Test public void onComponentOnly_restricts_search_to_specified_componentKeys() { ComponentDto project = db.components().insertPrivateProject(); SearchRequest request = new SearchRequest() .setComponentKeys(asList(project.getDbKey())) .setOnComponentOnly(true); IssueQuery query = underTest.create(request); assertThat(query.projectUuids()).isEmpty(); assertThat(query.componentUuids()).containsExactly(project.uuid()); assertThat(query.onComponentOnly()).isTrue(); }
@Test public void dates_are_inclusive() { SearchRequest request = new SearchRequest() .setCreatedAfter("2013-04-16") .setCreatedBefore("2013-04-17"); IssueQuery query = underTest.create(request); assertThat(query.createdAfter().date()).isEqualTo(DateUtils.parseDate("2013-04-16")); assertThat(query.createdAfter().inclusive()).isTrue(); assertThat(query.createdBefore()).isEqualTo(DateUtils.parseDate("2013-04-18")); }
@Test public void leak_period_start_date_is_exclusive() { long leakPeriodStart = addDays(new Date(), -14).getTime(); ComponentDto project = db.components().insertPublicProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); SnapshotDto analysis = db.components().insertSnapshot(project, s -> s.setPeriodDate(leakPeriodStart)); SearchRequest request = new SearchRequest() .setComponentUuids(Collections.singletonList(file.uuid())) .setOnComponentOnly(true) .setSinceLeakPeriod(true); IssueQuery query = underTest.create(request); assertThat(query.componentUuids()).containsOnly(file.uuid()); assertThat(query.createdAfter().date()).isEqualTo(new Date(leakPeriodStart)); assertThat(query.createdAfter().inclusive()).isFalse(); }
@Test public void application_search_project_issues_on_leak() { Date now = new Date(); ComponentDto project1 = db.components().insertPublicProject(); SnapshotDto analysis1 = db.components().insertSnapshot(project1, s -> s.setPeriodDate(addDays(now, -14).getTime())); ComponentDto project2 = db.components().insertPublicProject(); SnapshotDto analysis2 = db.components().insertSnapshot(project2, s -> s.setPeriodDate(null)); ComponentDto project3 = db.components().insertPublicProject(); ComponentDto application = db.components().insertApplication(db.getDefaultOrganization()); db.components().insertComponents(newProjectCopy("PC1", project1, application)); db.components().insertComponents(newProjectCopy("PC2", project2, application)); db.components().insertComponents(newProjectCopy("PC3", project3, application)); userSession.registerComponents(application, project1, project2, project3); IssueQuery result = underTest.create(new SearchRequest() .setComponentUuids(singletonList(application.uuid())) .setSinceLeakPeriod(true)); assertThat(result.createdAfterByProjectUuids()).hasSize(1); assertThat(result.createdAfterByProjectUuids().get(project1.uuid()).date().getTime()).isEqualTo(analysis1.getPeriodDate()); assertThat(result.createdAfterByProjectUuids().get(project1.uuid()).inclusive()).isFalse(); assertThat(result.viewUuids()).containsExactlyInAnyOrder(application.uuid()); }
@Test public void creation_date_support_localdate() { SearchRequest request = new SearchRequest() .setCreatedAt("2013-04-16"); IssueQuery query = underTest.create(request); assertThat(query.createdAt()).isEqualTo(DateUtils.parseDate("2013-04-16")); }
@Test public void add_unknown_when_no_component_found() { SearchRequest request = new SearchRequest() .setComponentKeys(asList("does_not_exist")); IssueQuery query = underTest.create(request); assertThat(query.componentUuids()).containsOnly("<UNKNOWN>"); }
private static AggregationBuilder createAssigneesFacet(IssueQuery query, Map<String, QueryBuilder> filters, QueryBuilder queryBuilder) { String fieldName = ASSIGNEES.getFieldName(); String facetName = ASSIGNEES.getName(); // Same as in super.stickyFacetBuilder Map<String, QueryBuilder> assigneeFilters = Maps.newHashMap(filters); assigneeFilters.remove(IS_ASSIGNED_FILTER); assigneeFilters.remove(fieldName); StickyFacetBuilder assigneeFacetBuilder = newStickyFacetBuilder(query, assigneeFilters, queryBuilder); BoolQueryBuilder facetFilter = assigneeFacetBuilder.getStickyFacetFilter(fieldName); FilterAggregationBuilder facetTopAggregation = assigneeFacetBuilder.buildTopFacetAggregation(fieldName, facetName, facetFilter, ASSIGNEES.getSize()); if (!query.assignees().isEmpty()) { facetTopAggregation = assigneeFacetBuilder.addSelectedItemsToFacet(fieldName, facetName, facetTopAggregation, t -> t, query.assignees().toArray()); } // Add missing facet for unassigned issues facetTopAggregation.subAggregation( addEffortAggregationIfNeeded(query, AggregationBuilders .missing(facetName + FACET_SUFFIX_MISSING) .field(fieldName))); return AggregationBuilders .global(facetName) .subAggregation(facetTopAggregation); }