Add mock and inject mocks value providers

Author: IlyaMuravjov

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

@@ -498,6 +498,8 @@ data class UtClassRefModel(
  * - isMock flag
  * - calculated field values (models)
  * - mocks for methods with return values
+ * - [canHaveRedundantOrMissingMocks] flag, which is set to `true` for mocks
+ *   created by fuzzer without knowing which methods will actually be called
  *
  * [fields] contains non-static fields
  */
@@ -507,6 +509,8 @@ data class UtCompositeModel(
     val isMock: Boolean,
     val fields: MutableMap<FieldId, UtModel> = mutableMapOf(),
     val mocks: MutableMap<ExecutableId, List<UtModel>> = mutableMapOf(),
+    // TODO handle it in instrumentation & codegen
+    val canHaveRedundantOrMissingMocks: Boolean = false,
 ) : UtReferenceModel(id, classId) {
     //TODO: SAT-891 - rewrite toString() method
     override fun toString() = withToStringThreadLocalReentrancyGuard {

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/spring/unit/InjectMocks.kt

@@ -0,0 +1,48 @@
+package org.utbot.fuzzing.spring.unit
+
+import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.UtCompositeModel
+import org.utbot.framework.plugin.api.util.allDeclaredFieldIds
+import org.utbot.framework.plugin.api.util.isFinal
+import org.utbot.framework.plugin.api.util.isStatic
+import org.utbot.framework.plugin.api.util.jField
+import org.utbot.fuzzer.FuzzedType
+import org.utbot.fuzzer.FuzzedValue
+import org.utbot.fuzzer.IdGenerator
+import org.utbot.fuzzer.fuzzed
+import org.utbot.fuzzing.FuzzedDescription
+import org.utbot.fuzzing.JavaValueProvider
+import org.utbot.fuzzing.Routine
+import org.utbot.fuzzing.Seed
+import org.utbot.fuzzing.toFuzzerType
+
+/**
+ * Models created by this class can be used with `@InjectMock` annotation, because
+ * they are [UtCompositeModel]s similar to the ones created by the symbolic engine.
+ */
+class InjectMockValueProvider(
+    private val idGenerator: IdGenerator<Int>,
+    private val classToUseCompositeModelFor: ClassId
+) : JavaValueProvider {
+    override fun accept(type: FuzzedType): Boolean = type.classId == classToUseCompositeModelFor
+
+    override fun generate(description: FuzzedDescription, type: FuzzedType): Sequence<Seed<FuzzedType, FuzzedValue>> {
+        val fields = type.classId.allDeclaredFieldIds.filterNot { it.isStatic && it.isFinal }.toList()
+        return sequenceOf(Seed.Recursive(
+            construct = Routine.Create(types = fields.map { toFuzzerType(it.jField.genericType, description.typeCache) }) { values ->
+                emptyFuzzedValue(type.classId).also {
+                    (it.model as UtCompositeModel).fields.putAll(
+                        fields.zip(values).associate { (field, value) -> field to value.model }
+                    )
+                }
+            },
+            empty = Routine.Empty { emptyFuzzedValue(type.classId) }
+        ))
+    }
+
+    private fun emptyFuzzedValue(classId: ClassId) = UtCompositeModel(
+        id = idGenerator.createId(),
+        classId = classId,
+        isMock = false,
+    ).fuzzed { summary = "%var% = ${classId.simpleName}()" }
+}

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/spring/unit/Mocks.kt

@@ -0,0 +1,70 @@
+package org.utbot.fuzzing.spring.unit
+
+import mu.KotlinLogging
+import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.MethodId
+import org.utbot.framework.plugin.api.UtCompositeModel
+import org.utbot.framework.plugin.api.util.executableId
+import org.utbot.framework.plugin.api.util.jClass
+import org.utbot.framework.plugin.api.util.method
+import org.utbot.fuzzer.FuzzedType
+import org.utbot.fuzzer.FuzzedValue
+import org.utbot.fuzzer.IdGenerator
+import org.utbot.fuzzer.fuzzed
+import org.utbot.fuzzing.FuzzedDescription
+import org.utbot.fuzzing.JavaValueProvider
+import org.utbot.fuzzing.Routine
+import org.utbot.fuzzing.Scope
+import org.utbot.fuzzing.ScopeProperty
+import org.utbot.fuzzing.Seed
+import org.utbot.fuzzing.toFuzzerType
+
+val methodsToMockProperty = ScopeProperty<Set<MethodId>>(
+    description = "Method ids that can be mocked by `MockValueProvider`"
+)
+
+// TODO shouldn't be used for primitives and other "easy" to create types
+class MockValueProvider(private val idGenerator: IdGenerator<Int>) : JavaValueProvider {
+    companion object {
+        private val logger = KotlinLogging.logger {}
+        private val loggedMockedMethods = mutableSetOf<MethodId>()
+    }
+
+    private val methodsToMock = mutableSetOf<MethodId>()
+
+    override fun enrich(description: FuzzedDescription, type: FuzzedType, scope: Scope) {
+        val publicMethods = type.classId.jClass.methods.map { it.executableId }
+        publicMethods.intersect(methodsToMock).takeIf { it.isNotEmpty() }?.let {
+            scope.putProperty(methodsToMockProperty, it)
+        }
+    }
+
+    override fun generate(description: FuzzedDescription, type: FuzzedType): Sequence<Seed<FuzzedType, FuzzedValue>> =
+        sequenceOf(Seed.Recursive(
+            construct = Routine.Create(types = emptyList()) { emptyMockFuzzedValue(type.classId) },
+            empty = Routine.Empty { emptyMockFuzzedValue(type.classId) },
+            modify = (description.scope?.getProperty(methodsToMockProperty)?.asSequence() ?: emptySequence()).map { methodId ->
+                if (loggedMockedMethods.add(methodId))
+                    logger.info { "Actually mocked $methodId for the first time" }
+                // TODO accept `List<returnType>` instead of singular `returnType`
+                Routine.Call(types = listOf(
+                    toFuzzerType(methodId.method.genericReturnType, description.typeCache)
+                )) { instance, (value) ->
+                    (instance.model as UtCompositeModel).mocks[methodId] = listOf(value.model)
+                }
+            }
+        ))
+
+    private fun emptyMockFuzzedValue(classId: ClassId) = UtCompositeModel(
+        id = idGenerator.createId(),
+        classId = classId,
+        isMock = true,
+        canHaveRedundantOrMissingMocks = true,
+    ).fuzzed { summary = "%var% = mock()" }
+
+    fun addMockingCandidates(detectedMockingCandidates: Set<MethodId>) =
+        detectedMockingCandidates.forEach { methodId ->
+            if (methodsToMock.add(methodId))
+                logger.info { "Detected that $methodId may need mocking" }
+        }
+}