Force mocking without mock framework installed fix

Added mock listeners for engine.
Added force mock listener.
Added url handler for urls like "#utbot/...".
Added message with link to mock framework configuration to test reports if force mocking happened.

Author: Nikita Vlaev

utbot-framework/src/main/kotlin/org/utbot/engine/Mocks.kt

@@ -18,6 +18,7 @@ import java.util.concurrent.atomic.AtomicInteger
 import kotlin.reflect.KFunction2
 import kotlin.reflect.KFunction5
 import kotlinx.collections.immutable.persistentListOf
+import org.utbot.engine.util.mockListeners.MockListenerController
 import soot.BooleanType
 import soot.RefType
 import soot.Scene
@@ -133,7 +134,8 @@ class Mocker(
     private val strategy: MockStrategy,
     private val classUnderTest: ClassId,
     private val hierarchy: Hierarchy,
-    chosenClassesToMockAlways: Set<ClassId>
+    chosenClassesToMockAlways: Set<ClassId>,
+    internal val mockListenerController: MockListenerController? = null,
 ) {
     /**
      * Creates mocked instance of the [type] using mock info if it should be mocked by the mocker,
@@ -164,6 +166,11 @@ class Mocker(
      * For others, if mock is not a new instance mock, asks mock strategy for decision.
      */
     fun shouldMock(
+        type: RefType,
+        mockInfo: UtMockInfo,
+    ): Boolean = checkIfShouldMock(type, mockInfo).also { if (it) mockListenerController?.onShouldMock(strategy) }
+
+    private fun checkIfShouldMock(
         type: RefType,
         mockInfo: UtMockInfo
     ): Boolean {

utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt

@@ -6,15 +6,17 @@ import kotlinx.collections.immutable.persistentSetOf
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.collections.immutable.toPersistentMap
 import kotlinx.collections.immutable.toPersistentSet
-import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.job
 import kotlinx.coroutines.yield
 import mu.KotlinLogging
 import org.utbot.analytics.EngineAnalyticsContext
@@ -103,6 +105,8 @@ import org.utbot.engine.symbolic.asHardConstraint
 import org.utbot.engine.symbolic.asSoftConstraint
 import org.utbot.engine.symbolic.asAssumption
 import org.utbot.engine.symbolic.asUpdate
+import org.utbot.engine.util.mockListeners.MockListener
+import org.utbot.engine.util.mockListeners.MockListenerController
 import org.utbot.engine.util.statics.concrete.associateEnumSootFieldsWithConcreteValues
 import org.utbot.engine.util.statics.concrete.isEnumAffectingExternalStatics
 import org.utbot.engine.util.statics.concrete.isEnumValuesFieldName
@@ -330,7 +334,7 @@ class UtBotSymbolicEngine(
 
     private val classUnderTest: ClassId = methodUnderTest.clazz.id
 
-    private val mocker: Mocker = Mocker(mockStrategy, classUnderTest, hierarchy, chosenClassesToMockAlways)
+    private val mocker: Mocker = Mocker(mockStrategy, classUnderTest, hierarchy, chosenClassesToMockAlways, MockListenerController(controller))
 
     private val statesForConcreteExecution: MutableList<ExecutionState> = mutableListOf()
 
@@ -541,6 +545,10 @@ class UtBotSymbolicEngine(
                             } else {
                                 traverseStmt(currentStmt)
                             }
+
+                            // Here job can be cancelled from within traverse, e.g. by using force mocking without Mockito.
+                            // So we need to make it throw CancelledException by method below:
+                            currentCoroutineContext().job.ensureActive()
                         } catch (ex: Throwable) {
                             environment.state.close()
 
@@ -2521,6 +2529,8 @@ class UtBotSymbolicEngine(
         )
     }
 
+    fun attachMockListener(mockListener: MockListener) = mocker.mockListenerController?.attach(mockListener)
+
     private fun staticInvoke(invokeExpr: JStaticInvokeExpr): List<MethodResult> {
         val parameters = resolveParameters(invokeExpr.args, invokeExpr.method.parameterTypes)
         val result = mockMakeSymbolic(invokeExpr) ?: mockStaticMethod(invokeExpr.method, parameters)

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/ForceMockListener.kt

@@ -0,0 +1,21 @@
+package org.utbot.engine.util.mockListeners
+import org.utbot.engine.EngineController
+import org.utbot.engine.MockStrategy
+import org.utbot.engine.util.mockListeners.exceptions.ForceMockCancellationException
+
+/**
+ * Listener for mocker events in [org.utbot.engine.UtBotSymbolicEngine].
+ * If forced mock happened, cancels the engine job.
+ *
+ * Supposed to be created only if Mockito is not installed.
+ */
+class ForceMockListener: MockListener {
+    var forceMockHappened = false
+        private set
+
+    override fun onShouldMock(controller: EngineController, strategy: MockStrategy) {
+        // If force mocking happened -- сancel engine job
+        controller.job?.cancel(ForceMockCancellationException())
+        forceMockHappened = true
+    }
+}

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListener.kt

@@ -0,0 +1,11 @@
+package org.utbot.engine.util.mockListeners
+
+import org.utbot.engine.EngineController
+import org.utbot.engine.MockStrategy
+
+/**
+ * Listener that can be attached using [MockListenerController] to mocker in [org.utbot.engine.UtBotSymbolicEngine].
+ */
+interface MockListener {
+    fun onShouldMock(controller: EngineController, strategy: MockStrategy)
+}

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/MockListenerController.kt

@@ -0,0 +1,19 @@
+package org.utbot.engine.util.mockListeners
+
+import org.utbot.engine.EngineController
+import org.utbot.engine.MockStrategy
+
+/**
+ * Controller that allows to attach listeners to mocker in [org.utbot.engine.UtBotSymbolicEngine].
+ */
+class MockListenerController(private val controller: EngineController) {
+    val listeners = mutableListOf<MockListener>()
+
+    fun attach(listener: MockListener) {
+        listeners += listener
+    }
+
+    fun onShouldMock(strategy: MockStrategy) {
+        listeners.map { it.onShouldMock(controller, strategy) }
+    }
+}

utbot-framework/src/main/kotlin/org/utbot/engine/util/mockListeners/exceptions/ForceMockCancellationException.kt

@@ -0,0 +1,8 @@
+package org.utbot.engine.util.mockListeners.exceptions
+
+import kotlinx.coroutines.CancellationException
+
+/**
+ * Exception used in [org.utbot.engine.util.mockListeners.ForceMockListener].
+ */
+class ForceMockCancellationException: CancellationException("Forced mocks without Mockito")

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgTestClassConstructor.kt

@@ -188,6 +188,9 @@ data class TestsGenerationReport(
     val classUnderTest: KClass<*>
         get() = executables.firstOrNull()?.clazz ?: error("No executables found in test report")
 
+    // Initial message is generated lazily to avoid evaluation of classUnderTest
+    var initialMessage: () -> String = { "Unit tests for $classUnderTest were generated successfully." }
+
     fun addMethodErrors(testCase: UtTestCase, errors: Map<String, Int>) {
         this.errors[testCase.method] = errors
     }
@@ -212,7 +215,8 @@ data class TestsGenerationReport(
     }
 
     override fun toString(): String = buildString {
-        appendHtmlLine("Unit tests for $classUnderTest were generated successfully.")
+        appendHtmlLine(initialMessage())
+        appendHtmlLine()
         val testMethodsStatistic = executables.map { it.countTestMethods() }
         val errors = executables.map { it.countErrors() }
         val overallTestMethods = testMethodsStatistic.sumBy { it.count }

utbot-framework/src/main/kotlin/org/utbot/framework/plugin/api/UtBotTestCaseGenerator.kt

@@ -58,6 +58,7 @@ object UtBotTestCaseGenerator : TestCaseGenerator {
     private val logger = KotlinLogging.logger {}
     private val timeoutLogger = KotlinLogging.logger(logger.name + ".timeout")
 
+    lateinit var configureEngine: (UtBotSymbolicEngine) -> Unit
     lateinit var isCanceled: () -> Boolean
 
     //properties to save time on soot initialization
@@ -71,8 +72,23 @@ object UtBotTestCaseGenerator : TestCaseGenerator {
         classpath: String?,
         dependencyPaths: String,
         isCanceled: () -> Boolean
+    ) = init(
+        buildDir,
+        classpath,
+        dependencyPaths,
+        configureEngine = {},
+        isCanceled
+    )
+
+    fun init(
+        buildDir: Path,
+        classpath: String?,
+        dependencyPaths: String,
+        configureEngine: (UtBotSymbolicEngine) -> Unit,
+        isCanceled: () -> Boolean
     ) {
         this.isCanceled = isCanceled
+        this.configureEngine = configureEngine
         if (isCanceled()) return
 
         checkFrameworkDependencies(dependencyPaths)
@@ -268,13 +284,15 @@ object UtBotTestCaseGenerator : TestCaseGenerator {
                         //yield one to
                         yield()
 
-                        generate(createSymbolicEngine(
+                        val engine: UtBotSymbolicEngine = createSymbolicEngine(
                             controller,
                             method,
                             mockStrategy,
                             chosenClassesToMockAlways,
                             executionTimeEstimator
-                        )).collect {
+                        ).apply(configureEngine)
+
+                        generate(engine).collect {
                             when (it) {
                                 is UtExecution -> method2executions.getValue(method) += it
                                 is UtError -> method2errors.getValue(method).merge(it.description, 1, Int::plus)
@@ -364,7 +382,6 @@ object UtBotTestCaseGenerator : TestCaseGenerator {
         val executions = mutableListOf<UtExecution>()
         val errors = mutableMapOf<String, Int>()
 
-
         runIgnoringCancellationException {
             runBlockingWithCancellationPredicate(isCanceled) {
                 generateAsync(EngineController(), method, mockStrategy).collect {

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerator.kt

@@ -14,6 +14,7 @@ import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiMethod
 import com.intellij.refactoring.util.classMembers.MemberInfo
+import org.utbot.engine.UtBotSymbolicEngine
 import java.nio.file.Path
 import java.nio.file.Paths
 import kotlin.reflect.KClass
@@ -32,14 +33,15 @@ class CodeGenerator(
     buildDir: String,
     classpath: String,
     pluginJarsPath: String,
-    isCanceled: () -> Boolean
+    configureEngine: (UtBotSymbolicEngine) -> Unit = {},
+    isCanceled: () -> Boolean,
 ) {
     init {
         UtSettings.testMinimizationStrategyType = TestSelectionStrategyType.COVERAGE_STRATEGY
     }
 
-    private val generator = project.service<Settings>().testCasesGenerator.apply {
-        init(Paths.get(buildDir), classpath, pluginJarsPath, isCanceled)
+    val generator = (project.service<Settings>().testCasesGenerator as UtBotTestCaseGenerator).apply {
+        init(Paths.get(buildDir), classpath, pluginJarsPath, configureEngine, isCanceled)
     }
 
     private val settingsState = project.service<Settings>().state
@@ -49,7 +51,7 @@ class CodeGenerator(
     fun generateForSeveralMethods(methods: List<UtMethod<*>>, timeout:Long = UtSettings.utBotGenerationTimeoutInMillis): List<UtTestCase> {
         logger.info("Tests generating parameters $settingsState")
 
-        return (generator as UtBotTestCaseGenerator)
+        return generator
             .generateForSeveralMethods(methods, mockStrategy, chosenClassesToMockAlways, methodsGenerationTimeout = timeout)
             .map { it.summarize(searchDirectory) }
     }

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/TestGenerator.kt

@@ -15,10 +15,6 @@ import org.utbot.framework.plugin.api.UtTestCase
 import org.utbot.intellij.plugin.sarif.SarifReportIdea
 import org.utbot.intellij.plugin.sarif.SourceFindingStrategyIdea
 import org.utbot.intellij.plugin.settings.Settings
-import org.utbot.intellij.plugin.ui.GenerateTestsModel
-import org.utbot.intellij.plugin.ui.SarifReportNotifier
-import org.utbot.intellij.plugin.ui.TestsReportNotifier
-import org.utbot.intellij.plugin.ui.packageName
 import org.utbot.intellij.plugin.ui.utils.getOrCreateSarifReportsPath
 import org.utbot.intellij.plugin.ui.utils.getOrCreateTestResourcesPath
 import org.utbot.sarif.SarifReport
@@ -63,6 +59,11 @@ import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.scripting.resolve.classId
 import org.utbot.intellij.plugin.error.showErrorDialogLater
+import org.utbot.intellij.plugin.ui.GenerateTestsModel
+import org.utbot.intellij.plugin.ui.SarifReportNotifier
+import org.utbot.intellij.plugin.ui.TestReportUrlOpeningListener
+import org.utbot.intellij.plugin.ui.TestsReportNotifier
+import org.utbot.intellij.plugin.ui.packageName
 
 object TestGenerator {
     fun generateTests(model: GenerateTestsModel, testCases: Map<PsiClass, List<UtTestCase>>) {
@@ -317,6 +318,17 @@ object TestGenerator {
         VfsUtil.createDirectories(parent.toString())
         resultedReportedPath.toFile().writeText(testsCodeWithTestReport.testsGenerationReport.getFileContent())
 
+        if (model.forceMockHappened) {
+            testsCodeWithTestReport.testsGenerationReport.apply {
+                initialMessage = {
+                    """
+                    Unit tests for $classUnderTest were generated partially.<br>
+                    <b>Warning</b>: Some test cases were ignored, because no mocking framework is installed in the project.<br>
+                    Better results could be achieved by <a href="${TestReportUrlOpeningListener.prefix}${TestReportUrlOpeningListener.mockitoSuffix}">installing mocking framework</a>.
+                """.trimIndent()
+                }
+            }
+        }
         val notifyMessage = buildString {
             appendHtmlLine(testsCodeWithTestReport.testsGenerationReport.toString())
             appendHtmlLine()
@@ -334,7 +346,7 @@ object TestGenerator {
             """.trimIndent()
             appendHtmlLine(savedFileMessage)
         }
-        TestsReportNotifier.notify(notifyMessage)
+        TestsReportNotifier.notify(notifyMessage, model.project, model.testModule)
     }
 
     @Suppress("unused")

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/ui/ConfigureWindowCommon.kt

@@ -0,0 +1,47 @@
+package org.utbot.intellij.plugin.ui
+
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.DependencyScope
+import com.intellij.openapi.roots.ExternalLibraryDescriptor
+import com.intellij.openapi.roots.JavaProjectModelModificationService
+import com.intellij.openapi.ui.Messages
+import org.jetbrains.concurrency.Promise
+import org.utbot.framework.plugin.api.MockFramework
+import org.utbot.intellij.plugin.ui.utils.LibrarySearchScope
+import org.utbot.intellij.plugin.ui.utils.findFrameworkLibrary
+import org.utbot.intellij.plugin.ui.utils.parseVersion
+
+fun createMockFrameworkNotificationDialog(title: String) = Messages.showYesNoDialog(
+    """Mock framework ${MockFramework.MOCKITO.displayName} is not installed into current module. 
+            |Would you like to install it now?""".trimMargin(),
+    title,
+    "Yes",
+    "No",
+    Messages.getQuestionIcon(),
+)
+
+fun configureMockFramework(project: Project, module: Module) {
+    val selectedMockFramework = MockFramework.MOCKITO
+
+    val libraryInProject =
+        findFrameworkLibrary(project, module, selectedMockFramework, LibrarySearchScope.Project)
+    val versionInProject = libraryInProject?.libraryName?.parseVersion()
+
+    selectedMockFramework.isInstalled = true
+    addDependency(project, module, mockitoCoreLibraryDescriptor(versionInProject))
+        .onError { selectedMockFramework.isInstalled = false }
+}
+
+/**
+ * Adds the dependency for selected framework via [JavaProjectModelModificationService].
+ *
+ * Note that version restrictions will be applied only if they are present on target machine
+ * Otherwise latest release version will be installed.
+ */
+fun addDependency(project: Project, module: Module, libraryDescriptor: ExternalLibraryDescriptor): Promise<Void> {
+    return JavaProjectModelModificationService
+        .getInstance(project)
+        //this method returns JetBrains internal Promise that is difficult to deal with, but it is our way
+        .addDependency(module, libraryDescriptor, DependencyScope.TEST)
+}