diff options
Diffstat (limited to 'runners/gradle-integration-tests/src/test')
6 files changed, 315 insertions, 0 deletions
diff --git a/runners/gradle-integration-tests/src/test/java/com/intellij/rt/execution/junit/FileComparisonFailure.java b/runners/gradle-integration-tests/src/test/java/com/intellij/rt/execution/junit/FileComparisonFailure.java new file mode 100644 index 00000000..cbb1cc3c --- /dev/null +++ b/runners/gradle-integration-tests/src/test/java/com/intellij/rt/execution/junit/FileComparisonFailure.java @@ -0,0 +1,39 @@ + +package com.intellij.rt.execution.junit; + +import junit.framework.ComparisonFailure; + +public class FileComparisonFailure extends ComparisonFailure implements KnownException { + private final String myExpected; + private final String myActual; + private final String myFilePath; + private final String myActualFilePath; + + public FileComparisonFailure(String message, String expected, String actual, String filePath) { + this(message, expected, actual, filePath, (String)null); + } + + public FileComparisonFailure(String message, String expected, String actual, String expectedFilePath, String actualFilePath) { + super(message, expected, actual); + this.myExpected = expected; + this.myActual = actual; + this.myFilePath = expectedFilePath; + this.myActualFilePath = actualFilePath; + } + + public String getFilePath() { + return this.myFilePath; + } + + public String getActualFilePath() { + return this.myActualFilePath; + } + + public String getExpected() { + return this.myExpected; + } + + public String getActual() { + return this.myActual; + } +} diff --git a/runners/gradle-integration-tests/src/test/java/com/intellij/rt/execution/junit/KnownException.java b/runners/gradle-integration-tests/src/test/java/com/intellij/rt/execution/junit/KnownException.java new file mode 100644 index 00000000..c24653ea --- /dev/null +++ b/runners/gradle-integration-tests/src/test/java/com/intellij/rt/execution/junit/KnownException.java @@ -0,0 +1,6 @@ + +package com.intellij.rt.execution.junit; + +interface KnownException { + +} diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaGradleTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaGradleTest.kt new file mode 100644 index 00000000..f93e1868 --- /dev/null +++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaGradleTest.kt @@ -0,0 +1,106 @@ +package org.jetbrains.dokka.gradle + + +import com.intellij.rt.execution.junit.FileComparisonFailure +import org.gradle.testkit.runner.GradleRunner +import org.junit.Rule +import org.junit.rules.TemporaryFolder +import java.io.File +import java.nio.file.Files +import java.nio.file.Paths + + +val testDataFolder = Paths.get("testData") + +val pluginClasspathData = Paths.get("build", "createClasspathManifest", "dokka-plugin-classpath.txt") +val androidPluginClasspathData = pluginClasspathData.resolveSibling("android-dokka-plugin-classpath.txt") + +val dokkaFatJarPathData = pluginClasspathData.resolveSibling("fatjar.txt") + +abstract class AbstractDokkaGradleTest { + @get:Rule val testProjectDir = TemporaryFolder() + + open val pluginClasspath: List<File> = pluginClasspathData.toFile().readLines().map { File(it) } + + fun checkOutputStructure(expected: String, actualSubpath: String) { + val expectedPath = testDataFolder.resolve(expected) + val actualPath = testProjectDir.root.toPath().resolve(actualSubpath).normalize() + + assertEqualsIgnoringSeparators(expectedPath.toFile(), buildString { + actualPath.toFile().writeStructure(this, File(actualPath.toFile(), ".")) + }) + } + + fun checkNoErrorClasses(actualSubpath: String, extension: String = "html", errorClassMarker: String = "ERROR CLASS") { + val actualPath = testProjectDir.root.toPath().resolve(actualSubpath).normalize() + var checked = 0 + Files.walk(actualPath).filter { Files.isRegularFile(it) && it.fileName.toString().endsWith(".$extension") }.forEach { + val text = it.toFile().readText() + + val noErrorClasses = text.replace(errorClassMarker, "?!") + + if (noErrorClasses != text) { + throw FileComparisonFailure("", noErrorClasses, text, null) + } + + checked++ + } + println("$checked files checked for error classes") + } + + fun checkNoUnresolvedLinks(actualSubpath: String, extension: String = "html", marker: Regex = "[\"']#[\"']".toRegex()) { + val actualPath = testProjectDir.root.toPath().resolve(actualSubpath).normalize() + var checked = 0 + Files.walk(actualPath).filter { Files.isRegularFile(it) && it.fileName.toString().endsWith(".$extension") }.forEach { + val text = it.toFile().readText() + + val noErrorClasses = text.replace(marker, "?!") + + if (noErrorClasses != text) { + throw FileComparisonFailure("", noErrorClasses, text, null) + } + + checked++ + } + println("$checked files checked for unresolved links") + } + + fun checkExternalLink(actualSubpath: String, linkBody: String, fullLink: String, extension: String = "html") { + val match = "!!match!!" + val notMatch = "!!not-match!!" + + val actualPath = testProjectDir.root.toPath().resolve(actualSubpath).normalize() + var checked = 0 + var totalEntries = 0 + Files.walk(actualPath).filter { Files.isRegularFile(it) && it.fileName.toString().endsWith(".$extension") }.forEach { + val text = it.toFile().readText() + + val textWithoutMatches = text.replace(fullLink, match) + + val textWithoutNonMatches = textWithoutMatches.replace(linkBody, notMatch) + + if (textWithoutNonMatches != textWithoutMatches) { + + val expected = textWithoutNonMatches.replace(notMatch, fullLink).replace(match, fullLink) + val actual = textWithoutMatches.replace(match, fullLink) + + throw FileComparisonFailure("", expected, actual, null) + } + if (text != textWithoutMatches) + totalEntries++ + + checked++ + } + println("$checked files checked for valid external links '$linkBody', found $totalEntries links") + } + + fun configure(gradleVersion: String = "3.5", kotlinVersion: String = "1.1.2", arguments: Array<String>): GradleRunner { + val fatjar = dokkaFatJarPathData.toFile().readText() + + return GradleRunner.create().withProjectDir(testProjectDir.root) + .withArguments("-Pdokka_fatjar=$fatjar", "-Ptest_kotlin_version=$kotlinVersion", *arguments) + .withPluginClasspath(pluginClasspath) + .withGradleVersion(gradleVersion) + .withDebug(true) + } +}
\ No newline at end of file diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt new file mode 100644 index 00000000..f9801c82 --- /dev/null +++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt @@ -0,0 +1,51 @@ +package org.jetbrains.dokka.gradle + +import org.gradle.testkit.runner.TaskOutcome +import org.junit.Test +import kotlin.test.assertEquals + +class BasicTest : AbstractDokkaGradleTest() { + + fun prepareTestData(testDataRootPath: String) { + val testDataRoot = testDataFolder.resolve(testDataRootPath) + val tmpRoot = testProjectDir.root.toPath() + + testDataRoot.resolve("src").copy(tmpRoot.resolve("src")) + testDataRoot.resolve("build.gradle").copy(tmpRoot.resolve("build.gradle")) + testDataRoot.resolve("settings.gradle").copy(tmpRoot.resolve("settings.gradle")) + } + + private fun doTest(gradleVersion: String, kotlinVersion: String) { + + prepareTestData("basic") + + val result = configure(gradleVersion, kotlinVersion, arguments = arrayOf("dokka", "--stacktrace")).build() + + println(result.output) + + assertEquals(TaskOutcome.SUCCESS, result.task(":dokka")?.outcome) + + val docsOutput = "build/dokka" + + checkOutputStructure("basic/fileTree.txt", docsOutput) + + checkNoErrorClasses(docsOutput) + checkNoUnresolvedLinks(docsOutput) + + checkExternalLink(docsOutput, "<span class=\"identifier\">String</span>", + """<a href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html"><span class="identifier">String</span></a>""") + } + + @Test fun `test kotlin 1_1_2 and gradle 3_5`() { + doTest("3.5", "1.1.2") + } + + @Test fun `test kotlin 1_0_7 and gradle 2_14_1`() { + doTest("2.14.1", "1.0.7") + } + + @Test fun `test kotlin 1_1_2 and gradle 4_0`() { + doTest("4.0", "1.1.2") + } + +}
\ No newline at end of file diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt new file mode 100644 index 00000000..13c7c37e --- /dev/null +++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt @@ -0,0 +1,54 @@ +package org.jetbrains.dokka.gradle + +import org.gradle.testkit.runner.TaskOutcome +import org.junit.Test +import kotlin.test.assertEquals + +class MultiProjectSingleOutTest : AbstractDokkaGradleTest() { + + fun prepareTestData(testDataRootPath: String) { + val testDataRoot = testDataFolder.resolve(testDataRootPath) + val tmpRoot = testProjectDir.root.toPath() + + testDataRoot.apply { + resolve("build.gradle").copy(tmpRoot.resolve("build.gradle")) + resolve("settings.gradle").copy(tmpRoot.resolve("settings.gradle")) + resolve("subA").copy(tmpRoot.resolve("subA")) + resolve("subB").copy(tmpRoot.resolve("subB")) + } + } + + private fun doTest(gradleVersion: String, kotlinVersion: String) { + + prepareTestData("multiProjectSingleOut") + + val result = configure(gradleVersion, kotlinVersion, arguments = arrayOf("dokka", "--stacktrace")).build() + + println(result.output) + + assertEquals(TaskOutcome.SUCCESS, result.task(":dokka")?.outcome) + + val docsOutput = "build/dokka" + + checkOutputStructure("multiProjectSingleOut/fileTree.txt", docsOutput) + + checkNoErrorClasses(docsOutput) + checkNoUnresolvedLinks(docsOutput) + + checkExternalLink(docsOutput, "<span class=\"identifier\">String</span>", + """<a href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html"><span class="identifier">String</span></a>""") + } + + @Test fun `test kotlin 1_1_2 and gradle 3_5`() { + doTest("3.5", "1.1.2") + } + + @Test fun `test kotlin 1_0_7 and gradle 2_14_1`() { + doTest("2.14.1", "1.0.7") + } + + @Test fun `test kotlin 1_1_2 and gradle 4_0`() { + doTest("4.0", "1.1.2") + } + +}
\ No newline at end of file diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/Utils.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/Utils.kt new file mode 100644 index 00000000..d44459b1 --- /dev/null +++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/Utils.kt @@ -0,0 +1,59 @@ +package org.jetbrains.dokka.gradle + +import com.intellij.rt.execution.junit.FileComparisonFailure +import java.io.File +import java.io.IOException +import java.nio.file.FileVisitResult +import java.nio.file.Files +import java.nio.file.Path +import java.nio.file.SimpleFileVisitor +import java.nio.file.attribute.BasicFileAttributes + + +fun File.writeStructure(builder: StringBuilder, relativeTo: File = this, spaces: Int = 0) { + builder.append(" ".repeat(spaces)) + val out = if (this != relativeTo) this.relativeTo(relativeTo) else this + + builder.append(out) + if (this.isDirectory) { + builder.appendln("/") + this.listFiles().sortedBy { it.name }.forEach { it.writeStructure(builder, this, spaces + 4) } + } else { + builder.appendln() + } +} + +fun assertEqualsIgnoringSeparators(expectedFile: File, output: String) { + if (!expectedFile.exists()) expectedFile.createNewFile() + val expectedText = expectedFile.readText().replace("\r\n", "\n") + val actualText = output.replace("\r\n", "\n") + + if (expectedText != actualText) + throw FileComparisonFailure("", expectedText, actualText, expectedFile.canonicalPath) +} + +class CopyFileVisitor(private var sourcePath: Path?, private val targetPath: Path) : SimpleFileVisitor<Path>() { + + @Throws(IOException::class) + override fun preVisitDirectory(dir: Path, + attrs: BasicFileAttributes): FileVisitResult { + if (sourcePath == null) { + sourcePath = dir + } else { + Files.createDirectories(targetPath.resolve(sourcePath?.relativize(dir))) + } + return FileVisitResult.CONTINUE + } + + @Throws(IOException::class) + override fun visitFile(file: Path, + attrs: BasicFileAttributes): FileVisitResult { + Files.copy(file, targetPath.resolve(sourcePath?.relativize(file))) + return FileVisitResult.CONTINUE + } +} + +fun Path.copy(to: Path) { + Files.walkFileTree(this, CopyFileVisitor(this, to)) +} + |