SONAR-3823 Don't activate Cobertura extensions on non-Java projects

diff --git a/plugins/sonar-cobertura-plugin/pom.xml b/plugins/sonar-cobertura-plugin/pom.xml
index 3a3aba347b11358c79b991e0bbdb398133fbe0d5..ac9b4cbb7a3e3bc9dfbd7ca81348b39c73767b9c 100644 (file)
--- a/plugins/sonar-cobertura-plugin/pom.xml
+++ b/plugins/sonar-cobertura-plugin/pom.xml
@@ -33,6 +33,11 @@
       <artifactId>sonar-testing-harness</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.easytesting</groupId>
+      <artifactId>fest-assert</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>

diff --git a/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaMavenInitializer.java b/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaMavenInitializer.java
index d2b1c2298c029c0b94520f3cd4405da3647dbb54..4aac7eabe3c11438fd1e13dcb6b34a3ef49d4a06 100644 (file)
--- a/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaMavenInitializer.java
+++ b/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaMavenInitializer.java
@@ -51,8 +51,9 @@ public class CoberturaMavenInitializer extends Initializer implements CoverageEx
 
   @Override
   public boolean shouldExecuteOnProject(Project project) {
-    return project.getAnalysisType().isDynamic(true) &&
-        !project.getFileSystem().mainFiles(Java.KEY).isEmpty();
+    return Java.KEY.equals(project.getLanguageKey())
+      && !project.getFileSystem().mainFiles(Java.KEY).isEmpty()
+      && project.getAnalysisType().isDynamic(true);
   }
 
   @Override

