Merge pull request #30 from jqassistant-plugin/29_fix_combination_con…

…traint #29 Refactor: Fix jee-injection:NoCombinationOfBeanProducersAndApplicationCode
jqassistant-plugin · Feb 20, 2025 · b7e2425 · b7e2425
2 parents 3e22a87 + 5af8a1f
commit b7e2425
Show file tree

Hide file tree

Showing 4 changed files with 57 additions and 43 deletions.
diff --git a/src/main/resources/META-INF/jqassistant-rules/injection/jee-injection.xml b/src/main/resources/META-INF/jqassistant-rules/injection/jee-injection.xml
@@ -236,6 +236,7 @@
               (t)-[:DECLARES]->(otherPublicMethod:Method {visibility: "public"})
             WHERE
               NOT otherPublicMethod:BeanProducer
+              AND NOT otherPublicMethod:Constructor
             RETURN DISTINCT
               t AS `Java-Klasse`
         ]]></cypher>

diff --git a/src/test/java/org/jqassistant/plugin/jee/injection/test/InjectionIT.java b/src/test/java/org/jqassistant/plugin/jee/injection/test/InjectionIT.java
@@ -14,26 +14,23 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import static com.buschmais.jqassistant.core.report.api.model.Result.Status.FAILURE;
 import static com.buschmais.jqassistant.core.report.api.model.Result.Status.SUCCESS;
 import static com.buschmais.jqassistant.core.test.matcher.ConstraintMatcher.constraint;
 import static com.buschmais.jqassistant.core.test.matcher.ResultMatcher.result;
 import static org.hamcrest.CoreMatchers.endsWith;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.hasSize;
 
 public class InjectionIT extends AbstractJavaPluginIT {
 
     /**
      * Verifies the concept "jee-injection:InjectionPoint".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void injectionPointIdentification() throws Exception {
-        scanClasses(BeanProducer.class);
+        scanClasses(BeanProducerWithConstraintViolations.class);
         Result<Concept> conceptResult = applyConcept("jee-injection:InjectionPoint");
         store.beginTransaction();
         assertThat(conceptResult.getStatus(), equalTo(Result.Status.SUCCESS));
@@ -47,30 +44,28 @@ void injectionPointIdentification() throws Exception {
     /**
      * Verifies the constraint "jee-injection:BeanProducerMustNotBeInvokedDirectly".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void beanProducerAccess() throws Exception {
-        scanClasses(BeanProducer.class);
+        scanClasses(BeanProducerWithConstraintViolations.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:BeanProducerMustNotBeInvokedDirectly");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
         assertThat(constraintResult.getRows().size(), equalTo(1));
-        assertThat(constraintResult.getRows().get(0).getColumns().get("Type").getLabel(), endsWith("test.set.BeanProducer"));
+        assertThat(constraintResult.getRows().get(0).getColumns().get("Type").getLabel(), endsWith("test.set.BeanProducerWithConstraintViolations"));
         assertThat(constraintResult.getRows().get(0).getColumns().get("Invocation").getLabel(), endsWith("void beanProducerAccessor()"));
         store.commitTransaction();
     }
 
     /**
      * Verifies the constraint "jee-injection:FieldsOfInjectablesMustNotBeManipulated".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void injectableFieldManipulation() throws Exception {
-        scanClasses(BeanProducer.class, InjectableA.class, InjectableB.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, InjectableA.class, InjectableB.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:FieldsOfInjectablesMustNotBeManipulated");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -87,12 +82,11 @@ void injectableFieldManipulation() throws Exception {
     /**
      * Verifies the constraint "jee-injection:InjectablesShouldBeHeldInFinalFields".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void finalFieldsForInjectables() throws Exception {
-        scanClasses(BeanProducer.class, InjectableA.class, InjectableB.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, InjectableA.class, InjectableB.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:InjectablesShouldBeHeldInFinalFields");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -107,12 +101,11 @@ void finalFieldsForInjectables() throws Exception {
     /**
      * Verifies the constraint "jee-injection:InjectablesMustNotBeAccessedStatically".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void staticAccessOfInjectables() throws Exception {
-        scanClasses(BeanProducer.class, InjectableA.class, InjectableB.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, InjectableA.class, InjectableB.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:InjectablesMustNotBeAccessedStatically");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -126,12 +119,11 @@ void staticAccessOfInjectables() throws Exception {
     /**
      * Verifies the constraint "jee-injection:InjectablesMustNotBeHeldInStaticVariables".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void staticVariablesForInjectables() throws Exception {
-        scanClasses(BeanProducer.class, InjectableA.class, InjectableB.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, InjectableA.class, InjectableB.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:InjectablesMustNotBeHeldInStaticVariables");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -144,12 +136,11 @@ void staticVariablesForInjectables() throws Exception {
     /**
      * Verifies the constraint "jee-injection:InjectablesMustNotBeInstantiated".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void injectableInstantiation() throws Exception {
-        scanClasses(BeanProducer.class, InjectableA.class, InjectableB.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, InjectableA.class, InjectableB.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:InjectablesMustNotBeInstantiated");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -163,12 +154,11 @@ void injectableInstantiation() throws Exception {
     /**
      * Verifies the constraint "jee-injection:InjectablesMustOnlyBeHeldInInjectables".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void injectableOfNonInjectable() throws Exception {
-        scanClasses(BeanProducer.class, InjectableA.class, NonInjectableType.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, InjectableA.class, NonInjectableType.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:InjectablesMustOnlyBeHeldInInjectables");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -181,12 +171,11 @@ void injectableOfNonInjectable() throws Exception {
     /**
      * Verifies the constraint "jee-injection:JdkClassesMustNotBeInjectables".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void jdkClassesAsInjectables() throws Exception {
-        scanClasses(BeanProducer.class);
+        scanClasses(BeanProducerWithConstraintViolations.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:JdkClassesMustNotBeInjectables");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
@@ -196,36 +185,49 @@ void jdkClassesAsInjectables() throws Exception {
     }
 
     /**
-     * Verifies the constraint "jee-injection:NoCombinationOfBeanProducersAndApplicationCode".
+     * Verifies the constraint "jee-injection:NoCombinationOfBeanProducersAndApplicationCode" with a test class with violations.
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
-    void combinationOfBeanProducersAndApplicationCode() throws Exception {
-        scanClasses(BeanProducer.class);
+    void combinationOfBeanProducersAndApplicationCodeWithViolation() throws Exception {
+        scanClasses(BeanProducerWithConstraintViolations.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:NoCombinationOfBeanProducersAndApplicationCode");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
         assertThat(constraintResult.getRows().size(), equalTo(1));
-        assertThat(constraintResult.getRows().get(0).getColumns().get("Java-Klasse").getLabel(), endsWith("test.set.BeanProducer"));
+        assertThat(constraintResult.getRows().get(0).getColumns().get("Java-Klasse").getLabel(), endsWith("test.set.BeanProducerWithConstraintViolations"));
+        store.commitTransaction();
+    }
+
+    /**
+     * Verifies the constraint "jee-injection:NoCombinationOfBeanProducersAndApplicationCode" with a test class without violations.
+     *
+     * @throws IOException If the test fails.
+     */
+    @Test
+    void combinationOfBeanProducersAndApplicationCodeWithoutViolation() throws Exception {
+        scanClasses(BeanProducerWithoutConstraintViolations.class);
+        Result<Constraint> constraintResult = validateConstraint("jee-injection:NoCombinationOfBeanProducersAndApplicationCode");
+        store.beginTransaction();
+        assertThat(constraintResult.getStatus(), equalTo(SUCCESS));
+        assertThat(constraintResult.getRows().size(), equalTo(0));
         store.commitTransaction();
     }
 
     /**
      * Verifies the constraint "jee-injection:BeansMustNotUseFieldInjectionExceptEJBs".
      *
-     * @throws IOException
-     *             If the test fails.
+     * @throws IOException If the test fails.
      */
     @Test
     void fieldInjectionWithEjb_Violation() throws Exception {
-        scanClasses(BeanProducer.class, LocalEjb.class);
+        scanClasses(BeanProducerWithConstraintViolations.class, LocalEjb.class);
         Result<Constraint> constraintResult = validateConstraint("jee-injection:BeansMustNotUseFieldInjectionExceptEJBs");
         store.beginTransaction();
         assertThat(constraintResult.getStatus(), equalTo(Result.Status.FAILURE));
         assertThat(constraintResult.getRows().size(), equalTo(1));
-        assertThat(constraintResult.getRows().get(0).getColumns().get("Type").getLabel(), endsWith("test.set.BeanProducer"));
+        assertThat(constraintResult.getRows().get(0).getColumns().get("Type").getLabel(), endsWith("test.set.BeanProducerWithConstraintViolations"));
         assertThat(constraintResult.getRows().get(0).getColumns().get("Field").getLabel(), endsWith("Object injectionPointField"));
         store.commitTransaction();
     }
@@ -234,8 +236,7 @@ void fieldInjectionWithEjb_Violation() throws Exception {
      * Verifies the constraint "jee-injection:BeansMustNotUseFieldInjectionExceptEJBs" results in no
      * violations when applied to beans with setter or constructor injection.
      *
-     * @throws java.io.IOException
-     *             If the test fails.
+     * @throws java.io.IOException If the test fails.
      */
     @Test
     void fieldInjectionWithEjb_No_Violation() throws Exception {

diff --git a/.../jee/injection/test/set/BeanProducer.java → ...BeanProducerWithConstraintViolations.java b/.../jee/injection/test/set/BeanProducer.java → ...BeanProducerWithConstraintViolations.java
@@ -3,7 +3,7 @@
 import javax.enterprise.inject.Produces;
 import javax.inject.Inject;
 
-public class BeanProducer {
+public class BeanProducerWithConstraintViolations {
 
     @Inject
     private Object injectionPointField;

diff --git a/...rg/jqassistant/plugin/jee/injection/test/set/BeanProducerWithoutConstraintViolations.java b/...rg/jqassistant/plugin/jee/injection/test/set/BeanProducerWithoutConstraintViolations.java
@@ -0,0 +1,12 @@
+package org.jqassistant.plugin.jee.injection.test.set;
+
+import javax.enterprise.inject.Produces;
+
+public class BeanProducerWithoutConstraintViolations {
+
+    @Produces
+    public InjectableA beanProducerA(){
+        return new InjectableA();
+    }
+
+}