fix bug where main source set code is not on compile classpath of archRulesTest

Author: wakingrufus

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

@@ -17,9 +17,16 @@ import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.jvm.component.internal.JvmSoftwareComponentInternal
-import org.gradle.kotlin.dsl.*
+import org.gradle.kotlin.dsl.add
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.invoke
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
 import org.gradle.kotlin.dsl.support.serviceOf
+import org.gradle.kotlin.dsl.withType
 import org.gradle.testing.base.TestingExtension
+import kotlin.collections.mapOf
 
 class ArchrulesLibraryPlugin : Plugin<Project> {
 
@@ -75,6 +82,7 @@ class ArchrulesLibraryPlugin : Plugin<Project> {
                     register("archRulesTest", JvmTestSuite::class.java) {
                         useJUnitJupiter()
                         dependencies {
+                            implementation(project())
                             implementation(archRulesSourceSet.output)
                             implementation("com.netflix.nebula:nebula-archrules-core:$version")
                         }

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

@@ -61,6 +61,7 @@ class ArchrulesLibraryPluginTest {
         }
 
         val result = runner.run(
+            "--stacktrace",
             "build",
             "archRulesJar",
             "generateMetadataFileForMavenPublication", // to test publication metadata without actually publishing,
@@ -280,4 +281,54 @@ class ArchrulesLibraryPluginTest {
             .hasNoMutableStateWarnings()
             .hasNoDeprecationWarnings()
     }
+
+    @Test
+    fun `main code is included in archRulesTest`() {
+        val runner = testProject(projectDir) {
+            properties {
+                gradleCache(true)
+            }
+            settings {
+                name("library-with-rules")
+            }
+            rootProject {
+                group("com.example")
+                // a library that contains production code and rules to go along with it
+                plugins {
+                    id("java-library")
+                    id("com.netflix.nebula.archrules.library")
+                    id("maven-publish")
+                }
+                repositories {
+                    maven("https://netflixoss.jfrog.io/artifactory/gradle-plugins")
+                    mavenCentral()
+                }
+                declareMavenPublication()
+                dependencies("""implementation("com.google.guava:guava:33.5.0-jre")""")
+                src {
+                    main {
+                        dontUseAnnotation()
+                    }
+
+                    sourceSet("archRules") {
+                        dontUseRule()
+                    }
+                    sourceSet("archRulesTest") {
+                        testForDontUseRule()
+                    }
+                }
+            }
+        }
+
+        val result = runner.run(
+            "build",
+            "archRulesJar",
+            "generateMetadataFileForMavenPublication", // to test publication metadata without actually publishing,
+            "-Pversion=0.0.1"
+        )
+
+        assertThat(result)
+            .hasNoMutableStateWarnings()
+            .hasNoDeprecationWarnings()
+    }
 }

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

@@ -37,6 +37,24 @@ public class LibraryClass {
     )
 }
 
+fun SourceSetBuilder.dontUseAnnotation() {
+    java(
+        "com/example/library/DontUse.java",
+        //language=java
+        """
+package com.example.library;
+
+import java.lang.annotation.*;
+import static java.lang.annotation.ElementType.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
+public @interface DontUse {
+}
+"""
+    )
+}
+
 fun SourceSetBuilder.exampleHelperClass() {
     java(
         "com/example/library/HaveNoTests.java",
@@ -97,6 +115,41 @@ public class LibraryArchRules implements ArchRulesService {
     )
 }
 
+fun SourceSetBuilder.dontUseRule() {
+    java(
+        "com/example/library/DontUseArchRules.java",
+        //language=java
+        """
+package com.example.library;
+
+import com.netflix.nebula.archrules.core.ArchRulesService;
+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.core.domain.JavaAccess.Predicates.target;
+import static com.tngtech.archunit.core.domain.JavaAccess.Predicates.targetOwner;
+import static com.tngtech.archunit.core.domain.properties.CanBeAnnotated.Predicates.annotatedWith;
+
+public class DontUseArchRules implements ArchRulesService {
+    public static final ArchRule noDontUse = ArchRuleDefinition.priority(Priority.LOW)
+            .noClasses()
+            .should().accessTargetWhere(targetOwner(annotatedWith("com.example.library.DontUse")))
+            .orShould().accessTargetWhere(target(annotatedWith("com.example.library.DontUse")))
+            .orShould().dependOnClassesThat().areAnnotatedWith("com.example.library.DontUse")
+            .allowEmptyShould(true)
+            .as("No code should reference dontuse APIs")
+            .because("usage of dontuse APIs introduces risk that future upgrades and migrations will be blocked");
+            
+    @Override
+    public Map<String, ArchRule> getRules() {
+        return Map.of("dont use", noDontUse);
+    }
+}
+"""
+    )
+}
+
 fun SourceSetBuilder.exampleNullabilityArchRule() {
     java(
         "com/example/library/NullabilityArchRules.java",
@@ -196,6 +249,50 @@ public class LibraryArchRulesTest {
     )
 }
 
+fun SourceSetBuilder.testForDontUseRule() {
+    java(
+        "com/example/library/DontUseArchRulesTest.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 DontUseArchRulesTest {
+    @DontUse
+    static void deprecatedMethod(){
+    }
+    static class PassingCode {
+        public void aMethod() {
+        }
+    }     
+    static class FailingCode {
+        public void aMethod() {
+            deprecatedMethod();
+        }
+    }
+    
+    @Test
+    public void test_pass() {
+        EvaluationResult result = Runner.check(DontUseArchRules.noDontUse, PassingCode.class);
+        Assertions.assertFalse(result.hasViolation());
+    }
+        
+    @Test
+    public void test_fail() {
+        EvaluationResult result = Runner.check(DontUseArchRules.noDontUse, FailingCode.class);
+        Assertions.assertTrue(result.hasViolation());
+    }
+}
+"""
+    )
+}
+
 fun SourceSetBuilder.exampleTestForNullabilityArchRule() {
     java("com/example/library/FailingCode.java",
         //language=java