Refactoring

Author: EgorkaKulikov

utbot-testing/src/main/kotlin/org/utbot/testing/TestCodeGeneratorPipeline.kt

@@ -1,6 +1,7 @@
 package org.utbot.testing
 
 import mu.KotlinLogging
+import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.utbot.common.FileUtil
 import org.utbot.common.measureTime
@@ -37,34 +38,30 @@ class TestCodeGeneratorPipeline(private val testInfrastructureConfiguration: Tes
         checkPipelinesResults(pipeline)
     }
 
-    private fun runPipelinesStages(classPipeline: ClassPipeline): List<CodeGenerationResult> {
-        val classesPipelines = listOf(classPipeline)
-        val classesPipelinesNames = classesPipelines.joinToString(" ") {
-            val classUnderTest = it.stageContext.classUnderTest
+    private fun runPipelinesStages(classPipeline: ClassPipeline): CodeGenerationResult {
+        val classUnderTest = classPipeline.stageContext.classUnderTest
+        val classPipelineName =
             classUnderTest.qualifiedName ?: error("${classUnderTest.simpleName} doesn't have a fqn name")
-        }
 
         logger
             .info()
-            .measureTime({ "Executing code generation tests for [$classesPipelinesNames]" }) {
-                CodeGeneration.filterPipelines(classesPipelines).forEach {
+            .measureTime({ "Executing code generation tests for [$classPipelineName]" }) {
+                CodeGeneration.verifyPipeline(classPipeline)?.let {
                     withUtContext(UtContext(it.stageContext.classUnderTest.java.classLoader)) {
                         processCodeGenerationStage(it)
                     }
                 }
 
-                Compilation.filterPipelines(classesPipelines).let {
-                    if (it.isNotEmpty()) processCompilationStages(it)
+                Compilation.verifyPipeline(classPipeline)?.let {
+                    processCompilationStages(it)
                 }
 
-                TestExecution.filterPipelines(classesPipelines).let {
-                    if (it.isNotEmpty()) processTestExecutionStages(it)
+                TestExecution.verifyPipeline(classPipeline)?.let {
+                    processTestExecutionStages(it)
                 }
 
-                return classesPipelines.map {
-                    with(it.stageContext) {
-                        CodeGenerationResult(classUnderTest, numberOfTestCases, stages)
-                    }
+                return with(classPipeline.stageContext) {
+                    CodeGenerationResult(classUnderTest, numberOfTestCases, stages)
                 }
             }
     }
@@ -181,18 +178,17 @@ class TestCodeGeneratorPipeline(private val testInfrastructureConfiguration: Tes
     )
 
     @Suppress("UNCHECKED_CAST")
-    private fun processCompilationStages(classesPipelines: List<ClassPipeline>) {
+    private fun processCompilationStages(classesPipeline: ClassPipeline) {
         val information = StageExecutionInformation(Compilation)
-        val classes = classesPipelines.retrieveClasses()
+        val classes = listOf(classesPipeline).retrieveClasses()
         val buildDirectory = classes.createBuildDirectory()
 
         val codegenLanguage = testInfrastructureConfiguration.codegenLanguage
 
-        val testClassesNamesToTestGeneratedTests = classesPipelines.map { classPipeline ->
-            val codeGeneratorResult = classPipeline.stageContext.data as CodeGeneratorResult//String
+            val codeGeneratorResult = classesPipeline.stageContext.data as CodeGeneratorResult//String
             val testClass = codeGeneratorResult.generatedCode
 
-            val testClassName = classPipeline.retrieveTestClassName("GeneratedTest")
+            val testClassName = classesPipeline.retrieveTestClassName("GeneratedTest")
             val generatedTestFile = writeTest(testClass, testClassName, buildDirectory, codegenLanguage)
             val generatedUtilClassFile = codeGeneratorResult.utilClassKind?.writeUtilClassToFile(buildDirectory, codegenLanguage)
 
@@ -201,25 +197,23 @@ class TestCodeGeneratorPipeline(private val testInfrastructureConfiguration: Tes
                 logger.info("Util class for the test has been written to the file: [$generatedUtilClassFile]")
             }
 
-            GeneratedTestClassInfo(testClassName, generatedTestFile, generatedUtilClassFile)
-        }
+            val testClassesNamesToTestGeneratedTests = GeneratedTestClassInfo(testClassName, generatedTestFile, generatedUtilClassFile)
+
 
         val sourceFiles = mutableListOf<String>().apply {
-            this += testClassesNamesToTestGeneratedTests.map { it.generatedTestFile.absolutePath }
-            this += testClassesNamesToTestGeneratedTests.mapNotNull { it.generatedUtilClassFile?.absolutePath }
+            testClassesNamesToTestGeneratedTests.generatedTestFile.absolutePath?.let { this += it }
+            testClassesNamesToTestGeneratedTests.generatedUtilClassFile?.absolutePath?.let { this += it }
         }
         compileTests(
             "$buildDirectory",
             sourceFiles,
             codegenLanguage
         )
 
-        testClassesNamesToTestGeneratedTests.zip(classesPipelines) { generatedTestClassInfo, classPipeline ->
-            classPipeline.stageContext = classPipeline.stageContext.copy(
-                data = CompilationResult("$buildDirectory", generatedTestClassInfo.testClassName),
-                stages = classPipeline.stageContext.stages + information.completeStage()
-            )
-        }
+        classesPipeline.stageContext = classesPipeline.stageContext.copy(
+            data = CompilationResult("$buildDirectory", testClassesNamesToTestGeneratedTests.testClassName),
+            stages = classesPipeline.stageContext.stages + information.completeStage()
+        )
     }
 
     /**
@@ -235,21 +229,20 @@ class TestCodeGeneratorPipeline(private val testInfrastructureConfiguration: Tes
     private fun List<ClassPipeline>.retrieveClasses() = map { it.stageContext.classUnderTest.java }
 
     @Suppress("UNCHECKED_CAST")
-    private fun processTestExecutionStages(classesPipelines: List<ClassPipeline>) {
+    private fun processTestExecutionStages(classesPipeline: ClassPipeline) {
         val information = StageExecutionInformation(TestExecution)
-        val buildDirectory = (classesPipelines.first().stageContext.data as CompilationResult).buildDirectory
-        val testClassesNames = classesPipelines.map { classPipeline ->
-            (classPipeline.stageContext.data as CompilationResult).testClassName
-        }
+        val compilationResult = classesPipeline.stageContext.data as CompilationResult
+        val buildDirectory = compilationResult.buildDirectory
+        val testClassesNames = listOf(compilationResult.testClassName)
+
         with(testInfrastructureConfiguration) {
             runTests(buildDirectory, testClassesNames, testFramework, codegenLanguage)
         }
-        classesPipelines.forEach {
-            it.stageContext = it.stageContext.copy(
+
+        classesPipeline.stageContext = classesPipeline.stageContext.copy(
                 data = Unit,
-                stages = it.stageContext.stages + information.completeStage()
+                stages = classesPipeline.stageContext.stages + information.completeStage()
             )
-        }
     }
 
     private fun callToCodeGenerator(
@@ -308,35 +301,27 @@ class TestCodeGeneratorPipeline(private val testInfrastructureConfiguration: Tes
     }
 
     private fun checkPipelinesResults(classesPipeline: ClassPipeline) {
-        val results = runPipelinesStages(classesPipeline)
-        val classesChecks = classesPipeline.stageContext.classUnderTest to listOf(classesPipeline.check)
-        processResults(results, listOf(classesChecks))
+        val result = runPipelinesStages(classesPipeline)
+        val classChecks = classesPipeline.stageContext.classUnderTest to listOf(classesPipeline.check)
+        processResults(result, classChecks)
     }
 
     private fun processResults(
-        results: List<CodeGenerationResult>,
-        classesChecks: List<Pair<KClass<*>, List<StageStatusCheck>>>
+        result: CodeGenerationResult,
+        classChecks: Pair<KClass<*>, List<StageStatusCheck>>
     ) {
-        val transformedResults: List<Pair<KClass<*>, List<String>>> =
-            results.zip(classesChecks) { result, classChecks ->
-                val stageStatusChecks = classChecks.second.mapNotNull { check ->
-                    runCatching { check(result) }
-                        .fold(
-                            onSuccess = { if (it) null else check.description },
-                            onFailure = { it.description }
-                        )
-                }
-                result.classUnderTest to stageStatusChecks
-            }
-        val failedResults = transformedResults.filter { it.second.isNotEmpty() }
-
-        assertTrue(failedResults.isEmpty()) {
-            val separator = "\n\t\t"
-            val failedResultsConcatenated = failedResults.joinToString(separator, prefix = separator) {
-                "${it.first.simpleName} : ${it.second.joinToString()}"
-            }
+        val stageStatusChecks = classChecks.second.mapNotNull { check ->
+            runCatching { check(result) }
+                .fold(
+                    onSuccess = { if (it) null else check.description },
+                    onFailure = { it.description }
+                )
+        }
+        val transformedResult: Pair<KClass<*>, List<String>> =  result.classUnderTest to stageStatusChecks
+        val failedResultExists = transformedResult.second.isNotEmpty()
 
-            "There are failed checks: $failedResultsConcatenated"
+        assertFalse(failedResultExists) {
+            "There are failed checks: ${transformedResult.second}"
         }
     }
 
@@ -377,10 +362,8 @@ enum class ExecutionStatus {
 sealed class Stage(private val name: String, val nextStage: Stage?) {
     override fun toString() = name
 
-    fun filterPipelines(classesPipelines: List<ClassPipeline>): List<ClassPipeline> =
-        classesPipelines.filter {
-            it.check.firstStage <= this && it.check.lastStage >= this
-        }
+    fun verifyPipeline(classesPipeline: ClassPipeline): ClassPipeline? =
+        if (classesPipeline.check.firstStage <= this && classesPipeline.check.lastStage >= this) classesPipeline else null
 
     abstract operator fun compareTo(stage: Stage): Int
 }