diff --git a/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaSensor.java b/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaSensor.java
index 31ce963af740401679c015626e5a241e06feb5c0..e2dd02c0d018f5fac05b5aecb9f1cc405734a2b4 100644 (file)
--- a/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaSensor.java
+++ b/plugins/sonar-cobertura-plugin/src/main/java/org/sonar/plugins/cobertura/CoberturaSensor.java
@@ -35,7 +35,9 @@ import java.io.File;
 public class CoberturaSensor implements Sensor, CoverageExtension {
 
   public boolean shouldExecuteOnProject(Project project) {
-    return Java.KEY.equals(project.getLanguageKey()) && project.getAnalysisType().isDynamic(true);
+    return Java.KEY.equals(project.getLanguageKey())
+      && !project.getFileSystem().mainFiles(Java.KEY).isEmpty()
+      && project.getAnalysisType().isDynamic(true);
   }
 
   public void analyse(Project project, SensorContext context) {

diff --git a/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaMavenInitializerTest.java b/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaMavenInitializerTest.java
index 823e48a4791a20cc5c5487c166a74c825acdc7c1..a16e3a5eb407eb8f99d2b179cb693c6e6b684b1e 100644 (file)
--- a/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaMavenInitializerTest.java
+++ b/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaMavenInitializerTest.java
@@ -19,27 +19,32 @@
  */
 package org.sonar.plugins.cobertura;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.core.IsNot.not;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
+import com.google.common.collect.Lists;
 import org.apache.commons.configuration.Configuration;
 import org.apache.maven.project.MavenProject;
 import org.junit.Before;
 import org.junit.Test;
 import org.sonar.api.CoreProperties;
+import org.sonar.api.resources.InputFile;
+import org.sonar.api.resources.InputFileUtils;
 import org.sonar.api.resources.Project;
 import org.sonar.api.resources.ProjectFileSystem;
 import org.sonar.api.test.MavenTestUtils;
 
 import java.io.File;
+import java.util.ArrayList;
+
+import static org.fest.assertions.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class CoberturaMavenInitializerTest {
 
@@ -52,6 +57,56 @@ public class CoberturaMavenInitializerTest {
     initializer = new CoberturaMavenInitializer(new CoberturaMavenPluginHandler(null));
   }
 
+  @Test
+  public void shouldNotAnalyseIfNoJavaProject() {
+    Project project = mock(Project.class);
+    when(project.getLanguageKey()).thenReturn("php");
+    assertThat(initializer.shouldExecuteOnProject(project)).isFalse();
+  }
+
+  @Test
+  public void shouldNotAnalyseIfJavaProjectButNoSource() {
+    Project project = mock(Project.class);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(new ArrayList<InputFile>());
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
+    assertThat(initializer.shouldExecuteOnProject(project)).isFalse();
+  }
+
+  @Test
+  public void shouldNotAnalyseIfJavaProjectWithSourceButStatic() {
+    Project project = mock(Project.class);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(Lists.newArrayList(InputFileUtils.create(null, "")));
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
+    when(project.getAnalysisType()).thenReturn(Project.AnalysisType.STATIC);
+    assertThat(initializer.shouldExecuteOnProject(project)).isFalse();
+  }
+
+  @Test
+  public void shouldAnalyse() {
+    Project project = mock(Project.class);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(Lists.newArrayList(InputFileUtils.create(null, "")));
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
+    when(project.getAnalysisType()).thenReturn(Project.AnalysisType.DYNAMIC);
+    assertThat(initializer.shouldExecuteOnProject(project)).isTrue();
+  }
+
+  @Test
+  public void shouldAnalyseIfReuseDynamicReports() {
+    Project project = mock(Project.class);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(Lists.newArrayList(InputFileUtils.create(null, "")));
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
+    when(project.getAnalysisType()).thenReturn(Project.AnalysisType.REUSE_REPORTS);
+    assertThat(initializer.shouldExecuteOnProject(project)).isTrue();
+  }
+
   @Test
   public void doNotExecuteMavenPluginIfReuseReports() {
     when(project.getAnalysisType()).thenReturn(Project.AnalysisType.REUSE_REPORTS);

diff --git a/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaSensorTest.java b/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaSensorTest.java
index adb06be473ffa1331733b9d74948766ef5fee498..e813dc49d236dd9357b0a935e43bb2f3c95fcb9b 100644 (file)
--- a/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaSensorTest.java
+++ b/plugins/sonar-cobertura-plugin/src/test/java/org/sonar/plugins/cobertura/CoberturaSensorTest.java
@@ -19,13 +19,15 @@
  */
 package org.sonar.plugins.cobertura;
 
+import com.google.common.collect.Lists;
 import org.junit.Before;
 import org.junit.Test;
 import org.sonar.api.CoreProperties;
 import org.sonar.api.batch.SensorContext;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.measures.Measure;
-import org.sonar.api.resources.Java;
+import org.sonar.api.resources.InputFile;
+import org.sonar.api.resources.InputFileUtils;
 import org.sonar.api.resources.JavaFile;
 import org.sonar.api.resources.JavaPackage;
 import org.sonar.api.resources.Project;
@@ -38,10 +40,10 @@ import org.sonar.api.test.IsResource;
 
 import java.io.File;
 import java.net.URISyntaxException;
+import java.util.ArrayList;
 
+import static org.fest.assertions.Assertions.assertThat;
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyDouble;
 import static org.mockito.Matchers.anyString;
@@ -67,24 +69,50 @@ public class CoberturaSensorTest {
   public void shouldNotAnalyseIfNoJavaProject() {
     Project project = mock(Project.class);
     when(project.getLanguageKey()).thenReturn("php");
-    when(project.getAnalysisType()).thenReturn(Project.AnalysisType.DYNAMIC);
-    assertFalse(sensor.shouldExecuteOnProject(project));
+    assertThat(sensor.shouldExecuteOnProject(project)).isFalse();
+  }
+
+  @Test
+  public void shouldNotAnalyseIfJavaProjectButNoSource() {
+    Project project = mock(Project.class);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(new ArrayList<InputFile>());
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
+    assertThat(sensor.shouldExecuteOnProject(project)).isFalse();
   }
 
   @Test
-  public void shouldNotAnalyseIfStaticAnalysis() {
+  public void shouldNotAnalyseIfJavaProjectWithSourceButStatic() {
     Project project = mock(Project.class);
-    when(project.getLanguageKey()).thenReturn(Java.KEY);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(Lists.newArrayList(InputFileUtils.create(null, "")));
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
     when(project.getAnalysisType()).thenReturn(Project.AnalysisType.STATIC);
-    assertFalse(sensor.shouldExecuteOnProject(project));
+    assertThat(sensor.shouldExecuteOnProject(project)).isFalse();
+  }
+
+  @Test
+  public void shouldAnalyse() {
+    Project project = mock(Project.class);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(Lists.newArrayList(InputFileUtils.create(null, "")));
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
+    when(project.getAnalysisType()).thenReturn(Project.AnalysisType.DYNAMIC);
+    assertThat(sensor.shouldExecuteOnProject(project)).isTrue();
   }
 
   @Test
   public void shouldAnalyseIfReuseDynamicReports() {
     Project project = mock(Project.class);
-    when(project.getLanguageKey()).thenReturn(Java.KEY);
+    ProjectFileSystem fs = mock(ProjectFileSystem.class);
+    when(fs.mainFiles("java")).thenReturn(Lists.newArrayList(InputFileUtils.create(null, "")));
+    when(project.getFileSystem()).thenReturn(fs);
+    when(project.getLanguageKey()).thenReturn("java");
     when(project.getAnalysisType()).thenReturn(Project.AnalysisType.REUSE_REPORTS);
-    assertThat(sensor.shouldExecuteOnProject(project), is(true));
+    assertThat(sensor.shouldExecuteOnProject(project)).isTrue();
   }
 
   @Test