@Test public void return_empty_results_if_organization_with_specified_key_does_not_exist() { SearchRequest request = new SearchRequest() .setOrganization("does_not_exist"); IssueQuery query = underTest.create(request); assertThat(query.organizationUuid()).isEqualTo("<UNKNOWN>"); }
checkArgument(qualifiers.size() == 1, "All components must have the same qualifier, found %s", String.join(",", qualifiers)); setBranch(builder, components.get(0), request.getBranch(), request.getPullRequest()); String qualifier = qualifiers.iterator().next(); switch (qualifier) { case Qualifiers.VIEW: case Qualifiers.SUBVIEW: addViewsOrSubViews(builder, components); break; case Qualifiers.APP: addApplications(builder, dbSession, components, request); addProjectUuidsForApplication(builder, dbSession, request); break; case Qualifiers.PROJECT: break; case Qualifiers.DIRECTORY: addDirectories(builder, components); break; case Qualifiers.FILE:
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); }
private boolean mergeDeprecatedComponentParameters(DbSession session, SearchRequest request, List<ComponentDto> allComponents) { Boolean onComponentOnly = request.getOnComponentOnly(); Collection<String> components = request.getComponents(); Collection<String> componentUuids = request.getComponentUuids(); Collection<String> componentKeys = request.getComponentKeys(); Collection<String> componentRootUuids = request.getComponentRootUuids(); Collection<String> componentRoots = request.getComponentRoots(); String branch = request.getBranch(); String pullRequest = request.getPullRequest(); boolean effectiveOnComponentOnly = false; checkArgument(atMostOneNonNullElement(components, componentUuids, componentKeys, componentRootUuids, componentRoots), "At most one of the following parameters can be provided: %s, %s, %s, %s, %s", PARAM_COMPONENT_KEYS, PARAM_COMPONENT_UUIDS, PARAM_COMPONENTS, PARAM_COMPONENT_ROOTS, PARAM_COMPONENT_UUIDS); if (componentRootUuids != null) { allComponents.addAll(getComponentsFromUuids(session, componentRootUuids)); } else if (componentRoots != null) { allComponents.addAll(getComponentsFromKeys(session, componentRoots, branch, pullRequest)); } else if (components != null) { allComponents.addAll(getComponentsFromKeys(session, components, branch, pullRequest)); effectiveOnComponentOnly = true; } else if (componentUuids != null) { allComponents.addAll(getComponentsFromUuids(session, componentUuids)); effectiveOnComponentOnly = BooleanUtils.isTrue(onComponentOnly); } else if (componentKeys != null) { allComponents.addAll(getComponentsFromKeys(session, componentKeys, branch, pullRequest)); effectiveOnComponentOnly = BooleanUtils.isTrue(onComponentOnly); } return effectiveOnComponentOnly; }
.resolutions(request.getResolutions()) .resolved(request.getResolved()) .rules(ruleKeysToRuleId(dbSession, request.getRules())) .assigneeUuids(request.getAssigneeUuids()) .authors(request.getAuthors()) .createdBefore(parseEndingDateOrDateTime(request.getCreatedBefore())) .facetMode(request.getFacetMode()) .organizationUuid(convertOrganizationKeyToUuid(dbSession, request.getOrganization())); boolean effectiveOnComponentOnly = mergeDeprecatedComponentParameters(dbSession, request, allComponents); addComponentParameters(builder, dbSession, effectiveOnComponentOnly, allComponents, request); setCreatedAfterFromRequest(dbSession, builder, request, allComponents); String sort = request.getSort(); if (!Strings.isNullOrEmpty(sort)) {
private void addApplications(IssueQuery.Builder builder, DbSession dbSession, List<ComponentDto> applications, SearchRequest request) { Set<String> authorizedApplicationUuids = applications.stream() .filter(app -> userSession.hasComponentPermission(UserRole.USER, app)) .map(ComponentDto::uuid) .collect(toSet()); builder.viewUuids(authorizedApplicationUuids.isEmpty() ? singleton(UNKNOWN) : authorizedApplicationUuids); addCreatedAfterByProjects(builder, dbSession, request, authorizedApplicationUuids); }
@Test public void fail_if_created_after_and_created_since_are_both_set() { SearchRequest request = new SearchRequest() .setCreatedAfter("2013-07-25T07:35:00+0100") .setCreatedInLast("palap"); try { underTest.create(request); fail(); } catch (Exception e) { assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("Parameters createdAfter and createdInLast cannot be set simultaneously"); } }
@Test public void set_created_after_from_created_since() { Date now = DateUtils.parseDateTime("2013-07-25T07:35:00+0100"); when(clock.instant()).thenReturn(now.toInstant()); when(clock.getZone()).thenReturn(ZoneOffset.UTC); SearchRequest request = new SearchRequest() .setCreatedInLast("1y2m3w4d"); assertThat(underTest.create(request).createdAfter().date()).isEqualTo(DateUtils.parseDateTime("2012-04-30T07:35:00+0100")); assertThat(underTest.create(request).createdAfter().inclusive()).isTrue(); }
@Test public void should_return_tag_list() { Map<String, Long> tags = ImmutableMap.<String, Long>builder() .put("convention", 2771L) .put("brain-overload", 998L) .put("cwe", 89L) .put("bug", 32L) .put("cert", 2L) .build(); ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class); when(issueQueryFactory.create(captor.capture())).thenReturn(mock(IssueQuery.class)); when(service.countTags(any(IssueQuery.class), eq(5))).thenReturn(tags); TestResponse response = tester.newRequest() .setParam("componentUuid", "polop") .setParam("ps", "5") .execute(); assertJson(response.getInput()).isSimilarTo(getClass().getResource("ComponentTagsActionTest/component-tags.json")); assertThat(captor.getValue().getComponentUuids()).containsOnly("polop"); assertThat(captor.getValue().getResolved()).isFalse(); assertThat(captor.getValue().getCreatedAfter()).isNull(); }
IssueQuery query = issueQueryFactory.create(request);
@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>"); }
@Test public void should_return_tag_list_with_created_after() { Map<String, Long> tags = ImmutableMap.<String, Long>builder() .put("convention", 2771L) .put("brain-overload", 998L) .put("cwe", 89L) .put("bug", 32L) .put("cert", 2L) .build(); ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class); when(issueQueryFactory.create(captor.capture())).thenReturn(mock(IssueQuery.class)); when(service.countTags(any(IssueQuery.class), eq(5))).thenReturn(tags); String componentUuid = "polop"; String createdAfter = "2011-04-25"; TestResponse response = tester.newRequest() .setParam("componentUuid", componentUuid) .setParam("createdAfter", createdAfter) .setParam("ps", "5") .execute(); assertJson(response.getInput()).isSimilarTo(getClass().getResource("ComponentTagsActionTest/component-tags.json")); assertThat(captor.getValue().getComponentUuids()).containsOnly(componentUuid); assertThat(captor.getValue().getResolved()).isFalse(); assertThat(captor.getValue().getCreatedAfter()).isEqualTo(createdAfter); } }
@Test public void fail_if_components_and_components_uuid_params_are_set_at_the_same_time() { SearchRequest request = new SearchRequest() .setComponentKeys(asList("foo")) .setComponentUuids(asList("bar")); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("At most one of the following parameters can be provided: componentKeys, componentUuids, components, componentRoots, componentUuids"); underTest.create(request); }
@Test public void fail_if_both_componentRoots_and_componentRootUuids_params_are_set() { SearchRequest request = new SearchRequest() .setComponentRoots(asList("foo")) .setComponentRootUuids(asList("bar")); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("At most one of the following parameters can be provided: componentKeys, componentUuids, components, componentRoots, componentUuids"); underTest.create(request); }
@Override public void handle(Request request, Response response) throws Exception { SearchRequest searchRequest = new SearchRequest() .setComponentUuids(singletonList(request.mandatoryParam(PARAM_COMPONENT_UUID))) .setResolved(false) .setCreatedAfter(request.param(PARAM_CREATED_AFTER)); IssueQuery query = queryService.create(searchRequest); int pageSize = request.mandatoryParamAsInt(PAGE_SIZE); try (JsonWriter json = response.newJsonWriter()) { json.beginObject().name("tags").beginArray(); for (Map.Entry<String, Long> tag : issueIndex.countTags(query, pageSize).entrySet()) { json.beginObject() .prop("key", tag.getKey()) .prop("value", tag.getValue()) .endObject(); } json.endArray().endObject(); } }
@Test public void param_componentUuids_enables_search_on_project_tree_by_default() { ComponentDto project = db.components().insertPrivateProject(); SearchRequest request = new SearchRequest() .setComponentUuids(asList(project.uuid())); IssueQuery query = underTest.create(request); assertThat(query.projectUuids()).containsExactly(project.uuid()); assertThat(query.onComponentOnly()).isFalse(); }
@Test public void creation_date_support_zoneddatetime() { SearchRequest request = new SearchRequest() .setCreatedAt("2013-04-16T09:08:24+0200"); IssueQuery query = underTest.create(request); assertThat(query.createdAt()).isEqualTo(DateUtils.parseDateTime("2013-04-16T09:08:24+0200")); }
@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 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 param_componentRootUuids_enables_search_in_view_tree_if_user_has_permission_on_view() { ComponentDto view = db.components().insertView(); SearchRequest request = new SearchRequest() .setComponentRootUuids(asList(view.uuid())); userSession.registerComponents(view); IssueQuery query = underTest.create(request); assertThat(query.viewUuids()).containsOnly(view.uuid()); assertThat(query.onComponentOnly()).isFalse(); }