Add a prototype of Spring integration tests

Author: IlyaMuravjov

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

@@ -636,6 +636,14 @@ class UtLambdaModel(
     }
 }
 
+class UtAutowiredModel(
+    override val id: Int?,
+    override val classId: ClassId,
+    val beanName: String,
+) : UtReferenceModel(
+    id, classId, modelName = "@Autowired $beanName#$id"
+)
+
 /**
  * Model for a step to obtain [UtAssembleModel].
  */
@@ -1257,6 +1265,23 @@ open class ApplicationContext(
     ): Boolean = field.isFinal || !field.isPublic
 }
 
+sealed class TypeReplacementApproach {
+    /**
+     * Do not replace interfaces and abstract classes with concrete implementors.
+     * Use mocking instead of it.
+     */
+    object DoNotReplace : TypeReplacementApproach()
+
+    /**
+     * Try to replace interfaces and abstract classes with concrete implementors
+     * obtained from bean definitions.
+     * If it is impossible, use mocking.
+     *
+     * Currently used in Spring applications only.
+     */
+    class ReplaceIfPossible(val config: String) : TypeReplacementApproach()
+}
+
 /**
  * Data we get from Spring application context
  * to manage engine and code generator behaviour.
@@ -1269,6 +1294,7 @@ class SpringApplicationContext(
     staticsMockingIsConfigured: Boolean,
     private val beanQualifiedNames: List<String> = emptyList(),
     private val shouldUseImplementors: Boolean,
+    val typeReplacementApproach: TypeReplacementApproach
 ): ApplicationContext(mockInstalled, staticsMockingIsConfigured) {
 
     companion object {

utbot-framework/build.gradle

@@ -1,5 +1,6 @@
 configurations {
     fetchSpringAnalyzerJar
+    fetchInstrumentationJar
 }
 
 dependencies {
@@ -41,10 +42,14 @@ dependencies {
     implementation project(':utbot-spring-analyzer')
 
     fetchSpringAnalyzerJar project(path: ':utbot-spring-analyzer', configuration: 'springAnalyzerJar')
+    fetchInstrumentationJar project(path: ':utbot-instrumentation', configuration: 'instrumentationArchive')
 }
 
 processResources {
     from(configurations.fetchSpringAnalyzerJar) {
         into "lib"
     }
+    from(configurations.fetchInstrumentationJar) {
+        into "lib"
+    }
 }

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

@@ -42,9 +42,9 @@ import org.utbot.fuzzer.*
 import org.utbot.fuzzing.*
 import org.utbot.fuzzing.utils.Trie
 import org.utbot.instrumentation.ConcreteExecutor
+import org.utbot.instrumentation.instrumentation.Instrumentation
 import org.utbot.instrumentation.instrumentation.execution.UtConcreteExecutionData
 import org.utbot.instrumentation.instrumentation.execution.UtConcreteExecutionResult
-import org.utbot.instrumentation.instrumentation.execution.UtExecutionInstrumentation
 import soot.jimple.Stmt
 import soot.tagkit.ParamNamesTag
 import java.lang.reflect.Method
@@ -105,7 +105,8 @@ class UtBotSymbolicEngine(
     dependencyPaths: String,
     val mockStrategy: MockStrategy = NO_MOCKS,
     chosenClassesToMockAlways: Set<ClassId>,
-    applicationContext: ApplicationContext,
+    val applicationContext: ApplicationContext,
+    executionInstrumentation: Instrumentation<UtConcreteExecutionResult>,
     private val solverTimeoutInMillis: Int = checkSolverTimeoutMillis
 ) : UtContextInitializer() {
     private val graph = methodUnderTest.sootMethod.jimpleBody().apply {
@@ -154,7 +155,7 @@ class UtBotSymbolicEngine(
 
     private val concreteExecutor =
         ConcreteExecutor(
-            UtExecutionInstrumentation,
+            executionInstrumentation,
             classpath,
         ).apply { this.classLoader = utContext.classLoader }
 
@@ -355,7 +356,18 @@ class UtBotSymbolicEngine(
             methodUnderTest,
             collectConstantsForFuzzer(graph),
             names,
-            listOf(transform(ValueProvider.of(defaultValueProviders(defaultIdGenerator))))
+            listOf(transform(ValueProvider.of(defaultValueProviders(defaultIdGenerator)))),
+            thisInstanceFuzzedTypeWrapper = { fuzzedType ->
+                when (applicationContext) {
+                    is SpringApplicationContext -> when (applicationContext.typeReplacementApproach) {
+                        // TODO use bean names here, which should be made available here via SpringApplicationContext
+                        //  should be fixed together with ("use `springContext.getBean(String)` here" in SpringUtExecutionInstrumentation)
+                        is TypeReplacementApproach.ReplaceIfPossible -> AutowiredFuzzedType(fuzzedType, listOf(fuzzedType.classId.jClass.name))
+                        is TypeReplacementApproach.DoNotReplace -> fuzzedType
+                    }
+                    else -> fuzzedType
+                }
+            }
         ) { thisInstance, descr, values ->
             if (thisInstance?.model is UtNullModel) {
                 // We should not try to run concretely any models with null-this.
@@ -593,7 +605,7 @@ private fun ResolvedModels.constructStateForMethod(methodUnderTest: ExecutableId
     return EnvironmentModels(thisInstanceBefore, paramsBefore, statics)
 }
 
-private suspend fun ConcreteExecutor<UtConcreteExecutionResult, UtExecutionInstrumentation>.executeConcretely(
+private suspend fun ConcreteExecutor<UtConcreteExecutionResult, Instrumentation<UtConcreteExecutionResult>>.executeConcretely(
     methodUnderTest: ExecutableId,
     stateBefore: EnvironmentModels,
     instrumentation: List<UtInstrumentation>,

utbot-framework/src/main/kotlin/org/utbot/framework/assemble/AssembleModelGenerator.kt

@@ -1,5 +1,6 @@
 package org.utbot.framework.assemble
 
+import mu.KotlinLogging
 import org.utbot.common.isPrivate
 import org.utbot.common.isPublic
 import org.utbot.engine.ResolvedExecution
@@ -55,6 +56,10 @@ import java.util.IdentityHashMap
  */
 class AssembleModelGenerator(private val basePackageName: String) {
 
+    companion object {
+        private val logger = KotlinLogging.logger {}
+    }
+
     //Instantiated models are stored to avoid cyclic references during reference graph analysis
     private val instantiatedModels: IdentityHashMap<UtModel, UtReferenceModel> =
         IdentityHashMap<UtModel, UtReferenceModel>()
@@ -175,8 +180,13 @@ class AssembleModelGenerator(private val basePackageName: String) {
     private fun assembleModel(utModel: UtModel): UtModel {
         val collectedCallChain = callChain.toMutableList()
 
-        // We cannot create an assemble model for an anonymous class instance
-        if (utModel.classId.isAnonymous) {
+        try {
+            // We cannot create an assemble model for an anonymous class instance
+            if (utModel.classId.isAnonymous) {
+                return utModel
+            }
+        } catch (e: Exception) {
+            logger.warn { "Failed to load jClass for class ${utModel.classId.name} when assembling model" }
             return utModel
         }
 

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/Domain.kt

@@ -689,23 +689,6 @@ enum class ProjectType {
     JavaScript,
 }
 
-sealed class TypeReplacementApproach {
-    /**
-     * Do not replace interfaces and abstract classes with concrete implementors.
-     * Use mocking instead of it.
-     */
-    object DoNotReplace : TypeReplacementApproach()
-
-    /**
-     * Try to replace interfaces and abstract classes with concrete implementors
-     * obtained from bean definitions.
-     * If it is impossible, use mocking.
-     *
-     * Currently used in Spring applications only.
-     */
-    class ReplaceIfPossible(val config: String) : TypeReplacementApproach()
-}
-
 abstract class DependencyInjectionFramework(
     override val id: String,
     override val displayName: String,

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt

@@ -328,6 +328,8 @@ open class CgMethodConstructor(val context: CgContext) : CgContextOwner by conte
         when (methodType) {
             SUCCESSFUL -> error("Unexpected successful without exception method type for execution with exception $expectedException")
             PASSED_EXCEPTION -> {
+                // TODO consider rendering message in a comment
+                //  expectedException.message?.let { +comment(it) }
                 testFrameworkManager.expectException(expectedException::class.id) {
                     methodInvocationBlock()
                 }

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgSpringVariableConstructor.kt

@@ -4,15 +4,21 @@ import org.utbot.framework.codegen.domain.context.CgContext
 import org.utbot.framework.codegen.domain.models.CgValue
 import org.utbot.framework.codegen.domain.models.CgVariable
 import org.utbot.framework.plugin.api.UtAssembleModel
+import org.utbot.framework.plugin.api.UtAutowiredModel
 import org.utbot.framework.plugin.api.UtCompositeModel
 import org.utbot.framework.plugin.api.UtModel
 import org.utbot.framework.plugin.api.isMockModel
+import org.utbot.framework.plugin.api.util.jClass
 
 class CgSpringVariableConstructor(context: CgContext) : CgVariableConstructor(context) {
     val injectedMocksModelsVariables: MutableMap<Set<UtModel>, CgValue> = mutableMapOf()
     val mockedModelsVariables: MutableMap<Set<UtModel>, CgValue> = mutableMapOf()
 
     override fun getOrCreateVariable(model: UtModel, name: String?): CgValue {
+        if (model is UtAutowiredModel)
+            // TODO also, properly render corresponding @Autowired field, and make sure name isn't taken
+            return CgVariable(name ?: model.classId.jClass.simpleName.let { it[0].lowercase() + it.drop(1) }, model.classId)
+
         val alreadyCreatedInjectMocks = findCgValueByModel(model, injectedMocksModelsVariables)
         if (alreadyCreatedInjectMocks != null) {
             val fields: Collection<UtModel> = when (model) {

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgVariableConstructor.kt

@@ -113,6 +113,7 @@ open class CgVariableConstructor(val context: CgContext) :
                 is UtEnumConstantModel -> constructEnumConstant(model, baseName)
                 is UtClassRefModel -> constructClassRef(model, baseName)
                 is UtLambdaModel -> constructLambda(model, baseName)
+                else -> error("Unexpected UtModel: ${model::class}")
             }
         } else valueByModel.getOrPut(model) {
             when (model) {

utbot-framework/src/main/kotlin/org/utbot/framework/fields/ExecutionStateAnalyzer.kt

@@ -8,6 +8,7 @@ import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.MissingState
 import org.utbot.framework.plugin.api.UtArrayModel
 import org.utbot.framework.plugin.api.UtAssembleModel
+import org.utbot.framework.plugin.api.UtAutowiredModel
 import org.utbot.framework.plugin.api.UtClassRefModel
 import org.utbot.framework.plugin.api.UtCompositeModel
 import org.utbot.framework.plugin.api.UtEnumConstantModel
@@ -237,6 +238,12 @@ private class FieldStateVisitor : UtModelVisitor<FieldData>() {
         recordFieldState(data, element)
     }
 
+    override fun visit(element: UtAutowiredModel, data: FieldData) {
+        // TODO consider making UtAutowiredModel wrap UtCompositeModel or
+        //  even extend UtAssembleModel so here it's possible to recursively record field state
+        recordFieldState(data, element)
+    }
+
     private fun recordFieldState(data: FieldData, model: UtModel) {
         val fields = data.fields
         val path = data.path

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

@@ -36,6 +36,7 @@ import org.utbot.framework.util.SootUtils
 import org.utbot.framework.util.jimpleBody
 import org.utbot.framework.util.toModel
 import org.utbot.instrumentation.ConcreteExecutor
+import org.utbot.instrumentation.instrumentation.execution.SpringUtExecutionInstrumentation
 import org.utbot.instrumentation.instrumentation.execution.UtExecutionInstrumentation
 import org.utbot.instrumentation.warmup
 import java.io.File
@@ -65,6 +66,15 @@ open class TestCaseGenerator(
 ) {
     private val logger: KLogger = KotlinLogging.logger {}
     private val timeoutLogger: KLogger = KotlinLogging.logger(logger.name + ".timeout")
+    private val executionInstrumentation by lazy {
+        when (applicationContext) {
+            is SpringApplicationContext -> when (val approach = applicationContext.typeReplacementApproach) {
+                is TypeReplacementApproach.ReplaceIfPossible -> SpringUtExecutionInstrumentation(UtExecutionInstrumentation, approach.config)
+                is TypeReplacementApproach.DoNotReplace -> UtExecutionInstrumentation
+            }
+            else -> UtExecutionInstrumentation
+        }
+    }
 
     private val classpathForEngine: String
         get() = (buildDirs + listOfNotNull(classpath)).joinToString(File.pathSeparator)
@@ -88,7 +98,7 @@ open class TestCaseGenerator(
             if (warmupConcreteExecution) {
                 // force pool to create an appropriate executor
                 ConcreteExecutor(
-                    UtExecutionInstrumentation,
+                    executionInstrumentation,
                     classpathForEngine,
                 ).apply {
                     warmup()
@@ -269,6 +279,7 @@ open class TestCaseGenerator(
             mockStrategy = mockStrategyApi.toModel(),
             chosenClassesToMockAlways = chosenClassesToMockAlways,
             applicationContext = applicationContext,
+            executionInstrumentation = executionInstrumentation,
             solverTimeoutInMillis = executionTimeEstimator.updatedSolverCheckTimeoutMillis
         )
     }

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

@@ -30,7 +30,7 @@ fun defaultTestFlow(timeout: Long) = testFlow {
  */
 fun defaultSpringFlow(params: GenerateParams) = testFlow {
     generationTimeout = params.generationTimeout
-    isSymbolicEngineEnabled = true
+    isSymbolicEngineEnabled = params.isSymbolicEngineEnabled
     isFuzzingEnabled = params.isFuzzingEnabled
     fuzzingValue = params.fuzzingValue
 }

utbot-framework/src/main/kotlin/org/utbot/framework/util/UtModelVisitor.kt

@@ -2,6 +2,7 @@ package org.utbot.framework.util
 
 import org.utbot.framework.plugin.api.UtArrayModel
 import org.utbot.framework.plugin.api.UtAssembleModel
+import org.utbot.framework.plugin.api.UtAutowiredModel
 import org.utbot.framework.plugin.api.UtClassRefModel
 import org.utbot.framework.plugin.api.UtCompositeModel
 import org.utbot.framework.plugin.api.UtEnumConstantModel
@@ -35,6 +36,7 @@ abstract class UtModelVisitor<D> {
             is UtAssembleModel -> visit(element, data)
             is UtCompositeModel -> visit(element, data)
             is UtLambdaModel -> visit(element, data)
+            is UtAutowiredModel -> visit(element, data)
         }
     }
 
@@ -44,6 +46,7 @@ abstract class UtModelVisitor<D> {
     protected abstract fun visit(element: UtAssembleModel, data: D)
     protected abstract fun visit(element: UtCompositeModel, data: D)
     protected abstract fun visit(element: UtLambdaModel, data: D)
+    protected abstract fun visit(element: UtAutowiredModel, data: D)
 
     /**
      * Returns true when we can traverse the given model.