Configure Spring unit tests to use fuzzer with mocks

Author: IlyaMuravjov

utbot-framework/src/main/kotlin/org/utbot/framework/context/custom/MockingJavaFuzzingContext.kt

@@ -0,0 +1,42 @@
+package org.utbot.framework.context.custom
+
+import org.utbot.framework.context.JavaFuzzingContext
+import org.utbot.fuzzing.JavaValueProvider
+import org.utbot.fuzzing.providers.MapValueProvider
+import org.utbot.fuzzing.spring.unit.MockValueProvider
+import org.utbot.fuzzing.providers.NullValueProvider
+import org.utbot.fuzzing.providers.ObjectValueProvider
+import org.utbot.fuzzing.providers.StringValueProvider
+import org.utbot.instrumentation.instrumentation.execution.UtConcreteExecutionResult
+
+/**
+ * Makes fuzzer mock all types that don't have *specific* [JavaValueProvider],
+ * like [MapValueProvider] or [StringValueProvider].
+ *
+ * NOTE: the caller is responsible for providing some *specific* [JavaValueProvider]
+ *       that can create values for class under test (otherwise it will be mocked),
+ *       [ObjectValueProvider] and [NullValueProvider] do not count as *specific*.
+ */
+fun JavaFuzzingContext.mockAllTypesWithoutSpecificValueProvider() =
+    MockingJavaFuzzingContext(delegateContext = this)
+
+class MockingJavaFuzzingContext(
+    val delegateContext: JavaFuzzingContext
+) : JavaFuzzingContext by delegateContext {
+    private val mockValueProvider = MockValueProvider(delegateContext.idGenerator)
+
+    override val valueProvider: JavaValueProvider =
+        // NOTE: we first remove `NullValueProvider` from `delegateContext.valueProvider` and then
+        //       add it back as a part of our `withFallback` so it has the same priority as
+        //       `mockValueProvider`, otherwise mocks will never be used where `null` can be used.
+        delegateContext.valueProvider
+            .except { it is NullValueProvider }
+            .except { it is ObjectValueProvider }
+            .withFallback(
+                mockValueProvider
+                    .with(NullValueProvider)
+            )
+
+    override fun handleFuzzedConcreteExecutionResult(concreteExecutionResult: UtConcreteExecutionResult) =
+        mockValueProvider.addMockingCandidates(concreteExecutionResult.detectedMockingCandidates)
+}

utbot-framework/src/main/kotlin/org/utbot/framework/context/spring/SpringApplicationContextImpl.kt

@@ -11,6 +11,9 @@ import org.utbot.framework.context.ConcreteExecutionContext
 import org.utbot.framework.context.NonNullSpeculator
 import org.utbot.framework.context.TypeReplacer
 import org.utbot.framework.context.custom.CoverageFilteringConcreteExecutionContext
+import org.utbot.framework.context.custom.mockAllTypesWithoutSpecificValueProvider
+import org.utbot.framework.context.utils.transformJavaFuzzingContext
+import org.utbot.framework.context.utils.withValueProvider
 import org.utbot.framework.plugin.api.BeanDefinitionData
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.ConcreteContextLoadingResult
@@ -21,6 +24,7 @@ import org.utbot.framework.plugin.api.util.allSuperTypes
 import org.utbot.framework.plugin.api.util.id
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.utContext
+import org.utbot.fuzzing.spring.unit.InjectMockValueProvider
 
 class SpringApplicationContextImpl(
     private val delegateContext: ApplicationContext,
@@ -58,7 +62,16 @@ class SpringApplicationContextImpl(
             )
 
         return when (springTestType) {
-            SpringTestType.UNIT_TEST -> delegateConcreteExecutionContext
+            SpringTestType.UNIT_TEST -> delegateConcreteExecutionContext.transformJavaFuzzingContext { fuzzingContext ->
+                fuzzingContext
+                    .withValueProvider(
+                        InjectMockValueProvider(
+                            idGenerator = fuzzingContext.idGenerator,
+                            classToUseCompositeModelFor = fuzzingContext.classUnderTest
+                        )
+                    )
+                    .mockAllTypesWithoutSpecificValueProvider()
+            }
             SpringTestType.INTEGRATION_TEST -> SpringIntegrationTestConcreteExecutionContext(
                 delegateConcreteExecutionContext,
                 classpathWithoutDependencies,

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

@@ -387,7 +387,7 @@ object UtTestsDialogProcessor {
                                         }
                                         val useFuzzing = when (model.projectType) {
                                             Spring -> when (model.springTestType) {
-                                                UNIT_TEST -> false
+                                                UNIT_TEST -> UtSettings.useFuzzing
                                                 INTEGRATION_TEST -> true
                                             }