Remove unnecessary annotations from Spring integration tests

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

@@ -1320,7 +1320,12 @@ enum class TypeReplacementMode {
 }
 
 sealed class SpringConfiguration(val fullDisplayName: String) {
-    class JavaConfiguration(val classBinaryName: String) : SpringConfiguration(classBinaryName)
+    abstract class JavaBasedConfiguration(open val configBinaryName: String) : SpringConfiguration(configBinaryName)
+
+    class JavaConfiguration(override val configBinaryName: String) : JavaBasedConfiguration(configBinaryName)
+
+    class SpringBootConfiguration(override val configBinaryName: String, val isUnique: Boolean): JavaBasedConfiguration(configBinaryName)
+
     class XMLConfiguration(val absolutePath: String) : SpringConfiguration(absolutePath)
 }
 

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

@@ -103,18 +103,26 @@ class CgSpringIntegrationTestClassConstructor(
     )
 
     private fun addNecessarySpringSpecificAnnotations() {
+        val isSpringBootTestAccessible = utContext.classLoader.tryLoadClass(springBootTestClassId.name) != null
+        if (isSpringBootTestAccessible) {
+            addAnnotation(springBootTestClassId, Class)
+        }
+
         val (testFrameworkExtension, springExtension) = when (testFramework) {
             Junit4 -> runWithClassId to springRunnerClassId
             Junit5 -> extendWithClassId to springExtensionClassId
             TestNg -> error("Spring extension is not implemented in TestNg")
             else -> error("Trying to generate tests for Spring project with non-JVM framework")
         }
 
-        addAnnotation(
-            classId = testFrameworkExtension,
-            argument = createGetClassExpression(springExtension, codegenLanguage),
-            target = Class,
-        )
+        // @SpringBootTest contains @ExtendWith(SpringExtension.class), no need to add it manually
+        if (!isSpringBootTestAccessible || testFrameworkExtension != extendWithClassId) {
+            addAnnotation(
+                classId = testFrameworkExtension,
+                argument = createGetClassExpression(springExtension, codegenLanguage),
+                target = Class,
+            )
+        }
 
         if (utContext.classLoader.tryLoadClass(springBootTestContextBootstrapperClassId.name) != null)
             // TODO in somewhat new versions of Spring Boot, @SpringBootTest
@@ -126,49 +134,44 @@ class CgSpringIntegrationTestClassConstructor(
                 target = Class,
             )
 
-        if (utContext.classLoader.tryLoadClass(springBootTestClassId.name) != null)
-            addAnnotation(springBootTestClassId, Class)
-
-        // TODO avoid adding @ActiveProfiles(profiles = {"default"}) to reduce number of annotations
-        addAnnotation(
-            classId = activeProfilesClassId,
-            namedArguments =
-            listOf(
-                CgNamedAnnotationArgument(
-                    name = "profiles",
-                    value =
-                    CgArrayAnnotationArgument(
-                        springSettings.profiles.map { profile ->
-                            profile.resolve()
-                        }
+        val defaultProfileIsUsed = springSettings.profiles.singleOrNull() == "default"
+        if (!defaultProfileIsUsed) {
+            addAnnotation(
+                classId = activeProfilesClassId,
+                namedArguments = listOf(
+                    CgNamedAnnotationArgument(
+                        name = "profiles",
+                        value = CgArrayAnnotationArgument(springSettings.profiles.map { profile -> profile.resolve() })
                     )
-                )
-            ),
-            target = Class,
-        )
+                ),
+                target = Class,
+            )
+        }
 
-        // TODO avoid adding @ContextConfiguration(classes = {$defaultBootConfigClass}) to reduce number of annotations
-        addAnnotation(
-            classId = contextConfigurationClassId,
-            namedArguments =
-            listOf(
-                CgNamedAnnotationArgument(
-                    name = "classes",
-                    value = CgArrayAnnotationArgument(
-                        listOf(
-                            createGetClassExpression(
-                                // TODO:
-                                //  For now we support only JavaConfigurations in integration tests.
-                                //  Adapt for XMLConfigurations when supported.
-                                ClassId((springSettings.configuration as JavaConfiguration).classBinaryName),
-                                codegenLanguage
+        val configClass = springSettings.configuration as JavaBasedConfiguration
+        if (configClass is JavaConfiguration || configClass is SpringBootConfiguration && !configClass.isUnique) {
+            addAnnotation(
+                classId = contextConfigurationClassId,
+                namedArguments = listOf(
+                    CgNamedAnnotationArgument(
+                        name = "classes",
+                        value = CgArrayAnnotationArgument(
+                            listOf(
+                                createGetClassExpression(
+                                    // TODO: we support only JavaConfigurations in integration tests.
+                                    //  Adapt for XMLConfigurations when supported.
+                                    ClassId((springSettings.configuration as JavaConfiguration).configBinaryName),
+                                    codegenLanguage
+                                )
                             )
                         )
                     )
-                )
-            ),
-            target = Class,
-        )
+                ),
+                target = Class,
+            )
+        }
+
+
         addAnnotation(
             classId = dirtiesContextClassId,
             namedArguments = listOf(

utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/spring/SpringInstrumentationContext.kt

@@ -26,7 +26,7 @@ class SpringInstrumentationContext(
                 //  so we expect JavaConfigurations only.
                 //  After fix rewrite the following.
                 classLoader.loadClass(
-                    (springSettings.configuration as? JavaConfiguration)?.classBinaryName
+                    (springSettings.configuration as? JavaBasedConfiguration)?.configBinaryName
                         ?: error("JavaConfiguration was expected, but ${springSettings.configuration.javaClass.name} was provided.")
                 )
             ),

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

@@ -180,10 +180,10 @@ object UtTestsDialogProcessor {
                 is AbsentSpringSettings -> null
                 is PresentSpringSettings ->
                     when (val config = settings.configuration) {
-                        is JavaConfiguration -> {
+                        is JavaBasedConfiguration -> {
                             PsiClassHelper
-                                .findClass(config.classBinaryName, project)
-                                ?: error("Cannot find configuration class ${config.classBinaryName}.")
+                                .findClass(config.configBinaryName, project)
+                                ?: error("Cannot find configuration class ${config.configBinaryName}.")
                         }
                         // TODO: for XML config we also need to compile module containing,
                         //  since it may reference classes from that module

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/ui/GenerateTestsDialogWindow.kt

@@ -703,7 +703,16 @@ class GenerateTestsDialogWindow(val model: GenerateTestsModel) : DialogWrapper(m
                             SpringConfiguration.XMLConfiguration(absolutePath)
                         } else {
                             val classBinaryName = javaConfigurationHelper.restoreFullName(shortConfigName)
-                            SpringConfiguration.JavaConfiguration(classBinaryName)
+
+                            val springBootConfigs = model.getSortedSpringBootApplicationClasses()
+                            if (springBootConfigs.contains(classBinaryName)) {
+                                SpringConfiguration.SpringBootConfiguration(
+                                    configBinaryName = classBinaryName,
+                                    isUnique = springBootConfigs.size == 1,
+                                    )
+                            } else {
+                                SpringConfiguration.JavaConfiguration(classBinaryName)
+                            }
                         }
 
                     PresentSpringSettings(

utbot-spring-analyzer/src/main/kotlin/org/utbot/spring/utils/SourceFinder.kt

@@ -7,7 +7,6 @@ import org.utbot.common.patchAnnotation
 import org.utbot.framework.plugin.api.SpringConfiguration.*
 import org.utbot.spring.api.ApplicationData
 import org.utbot.spring.config.TestApplicationConfiguration
-import org.utbot.spring.configurators.ApplicationConfigurationType
 import java.nio.file.Path
 import kotlin.io.path.Path
 
@@ -20,11 +19,11 @@ class SourceFinder(
 
     fun findSources(): Array<Class<*>> =
         when (val config = applicationData.springSettings.configuration) {
-            is JavaConfiguration -> {
+            is JavaBasedConfiguration -> {
                 logger.info { "Using java Spring configuration" }
                 arrayOf(
                     TestApplicationConfiguration::class.java,
-                    classLoader.loadClass(config.classBinaryName)
+                    classLoader.loadClass(config.configBinaryName)
                 )
             }