From b90a6acdd4b6e1e418bd56d5ce5a354b8941c28c Mon Sep 17 00:00:00 2001
From: Marc Hermans <marc.hermans@ldtteam.com>
Date: Tue, 14 May 2024 13:57:09 +0200
Subject: [PATCH] Test all conventions and fix bugs.

---
 README.md                                     |   9 +-
 .../gradle/common/CommonProjectPlugin.java    |  27 +-
 .../subsystems/ConventionsExtension.java      |   2 +-
 .../convention/IDEAIDEConventionTests.groovy  | 216 +++++++
 .../convention/RunConventionTests.groovy      | 442 +++++++++++++++
 .../SourceSetConventionTests.groovy           | 529 ++++++++++++++++++
 .../extension/UserDevRuntimeExtension.java    |   9 +-
 7 files changed, 1217 insertions(+), 17 deletions(-)
 create mode 100644 userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/IDEAIDEConventionTests.groovy
 create mode 100644 userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/RunConventionTests.groovy
 create mode 100644 userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/SourceSetConventionTests.groovy

diff --git a/README.md b/README.md
index 9362c9cdb..55db16ba6 100644
--- a/README.md
+++ b/README.md
@@ -248,9 +248,11 @@ Globally the following configurations are added:
 
 #### LocalRuntime (Per SourceSet)
 This configuration is used to add dependencies to your local projects runtime only, without exposing them to the runtime of other projects.
+Requires source set conventions to be enabled
 
 #### LocalRunRuntime (Per SourceSet)
 This configuration is used to add dependencies to the local runtime of the runs you add the SourceSets too, without exposing them to the runtime of other runs.
+Requires source set conventions to be enabled
 
 #### Run (Per Run)
 This configuration is used to add dependencies to the runtime of a specific run only, without exposing them to the runtime of other runs.
@@ -267,14 +269,14 @@ This configuration is used to add dependencies (and their dependencies), straigh
 ### Sourceset Management
 To disable the sourceset management, you can set the following property in your gradle.properties:
 ```properties
-neogradle.subsystems.conventions.sourceset.enabled=false
+neogradle.subsystems.conventions.sourcesets.enabled=false
 ```
 
 #### Automatic inclusion of the current project in its runs
 By default, the current project is automatically included in its runs.
 If you want to disable this, you can set the following property in your gradle.properties:
 ```properties
-neogradle.subsystems.conventions.sourceset.automatic-inclusion=false
+neogradle.subsystems.conventions.sourcesets.automatic-inclusion=false
 ```
 
 This is equivalent to setting the following in your build.gradle:
