Draft using user classpath in spring-analyzer

Author: IlyaMuravjov

utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt

@@ -301,7 +301,7 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
      * The property is useful only for the IntelliJ IDEs.
      * If the property is set in true the spring analyzer process opens a debug port.
      * @see runInstrumentedProcessWithDebug
-     * @see org.utbot.framework.process.SpringAnalyzerProcess
+     * @see org.utbot.spring.process.SpringAnalyzerProcess
      */
     var runSpringAnalyzerProcessWithDebug by getBooleanProperty(false)
 

utbot-framework/src/main/kotlin/org/utbot/framework/process/EngineProcessMain.kt

@@ -77,15 +77,12 @@ private fun EngineProcessModel.setup(kryoHelper: KryoHelper, watchdog: IdleWatch
         }.toTypedArray())))
     }
     watchdog.measureTimeForActiveCall(getSpringBeanQualifiedNames, "Getting Spring bean definitions") { params ->
-        val springAnalyzerProcess = SpringAnalyzerProcess.createBlocking()
+        val springAnalyzerProcess = SpringAnalyzerProcess.createBlocking(params.classpath.toList())
         val beans = springAnalyzerProcess.terminateOnException { _ ->
             springAnalyzerProcess.getBeanQualifiedNames(
                 params.classpath.toList(),
                 params.config,
-                // TODO remove once spring-analyzer learns to find resources on its own, temporarily leaving it here for testing with hardcoded absolute paths
-                propertyFilesPaths = emptyList(),
-                xmlConfigurationPaths = emptyList(),
-                params.useSpringAnalyzer
+                params.fileStorage,
             ).toTypedArray()
         }
         springAnalyzerProcess.terminate()

utbot-framework/src/main/kotlin/org/utbot/framework/process/generated/EngineProcessModel.Generated.kt

@@ -72,7 +72,7 @@ class EngineProcessModel private constructor(
 
         private val __StringArraySerializer = FrameworkMarshallers.String.array()
 
-        const val serializationHash = 1955031277042475752L
+        const val serializationHash = -8371458556124482010L
 
     }
     override val serializersOwner: ISerializersOwner get() = EngineProcessModel
@@ -754,7 +754,7 @@ data class GenerateTestReportResult (
 data class GetSpringBeanQualifiedNamesParams (
     val classpath: Array<String>,
     val config: String,
-    val useSpringAnalyzer: Boolean
+    val fileStorage: String?
 ) : IPrintable {
     //companion
 
@@ -765,14 +765,14 @@ data class GetSpringBeanQualifiedNamesParams (
         override fun read(ctx: SerializationCtx, buffer: AbstractBuffer): GetSpringBeanQualifiedNamesParams  {
             val classpath = buffer.readArray {buffer.readString()}
             val config = buffer.readString()
-            val useSpringAnalyzer = buffer.readBool()
-            return GetSpringBeanQualifiedNamesParams(classpath, config, useSpringAnalyzer)
+            val fileStorage = buffer.readNullable { buffer.readString() }
+            return GetSpringBeanQualifiedNamesParams(classpath, config, fileStorage)
         }
 
         override fun write(ctx: SerializationCtx, buffer: AbstractBuffer, value: GetSpringBeanQualifiedNamesParams)  {
             buffer.writeArray(value.classpath) { buffer.writeString(it) }
             buffer.writeString(value.config)
-            buffer.writeBool(value.useSpringAnalyzer)
+            buffer.writeNullable(value.fileStorage) { buffer.writeString(it) }
         }
 
 
@@ -790,7 +790,7 @@ data class GetSpringBeanQualifiedNamesParams (
 
         if (!(classpath contentDeepEquals other.classpath)) return false
         if (config != other.config) return false
-        if (useSpringAnalyzer != other.useSpringAnalyzer) return false
+        if (fileStorage != other.fileStorage) return false
 
         return true
     }
@@ -799,7 +799,7 @@ data class GetSpringBeanQualifiedNamesParams (
         var __r = 0
         __r = __r*31 + classpath.contentDeepHashCode()
         __r = __r*31 + config.hashCode()
-        __r = __r*31 + useSpringAnalyzer.hashCode()
+        __r = __r*31 + if (fileStorage != null) fileStorage.hashCode() else 0
         return __r
     }
     //pretty print
@@ -808,7 +808,7 @@ data class GetSpringBeanQualifiedNamesParams (
         printer.indent {
             print("classpath = "); classpath.print(printer); println()
             print("config = "); config.print(printer); println()
-            print("useSpringAnalyzer = "); useSpringAnalyzer.print(printer); println()
+            print("fileStorage = "); fileStorage.print(printer); println()
         }
         printer.print(")")
     }

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

@@ -8,6 +8,7 @@ import com.intellij.openapi.progress.ProgressIndicator
 import com.intellij.openapi.progress.Task
 import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.project.guessProjectDir
 import com.intellij.openapi.roots.OrderEnumerator
 import com.intellij.openapi.roots.ProjectFileIndex
 import com.intellij.openapi.ui.Messages
@@ -28,6 +29,7 @@ import com.intellij.util.concurrency.AppExecutorUtil
 import com.intellij.util.containers.ContainerUtil
 import com.intellij.util.containers.nullize
 import com.intellij.util.io.exists
+import com.jetbrains.python.sdk.basePath
 import java.io.File
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -225,8 +227,10 @@ object UtTestsDialogProcessor {
                                                 process.getSpringBeanQualifiedNames(
                                                     buildDirs + classpathList,
                                                     approach.config,
-                                                    model.useSpringAnalyzer
-                                                ).also { logger.info { "Detected Spring Beans: $it" } }
+                                                    // TODO use common parent path for srcModule and used Spring
+                                                    //   config module if they are different modules
+                                                    model.srcModule.basePath
+                                                )
                                         }
 
                                     SpringApplicationContext(

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

@@ -56,9 +56,6 @@ class GenerateTestsModel(
 
     lateinit var typeReplacementApproach: TypeReplacementApproach
 
-    // TODO remove once issue with spring-analyzer expecting .properties and .xml file paths is resolved
-    var useSpringAnalyzer = false
-
     val conflictTriggers: ConflictTriggers = ConflictTriggers()
 
     var runGeneratedTestsWithCoverage : Boolean = false

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt

@@ -145,10 +145,10 @@ class EngineProcess private constructor(val project: Project, private val classN
         engineModel.setupUtContext.startBlocking(SetupContextParams(classpathForUrlsClassloader))
     }
 
-    fun getSpringBeanQualifiedNames(classpathList: List<String>, config: String, useSpringAnalyzer: Boolean): List<String> {
+    fun getSpringBeanQualifiedNames(classpathList: List<String>, config: String, fileStorage: String?): List<String> {
         assertReadAccessNotAllowed()
         return engineModel.getSpringBeanQualifiedNames.startBlocking(
-            GetSpringBeanQualifiedNamesParams(classpathList.toTypedArray(), config, useSpringAnalyzer)
+            GetSpringBeanQualifiedNamesParams(classpathList.toTypedArray(), config, fileStorage)
         ).toList()
     }
 

utbot-rd/src/main/rdgen/org/utbot/rd/models/EngineProcessModel.kt

@@ -87,7 +87,7 @@ object EngineProcessModel : Ext(EngineProcessRoot) {
     val getSpringBeanQualifiedNamesParams = structdef {
         field("classpath", array(PredefinedType.string))
         field("config", PredefinedType.string)
-        field("useSpringAnalyzer", PredefinedType.bool)
+        field("fileStorage", PredefinedType.string.nullable)
     }
     val methodDescription = structdef {
         field("name", PredefinedType.string)

utbot-rd/src/main/rdgen/org/utbot/rd/models/SpringAnalyzerModel.kt

@@ -9,9 +9,7 @@ object SpringAnalyzerProcessModel : Ext(SpringAnalyzerRoot) {
     val springAnalyzerParams = structdef {
         field("classpath", array(PredefinedType.string))
         field("configuration", PredefinedType.string)
-        field("propertyFilesPaths", array(PredefinedType.string))
-        field("xmlConfigurationPaths", array(PredefinedType.string))
-        field("useSpringAnalyzer", PredefinedType.bool)
+        field("fileStorage", PredefinedType.string.nullable)
     }
 
     val springAnalyzerResult = structdef {

utbot-spring-analyzer/src/main/kotlin/org/utbot/spring/ApplicationRunner.kt

@@ -1,5 +1,7 @@
 package org.utbot.spring.analyzers
 
+import com.jetbrains.rd.util.getLogger
+import com.jetbrains.rd.util.info
 import org.springframework.boot.builder.SpringApplicationBuilder
 import org.springframework.context.ApplicationContextException
 import org.utbot.spring.configurators.ApplicationConfigurationType
@@ -11,22 +13,19 @@ import org.utbot.spring.utils.FakeFileManager
 import org.utbot.spring.postProcessors.UtBotBeanFactoryPostProcessor
 import java.io.File
 
+val logger = getLogger<SpringApplicationAnalyzer>()
+
 class SpringApplicationAnalyzer(
     private val applicationData: ApplicationData
 ) {
 
     fun analyze(): List<String> {
-        val fakeFileManager =
-            FakeFileManager(applicationData.propertyFilesPaths + applicationData.xmlConfigurationPaths)
-        fakeFileManager.createTempFiles()
+        logger.info { "Analyzer Java: " + System.getProperty("java.version") }
 
         val applicationBuilder = SpringApplicationBuilder(SpringApplicationAnalyzer::class.java)
         val applicationConfigurator = ApplicationConfigurator(applicationBuilder, applicationData)
 
-        when (findConfigurationType(applicationData)) {
-            XmlConfiguration -> applicationConfigurator.configureXmlBasedApplication()
-            else -> applicationConfigurator.configureJavaBasedApplication()
-        }
+        applicationConfigurator.configureApplication()
 
         try {
             applicationBuilder.build()
@@ -35,19 +34,8 @@ class SpringApplicationAnalyzer(
             // UtBotBeanFactoryPostProcessor destroys bean definitions
             // to prevent Spring application from actually starting and
             // that causes it to throw ApplicationContextException
-            println("Bean analysis finished successfully")
-        } finally {
-            fakeFileManager.deleteTempFiles()
+            logger.info { "Bean analysis finished successfully" }
         }
         return UtBotBeanFactoryPostProcessor.beanQualifiedNames
     }
-
-    private fun findConfigurationType(applicationData: ApplicationData): ApplicationConfigurationType {
-        //TODO: support Spring Boot Applications here.
-        val fileExtension = File(applicationData.configurationFile).extension
-        return when (fileExtension) {
-            "xml" -> XmlConfiguration
-            else -> JavaConfiguration
-        }
-    }
 }

utbot-spring-analyzer/src/main/kotlin/org/utbot/spring/analyzers/SpringApplicationAnalyzer.kt

@@ -1,44 +1,56 @@
 package org.utbot.spring.configurators
 
+import com.jetbrains.rd.util.getLogger
+import com.jetbrains.rd.util.info
+import org.springframework.beans.factory.support.BeanDefinitionRegistry
+import org.springframework.beans.factory.support.SimpleBeanDefinitionRegistry
+import org.springframework.boot.SpringApplication
 import org.springframework.boot.builder.SpringApplicationBuilder
+import org.springframework.context.annotation.ClassPathBeanDefinitionScanner
+import org.springframework.context.annotation.ComponentScanBeanDefinitionParser
+import org.springframework.core.io.DefaultResourceLoader
 import org.utbot.spring.config.TestApplicationConfiguration
 import org.utbot.spring.data.ApplicationData
 import org.utbot.spring.utils.ConfigurationManager
+import java.io.File
 import java.net.URLClassLoader
+import kotlin.io.path.Path
+
+private val logger = getLogger<ApplicationConfigurator>()
 
 open class ApplicationConfigurator(
     private val applicationBuilder: SpringApplicationBuilder,
     private val applicationData: ApplicationData
 ) {
-    private val classLoader: ClassLoader = URLClassLoader(applicationData.applicationUrlArray)
-
-    fun configureJavaBasedApplication() {
-        configureApplication(
-            configurationClass = classLoader.loadClass(applicationData.configurationFile),
-            xmlConfigurationPaths = applicationData.xmlConfigurationPaths
-        )
-    }
-
-    fun configureXmlBasedApplication() {
-        configureApplication(
-            configurationClass = TestApplicationConfiguration::class.java,
-            xmlConfigurationPaths = listOf(applicationData.configurationFile)
-        )
+//    private val classLoader: ClassLoader = URLClassLoader(applicationData.classpath)
+    private val classLoader: ClassLoader = this::class.java.classLoader
+
+    fun configureApplication() {
+        //applicationBuilder.resourceLoader(DefaultResourceLoader().also { it.classLoader = classLoader })
+        when (findConfigurationType(applicationData)) {
+            ApplicationConfigurationType.XmlConfiguration -> {
+                logger.info { "Using xml Spring configuration" }
+                val configurationManager = ConfigurationManager(classLoader, TestApplicationConfiguration::class.java)
+                // Put `applicationData.configurationFile` in `@ImportResource` of `TestApplicationConfiguration`
+                configurationManager.patchImportResourceAnnotation(Path(applicationData.configurationFile).fileName)
+                applicationBuilder.sources(TestApplicationConfiguration::class.java)
+            }
+            else -> {
+                logger.info { "Using java Spring configuration" }
+                applicationBuilder.sources(
+                    TestApplicationConfiguration::class.java,
+                    classLoader.loadClass(applicationData.configurationFile)
+                )
+            }
+        }
     }
 
-    private fun configureApplication(configurationClass: Class<*>, xmlConfigurationPaths: List<String>) {
-
-        val configurationManager = ConfigurationManager(classLoader, configurationClass)
-
-        val xmlFilesConfigurator = XmlFilesConfigurator(xmlConfigurationPaths, configurationManager)
-        val propertiesConfigurator = PropertiesConfigurator(applicationData.propertyFilesPaths, configurationManager)
-
-        propertiesConfigurator.configure()
-        xmlFilesConfigurator.configure()
-
-        for (prop in propertiesConfigurator.readProperties()) {
-            applicationBuilder.properties(prop)
+    private fun findConfigurationType(applicationData: ApplicationData): ApplicationConfigurationType {
+        //TODO: support Spring Boot Applications here.
+        val fileExtension = File(applicationData.configurationFile).extension
+        return when (fileExtension) {
+            "xml" -> ApplicationConfigurationType.XmlConfiguration
+            else -> ApplicationConfigurationType.JavaConfiguration
         }
-        applicationBuilder.sources(TestApplicationConfiguration::class.java, configurationClass)
     }
 }