Automatically install Spring test dependencies into user project if required

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

@@ -1341,6 +1341,32 @@ class SpringApplicationContext(
     ): Boolean = field.fieldId in classUnderTest.allDeclaredFieldIds && field.declaringClass.id !in springInjectedClasses
 }
 
+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 tests",
+        "Unit tests",
+        "Generate unit tests mocking other classes"
+    ),
+    INTEGRATION_TESTS(
+        "Integration tests",
+        "Integration tests",
+        "Generate integration tests autowiring real instance"
+    );
+
+    override fun toString() = id
+
+    companion object : CodeGenerationSettingBox {
+        override val defaultItem = UNIT_TESTS
+        override val allItems: List<SpringTestType> = values().toList()
+    }
+}
+
 /**
  * Describes information about beans obtained from Spring analysis process.
  *

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

@@ -76,6 +76,21 @@ fun DependencyInjectionFramework.patterns(): Patterns {
     return Patterns(moduleLibraryPatterns, libraryPatterns)
 }
 
+fun DependencyInjectionFramework.testPatterns(): Patterns {
+    val moduleLibraryPatterns = when (this) {
+        SpringBoot -> springBootTestModulePatterns
+        SpringBeans -> springBeansTestModulePatterns
+        else -> throw UnsupportedOperationException("Unknown dependency injection framework $this")
+    }
+    val libraryPatterns = when (this) {
+        SpringBoot -> springBootTestPatterns
+        SpringBeans -> springBeansTestPatterns
+        else -> throw UnsupportedOperationException("Unknown dependency injection framework $this")
+    }
+
+    return Patterns(moduleLibraryPatterns, libraryPatterns)
+}
+
 val JUNIT_4_JAR_PATTERN = Regex("junit-4(\\.1[2-9])(\\.[0-9]+)?")
 val JUNIT_4_MVN_PATTERN = Regex("junit:junit:4(\\.1[2-9])(\\.[0-9]+)?")
 val junit4Patterns = listOf(JUNIT_4_JAR_PATTERN, JUNIT_4_MVN_PATTERN)
@@ -120,9 +135,24 @@ val springBeansPatterns = listOf(SPRING_BEANS_JAR_PATTERN, SPRING_BEANS_MVN_PATT
 val SPRING_BEANS_BASIC_MODULE_PATTERN = Regex("spring-beans")
 val springBeansModulePatterns = listOf(SPRING_BEANS_BASIC_MODULE_PATTERN)
 
+val SPRING_BEANS_TEST_JAR_PATTERN = Regex("spring-test-([0-9]+)(\\.[0-9]+){1,2}")
+val SPRING_BEANS_TEST_MVN_PATTERN = Regex("org\\.springframework:spring-test:([0-9]+)(\\.[0-9]+){1,2}")
+val springBeansTestPatterns = listOf(SPRING_BEANS_TEST_JAR_PATTERN, SPRING_BEANS_TEST_MVN_PATTERN)
+
+val SPRING_BEANS_TEST_BASIC_MODULE_PATTERN = Regex("spring-test")
+val springBeansTestModulePatterns = listOf(SPRING_BEANS_TEST_BASIC_MODULE_PATTERN)
+
 val SPRING_BOOT_JAR_PATTERN = Regex("spring-boot-([0-9]+)(\\.[0-9]+){1,2}")
 val SPRING_BOOT_MVN_PATTERN = Regex("org\\.springframework\\.boot:spring-boot:([0-9]+)(\\.[0-9]+){1,2}")
 val springBootPatterns = listOf(SPRING_BOOT_JAR_PATTERN, SPRING_BOOT_MVN_PATTERN)
 
 val SPRING_BOOT_BASIC_MODULE_PATTERN = Regex("spring-boot")
 val springBootModulePatterns = listOf(SPRING_BOOT_BASIC_MODULE_PATTERN)
+
+val SPRING_BOOT_TEST_JAR_PATTERN = Regex("spring-boot-test-([0-9]+)(\\.[0-9]+){1,2}")
+val SPRING_BOOT_TEST_MVN_PATTERN = Regex("org\\.springframework\\.boot:spring-boot-test:([0-9]+)(\\.[0-9]+){1,2}")
+
+val springBootTestPatterns = listOf(SPRING_BOOT_TEST_JAR_PATTERN, SPRING_BOOT_TEST_MVN_PATTERN)
+
+val SPRING_BOOT_TEST_BASIC_MODULE_PATTERN = Regex("spring-boot-test")
+val springBootTestModulePatterns = listOf(SPRING_BOOT_TEST_BASIC_MODULE_PATTERN)

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

@@ -40,6 +40,8 @@ import kotlin.io.path.exists
 import kotlin.io.path.pathString
 import mu.KotlinLogging
 import org.jetbrains.concurrency.Promise
+import org.jetbrains.concurrency.all
+import org.jetbrains.concurrency.thenRun
 import org.jetbrains.idea.maven.project.MavenProjectsManager
 import org.jetbrains.kotlin.idea.base.util.module
 import org.utbot.framework.CancellationStrategyType.CANCEL_EVERYTHING
@@ -181,8 +183,11 @@ object UtTestsDialogProcessor {
             .map { it.containingFile.virtualFile }
             .toTypedArray()
 
-        val promise = compile(project, filesToCompile, springConfigClass)
-        promise.onSuccess {
+        val compilationPromise = model.preCompilePromises
+            .all()
+            .thenAsync { compile(project, filesToCompile, springConfigClass) }
+
+        compilationPromise.onSuccess {
             if (it.hasErrors() || it.isAborted)
                 return@onSuccess
 

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/models/ExternalLibraryDescriptors.kt

@@ -22,6 +22,13 @@ fun jUnit5ParametrizedTestsLibraryDescriptor(versionInProject: String?) =
 fun mockitoCoreLibraryDescriptor(versionInProject: String?) =
     ExternalLibraryDescriptor("org.mockito", "mockito-core", "3.5.0", null, versionInProject ?: "4.2.0")
 
+fun springBootTestLibraryDescriptor(versionInProject: String?) =
+    ExternalLibraryDescriptor("org.springframework.boot", "spring-boot-test", "2.4.0", null, versionInProject ?: "3.0.6")
+
+fun springTestLibraryDescriptor(versionInProject: String?) =
+    ExternalLibraryDescriptor("org.springframework", "spring-test", "2.5", null, versionInProject ?: "6.0.8")
+
+
 /**
  * TestNg requires JDK 11 since version 7.6.0
  * For projects with JDK 8 version 7.5 should be installed.

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/models/GenerateTestsModel.kt

@@ -15,11 +15,13 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiJavaFile
 import com.intellij.refactoring.util.classMembers.MemberInfo
+import org.jetbrains.concurrency.Promise
 import org.jetbrains.kotlin.psi.KtFile
 import org.utbot.framework.SummariesGenerationType
 import org.utbot.framework.UtSettings
 import org.utbot.framework.codegen.domain.TypeReplacementApproach
 import org.utbot.framework.plugin.api.JavaDocCommentStyle
+import org.utbot.framework.plugin.api.SpringTestType
 import org.utbot.framework.util.ConflictTriggers
 import org.utbot.intellij.plugin.settings.Settings
 
@@ -52,12 +54,14 @@ class GenerateTestsModel(
     var runInspectionAfterTestGeneration: Boolean = true
     lateinit var forceStaticMocking: ForceStaticMocking
     lateinit var chosenClassesToMockAlways: Set<ClassId>
+    lateinit var springTestType: SpringTestType
     lateinit var commentStyle: JavaDocCommentStyle
 
     lateinit var typeReplacementApproach: TypeReplacementApproach
     lateinit var profileNames: String
 
     val conflictTriggers: ConflictTriggers = ConflictTriggers()
+    val preCompilePromises: MutableList<Promise<*>> = mutableListOf()
 
     var runGeneratedTestsWithCoverage : Boolean = false
     var summariesGenerationType : SummariesGenerationType = UtSettings.summaryGenerationType

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/settings/Settings.kt

@@ -23,6 +23,7 @@ private fun fromGenerateTestsModel(model: GenerateTestsModel): Settings.State {
         forceStaticMocking = model.forceStaticMocking,
         parametrizedTestSource = model.parametrizedTestSource,
         classesToMockAlways = model.chosenClassesToMockAlways.mapTo(mutableSetOf()) { it.name }.toTypedArray(),
+        springTestType = model.springTestType,
         fuzzingValue = model.fuzzingValue,
         runGeneratedTestsWithCoverage = model.runGeneratedTestsWithCoverage,
         commentStyle = model.commentStyle,