container.addSingleton(I18nManager.class);
container.addSingleton(RuleI18nManager.class);
for (Object component : boostrapperComponents) {
- container.addSingleton(component);
+ if (component != null) {
+ container.addSingleton(component);
+ }
}
container.addSingleton(BootstrapExtensionExecutor.class);
if (!isMavenPluginExecutorRegistered()) {
public void stop() {
if (classLoader != null) {
classLoader.clearReferencesJdbc();
+ if (Thread.currentThread().getContextClassLoader()==classLoader) {
+ Thread.currentThread().setContextClassLoader(classLoader.getParent());
+ }
classLoader = null;
}
}
try {
doStop();
container.stopComponents();
+ container.removeChild();
} catch (Exception e) {
// ignore
}
}
/**
- * Implementation of this method must not contain conditional logic and just should contain several invocations of
- * {@link #addCoreSingleton(Object)}, {@link #addExtension(org.sonar.api.platform.PluginMetadata, Object)} or {@link #addAdapter(ComponentAdapter)}.
+ * Implementation of this method must not contain conditional logic and just should contain several invocations on
+ * {@link #container}.
*/
protected abstract void configure();
*/
package org.sonar.batch.bootstrap;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-
import org.junit.Test;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.bootstrap.ProjectReactor;
import org.sonar.api.batch.maven.MavenPluginHandler;
import org.sonar.api.resources.Project;
+import org.sonar.batch.FakeMavenPluginExecutor;
import org.sonar.batch.MavenPluginExecutor;
+import static org.fest.assertions.Assertions.assertThat;
+
+
public class BootstrapModuleTest {
- class MyMavenPluginExecutor implements MavenPluginExecutor {
+ private ProjectReactor reactor = new ProjectReactor(ProjectDefinition.create());
+
+ @Test
+ public void should_register_fake_maven_executor_if_not_maven_env() {
+ BootstrapModule module = new BootstrapModule(reactor, null, MyMavenPluginExecutor.class);
+ module.init();
+
+ assertThat(module.isMavenPluginExecutorRegistered()).isTrue();
+ assertThat(module.container.getComponentByType(MavenPluginExecutor.class)).isInstanceOf(MyMavenPluginExecutor.class);
+ }
+
+ @Test
+ public void should_use_plugin_executor_provided_by_maven() {
+ BootstrapModule module = new BootstrapModule(reactor);
+ module.init();
+ assertThat(module.isMavenPluginExecutorRegistered()).isFalse();
+ assertThat(module.container.getComponentByType(MavenPluginExecutor.class)).isInstanceOf(FakeMavenPluginExecutor.class);
+ }
+
+ @Test
+ public void should_register_bootstrap_components() {
+ BootstrapModule module = new BootstrapModule(reactor, new FakeComponent());
+ module.init();
+
+ assertThat(module.container).isNotNull();
+ assertThat(module.container.getComponentByType(FakeComponent.class)).isNotNull();
+ assertThat(module.container.getComponentByType(ProjectReactor.class)).isSameAs(reactor);
+ }
+
+ @Test
+ public void should_not_fail_if_no_bootstrap_components() {
+ BootstrapModule module = new BootstrapModule(reactor);
+ module.init();
+
+ assertThat(module.container).isNotNull();
+ assertThat(module.container.getComponentByType(ProjectReactor.class)).isSameAs(reactor);
+ }
+
+ public static class FakeComponent {
+
+ }
+
+ public static class MyMavenPluginExecutor implements MavenPluginExecutor {
public void execute(Project project, ProjectDefinition projectDef, String goal) {
}
return handler;
}
}
-
- @Test
- public void shouldSearchMavenPluginExecutor() {
- ProjectReactor projectReactor = new ProjectReactor(ProjectDefinition.create());
- BootstrapModule module = new BootstrapModule(projectReactor, null, MyMavenPluginExecutor.class);
- assertThat(module.isMavenPluginExecutorRegistered(), is(true));
-
- module = new BootstrapModule(projectReactor);
- assertThat(module.isMavenPluginExecutorRegistered(), is(false));
- }
}
import org.sonar.batch.bootstrapper.EnvironmentInformation;
import org.sonar.core.NotDryRun;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
public class ExtensionUtilsTest {
@Test
public void shouldBeBatchInstantiationStrategy() {
- assertThat(ExtensionUtils.isInstantiationStrategy(BatchService.class, InstantiationStrategy.BATCH), is(true));
- assertThat(ExtensionUtils.isInstantiationStrategy(new BatchService(), InstantiationStrategy.BATCH), is(true));
- assertThat(ExtensionUtils.isInstantiationStrategy(ProjectService.class, InstantiationStrategy.BATCH), is(false));
- assertThat(ExtensionUtils.isInstantiationStrategy(new ProjectService(), InstantiationStrategy.BATCH), is(false));
- assertThat(ExtensionUtils.isInstantiationStrategy(DefaultService.class, InstantiationStrategy.BATCH), is(false));
- assertThat(ExtensionUtils.isInstantiationStrategy(new DefaultService(), InstantiationStrategy.BATCH), is(false));
+ assertThat(ExtensionUtils.isInstantiationStrategy(BatchService.class, InstantiationStrategy.BATCH)).isTrue();
+ assertThat(ExtensionUtils.isInstantiationStrategy(new BatchService(), InstantiationStrategy.BATCH)).isTrue();
+ assertThat(ExtensionUtils.isInstantiationStrategy(ProjectService.class, InstantiationStrategy.BATCH)).isFalse();
+ assertThat(ExtensionUtils.isInstantiationStrategy(new ProjectService(), InstantiationStrategy.BATCH)).isFalse();
+ assertThat(ExtensionUtils.isInstantiationStrategy(DefaultService.class, InstantiationStrategy.BATCH)).isFalse();
+ assertThat(ExtensionUtils.isInstantiationStrategy(new DefaultService(), InstantiationStrategy.BATCH)).isFalse();
}
@Test
public void shouldBeProjectInstantiationStrategy() {
- assertThat(ExtensionUtils.isInstantiationStrategy(BatchService.class, InstantiationStrategy.PROJECT), is(false));
- assertThat(ExtensionUtils.isInstantiationStrategy(new BatchService(), InstantiationStrategy.PROJECT), is(false));
- assertThat(ExtensionUtils.isInstantiationStrategy(ProjectService.class, InstantiationStrategy.PROJECT), is(true));
- assertThat(ExtensionUtils.isInstantiationStrategy(new ProjectService(), InstantiationStrategy.PROJECT), is(true));
- assertThat(ExtensionUtils.isInstantiationStrategy(DefaultService.class, InstantiationStrategy.PROJECT), is(true));
- assertThat(ExtensionUtils.isInstantiationStrategy(new DefaultService(), InstantiationStrategy.PROJECT), is(true));
+ assertThat(ExtensionUtils.isInstantiationStrategy(BatchService.class, InstantiationStrategy.PROJECT)).isFalse();
+ assertThat(ExtensionUtils.isInstantiationStrategy(new BatchService(), InstantiationStrategy.PROJECT)).isFalse();
+ assertThat(ExtensionUtils.isInstantiationStrategy(ProjectService.class, InstantiationStrategy.PROJECT)).isTrue();
+ assertThat(ExtensionUtils.isInstantiationStrategy(new ProjectService(), InstantiationStrategy.PROJECT)).isTrue();
+ assertThat(ExtensionUtils.isInstantiationStrategy(DefaultService.class, InstantiationStrategy.PROJECT)).isTrue();
+ assertThat(ExtensionUtils.isInstantiationStrategy(new DefaultService(), InstantiationStrategy.PROJECT)).isTrue();
}
@Test
public void testIsBatchExtension() {
- assertThat(ExtensionUtils.isBatchExtension(BatchService.class), is(true));
- assertThat(ExtensionUtils.isBatchExtension(new BatchService()), is(true));
+ assertThat(ExtensionUtils.isBatchExtension(BatchService.class)).isTrue();
+ assertThat(ExtensionUtils.isBatchExtension(new BatchService())).isTrue();
- assertThat(ExtensionUtils.isBatchExtension(ServerService.class), is(false));
- assertThat(ExtensionUtils.isBatchExtension(new ServerService()), is(false));
+ assertThat(ExtensionUtils.isBatchExtension(ServerService.class)).isFalse();
+ assertThat(ExtensionUtils.isBatchExtension(new ServerService())).isFalse();
}
@Test
public void shouldCheckEnvironment() {
- assertThat(ExtensionUtils.supportsEnvironment(new MavenService(), new EnvironmentInformation("maven", "2.2.1")), is(true));
- assertThat(ExtensionUtils.supportsEnvironment(new BuildToolService(), new EnvironmentInformation("maven", "2.2.1")), is(true));
- assertThat(ExtensionUtils.supportsEnvironment(new DefaultService(), new EnvironmentInformation("maven", "2.2.1")), is(true));
+ assertThat(ExtensionUtils.supportsEnvironment(new MavenService(), new EnvironmentInformation("maven", "2.2.1"))).isTrue();
+ assertThat(ExtensionUtils.supportsEnvironment(new BuildToolService(), new EnvironmentInformation("maven", "2.2.1"))).isTrue();
+ assertThat(ExtensionUtils.supportsEnvironment(new DefaultService(), new EnvironmentInformation("maven", "2.2.1"))).isTrue();
- assertThat(ExtensionUtils.supportsEnvironment(new BuildToolService(), new EnvironmentInformation("eclipse", "0.1")), is(false));
+ assertThat(ExtensionUtils.supportsEnvironment(new BuildToolService(), new EnvironmentInformation("eclipse", "0.1"))).isFalse();
}
@Test
public void shouldBeMavenExtensionOnly() {
- assertThat(ExtensionUtils.isMavenExtensionOnly(MavenService.class), is(true));
- assertThat(ExtensionUtils.isMavenExtensionOnly(BuildToolService.class), is(false));
+ assertThat(ExtensionUtils.isMavenExtensionOnly(DefaultService.class)).isFalse();
+ assertThat(ExtensionUtils.isMavenExtensionOnly(new DefaultService())).isFalse();
+ assertThat(ExtensionUtils.isMavenExtensionOnly(MavenService.class)).isTrue();
+ assertThat(ExtensionUtils.isMavenExtensionOnly(new MavenService())).isTrue();
+ assertThat(ExtensionUtils.isMavenExtensionOnly(BuildToolService.class)).isFalse();
+ assertThat(ExtensionUtils.isMavenExtensionOnly(new BuildToolService())).isFalse();
}
-// @Test
-// public void shouldCheckDryRun() {
-// assertThat(ExtensionUtils.supportsDryRun(BatchService.class, true), is(true));
-// assertThat(ExtensionUtils.supportsDryRun(PersistentService.class, true), is(false));
-// }
-//
-// @Test
-// public void shouldNotCheckDryRun() {
-// assertThat(ExtensionUtils.supportsDryRun(BatchService.class, false), is(true));
-// assertThat(ExtensionUtils.supportsDryRun(PersistentService.class, false), is(true));
-// }
+ @Test
+ public void shouldSupportDryRun() {
+ assertThat(ExtensionUtils.supportsDryRun(BatchService.class)).isTrue();
+ assertThat(ExtensionUtils.supportsDryRun(new BatchService())).isTrue();
+ assertThat(ExtensionUtils.supportsDryRun(PersistentService.class)).isFalse();
+ assertThat(ExtensionUtils.supportsDryRun(new PersistentService())).isFalse();
+ }
@InstantiationStrategy(InstantiationStrategy.BATCH)
public static class BatchService implements BatchExtension {
import org.junit.Test;
import java.io.File;
-import java.net.URISyntaxException;
import java.net.URL;
import static org.fest.assertions.Assertions.assertThat;
}
@Test
- public void should_extend_classloader_with_jdbc_driver() throws URISyntaxException {
- /* foo.jar has just one file /foo/foo.txt */
- assertThat(getClass().getClassLoader().getResource("foo/foo.txt")).isNull();
-
- URL url = getClass().getResource("/org/sonar/batch/bootstrap/JdbcDriverHolderTest/foo.jar");
- JdbcDriverHolder.JdbcDriverClassLoader classloader = JdbcDriverHolder.initClassloader(new File(url.toURI()));
- assertThat(classloader).isNotNull();
- assertThat(classloader.getResource("foo/foo.txt")).isNotNull();
- assertThat(Thread.currentThread().getContextClassLoader()).isSameAs(classloader);
+ public void should_extend_classloader_with_jdbc_driver() throws Exception {
+ /* jdbc-driver.jar has just one file /foo/foo.txt */
+ assertThat(Thread.currentThread().getContextClassLoader().getResource("foo/foo.txt")).isNull();
+
+ File fakeDriver = new File(getClass().getResource("/org/sonar/batch/bootstrap/JdbcDriverHolderTest/jdbc-driver.jar").toURI());
+ TempDirectories tempDirectories = mock(TempDirectories.class);
+ when(tempDirectories.getRoot()).thenReturn(fakeDriver.getParentFile());
+ ServerClient server = mock(ServerClient.class);
+
+ JdbcDriverHolder holder = new JdbcDriverHolder(mock(DryRun.class), tempDirectories, server);
+ holder.start();
+
+ verify(server).download("/deploy/jdbc-driver.jar", fakeDriver);
+ assertThat(holder.getClassLoader().getResource("foo/foo.txt")).isNotNull();
+ assertThat(Thread.currentThread().getContextClassLoader()).isSameAs(holder.getClassLoader());
+ assertThat(holder.getClassLoader().getParent()).isSameAs(getClass().getClassLoader());
+
+ holder.stop();
+ assertThat(Thread.currentThread().getContextClassLoader()).isSameAs(getClass().getClassLoader());
+ assertThat(holder.getClassLoader()).isNull();
}
@Test
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * Sonar is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.bootstrap;
+
+import org.junit.Test;
+import org.sonar.api.measures.CoreMetrics;
+import org.sonar.api.measures.Metric;
+import org.sonar.api.measures.Metrics;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.fest.assertions.Assertions.assertThat;
+
+public class MetricProviderTest {
+ @Test
+ public void should_provide_at_least_core_metrics() {
+ MetricProvider provider = new MetricProvider();
+ List<Metric> metrics = provider.provide();
+
+ assertThat(metrics).hasSize(CoreMetrics.getMetrics().size());
+ assertThat(metrics).onProperty("key").contains("ncloc");
+ }
+
+ @Test
+ public void should_provide_plugin_metrics() {
+ Metrics factory = new Metrics(){
+ public List<Metric> getMetrics() {
+ return Arrays.asList(new Metric.Builder("custom", "Custom", Metric.ValueType.FLOAT).create());
+ }
+ };
+ MetricProvider provider = new MetricProvider(new Metrics[]{factory});
+ List<Metric> metrics = provider.provide();
+
+ assertThat(metrics.size()).isEqualTo(1 + CoreMetrics.getMetrics().size());
+ assertThat(metrics).onProperty("key").contains("custom");
+ }
+}
assertThat(tempDirectories.getRoot()).isNotNull();
assertThat(tempDirectories.getRoot()).exists();
assertThat(tempDirectories.getRoot()).isDirectory();
+ assertThat(tempDirectories.getDir("")).isEqualTo(tempDirectories.getRoot());
}
@Test
/**
* @since 2.9
*/
-public final class ProjectReactor {
+public class ProjectReactor {
private ProjectDefinition root;
projects / sonarqube.git / commitdiff