Migrate diktat smoke tests to SAVE-cli mechanism

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/smoke/DiktatSaveSmokeTest.kt

@@ -0,0 +1,204 @@
+package org.cqfn.diktat.ruleset.smoke
+
+import org.cqfn.diktat.common.config.rules.DIKTAT_COMMON
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.common.config.rules.RulesConfigReader
+import org.cqfn.diktat.ruleset.constants.Warnings
+import org.cqfn.diktat.ruleset.rules.DiktatRuleSetProvider
+import org.cqfn.diktat.util.FixTestBase
+
+import com.charleskorn.kaml.Yaml
+import com.charleskorn.kaml.YamlConfiguration
+import com.pinterest.ktlint.core.LintError
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+
+import java.time.LocalDate
+
+import kotlin.io.path.createTempFile
+import kotlinx.serialization.builtins.ListSerializer
+
+class DiktatSaveSmokeTest : FixTestBase("test/smoke/src/main/kotlin",
+    { DiktatRuleSetProvider(configFilePath) },
+    { lintError, _ -> unfixedLintErrors.add(lintError) },
+) {
+    /**
+     * Disable some of the rules.
+     */
+    @Suppress("UnsafeCallOnNullableType")
+    private fun overrideRulesConfig(rulesToDisable: List<Warnings>, rulesToOverride: RuleToConfig = emptyMap()) {
+        val rulesConfig = RulesConfigReader(javaClass.classLoader).readResource(DEFAULT_CONFIG_PATH)!!
+            .toMutableList()
+            .also { rulesConfig ->
+                rulesToDisable.forEach { warning ->
+                    rulesConfig.removeIf { it.name == warning.name }
+                    rulesConfig.add(RulesConfig(warning.name, enabled = false, configuration = emptyMap()))
+                }
+                rulesToOverride.forEach { (warning, configuration) ->
+                    rulesConfig.removeIf { it.name == warning }
+                    rulesConfig.add(RulesConfig(warning, enabled = true, configuration = configuration))
+                }
+            }
+            .toList()
+        createTempFile().toFile()
+            .also {
+                configFilePath = it.absolutePath
+            }
+            .writeText(
+                Yaml(configuration = YamlConfiguration(strictMode = true))
+                    .encodeToString(ListSerializer(RulesConfig.serializer()), rulesConfig)
+            )
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #1`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "Bug1Expected.kt", "Bug1Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #2`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "DefaultPackageExpected.kt", "DefaultPackageTest.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #3`() {
+        overrideRulesConfig(
+            rulesToDisable = emptyList(),
+            rulesToOverride = mapOf(
+                Warnings.WRONG_INDENTATION.name to mapOf(
+                    "extendedIndentAfterOperators" to "true",
+                    "extendedIndentBeforeDot" to "false",
+                )
+            )
+        )
+        saveSmokeTest(configFilePath, "Example1Expected.kt", "Example1Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #4`() {
+        overrideRulesConfig(
+            rulesToDisable = emptyList(),
+            rulesToOverride = mapOf(
+                Warnings.WRONG_INDENTATION.name to mapOf(
+                    "extendedIndentAfterOperators" to "true",
+                    "extendedIndentBeforeDot" to "true",
+                )
+            )
+        )
+        saveSmokeTest(configFilePath, "Example2Expected.kt", "Example2Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #5`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "Example3Expected.kt", "Example3Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #6`() {
+        overrideRulesConfig(
+            rulesToDisable = emptyList(),
+            rulesToOverride = mapOf(
+                Warnings.WRONG_INDENTATION.name to mapOf(
+                    "extendedIndentAfterOperators" to "true",
+                    "extendedIndentBeforeDot" to "false",
+                )
+            )
+        )
+        saveSmokeTest(configFilePath, "Example4Expected.kt", "Example4Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #7`() {
+        overrideRulesConfig(emptyList(),
+            mapOf(
+                Warnings.HEADER_MISSING_OR_WRONG_COPYRIGHT.name to mapOf(
+                    "isCopyrightMandatory" to "true",
+                    "copyrightText" to """|Copyright 2018-${LocalDate.now().year} John Doe.
+                                    |    Licensed under the Apache License, Version 2.0 (the "License");
+                                    |    you may not use this file except in compliance with the License.
+                                    |    You may obtain a copy of the License at
+                                    |
+                                    |        http://www.apache.org/licenses/LICENSE-2.0
+                                """.trimMargin()
+                ),
+                DIKTAT_COMMON to mapOf(
+                    "domainName" to "org.cqfn.diktat",
+                    "kotlinVersion" to "1.3.7"
+                )
+            )
+        )
+        saveSmokeTest(configFilePath, "Example5Expected.kt", "Example5Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #8`() {
+        overrideRulesConfig(
+            rulesToDisable = emptyList(),
+            rulesToOverride = mapOf(
+                Warnings.WRONG_INDENTATION.name to mapOf(
+                    "extendedIndentAfterOperators" to "true",
+                    "extendedIndentBeforeDot" to "true",
+                )
+            )
+        )
+        saveSmokeTest(configFilePath, "Example6Expected.kt", "Example6Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #9`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "Example7Expected.kt", "Example7Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #10`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "Example8Expected.kt", "Example8Test.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #11`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "KdocFormattingMultilineTagsExpected.kt", "KdocFormattingMultilineTagsTest.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #12`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "ManyLineTransformInLongLineExpected.kt", "ManyLineTransformInLongLineTest.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test #13`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "LocalVariableWithOffsetExpected.kt", "LocalVariableWithOffsetTest.kt")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test with kts files #2`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "script/SimpleRunInScriptExpected.kts", "script/SimpleRunInScriptTest.kts")
+    }
+
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `save smoke test with kts files with package name`() {
+        saveSmokeTest(DEFAULT_CONFIG_PATH, "script/PackageInScriptExpected.kts", "script/PackageInScriptTest.kts")
+    }
+
+    companion object {
+        private const val DEFAULT_CONFIG_PATH = "../diktat-analysis.yml"
+        private val unfixedLintErrors: MutableList<LintError> = mutableListOf()
+
+        // by default using same yml config as for diktat code style check, but allow to override
+        private var configFilePath = DEFAULT_CONFIG_PATH
+    }
+}

diktat-rules/src/test/kotlin/org/cqfn/diktat/util/FixTestBase.kt

@@ -6,8 +6,10 @@ import org.cqfn.diktat.test.framework.processing.TestComparatorUnit
 
 import com.pinterest.ktlint.core.Rule
 import com.pinterest.ktlint.core.RuleSetProvider
+import org.apache.commons.io.FileUtils.copyFile
 import org.intellij.lang.annotations.Language
 import org.junit.jupiter.api.Assertions
+import java.io.File
 
 import java.nio.file.Path
 import kotlin.io.path.bufferedWriter
@@ -19,11 +21,12 @@ import kotlin.io.path.div
 open class FixTestBase(protected val resourceFilePath: String,
                        private val ruleSetProviderRef: (rulesConfigList: List<RulesConfig>?) -> RuleSetProvider,
                        private val cb: LintErrorCallback = defaultCallback,
-                       private val rulesConfigList: List<RulesConfig>? = null
+                       private val rulesConfigList: List<RulesConfig>? = null,
 ) {
     private val testComparatorUnit = TestComparatorUnit(resourceFilePath) { text, fileName ->
         format(ruleSetProviderRef, text, fileName, rulesConfigList, cb = cb)
     }
+    private val diktatVersion = "1.2.1-SNAPSHOT"
 
     constructor(resourceFilePath: String,
                 ruleSupplier: (rulesConfigList: List<RulesConfig>) -> Rule,
@@ -58,6 +61,56 @@ open class FixTestBase(protected val resourceFilePath: String,
         )
     }
 
+    private fun getSaveForCurrentOs() = when {
+        System.getProperty("os.name").startsWith("Linux", ignoreCase = true) -> "save-linuxX64.kexe"
+        System.getProperty("os.name").startsWith("Mac", ignoreCase = true) -> "save-macosX64.kexe"
+        System.getProperty("os.name").startsWith("Windows", ignoreCase = true) -> "save.exe"
+        else -> ""
+    }
+
+    /**
+     * @param expectedPath path to file with expected result, relative to [resourceFilePath]
+     * @param testPath path to file with code that will be transformed by formatter, relative to [resourceFilePath]
+     * @param configFilePath path of diktat-analysis file
+     */
+    protected fun saveSmokeTest(
+        configFilePath: String,
+        expectedPath: String,
+        testPath: String
+    ) {
+        val processBuilder = ProcessBuilder("src/test/resources/test/smoke/${getSaveForCurrentOs()}", "src/test/resources/test/smoke/src/main/kotlin", expectedPath, testPath,
+            "--log", "all")
+
+        val file = File("tmpSave.txt")
+        val diktat = File("src/test/resources/test/smoke/diktat.jar")
+        val configFile = File("src/test/resources/test/smoke/diktat-analysis.yml")
+        val diktatFrom = File("../diktat-ruleset/target/diktat-$diktatVersion.jar")
+        val configFileFrom = File(configFilePath)
+
+        file.createNewFile()
+        diktat.createNewFile()
+        configFile.createNewFile()
+
+        copyFile(diktatFrom, diktat)
+        copyFile(configFileFrom, configFile)
+
+        processBuilder.redirectOutput(file)
+
+        val process = processBuilder.start()
+        process.waitFor()
+
+        val output = file.readLines()
+        val saveOutput = output.joinToString("\n")
+
+        file.delete()
+        diktat.delete()
+        configFile.delete()
+
+        Assertions.assertTrue(
+            saveOutput.contains("SUCCESS")
+        )
+    }
+
     /**
      * @param expectedPath path to file with expected result, relative to [resourceFilePath]
      * @param testPath path to file with code that will be transformed by formatter, relative to [resourceFilePath]

diktat-rules/src/test/resources/test/smoke/save.toml

@@ -1,8 +1,13 @@
 [general]
-execCmd="java -jar ktlint-snap.jar -R diktat-1.0.0-rc.2.jar"
+execCmd="java -jar ktlint -R diktat.jar"
 tags = ["smokeTest"]
 description = "SmokeTest"
 suiteName = "SmokeTest"
+language = "Kotlin"
+expectedWarningsPattern = "// ;warn:?(.*):(\\d*): (.+)"
 
-[fix]
-  execFlags="--disabled_rules 'standard' -F"
+["fix and warn"]
+    ["fix and warn".fix]
+        execFlags="--disabled_rules=standard -F"
+    ["fix and warn".warn]
+        actualWarningsPattern = "(\\w+\\..+):(\\d+):(\\d+): (\\[.*\\].*)$"

diktat-rules/src/test/resources/test/smoke/src/main/kotlin/Bug1Expected.kt

@@ -1,19 +1,19 @@
-// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Bug1Expected.kt vs D
+// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Bug1Expected.kt vs D{{.*}}
 package org.cqfn.diktat
 
-// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: D (cannot be auto-corrected)
-// ;warn:7:7: [CLASS_NAME_INCORRECT] class/enum/interface name should be in PascalCase and should contain only latin (ASCII) letters or numbers: D
-// ;warn:7:7: [IDENTIFIER_LENGTH] identifier's length is incorrect, it should be in range of [2, 64] symbols: D (cannot be auto-corrected)
+// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: D (cannot be auto-corrected){{.*}}
+// ;warn:7:7: [CLASS_NAME_INCORRECT] class/enum/interface name should be in PascalCase and should contain only latin (ASCII) letters or numbers: D{{.*}}
+// ;warn:7:7: [IDENTIFIER_LENGTH] identifier's length is incorrect, it should be in range of [2, 64] symbols: D (cannot be auto-corrected){{.*}}
 class D {
-    // ;warn:8:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: x (cannot be auto-corrected)
+    // ;warn:8:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: x (cannot be auto-corrected){{.*}}
     val x = 0
-    // ;warn:13:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected)
+    // ;warn:13:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected){{.*}}
 
     /**
      * @return
      */
     fun bar(): Bar {
-        // ;warn:17:19: [MAGIC_NUMBER] avoid using magic numbers, instead define constants with clear names describing what the magic number means: 42 (cannot be auto-corrected)
+        // ;warn:17:19: [MAGIC_NUMBER] avoid using magic numbers, instead define constants with clear names describing what the magic number means: 42 (cannot be auto-corrected){{.*}}
         val qux = 42
         return Bar(qux)
     }

diktat-rules/src/test/resources/test/smoke/src/main/kotlin/DefaultPackageExpected.kt

@@ -1,3 +1,5 @@
+// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: DefaultPackageExpected.kt vs Example{{.*}}
+// ;warn:3:1: [FILE_INCORRECT_BLOCKS_ORDER] general structure of kotlin source file is wrong, parts are in incorrect order: @file:Suppress{{.*}}
 @file:Suppress(
     "PACKAGE_NAME_MISSING",
     "PACKAGE_NAME_INCORRECT_PATH",

diktat-rules/src/test/resources/test/smoke/src/main/kotlin/Example1Expected.kt

@@ -1,10 +1,21 @@
+// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Example1Expected.kt vs Example{{.*}}
 package org.cqfn.diktat
 
+// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: Example (cannot be auto-corrected){{.*}}
 class Example {
+    // ;warn:6:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: isValid (cannot be auto-corrected){{.*}}
+    // ;warn:10:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: foo (cannot be auto-corrected){{.*}}
     @get:JvmName("getIsValid")
     val isValid = true
     val foo: Int = 1
 
+    // ;warn:12:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: foo (cannot be auto-corrected){{.*}}
+    // ;warn:12:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo (cannot be auto-corrected){{.*}}
+    // ;warn:19:19: [EMPTY_BLOCK_STRUCTURE_ERROR] incorrect format of empty block: empty blocks are forbidden unless it is function with override keyword (cannot be auto-corrected){{.*}}
+    // ;warn:24:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected){{.*}}
+    // ;warn:30:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected){{.*}}
+    // ;warn:38:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected){{.*}}
+    // ;warn:47:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected){{.*}}
     fun Foo.foo() { }
 
     /**

diktat-rules/src/test/resources/test/smoke/src/main/kotlin/Example2Expected.kt

@@ -1,3 +1,4 @@
+// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 2 declared classes and/or objects (cannot be auto-corrected){{.*}}
 package org.cqfn.diktat
 
 import org.slf4j.LoggerFactory
@@ -11,6 +12,7 @@ import java.util.Properties
  */
 @ExperimentalStdlibApi public data class Example(val foo: Int, val bar: Double) : SuperExample("lorem ipsum")
 
+// ;warn:36:3: [EMPTY_BLOCK_STRUCTURE_ERROR] incorrect format of empty block: empty blocks are forbidden unless it is function with override keyword (cannot be auto-corrected){{.*}}
 private class TestException : Exception()
 /* this class is unused */
 // private class Test : RuntimeException()