private void assertThatNoLogsFromRecovery(LoggerLevel loggerLevel) { assertThat(logTester.logs(loggerLevel)).filteredOn(m -> m.contains("Elasticsearch recovery - ")).isEmpty(); }
private void assertThatLogsDoNotContain(LoggerLevel loggerLevel, String message) { assertThat(logTester.logs(loggerLevel)).filteredOn(m -> m.contains(message)).isEmpty(); }
private void assertThatLogsContain(LoggerLevel loggerLevel, String message) { assertThat(logTester.logs(loggerLevel)).filteredOn(m -> m.contains(message)).isNotEmpty(); }
@Test public void shouldParseStdOutOnFail() throws Exception { process( "trxdata/sample.trx", "sample.trx" ); final ArgumentCaptor<TestResult> captor = ArgumentCaptor.forClass(TestResult.class); verify(visitor, times(4)).visitTestResult(captor.capture()); assertThat(captor.getAllValues()) .filteredOn(result -> result.getStatus() == Status.FAILED) .filteredOn(result -> result.getTestStage().getSteps().size() == 10) .filteredOn(result -> result.getTestStage().getSteps().get(1).getName().contains("Given I have entered 50 into the calculator")) .filteredOn(result -> result.getTestStage().getSteps().get(3).getName().contains("And I have entered -1 into the calculator")) .hasSize(1); }
@Test public void return_500_on_internal_error() { Request request = new TestRequest().setPath("api/foo"); DumbResponse response = run(request, newFailWs()); assertThat(response.stream().outputAsString()).isEqualTo("{\"errors\":[{\"msg\":\"An error has occurred. Please contact your administrator\"}]}"); assertThat(response.stream().status()).isEqualTo(500); assertThat(response.stream().mediaType()).isEqualTo(MediaTypes.JSON); assertThat(logTester.logs(LoggerLevel.ERROR)).filteredOn(l -> l.contains("Fail to process request api/foo")).isNotEmpty(); }
@Test public void raceRequest() { List<Long> requests = Collections.synchronizedList(new ArrayList<>()); final Flux<Integer> flux = Flux.range(1, 1000) .doOnRequest(requests::add) .limitRequest(81); BaseSubscriber<Integer> base = new BaseSubscriber<Integer>() { @Override protected void hookOnSubscribe(Subscription subscription) { } }; flux.subscribe(base); for (int i = 0; i < 11; i++) { final int idx = i; RaceTestUtils.race( () -> base.request(idx % 2 == 0 ? 10 : 8), () -> base.request(8) ); } assertThat(requests.stream().mapToLong(l -> l).sum()) .as("total request should match the limitRequest") .isEqualTo(81); assertThat(requests.subList(0, requests.size() - 2)) .allMatch(l -> l % 2 == 0, "all requests except last two are even"); assertThat(requests) .filteredOn(l -> l % 2 == 1) .as("only one odd element toward end") .hasSize(1); }
.filteredOn(q -> q.getItemsCount() > 0) .isEmpty(); } else { assertThat(response.getResultsList()) .filteredOn(c -> "TRK".equals(c.getQ())) .extracting(Category::getMore) .containsExactly(expectedNumberOfMoreResults);
@Test public void must_not_search_if_no_valid_tokens_are_provided() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization).setName("SonarQube")); componentIndexer.indexOnStartup(null); authorizationIndexerTester.allowOnlyAnyone(project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_QUERY, "S o") .executeProtobuf(SuggestionsWsResponse.class); assertThat(response.getResultsList()).filteredOn(q -> q.getItemsCount() > 0).isEmpty(); assertThat(response.getWarning()).contains(SHORT_INPUT_WARNING); }
@Test public void recovery_does_not_fail_if_unsupported_docIdType() { EsQueueDto item = EsQueueDto.create(INDEX_TYPE_ISSUE.format(), "I1", "unknown", "P1"); db.getDbClient().esQueueDao().insert(db.getSession(), item); db.commit(); recover(); assertThat(logTester.logs(LoggerLevel.ERROR)) .filteredOn(l -> l.contains("Unsupported es_queue.doc_id_type for issues. Manual fix is required: ")) .hasSize(1); assertThatEsQueueTableHasSize(1); }
@Test public void initialize_matches_Sonar_Way_default_with_case_sensitivity() { String sonarWayInOtherCase = SONAR_WAY_QP_NAME.toUpperCase(); BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl( dbClient, new Languages(FOO_LANGUAGE), new DummyProfileDefinition("foo", "goo", false), new DummyProfileDefinition("foo", sonarWayInOtherCase, false)); underTest.initialize(); assertThat(underTest.get()) .filteredOn(b -> FOO_LANGUAGE.getKey().equals(b.getLanguage())) .filteredOn(BuiltInQProfile::isDefault) .extracting(BuiltInQProfile::getName) .containsExactly("goo"); }
@Test public void initialize_does_not_create_Sonar_Way_as_default_if_other_profile_is_defined_as_default() { BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl( dbClient, new Languages(FOO_LANGUAGE), new DummyProfileDefinition("foo", SONAR_WAY_QP_NAME, false), new DummyProfileDefinition("foo", "goo", true)); underTest.initialize(); assertThat(underTest.get()) .filteredOn(b -> FOO_LANGUAGE.getKey().equals(b.getLanguage())) .filteredOn(BuiltInQProfile::isDefault) .extracting(BuiltInQProfile::getName) .containsExactly("goo"); }
@Test public void suggestions_without_query_should_contain_favorites() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization)); doReturn(singletonList(project)).when(favoriteFinder).list(); componentIndexer.indexOnStartup(null); userSessionRule.addProjectPermission(USER, project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .extracting(Category::getQ) .containsExactly(PROJECT); // assert correct id to be found assertThat(response.getResultsList()) .flatExtracting(Category::getItemsList) .extracting(Suggestion::getKey, Suggestion::getIsFavorite) .containsExactly(tuple(project.getDbKey(), true)); }
@Test public void suggestions_without_query_should_contain_recently_browsed_favorites() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization)); doReturn(singletonList(project)).when(favoriteFinder).list(); componentIndexer.indexOnStartup(null); userSessionRule.addProjectPermission(USER, project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_RECENTLY_BROWSED, project.getDbKey()) .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .extracting(Category::getQ) .containsExactly(Qualifiers.PROJECT); // assert correct id to be found assertThat(response.getResultsList()) .flatExtracting(Category::getItemsList) .extracting(Suggestion::getKey, Suggestion::getIsFavorite, Suggestion::getIsRecentlyBrowsed) .containsExactly(tuple(project.getDbKey(), true, true)); }
@Test public void suggestions_without_query_should_not_contain_matches_that_are_neither_favorites_nor_recently_browsed() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization)); componentIndexer.indexOnStartup(null); userSessionRule.addProjectPermission(USER, project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .extracting(Category::getQ) .isEmpty(); }
@Test public void initialize_creates_profile_Sonar_Way_as_default_if_none_other_is_defined_default_for_a_given_language() { BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl( dbClient, new Languages(FOO_LANGUAGE), new DummyProfileDefinition("foo", "doh", false), new DummyProfileDefinition("foo", "boo", false), new DummyProfileDefinition("foo", SONAR_WAY_QP_NAME, false), new DummyProfileDefinition("foo", "goo", false)); underTest.initialize(); assertThat(underTest.get()) .filteredOn(b -> FOO_LANGUAGE.getKey().equals(b.getLanguage())) .filteredOn(BuiltInQProfile::isDefault) .extracting(BuiltInQProfile::getName) .containsExactly(SONAR_WAY_QP_NAME); }
@Test public void does_not_return_branches() { ComponentDto project = db.components().insertMainBranch(); authorizationIndexerTester.allowOnlyAnyone(project); ComponentDto branch = db.components().insertProjectBranch(project); componentIndexer.indexOnStartup(null); authorizationIndexerTester.allowOnlyAnyone(project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_QUERY, project.name()) .executeProtobuf(SuggestionsWsResponse.class); assertThat(response.getResultsList()) .filteredOn(c -> "TRK".equals(c.getQ())) .extracting(Category::getItemsList) .hasSize(1); }
@Test public void suggestions_without_query_should_contain_recently_browsed_public_project() { ComponentDto project = db.components().insertComponent(newPublicProjectDto(organization)); componentIndexer.indexOnStartup(null); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_RECENTLY_BROWSED, project.getDbKey()) .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .extracting(Category::getQ) .containsExactly(PROJECT); // assert correct id to be found assertThat(response.getResultsList()) .flatExtracting(Category::getItemsList) .extracting(Suggestion::getKey, Suggestion::getIsRecentlyBrowsed) .containsExactly(tuple(project.getDbKey(), true)); }
@Test public void suggestions_without_query_should_contain_recently_browsed() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization)); componentIndexer.indexOnStartup(null); userSessionRule.addProjectPermission(USER, project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_RECENTLY_BROWSED, project.getDbKey()) .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .extracting(Category::getQ) .containsExactly(PROJECT); // assert correct id to be found assertThat(response.getResultsList()) .flatExtracting(Category::getItemsList) .extracting(Suggestion::getKey, Suggestion::getIsRecentlyBrowsed) .containsExactly(tuple(project.getDbKey(), true)); }
@Test public void exact_match_in_one_qualifier() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization)); componentIndexer.indexOnStartup(null); authorizationIndexerTester.allowOnlyAnyone(project); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_QUERY, project.getDbKey()) .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .extracting(Category::getQ) .containsExactly(PROJECT); // assert correct id to be found assertThat(response.getResultsList()) .flatExtracting(Category::getItemsList) .extracting(Suggestion::getKey, Suggestion::getOrganization) .containsExactly(tuple(project.getDbKey(), organization.getKey())); }
@Test public void should_not_return_suggestion_on_non_existing_project() { ComponentDto project = db.components().insertComponent(newPrivateProjectDto(organization)); componentIndexer.indexOnStartup(null); authorizationIndexerTester.allowOnlyAnyone(project); db.getDbClient().componentDao().delete(db.getSession(), project.getId()); db.commit(); SuggestionsWsResponse response = ws.newRequest() .setMethod("POST") .setParam(PARAM_QUERY, project.getDbKey()) .executeProtobuf(SuggestionsWsResponse.class); // assert match in qualifier "TRK" assertThat(response.getResultsList()) .filteredOn(q -> q.getItemsCount() > 0) .isEmpty(); }