From ee425e0b1e39245f5e1106bbb0888e557e6fbfcd Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Tue, 9 Jun 2020 13:40:03 +0200
Subject: Implement "failOnWarning" option

---
 .../src/test/kotlin/basic/FailOnWarningTest.kt     | 118 +++++++++++++++++++++
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt |  14 +--
 2 files changed, 126 insertions(+), 6 deletions(-)
 create mode 100644 plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt

(limited to 'plugins/base/src/test/kotlin')

diff --git a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
new file mode 100644
index 00000000..2c805110
--- /dev/null
+++ b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
@@ -0,0 +1,118 @@
+package basic
+
+import org.jetbrains.dokka.DokkaException
+import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
+import org.jetbrains.dokka.utilities.DokkaConsoleLogger
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import testApi.logger.TestLogger
+
+class FailOnWarningTest : AbstractCoreTest() {
+
+    @Test
+    fun `throws exception if one or more warnings were emitted`() {
+        val configuration = dokkaConfiguration {
+            failOnWarning = true
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin")
+                }
+            }
+        }
+
+        assertThrows<DokkaException> {
+            testInline(
+                """
+                |/src/main/kotlin
+                |package sample
+                """.trimIndent(), configuration
+            ) {
+                analysisSetupStage = {
+                    logger.warn("Warning!")
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `throws exception if one or more error were emitted`() {
+        val configuration = dokkaConfiguration {
+            failOnWarning = true
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin")
+                }
+            }
+        }
+
+        assertThrows<DokkaException> {
+            testInline(
+                """
+                |/src/main/kotlin
+                |package sample
+                """.trimIndent(), configuration
+            ) {
+                analysisSetupStage = {
+                    logger.error("Error!")
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `does not throw if now warning or error was emitted`() {
+        logger = TestLogger(ZeroErrorOrWarningCountDokkaLogger())
+
+        val configuration = dokkaConfiguration {
+            failOnWarning = true
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin")
+                }
+            }
+        }
+
+
+        testInline(
+            """
+                |/src/main/kotlin
+                |package sample
+                """.trimIndent(), configuration
+        ) {
+            /* We expect no Exception */
+        }
+    }
+
+    @Test
+    fun `does not throw if disabled`() {
+        val configuration = dokkaConfiguration {
+            failOnWarning = false
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin")
+                }
+            }
+        }
+
+
+        testInline(
+            """
+                |/src/main/kotlin
+                |package sample
+                """.trimIndent(), configuration
+        ) {
+            analysisSetupStage = {
+                logger.warn("Error!")
+                logger.error("Error!")
+            }
+        }
+    }
+}
+
+private class ZeroErrorOrWarningCountDokkaLogger(
+    logger: DokkaLogger = DokkaConsoleLogger
+) : DokkaLogger by logger {
+    override var warningsCount: Int = 0
+    override var errorsCount: Int = 0
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index a4d7bd04..452439e9 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -36,7 +36,9 @@ abstract class RenderingOnlyTestBase {
         DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
         DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
         sourceSetCache = SourceSetCache(),
-        testConfiguration = DokkaConfigurationImpl("", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList())
+        testConfiguration = DokkaConfigurationImpl(
+            "", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList(), false
+        )
     )
 
     protected val renderedContent: Element by lazy {
@@ -50,7 +52,7 @@ abstract class RenderingOnlyTestBase {
 
 }
 
-class TestPage(callback: PageContentBuilder.DocumentableContentBuilder.() -> Unit): RootPageNode(), ContentPage {
+class TestPage(callback: PageContentBuilder.DocumentableContentBuilder.() -> Unit) : RootPageNode(), ContentPage {
     override val dri: Set<DRI> = setOf(DRI.topLevel)
     override val documentable: Documentable? = null
     override val embeddedResources: List<String> = emptyList()
@@ -88,14 +90,14 @@ fun Element.match(vararg matchers: Any): Unit =
         .forEach { (n, m) -> m.accepts(n) }
 
 open class Tag(val name: String, vararg val matchers: Any)
-class Div(vararg matchers: Any): Tag("div", *matchers)
-class P(vararg matchers: Any): Tag("p", *matchers)
-class Span(vararg matchers: Any): Tag("span", *matchers)
+class Div(vararg matchers: Any) : Tag("div", *matchers)
+class P(vararg matchers: Any) : Tag("p", *matchers)
+class Span(vararg matchers: Any) : Tag("span", *matchers)
 
 private fun Any.accepts(n: Node) {
     when (this) {
         is String -> assert(n is TextNode && n.text().trim() == this.trim()) { "\"$this\" expected but found: $n" }
-        is Tag ->  {
+        is Tag -> {
             assert(n is Element && n.tagName() == name) { "Tag $name expected but found: $n" }
             if (n is Element && matchers.isNotEmpty()) n.match(*matchers)
         }
-- 
cgit