private void assertResults(ProjectMeasuresQuery query, ComponentDto... expectedProjects) { List<String> result = underTest.search(query, new SearchOptions()).getIds(); assertThat(result).containsExactly(Arrays.stream(expectedProjects).map(ComponentDto::uuid).toArray(String[]::new)); }
private void assertResults(ProjectMeasuresQuery query, String... expectedProjectUuids) { List<String> result = underTest.search(query, new SearchOptions()).getIds(); assertThat(result).containsExactly(expectedProjectUuids); }
private void verifySearch(RuleQuery query, RuleDefinitionDto... expectedRules) { SearchIdResult<Integer> result = underTest.search(query, new SearchOptions()); assertThat(result.getTotal()).isEqualTo((long) expectedRules.length); assertThat(result.getIds()).hasSize(expectedRules.length); for (RuleDefinitionDto expectedRule : expectedRules) { assertThat(result.getIds()).contains(expectedRule.getId()); } }
@Test public void paginate_results() { IntStream.rangeClosed(1, 9) .forEach(i -> index(newDoc(newPrivateProjectDto(ORG, "P" + i)))); SearchIdResult<String> result = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().setPage(2, 3)); assertThat(result.getIds()).containsExactly("P4", "P5", "P6"); assertThat(result.getTotal()).isEqualTo(9); }
@Test public void sticky_facets_base() { setupStickyFacets(); RuleQuery query = new RuleQuery(); assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(9); }
@Test public void search_all_rules() { createRule(); createRule(); index(); SearchIdResult results = underTest.search(new RuleQuery(), new SearchOptions()); assertThat(results.getTotal()).isEqualTo(2); assertThat(results.getIds()).hasSize(2); }
@Test public void paginate_results() { List<ComponentDto> projects = IntStream.range(0, 9) .mapToObj(i -> db.components().insertPrivateProject(p -> p.setName("project " + i))) .collect(Collectors.toList()); index(projects.toArray(new ComponentDto[0])); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().build(), new SearchOptions().setPage(2, 3)); assertThat(result.getIds()).containsExactlyInAnyOrder(projects.get(3).uuid(), projects.get(4).uuid(), projects.get(5).uuid()); }
@Test public void search_by_is_external() { RuleDefinitionDto ruleIsNotExternal = createRule(setIsExternal(false)); RuleDefinitionDto ruleIsExternal = createRule(setIsExternal(true)); index(); // Only external RuleQuery query = new RuleQuery().setIncludeExternal(true); SearchIdResult<Integer> results = underTest.search(query, new SearchOptions()); assertThat(results.getIds()).containsOnly(ruleIsExternal.getId(), ruleIsNotExternal.getId()); // Only not external query = new RuleQuery().setIncludeExternal(false); results = underTest.search(query, new SearchOptions()); assertThat(results.getIds()).containsOnly(ruleIsNotExternal.getId()); }
@Test public void filter_by_qualifier() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); index(project); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().setQualifiers(singleton(Qualifiers.FILE)).build(), new SearchOptions()); assertThat(result.getIds()).containsExactlyInAnyOrder(file.uuid()); }
@Test public void search_name_with_protected_chars() { RuleDefinitionDto rule = createRule(setName("ja#va&sc\"r:ipt")); index(); RuleQuery protectedCharsQuery = new RuleQuery().setQueryText(rule.getName()); List<Integer> results = underTest.search(protectedCharsQuery, new SearchOptions()).getIds(); assertThat(results).containsOnly(rule.getId()); }
@Test public void search_by_case_insensitive_key() { RuleDefinitionDto ruleDto = createRule( setRepositoryKey("javascript"), setRuleKey("X001")); index(); RuleQuery query = new RuleQuery().setQueryText("x001"); assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(ruleDto.getId()); }
@Test public void fail_if_profile_key_and_name_both_set() { QProfileDto child = createProfile(); assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty(); assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty(); TestRequest request = ws.newRequest() .setMethod("POST") .setParam(PARAM_KEY, child.getKee()) .setParam(PARAM_QUALITY_PROFILE, child.getName()) .setParam(PARAM_ORGANIZATION, organization.getKey()) .setParam(PARAM_PARENT_KEY, "palap"); expectedException.expect(IllegalArgumentException.class); request.execute(); }
private SearchWsResponse doHandle(SearchRequest request) { try (DbSession dbSession = dbClient.openSession(false)) { OrganizationDto organization = getOrganization(dbSession, request); ComponentQuery esQuery = buildEsQuery(organization, request); SearchIdResult<String> results = componentIndex.search(esQuery, new SearchOptions().setPage(request.getPage(), request.getPageSize())); List<ComponentDto> components = dbClient.componentDao().selectByUuids(dbSession, results.getIds()); Map<String, String> projectKeysByUuids = searchProjectsKeysByUuids(dbSession, components); return buildResponse(components, organization, projectKeysByUuids, Paging.forPageIndex(request.getPage()).withPageSize(request.getPageSize()).andTotal((int) results.getTotal())); } }
@Test public void default_sort_is_by_updated_at_desc() { RuleDefinitionDto old = createRule(setCreatedAt(1000L), setUpdatedAt(1000L)); RuleDefinitionDto oldest = createRule(setCreatedAt(1000L), setUpdatedAt(3000L)); RuleDefinitionDto older = createRule(setCreatedAt(1000L), setUpdatedAt(2000L)); index(); SearchIdResult<Integer> results = underTest.search(new RuleQuery(), new SearchOptions()); assertThat(results.getIds()).containsExactly(oldest.getId(), older.getId(), old.getId()); }
@Test public void order_by_name_case_insensitive() { ComponentDto project2 = db.components().insertPrivateProject(p -> p.setName("PROJECT 2")); ComponentDto project3 = db.components().insertPrivateProject(p -> p.setName("project 3")); ComponentDto project1 = db.components().insertPrivateProject(p -> p.setName("Project 1")); index(project1, project2, project3); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().build(), new SearchOptions()); assertThat(result.getIds()).containsExactly(project1.uuid(), project2.uuid(), project3.uuid()); }
@Test public void filter_unauthorized_components() { ComponentDto unauthorizedProject = db.components().insertPrivateProject(); ComponentDto project1 = db.components().insertPrivateProject(); ComponentDto project2 = db.components().insertPrivateProject(); indexer.indexOnStartup(emptySet()); authorizationIndexerTester.allowOnlyAnyone(project1); authorizationIndexerTester.allowOnlyAnyone(project2); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().build(), new SearchOptions()); assertThat(result.getIds()).containsExactlyInAnyOrder(project1.uuid(), project2.uuid()) .doesNotContain(unauthorizedProject.uuid()); }
@Test public void filter_by_name() { ComponentDto ignoredProject = db.components().insertPrivateProject(p -> p.setName("ignored project")); ComponentDto project = db.components().insertPrivateProject(p -> p.setName("Project Shiny name")); index(ignoredProject, project); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().setQuery("shiny").build(), new SearchOptions()); assertThat(result.getIds()).containsExactlyInAnyOrder(project.uuid()); }
@Test public void filter_by_organization() { OrganizationDto organization = db.organizations().insert(); OrganizationDto anotherOrganization = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(organization); ComponentDto anotherProject = db.components().insertPrivateProject(anotherOrganization); index(project, anotherProject); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().setOrganization(organization.getUuid()).build(), new SearchOptions()); assertThat(result.getIds()).containsExactlyInAnyOrder(project.uuid()); }
@Test public void filter_by_key_with_exact_match() { ComponentDto ignoredProject = db.components().insertPrivateProject(p -> p.setDbKey("ignored-project")); ComponentDto project = db.components().insertPrivateProject(p -> p.setDbKey("shiny-project")); ComponentDto anotherIgnoreProject = db.components().insertPrivateProject(p -> p.setDbKey("another-shiny-project")); index(ignoredProject, project); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().setQuery("shiny-project").build(), new SearchOptions()); assertThat(result.getIds()).containsExactlyInAnyOrder(project.uuid()); }
@Test public void filter_by_language() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto javaFile = db.components().insertComponent(newFileDto(project).setLanguage("java")); ComponentDto jsFile1 = db.components().insertComponent(newFileDto(project).setLanguage("js")); ComponentDto jsFile2 = db.components().insertComponent(newFileDto(project).setLanguage("js")); index(project); SearchIdResult<String> result = underTest.search(ComponentQuery.builder().setLanguage("js").build(), new SearchOptions()); assertThat(result.getIds()).containsExactlyInAnyOrder(jsFile1.uuid(), jsFile2.uuid()); }