diff --git a/gradle.properties b/gradle.properties index e576c5245..bb5f472f1 100644 --- a/gradle.properties +++ b/gradle.properties @@ -7,6 +7,6 @@ org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled javaVersion=25 mcVersion=26.3 group=dev.slne.surf.api -version=3.47.0 +version=3.47.1 relocationPrefix=dev.slne.surf.api.libs snapshot=false diff --git a/surf-api-gradle-plugin/build.gradle.kts b/surf-api-gradle-plugin/build.gradle.kts index 3fce645fd..246de7853 100644 --- a/surf-api-gradle-plugin/build.gradle.kts +++ b/surf-api-gradle-plugin/build.gradle.kts @@ -20,7 +20,7 @@ plugins { group = groupId version = buildString { - append("2.2.1") + append("2.3.0") if (snapshot) append("-SNAPSHOT") } @@ -46,6 +46,14 @@ dependencies { implementation("com.palantir.javapoet:javapoet:0.20.0") implementation(libs.bundles.kotlin.serialization) + + testImplementation(kotlin("test")) + testImplementation(libs.junit.jupiter) + testRuntimeOnly(libs.junit.platform.launcher) +} + +tasks.test { + useJUnitPlatform() } gradlePlugin { @@ -123,7 +131,7 @@ val generateConstants = tasks.register("generateConstants") { inputs.property("libs.auto.service.annotations", libs.auto.service.annotations.get().toString()) inputs.property("libs.versions.commandapiplugin", libs.versions.commandapiplugin.get()) inputs.property("libs.versions.placeholder.api", libs.versions.placeholder.api.get()) - inputs.property("libs.versions.luckperms", libs.versions.luckperms.get()) + inputs.property("libs.versions.luckpermsplugin.bukkit", libs.versions.luckpermsplugin.bukkit.get()) inputs.property( "libs.versions.packetevents", libs.versions.packetevents.plugin.get() @@ -165,7 +173,7 @@ val generateConstants = tasks.register("generateConstants") { | | const val COMMAND_API_VERSION = "${libs.versions.commandapiplugin.get()}" | const val PLACEHOLDER_API_VERSION = "${libs.versions.placeholder.api.get()}" - | const val LUCKPERMS_VERSION = "${libs.versions.luckperms.get()}" + | const val LUCKPERMS_VERSION = "${libs.versions.luckpermsplugin.bukkit.get()}" | const val PACKETEVENTS_VERSION = "${libs.versions.packetevents.plugin.get()}" | | const val TEST_JUNIT_VERSION = "${libs.versions.junit.asProvider().get()}" diff --git a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfExtension.kt b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfExtension.kt index 375f13518..676916e5e 100644 --- a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfExtension.kt +++ b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfExtension.kt @@ -4,6 +4,7 @@ import dev.slne.surf.api.gradle.SurfCoreModules import dev.slne.surf.api.gradle.platform.common.testing.SurfTestingExtension import org.gradle.api.Action import org.gradle.api.model.ObjectFactory +import org.gradle.api.provider.Provider import org.gradle.kotlin.dsl.newInstance import org.gradle.kotlin.dsl.property import org.jetbrains.annotations.MustBeInvokedByOverriders @@ -19,6 +20,7 @@ abstract class CommonSurfExtension(protected val objects: ObjectFactory) { internal val withSurfRedis = objects.property().convention(false) internal val surfRedisVersion = objects.property() internal val surfRedisRelocation = objects.property() + internal val withSurfNats = objects.property().convention(false) internal val withSurfDatabaseR2dbc = objects.property().convention(false) internal val surfDatabaseR2dbcVersion = objects.property() internal val surfDatabaseR2dbcRelocation = objects.property() @@ -54,6 +56,15 @@ abstract class CommonSurfExtension(protected val objects: ObjectFactory) { surfRedisRelocation.finalizeValue() } + + fun withSurfNats() { + withSurfNats.set(true) + withSurfNats.finalizeValue() + } + + val surfNatsEnabled: Provider + get() = withSurfNats + fun withSurfDatabaseR2dbc(version: String, relocation: String) { withSurfDatabaseR2dbc.set(true) withSurfDatabaseR2dbc.finalizeValue() diff --git a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfPlugin.kt b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfPlugin.kt index 7b0b31def..2786c3dfb 100644 --- a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfPlugin.kt +++ b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/common/CommonSurfPlugin.kt @@ -212,7 +212,13 @@ abstract class CommonSurfPlugin( private fun Project.configureKotlin() = configure { jvmToolchain(Constants.JAVA_VERSION) compilerOptions { - freeCompilerArgs.addAll(listOf("-Xjsr305=strict", "-Xcontext-parameters")) + freeCompilerArgs.addAll( + listOf( + "-Xjsr305=strict", + "-Xcontext-parameters", + "-Xreturn-value-checker=check", + ) + ) javaParameters = true } } @@ -269,6 +275,16 @@ abstract class CommonSurfPlugin( } } + if (extension.withSurfNats.get()) { + dependencies { + val notation = "dev.slne.surf.nats:surf-nats-api:+" + add(COMPILE_ONLY, notation) + if (testingEnabled) { + add(SurfTestingConfigurer.TEST_IMPLEMENTATION, notation) + } + } + } + if (extension.withSurfDatabaseR2dbc.get()) { dependencies { add( diff --git a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/core/CoreSurfPlugin.kt b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/core/CoreSurfPlugin.kt index 32dfe6415..481884133 100644 --- a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/core/CoreSurfPlugin.kt +++ b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/core/CoreSurfPlugin.kt @@ -2,6 +2,7 @@ package dev.slne.surf.api.gradle.platform.core import dev.slne.surf.api.gradle.platform.SurfApiPlatform import dev.slne.surf.api.gradle.platform.common.CommonSurfPlugin +import dev.slne.surf.api.gradle.platform.common.testing.SurfTestingConfigurer import org.gradle.api.Project internal abstract class AbstractCoreSurfPlugin( @@ -28,4 +29,11 @@ internal abstract class AbstractCoreSurfPlugin( internal class CoreSurfPlugin : AbstractCoreSurfPlugin("core", SurfApiPlatform.CORE) { override val extensionClass = CoreSurfExtension::class.java + + override fun Project.platformTestDependencies(extension: CoreSurfExtension) { + dependencies.add( + SurfTestingConfigurer.TEST_RUNTIME_ONLY, + SurfApiPlatform.STANDALONE.dependency + ) + } } \ No newline at end of file diff --git a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/paper/plugin/PaperPluginSurfPlugin.kt b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/paper/plugin/PaperPluginSurfPlugin.kt index 0de78929f..d82fae2ec 100644 --- a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/paper/plugin/PaperPluginSurfPlugin.kt +++ b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/paper/plugin/PaperPluginSurfPlugin.kt @@ -60,6 +60,10 @@ internal class PaperPluginSurfPlugin : registerRequired("surf-redis-paper") } + if (extension.withSurfNats.get()) { + registerRequired("surf-nats-paper") + } + extension.bootstrapDependencies.orNull?.execute(this) } @@ -73,6 +77,10 @@ internal class PaperPluginSurfPlugin : registerRequired("surf-redis-paper") } + if (extension.withSurfNats.get()) { + registerRequired("surf-nats-paper") + } + if (extension.installSurfNpc.get()) { registerRequired("surf-npc-paper") } diff --git a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/velocity/VelocitySurfPlugin.kt b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/velocity/VelocitySurfPlugin.kt index 94ec95f64..379fc11b6 100644 --- a/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/velocity/VelocitySurfPlugin.kt +++ b/surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/api/gradle/platform/velocity/VelocitySurfPlugin.kt @@ -64,6 +64,11 @@ internal class VelocitySurfPlugin : optional.convention(false) enabled.convention(redisEnabled) } + + register("surf-nats-velocity") { + optional.convention(false) + enabled.convention(ext.withSurfNats) + } } } diff --git a/surf-api-gradle-plugin/src/test/kotlin/dev/slne/surf/api/gradle/platform/SurfNatsPluginTest.kt b/surf-api-gradle-plugin/src/test/kotlin/dev/slne/surf/api/gradle/platform/SurfNatsPluginTest.kt new file mode 100644 index 000000000..b6bc04f26 --- /dev/null +++ b/surf-api-gradle-plugin/src/test/kotlin/dev/slne/surf/api/gradle/platform/SurfNatsPluginTest.kt @@ -0,0 +1,157 @@ +package dev.slne.surf.api.gradle.platform + +import dev.slne.surf.api.gradle.generated.Constants +import dev.slne.surf.api.gradle.generators.pluginfiles.VelocityPluginFile +import dev.slne.surf.api.gradle.platform.core.CoreSurfExtension +import dev.slne.surf.api.gradle.platform.core.CoreSurfPlugin +import dev.slne.surf.api.gradle.platform.paper.plugin.PaperPluginSurfExtension +import dev.slne.surf.api.gradle.platform.paper.plugin.PaperPluginSurfPlugin +import dev.slne.surf.api.gradle.platform.velocity.VelocitySurfExtension +import dev.slne.surf.api.gradle.platform.velocity.VelocitySurfPlugin +import net.minecrell.pluginyml.paper.PaperPluginDescription +import org.gradle.api.Plugin +import org.gradle.api.Project +import org.gradle.api.internal.project.ProjectInternal +import org.gradle.kotlin.dsl.getByType +import org.gradle.testfixtures.ProjectBuilder +import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension +import kotlin.test.* + +class SurfNatsPluginTest { + + private val natsApi = "dev.slne.surf.nats:surf-nats-api:+" + private val standaloneApi = SurfApiPlatform.STANDALONE.dependency + + private inline fun evaluatedProject( + plugin: Class>, + configure: E.() -> Unit = {}, + ): Project { + val project = ProjectBuilder.builder().build() + project.plugins.apply(plugin) + project.extensions.getByType().configure() + (project as ProjectInternal).evaluate() + return project + } + + private fun Project.dependencyNotations(configuration: String) = + configurations.getByName(configuration).dependencies + .map { "${it.group}:${it.name}:${it.version}" } + + @Test + fun `withSurfNats adds surf-nats-api as compileOnly and testImplementation`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) { + withSurfNats() + } + + assertTrue(natsApi in project.dependencyNotations("compileOnly")) + assertTrue(natsApi in project.dependencyNotations("testImplementation")) + assertFalse(natsApi in project.dependencyNotations("implementation")) + assertFalse(natsApi in project.dependencyNotations("api")) + } + + @Test + fun `withSurfNats skips testImplementation when testing is disabled`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) { + withSurfNats() + testing.enabled.set(false) + } + + assertTrue(natsApi in project.dependencyNotations("compileOnly")) + assertFalse(natsApi in project.dependencyNotations("testImplementation")) + } + + @Test + fun `surf-nats is absent without withSurfNats`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) + + assertFalse(natsApi in project.dependencyNotations("compileOnly")) + assertFalse(project.extensions.getByType().surfNatsEnabled.get()) + } + + @Test + fun `surfNatsEnabled reflects withSurfNats`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) { + withSurfNats() + } + + assertTrue(project.extensions.getByType().surfNatsEnabled.get()) + } + + @Test + fun `core tests get the standalone runtime`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) + + assertTrue(standaloneApi in project.dependencyNotations("testRuntimeOnly")) + } + + @Test + fun `core without testing gets no standalone runtime`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) { + testing.enabled.set(false) + } + + assertFalse(standaloneApi in project.dependencyNotations("testRuntimeOnly")) + } + + @Test + fun `return value checker is enabled`() { + val project = evaluatedProject(CoreSurfPlugin::class.java) + + val args = project.extensions.getByType() + .compilerOptions.freeCompilerArgs.get() + assertTrue("-Xreturn-value-checker=check" in args) + } + + @Test + fun `paper plugin requires surf-nats-paper`() { + val project = + evaluatedProject(PaperPluginSurfPlugin::class.java) { + mainClass("dev.slne.test.TestPlugin") + withSurfNats() + } + + val description = project.extensions.getByType() + for (dependencies in listOf(description.bootstrapDependencies, description.serverDependencies)) { + val nats = assertNotNull(dependencies.findByName("surf-nats-paper")) + assertEquals(true, nats.required) + } + } + + @Test + fun `paper plugin without withSurfNats does not require surf-nats-paper`() { + val project = + evaluatedProject(PaperPluginSurfPlugin::class.java) { + mainClass("dev.slne.test.TestPlugin") + } + + val description = project.extensions.getByType() + assertEquals(null, description.serverDependencies.findByName("surf-nats-paper")) + assertEquals(null, description.bootstrapDependencies.findByName("surf-nats-paper")) + } + + @Test + fun `velocity plugin depends on surf-nats-velocity`() { + val project = evaluatedProject(VelocitySurfPlugin::class.java) { + withSurfNats() + } + + val nats = project.extensions.getByType() + .pluginDependencies.getByName("surf-nats-velocity") + assertTrue(nats.enabled.get()) + assertFalse(nats.optional.get()) + } + + @Test + fun `velocity plugin without withSurfNats leaves surf-nats-velocity disabled`() { + val project = evaluatedProject(VelocitySurfPlugin::class.java) + + val nats = project.extensions.getByType() + .pluginDependencies.getByName("surf-nats-velocity") + assertFalse(nats.enabled.get()) + } + + @Test + fun `luckperms version is the modrinth plugin version`() { + assertTrue(Constants.LUCKPERMS_VERSION.endsWith("-bukkit"), Constants.LUCKPERMS_VERSION) + } +}