*/
package org.sonar.server.platform.db.migration.step;
-import java.util.stream.Stream;
+import java.util.List;
public interface MigrationSteps {
/**
/**
* Reads all migration steps in order of increasing migration number.
*/
- Stream<RegisteredMigrationStep> readAll();
+ List<RegisteredMigrationStep> readAll();
/**
* Reads migration steps, in order of increasing migration number, from the specified migration number <strong>included</strong>.
*/
- Stream<RegisteredMigrationStep> readFrom(long migrationNumber);
+ List<RegisteredMigrationStep> readFrom(long migrationNumber);
}
*/
package org.sonar.server.platform.db.migration.step;
-import java.util.stream.Stream;
+import java.util.List;
/**
* Responsible for:
/**
* @throws MigrationStepExecutionException at the first failing migration step execution
*/
- void execute(Stream<RegisteredMigrationStep> steps);
+ void execute(List<RegisteredMigrationStep> steps);
}
*/
package org.sonar.server.platform.db.migration.step;
-import java.util.stream.Stream;
+import java.util.List;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
import org.sonar.core.util.logs.Profiler;
}
@Override
- public void execute(Stream<RegisteredMigrationStep> steps) {
+ public void execute(List<RegisteredMigrationStep> steps) {
Profiler globalProfiler = Profiler.create(LOGGER);
globalProfiler.startInfo(GLOBAL_START_MESSAGE);
boolean allStepsExecuted = false;
try {
- steps.forEachOrdered(this::execute);
+ steps.forEach(this::execute);
allStepsExecuted = true;
} finally {
if (allStepsExecuted) {
*/
package org.sonar.server.platform.db.migration.step;
+import java.util.Collections;
import java.util.List;
-import java.util.stream.Stream;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.ImmutableList.copyOf;
}
@Override
- public Stream<RegisteredMigrationStep> readAll() {
- return steps.stream();
+ public List<RegisteredMigrationStep> readAll() {
+ return steps;
}
@Override
- public Stream<RegisteredMigrationStep> readFrom(long migrationNumber) {
+ public List<RegisteredMigrationStep> readFrom(long migrationNumber) {
validate(migrationNumber);
int startingIndex = lookupIndexOfClosestTo(migrationNumber);
if (startingIndex < 0) {
- return Stream.empty();
+ return Collections.emptyList();
}
- return steps.subList(startingIndex, steps.size()).stream();
+ return steps.subList(startingIndex, steps.size());
}
private int lookupIndexOfClosestTo(long startingPoint) {
import org.sonar.server.platform.db.migration.step.RegisteredMigrationStep;
import org.sonar.server.platform.db.migration.version.DbVersion;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
return Stream.of(Clazz1.class, Clazz3.class);
}
});
- when(migrationSteps.readAll()).thenReturn(Stream.empty());
+ when(migrationSteps.readAll()).thenReturn(emptyList());
underTest.populateContainer(migrationContainer);
@Test
public void populateContainer_adds_MigrationStepsExecutorImpl() {
- when(migrationSteps.readAll()).thenReturn(Stream.empty());
+ when(migrationSteps.readAll()).thenReturn(emptyList());
// add MigrationStepsExecutorImpl's dependencies
migrationContainer.add(mock(MigrationHistory.class));
@Test
public void populateContainer_adds_classes_of_all_steps_defined_in_MigrationSteps() {
- when(migrationSteps.readAll()).thenReturn(Stream.of(
+ when(migrationSteps.readAll()).thenReturn(asList(
new RegisteredMigrationStep(1, "foo", MigrationStep1.class),
new RegisteredMigrationStep(2, "bar", MigrationStep2.class),
new RegisteredMigrationStep(3, "dor", MigrationStep3.class)));
@Test
public void populateCotnainer_does_not_fail_if_same_class_is_used_for_more_than_one_migration() {
- when(migrationSteps.readAll()).thenReturn(Stream.of(
+ when(migrationSteps.readAll()).thenReturn(asList(
new RegisteredMigrationStep(1, "foo", MigrationStep1.class),
new RegisteredMigrationStep(2, "bar", MigrationStep2.class),
new RegisteredMigrationStep(3, "bar2", MigrationStep2.class),
*/
package org.sonar.server.platform.db.migration.engine;
+import java.util.List;
import java.util.Optional;
-import java.util.stream.Stream;
import org.junit.Test;
+import org.sonar.api.config.Configuration;
import org.sonar.core.platform.ComponentContainer;
import org.sonar.server.platform.db.migration.history.MigrationHistory;
import org.sonar.server.platform.db.migration.step.MigrationStep;
import org.sonar.server.platform.db.migration.step.MigrationStepsExecutor;
import org.sonar.server.platform.db.migration.step.RegisteredMigrationStep;
+import static java.util.Collections.singletonList;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
};
private MigrationSteps migrationSteps = mock(MigrationSteps.class);
- private MigrationEngineImpl underTest = new MigrationEngineImpl(migrationHistory, serverContainer, populator, migrationSteps);
+ private Configuration configuration;
+ private MigrationEngineImpl underTest = new MigrationEngineImpl(migrationHistory, serverContainer, populator, migrationSteps, configuration);
@Test
public void execute_execute_all_steps_of_there_is_no_last_migration_number() {
when(migrationHistory.getLastMigrationNumber()).thenReturn(Optional.empty());
- Stream<RegisteredMigrationStep> steps = Stream.of(new RegisteredMigrationStep(1, "doo", MigrationStep.class));
+ List<RegisteredMigrationStep> steps = singletonList(new RegisteredMigrationStep(1, "doo", MigrationStep.class));
when(migrationSteps.readAll()).thenReturn(steps);
underTest.execute();
@Test
public void execute_execute_steps_from_last_migration_number_plus_1() {
when(migrationHistory.getLastMigrationNumber()).thenReturn(Optional.of(50L));
- Stream<RegisteredMigrationStep> steps = Stream.of(new RegisteredMigrationStep(1, "doo", MigrationStep.class));
+ List<RegisteredMigrationStep> steps = singletonList(new RegisteredMigrationStep(1, "doo", MigrationStep.class));
when(migrationSteps.readFrom(51)).thenReturn(steps);
underTest.execute();
import java.sql.SQLException;
import java.util.List;
import java.util.Random;
-import java.util.stream.Collectors;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
MigrationSteps migrationSteps = underTest.build();
assertThat(migrationSteps).isInstanceOf(MigrationStepsImpl.class);
- List<RegisteredMigrationStep> registeredMigrationSteps = migrationSteps.readAll().collect(Collectors.toList());
+ List<RegisteredMigrationStep> registeredMigrationSteps = migrationSteps.readAll();
assertThat(registeredMigrationSteps).hasSize(4);
verify(registeredMigrationSteps.get(0), 2, "aaaa", MigrationStep4.class);
verify(registeredMigrationSteps.get(1), 5, "aazsa", MigrationStep1.class);
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-import java.util.stream.Stream;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.log.LogTester;
import org.sonar.server.platform.db.migration.history.MigrationHistory;
import static com.google.common.base.Preconditions.checkState;
+import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.mock;
@Test
public void execute_does_not_fail_when_stream_is_empty_and_log_start_stop_INFO() {
- underTest.execute(Stream.empty());
+ underTest.execute(Collections.emptyList());
assertThat(logTester.logs()).hasSize(2);
assertLogLevel(LoggerLevel.INFO, "Executing DB migrations...", "Executed DB migrations: success | time=");
@Test
public void execute_fails_with_ISE_if_no_instance_of_computation_step_exist_in_container() {
- Stream<RegisteredMigrationStep> steps = Stream.of(registeredStepOf(1, MigrationStep1.class));
+ List<RegisteredMigrationStep> steps = asList(registeredStepOf(1, MigrationStep1.class));
try {
underTest.execute(steps);
public void execute_execute_the_instance_of_type_specified_in_step_in_stream_order() {
migrationContainer.add(MigrationStep1.class, MigrationStep2.class, MigrationStep3.class);
- underTest.execute(Stream.of(
+ underTest.execute(asList(
registeredStepOf(1, MigrationStep2.class),
registeredStepOf(2, MigrationStep1.class),
registeredStepOf(3, MigrationStep3.class)));
@Test
public void execute_throws_MigrationStepExecutionException_on_first_failing_step_execution_throws_SQLException() {
migrationContainer.add(MigrationStep2.class, SqlExceptionFailingMigrationStep.class, MigrationStep3.class);
- Stream<RegisteredMigrationStep> steps = Stream.of(
+ List<RegisteredMigrationStep> steps = asList(
registeredStepOf(1, MigrationStep2.class),
registeredStepOf(2, SqlExceptionFailingMigrationStep.class),
registeredStepOf(3, MigrationStep3.class));
public void execute_throws_MigrationStepExecutionException_on_first_failing_step_execution_throws_any_exception() {
migrationContainer.add(MigrationStep2.class, RuntimeExceptionFailingMigrationStep.class, MigrationStep3.class);
- Stream<RegisteredMigrationStep> steps = Stream.of(
+ List<RegisteredMigrationStep> steps = asList(
registeredStepOf(1, MigrationStep2.class),
registeredStepOf(2, RuntimeExceptionFailingMigrationStep.class),
registeredStepOf(3, MigrationStep3.class));
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
@Test
public void readAll_iterates_over_all_steps_in_constructor_list_argument() {
- verifySteamContainsNumbers(underTest.readAll(), 1L, 2L, 8L);
+ verifyContainsNumbers(underTest.readAll(), 1L, 2L, 8L);
}
@Test
@Test
public void readFrom_returns_stream_of_sublist_from_the_first_migration_with_number_greater_or_equal_to_argument() {
- verifySteamContainsNumbers(underTest.readFrom(1), 1L, 2L, 8L);
- verifySteamContainsNumbers(underTest.readFrom(2), 2L, 8L);
- verifySteamContainsNumbers(underTest.readFrom(3), 8L);
- verifySteamContainsNumbers(underTest.readFrom(4), 8L);
- verifySteamContainsNumbers(underTest.readFrom(5), 8L);
- verifySteamContainsNumbers(underTest.readFrom(6), 8L);
- verifySteamContainsNumbers(underTest.readFrom(7), 8L);
- verifySteamContainsNumbers(underTest.readFrom(8), 8L);
+ verifyContainsNumbers(underTest.readFrom(1), 1L, 2L, 8L);
+ verifyContainsNumbers(underTest.readFrom(2), 2L, 8L);
+ verifyContainsNumbers(underTest.readFrom(3), 8L);
+ verifyContainsNumbers(underTest.readFrom(4), 8L);
+ verifyContainsNumbers(underTest.readFrom(5), 8L);
+ verifyContainsNumbers(underTest.readFrom(6), 8L);
+ verifyContainsNumbers(underTest.readFrom(7), 8L);
+ verifyContainsNumbers(underTest.readFrom(8), 8L);
}
@Test
public void readFrom_returns_an_empty_stream_if_argument_is_greater_than_biggest_migration_number() {
- verifySteamContainsNumbers(underTest.readFrom(9));
- verifySteamContainsNumbers(unorderedSteps.readFrom(9));
+ verifyContainsNumbers(underTest.readFrom(9));
+ verifyContainsNumbers(unorderedSteps.readFrom(9));
}
- private static void verifySteamContainsNumbers(Stream<RegisteredMigrationStep> stream, Long... expectedMigrationNumbers) {
- List<RegisteredMigrationStep> steps = stream.collect(Collectors.toList());
+ private static void verifyContainsNumbers(List<RegisteredMigrationStep> steps, Long... expectedMigrationNumbers) {
assertThat(steps).hasSize(expectedMigrationNumbers.length);
Iterator<RegisteredMigrationStep> iterator = steps.iterator();
Arrays.stream(expectedMigrationNumbers).forEach(expected -> assertThat(iterator.next().getMigrationNumber()).isEqualTo(expected));
projects / sonarqube.git / commitdiff