add ArchRulesService interface

nebula-archrules-core/src/main/java/com/netflix/nebula/archrules/core/ArchRulesService.java

@@ -0,0 +1,20 @@
+package com.netflix.nebula.archrules.core;
+
+import com.tngtech.archunit.lang.ArchRule;
+
+import java.util.Map;
+
+/**
+ * Interface used to make ArchRules automatically discoverable.
+ * Implementations should be declared as a {@link java.util.ServiceLoader} service.
+ */
+public interface ArchRulesService {
+    /**
+     * An ArchRulesService implementation will produce a map of rules to be discovered for evaluation.
+     * The map keys are the IDs of the rules,
+     * which will be used as display names in reporting and for additional configuration in the Gradle plugin.
+     *
+     * @return the rules to evaluate
+     */
+    Map<String, ArchRule> getRules();
+}

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

@@ -1,14 +1,65 @@
 package com.netflix.nebula.archrules.gradle
 
+import nebula.test.dsl.*
+import nebula.test.dsl.TestKitAssertions.assertThat
+import org.gradle.testkit.runner.TaskOutcome
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.io.TempDir
 import java.io.File
 
 internal class IntegrationTest {
     @TempDir
-    lateinit var testProjectDir: File
+    lateinit var projectDir: File
+
     @Test
-    fun test(){
+    fun test() {
+        val runner = testProject(projectDir) {
+            subProject("library-with-rules") {
+                // a library that contains production code and rules to go along with it
+                plugins {
+                    id("java-library")
+                    id("com.netflix.nebula.archrules.library")
+                }
+                src {
+                    main {
+                        java(
+                            "com/example/library/LibraryClass.java",
+                            //language=java
+                            """
+package com.example.library;
+
+public class LibraryClass {
+
+}
+                        """
+                        )
+                    }
+                }
+            }
+            subProject("code-to-check") {
+                // a project which consumes libraries which should have the rules evaluated against it
+                plugins {
+                    id("java")
+                    id("com.netflix.nebula.archrules.runner")
+                }
+                dependencies(
+                    """implementation(project(":library-with-rules"))"""
+                )
+            }
+        }
+
+        val result = runner.run("check")
+
+        assertThat(result.task(":library-with-rules:check"))
+            .hasOutcome(TaskOutcome.SUCCESS, TaskOutcome.UP_TO_DATE)
+        assertThat(result.task(":code-to-check:check"))
+            .hasOutcome(TaskOutcome.SUCCESS, TaskOutcome.UP_TO_DATE)
+        assertThat(result)
+            .hasNoMutableStateWarnings()
+            .hasNoDeprecationWarnings()
 
+        assertThat(projectDir.resolve("library-with-rules/build/libs/library-with-rules.jar"))
+            .`as`("Library Jar is created")
+            .exists()
     }
 }