Introduce SpringSettings

Author: sofurihafe

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

@@ -1323,6 +1323,13 @@ enum class TypeReplacementMode {
     NoImplementors,
 }
 
+interface CodeGenerationContext
+
+interface SpringCodeGenerationContext : CodeGenerationContext {
+    val springTestType: SpringTestType
+    val springSettings: SpringSettings?
+}
+
 /**
  * A context to use when no specific data is required.
  *
@@ -1332,7 +1339,7 @@ enum class TypeReplacementMode {
 open class ApplicationContext(
     val mockFrameworkInstalled: Boolean = true,
     staticsMockingIsConfigured: Boolean = true,
-) {
+) : CodeGenerationContext {
     var staticsMockingIsConfigured = staticsMockingIsConfigured
         private set
 
@@ -1384,23 +1391,16 @@ 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()
+sealed interface SpringConfiguration {
+    class JavaConfiguration(val classBinaryName: String) : SpringConfiguration
+    class XMLConfiguration(val absolutePath: String) : SpringConfiguration
 }
 
+class SpringSettings(
+    val configuration: SpringConfiguration,
+    val profileExpression: String
+)
+
 /**
  * Data we get from Spring application context
  * to manage engine and code generator behaviour.
@@ -1422,9 +1422,9 @@ class SpringApplicationContext(
     staticsMockingIsConfigured: Boolean,
     val beanDefinitions: List<BeanDefinitionData> = emptyList(),
     private val shouldUseImplementors: Boolean,
-    val typeReplacementApproach: TypeReplacementApproach,
-    val testType: SpringTestsType
-): ApplicationContext(mockInstalled, staticsMockingIsConfigured) {
+    override val springTestType: SpringTestType,
+    override val springSettings: SpringSettings?,
+): ApplicationContext(mockInstalled, staticsMockingIsConfigured), SpringCodeGenerationContext {
 
     companion object {
         private val logger = KotlinLogging.logger {}
@@ -1500,19 +1500,19 @@ class SpringApplicationContext(
     ): Boolean = field.fieldId in classUnderTest.allDeclaredFieldIds && field.declaringClass.id !in springInjectedClasses
 }
 
-enum class SpringTestsType(
+enum class SpringTestType(
     override val id: String,
     override val displayName: String,
     override val description: String,
     // Integration tests generation requires spring test framework being installed
     var frameworkInstalled: Boolean = false,
 ) : CodeGenerationSettingItem {
-    UNIT_TESTS(
+    UNIT_TEST(
         "Unit tests",
         "Unit tests",
         "Generate unit tests mocking other classes"
     ),
-    INTEGRATION_TESTS(
+    INTEGRATION_TEST(
         "Integration tests",
         "Integration tests",
         "Generate integration tests autowiring real instance"
@@ -1521,8 +1521,8 @@ enum class SpringTestsType(
     override fun toString() = id
 
     companion object : CodeGenerationSettingBox {
-        override val defaultItem = UNIT_TESTS
-        override val allItems: List<SpringTestsType> = values().toList()
+        override val defaultItem = UNIT_TEST
+        override val allItems: List<SpringTestType> = values().toList()
     }
 }
 

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

@@ -31,6 +31,9 @@ object SpringModelUtils {
     val springBootTestContextBootstrapperClassId =
         ClassId("org.springframework.boot.test.context.SpringBootTestContextBootstrapper")
 
+    val activeProfilesClassId = ClassId("org.springframework.test.context.ActiveProfiles")
+    val contextConfigurationClassId = ClassId("org.springframework.test.context.ContextConfiguration")
+
 
     // most likely only one persistent library is on the classpath, but we need to be able to work with either of them
     private val persistentLibraries = listOf("javax.persistence", "jakarta.persistence")

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

@@ -388,7 +388,7 @@ class UtBotSymbolicEngine(
         var testEmittedByFuzzer = 0
         val valueProviders = ValueProvider.of(defaultValueProviders(defaultIdGenerator))
             .letIf(applicationContext is SpringApplicationContext
-                        && applicationContext.typeReplacementApproach is TypeReplacementApproach.ReplaceIfPossible
+                        && applicationContext.springSettings != null
             ) { provider ->
                 val relevantRepositories = concreteExecutor.getRelevantSpringRepositories(methodUnderTest.classId)
                 logger.info { "Detected relevant repositories for class ${methodUnderTest.classId}: $relevantRepositories" }

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

@@ -30,9 +30,8 @@ class SpringTestClassModel(
     val springSpecificInformation: SpringSpecificInformation,
 ): TestClassModel(classUnderTest, methodTestSets, nestedClasses)
 
-
 class SpringSpecificInformation(
-    val thisInstanceModels: TypedModelWrappers = mapOf(),
-    val thisInstanceDependentMocks: TypedModelWrappers = mapOf(),
-    val autowiredFromContextModels: TypedModelWrappers = mapOf(),
+    val thisInstanceModels: TypedModelWrappers,
+    val thisInstanceDependentMocks: TypedModelWrappers,
+    val autowiredFromContextModels: TypedModelWrappers,
 )

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/generator/SpringCodeGenerator.kt

@@ -17,12 +17,13 @@ import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.CodegenLanguage
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.MockFramework
-import org.utbot.framework.plugin.api.SpringTestsType
+import org.utbot.framework.plugin.api.SpringTestType
+import org.utbot.framework.plugin.api.SpringCodeGenerationContext
 
 class SpringCodeGenerator(
-    private val springTestsType: SpringTestsType = SpringTestsType.defaultItem,
     val classUnderTest: ClassId,
     val projectType: ProjectType,
+    val codeGenerationContext: SpringCodeGenerationContext,
     paramNames: MutableMap<ExecutableId, List<String>> = mutableMapOf(),
     generateUtilClassFile: Boolean = false,
     testFramework: TestFramework = TestFramework.defaultItem,
@@ -59,9 +60,12 @@ class SpringCodeGenerator(
         val testClassModel = SpringTestClassModelBuilder(context).createTestClassModel(classUnderTest, testSets)
 
         logger.info { "Code generation phase started at ${now()}" }
-        val astConstructor = when (springTestsType) {
-            SpringTestsType.UNIT_TESTS -> CgSpringUnitTestClassConstructor(context)
-            SpringTestsType.INTEGRATION_TESTS -> CgSpringIntegrationTestClassConstructor(context)
+        val astConstructor = when (codeGenerationContext.springTestType) {
+            SpringTestType.UNIT_TEST -> CgSpringUnitTestClassConstructor(context)
+            SpringTestType.INTEGRATION_TEST ->
+                codeGenerationContext.springSettings
+                    ?.let { CgSpringIntegrationTestClassConstructor(context, it) }
+                    ?: error("Error text.")
         }
         val testClassFile = astConstructor.construct(testClassModel)
         logger.info { "Code generation phase finished at ${now()}" }

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

@@ -8,50 +8,67 @@ import org.utbot.framework.codegen.domain.context.CgContext
 import org.utbot.framework.codegen.domain.models.*
 import org.utbot.framework.codegen.domain.models.AnnotationTarget.*
 import org.utbot.framework.plugin.api.ClassId
-import org.utbot.framework.plugin.api.CodegenLanguage
+import org.utbot.framework.plugin.api.SpringConfiguration
+import org.utbot.framework.plugin.api.SpringSettings
 import org.utbot.framework.plugin.api.util.SpringModelUtils
+import org.utbot.framework.plugin.api.util.SpringModelUtils.activeProfilesClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.autoConfigureTestDbClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.autowiredClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.bootstrapWithClassId
+import org.utbot.framework.plugin.api.util.SpringModelUtils.contextConfigurationClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.dirtiesContextClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.dirtiesContextClassModeClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.springBootTestContextBootstrapperClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.springExtensionClassId
 import org.utbot.framework.plugin.api.util.SpringModelUtils.transactionalClassId
 import org.utbot.framework.plugin.api.util.utContext
 
-class CgSpringIntegrationTestClassConstructor(context: CgContext) : CgAbstractSpringTestClassConstructor(context) {
+class CgSpringIntegrationTestClassConstructor(
+    context: CgContext,
+    private val springSettings: SpringSettings
+) : CgAbstractSpringTestClassConstructor(context) {
     override fun constructTestClass(testClassModel: SpringTestClassModel): CgClass {
-        collectSpringSpecificAnnotations()
+        addNecessarySpringSpecificAnnotations()
         return super.constructTestClass(testClassModel)
     }
 
     override fun constructClassFields(testClassModel: SpringTestClassModel): List<CgFieldDeclaration> {
-        val autowiredFromContextModels = testClassModel.springSpecificInformation.autowiredFromContextModels
+        val autowiredFromContextModels =
+            testClassModel.springSpecificInformation.autowiredFromContextModels
         return constructFieldsWithAnnotation(autowiredClassId, autowiredFromContextModels)
     }
 
-    override fun constructAdditionalMethods() = CgMethodsCluster(header = null, content = emptyList())
+    override fun constructAdditionalMethods() =
+        CgMethodsCluster(header = null, content = emptyList())
 
-    private fun collectSpringSpecificAnnotations() {
+    private fun addNecessarySpringSpecificAnnotations() {
         val springRunnerType = when (testFramework) {
             Junit4 -> SpringModelUtils.runWithClassId
             Junit5 -> SpringModelUtils.extendWithClassId
             TestNg -> error("Spring extension is not implemented in TestNg")
             else -> error("Trying to generate tests for Spring project with non-JVM framework")
         }
 
-        statementConstructor.addAnnotation(
+        addAnnotation(
             classId = springRunnerType,
             argument = createGetClassExpression(springExtensionClassId, codegenLanguage),
             target = Class,
         )
-        statementConstructor.addAnnotation(
+        addAnnotation(
             classId = bootstrapWithClassId,
             argument = createGetClassExpression(springBootTestContextBootstrapperClassId, codegenLanguage),
             target = Class,
         )
-
+        addAnnotation(
+            classId = activeProfilesClassId,
+            argument = springSettings.profileExpression, // TODO: separate by comma
+            target = Class,
+        )
+        addAnnotation(
+            classId = contextConfigurationClassId,
+            argument = (springSettings.configuration as SpringConfiguration.JavaConfiguration).classBinaryName, // TODO: unpacking
+            target = Class,
+        )
         addAnnotation(
             classId = dirtiesContextClassId,
             namedArguments = listOf(

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

@@ -69,19 +69,19 @@ open class TestCaseGenerator(
     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 ->
-                    when (applicationContext.testType) {
-                        SpringTestsType.UNIT_TESTS -> UtExecutionInstrumentation
-                        SpringTestsType.INTEGRATION_TESTS -> SpringUtExecutionInstrumentation(
-                                UtExecutionInstrumentation,
-                                approach.config,
-                                applicationContext.beanDefinitions,
-                                buildDirs.map { it.toURL() }.toTypedArray(),
-                                )
-                    }
-                is TypeReplacementApproach.DoNotReplace -> UtExecutionInstrumentation
+            is SpringApplicationContext -> when (val springSettings = applicationContext.springSettings) {
+                null -> UtExecutionInstrumentation
+                else -> when (applicationContext.springTestType) {
+                    SpringTestType.UNIT_TEST -> UtExecutionInstrumentation
+                    SpringTestType.INTEGRATION_TEST -> SpringUtExecutionInstrumentation(
+                        UtExecutionInstrumentation,
+                        springSettings,
+                        applicationContext.beanDefinitions,
+                        buildDirs.map { it.toURL() }.toTypedArray(),
+                    )
+                }
             }
+
             else -> UtExecutionInstrumentation
         }
     }