archRulesTest compile and runtime classpaths should include all dependencies from archRules source set

fixes #26

Author: wakingrufus

nebula-archrules-gradle-plugin/src/main/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesLibraryPlugin.kt

@@ -62,7 +62,7 @@ class ArchrulesLibraryPlugin : Plugin<Project> {
                         useJUnitJupiter()
                         dependencies {
                             implementation(project())
-                            implementation(archRulesSourceSet.output)
+                            implementation(archRulesSourceSet.runtimeClasspath)
                             implementation("com.netflix.nebula:nebula-archrules-core:$version")
                         }
                         javaExt.sourceSets.named("archRulesTest").configure {

nebula-archrules-gradle-plugin/src/test/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesLibraryPluginTest.kt

@@ -198,4 +198,67 @@ class ArchrulesLibraryPluginTest {
             .hasNoMutableStateWarnings()
             .hasNoDeprecationWarnings()
     }
+
+    @Test
+    fun `plugin sets up tests for rules with dependencies`() {
+        val runner = testProject(projectDir) {
+            properties {
+                gradleCache(true)
+            }
+            settings {
+                name("library-with-rules")
+            }
+            subProject("rules") {
+                group("com.example")
+                plugins {
+                    id("java-library")
+                    id("com.netflix.nebula.archrules.library")
+                }
+                repositories {
+                    maven("https://netflixoss.jfrog.io/artifactory/gradle-plugins")
+                    mavenCentral()
+                }
+                dependencies(
+                    """archRulesImplementation(project(":helper"))""",
+                    """archRulesTestImplementation("org.jspecify:jspecify:1.0.0")"""
+                )
+                src {
+                    main {
+                        exampleLibraryClass()
+                    }
+                    sourceSet("archRules") {
+                        exampleNullabilityArchRule() // rules that uses a helper from a dependency
+                    }
+                    sourceSet("archRulesTest") {
+                        exampleTestForNullabilityArchRule()
+                    }
+                }
+            }
+            subProject("helper") {
+                group("com.example")
+                plugins {
+                    id("java-library")
+                }
+                repositories {
+                    maven("https://netflixoss.jfrog.io/artifactory/gradle-plugins")
+                    mavenCentral()
+                }
+                dependencies("""implementation("com.tngtech.archunit:archunit:1.4.1")""")
+                src {
+                    main {
+                        exampleHelperClass()
+                    }
+                }
+            }
+        }
+
+        val result = runner.run("check", "--stacktrace")
+
+        assertThat(result.task(":rules:archRulesTest"))
+            .`as`("archRules test task runs")
+            .hasOutcome(TaskOutcome.SUCCESS, TaskOutcome.FROM_CACHE)
+        assertThat(result)
+            .hasNoMutableStateWarnings()
+            .hasNoDeprecationWarnings()
+    }
 }

nebula-archrules-gradle-plugin/src/test/kotlin/com/netflix/nebula/archrules/gradle/TestKitDslExtensions.kt

@@ -37,6 +37,31 @@ public class LibraryClass {
     )
 }
 
+fun SourceSetBuilder.exampleHelperClass() {
+    java(
+        "com/example/library/HaveNoTests.java",
+        //language=java
+        """
+package com.example.library;
+                            
+import com.tngtech.archunit.base.DescribedPredicate;
+import com.tngtech.archunit.core.domain.JavaClass;
+
+public class HaveNoTests extends DescribedPredicate<JavaClass> {
+    public HaveNoTests() {
+        super("have no tests");
+    }
+
+    @Override
+    public boolean test(JavaClass javaClass) {
+        return javaClass.getMembers().stream()
+                .noneMatch(it -> it.isAnnotatedWith("org.junit.jupiter.api.Test"));
+    }
+}
+"""
+    )
+}
+
 fun SourceSetBuilder.exampleDeprecatedArchRule() {
     java(
         "com/example/library/LibraryArchRules.java",
@@ -72,6 +97,43 @@ public class LibraryArchRules implements ArchRulesService {
     )
 }
 
+fun SourceSetBuilder.exampleNullabilityArchRule() {
+    java(
+        "com/example/library/NullabilityArchRules.java",
+        //language=java
+        """
+package com.example.library;
+
+import com.netflix.nebula.archrules.core.ArchRulesService;
+import com.tngtech.archunit.core.domain.JavaModifier;
+import com.tngtech.archunit.core.domain.properties.HasModifiers;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.Priority;
+import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
+import java.util.Map;
+import static com.tngtech.archunit.lang.conditions.ArchConditions.fullyQualifiedName;
+
+public class NullabilityArchRules implements ArchRulesService {
+    public static final ArchRule PUBLIC_CLASSES_SHOULD_BE_NULL_MARKED = ArchRuleDefinition.priority(Priority.MEDIUM)
+            .classes().that()
+            .areTopLevelClasses()
+            .and().arePublic()
+            .and().containAnyMembersThat(HasModifiers.Predicates.modifier(JavaModifier.PUBLIC))
+            .and(new HaveNoTests())
+            .and().areNotAnnotatedWith("kotlin.Metadata")
+            .should().beAnnotatedWith("org.jspecify.annotations.NullMarked")
+            .allowEmptyShould(true)
+            .because("public classes should be null marked");
+            
+    @Override
+    public Map<String, ArchRule> getRules() {
+        return Map.of("public classes should be @NullMarked", PUBLIC_CLASSES_SHOULD_BE_NULL_MARKED);
+    }
+}
+"""
+    )
+}
+
 fun SourceSetBuilder.exampleDeprecatedUsage(className: String = "FailingCode") {
     java(
         "com/example/consumer/$className.java",
@@ -128,6 +190,59 @@ public class LibraryArchRulesTest {
         Assertions.assertTrue(result.hasViolation());
     }
 }
+"""
+    )
+}
+
+fun SourceSetBuilder.exampleTestForNullabilityArchRule() {
+    java("com/example/library/FailingCode.java",
+        //language=java
+        """
+package com.example.library;
+public class FailingCode {
+    public void aMethod() {
+    }
+}
+        """)
+    java("com/example/library/PassingCode.java",
+        //language=java
+        """
+package com.example.library;
+import org.jspecify.annotations.NullMarked;
+@NullMarked
+public class PassingCode {
+    public void aMethod() {
+    }
+}
+        """)
+    java(
+        "com/example/library/NullabilityArchRulesTest.java",
+        //language=java
+        """
+package com.example.library;
+
+import com.netflix.nebula.archrules.core.ArchRulesService;
+import com.netflix.nebula.archrules.core.Runner;
+import com.tngtech.archunit.lang.EvaluationResult;
+import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
+
+public class NullabilityArchRulesTest {
+
+    @Test
+    public void test_pass() {
+        EvaluationResult result = Runner.check(NullabilityArchRules.PUBLIC_CLASSES_SHOULD_BE_NULL_MARKED, PassingCode.class);
+        Assertions.assertFalse(result.hasViolation());
+    }
+        
+    @Test
+    public void test_fail() {
+        EvaluationResult result = Runner.check(NullabilityArchRules.PUBLIC_CLASSES_SHOULD_BE_NULL_MARKED, FailingCode.class);
+        Assertions.assertTrue(result.hasViolation());
+    }
+}
 """
     )
 }