<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
- <version>3.4.1</version>
+ <version>3.9.0</version>
</dependency>
<dependency>
<groupId>org.assertj</groupId>
List<ComponentDto> components = new ArrayList<>();
underTest.scrollForIndexing(dbSession, projectUuid, context -> components.add(context.getResultObject()));
- return assertThat(components).extracting(ComponentDto::uuid);
+ return (ListAssert<String>)assertThat(components).extracting(ComponentDto::uuid);
}
@Test
assertThat(monitor).isNotNull();
assertThat(processBuilder.started).isTrue();
assertThat(processBuilder.commands.get(0)).endsWith("java");
- assertThat(processBuilder.commands).containsSequence(
+ assertThat(processBuilder.commands).containsSubsequence(
"-Dfoo=bar",
"-Dfoo2=bar2",
"-cp",
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
-import org.assertj.core.api.AbstractListAssert;
+import org.assertj.core.api.ListAssert;
import org.junit.Before;
import org.junit.Rule;
import org.sonar.api.config.internal.MapSettings;
assertExactResults(query, files.toArray(new ComponentDto[0]));
}
- protected AbstractListAssert<?, ? extends List<? extends String>, String> assertSearch(String query) {
+ protected ListAssert<String> assertSearch(String query) {
return assertSearch(SuggestionQuery.builder().setQuery(query).setQualifiers(asList(PROJECT, MODULE, FILE)).build());
}
- protected AbstractListAssert<?, ? extends List<? extends String>, String> assertSearch(SuggestionQuery query) {
- return assertThat(index.searchSuggestions(query, features.get()).getQualifiers())
+ protected ListAssert<String> assertSearch(SuggestionQuery query) {
+ return (ListAssert<String>)assertThat(index.searchSuggestions(query, features.get()).getQualifiers())
.flatExtracting(ComponentHitsPerQualifier::getHits)
.extracting(ComponentHit::getUuid);
}
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
-import org.assertj.core.api.AbstractIterableAssert;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.server.computation.task.projectanalysis.component.ViewsComponent;
import org.sonar.server.computation.task.projectanalysis.formula.counter.IntValue;
import org.sonar.server.computation.task.projectanalysis.measure.Measure;
-import org.sonar.server.computation.task.projectanalysis.measure.MeasureRepoEntry;
import org.sonar.server.computation.task.projectanalysis.measure.MeasureRepositoryRule;
import org.sonar.server.computation.task.projectanalysis.metric.Metric;
import org.sonar.server.computation.task.projectanalysis.metric.MetricRepositoryRule;
verifySingleMetricWithVariation(ROOT_REF, 23);
}
- private AbstractIterableAssert<?, ? extends Iterable<? extends MeasureRepoEntry>, MeasureRepoEntry> verifySingleMetricWithVariation(int componentRef, int variation) {
- return assertThat(toEntries(measureRepository.getAddedRawMeasures(componentRef)))
+ private void verifySingleMetricWithVariation(int componentRef, int variation) {
+ assertThat(toEntries(measureRepository.getAddedRawMeasures(componentRef)))
.containsOnly(entryOf(NEW_COVERAGE_KEY, createMeasureWithVariation(variation)));
}
public void list_statuses() {
workflow.start();
// order is important for UI
- assertThat(workflow.statusKeys()).containsSequence(STATUS_OPEN, STATUS_CONFIRMED, STATUS_REOPENED, STATUS_RESOLVED, STATUS_CLOSED);
+ assertThat(workflow.statusKeys()).containsSubsequence(STATUS_OPEN, STATUS_CONFIRMED, STATUS_REOPENED, STATUS_RESOLVED, STATUS_CLOSED);
}
@Test
public void keep_order_of_state_keys() {
StateMachine machine = StateMachine.builder().states("OPEN", "RESOLVED", "CLOSED").build();
- assertThat(machine.stateKeys()).containsSequence("OPEN", "RESOLVED", "CLOSED");
+ assertThat(machine.stateKeys()).containsSubsequence("OPEN", "RESOLVED", "CLOSED");
}
@Test
.execute()
.getInput();
- assertThat(result).containsSequence(DefaultGroups.ANYONE, "group-1", "group-2");
+ assertThat(result).containsSubsequence(DefaultGroups.ANYONE, "group-1", "group-2");
}
@Test
EmailMessage emailMessage = underTest.format(notification.serialize());
- assertThat(emailMessage.getMessage()).containsSequence("The following built-in profiles have been updated:\n",
+ assertThat(emailMessage.getMessage()).containsSubsequence("The following built-in profiles have been updated:\n",
profileTitleText(profileName1, languageKey1, languageName1),
" 2 new rules\n",
profileTitleText(profileName2, languageKey2, languageName2),
EmailMessage emailMessage = underTest.format(notification.serialize());
- assertThat(emailMessage.getMessage()).containsSequence(
+ assertThat(emailMessage.getMessage()).containsSubsequence(
"\"" + profileName2 + "\" - " + languageName1,
"\"" + profileName1 + "\" - " + languageName2,
"\"" + profileName3 + "\" - " + languageName2);
private void assertMessage(EmailMessage emailMessage, String expectedProfileDetails) {
assertThat(emailMessage.getMessage())
- .containsSequence(
+ .containsSubsequence(
"The following built-in profiles have been updated:\n\n",
expectedProfileDetails,
"\nThis is a good time to review your quality profiles and update them to benefit from the latest evolutions: " + server.getPublicRootUrl() + "/profiles");
.execute()
.getInput();
- assertThat(response).containsSequence("15:43", "15:42");
+ assertThat(response).containsSubsequence("15:43", "15:42");
}
@Test
public class SeverityTest {
@Test
- public void test_ALL() throws Exception {
- assertThat(Severity.ALL).hasSize(5).containsSequence("INFO", "MINOR", "MAJOR", "CRITICAL", "BLOCKER");
+ public void test_ALL() {
+ assertThat(Severity.ALL).hasSize(5).containsSubsequence("INFO", "MINOR", "MAJOR", "CRITICAL", "BLOCKER");
}
@Test
String content = FileUtils.readFileToString(writer.getFileStructure().analysisLog());
assertThat(content).containsOnlyOnce(FOO);
assertThat(content).containsOnlyOnce(BIZ);
- assertThat(content).containsSequence(BIZ, FOO);
+ assertThat(content).containsSubsequence(BIZ, FOO);
publisher.dumpModuleSettings(new DefaultInputModule(ProjectDefinition.create()
.setBaseDir(temp.newFolder())
.setProperty("sonar.password", "azerty")
.setProperty("sonar.cpp.license.secured", "AZERTY")));
- assertThat(FileUtils.readFileToString(writer.getFileStructure().analysisLog())).containsSequence(
+ assertThat(FileUtils.readFileToString(writer.getFileStructure().analysisLog())).containsSubsequence(
"sonar.cpp.license.secured=******",
"sonar.login=******",
"sonar.password=******",
publisher.init(writer);
- assertThat(FileUtils.readFileToString(writer.getFileStructure().analysisLog())).containsSequence(
+ assertThat(FileUtils.readFileToString(writer.getFileStructure().analysisLog())).containsSubsequence(
"sonar.cpp.license.secured=******",
"sonar.login=******",
"sonar.password=******");
*/
package org.sonarqube.tests.issue;
-import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
-import org.assertj.core.api.AbstractListAssert;
import org.assertj.core.api.Fail;
+import org.assertj.core.api.ListAssert;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
}
@SafeVarargs
- private final AbstractListAssert<?, ? extends List<? extends org.sonarqube.ws.Issues.Issue>, org.sonarqube.ws.Issues.Issue> assertSearch(Consumer<SearchRequest>... consumers) {
+ private final ListAssert<org.sonarqube.ws.Issues.Issue> assertSearch(Consumer<SearchRequest>... consumers) {
return assertThat(searchResponse(consumers).getIssuesList());
}
.containsOnly("[SONARQUBE] Built-in quality profiles have been updated");
String url = orchestrator.getServer().getUrl();
assertThat(messages.get(0).getMimeMessage().getContent().toString())
- .containsSequence(
+ .containsSubsequence(
"The following built-in profiles have been updated:",
"\"Basic\" - Foo: " + url + "/profiles/changelog?language=foo&name=Basic&since=", "&to=",
" 1 new rule",
MapEntry.entry(4, new LineData("1", "2013-01-04T00:00:00+0000", "jhenry")),
MapEntry.entry(8, new LineData("3", "2014-01-04T00:00:00+0000", "toto")));
- assertThat(buildResult.getLogs()).containsSequence("1 files to be analyzed", "1/1 files analyzed");
+ assertThat(buildResult.getLogs()).containsSubsequence("1 files to be analyzed", "1/1 files analyzed");
// Second run with same file should not trigger blame but SCM data are copied from previous analysis
buildResult = orchestrator.executeBuild(build);