Smoke tests in diktat

diktat-rules/pom.xml

@@ -259,51 +259,6 @@
                     </execution>
                 </executions>
             </plugin>
-
-            <!-- Create a fat JAR to be used in smoke tests, removing the
-                 circular dependency between `diktat-rules` and `diktat-ruleset`. -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <configuration>
-                    <!-- Suppress the generation of `dependency-reduced-pom.xml`,
-                         because it will also get installed under `~/.m2`,
-                         resulting in the `diktat-maven-plugin` build failure
-                         (the plug-in depends on `diktat-rules`). -->
-                    <createDependencyReducedPom>false</createDependencyReducedPom>
-                    <!-- Should be `false`: otherwise, the generated JAR, even
-                         with a custom classifier, will still be installed/deployed. -->
-                    <shadedArtifactAttached>false</shadedArtifactAttached>
-                    <!-- Necessary: otherwise, the artifact produced by the JAR
-                         plug-in will be overwritten by the fat JAR. -->
-                    <finalName>${project.name}-${project.version}-fat-jar-for-smoke-tests</finalName>
-                    <artifactSet>
-                        <excludes>
-                            <exclude>com.squareup:kotlinpoet</exclude>
-                            <exclude>net.java.dev.jna:jna</exclude>
-                            <exclude>org.jetbrains.intellij.deps:trove4j</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-compiler-embeddable</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-daemon-embeddable</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-reflect</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-script-runtime</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-stdlib-common</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-stdlib-jdk7</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-stdlib-jdk8</exclude>
-                            <exclude>org.jetbrains.kotlin:kotlin-stdlib</exclude>
-                            <exclude>org.jetbrains:annotations</exclude>
-                        </excludes>
-                    </artifactSet>
-                </configuration>
-                <executions>
-                    <execution>
-                        <id>fat-jar-for-smoke-tests</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
         </plugins>
     </build>
 

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/indentation/IndentationConfig.kt

@@ -5,7 +5,7 @@ import org.cqfn.diktat.common.config.rules.RuleConfiguration
 /**
  * [RuleConfiguration] for indentation logic
  */
