From e3c1b2bdbfe20e602fbf570df946edc94266e5ff Mon Sep 17 00:00:00 2001 From: "sebastian.sellmair" Date: Wed, 5 Aug 2020 22:56:16 +0200 Subject: API refinement for AbstractDokkaParentTask and DokkaMultiModuleTask --- .../dokka/gradle/AbstractDokkaParentTaskTest.kt | 255 ++++++++++++++------- .../dokka/gradle/DokkaCollectorTaskTest.kt | 26 ++- .../dokka/gradle/DokkaConfigurationJsonTest.kt | 14 +- .../gradle/DokkaConfigurationSerializableTest.kt | 13 +- .../dokka/gradle/DokkaMultiModuleFileLayoutTest.kt | 100 ++++++++ .../dokka/gradle/DokkaMultiModuleTaskTest.kt | 88 ++++++- .../jetbrains/dokka/gradle/DokkaPluginApplyTest.kt | 84 +++++++ .../org/jetbrains/dokka/gradle/DokkaTasksTest.kt | 65 ------ .../gradle/KotlinDslDokkaTaskConfigurationTest.kt | 11 +- 9 files changed, 473 insertions(+), 183 deletions(-) create mode 100644 runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt create mode 100644 runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaPluginApplyTest.kt delete mode 100644 runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaTasksTest.kt (limited to 'runners/gradle-plugin/src/test/kotlin') diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt index da0f3f35..f0e05637 100644 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt @@ -1,107 +1,200 @@ package org.jetbrains.dokka.gradle -import org.gradle.kotlin.dsl.register -import org.gradle.kotlin.dsl.withType +import org.gradle.api.Project +import org.gradle.api.UnknownTaskException +import org.gradle.kotlin.dsl.create +import org.gradle.kotlin.dsl.getByName import org.gradle.testfixtures.ProjectBuilder +import org.jetbrains.dokka.DokkaConfigurationImpl import kotlin.test.Test import kotlin.test.assertEquals -import kotlin.test.assertTrue +import kotlin.test.assertFailsWith class AbstractDokkaParentTaskTest { private val rootProject = ProjectBuilder.builder().build() private val subproject0 = ProjectBuilder.builder().withName("subproject0").withParent(rootProject).build() private val subproject1 = ProjectBuilder.builder().withName("subproject1").withParent(rootProject).build() - private val subSubproject0a = ProjectBuilder.builder().withName("subSubproject0a").withParent(subproject0).build() + private val subSubproject0 = ProjectBuilder.builder().withName("subSubproject0").withParent(subproject0).build() init { - rootProject.allprojects { project -> project.plugins.apply("org.jetbrains.dokka") } + rootProject.subprojects { project -> + project.tasks.create("dokkaTask") + } } - private val parentTasks = rootProject.tasks.withType().toList() + private val parentTask = rootProject.tasks.create("parent") + @Test - fun `at least one parent task is registered`() { - assertTrue( - parentTasks.isNotEmpty(), - "Expected at least one ${AbstractDokkaParentTask::class.simpleName} task in rootProject" + fun `add and remove tasks by reference`() { + assertEquals( + emptySet(), parentTask.childDokkaTasks, + "Expected no childDokkaTasks by default" + ) + + parentTask.addChildTask(subproject0.dokkaTask) + assertEquals( + setOf(subproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} being registered as child task" + ) + + parentTask.addChildTask(subproject1.dokkaTask) + assertEquals( + setOf(subproject0.dokkaTask, subproject1.dokkaTask), parentTask.childDokkaTasks, + "Expected both dokka tasks being present" + ) + + parentTask.removeChildTask(subproject0.dokkaTask) + assertEquals( + setOf(subproject1.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} being removed from child tasks" + ) + + parentTask.addChildTask(subSubproject0.dokkaTask) + assertEquals( + setOf(subproject1.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subSubproject0.dokkaTask.path} being added as child task" + ) + + parentTask.addChildTask(subSubproject0.dokkaTask) + assertEquals( + setOf(subproject1.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected no effect for adding a task twice" ) } @Test - fun `configuring subprojects`() { - parentTasks.forEach { task -> - assertEquals( - setOf(":subproject0", ":subproject1", ":subproject0:subSubproject0a"), task.subprojectPaths, - "Expected all sub projects registered by default" - ) - - assertEquals( - listOf(subproject0, subproject1, subSubproject0a), task.subprojects, - "Expected all sub projects registered by default" - ) - - assertEquals(3, task.dokkaTasks.size, "Expected three referenced dokka tasks") - assertTrue(listOf(subproject0, subproject1, subSubproject0a).all { project -> - task.dokkaTasks.any { task -> task in project.tasks } - }, "Expected all sub projects to contribute to referenced dokka tasks") - - task.removeSubproject(subproject0) - assertEquals( - setOf(":subproject1", ":subproject0:subSubproject0a"), task.subprojectPaths, - "Expected subproject0 to be removed (without removing its children)" - ) - - task.addSubproject(subproject0) - assertEquals( - setOf(":subproject1", ":subproject0:subSubproject0a", ":subproject0"), task.subprojectPaths, - "Expected subproject0 being added again" - ) - - task.addSubproject(subproject0) - assertEquals( - setOf(":subproject1", ":subproject0:subSubproject0a", ":subproject0"), task.subprojectPaths, - "Expected adding same project twice to be ignored" - ) - - task.removeAllProjects(subproject0) - assertEquals( - setOf(":subproject1"), task.subprojectPaths, - "Expected subproject0 and subSubproject0a to be removed" - ) - - task.addAllProjects(subproject0) - assertEquals( - setOf(":subproject1", ":subproject0", ":subproject0:subSubproject0a"), task.subprojectPaths, - "Expected subproject0 and subSubproject0a to be added again" - ) - } + fun `add and remove by absolute path`() { + parentTask.addChildTask(":subproject0:dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} as child task" + ) + + parentTask.addChildTask(":subproject0:subSubproject0:dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subSubproject0.dokkaTask.path} being added as child task" + ) + + parentTask.removeChildTask(":subproject0:dokkaTask") + assertEquals( + setOf(subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} being removed as child task" + ) } @Test - fun `configure dokkaTaskNames`() { - parentTasks.forEach { task -> - assertEquals( - 3, task.dokkaTasks.size, - "Expected 3 tasks referenced by default" - ) - - val customDokkaTaskName = "custom${task.name}" - task.dokkaTaskNames = setOf(customDokkaTaskName) - assertTrue(task.dokkaTasks.isEmpty(), "Expected no $customDokkaTaskName. Found: ${task.dokkaTasks}") - - rootProject.subprojects { subproject -> - subproject.tasks.register(customDokkaTaskName) - } - - assertEquals( - 3, task.dokkaTasks.size, - "Expected three $customDokkaTaskName found" - ) - - task.dokkaTasks.forEach { dokkaTask -> - assertEquals(customDokkaTaskName, dokkaTask.name) - } - } + fun `add and remove by relative path`() { + parentTask.addChildTask("subproject0:dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} as child task" + ) + + parentTask.addChildTask("subproject0:subSubproject0:dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subSubproject0.dokkaTask.path} being added as child task" + ) + + parentTask.removeChildTask("subproject0:dokkaTask") + assertEquals( + setOf(subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} being removed as child task" + ) + } + + @Test + fun `add and remove by relative path ob subproject0`() { + val parentTask = subproject0.tasks.create("parent") + + parentTask.addChildTask("subSubproject0:dokkaTask") + assertEquals( + setOf(subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subSubproject0.dokkaTask.path} being registered as child" + ) + + parentTask.removeChildTask("subSubproject0:dokkaTask") + assertEquals( + emptySet(), parentTask.childDokkaTasks, + "Expected ${subSubproject0.dokkaTask.path} being removed as child" + ) + } + + @Test + fun `add and remove by project and name`() { + parentTask.addChildTasks(rootProject.subprojects, "dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask, subproject1.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected all subproject tasks being registered as child task" + ) + + parentTask.removeChildTasks(rootProject.subprojects, "dokkaTask") + assertEquals( + emptySet(), parentTask.childDokkaTasks, + "Expected all tasks being removed" + ) + + parentTask.addChildTasks(listOf(subproject0), "dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected only ${subproject0.dokkaTask.path} being registered as child" + ) + + parentTask.addSubprojectChildTasks("dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask, subproject1.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected all subproject tasks being registered as child task" + ) + + parentTask.removeSubprojectChildTasks("dokkaTask") + assertEquals( + emptySet(), parentTask.childDokkaTasks, + "Expected all tasks being removed" + ) + + parentTask.addSubprojectChildTasks("dokkaTask") + assertEquals( + setOf(subproject0.dokkaTask, subproject1.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected all subproject tasks being registered as child task" + ) + + parentTask.removeChildTasks(subproject0) + assertEquals( + setOf(subproject1.dokkaTask, subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected only ${subproject0.dokkaTask.path} being removed" + ) + + parentTask.addSubprojectChildTasks("dokkaTask") + parentTask.removeChildTasks(listOf(subproject0, subproject1)) + assertEquals( + setOf(subSubproject0.dokkaTask), parentTask.childDokkaTasks, + "Expected ${subproject0.dokkaTask.path} and ${subproject1.dokkaTask.path} being removed" + ) + } + + @Test + fun `adding invalid path will not throw exception`() { + parentTask.addChildTask(":some:stupid:path") + parentTask.childDokkaTasks + } + + @Test + fun `adding non dokka task will throw exception`() { + val badTask = rootProject.tasks.create("badTask") + parentTask.addChildTask(badTask.path) + assertFailsWith { parentTask.childDokkaTasks } + } +} + +internal open class TestDokkaParentTask : AbstractDokkaParentTask() { + override fun buildDokkaConfiguration(): DokkaConfigurationImpl { + throw NotImplementedError() } } + +private val Project.dokkaTask: DokkaTask get() = tasks.getByName("dokkaTask") + + diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTaskTest.kt index 18128e34..d7f0e946 100644 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTaskTest.kt +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTaskTest.kt @@ -1,13 +1,14 @@ package org.jetbrains.dokka.gradle -import org.gradle.api.artifacts.Dependency -import org.gradle.api.artifacts.FileCollectionDependency +import org.gradle.kotlin.dsl.create import org.gradle.kotlin.dsl.withType import org.gradle.testfixtures.ProjectBuilder import org.jetbrains.dokka.DokkaConfigurationImpl +import org.jetbrains.dokka.DokkaException import java.io.File import kotlin.test.Test import kotlin.test.assertEquals +import kotlin.test.assertFailsWith import kotlin.test.assertTrue class DokkaCollectorTaskTest { @@ -32,15 +33,15 @@ class DokkaCollectorTaskTest { val collectorTasks = rootProject.tasks.withType() collectorTasks.configureEach { task -> - task.outputDirectory = File("customOutputDirectory") - task.cacheRoot = File("customCacheRoot") - task.failOnWarning = true - task.offlineMode = true + task.outputDirectory by File("customOutputDirectory") + task.cacheRoot by File("customCacheRoot") + task.failOnWarning by true + task.offlineMode by true } assertTrue(collectorTasks.isNotEmpty(), "Expected at least one collector task") - collectorTasks.forEach { task -> + collectorTasks.toList().forEach { task -> val dokkaConfiguration = task.buildDokkaConfiguration() assertEquals( DokkaConfigurationImpl( @@ -48,17 +49,24 @@ class DokkaCollectorTaskTest { cacheRoot = File("customCacheRoot"), failOnWarning = true, offlineMode = true, - sourceSets = task.dokkaTasks + sourceSets = task.childDokkaTasks .map { it.buildDokkaConfiguration() } .map { it.sourceSets } .reduce { acc, list -> acc + list }, - pluginsClasspath = task.dokkaTasks + pluginsClasspath = task.childDokkaTasks .map { it.plugins.resolve() } .reduce { acc, mutableSet -> acc + mutableSet } ), dokkaConfiguration ) } + } + @Test + fun `with no child tasks throws DokkaException`() { + val project = ProjectBuilder.builder().build() + val collectorTask = project.tasks.create("collector") + project.configurations.all { configuration -> configuration.withDependencies { it.clear() } } + assertFailsWith { collectorTask.generateDocumentation() } } } diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt index 7a3bc2bd..29532877 100644 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt @@ -1,3 +1,5 @@ +@file:Suppress("UnstableApiUsage") + package org.jetbrains.dokka.gradle import org.gradle.kotlin.dsl.withType @@ -19,12 +21,12 @@ class DokkaConfigurationJsonTest { dependencies.clear() } dokkaTask.apply { - this.failOnWarning = true - this.offlineMode = true - this.outputDirectory = File("customOutputDir") - this.cacheRoot = File("customCacheRoot") - this.pluginsConfiguration["0"] = "a" - this.pluginsConfiguration["1"] = "b" + this.failOnWarning by true + this.offlineMode by true + this.outputDirectory by File("customOutputDir") + this.cacheRoot by File("customCacheRoot") + this.pluginsConfiguration.put("0", "a") + this.pluginsConfiguration.put("1", "b") this.dokkaSourceSets.create("main") { sourceSet -> sourceSet.moduleDisplayName by "moduleDisplayName" sourceSet.displayName by "customSourceSetDisplayName" diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt index e4dc5afc..f22a5b8c 100644 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt @@ -13,6 +13,7 @@ import java.net.URL import kotlin.test.Test import kotlin.test.assertEquals +@Suppress("UnstableApiUsage") class DokkaConfigurationSerializableTest { @get:Rule @@ -27,12 +28,12 @@ class DokkaConfigurationSerializableTest { dependencies.clear() } dokkaTask.apply { - this.failOnWarning = true - this.offlineMode = true - this.outputDirectory = File("customOutputDir") - this.cacheRoot = File("customCacheRoot") - this.pluginsConfiguration["0"] = "a" - this.pluginsConfiguration["1"] = "b" + this.failOnWarning by true + this.offlineMode by true + this.outputDirectory by File("customOutputDir") + this.cacheRoot by File("customCacheRoot") + this.pluginsConfiguration.put("0", "a") + this.pluginsConfiguration.put("1", "b") this.dokkaSourceSets.create("main") { sourceSet -> sourceSet.moduleDisplayName by "moduleDisplayName" sourceSet.displayName by "customSourceSetDisplayName" diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt new file mode 100644 index 00000000..36abacfc --- /dev/null +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt @@ -0,0 +1,100 @@ +package org.jetbrains.dokka.gradle + +import org.gradle.kotlin.dsl.create +import org.gradle.testfixtures.ProjectBuilder +import org.jetbrains.dokka.gradle.DokkaMultiModuleFileLayout.CompactInParent +import org.jetbrains.dokka.gradle.DokkaMultiModuleFileLayout.NoCopy +import java.io.File +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class DokkaMultiModuleFileLayoutTest { + + @Test + fun `no copy`() { + val project = ProjectBuilder.builder().build() + val child = project.tasks.create("child") + val parent = project.tasks.create("parent") + child.outputDirectory by File("some/path") + + assertEquals( + File("some/path"), NoCopy.targetChildOutputDirectory(parent, child), + "Expected original file path returned" + ) + } + + @Test + fun `compact in parent`() { + val rootProject = ProjectBuilder.builder().build() + val parentProject = ProjectBuilder.builder().withName("parent").withParent(rootProject).build() + val intermediateProject = ProjectBuilder.builder().withName("intermediate").withParent(parentProject).build() + val childProject = ProjectBuilder.builder().withName("child").withParent(intermediateProject).build() + + val parentTask = parentProject.tasks.create("parentTask") + val childTask = childProject.tasks.create("childTask") + + val targetOutputDirectory = CompactInParent.targetChildOutputDirectory(parentTask, childTask) + assertEquals( + parentTask.outputDirectory.getSafe().resolve("intermediate/child"), targetOutputDirectory, + "Expected nested file structure representing project structure" + ) + } + + @Test + fun copyChildOutputDirectory() { + /* Prepare */ + val project = ProjectBuilder.builder().build() + val childTask = project.tasks.create("child") + val parentTask = project.tasks.create("parent") + + val sourceOutputDirectory = childTask.outputDirectory.getSafe() + sourceOutputDirectory.mkdirs() + sourceOutputDirectory.resolve("some.file").writeText("some text") + val subFolder = sourceOutputDirectory.resolve("subFolder") + subFolder.mkdirs() + subFolder.resolve("other.file").writeText("other text") + + val layout = object : DokkaMultiModuleFileLayout { + override fun targetChildOutputDirectory(parent: AbstractDokkaParentTask, child: AbstractDokkaTask): File { + return parent.project.file("target/output") + } + } + layout.copyChildOutputDirectory(parentTask, childTask) + + /* Assertions */ + val targetOutputDirectory = project.file("target/output") + assertTrue( + targetOutputDirectory.exists() && targetOutputDirectory.isDirectory, + "Expected target output directory ${targetOutputDirectory.path} to exist" + ) + + val targetSomeFile = targetOutputDirectory.resolve("some.file") + assertTrue( + targetSomeFile.exists() && targetSomeFile.isFile, + "Expected sample file to exist in target output directory" + ) + + assertEquals( + "some text", targetSomeFile.readText(), + "Expected content to be written into sample file" + ) + + val targetSubFolder = targetOutputDirectory.resolve("subFolder") + assertTrue( + targetSubFolder.exists() && targetSubFolder.isDirectory, + "Expected sub folder being present in target output directory" + ) + + val targetOtherFile = targetSubFolder.resolve("other.file") + assertTrue( + targetOtherFile.exists() && targetOtherFile.isFile, + "Expected nested 'other.file' being copied into target" + ) + + assertEquals( + "other text", targetOtherFile.readText(), + "Expected content to be written into 'other.file'" + ) + } +} diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt index 8814a897..a7c9946d 100644 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt @@ -1,13 +1,17 @@ +@file:Suppress("UnstableApiUsage") + package org.jetbrains.dokka.gradle import org.gradle.kotlin.dsl.create import org.gradle.kotlin.dsl.withType import org.gradle.testfixtures.ProjectBuilder import org.jetbrains.dokka.DokkaConfigurationImpl +import org.jetbrains.dokka.DokkaException import org.jetbrains.dokka.DokkaModuleDescriptionImpl import java.io.File import kotlin.test.Test import kotlin.test.assertEquals +import kotlin.test.assertFailsWith import kotlin.test.assertTrue class DokkaMultiModuleTaskTest { @@ -47,19 +51,19 @@ class DokkaMultiModuleTaskTest { @Test fun buildDokkaConfiguration() { childProject.tasks.withType().configureEach { task -> - task.outputDirectory = task.project.buildDir.resolve("output") + task.outputDirectory by task.project.buildDir.resolve("output") } - val multimoduleTasks = rootProject.tasks.withType() + val multimoduleTasks = rootProject.tasks.withType() assertTrue(multimoduleTasks.isNotEmpty(), "Expected at least one multimodule task") multimoduleTasks.configureEach { task -> task.documentationFileName = "customDocumentationFileName.md" - task.outputDirectory = task.project.buildDir.resolve("customOutputDirectory") - task.cacheRoot = File("customCacheRoot") - task.pluginsConfiguration["pluginA"] = "configA" - task.failOnWarning = true - task.offlineMode = true + task.outputDirectory by task.project.buildDir.resolve("customOutputDirectory") + task.cacheRoot by File("customCacheRoot") + task.pluginsConfiguration.put("pluginA", "configA") + task.failOnWarning by true + task.offlineMode by true } multimoduleTasks.forEach { task -> @@ -75,7 +79,7 @@ class DokkaMultiModuleTaskTest { modules = listOf( DokkaModuleDescriptionImpl( name = "child", - path = File("../../child/build/output"), + path = File("child"), docFile = childProject.projectDir.resolve("customDocumentationFileName.md") ) ) @@ -87,7 +91,7 @@ class DokkaMultiModuleTaskTest { @Test fun `setting dokkaTaskNames declares proper task dependencies`() { - val multimoduleTasks = rootProject.tasks.withType() + val multimoduleTasks = rootProject.tasks.withType() assertTrue(multimoduleTasks.isNotEmpty(), "Expected at least one multimodule task") multimoduleTasks.toList().forEach { task -> @@ -102,11 +106,75 @@ class DokkaMultiModuleTaskTest { val customDokkaTask = childProject.tasks.create("customDokkaTask") multimoduleTasks.toList().forEach { task -> - task.dokkaTaskNames += "customDokkaTask" + task.addSubprojectChildTasks("customDokkaTask") val dependencies = task.taskDependencies.getDependencies(task).toSet() assertEquals(2, dependencies.size, "Expected two dependencies") assertTrue(customDokkaTask in dependencies, "Expected 'customDokkaTask' in dependencies") } } + + @Test + fun `multimodule task with no child tasks throws DokkaException`() { + val project = ProjectBuilder.builder().build() + val multimodule = project.tasks.create("multimodule") + project.configurations.configureEach { it.withDependencies { it.clear() } } + assertFailsWith { multimodule.generateDocumentation() } + } + + @Test + fun childDocumentationFiles() { + val parent = ProjectBuilder.builder().build() + val child = ProjectBuilder.builder().withName("child").withParent(parent).build() + + val parentTask = parent.tasks.create("parent") + val childTask = child.tasks.create("child") + + parentTask.addChildTask(childTask) + parentTask.documentationFileName = "module.txt" + + assertEquals( + listOf(parent.file("child/module.txt")), parentTask.childDocumentationFiles, + "Expected child documentation file being present" + ) + } + + @Test + fun sourceChildOutputDirectories() { + val parent = ProjectBuilder.builder().build() + val child = ProjectBuilder.builder().withName("child").withParent(parent).build() + + val parentTask = parent.tasks.create("parent") + val childTask = child.tasks.create("child") + + parentTask.addChildTask(childTask) + childTask.outputDirectory by child.file("custom/output") + + assertEquals( + listOf(parent.file("child/custom/output")), parentTask.sourceChildOutputDirectories, + "Expected child output directory being present" + ) + } + + @Test + fun targetChildOutputDirectories() { + val parent = ProjectBuilder.builder().build() + val child = ProjectBuilder.builder().withName("child").withParent(parent).build() + + val parentTask = parent.tasks.create("parent") + val childTask = child.tasks.create("child") + + parentTask.addChildTask(childTask) + parentTask.fileLayout = object : DokkaMultiModuleFileLayout { + override fun targetChildOutputDirectory(parent: AbstractDokkaParentTask, child: AbstractDokkaTask): File { + return parent.project.buildDir.resolve(child.name) + } + } + + assertEquals( + listOf(parent.project.buildDir.resolve("child")), parentTask.targetChildOutputDirectories, + "Expected child target output directory being present" + ) + + } } diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaPluginApplyTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaPluginApplyTest.kt new file mode 100644 index 00000000..db218b9f --- /dev/null +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaPluginApplyTest.kt @@ -0,0 +1,84 @@ +package org.jetbrains.dokka.gradle + +import org.gradle.api.plugins.JavaBasePlugin +import org.gradle.kotlin.dsl.withType +import org.gradle.testfixtures.ProjectBuilder +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertSame +import kotlin.test.assertTrue + +class DokkaPluginApplyTest { + + @Test + fun `one task per format is registered`() { + val project = ProjectBuilder.builder().build() + project.plugins.apply("org.jetbrains.dokka") + + assertTrue( + project.tasks.findByName("dokkaHtml") is DokkaTask, + "Expected DokkaTask: dokkaHtml" + ) + + assertTrue( + project.tasks.findByName("dokkaGfm") is DokkaTask, + "Expected DokkaTask: dokkaGfm" + ) + + assertTrue( + project.tasks.findByName("dokkaJekyll") is DokkaTask, + "Expected DokkaTask: dokkaJekyll" + ) + + assertTrue( + project.tasks.findByName("dokkaJavadoc") is DokkaTask, + "Expected DokkaTask: dokkaJavadoc" + ) + } + + @Test + fun `dokka plugin configurations extend dokkaPlugin`() { + val project = ProjectBuilder.builder().build() + project.plugins.apply("org.jetbrains.dokka") + + val dokkaPluginsConfiguration = project.maybeCreateDokkaDefaultPluginConfiguration() + + project.tasks.withType().forEach { dokkaTask -> + assertSame( + dokkaTask.plugins.extendsFrom.single(), dokkaPluginsConfiguration, + "Expected dokka plugins configuration to extend default ${dokkaPluginsConfiguration.name} configuration" + ) + } + } + + @Test + fun `all dokka tasks are part of the documentation group`() { + val project = ProjectBuilder.builder().build() + project.plugins.apply("org.jetbrains.dokka") + project.tasks.filter { "dokka" in it.name.toLowerCase() }.forEach { dokkaTask -> + assertEquals( + JavaBasePlugin.DOCUMENTATION_GROUP, dokkaTask.group, + "Expected task: ${dokkaTask.path} group to be ${JavaBasePlugin.DOCUMENTATION_GROUP}" + ) + } + } + + @Test + fun `parent dokka tasks have children configured`() { + val root = ProjectBuilder.builder().withName("root").build() + val child = ProjectBuilder.builder().withName("child").withParent(root).build() + root.plugins.apply("org.jetbrains.dokka") + child.plugins.apply("org.jetbrains.dokka") + + val parentTasks = root.tasks.withType() + assertTrue(parentTasks.isNotEmpty(), "Expected at least one parent task being created") + + parentTasks.toList().forEach { parentTask -> + assertEquals(1, parentTask.childDokkaTasks.size, "Expected one child dokka task") + assertEquals( + child, parentTask.childDokkaTasks.single().project, + "Expected child dokka task from child project" + ) + } + } +} diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaTasksTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaTasksTest.kt deleted file mode 100644 index b948c540..00000000 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaTasksTest.kt +++ /dev/null @@ -1,65 +0,0 @@ -package org.jetbrains.dokka.gradle - -import org.gradle.api.plugins.JavaBasePlugin -import org.gradle.kotlin.dsl.withType -import org.gradle.testfixtures.ProjectBuilder -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertSame -import kotlin.test.assertTrue - -class DokkaTasksTest { - - @Test - fun `one task per format is registered`() { - val project = ProjectBuilder.builder().build() - project.plugins.apply("org.jetbrains.dokka") - - assertTrue( - project.tasks.findByName("dokkaHtml") is DokkaTask, - "Expected DokkaTask: dokkaHtml" - ) - - assertTrue( - project.tasks.findByName("dokkaGfm") is DokkaTask, - "Expected DokkaTask: dokkaGfm" - ) - - assertTrue( - project.tasks.findByName("dokkaJekyll") is DokkaTask, - "Expected DokkaTask: dokkaJekyll" - ) - - assertTrue( - project.tasks.findByName("dokkaJavadoc") is DokkaTask, - "Expected DokkaTask: dokkaJavadoc" - ) - } - - @Test - fun `dokka plugin configurations extend dokkaPlugin`() { - val project = ProjectBuilder.builder().build() - project.plugins.apply("org.jetbrains.dokka") - - val dokkaPluginsConfiguration = project.maybeCreateDokkaDefaultPluginConfiguration() - - project.tasks.withType().forEach { dokkaTask -> - assertSame( - dokkaTask.plugins.extendsFrom.single(), dokkaPluginsConfiguration, - "Expected dokka plugins configuration to extend default ${dokkaPluginsConfiguration.name} configuration" - ) - } - } - - @Test - fun `all dokka tasks are part of the documentation group`() { - val project = ProjectBuilder.builder().build() - project.plugins.apply("org.jetbrains.dokka") - project.tasks.filter { "dokka" in it.name.toLowerCase() }.forEach { dokkaTask -> - assertEquals( - JavaBasePlugin.DOCUMENTATION_GROUP, dokkaTask.group, - "Expected task: ${dokkaTask.path} group to be ${JavaBasePlugin.DOCUMENTATION_GROUP}" - ) - } - } -} diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt index 013ad3f2..6a356b79 100644 --- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt +++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt @@ -1,6 +1,6 @@ package org.jetbrains.dokka.gradle -import dokka +import org.gradle.kotlin.dsl.withType import org.gradle.testfixtures.ProjectBuilder import org.jetbrains.dokka.DokkaSourceSetID import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension @@ -9,17 +9,16 @@ import kotlin.test.Test import kotlin.test.assertEquals class KotlinDslDokkaTaskConfigurationTest { - @Test - fun `configure project using dokka extension function`() { + fun `configure dokka task`() { val project = ProjectBuilder.builder().build() project.plugins.apply("org.jetbrains.dokka") - project.dokka { - outputDirectory = File("test") + project.tasks.withType().configureEach { + it.outputDirectory by File("test") } project.tasks.withType(DokkaTask::class.java).forEach { dokkaTask -> - assertEquals(File("test"), dokkaTask.outputDirectory) + assertEquals(File("test"), dokkaTask.outputDirectory.getSafe()) } } -- cgit