@@ -289,13 +291,12 @@ runs {
 By default, the local run runtime configuration of a sourceset is automatically included in the runs configuration of the run.
 If you want to disable this, you can set the following property in your gradle.properties:
 ```properties
-neogradle.subsystems.conventions.sourceset.automatic-inclusion-local-run-runtime=false
+neogradle.subsystems.conventions.sourcesets.automatic-inclusion-local-run-runtime=false
 ```
 This is equivalent to setting the following in your build.gradle:
 ```groovy
 runs {
     configureEach { run ->
-        run.modSource sourceSets.main
         run.dependencies {
             runtime sourceSets.main.configurations.localRunRuntime
         }
diff --git a/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java b/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java
index 8b7f75ef8..0ca6f3c07 100644
--- a/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java
+++ b/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java
@@ -204,8 +204,14 @@ private void configureSourceSetConventions(Project project, Conventions conventi
             project.getExtensions().getByType(SourceSetContainer.class).configureEach(sourceSet -> {
                 final NamedDomainObjectCollection<Configuration> sourceSetConfigurations = (NamedDomainObjectCollection<Configuration>) sourceSet.getExtensions().getByName("configurations");
 
-                sourceSetConfigurations.add(project.getConfigurations().create(ConfigurationUtils.getSourceSetName(sourceSet, configurations.getLocalRuntimeConfigurationPostFix().get())));
-                sourceSetConfigurations.add(project.getConfigurations().create(ConfigurationUtils.getSourceSetName(sourceSet, configurations.getRunRuntimeConfigurationPostFix().get())));
+                final Configuration sourceSetLocalRuntimeConfiguration = project.getConfigurations().create(ConfigurationUtils.getSourceSetName(sourceSet, configurations.getLocalRuntimeConfigurationPostFix().get()));
+                sourceSetConfigurations.add(sourceSetLocalRuntimeConfiguration);
+
+                final Configuration sourceSetRunRuntimeConfiguration = project.getConfigurations().create(ConfigurationUtils.getSourceSetName(sourceSet, configurations.getRunRuntimeConfigurationPostFix().get()));
+                sourceSetConfigurations.add(sourceSetRunRuntimeConfiguration);
+
+                final Configuration sourceSetRuntimeClasspath = project.getConfigurations().maybeCreate(sourceSet.getRuntimeClasspathConfigurationName());
+                sourceSetRuntimeClasspath.extendsFrom(sourceSetLocalRuntimeConfiguration);
             });
         }
 
@@ -228,14 +234,13 @@ private void configureRunConventions(Project project, Conventions conventions) {
         final Configurations configurations = conventions.getConfigurations();
         final Runs runs = conventions.getRuns();
 
-        if (!configurations.getIsEnabled().get())
+        if (!runs.getIsEnabled().get())
             return;
 
-        final Configuration runRuntimeConfiguration = project.getConfigurations().create(configurations.getRunRuntimeConfigurationName().get());
-        final Configuration runModsConfiguration = project.getConfigurations().create(configurations.getRunModsConfigurationName().get());
-
         if (runs.getShouldDefaultRunsBeCreated().get()) {
-            project.getExtensions().configure(RunsConstants.Extensions.RUN_TYPES, (Action<NamedDomainObjectContainer<RunType>>) runTypesContainer -> runTypesContainer.configureEach(runType -> {
+            final NamedDomainObjectContainer<RunType> runTypes = (NamedDomainObjectContainer<RunType>) project.getExtensions().getByName(RunsConstants.Extensions.RUN_TYPES);
+            //Force none lazy resolve here.
+            runTypes.whenObjectAdded(runType -> {
                 project.getExtensions().configure(RunsConstants.Extensions.RUNS, (Action<NamedDomainObjectContainer<Run>>) runContainer -> {
                     if (runContainer.getAsMap().containsKey(runType.getName()))
                         return;
@@ -244,9 +249,15 @@ private void configureRunConventions(Project project, Conventions conventions) {
                         run.configure(runType);
                     });
                 });
-            }));
+            });
         }
 
+        if (!configurations.getIsEnabled().get())
+            return;
+
+        final Configuration runRuntimeConfiguration = project.getConfigurations().create(configurations.getRunRuntimeConfigurationName().get());
+        final Configuration runModsConfiguration = project.getConfigurations().create(configurations.getRunModsConfigurationName().get());
+
         project.getExtensions().configure(RunsConstants.Extensions.RUNS, (Action<NamedDomainObjectContainer<Run>>) runContainer -> runContainer.configureEach(run -> {
             final Configuration runSpecificRuntimeConfiguration = project.getConfigurations().create(ConfigurationUtils.getRunName(run, configurations.getPerRunRuntimeConfigurationPostFix().get()));
             final Configuration runSpecificModsConfiguration = project.getConfigurations().create(ConfigurationUtils.getRunName(run, configurations.getPerRunModsConfigurationPostFix().get()));
diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/ConventionsExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/ConventionsExtension.java
index 8d68cc23f..e98422ceb 100644
--- a/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/ConventionsExtension.java
+++ b/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/ConventionsExtension.java
@@ -69,7 +69,7 @@ public static abstract class SourceSetsExtension extends WithEnabledProperty imp
 
         @Inject
         public SourceSetsExtension(WithEnabledProperty parent) {
-            super(parent, "sourceSets");
+            super(parent, "sourcesets");
 
             getShouldMainSourceSetBeAutomaticallyAddedToRuns().convention(getBooleanProperty("automatic-inclusion").orElse(true));
             getShouldSourceSetsLocalRunRuntimesBeAutomaticallyAddedToRuns().convention(getBooleanProperty("automatic-inclusion-local-run-runtime").orElse(true));
diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/IDEAIDEConventionTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/IDEAIDEConventionTests.groovy
new file mode 100644
index 000000000..35ea12486
--- /dev/null
+++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/IDEAIDEConventionTests.groovy
@@ -0,0 +1,216 @@
+package net.neoforged.gradle.userdev.convention
+
+import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification
+
+class IDEAIDEConventionTests extends BuilderBasedTestSpecification {
+
+    @Override
+    protected void configurePluginUnderTest() {
+        pluginUnderTest = "net.neoforged.gradle.userdev";
+        injectIntoAllProject = true;
+    }
+
+    def "disabling conventions globally forces auto detection to be false"() {
+        given:
+        def project = create("disable_globally_disables_auto_detection", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            //Force NeoGradle to think build with IDEA is enabled.
+            it.file(".idea/gradle.xml", """
+            <option name=\"delegatedBuild\" value=\"false\" />
+            """)
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("IDEA Run with IDEA: \${project.idea.project.runs.runWithIdea.get()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("IDEA Run with IDEA: false")
+    }
+
+    def "disabling ide conventions forces auto detection to be false"() {
+        given:
+        def project = create("disable_ide_disables_auto_detection", {
+            it.property('neogradle.subsystems.conventions.ide.enabled', 'false')
+            //Force NeoGradle to think build with IDEA is enabled.
+            it.file(".idea/gradle.xml", """
+            <option name=\"delegatedBuild\" value=\"false\" />
+            """)
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("IDEA Run with IDEA: \${project.idea.project.runs.runWithIdea.get()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("IDEA Run with IDEA: false")
+    }
+
+    def "disabling idea ide conventions forces auto detection to be false"() {
+        given:
+        def project = create("disable_idea_ide_disables_auto_detection", {
+            it.property('neogradle.subsystems.conventions.ide.idea.enabled', 'false')
+            //Force NeoGradle to think build with IDEA is enabled.
+            it.file(".idea/gradle.xml", """
+            <option name=\"delegatedBuild\" value=\"false\" />
+            """)
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("IDEA Run with IDEA: \${project.idea.project.runs.runWithIdea.get()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("IDEA Run with IDEA: false")
+    }
+
+    def "disabling compiler auto-detection conventions forces auto detection to be false"() {
+        given:
+        def project = create("disable_compiler_idea_ide_disables_auto_detection", {
+            it.property('neogradle.subsystems.conventions.ide.idea.compiler-detection', 'false')
+            //Force NeoGradle to think build with IDEA is enabled.
+            it.file(".idea/gradle.xml", """
+            <option name=\"delegatedBuild\" value=\"false\" />
+            """)
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("IDEA Run with IDEA: \${project.idea.project.runs.runWithIdea.get()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("IDEA Run with IDEA: false")
+    }
+
+    def "enabling compiler auto-detection conventions detects idea compiler"() {
+        given:
+        def project = create("disable_compiler_idea_ide_disables_auto_detection", {
+            //Force NeoGradle to think build with IDEA is enabled.
+            it.file(".idea/gradle.xml", """
+            <option name=\"delegatedBuild\" value=\"false\" />
+            """)
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("IDEA Run with IDEA: \${project.idea.project.runs.runWithIdea.get()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("IDEA Run with IDEA: true")
+    }
+
+    def "enabling compiler auto-detection conventions detects gradle compiler"() {
+        given:
+        def project = create("disable_compiler_idea_ide_disables_auto_detection", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("IDEA Run with IDEA: \${project.idea.project.runs.runWithIdea.get()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("IDEA Run with IDEA: false")
+    }
+}
diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/RunConventionTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/RunConventionTests.groovy
new file mode 100644
index 000000000..eaba2fa11
--- /dev/null
+++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/RunConventionTests.groovy
@@ -0,0 +1,442 @@
+package net.neoforged.gradle.userdev.convention
+
+import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification
+import org.gradle.testkit.runner.TaskOutcome
+
+/**
+ * Tests the run conventions.
+ * Note: When counting the elements in a NDOC do not use size(), values are not guaranteed to be present.
+ */
+class RunConventionTests extends BuilderBasedTestSpecification {
+    @Override
+    protected void configurePluginUnderTest() {
+        pluginUnderTest = "net.neoforged.gradle.userdev";
+        injectIntoAllProject = true;
+    }
+
+    def "disabling conventions globally does not register runs"() {
+        given:
+        def project = create("disable_globally_disables_registration", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run count: \${project.runs.stream().count()}")
+                logger.lifecycle("Runtype count: \${project.runTypes.stream().count()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("Run count: 0")
+        run.output.contains("Runtype count:")
+        !run.output.contains("Runtype count: 0")
+    }
+
+    def "disabling run conventions does not register runs"() {
+        given:
+        def project = create("disable_runs_disables_registration", {
+            it.property('neogradle.subsystems.conventions.runs.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run count: \${project.runs.stream().count()}")
+                logger.lifecycle("Runtype count: \${project.runTypes.stream().count()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("Run count: 0")
+        run.output.contains("Runtype count:")
+        !run.output.contains("Runtype count: 0")
+    }
+
+    def "disabling automatic registration does not register runs"() {
+        given:
+        def project = create("disable_automatic_registration_disables_registration", {
+            it.property('neogradle.subsystems.conventions.runs.create-default-run-per-type', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run count: \${project.runs.stream().count()}")
+                logger.lifecycle("Runtype count: \${project.runTypes.stream().count()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.output.contains("Run count: 0")
+        run.output.contains("Runtype count:")
+        !run.output.contains("Runtype count: 0")
+    }
+
+    def "enabling automatic registration does not register runs"() {
+        given:
+        def project = create("disable_automatic_registration_disables_registration", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            afterEvaluate {
+                // Do not use size here.
+                logger.lifecycle("Run count: \${project.runs.stream().count()}")
+                logger.lifecycle("Runtype count: \${project.runTypes.stream().count()}")
+                logger.lifecycle("Equal: \${project.runTypes.stream().count() == project.runs.stream().count()}")
+            }                        
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.debug()
+        }
+
+        then:
+        run.output.contains("Run count: ")
+        !run.output.contains("Run count: 0")
+        run.output.contains("Runtype count:")
+        !run.output.contains("Runtype count: 0")
+        run.output.contains("Equal: true")
+    }
+
+    def "disabling conventions globally prevents creation of runs configuration run"() {
+        given:
+        def project = create("disable_globally_errors_run", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                clientRun 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method clientRun() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling conventions globally prevents creation of runs configuration mod"() {
+        given:
+        def project = create("disable_globally_errors_mod", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'                
+                clientMod 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method clientMod() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling conventions globally prevents creation of runs configuration runs"() {
+        given:
+        def project = create("disable_globally_errors_runs", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                runs 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method runs() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling conventions globally prevents creation of runs configuration mods"() {
+        given:
+        def project = create("disable_globally_errors_mods", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                mods 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method mods() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "using the mod convention configuration downloads the referenced mod"() {
+        given:
+        def project = create("mod_can_download_mods", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                clientMod 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':downloadModsClient')
+        }
+
+        then:
+        def modsDir = run.file("runs/client/mods")
+
+        run.task(':downloadModsClient').outcome == TaskOutcome.SUCCESS
+        modsDir.listFiles().length >= 1 //At least one file has to be download, generally more.
+    }
+
+    def "using the run convention configuration puts the dependency on the runtime config"() {
+        given:
+        def project = create("run_can_download_runtime_elements", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                clientRun 'org.jgrapht:jgrapht-core:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run contains cp entry: \${project.runs.client.dependencies.get().runtimeConfiguration.files.any { it.name.contains 'jgrapht' }}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run contains cp entry: true")
+    }
+
+    def "using the mods convention configuration downloads the referenced mod"() {
+        given:
+        def project = create("mods_can_download_mods", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                mods 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':downloadModsClient')
+        }
+
+        then:
+        def modsDir = run.file("runs/client/mods")
+
+        run.task(':downloadModsClient').outcome == TaskOutcome.SUCCESS
+        modsDir.listFiles().length >= 1 //At least one file has to be download, generally more.
+    }
+
+    def "using the runs convention configuration puts the dependency on the runtime config"() {
+        given:
+        def project = create("runs_can_download_runtime_elements", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                runs 'org.jgrapht:jgrapht-core:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run contains cp entry: \${project.runs.client.dependencies.get().runtimeConfiguration.files.any { it.name.contains 'jgrapht' }}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run contains cp entry: true")
+    }
+}
diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/SourceSetConventionTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/SourceSetConventionTests.groovy
new file mode 100644
index 000000000..f3c43a5b4
--- /dev/null
+++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/convention/SourceSetConventionTests.groovy
@@ -0,0 +1,529 @@
+package net.neoforged.gradle.userdev.convention
+
+import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification
+import org.gradle.testkit.runner.TaskOutcome
+
+class SourceSetConventionTests extends BuilderBasedTestSpecification {
+
+    @Override
+    protected void configurePluginUnderTest() {
+        pluginUnderTest = "net.neoforged.gradle.userdev";
+        injectIntoAllProject = true;
+    }
+
+    def "disabling conventions globally prevents creation of sourceset configuration localRuntime"() {
+        given:
+        def project = create("disable_globally_errors_local_runtime", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                localRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method localRuntime() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling conventions globally prevents creation of sourceset configuration localRunRuntime"() {
+        given:
+        def project = create("disable_globally_errors_local_run_runtime", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                localRunRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method localRunRuntime() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling configuration conventions prevents creation of sourceset configuration localRuntime"() {
+        given:
+        def project = create("disable_configurations_errors_local_runtime", {
+            it.property('neogradle.subsystems.conventions.configurations.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                localRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method localRuntime() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling configuration conventions prevents creation of sourceset configuration localRunRuntime"() {
+        given:
+        def project = create("disable_configurations_errors_local_run_runtime", {
+            it.property('neogradle.subsystems.conventions.configurations.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                localRunRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method localRunRuntime() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling sourceset conventions prevents creation of sourceset configuration localRuntime"() {
+        given:
+        def project = create("disable_sourcesets_fails_local_runtime", {
+            it.property('neogradle.subsystems.conventions.sourcesets.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                localRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method localRuntime() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling sourceset conventions prevents creation of sourceset configuration localRunRuntime"() {
+        given:
+        def project = create("disable_sourcesets_fails_local_run_runtime", {
+            it.property('neogradle.subsystems.conventions.sourcesets.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                localRunRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+            it.shouldFail()
+        }
+
+        then:
+        run.output.contains("Could not find method localRunRuntime() for arguments [org.jgrapht:jgrapht-core:+] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.")
+    }
+
+    def "disabling global conventions prevents registration of main sourceset to run"() {
+        given:
+        def project = create("disable_global_no_registration_main", {
+            it.property('neogradle.subsystems.conventions.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            runs {
+                client { }
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run sources: \${project.runs.client.modSources.get()}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run sources: []")
+    }
+
+    def "disabling sourceset conventions prevents registration of main sourceset to run"() {
+        given:
+        def project = create("disable_sourcesets_no_registration_main", {
+            it.property('neogradle.subsystems.conventions.sourcesets.enabled', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            runs {
+                client { }
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run sources: \${project.runs.client.modSources.get()}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run sources: []")
+    }
+
+    def "disabling main source set registration conventions prevents registration of main sourceset to run"() {
+        given:
+        def project = create("disable_sourcesets_no_registration_main", {
+            it.property('neogradle.subsystems.conventions.sourcesets.automatic-inclusion', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            runs {
+                client { }
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run sources: \${project.runs.client.modSources.get()}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run sources: []")
+    }
+
+    def "having the conventions for main sourceset registration enabled registers it"() {
+        given:
+        def project = create("registration_enabled", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            
+            runs {
+                client { }
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run sources: \${project.runs.client.modSources.get()}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run sources: [source set 'main']")
+    }
+
+    def "disabling sourceset local run runtime registration conventions prevents registration of localRunRuntime"() {
+        given:
+        def project = create("disable_sourcesets_prevents_local_run_runtime", {
+            it.property('neogradle.subsystems.conventions.sourcesets.automatic-inclusion-local-run-runtime', 'false')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                localRunRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            
+            runs {
+                client { }
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':writeMinecraftClasspathClient')
+        }
+
+        then:
+        run.task(':writeMinecraftClasspathClient').outcome == TaskOutcome.SUCCESS
+
+
+        def neoformDir = run.file(".gradle/configuration/neoForm")
+        def versionedNeoformDir = neoformDir.listFiles()[0]
+        def stepsDir = new File(versionedNeoformDir, "steps")
+        def stepDir = new File(stepsDir, "writeMinecraftClasspathClient")
+        def classpathFile = new File(stepDir, "classpath.txt")
+
+        classpathFile.exists()
+
+        !classpathFile.text.contains("org.jgrapht/jgrapht-core")
+    }
+
+    def "enabling sourceset local run runtime registration conventions registers localRunRuntime"() {
+        given:
+        def project = create("disable_sourcesets_prevents_local_run_runtime", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                localRunRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            
+            runs {
+                client { }
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':writeMinecraftClasspathClient')
+        }
+
+        then:
+        run.task(':writeMinecraftClasspathClient').outcome == TaskOutcome.SUCCESS
+
+
+        def neoformDir = run.file(".gradle/configuration/neoForm")
+        def versionedNeoformDir = neoformDir.listFiles()[0]
+        def stepsDir = new File(versionedNeoformDir, "steps")
+        def stepDir = new File(stepsDir, "writeMinecraftClasspathClient")
+        def classpathFile = new File(stepDir, "classpath.txt")
+
+        classpathFile.exists()
+
+        classpathFile.text.contains("org.jgrapht/jgrapht-core")
+    }
+
+    def "using the local runtime convention configuration does not put the dependency on the runtime config"() {
+        given:
+        def project = create("run_can_download_runtime_elements", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                localRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run contains cp entry: \${project.runs.client.dependencies.get().runtimeConfiguration.files.any { it.name.contains 'jgrapht' }}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run contains cp entry: false")
+    }
+
+    def "using the local run runtime convention configuration does not put the dependency on the runtime config"() {
+        given:
+        def project = create("run_can_download_runtime_elements", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+                localRunRuntime 'org.jgrapht:jgrapht-core:+'
+            }
+            
+            afterEvaluate {
+                logger.lifecycle("Run contains cp entry: \${project.runs.client.dependencies.get().runtimeConfiguration.files.any { it.name.contains 'jgrapht' }}")
+            }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks(':dependencies')
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("Run contains cp entry: true")
+    }
+}
diff --git a/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/extension/UserDevRuntimeExtension.java b/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/extension/UserDevRuntimeExtension.java
index 8fbeac2be..0169028b6 100644
--- a/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/extension/UserDevRuntimeExtension.java
+++ b/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/extension/UserDevRuntimeExtension.java
@@ -89,10 +89,11 @@ public UserDevRuntimeExtension(Project project) {
         });
         
         spec.setMinecraftVersion(mcpRuntimeDefinition.getSpecification().getMinecraftVersion());
-        
-        getProject().getExtensions().configure(RunsConstants.Extensions.RUN_TYPES, (Action<NamedDomainObjectContainer<RunType>>) types -> userdevProfile.getRunTypes().forEach((type) -> {
-            TypesUtil.registerWithPotentialPrefix(types, spec.getIdentifier(), type.getName(), type::copyTo);
-        }));
+
+        final NamedDomainObjectContainer<RunType> runTypes = (NamedDomainObjectContainer<RunType>) getProject().getExtensions().getByName(RunsConstants.Extensions.RUN_TYPES);
+        userdevProfile.getRunTypes().forEach((type) -> {
+            TypesUtil.registerWithPotentialPrefix(runTypes, spec.getIdentifier(), type.getName(), type::copyTo);
+        });
         
         return new UserDevRuntimeDefinition(
                 spec,