-internal class IndentationConfig(config: Map<String, String>) : RuleConfiguration(config) {
+class IndentationConfig(config: Map<String, String>) : RuleConfiguration(config) {
     /**
      * Is newline at the end of a file needed
      */
@@ -87,20 +87,20 @@ internal class IndentationConfig(config: Map<String, String>) : RuleConfiguratio
     override fun toString(): String =
         "${javaClass.simpleName}$configWithExplicitDefaults"
 
-    internal companion object {
+    companion object {
         internal const val ALIGNED_PARAMETERS = "alignedParameters"
 
         /**
          * The default indent size (space characters), configurable via
          * `indentationSize`.
          */
         private const val DEFAULT_INDENTATION_SIZE = 4
-        internal const val EXTENDED_INDENT_AFTER_OPERATORS = "extendedIndentAfterOperators"
-        internal const val EXTENDED_INDENT_BEFORE_DOT = "extendedIndentBeforeDot"
-        internal const val EXTENDED_INDENT_FOR_EXPRESSION_BODIES = "extendedIndentForExpressionBodies"
-        internal const val EXTENDED_INDENT_OF_PARAMETERS = "extendedIndentOfParameters"
-        internal const val INDENTATION_SIZE = "indentationSize"
-        internal const val NEWLINE_AT_END = "newlineAtEnd"
+        const val EXTENDED_INDENT_AFTER_OPERATORS = "extendedIndentAfterOperators"
+        const val EXTENDED_INDENT_BEFORE_DOT = "extendedIndentBeforeDot"
+        const val EXTENDED_INDENT_FOR_EXPRESSION_BODIES = "extendedIndentForExpressionBodies"
+        const val EXTENDED_INDENT_OF_PARAMETERS = "extendedIndentOfParameters"
+        const val INDENTATION_SIZE = "indentationSize"
+        const val NEWLINE_AT_END = "newlineAtEnd"
 
         @Suppress("CUSTOM_GETTERS_SETTERS")
         private val IndentationConfig.configWithExplicitDefaults: Map<String, String>

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

@@ -3,92 +3,57 @@ package org.cqfn.diktat.util
 import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.test.framework.processing.FileComparisonResult
 import org.cqfn.diktat.test.framework.processing.TestComparatorUnit
+import org.cqfn.diktat.test.framework.util.LintErrorCallback
+import org.cqfn.diktat.test.framework.util.defaultCallback
 import com.pinterest.ktlint.core.Rule
-import com.pinterest.ktlint.core.RuleSetProvider
 import org.intellij.lang.annotations.Language
 import org.junit.jupiter.api.Assertions
 import java.nio.file.Path
 import kotlin.io.path.bufferedWriter
 import kotlin.io.path.div
 
-const val SAVE_VERSION: String = "0.3.2"
-
 /**
- * @property resourceFilePath path to files which will be compared in tests
+ * Base class for FixTest
  */
 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,
+    resourceFilePath: String,
+    ruleSupplier: (rulesConfigList: List<RulesConfig>) -> Rule,
+    defaultRulesConfigList: List<RulesConfig>? = null,
+    cb: LintErrorCallback = defaultCallback,
 ) {
     /**
      * testComparatorUnit
      */
-    protected val testComparatorUnit = TestComparatorUnit(resourceFilePath) { text, fileName ->
-        format(ruleSetProviderRef, text, fileName, rulesConfigList, cb = cb)
+    private val testComparatorUnitSupplier = { overrideRulesConfigList: List<RulesConfig>? ->
+        TestComparatorUnit(
+            resourceFilePath = resourceFilePath,
+            ruleSetProviderSupplier = { DiktatRuleSetProvider4Test(ruleSupplier, overrideRulesConfigList ?: defaultRulesConfigList) },
+            cb = cb
+        )
     }
 
-    constructor(resourceFilePath: String,
-                ruleSupplier: (rulesConfigList: List<RulesConfig>) -> Rule,
-                rulesConfigList: List<RulesConfig>? = null,
-                cb: LintErrorCallback = defaultCallback
-    ) : this(
-        resourceFilePath,
-        { overrideRulesConfigList -> DiktatRuleSetProvider4Test(ruleSupplier, overrideRulesConfigList) },
-        cb,
-        rulesConfigList
-    )
-
     /**
      * @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 overrideRulesConfigList optional override to [rulesConfigList]
+     * @param overrideRulesConfigList optional override to [defaultRulesConfigList]
+     * @param trimLastEmptyLine whether the last (empty) line should be
+     *   discarded when reading the content of [testPath].
      * @see fixAndCompareContent
      */
     protected fun fixAndCompare(
         expectedPath: String,
         testPath: String,
-        overrideRulesConfigList: List<RulesConfig> = emptyList()
-    ) {
-        val testComparatorUnit = if (overrideRulesConfigList.isNotEmpty()) {
-            TestComparatorUnit(resourceFilePath) { text, fileName ->
-                format(ruleSetProviderRef, text, fileName, overrideRulesConfigList)
-            }
-        } else {
-            testComparatorUnit
-        }
-
+        overrideRulesConfigList: List<RulesConfig>? = null,
+        trimLastEmptyLine: Boolean = false,
+    )  {
+        val testComparatorUnit = testComparatorUnitSupplier(overrideRulesConfigList)
         Assertions.assertTrue(
             testComparatorUnit
-                .compareFilesFromResources(expectedPath, testPath)
+                .compareFilesFromResources(expectedPath, testPath, trimLastEmptyLine)
+                .isSuccessful
         )
     }
 
-    private fun getSaveForCurrentOs() = when {
-        System.getProperty("os.name").startsWith("Linux", ignoreCase = true) -> "save-$SAVE_VERSION-linuxX64.kexe"
-        System.getProperty("os.name").startsWith("Mac", ignoreCase = true) -> "save-$SAVE_VERSION-macosX64.kexe"
-        System.getProperty("os.name").startsWith("Windows", ignoreCase = true) -> "save-$SAVE_VERSION-mingwX64.exe"
-        else -> ""
-    }
-
-    /**
-     * @param testPath path to file with code that will be transformed by formatter, relative to [resourceFilePath]
-     * @return ProcessBuilder
-     */
-    protected fun createProcessBuilderWithCmd(testPath: String): ProcessBuilder {
-        val filesDir = "src/test/resources/test/smoke"
-        val savePath = "$filesDir/${getSaveForCurrentOs()}"
-
-        val systemName = System.getProperty("os.name")
-        val result = when {
-            systemName.startsWith("Linux", ignoreCase = true) || systemName.startsWith("Mac", ignoreCase = true) ->
-                ProcessBuilder("sh", "-c", "chmod 777 $savePath ; ./$savePath $filesDir/src/main/kotlin $testPath --log all")
-            else -> ProcessBuilder(savePath, "$filesDir/src/main/kotlin", testPath)
-        }
-        return result
-    }
-
     /**
      * Unlike [fixAndCompare], this method doesn't perform any assertions.
      *
@@ -119,10 +84,8 @@ open class FixTestBase(
             out.write(expectedContent)
         }
 
-        val testComparatorUnit = TestComparatorUnit(tempDir.toString()) { text, fileName ->
-            format(ruleSetProviderRef, text, fileName, overrideRulesConfigList ?: rulesConfigList, cb)
-        }
-
-        return testComparatorUnit.compareFilesFromFileSystem(expected, actual)
+        val testComparatorUnit = testComparatorUnitSupplier(overrideRulesConfigList)
+        return testComparatorUnit
+            .compareFilesFromFileSystem(expected, actual, false)
     }
 }