From a00e567bffae6300381d11989bfda011d2f85aba Mon Sep 17 00:00:00 2001 From: Julien HENRY Date: Thu, 29 Nov 2018 17:07:21 +0100 Subject: SONAR-11465 Move post-job at project level --- .../bootstrap/PostJobExtensionDictionnaryTest.java | 110 +++++ .../bootstrap/ScannerExtensionDictionnaryTest.java | 459 --------------------- .../bootstrap/SensorExtensionDictionnaryTest.java | 429 +++++++++++++++++++ .../mediumtest/fs/FileSystemMediumTest.java | 2 +- .../phases/ModuleCoverageExclusionsTest.java | 11 +- .../sonar/scanner/phases/PostJobsExecutorTest.java | 5 +- .../sonar/scanner/phases/SensorsExecutorTest.java | 4 +- .../scan/filesystem/InputComponentStoreTest.java | 12 +- .../filesystem/ModuleInputComponentStoreTest.java | 10 +- 9 files changed, 566 insertions(+), 476 deletions(-) create mode 100644 sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/PostJobExtensionDictionnaryTest.java delete mode 100644 sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/ScannerExtensionDictionnaryTest.java create mode 100644 sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/SensorExtensionDictionnaryTest.java (limited to 'sonar-scanner-engine/src/test') diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/PostJobExtensionDictionnaryTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/PostJobExtensionDictionnaryTest.java new file mode 100644 index 00000000000..a3b55c69e13 --- /dev/null +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/PostJobExtensionDictionnaryTest.java @@ -0,0 +1,110 @@ +/* + * SonarQube + * Copyright (C) 2009-2018 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program 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. + * + * This program 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 this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.scanner.bootstrap; + +import org.junit.Before; +import org.junit.Test; +import org.sonar.api.batch.Phase; +import org.sonar.api.batch.postjob.PostJob; +import org.sonar.api.batch.postjob.PostJobContext; +import org.sonar.api.batch.postjob.PostJobDescriptor; +import org.sonar.api.batch.postjob.internal.DefaultPostJobDescriptor; +import org.sonar.api.batch.sensor.Sensor; +import org.sonar.api.batch.sensor.SensorContext; +import org.sonar.api.batch.sensor.SensorDescriptor; +import org.sonar.core.platform.ComponentContainer; +import org.sonar.scanner.postjob.PostJobOptimizer; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class PostJobExtensionDictionnaryTest { + private PostJobOptimizer postJobOptimizer = mock(PostJobOptimizer.class); + + @Before + public void setUp() { + when(postJobOptimizer.shouldExecute(any(DefaultPostJobDescriptor.class))).thenReturn(true); + } + + private PostJobExtensionDictionnary newSelector(Object... extensions) { + ComponentContainer iocContainer = new ComponentContainer(); + for (Object extension : extensions) { + iocContainer.addSingleton(extension); + } + return new PostJobExtensionDictionnary(iocContainer, postJobOptimizer, mock(PostJobContext.class)); + } + + @Test + public void dependsUponPhaseForPostJob() { + PrePostJob pre = new PrePostJob(); + NormalPostJob normal = new NormalPostJob(); + + PostJobExtensionDictionnary selector = newSelector(normal, pre); + assertThat(selector.selectPostJobs()).extracting("wrappedPostJob").containsExactly(pre, normal); + } + + interface Marker { + + } + + @Phase(name = Phase.Name.POST) + class PostSensor implements Sensor { + + @Override + public void describe(SensorDescriptor descriptor) { + } + + @Override + public void execute(SensorContext context) { + } + + } + + class PostSensorSubclass extends PostSensor { + + } + + class NormalPostJob implements PostJob { + + @Override + public void describe(PostJobDescriptor descriptor) { + } + + @Override + public void execute(PostJobContext context) { + } + + } + + @Phase(name = Phase.Name.PRE) + class PrePostJob implements PostJob { + + @Override + public void describe(PostJobDescriptor descriptor) { + } + + @Override + public void execute(PostJobContext context) { + } + + } +} diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/ScannerExtensionDictionnaryTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/ScannerExtensionDictionnaryTest.java deleted file mode 100644 index 7ddf235b0cd..00000000000 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/ScannerExtensionDictionnaryTest.java +++ /dev/null @@ -1,459 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2019 SonarSource SA - * mailto:info AT sonarsource DOT com - * - * This program 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. - * - * This program 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 this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ -package org.sonar.scanner.bootstrap; - -import com.google.common.collect.Lists; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import org.junit.Before; -import org.junit.Test; -import org.picocontainer.behaviors.FieldDecorated; -import org.sonar.api.batch.DependedUpon; -import org.sonar.api.batch.DependsUpon; -import org.sonar.api.batch.Phase; -import org.sonar.api.batch.ScannerSide; -import org.sonar.api.batch.postjob.PostJob; -import org.sonar.api.batch.postjob.PostJobContext; -import org.sonar.api.batch.postjob.PostJobDescriptor; -import org.sonar.api.batch.postjob.internal.DefaultPostJobDescriptor; -import org.sonar.api.batch.sensor.Sensor; -import org.sonar.api.batch.sensor.SensorContext; -import org.sonar.api.batch.sensor.SensorDescriptor; -import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor; -import org.sonar.core.platform.ComponentContainer; -import org.sonar.scanner.postjob.PostJobOptimizer; -import org.sonar.scanner.sensor.DefaultSensorContext; -import org.sonar.scanner.sensor.SensorOptimizer; -import org.sonar.scanner.sensor.SensorWrapper; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -public class ScannerExtensionDictionnaryTest { - private SensorOptimizer sensorOptimizer = mock(SensorOptimizer.class); - private PostJobOptimizer postJobOptimizer = mock(PostJobOptimizer.class); - - @Before - public void setUp() { - when(sensorOptimizer.shouldExecute(any(DefaultSensorDescriptor.class))).thenReturn(true); - when(postJobOptimizer.shouldExecute(any(DefaultPostJobDescriptor.class))).thenReturn(true); - } - - private ScannerExtensionDictionnary newSelector(Object... extensions) { - ComponentContainer iocContainer = new ComponentContainer(); - for (Object extension : extensions) { - iocContainer.addSingleton(extension); - } - return new ScannerExtensionDictionnary(iocContainer, mock(DefaultSensorContext.class), sensorOptimizer, postJobOptimizer, mock(PostJobContext.class)); - } - - @Test - public void testGetFilteredExtensionWithExtensionMatcher() { - final Sensor sensor1 = new FakeSensor(); - final Sensor sensor2 = new FakeSensor(); - - ScannerExtensionDictionnary selector = newSelector(sensor1, sensor2); - Collection sensors = selector.select(Sensor.class, true, extension -> extension.equals(sensor1)); - assertThat(sensors).contains(sensor1); - assertEquals(1, sensors.size()); - } - - @Test - public void testGetFilteredExtensions() { - Sensor sensor1 = new FakeSensor(); - Sensor sensor2 = new FakeSensor(); - FieldDecorated.Decorator decorator = mock(FieldDecorated.Decorator.class); - - ScannerExtensionDictionnary selector = newSelector(sensor1, sensor2, decorator); - Collection sensors = selector.select(Sensor.class, false, null); - - assertThat(sensors).containsOnly(sensor1, sensor2); - } - - @Test - public void shouldSearchInParentContainers() { - Sensor a = new FakeSensor(); - Sensor b = new FakeSensor(); - Sensor c = new FakeSensor(); - - ComponentContainer grandParent = new ComponentContainer(); - grandParent.addSingleton(a); - - ComponentContainer parent = grandParent.createChild(); - parent.addSingleton(b); - - ComponentContainer child = parent.createChild(); - child.addSingleton(c); - - ScannerExtensionDictionnary dictionnary = new ScannerExtensionDictionnary(child, mock(DefaultSensorContext.class), - mock(SensorOptimizer.class), mock(PostJobOptimizer.class), mock(PostJobContext.class)); - assertThat(dictionnary.select(Sensor.class, true, null)).containsOnly(a, b, c); - } - - @Test - public void sortExtensionsByDependency() { - Object a = new MethodDependentOf(null); - Object b = new MethodDependentOf(a); - Object c = new MethodDependentOf(b); - - ScannerExtensionDictionnary selector = newSelector(b, c, a); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(3); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - assertThat(extensions.get(2)).isEqualTo(c); - } - - @Test - public void useMethodAnnotationsToSortExtensions() { - Object a = new GeneratesSomething("foo"); - Object b = new MethodDependentOf("foo"); - - ScannerExtensionDictionnary selector = newSelector(a, b); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions.size()).isEqualTo(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - - // different initial order - selector = newSelector(b, a); - extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - } - - @Test - public void methodDependsUponCollection() { - Object a = new GeneratesSomething("foo"); - Object b = new MethodDependentOf(Arrays.asList("foo")); - - ScannerExtensionDictionnary selector = newSelector(a, b); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - - // different initial order - selector = newSelector(b, a); - extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - } - - @Test - public void methodDependsUponArray() { - Object a = new GeneratesSomething("foo"); - Object b = new MethodDependentOf(new String[] {"foo"}); - - ScannerExtensionDictionnary selector = newSelector(a, b); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - - // different initial order - selector = newSelector(b, a); - extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - } - - @Test - public void useClassAnnotationsToSortExtensions() { - Object a = new ClassDependedUpon(); - Object b = new ClassDependsUpon(); - - ScannerExtensionDictionnary selector = newSelector(a, b); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - - // different initial order - selector = newSelector(b, a); - extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - } - - @Test - public void useClassAnnotationsOnInterfaces() { - Object a = new InterfaceDependedUpon() { - }; - Object b = new InterfaceDependsUpon() { - }; - - ScannerExtensionDictionnary selector = newSelector(a, b); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - - // different initial order - selector = newSelector(b, a); - extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - } - - @Test - public void inheritAnnotations() { - Object a = new SubClass("foo"); - Object b = new MethodDependentOf("foo"); - - ScannerExtensionDictionnary selector = newSelector(b, a); - List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - - // change initial order - selector = newSelector(a, b); - extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); - - assertThat(extensions).hasSize(2); - assertThat(extensions.get(0)).isEqualTo(a); - assertThat(extensions.get(1)).isEqualTo(b); - } - - @Test(expected = IllegalStateException.class) - public void annotatedMethodsCanNotBePrivate() { - ScannerExtensionDictionnary selector = newSelector(); - Object wrong = new Object() { - @DependsUpon - private Object foo() { - return "foo"; - } - }; - selector.evaluateAnnotatedClasses(wrong, DependsUpon.class); - } - - @Test - public void dependsUponPhaseForSensors() { - PreSensor pre = new PreSensor(); - NormalSensor normal = new NormalSensor(); - PostSensor post = new PostSensor(); - - ScannerExtensionDictionnary selector = newSelector(normal, post, pre); - assertThat(selector.selectSensors(false)).extracting("wrappedSensor").containsExactly(pre, normal, post); - } - - @Test - public void dependsUponPhaseForPostJob() { - PrePostJob pre = new PrePostJob(); - NormalPostJob normal = new NormalPostJob(); - - ScannerExtensionDictionnary selector = newSelector(normal, pre); - assertThat(selector.selectPostJobs()).extracting("wrappedPostJob").containsExactly(pre, normal); - } - - @Test - public void dependsUponInheritedPhase() { - PreSensorSubclass pre = new PreSensorSubclass(); - NormalSensor normal = new NormalSensor(); - PostSensorSubclass post = new PostSensorSubclass(); - - ScannerExtensionDictionnary selector = newSelector(normal, post, pre); - List extensions = Lists.newArrayList(selector.select(Sensor.class, true, null)); - - assertThat(extensions).containsExactly(pre, normal, post); - } - - @Test - public void selectSensors() { - FakeSensor nonGlobalSensor = new FakeSensor(); - FakeGlobalSensor globalSensor = new FakeGlobalSensor(); - ScannerExtensionDictionnary selector = newSelector(nonGlobalSensor, globalSensor); - - // verify non-global sensor - Collection extensions = selector.selectSensors(false); - assertThat(extensions).hasSize(1); - assertThat(extensions).extracting("wrappedSensor").containsExactly(nonGlobalSensor); - - // verify global sensor - extensions = selector.selectSensors(true); - assertThat(extensions).extracting("wrappedSensor").containsExactly(globalSensor); - } - - interface Marker { - - } - - class FakeSensor implements Sensor { - - @Override public void describe(SensorDescriptor descriptor) { - - } - - @Override public void execute(SensorContext context) { - - } - } - - class FakeGlobalSensor implements Sensor { - - @Override - public void describe(SensorDescriptor descriptor) { - descriptor.global(); - } - - @Override - public void execute(SensorContext context) { - } - - } - - @ScannerSide class MethodDependentOf implements Marker { - private Object dep; - - MethodDependentOf(Object o) { - this.dep = o; - } - - @DependsUpon - public Object dependsUponObject() { - return dep; - } - } - - @ScannerSide - @DependsUpon("flag") class ClassDependsUpon implements Marker { - } - - @ScannerSide - @DependedUpon("flag") class ClassDependedUpon implements Marker { - } - - @ScannerSide - @DependsUpon("flag") interface InterfaceDependsUpon extends Marker { - } - - @ScannerSide - @DependedUpon("flag") interface InterfaceDependedUpon extends Marker { - } - - @ScannerSide class GeneratesSomething implements Marker { - private Object gen; - - GeneratesSomething(Object o) { - this.gen = o; - } - - @DependedUpon - public Object generates() { - return gen; - } - } - - class SubClass extends GeneratesSomething implements Marker { - SubClass(Object o) { - super(o); - } - } - - class NormalSensor implements Sensor { - - @Override - public void describe(SensorDescriptor descriptor) { - } - - @Override - public void execute(SensorContext context) { - } - - } - - @Phase(name = Phase.Name.PRE) class PreSensor implements Sensor { - - @Override - public void describe(SensorDescriptor descriptor) { - } - - @Override - public void execute(SensorContext context) { - } - - } - - class PreSensorSubclass extends PreSensor { - - } - - @Phase(name = Phase.Name.POST) class PostSensor implements Sensor { - - @Override - public void describe(SensorDescriptor descriptor) { - } - - @Override - public void execute(SensorContext context) { - } - - } - - class PostSensorSubclass extends PostSensor { - - } - - class NormalPostJob implements PostJob { - - @Override - public void describe(PostJobDescriptor descriptor) { - } - - @Override - public void execute(PostJobContext context) { - } - - } - - @Phase(name = Phase.Name.PRE) class PrePostJob implements PostJob { - - @Override - public void describe(PostJobDescriptor descriptor) { - } - - @Override - public void execute(PostJobContext context) { - } - - } -} diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/SensorExtensionDictionnaryTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/SensorExtensionDictionnaryTest.java new file mode 100644 index 00000000000..b922b3a99ad --- /dev/null +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/bootstrap/SensorExtensionDictionnaryTest.java @@ -0,0 +1,429 @@ +/* + * SonarQube + * Copyright (C) 2009-2019 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program 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. + * + * This program 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 this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.scanner.bootstrap; + +import com.google.common.collect.Lists; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.picocontainer.behaviors.FieldDecorated; +import org.sonar.api.batch.DependedUpon; +import org.sonar.api.batch.DependsUpon; +import org.sonar.api.batch.Phase; +import org.sonar.api.batch.ScannerSide; +import org.sonar.api.batch.sensor.Sensor; +import org.sonar.api.batch.sensor.SensorContext; +import org.sonar.api.batch.sensor.SensorDescriptor; +import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor; +import org.sonar.core.platform.ComponentContainer; +import org.sonar.scanner.sensor.DefaultSensorContext; +import org.sonar.scanner.sensor.SensorOptimizer; +import org.sonar.scanner.sensor.SensorWrapper; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class SensorExtensionDictionnaryTest { + private SensorOptimizer sensorOptimizer = mock(SensorOptimizer.class); + + @Before + public void setUp() { + when(sensorOptimizer.shouldExecute(any(DefaultSensorDescriptor.class))).thenReturn(true); + } + + private SensorExtensionDictionnary newSelector(Object... extensions) { + ComponentContainer iocContainer = new ComponentContainer(); + for (Object extension : extensions) { + iocContainer.addSingleton(extension); + } + return new SensorExtensionDictionnary(iocContainer, mock(DefaultSensorContext.class), sensorOptimizer); + } + + @Test + public void testGetFilteredExtensionWithExtensionMatcher() { + final Sensor sensor1 = new FakeSensor(); + final Sensor sensor2 = new FakeSensor(); + + SensorExtensionDictionnary selector = newSelector(sensor1, sensor2); + Collection sensors = selector.select(Sensor.class, true, extension -> extension.equals(sensor1)); + assertThat(sensors).contains(sensor1); + assertEquals(1, sensors.size()); + } + + @Test + public void testGetFilteredExtensions() { + Sensor sensor1 = new FakeSensor(); + Sensor sensor2 = new FakeSensor(); + FieldDecorated.Decorator decorator = mock(FieldDecorated.Decorator.class); + + SensorExtensionDictionnary selector = newSelector(sensor1, sensor2, decorator); + Collection sensors = selector.select(Sensor.class, false, null); + + assertThat(sensors).containsOnly(sensor1, sensor2); + } + + @Test + public void shouldSearchInParentContainers() { + Sensor a = new FakeSensor(); + Sensor b = new FakeSensor(); + Sensor c = new FakeSensor(); + + ComponentContainer grandParent = new ComponentContainer(); + grandParent.addSingleton(a); + + ComponentContainer parent = grandParent.createChild(); + parent.addSingleton(b); + + ComponentContainer child = parent.createChild(); + child.addSingleton(c); + + SensorExtensionDictionnary dictionnary = new SensorExtensionDictionnary(child, mock(DefaultSensorContext.class), mock(SensorOptimizer.class)); + assertThat(dictionnary.select(Sensor.class, true, null)).containsOnly(a, b, c); + } + + @Test + public void sortExtensionsByDependency() { + Object a = new MethodDependentOf(null); + Object b = new MethodDependentOf(a); + Object c = new MethodDependentOf(b); + + SensorExtensionDictionnary selector = newSelector(b, c, a); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(3); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + assertThat(extensions.get(2)).isEqualTo(c); + } + + @Test + public void useMethodAnnotationsToSortExtensions() { + Object a = new GeneratesSomething("foo"); + Object b = new MethodDependentOf("foo"); + + SensorExtensionDictionnary selector = newSelector(a, b); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions.size()).isEqualTo(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + + // different initial order + selector = newSelector(b, a); + extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + } + + @Test + public void methodDependsUponCollection() { + Object a = new GeneratesSomething("foo"); + Object b = new MethodDependentOf(Arrays.asList("foo")); + + SensorExtensionDictionnary selector = newSelector(a, b); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + + // different initial order + selector = newSelector(b, a); + extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + } + + @Test + public void methodDependsUponArray() { + Object a = new GeneratesSomething("foo"); + Object b = new MethodDependentOf(new String[] {"foo"}); + + SensorExtensionDictionnary selector = newSelector(a, b); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + + // different initial order + selector = newSelector(b, a); + extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + } + + @Test + public void useClassAnnotationsToSortExtensions() { + Object a = new ClassDependedUpon(); + Object b = new ClassDependsUpon(); + + SensorExtensionDictionnary selector = newSelector(a, b); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + + // different initial order + selector = newSelector(b, a); + extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + } + + @Test + public void useClassAnnotationsOnInterfaces() { + Object a = new InterfaceDependedUpon() { + }; + Object b = new InterfaceDependsUpon() { + }; + + SensorExtensionDictionnary selector = newSelector(a, b); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + + // different initial order + selector = newSelector(b, a); + extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + } + + @Test + public void inheritAnnotations() { + Object a = new SubClass("foo"); + Object b = new MethodDependentOf("foo"); + + SensorExtensionDictionnary selector = newSelector(b, a); + List extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + + // change initial order + selector = newSelector(a, b); + extensions = Lists.newArrayList(selector.select(Marker.class, true, null)); + + assertThat(extensions).hasSize(2); + assertThat(extensions.get(0)).isEqualTo(a); + assertThat(extensions.get(1)).isEqualTo(b); + } + + @Test(expected = IllegalStateException.class) + public void annotatedMethodsCanNotBePrivate() { + SensorExtensionDictionnary selector = newSelector(); + Object wrong = new Object() { + @DependsUpon + private Object foo() { + return "foo"; + } + }; + selector.evaluateAnnotatedClasses(wrong, DependsUpon.class); + } + + @Test + public void dependsUponPhaseForSensors() { + PreSensor pre = new PreSensor(); + NormalSensor normal = new NormalSensor(); + PostSensor post = new PostSensor(); + + SensorExtensionDictionnary selector = newSelector(normal, post, pre); + assertThat(selector.selectSensors(false)).extracting("wrappedSensor").containsExactly(pre, normal, post); + } + + @Test + public void dependsUponInheritedPhase() { + PreSensorSubclass pre = new PreSensorSubclass(); + NormalSensor normal = new NormalSensor(); + PostSensorSubclass post = new PostSensorSubclass(); + + SensorExtensionDictionnary selector = newSelector(normal, post, pre); + List extensions = Lists.newArrayList(selector.select(Sensor.class, true, null)); + + assertThat(extensions).containsExactly(pre, normal, post); + } + + @Test + public void selectSensors() { + FakeSensor nonGlobalSensor = new FakeSensor(); + FakeGlobalSensor globalSensor = new FakeGlobalSensor(); + SensorExtensionDictionnary selector = newSelector(nonGlobalSensor, globalSensor); + + // verify non-global sensor + Collection extensions = selector.selectSensors(false); + assertThat(extensions).hasSize(1); + assertThat(extensions).extracting("wrappedSensor").containsExactly(nonGlobalSensor); + + // verify global sensor + extensions = selector.selectSensors(true); + assertThat(extensions).extracting("wrappedSensor").containsExactly(globalSensor); + } + + interface Marker { + + } + + class FakeSensor implements Sensor { + + @Override + public void describe(SensorDescriptor descriptor) { + + } + + @Override + public void execute(SensorContext context) { + + } + } + + class FakeGlobalSensor implements Sensor { + + @Override + public void describe(SensorDescriptor descriptor) { + descriptor.global(); + } + + @Override + public void execute(SensorContext context) { + } + + } + + @ScannerSide + class MethodDependentOf implements Marker { + private Object dep; + + MethodDependentOf(Object o) { + this.dep = o; + } + + @DependsUpon + public Object dependsUponObject() { + return dep; + } + } + + @ScannerSide + @DependsUpon("flag") + class ClassDependsUpon implements Marker { + } + + @ScannerSide + @DependedUpon("flag") + class ClassDependedUpon implements Marker { + } + + @ScannerSide + @DependsUpon("flag") + interface InterfaceDependsUpon extends Marker { + } + + @ScannerSide + @DependedUpon("flag") + interface InterfaceDependedUpon extends Marker { + } + + @ScannerSide + class GeneratesSomething implements Marker { + private Object gen; + + GeneratesSomething(Object o) { + this.gen = o; + } + + @DependedUpon + public Object generates() { + return gen; + } + } + + class SubClass extends GeneratesSomething implements Marker { + SubClass(Object o) { + super(o); + } + } + + class NormalSensor implements Sensor { + + @Override + public void describe(SensorDescriptor descriptor) { + } + + @Override + public void execute(SensorContext context) { + } + + } + + @Phase(name = Phase.Name.PRE) + class PreSensor implements Sensor { + + @Override + public void describe(SensorDescriptor descriptor) { + } + + @Override + public void execute(SensorContext context) { + } + + } + + class PreSensorSubclass extends PreSensor { + + } + + @Phase(name = Phase.Name.POST) + class PostSensor implements Sensor { + + @Override + public void describe(SensorDescriptor descriptor) { + } + + @Override + public void execute(SensorContext context) { + } + + } + + class PostSensorSubclass extends PostSensor { + + } + +} diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/mediumtest/fs/FileSystemMediumTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/mediumtest/fs/FileSystemMediumTest.java index bcc778dc724..6c2f47ff34c 100644 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/mediumtest/fs/FileSystemMediumTest.java +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/mediumtest/fs/FileSystemMediumTest.java @@ -574,7 +574,7 @@ public class FileSystemMediumTest { assertThat(fileB).isNull(); assertThat(logTester.logs(LoggerLevel.WARN)) - .contains("File 'moduleB/src/sample.xoo' was excluded because patterns are still evaluated using module relative paths but this is deprecated. " + + .contains("File 'moduleA/src/sample.xoo' was excluded because patterns are still evaluated using module relative paths but this is deprecated. " + "Please update file inclusion/exclusion configuration so that patterns refer to project relative paths."); } diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/ModuleCoverageExclusionsTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/ModuleCoverageExclusionsTest.java index 6d95e2ff828..6be5efa45a9 100644 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/ModuleCoverageExclusionsTest.java +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/ModuleCoverageExclusionsTest.java @@ -20,11 +20,15 @@ package org.sonar.scanner.phases; import java.io.File; +import java.util.Arrays; +import java.util.stream.Collectors; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; +import org.sonar.api.batch.bootstrap.ProjectDefinition; import org.sonar.api.batch.fs.internal.DefaultInputFile; +import org.sonar.api.batch.fs.internal.DefaultInputModule; import org.sonar.api.batch.fs.internal.TestInputFileBuilder; import org.sonar.scanner.scan.ModuleConfiguration; @@ -63,9 +67,12 @@ public class ModuleCoverageExclusionsTest { assertThat(coverageExclusions.isExcluded(file)).isFalse(); } - private ModuleConfiguration mockConfig(String... values) { + private DefaultInputModule mockConfig(String... values) { ModuleConfiguration config = mock(ModuleConfiguration.class); when(config.getStringArray("sonar.coverage.exclusions")).thenReturn(values); - return config; + return new DefaultInputModule(ProjectDefinition.create() + .setBaseDir(baseDir) + .setWorkDir(baseDir) + .setProperty("sonar.coverage.exclusions", Arrays.asList(values).stream().collect(Collectors.joining(",")))); } } diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/PostJobsExecutorTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/PostJobsExecutorTest.java index f4a8ed15f92..92e7bc2a8ce 100644 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/PostJobsExecutorTest.java +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/PostJobsExecutorTest.java @@ -22,8 +22,9 @@ package org.sonar.scanner.phases; import java.util.Arrays; import org.junit.Before; import org.junit.Test; -import org.sonar.scanner.bootstrap.ScannerExtensionDictionnary; +import org.sonar.scanner.bootstrap.PostJobExtensionDictionnary; import org.sonar.scanner.postjob.PostJobWrapper; +import org.sonar.scanner.postjob.PostJobsExecutor; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -33,7 +34,7 @@ import static org.mockito.Mockito.when; public class PostJobsExecutorTest { private PostJobsExecutor executor; - private ScannerExtensionDictionnary selector = mock(ScannerExtensionDictionnary.class); + private PostJobExtensionDictionnary selector = mock(PostJobExtensionDictionnary.class); private PostJobWrapper job1 = mock(PostJobWrapper.class); private PostJobWrapper job2 = mock(PostJobWrapper.class); diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/SensorsExecutorTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/SensorsExecutorTest.java index ca97a46a6fc..de31e20e3c3 100644 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/SensorsExecutorTest.java +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/phases/SensorsExecutorTest.java @@ -31,7 +31,7 @@ import org.sonar.api.batch.fs.internal.InputModuleHierarchy; import org.sonar.api.batch.fs.internal.SensorStrategy; import org.sonar.api.batch.fs.internal.TestInputFileBuilder; import org.sonar.api.batch.sensor.Sensor; -import org.sonar.scanner.bootstrap.ScannerExtensionDictionnary; +import org.sonar.scanner.bootstrap.SensorExtensionDictionnary; import org.sonar.scanner.bootstrap.ScannerPluginRepository; import org.sonar.scanner.sensor.SensorWrapper; @@ -64,7 +64,7 @@ public class SensorsExecutorTest { when(globalSensor.shouldExecute()).thenReturn(true); when(globalSensor.wrappedSensor()).thenReturn(mock(Sensor.class)); - ScannerExtensionDictionnary selector = mock(ScannerExtensionDictionnary.class); + SensorExtensionDictionnary selector = mock(SensorExtensionDictionnary.class); when(selector.selectSensors(false)).thenReturn(Collections.singleton(perModuleSensor)); when(selector.selectSensors(true)).thenReturn(Collections.singleton(globalSensor)); diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/InputComponentStoreTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/InputComponentStoreTest.java index ee736b0578f..98785e06e62 100644 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/InputComponentStoreTest.java +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/InputComponentStoreTest.java @@ -84,8 +84,8 @@ public class InputComponentStoreTest { assertThat(store.filesByModule(rootModuleKey)).hasSize(1); assertThat(store.filesByModule(subModuleKey)).hasSize(1); - assertThat(store.allFiles()).hasSize(2); - for (InputPath inputPath : store.allFiles()) { + assertThat(store.inputFiles()).hasSize(2); + for (InputPath inputPath : store.inputFiles()) { assertThat(inputPath.relativePath()).startsWith("src/main/java/"); } @@ -118,9 +118,9 @@ public class InputComponentStoreTest { String mod2Key = "mod2"; tester.addFile(mod2Key, "src/main/groovy/Foo.groovy", "groovy"); - assertThat(tester.getLanguages(mod1Key)).containsExactly("java"); - assertThat(tester.getLanguages(mod2Key)).containsExactly("groovy"); - assertThat(tester.getLanguages()).containsExactlyInAnyOrder("java", "groovy"); + assertThat(tester.languages(mod1Key)).containsExactly("java"); + assertThat(tester.languages(mod2Key)).containsExactly("groovy"); + assertThat(tester.languages()).containsExactlyInAnyOrder("java", "groovy"); } @Test @@ -135,6 +135,6 @@ public class InputComponentStoreTest { assertThat(tester.filesByModule(mod1Key)).containsExactly(mod1File); assertThat(tester.filesByModule(mod2Key)).containsExactly(mod2File); - assertThat(tester.allFiles()).containsExactlyInAnyOrder(mod1File, mod2File); + assertThat(tester.inputFiles()).containsExactlyInAnyOrder(mod1File, mod2File); } } diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/ModuleInputComponentStoreTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/ModuleInputComponentStoreTest.java index cb1b4793940..29064edd51b 100644 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/ModuleInputComponentStoreTest.java +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/filesystem/ModuleInputComponentStoreTest.java @@ -127,6 +127,8 @@ public class ModuleInputComponentStoreTest { when(module.key()).thenReturn("foo"); ModuleInputComponentStore store = new ModuleInputComponentStore(module, inputComponentStore, strategy); + strategy.setGlobal(false); + store.inputFiles(); verify(inputComponentStore).filesByModule("foo"); @@ -135,7 +137,7 @@ public class ModuleInputComponentStoreTest { verify(inputComponentStore).getFile(any(String.class), eq(relativePath)); store.languages(); - verify(inputComponentStore).getLanguages(any(String.class)); + verify(inputComponentStore).languages(any(String.class)); } @Test @@ -147,13 +149,13 @@ public class ModuleInputComponentStoreTest { strategy.setGlobal(true); store.inputFiles(); - verify(inputComponentStore).allFiles(); + verify(inputComponentStore).inputFiles(); String relativePath = "somepath"; store.inputFile(relativePath); - verify(inputComponentStore).getFile(relativePath); + verify(inputComponentStore).inputFile(relativePath); store.languages(); - verify(inputComponentStore).getLanguages(); + verify(inputComponentStore).languages(); } } -- cgit v1.2.3