Support Spring autowire two and more different beans of one type #2389 (#2421)

---------

Co-authored-by: Egor Kulikov <egor.k.kulikov@gmail.com>

Author: tepa46

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

@@ -16,14 +16,13 @@ import org.utbot.framework.codegen.domain.models.CgStaticsRegion
 import org.utbot.framework.codegen.domain.models.CgVariable
 import org.utbot.framework.codegen.domain.models.SpringTestClassModel
 import org.utbot.framework.codegen.domain.models.builders.TypedModelWrappers
-import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.UtExecution
 import org.utbot.framework.plugin.api.UtSpringContextModel
 import org.utbot.framework.plugin.api.util.SpringModelUtils.getBeanNameOrNull
 import org.utbot.framework.plugin.api.util.id
 import java.lang.Exception
 
-abstract class CgAbstractSpringTestClassConstructor(context: CgContext):
+abstract class CgAbstractSpringTestClassConstructor(context: CgContext) :
     CgAbstractTestClassConstructor<SpringTestClassModel>(context) {
 
     protected val variableConstructor: CgSpringVariableConstructor =
@@ -93,29 +92,43 @@ abstract class CgAbstractSpringTestClassConstructor(context: CgContext):
     open fun constructAdditionalUtilMethods(): CgMethodsCluster? = null
 
     protected fun constructFieldsWithAnnotation(
-        annotationClassId: ClassId,
+        fieldManager: CgClassFieldManager,
         groupedModelsByClassId: TypedModelWrappers,
     ): List<CgFieldDeclaration> {
+        val annotationClassId = fieldManager.annotationType
         val annotation = addAnnotation(annotationClassId, Field)
 
         val constructedDeclarations = mutableListOf<CgFieldDeclaration>()
-        for ((classId, listOfUtModels) in groupedModelsByClassId) {
-            val modelWrapper = listOfUtModels.firstOrNull() ?: continue
+        for ((classId, modelWrappers) in groupedModelsByClassId) {
+
+            val fieldWithAnnotationIsRequired = fieldManager.fieldWithAnnotationIsRequired(modelWrappers)
+            if (!fieldWithAnnotationIsRequired) {
+                continue
+            }
+
+            val modelWrapper = modelWrappers.firstOrNull() ?: continue
             val model = modelWrapper.model
+
             val baseVarName = model.getBeanNameOrNull()
 
             val createdVariable = variableConstructor.getOrCreateVariable(model, baseVarName) as? CgVariable
                 ?: error("`UtCompositeModel` model was expected, but $model was found")
 
             val declaration = CgDeclaration(classId, variableName = createdVariable.name, initializer = null)
-            constructedDeclarations += CgFieldDeclaration(ownerClassId = currentTestClass, declaration, annotation)
 
-            listOfUtModels.forEach { key ->
-                valueByUtModelWrapper[key] = createdVariable
-            }
-
-            variableConstructor.annotatedModelGroups
-                .getOrPut(annotationClassId) { mutableSetOf() } += listOfUtModels
+            constructedDeclarations += CgFieldDeclaration(
+                ownerClassId = currentTestClass,
+                declaration,
+                annotation
+            )
+
+            modelWrappers
+                .forEach { modelWrapper ->
+                    modelWrapper.let {
+                        valueByUtModelWrapper[modelWrapper] = createdVariable
+                        variableConstructor.annotatedModelGroups.getOrPut(annotationClassId) { mutableSetOf() } += modelWrapper
+                    }
+                }
         }
 
         return constructedDeclarations

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

@@ -14,12 +14,16 @@ import org.utbot.framework.plugin.api.UtModel
 import org.utbot.framework.plugin.api.isMockModel
 import org.utbot.framework.plugin.api.util.SpringModelUtils.autowiredClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.isAutowiredFromContext
+import java.util.*
+import kotlin.collections.HashMap
 
 sealed interface CgClassFieldManager : CgContextOwner {
 
     val annotationType: ClassId
 
     fun constructVariableForField(model: UtModel, modelVariable: CgValue): CgValue
+
+    fun fieldWithAnnotationIsRequired(modelWrappers: Set<UtModelWrapper>): Boolean
 }
 
 abstract class CgClassFieldManagerImpl(context: CgContext) :
@@ -29,6 +33,11 @@ abstract class CgClassFieldManagerImpl(context: CgContext) :
     val variableConstructor: CgSpringVariableConstructor by lazy {
         CgComponents.getVariableConstructorBy(context) as CgSpringVariableConstructor
     }
+
+    fun findCgValueByModel(model: UtModel, setOfModels: Set<UtModelWrapper>?): CgValue? {
+        val key = setOfModels?.find { it == model.wrap() } ?: return null
+        return valueByUtModelWrapper[key]
+    }
 }
 
 class CgInjectingMocksFieldsManager(val context: CgContext) : CgClassFieldManagerImpl(context) {
@@ -43,19 +52,23 @@ class CgInjectingMocksFieldsManager(val context: CgContext) : CgClassFieldManage
         }
 
         modelFields?.forEach { (fieldId, fieldModel) ->
-            //creating variables for modelVariable fields
+            // creating variables for modelVariable fields
             val variableForField = variableConstructor.getOrCreateVariable(fieldModel)
 
-            // If field model is a mock, it is set in the connected with instance under test automatically via @InjectMocks;
+            // is variable mocked by @Mock annotation
+            val isMocked = findCgValueByModel(fieldModel, variableConstructor.annotatedModelGroups[mockClassId]) != null
+
+            // If field model is a mock model and is mocked by @Mock annotation in classFields, it is set in the connected with instance under test automatically via @InjectMocks;
             // Otherwise we need to set this field manually.
-            if (!fieldModel.isMockModel()) {
+            if (!fieldModel.isMockModel() || !isMocked) {
                 variableConstructor.setFieldValue(modelVariable, fieldId, variableForField)
             }
         }
 
         return modelVariable
     }
 
+    override fun fieldWithAnnotationIsRequired(modelWrappers: Set<UtModelWrapper>): Boolean = true
 }
 
 class CgMockedFieldsManager(context: CgContext) : CgClassFieldManagerImpl(context) {
@@ -72,6 +85,20 @@ class CgMockedFieldsManager(context: CgContext) : CgClassFieldManagerImpl(contex
         return modelVariable
     }
 
+    override fun fieldWithAnnotationIsRequired(modelWrappers: Set<UtModelWrapper>): Boolean {
+        // group [listOfUtModels] by `testSetId` and `executionId`
+        // to check how many instances of one type are used in each execution
+        val modelsByExecutions = modelWrappers
+            .groupByTo(HashMap()) { Pair(it.testSetId, it.executionId) }
+
+        // maximal instances of one type amount in one execution
+        val instanceMaxCount = Collections.max(modelsByExecutions.map { (_, modelsList) -> modelsList.size })
+
+        // if [instanceCount] is 1, then we mock variable by @Mock annotation
+        // Otherwise we will mock variable by simple mock later
+        return instanceMaxCount == 1
+    }
+
 }
 
 class CgAutowiredFieldsManager(context: CgContext) : CgClassFieldManagerImpl(context) {
@@ -87,6 +114,8 @@ class CgAutowiredFieldsManager(context: CgContext) : CgClassFieldManagerImpl(con
             else -> error("Trying to autowire model $model but it is not appropriate")
         }
     }
+
+    override fun fieldWithAnnotationIsRequired(modelWrappers: Set<UtModelWrapper>): Boolean = true
 }
 
 class ClassFieldManagerFacade(context: CgContext) : CgContextOwner by context {
@@ -97,12 +126,13 @@ class ClassFieldManagerFacade(context: CgContext) : CgContextOwner by context {
 
     fun constructVariableForField(
         model: UtModel,
-        annotatedModelGroups: Map<ClassId, Set<UtModelWrapper>>,
     ): CgValue? {
         val annotationManagers = listOf(injectingMocksFieldsManager, mockedFieldsManager, autowiredFieldsManager)
 
         annotationManagers.forEach { manager ->
-            val alreadyCreatedVariable = findCgValueByModel(model, annotatedModelGroups[manager.annotationType])
+            val annotatedModelGroups = manager.variableConstructor.annotatedModelGroups
+
+            val alreadyCreatedVariable = manager.findCgValueByModel(model, annotatedModelGroups[manager.annotationType])
 
             if (alreadyCreatedVariable != null) {
                 return manager.constructVariableForField(model, alreadyCreatedVariable)
@@ -111,9 +141,4 @@ class ClassFieldManagerFacade(context: CgContext) : CgContextOwner by context {
 
         return null
     }
-
-    private fun findCgValueByModel(model: UtModel, setOfModels: Set<UtModelWrapper>?): CgValue? {
-        val key = setOfModels?.find { it == model.wrap() } ?: return null
-        return valueByUtModelWrapper[key]
-    }
 }

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

@@ -40,6 +40,9 @@ class CgSpringIntegrationTestClassConstructor(
     private val springCodeGenerationContext: SpringCodeGenerationContext,
     private val springSettings: PresentSpringSettings,
 ) : CgAbstractSpringTestClassConstructor(context) {
+
+    private val autowiredFieldManager = CgAutowiredFieldsManager(context)
+
     companion object {
         private val logger = KotlinLogging.logger {}
     }
@@ -52,7 +55,7 @@ class CgSpringIntegrationTestClassConstructor(
     override fun constructClassFields(testClassModel: SpringTestClassModel): List<CgFieldDeclaration> {
         val autowiredFromContextModels =
             testClassModel.springSpecificInformation.autowiredFromContextModels
-        return constructFieldsWithAnnotation(autowiredClassId, autowiredFromContextModels)
+        return constructFieldsWithAnnotation(autowiredFieldManager, autowiredFromContextModels)
     }
 
     override fun constructAdditionalTestMethods() =

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

@@ -22,17 +22,19 @@ import org.utbot.framework.plugin.api.util.objectClassId
 class CgSpringUnitTestClassConstructor(context: CgContext) : CgAbstractSpringTestClassConstructor(context) {
 
     private var additionalMethodsRequired: Boolean = false
-
     private lateinit var mockitoCloseableVariable: CgValue
 
+    private val injectingMocksFieldsManager = CgInjectingMocksFieldsManager(context)
+    private val mocksFieldsManager = CgMockedFieldsManager(context)
+
     override fun constructClassFields(testClassModel: SpringTestClassModel): List<CgFieldDeclaration> {
         val fields = mutableListOf<CgFieldDeclaration>()
         val thisInstances = testClassModel.springSpecificInformation.thisInstanceModels
         val mocks = testClassModel.springSpecificInformation.thisInstanceDependentMocks
 
         if (mocks.isNotEmpty()) {
-            val mockedFields = constructFieldsWithAnnotation(mockClassId, mocks)
-            val injectingMocksFields = constructFieldsWithAnnotation(injectMocksClassId, thisInstances)
+            val mockedFields = constructFieldsWithAnnotation(mocksFieldsManager, mocks)
+            val injectingMocksFields = constructFieldsWithAnnotation(injectingMocksFieldsManager, thisInstances)
 
             fields += injectingMocksFields
             fields += mockedFields

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

@@ -12,10 +12,10 @@ import org.utbot.framework.plugin.api.util.stringClassId
 class CgSpringVariableConstructor(context: CgContext) : CgVariableConstructor(context) {
     val annotatedModelGroups: MutableMap<ClassId, MutableSet<UtModelWrapper>> = mutableMapOf()
 
-    private val classFieldManager = ClassFieldManagerFacade(context)
+    private val fieldManagerFacade = ClassFieldManagerFacade(context)
 
     override fun getOrCreateVariable(model: UtModel, name: String?): CgValue {
-        val variable = classFieldManager.constructVariableForField(model, annotatedModelGroups)
+        val variable = fieldManagerFacade.constructVariableForField(model)
 
         variable?.let { return it }