Generate parametrized tests when there is no force mocking

sofurihafe · sofurihafe · commit c51298174169 · 2022-07-22T11:18:25.000+03:00
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt
@@ -180,6 +180,8 @@ class UtBotSymbolicEngine(
 
     fun attachMockListener(mockListener: MockListener) = mocker.mockListenerController?.attach(mockListener)
 
+    fun detachMockListener(mockListener: MockListener) = mocker.mockListenerController?.detach(mockListener)
+
     private val statesForConcreteExecution: MutableList<ExecutionState> = mutableListOf()
 
     private val traverser = Traverser(
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceMockListener.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceMockListener.kt
@@ -2,6 +2,7 @@ package org.utbot.engine.util.mockListeners
 import org.utbot.engine.EngineController
 import org.utbot.engine.MockStrategy
 import org.utbot.engine.UtMockInfo
+import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.util.Conflict
 import org.utbot.framework.util.ConflictTriggers
 
@@ -18,4 +19,13 @@ class ForceMockListener(triggers: ConflictTriggers): MockListener(triggers) {
 
         triggers[Conflict.ForceMockHappened] = true
     }
+
+    companion object {
+        fun create(testCaseGenerator: TestCaseGenerator, conflictTriggers: ConflictTriggers) : ForceMockListener {
+            val listener = ForceMockListener(conflictTriggers)
+            testCaseGenerator.engineActions.add { engine -> engine.attachMockListener(listener) }
+
+            return listener
+        }
+    }
 }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceStaticMockListener.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceStaticMockListener.kt
@@ -6,6 +6,7 @@ import org.utbot.engine.UtMockInfo
 import org.utbot.engine.UtNewInstanceMockInfo
 import org.utbot.engine.UtStaticMethodMockInfo
 import org.utbot.engine.UtStaticObjectMockInfo
+import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.util.Conflict
 import org.utbot.framework.util.ConflictTriggers
 
@@ -26,4 +27,13 @@ class ForceStaticMockListener(triggers: ConflictTriggers): MockListener(triggers
             triggers[Conflict.ForceStaticMockHappened] = true
         }
     }
+
+    companion object {
+        fun create(testCaseGenerator: TestCaseGenerator, conflictTriggers: ConflictTriggers) : ForceStaticMockListener {
+            val listener = ForceStaticMockListener(conflictTriggers)
+            testCaseGenerator.engineActions.add { engine -> engine.attachMockListener(listener) }
+
+            return listener
+        }
+    }
 }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListener.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListener.kt
@@ -3,6 +3,7 @@ package org.utbot.engine.util.mockListeners
 import org.utbot.engine.EngineController
 import org.utbot.engine.MockStrategy
 import org.utbot.engine.UtMockInfo
