Added support for multiple configuration files of the same type.

Author: tepa46

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

@@ -4,18 +4,23 @@ import analyzers.SpringApplicationAnalyzer
 
 fun main(args: Array<String>) {
     /*
-    val arg0 = "D:/Projects/spring-starter-lesson-28/build/classes/java/main";
-    val arg1 = "com.dmdev.spring.config.ApplicationConfiguration";
-    val arg2 = "D:/Projects/spring-starter-lesson-28/src/main/resources/application.properties";
-    val arg3 = "D:/Projects/spring-starter-lesson-28/src/main/resources/application.xml";
-    val springApplicationAnalyzer = SpringApplicationAnalyzer(arg0, arg1, arg2, arg3)
+        arg2 contains .properties files, arg3 contains .xml files.
+        If there are several files, they are transmitted via ";".
+        If there are no files, then an empty string "" is passed
+    */
+
+    /* FOR EXAMPLE
+    val arg0 = "/Users/kirillshishin/IdeaProjects/spring-starter-lesson-28/build/classes/java/main"
+    val arg1 = "com.dmdev.spring.config.ApplicationConfiguration"
+    val arg2 = "/Users/kirillshishin/IdeaProjects/spring-starter-lesson-28/src/main/resources/application.properties;/Users/kirillshishin/IdeaProjects/spring-starter-lesson-28/src/main/resources/application-web.properties"
+    val arg3 = "/Users/kirillshishin/IdeaProjects/spring-starter-lesson-28/src/main/resources/application.xml;/Users/kirillshishin/IdeaProjects/spring-starter-lesson-28/src/main/resources/application2.xml"
     */
 
     val springApplicationAnalyzer = SpringApplicationAnalyzer(
         applicationPath = args[0],
         configurationClassFqn = args[1],
-        propertyFilePath = args[2],
-        xmlConfigurationPath = args[3],
+        propertyFilesPaths = args[2].split(";"),
+        xmlConfigurationPaths = args[3].split(";"),
     )
 
     springApplicationAnalyzer.analyze()

utbot-spring-analyzer/src/main/kotlin/analyzers/PropertiesAnalyzer.kt

@@ -1,5 +1,8 @@
 package analyzers
 
+import application.utils.FakeFileManager
+import application.configurators.PropertiesConfigurator
+import application.configurators.XmlFilesConfigurator
 import config.TestApplicationConfiguration
 import org.springframework.boot.builder.SpringApplicationBuilder
 import org.springframework.context.ApplicationContextException
@@ -12,29 +15,30 @@ import java.nio.file.Path
 class SpringApplicationAnalyzer(
     private val applicationPath: String,
     private val configurationClassFqn: String,
-    private val propertyFilePath: String,
-    private val xmlConfigurationPath: String,
+    private val propertyFilesPaths: List<String>,
+    private val xmlConfigurationPaths: List<String>,
 ) {
 
     private val applicationUrl: URL
         get() = Path.of(applicationPath).toUri().toURL()
 
     fun analyze() {
+        val fakeFileManager = FakeFileManager(propertyFilesPaths + xmlConfigurationPaths)
+        fakeFileManager.createFakeFiles()
+
         val classLoader: ClassLoader = URLClassLoader(arrayOf(applicationUrl))
         val userConfigurationClass = classLoader.loadClass(configurationClassFqn)
 
         val configurationManager = ConfigurationManager(classLoader, userConfigurationClass)
-        val propertiesAnalyzer = PropertiesAnalyzer(propertyFilePath)
-        val xmlConfigurationAnalyzer = XmlConfigurationAnalyzer(xmlConfigurationPath)
-
-        xmlConfigurationAnalyzer.fillFakeApplicationXml()
+        val propertiesConfigurator = PropertiesConfigurator(propertyFilesPaths, configurationManager)
+        val xmlFilesConfigurator = XmlFilesConfigurator(xmlConfigurationPaths, configurationManager, fakeFileManager)
 
-        configurationManager.patchPropertySourceAnnotation()
-        configurationManager.patchImportResourceAnnotation()
+        propertiesConfigurator.configure()
+        xmlFilesConfigurator.configure()
 
         val app = SpringApplicationBuilder(SpringApplicationAnalyzer::class.java)
         app.sources(TestApplicationConfiguration::class.java, userConfigurationClass)
-        for (prop in propertiesAnalyzer.readProperties()) {
+        for (prop in propertiesConfigurator.readProperties()) {
             app.properties(prop)
         }
 
@@ -43,6 +47,8 @@ class SpringApplicationAnalyzer(
             app.run()
         } catch (e: ApplicationContextException) {
             println("Bean analysis finished successfully")
+        }finally {
+            fakeFileManager.deleteFakeFiles()
         }
     }
 }

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

@@ -2,15 +2,12 @@ package analyzers
 
 import org.w3c.dom.Document
 import org.w3c.dom.Element
-import utils.ResourceNames
 import javax.xml.parsers.DocumentBuilderFactory
 import javax.xml.transform.TransformerFactory
 import javax.xml.transform.dom.DOMSource
 import javax.xml.transform.stream.StreamResult
 
-class XmlConfigurationAnalyzer(private val userXmlFilePath: String) {
-    private val fakeXmlFilePath = this.javaClass.classLoader.getResource(ResourceNames.fakeApplicationXmlFileName)?.path
-        ?: error("The path must exist")
+class XmlConfigurationAnalyzer(private val userXmlFilePath: String, private val fakeXmlFilePath: String) {
 
     fun fillFakeApplicationXml() {
         val builder = DocumentBuilderFactory.newInstance().newDocumentBuilder()

utbot-spring-analyzer/src/main/kotlin/analyzers/XmlConfigurationAnalyzer.kt

@@ -0,0 +1,42 @@
+package application.configurators
+
+import utils.ConfigurationManager
+import utils.Paths
+import java.io.BufferedReader
+import java.io.FileReader
+import kotlin.io.path.Path
+
+class PropertiesConfigurator(
+    private val propertiesFilesPaths: List<String>,
+    private val configurationManager: ConfigurationManager
+) {
+
+    fun configure(){
+        configurationManager.clearPropertySourceAnnotation()
+
+        for(propertiesFilePath in propertiesFilesPaths) {
+            if(propertiesFilePath == Paths.EMPTY_PATH)continue
+
+            configurationManager.patchPropertySourceAnnotation(Path(propertiesFilePath).fileName)
+        }
+    }
+
+    fun readProperties(): ArrayList<String> {
+        val props = ArrayList<String>()
+
+        for(propertiesFilePath in propertiesFilesPaths) {
+            if(propertiesFilePath == Paths.EMPTY_PATH)continue
+
+            val reader = BufferedReader(FileReader(propertiesFilePath))
+            var line = reader.readLine()
+            while (line != null) {
+                props.add(line)
+                line = reader.readLine()
+            }
+
+            reader.close()
+        }
+
+        return props
+    }
+}

utbot-spring-analyzer/src/main/kotlin/configurators/PropertiesConfigurator.kt

@@ -0,0 +1,28 @@
+package application.configurators
+
+import analyzers.XmlConfigurationAnalyzer
+import application.utils.FakeFileManager
+import utils.ConfigurationManager
+import utils.Paths
+import kotlin.io.path.Path
+
+class XmlFilesConfigurator(
+    private val userXmlFilePaths: List<String>,
+    private val configurationManager: ConfigurationManager,
+    private val fakeFileManager: FakeFileManager
+) {
+
+    fun configure() {
+        configurationManager.clearImportResourceAnnotation()
+
+        for (userXmlFilePath in userXmlFilePaths) {
+            if(userXmlFilePath == Paths.EMPTY_PATH)continue
+
+            val xmlConfigurationAnalyzer =
+                XmlConfigurationAnalyzer(userXmlFilePath, fakeFileManager.getFakeFilePath(userXmlFilePath))
+
+            xmlConfigurationAnalyzer.fillFakeApplicationXml()
+            configurationManager.patchImportResourceAnnotation(Path(userXmlFilePath).fileName)
+        }
+    }
+}

utbot-spring-analyzer/src/main/kotlin/configurators/XmlFilesConfigurator.kt

@@ -3,21 +3,40 @@ package utils
 import org.springframework.context.annotation.ImportResource
 import org.springframework.context.annotation.PropertySource
 import java.lang.reflect.InvocationHandler
+import java.nio.file.Path
 import java.util.Arrays
 import kotlin.reflect.KClass
 
 class ConfigurationManager(private val classLoader: ClassLoader, private val userConfigurationClass: Class<*>) {
 
-    fun patchPropertySourceAnnotation() =
-        patchAnnotation(PropertySource::class, String.format("classpath:%s", ResourceNames.fakePropertiesFileName))
+    fun clearPropertySourceAnnotation(){
+        patchAnnotation(
+            PropertySource::class, null
+        )
+    }
+
+    fun clearImportResourceAnnotation(){
+        patchAnnotation(
+            ImportResource::class, null
+        )
+    }
 
-    fun patchImportResourceAnnotation() =
+    fun patchPropertySourceAnnotation(userPropertiesFileName: Path) =
+        patchAnnotation(
+            PropertySource::class, String.format(
+                "classpath:%s", "fake_$userPropertiesFileName"
+            )
+        )
+
+    fun patchImportResourceAnnotation(userXmlFilePath: Path) =
         patchAnnotation(
             ImportResource::class,
-            String.format("classpath:%s", ResourceNames.fakeApplicationXmlFileName)
+            String.format(
+                "classpath:%s", "fake_$userXmlFilePath"
+            )
         )
 
-    private fun patchAnnotation(annotationClass: KClass<*>, newValue: String) {
+    private fun patchAnnotation(annotationClass: KClass<*>, newValue: String?) {
         val proxyClass = classLoader.loadClass("java.lang.reflect.Proxy")
         val hField = proxyClass.getDeclaredField("h")
         hField.isAccessible = true
@@ -37,7 +56,18 @@ class ConfigurationManager(private val classLoader: ClassLoader, private val use
             memberValuesField.isAccessible = true
 
             val memberValues = memberValuesField[annotationInvocationHandler] as MutableMap<String, Any>
-            memberValues["value"] = newValue
+            addNewValue(memberValues, newValue)
+        }
+    }
+
+    private fun addNewValue(memberValues: MutableMap<String, Any>, newValue: String?){
+        if(newValue == null){
+            memberValues["value"] = Array(0){""}
+        }
+        else {
+            val list: MutableList<String> = (memberValues["value"] as Array<String>).toMutableList()
+            list.add(newValue)
+            memberValues["value"] = list.toTypedArray()
         }
     }
 }

utbot-spring-analyzer/src/main/kotlin/utils/ConfigurationManager.kt

@@ -0,0 +1,31 @@
+package application.utils
+
+import utils.Paths
+import java.io.File
+import kotlin.io.path.Path
+
+class FakeFileManager(private val fakeFilesList: List<String>) {
+
+    private val buildResourcesPath =
+        Path(this.javaClass.classLoader.getResource(Paths.GAG_FILE)!!.path).parent.toString()
+
+    fun createFakeFiles() {
+        for (fileName in fakeFilesList) {
+            if(fileName == Paths.EMPTY_FILENAME)continue
+            val fakeXmlFileAbsolutePath = getFakeFilePath(fileName)
+            File(fakeXmlFileAbsolutePath).createNewFile()
+        }
+    }
+
+    fun deleteFakeFiles() {
+        for (fileName in fakeFilesList) {
+            if(fileName == Paths.EMPTY_FILENAME)continue
+            val fakeXmlFileAbsolutePath = getFakeFilePath(fileName)
+            File(fakeXmlFileAbsolutePath).delete()
+        }
+    }
+
+    fun getFakeFilePath(fileName: String): String {
+        return Path(buildResourcesPath, "fake_${Path(fileName).fileName}").toString()
+    }
+}

utbot-spring-analyzer/src/main/kotlin/utils/FakeFileManager.kt

@@ -0,0 +1,7 @@
+package utils
+
+object Paths {
+    const val GAG_FILE = "gag_file.txt"
+    const val EMPTY_PATH = ""
+    const val EMPTY_FILENAME = ""
+}