Introduce utbot-spring-commons-api module #2239 (#2251)

EgorkaKulikov · web-flow · commit 450f1c652dc2 · 2023-06-07T10:24:12.000Z
Separate utbot-spring-commons-api logic in a separate module
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -72,3 +72,4 @@ if (goIde.split(",").contains(ideType)) {
 
 include("utbot-spring-analyzer")
 include("utbot-spring-commons")
+include("utbot-spring-commons-api")
diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/generator/SpringCodeGenerator.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/codegen/generator/SpringCodeGenerator.kt
@@ -61,7 +61,8 @@ class SpringCodeGenerator(
         logger.info { "Code generation phase started at ${now()}" }
         val astConstructor = when (springTestsType) {
             SpringTestsType.UNIT_TESTS -> CgSpringUnitTestClassConstructor(context)
-            SpringTestsType.INTEGRATION_TESTS -> CgSpringIntegrationTestClassConstructor(context)
+            // TODO replace with CgSpringIntegrationTestClassConstructor
+            SpringTestsType.INTEGRATION_TESTS -> CgSpringUnitTestClassConstructor(context)
         }
         val testClassFile = astConstructor.construct(testClassModel)
         logger.info { "Code generation phase finished at ${now()}" }
diff --git a/utbot-instrumentation/build.gradle.kts b/utbot-instrumentation/build.gradle.kts
@@ -42,7 +42,8 @@ val fetchSpringCommonsJar: Configuration by configurations.creating {
 dependencies {
     implementation(project(":utbot-framework-api"))
     implementation(project(":utbot-rd"))
-    implementation(project(":utbot-spring-commons"))
+    implementation(project(":utbot-spring-commons-api"))
+
 
     implementation("org.ow2.asm:asm:$asmVersion")
     implementation("org.ow2.asm:asm-commons:$asmVersion")
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/execution/SpringUtExecutionInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/execution/SpringUtExecutionInstrumentation.kt
@@ -14,9 +14,11 @@ import org.utbot.instrumentation.instrumentation.Instrumentation
 import org.utbot.instrumentation.instrumentation.execution.mock.SpringInstrumentationContext
 import org.utbot.instrumentation.instrumentation.execution.phases.ModelConstructionPhase
 import org.utbot.instrumentation.process.HandlerClassesLoader
+import org.utbot.spring.api.context.ContextWrapper
+import org.utbot.spring.api.instantiator.InstantiationSettings
+import org.utbot.spring.api.instantiator.ApplicationInstantiatorFacade
 import org.utbot.spring.api.repositoryWrapper.RepositoryInteraction
 import java.security.ProtectionDomain
-import kotlin.random.Random
 
 /**
  * UtExecutionInstrumentation wrapper that is aware of Spring config and initialises Spring context
@@ -25,7 +27,7 @@ class SpringUtExecutionInstrumentation(
     private val instrumentation: UtExecutionInstrumentation,
     private val springConfig: String
 ) : Instrumentation<UtConcreteExecutionResult> by instrumentation {
-    private lateinit var springContext: Any
+    private lateinit var springContext: ContextWrapper
 
     companion object {
         private val logger = getLogger<SpringUtExecutionInstrumentation>()
@@ -52,22 +54,23 @@ class SpringUtExecutionInstrumentation(
         val classLoader = utContext.classLoader
         Thread.currentThread().contextClassLoader = classLoader
 
-        val primarySources = arrayOf(
-            classLoader.loadClass(springConfig),
-            classLoader.loadClass("org.utbot.spring.repositoryWrapper.RepositoryWrapperConfiguration")
+        val instantiationSettings = InstantiationSettings(
+            configurationClasses = arrayOf(
+                classLoader.loadClass(springConfig),
+                classLoader.loadClass("org.utbot.spring.repositoryWrapper.RepositoryWrapperConfiguration")
+            ),
+            profileExpression = null,
         )
 
-        // Setting server.port value to 0 means given Spring to select any appropriate port itself.
-        // See https://stackoverflow.com/questions/21083170/how-to-configure-port-for-a-spring-boot-application
-        val args = arrayOf("--server.port=0")
-
-        // TODO if we don't have SpringBoot just create ApplicationContext here, reuse code from utbot-spring-analyzer
-        // TODO recreate context/app every time whenever we change method under test
-        val springAppClass =
-            classLoader.loadClass("org.springframework.boot.SpringApplication")
-        springContext = springAppClass
-            .getMethod("run", primarySources::class.java, args::class.java)
-            .invoke(null, primarySources, args)
+        val springFacadeInstance =  classLoader
+            .loadClass("org.utbot.spring.instantiator.SpringApplicationInstantiatorFacade")
+            .getConstructor()
+            .newInstance()
+        springFacadeInstance as ApplicationInstantiatorFacade
+
+        // TODO: recreate context/app every time whenever we change method under test
+        springContext = springFacadeInstance.instantiate(instantiationSettings)
+            ?: error("Failed to initialize Spring context")
     }
 
     override fun invoke(
@@ -79,20 +82,11 @@ class SpringUtExecutionInstrumentation(
         RepositoryInteraction.recordedInteractions.clear()
         // TODO properly detect which beans need to be reset, right now "orderRepository" and "orderService" are hardcoded
         val beanNamesToReset = listOf("orderRepository", "orderService")
+
         beanNamesToReset.forEach { beanNameToReset ->
-            val beanDefToReset = springContext::class.java
-                .getMethod("getBeanDefinition", String::class.java)
-                .invoke(springContext, beanNameToReset)
-            springContext::class.java
-                .getMethod("removeBeanDefinition", String::class.java)
-                .invoke(springContext, beanNameToReset)
-            springContext::class.java
-                .getMethod(
-                    "registerBeanDefinition",
-                    String::class.java,
-                    utContext.classLoader.loadClass("org.springframework.beans.factory.config.BeanDefinition")
-                )
-                .invoke(springContext, beanNameToReset, beanDefToReset)
+            val beanDefToReset = springContext.getBeanDefinition(beanNameToReset)
+            springContext.removeBeanDefinition(beanNameToReset)
+            springContext.registerBeanDefinition(beanNameToReset, beanDefToReset)
         }
 
         val jdbcTemplate = getBean("jdbcTemplate")
@@ -124,10 +118,7 @@ class SpringUtExecutionInstrumentation(
         }
     }
 
-    fun getBean(beanName: String): Any =
-        springContext::class.java
-            .getMethod("getBean", String::class.java)
-            .invoke(springContext, beanName)
+    fun getBean(beanName: String): Any = springContext.getBean(beanName)
 
     fun saveToRepository(repository: Any, entity: Any) {
         // ignore repository interactions done during repository fill up
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessMain.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessMain.kt
@@ -46,9 +46,7 @@ internal object HandlerClassesLoader : URLClassLoader(emptyArray()) {
      *  - we want org.utbot.spring to be loaded by [HandlerClassesLoader] so it can use Spring directly
      */
     override fun loadClass(name: String, resolve: Boolean): Class<*> {
-        // TODO extract `utbot-spring-commons-api` into a separate module to not mess around with class loader
-        if (name.startsWith("org.slf4j") ||
-            (name.startsWith("org.utbot.spring") && !name.startsWith("org.utbot.spring.api"))) {
+        if (name.startsWith("org.slf4j")) {
             return (findLoadedClass(name) ?: findClass(name)).apply {
                 if (resolve) resolveClass(this)
             }
diff --git a/utbot-spring-analyzer/build.gradle.kts b/utbot-spring-analyzer/build.gradle.kts
@@ -31,7 +31,10 @@ dependencies {
     implementation(project(":utbot-rd")) { excludeSlf4jApi() }
     implementation(project(":utbot-core")) { excludeSlf4jApi() }
     implementation(project(":utbot-framework-api")) { excludeSlf4jApi() }
-    implementation(project(":utbot-spring-commons")) { excludeSlf4jApi() }
+
+    runtimeOnly(project(":utbot-spring-commons")) { excludeSlf4jApi() }
+    implementation(project(":utbot-spring-commons-api")) { excludeSlf4jApi() }
+
     implementation("com.jetbrains.rd:rd-framework:$rdVersion") { excludeSlf4jApi() }
     implementation("com.jetbrains.rd:rd-core:$rdVersion") { excludeSlf4jApi() }
     implementation("commons-logging:commons-logging:$commonsLoggingVersion") { excludeSlf4jApi() }
diff --git a/utbot-spring-analyzer/src/main/kotlin/org/utbot/spring/analyzer/SpringApplicationAnalyzer.kt b/utbot-spring-analyzer/src/main/kotlin/org/utbot/spring/analyzer/SpringApplicationAnalyzer.kt
@@ -1,8 +1,9 @@
 package org.utbot.spring.analyzer
 
-import org.utbot.spring.context.InstantiationContext
-import org.utbot.spring.instantiator.SpringApplicationInstantiatorFacade
+import org.utbot.framework.plugin.api.util.utContext
+import org.utbot.spring.api.instantiator.InstantiationSettings
 import org.utbot.spring.api.ApplicationData
+import org.utbot.spring.api.instantiator.ApplicationInstantiatorFacade
 import org.utbot.spring.exception.UtBotSpringShutdownException
 import org.utbot.spring.generated.BeanDefinitionData
 import org.utbot.spring.utils.SourceFinder
@@ -11,13 +12,19 @@ class SpringApplicationAnalyzer {
 
     fun getBeanDefinitions(applicationData: ApplicationData): Array<BeanDefinitionData> {
         val configurationClasses = SourceFinder(applicationData).findSources()
-        val instantiationContext = InstantiationContext(
+        val instantiationSettings = InstantiationSettings(
             configurationClasses,
             applicationData.profileExpression,
         )
 
+        val springFacadeInstance = this::class.java.classLoader
+            .loadClass("org.utbot.spring.instantiator.SpringApplicationInstantiatorFacade")
+            .getConstructor()
+            .newInstance()
+        springFacadeInstance as ApplicationInstantiatorFacade
+
         return UtBotSpringShutdownException
-            .catch { SpringApplicationInstantiatorFacade(instantiationContext).instantiate() }
+            .catch { springFacadeInstance.instantiate(instantiationSettings) }
             .beanDefinitions
             .toTypedArray()
     }
diff --git a/utbot-spring-commons-api/build.gradle.kts b/utbot-spring-commons-api/build.gradle.kts
@@ -0,0 +1,8 @@
+plugins {
+    id("java")
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
diff --git a/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/context/ContextWrapper.kt b/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/context/ContextWrapper.kt
@@ -0,0 +1,13 @@
+package org.utbot.spring.api.context
+
+interface ContextWrapper {
+    val context: Any?
+
+    fun getBeanDefinition(beanName: String): Any
+
+    fun removeBeanDefinition(beanName: String)
+
+    fun registerBeanDefinition(beanName: String, beanDefinition: Any)
+
+    fun getBean(beanName: String): Any
+}
diff --git a/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/instantiator/ApplicationInstantiatorFacade.kt b/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/instantiator/ApplicationInstantiatorFacade.kt
@@ -0,0 +1,8 @@
+package org.utbot.spring.api.instantiator
+
+import org.utbot.spring.api.context.ContextWrapper
+
+
+interface ApplicationInstantiatorFacade {
+    fun instantiate(instantiationSettings: InstantiationSettings): ContextWrapper?
+}
diff --git a/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/instantiator/InstantiationSettings.kt b/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/instantiator/InstantiationSettings.kt
@@ -1,6 +1,6 @@
-package org.utbot.spring.context
+package org.utbot.spring.api.instantiator
 
-class InstantiationContext(
+class InstantiationSettings(
     val configurationClasses: Array<Class<*>>,
     val profileExpression: String?,
 )
diff --git a/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/repositoryWrapper/RepositoryInteraction.kt b/utbot-spring-commons-api/src/main/kotlin/org/utbot/spring/api/repositoryWrapper/RepositoryInteraction.kt
diff --git a/utbot-spring-commons/build.gradle.kts b/utbot-spring-commons/build.gradle.kts
@@ -14,9 +14,10 @@ java {
 }
 
 dependencies {
+    implementation(project(":utbot-spring-commons-api"))
+
     // https://mvnrepository.com/artifact/org.springframework.boot/spring-boot
     compileOnly("org.springframework.boot:spring-boot:$springBootVersion")
-
     implementation("com.jetbrains.rd:rd-core:$rdVersion") { exclude(group = "org.slf4j", module = "slf4j-api") }
 }
 
diff --git a/utbot-spring-commons/src/main/kotlin/org/utbot/spring/context/SpringContextWrapper.kt b/utbot-spring-commons/src/main/kotlin/org/utbot/spring/context/SpringContextWrapper.kt
@@ -0,0 +1,23 @@
+package org.utbot.spring.context
+
+import org.springframework.beans.factory.config.BeanDefinition
+import org.springframework.beans.factory.support.BeanDefinitionRegistry
+import org.springframework.context.ConfigurableApplicationContext
+import org.utbot.spring.api.context.ContextWrapper
+
+class SpringContextWrapper(override val context: ConfigurableApplicationContext) : ContextWrapper {
+    override fun getBeanDefinition(beanName: String): BeanDefinition = context.beanFactory.getBeanDefinition(beanName)
+
+    override fun removeBeanDefinition(beanName: String) {
+        val beanDefinitionRegistry = context.beanFactory as BeanDefinitionRegistry
+        beanDefinitionRegistry.removeBeanDefinition(beanName)
+    }
+
+    override fun registerBeanDefinition(beanName: String, beanDefinition: Any) {
+        val beanDefinitionRegistry = context.beanFactory as BeanDefinitionRegistry
+        beanDefinition as BeanDefinition
+        beanDefinitionRegistry.registerBeanDefinition(beanName, beanDefinition)
+    }
+
+    override fun getBean(beanName: String): Any = context.getBean(beanName)
+}
diff --git a/utbot-spring-commons/src/main/kotlin/org/utbot/spring/environment/EnvironmentFactory.kt b/utbot-spring-commons/src/main/kotlin/org/utbot/spring/environment/EnvironmentFactory.kt
@@ -4,27 +4,27 @@ import com.jetbrains.rd.util.getLogger
 import com.jetbrains.rd.util.info
 import org.springframework.core.env.ConfigurableEnvironment
 import org.springframework.core.env.StandardEnvironment
-import org.utbot.spring.context.InstantiationContext
+import org.utbot.spring.api.instantiator.InstantiationSettings
 
 
 private val logger = getLogger<EnvironmentFactory>()
 
 class EnvironmentFactory(
-    private val instantiationContext: InstantiationContext
+    private val instantiationSettings: InstantiationSettings
 ) {
     companion object {
         const val DEFAULT_PROFILE_NAME = "default"
     }
 
     fun createEnvironment(): ConfigurableEnvironment {
-        val profilesToActivate = parseProfileExpression(instantiationContext.profileExpression)
+        val profilesToActivate = parseProfileExpression(instantiationSettings.profileExpression)
 
         val environment = StandardEnvironment()
 
         try {
             environment.setActiveProfiles(*profilesToActivate)
         } catch (e: Exception) {
-            logger.info { "Setting ${instantiationContext.profileExpression} as active profiles failed with exception $e" }
+            logger.info { "Setting ${instantiationSettings.profileExpression} as active profiles failed with exception $e" }
         }
 
         return environment
diff --git a/utbot-spring-commons/src/main/kotlin/org/utbot/spring/instantiator/SpringApplicationInstantiatorFacade.kt b/utbot-spring-commons/src/main/kotlin/org/utbot/spring/instantiator/SpringApplicationInstantiatorFacade.kt
@@ -1,31 +1,33 @@
 package org.utbot.spring.instantiator
 
-import org.springframework.context.ConfigurableApplicationContext
-import org.utbot.spring.context.InstantiationContext
+import org.utbot.spring.api.instantiator.InstantiationSettings
 import org.utbot.spring.environment.EnvironmentFactory
 
 import com.jetbrains.rd.util.error
 import com.jetbrains.rd.util.getLogger
 import com.jetbrains.rd.util.info
 import org.springframework.boot.SpringBootVersion
 import org.springframework.core.SpringVersion
+import org.utbot.spring.api.instantiator.ApplicationInstantiatorFacade
+import org.utbot.spring.context.SpringContextWrapper
 
 private val logger = getLogger<SpringApplicationInstantiatorFacade>()
 
-class SpringApplicationInstantiatorFacade(private val instantiationContext: InstantiationContext) {
+class SpringApplicationInstantiatorFacade : ApplicationInstantiatorFacade {
 
-    fun instantiate(): ConfigurableApplicationContext? {
+    override fun instantiate(instantiationSettings: InstantiationSettings): SpringContextWrapper? {
         logger.info { "Current Java version is: " + System.getProperty("java.version") }
         logger.info { "Current Spring version is: " + runCatching { SpringVersion.getVersion() }.getOrNull() }
         logger.info { "Current Spring Boot version is: " + runCatching { SpringBootVersion.getVersion() }.getOrNull() }
 
-        val environment = EnvironmentFactory(instantiationContext).createEnvironment()
+        val environment = EnvironmentFactory(instantiationSettings).createEnvironment()
 
         for (instantiator in listOf(SpringBootApplicationInstantiator(), PureSpringApplicationInstantiator())) {
             if (instantiator.canInstantiate()) {
                 logger.info { "Instantiating with $instantiator" }
                 try {
-                    return instantiator.instantiate(instantiationContext.configurationClasses, environment)
+                    val context = instantiator.instantiate(instantiationSettings.configurationClasses, environment)
+                    return SpringContextWrapper(context)
                 } catch (e: Throwable) {
                     logger.error("Instantiating with $instantiator failed", e)
                 }
diff --git a/utbot-spring-commons/src/main/kotlin/org/utbot/spring/instantiator/SpringBootApplicationInstantiator.kt b/utbot-spring-commons/src/main/kotlin/org/utbot/spring/instantiator/SpringBootApplicationInstantiator.kt
@@ -18,6 +18,9 @@ class SpringBootApplicationInstantiator : SpringApplicationInstantiator {
             .environment(environment)
             .build()
 
-        return application.run()
+        // This settings means that Spring will use any free port itself
+        val args = arrayOf("--server.port=0")
+
+        return application.run(*args)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -72,3 +72,4 @@ if (goIde.split(",").contains(ideType)) {`
`72`	`72`
`73`	`73`	`include("utbot-spring-analyzer")`
`74`	`74`	`include("utbot-spring-commons")`
	`75`	`+include("utbot-spring-commons-api")`