+import org.utbot.framework.plugin.api.TestCaseGenerator
 import org.utbot.framework.util.ConflictTriggers
 
 /**
@@ -12,4 +13,8 @@ abstract class MockListener(
     val triggers: ConflictTriggers
 ) {
     abstract fun onShouldMock(controller: EngineController, strategy: MockStrategy, mockInfo: UtMockInfo)
+
+    fun detach(testCaseGenerator: TestCaseGenerator, listener: MockListener) {
+        testCaseGenerator.engineActions.add { engine -> engine.detachMockListener(listener) }
+    }
 }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListenerController.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListenerController.kt
@@ -14,6 +14,10 @@ class MockListenerController(private val controller: EngineController) {
         listeners += listener
     }
 
+    fun detach(listener: MockListener) {
+        listeners -= listener
+    }
+
     fun onShouldMock(strategy: MockStrategy, mockInfo: UtMockInfo) {
         listeners.map { it.onShouldMock(controller, strategy, mockInfo) }
     }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgMethodConstructor.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgMethodConstructor.kt
@@ -1217,11 +1217,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
     private val expectedResultVarName = "expectedResult"
     private val expectedErrorVarName = "expectedError"
 
-    fun createParameterizedTestMethod(testSet: UtMethodTestSet, dataProviderMethodName: String): CgTestMethod? {
-        if (testSet.executions.isEmpty()) {
-            return null
-        }
-
+    fun createParameterizedTestMethod(testSet: UtMethodTestSet, dataProviderMethodName: String): CgTestMethod {
         //TODO: orientation on generic execution may be misleading, but what is the alternative?
         //may be a heuristic to select a model with minimal number of internal nulls should be used
         val genericExecution = testSet.executions
diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgTestClassConstructor.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgTestClassConstructor.kt
@@ -52,7 +52,7 @@ internal class CgTestClassConstructor(val context: CgContext) :
                     cgDataProviderMethods.clear()
                     for (testSet in testSets) {
                         updateCurrentExecutable(testSet.method)
-                        val currentMethodUnderTestRegions = construct(testSet)
+                        val currentMethodUnderTestRegions = construct(testSet) ?: continue
                         val executableUnderTestCluster = CgExecutableUnderTestCluster(
                             "Test suites for executable $currentExecutable",
                             currentMethodUnderTestRegions
@@ -76,7 +76,11 @@ internal class CgTestClassConstructor(val context: CgContext) :
         }
     }
 
-    private fun construct(testSet: UtMethodTestSet): List<CgRegion<CgMethod>> {
+    private fun construct(testSet: UtMethodTestSet): List<CgRegion<CgMethod>>? {
+        if (testSet.executions.isEmpty()) {
+            return null
+        }
+
         val (methodUnderTest, executions, _, _, clustersInfo) = testSet
         val regions = mutableListOf<CgRegion<CgMethod>>()
         val requiredFields = mutableListOf<CgParameterDeclaration>()
@@ -107,17 +111,15 @@ internal class CgTestClassConstructor(val context: CgContext) :
                     val parameterizedTestMethod =
                         methodConstructor.createParameterizedTestMethod(testSet, dataProviderMethodName)
 
-                    if (parameterizedTestMethod != null) {
-                        requiredFields += parameterizedTestMethod.requiredFields
+                    requiredFields += parameterizedTestMethod.requiredFields
 
-                        cgDataProviderMethods +=
-                            methodConstructor.createParameterizedTestDataProvider(testSet, dataProviderMethodName)
+                    cgDataProviderMethods +=
+                        methodConstructor.createParameterizedTestDataProvider(testSet, dataProviderMethodName)
 
-                        regions += CgSimpleRegion(
-                            "Parameterized test for method ${methodUnderTest.displayName}",
-                            listOf(parameterizedTestMethod),
-                        )
-                    }
+                    regions += CgSimpleRegion(
+                        "Parameterized test for method ${methodUnderTest.displayName}",
+                        listOf(parameterizedTestMethod),
+                    )
                 }.onFailure { error -> processFailure(testSet, error) }
             }
         }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/plugin/api/TestCaseGenerator.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/plugin/api/TestCaseGenerator.kt
@@ -117,6 +117,8 @@ open class TestCaseGenerator(
         executionTimeEstimator: ExecutionTimeEstimator = ExecutionTimeEstimator(utBotGenerationTimeoutInMillis, 1)
     ): Flow<UtResult> {
         val engine = createSymbolicEngine(controller, method, mockStrategy, chosenClassesToMockAlways, executionTimeEstimator)
+        engineActions.map { engine.apply(it) }
+        engineActions.clear()
         return defaultTestFlow(engine, executionTimeEstimator.userTimeout)
     }
 
diff --git a/utbot-framework/src/test/kotlin/org/utbot/examples/TestUtil.kt b/utbot-framework/src/test/kotlin/org/utbot/examples/TestUtil.kt
@@ -14,6 +14,8 @@ import org.utbot.framework.plugin.api.MockFramework
 import org.utbot.framework.plugin.api.MockStrategyApi
 import org.utbot.framework.plugin.api.MockStrategyApi.NO_MOCKS
 import org.utbot.framework.plugin.api.MockStrategyApi.OTHER_CLASSES
+import org.utbot.framework.util.Conflict
+import org.utbot.framework.util.ConflictTriggers
 
 
 data class TestFrameworkConfiguration(
@@ -28,6 +30,12 @@ data class TestFrameworkConfiguration(
     val runtimeExceptionTestsBehaviour: RuntimeExceptionTestsBehaviour = RuntimeExceptionTestsBehaviour.PASS,
     val enableTestsTimeout: Boolean = false // our tests should not fail due to timeout
 ) {
+    val conflictTriggers: ConflictTriggers = ConflictTriggers()
+    val isParametrizedAndMocked: Boolean
+        get() = parametrizedTestSource == ParametrizedTestSource.PARAMETRIZE &&
+                (mockStrategy != NO_MOCKS ||
+                        conflictTriggers[Conflict.ForceMockHappened] ?: false || conflictTriggers[Conflict.ForceStaticMockHappened] ?: false)
+
     val isDisabled: Boolean
         get() = run {
             // TODO Any? JIRA:1366
@@ -42,9 +50,6 @@ data class TestFrameworkConfiguration(
             // because otherwise the code generator will not create mocks even for mandatory to mock classes
             if (forceStaticMocking == ForceStaticMocking.FORCE && staticsMocking == NoStaticMocking) return true
 
-            // TODO find if mocks are used during the analysis JIRA:1418
-            if (parametrizedTestSource == ParametrizedTestSource.PARAMETRIZE) return true
-
             // junit4 doesn't support parametrized tests
             if (testFramework == Junit4 && parametrizedTestSource == ParametrizedTestSource.PARAMETRIZE) return true
 
diff --git a/utbot-framework/src/test/kotlin/org/utbot/examples/UtValueTestCaseChecker.kt b/utbot-framework/src/test/kotlin/org/utbot/examples/UtValueTestCaseChecker.kt
@@ -9,6 +9,8 @@ import org.utbot.common.FileUtil.clearTempDirectory
 import org.utbot.common.FileUtil.findPathToClassFiles
 import org.utbot.common.FileUtil.locateClass
 import org.utbot.engine.prettify
+import org.utbot.engine.util.mockListeners.ForceMockListener
+import org.utbot.engine.util.mockListeners.ForceStaticMockListener
 import org.utbot.framework.PathSelectorType
 import org.utbot.framework.TestSelectionStrategyType
 import org.utbot.framework.UtSettings
@@ -80,6 +82,7 @@ abstract class UtValueTestCaseChecker(
 ) : CodeGenerationIntegrationTest(testClass, testCodeGeneration, languagePipelines) {
     // contains already analyzed by the engine methods
     private val analyzedMethods: MutableMap<MethodWithMockStrategy, MethodResult> = mutableMapOf()
+    private var currentTestFrameworkConfiguration: TestFrameworkConfiguration? = null
 
     val searchDirectory: Path = Paths.get("../utbot-sample/src/main/java")
 
@@ -2293,6 +2296,7 @@ abstract class UtValueTestCaseChecker(
                         MethodWithMockStrategy(utMethod, mockStrategy, resetNonFinalFieldsAfterClinit)
 
                     val (testSet, coverage) = analyzedMethods.getOrPut(methodWithStrategy) {
+                        currentTestFrameworkConfiguration = testFrameworkConfiguration
                         walk(utMethod, mockStrategy)
                     }
 
@@ -2500,6 +2504,20 @@ abstract class UtValueTestCaseChecker(
                     System.getProperty("java.class.path")
                 )
             }
+
+        val conflictTriggers = currentTestFrameworkConfiguration?.conflictTriggers
+        if (conflictTriggers != null) {
+            val forceMockListener = ForceMockListener.create(testCaseGenerator, conflictTriggers)
+            val forceStaticMockListener = ForceStaticMockListener.create(testCaseGenerator, conflictTriggers)
+
+            val testSet = testCaseGenerator.generate(method, mockStrategy)
+
+            forceMockListener.detach(testCaseGenerator, forceMockListener)
+            forceStaticMockListener.detach(testCaseGenerator, forceStaticMockListener)
+
+            return testSet
+        }
+
         return testCaseGenerator.generate(method, mockStrategy)
     }
 
diff --git a/utbot-framework/src/test/kotlin/org/utbot/framework/codegen/TestCodeGeneratorPipeline.kt b/utbot-framework/src/test/kotlin/org/utbot/framework/codegen/TestCodeGeneratorPipeline.kt
@@ -71,6 +71,8 @@ class TestCodeGeneratorPipeline(private val testFrameworkConfiguration: TestFram
             val testSets = data as List<UtMethodTestSet>
 
             val codegenLanguage = testFrameworkConfiguration.codegenLanguage
+            val parametrizedTestSource = testFrameworkConfiguration.parametrizedTestSource
+            val isParametrizedAndMocked = testFrameworkConfiguration.isParametrizedAndMocked
 
             val testClass = callToCodeGenerator(testSets, classUnderTest)
 
@@ -79,14 +81,30 @@ class TestCodeGeneratorPipeline(private val testFrameworkConfiguration: TestFram
                 .lines()
                 .count {
                     val trimmedLine = it.trimStart()
-                    if (codegenLanguage == CodegenLanguage.JAVA) {
-                        trimmedLine.startsWith("public void")
-                    } else {
-                        trimmedLine.startsWith("fun ")
+                    val prefix = when (codegenLanguage) {
+                        CodegenLanguage.JAVA ->
+                            when (parametrizedTestSource) {
+                                ParametrizedTestSource.DO_NOT_PARAMETRIZE -> "public void "
+                                ParametrizedTestSource.PARAMETRIZE -> "public void parameterizedTestsFor"
+                            }
+
+                        CodegenLanguage.KOTLIN ->
+                            when (parametrizedTestSource) {
+                                ParametrizedTestSource.DO_NOT_PARAMETRIZE -> "fun "
+                                ParametrizedTestSource.PARAMETRIZE -> "fun parameterizedTestsFor"
+                            }
                     }
+                    trimmedLine.startsWith(prefix)
                 }
             // expected number of the tests in the generated testClass
-            val expectedNumberOfGeneratedMethods = testSets.sumOf { it.executions.size }
+            // if force mocking took place in parametrized test generation,
+            // we don't generate tests at all
+            val expectedNumberOfGeneratedMethods =
+                if (isParametrizedAndMocked) 0
+                else when (parametrizedTestSource) {
+                    ParametrizedTestSource.DO_NOT_PARAMETRIZE -> testSets.sumOf { it.executions.size }
+                    ParametrizedTestSource.PARAMETRIZE -> testSets.size
+                }
 
             // check for error in the generated file
             runCatching {
@@ -220,7 +238,12 @@ class TestCodeGeneratorPipeline(private val testFrameworkConfiguration: TestFram
         }
         val testClassCustomName = "${classUnderTest.java.simpleName}GeneratedTest"
 
-        return codeGenerator.generateAsString(testSets, testClassCustomName)
+        // if force mocking took place in parametrized test generation,
+        // we don't generate tests at all by passing empty list instead of test sets
+        return codeGenerator.generateAsString(
+            if (testFrameworkConfiguration.isParametrizedAndMocked) listOf() else testSets,
+            testClassCustomName
+        )
     }
 
     private fun checkPipelinesResults(classesPipelines: List<ClassPipeline>) {
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt
@@ -178,15 +178,11 @@ object UtTestsDialogProcessor {
                                     val mockFrameworkInstalled = model.mockFramework?.isInstalled ?: true
 
                                     if (!mockFrameworkInstalled) {
-                                         ForceMockListener(model.conflictTriggers).apply {
-                                             testCaseGenerator.engineActions.add { engine -> engine.attachMockListener(this) }
-                                         }
+                                        ForceMockListener.create(testCaseGenerator, model.conflictTriggers)
                                     }
 
                                     if (!model.staticsMocking.isConfigured) {
-                                        ForceStaticMockListener(model.conflictTriggers).apply {
-                                            testCaseGenerator.engineActions.add { engine -> engine.attachMockListener(this) }
-                                        }
+                                        ForceStaticMockListener.create(testCaseGenerator, model.conflictTriggers)
                                     }
 
                                     val notEmptyCases = withUtContext(context) {

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,10 @@ class MockListenerController(private val controller: EngineController) {`
`14`	`14`	`listeners += listener`
`15`	`15`	`}`
`16`	`16`
	`17`	`+ fun detach(listener: MockListener) {`
	`18`	`+ listeners -= listener`
	`19`	`+ }`
	`20`	`+`
`17`	`21`	`fun onShouldMock(strategy: MockStrategy, mockInfo: UtMockInfo) {`
`18`	`22`	`listeners.map { it.onShouldMock(controller, strategy, mockInfo) }`
`19`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,6 +117,8 @@ open class TestCaseGenerator(`
`117`	`117`	`executionTimeEstimator: ExecutionTimeEstimator = ExecutionTimeEstimator(utBotGenerationTimeoutInMillis, 1)`
`118`	`118`	`): Flow<UtResult> {`
`119`	`119`	`val engine = createSymbolicEngine(controller, method, mockStrategy, chosenClassesToMockAlways, executionTimeEstimator)`
	`120`	`+ engineActions.map { engine.apply(it) }`
	`121`	`+ engineActions.clear()`
`120`	`122`	`return defaultTestFlow(engine, executionTimeEstimator.userTimeout)`
`121`	`123`	`}`
`122`	`124`