cid-3525: Change the full scan to async method

src/main/kotlin/net/leanix/githubagent/listener/ApplicationReadyListener.kt

@@ -1,13 +1,6 @@
 package net.leanix.githubagent.listener
 
-import net.leanix.githubagent.handler.BrokerStompSessionHandler
-import net.leanix.githubagent.services.CachingService
-import net.leanix.githubagent.services.GitHubAuthenticationService
-import net.leanix.githubagent.services.GitHubEnterpriseService
-import net.leanix.githubagent.services.GitHubScanningService
-import net.leanix.githubagent.services.SyncLogService
-import net.leanix.githubagent.services.WebSocketService
-import net.leanix.githubagent.shared.APP_NAME_TOPIC
+import net.leanix.githubagent.services.GitHubStartService
 import org.slf4j.LoggerFactory
 import org.springframework.boot.context.event.ApplicationReadyEvent
 import org.springframework.context.ApplicationListener
@@ -17,40 +10,13 @@ import org.springframework.stereotype.Component
 @Component
 @Profile("!test")
 class ApplicationReadyListener(
-    private val githubAuthenticationService: GitHubAuthenticationService,
-    private val webSocketService: WebSocketService,
-    private val gitHubScanningService: GitHubScanningService,
-    private val gitHubEnterpriseService: GitHubEnterpriseService,
-    private val cachingService: CachingService,
-    private val brokerStompSessionHandler: BrokerStompSessionHandler,
-    private val syncLogService: SyncLogService
+    private val gitHubStartService: GitHubStartService,
 ) : ApplicationListener<ApplicationReadyEvent> {
 
     private val logger = LoggerFactory.getLogger(this::class.java)
 
     override fun onApplicationEvent(event: ApplicationReadyEvent) {
-        webSocketService.initSession()
-        if (!brokerStompSessionHandler.isConnected()) {
-            logger.error("Stopping the application as the WebSocket connection could not be established.")
-            return
-        }
-        kotlin.runCatching {
-            syncLogService.sendFullScanStart(null)
-            scanResources()
-        }.onSuccess {
-            syncLogService.sendFullScanSuccess()
-        }.onFailure {
-            syncLogService.sendFullScanFailure(it.message)
-        }
-    }
-
-    private fun scanResources() {
-        githubAuthenticationService.generateAndCacheJwtToken()
-        val jwt = cachingService.get("jwtToken") as String
-        webSocketService.sendMessage(
-            APP_NAME_TOPIC,
-            gitHubEnterpriseService.getGitHubApp(jwt).slug
-        )
-        gitHubScanningService.scanGitHubResources()
+        logger.info("Agent started")
+        gitHubStartService.startAgent()
     }
 }

src/main/kotlin/net/leanix/githubagent/services/GitHubStartService.kt

@@ -0,0 +1,48 @@
+package net.leanix.githubagent.services
+
+import net.leanix.githubagent.handler.BrokerStompSessionHandler
+import net.leanix.githubagent.shared.APP_NAME_TOPIC
+import org.slf4j.LoggerFactory
+import org.springframework.scheduling.annotation.Async
+import org.springframework.stereotype.Service
+
+@Service
+class GitHubStartService(
+    private val githubAuthenticationService: GitHubAuthenticationService,
+    private val webSocketService: WebSocketService,
+    private val gitHubScanningService: GitHubScanningService,
+    private val gitHubEnterpriseService: GitHubEnterpriseService,
+    private val cachingService: CachingService,
+    private val brokerStompSessionHandler: BrokerStompSessionHandler,
+    private val syncLogService: SyncLogService
+) {
+
+    private val logger = LoggerFactory.getLogger(this::class.java)
+
+    @Async
+    fun startAgent() {
+        webSocketService.initSession()
+        if (!brokerStompSessionHandler.isConnected()) {
+            logger.error("Stopping the application as the WebSocket connection could not be established.")
+            return
+        }
+        kotlin.runCatching {
+            syncLogService.sendFullScanStart(null)
+            scanResources()
+        }.onSuccess {
+            syncLogService.sendFullScanSuccess()
+        }.onFailure {
+            syncLogService.sendFullScanFailure(it.message)
+        }
+    }
+
+    private fun scanResources() {
+        githubAuthenticationService.generateAndCacheJwtToken()
+        val jwt = cachingService.get("jwtToken") as String
+        webSocketService.sendMessage(
+            APP_NAME_TOPIC,
+            gitHubEnterpriseService.getGitHubApp(jwt).slug
+        )
+        gitHubScanningService.scanGitHubResources()
+    }
+}

src/test/kotlin/net/leanix/githubagent/listener/ApplicationReadyListenerTest.kt

@@ -3,73 +3,30 @@ package net.leanix.githubagent.listener
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
-import net.leanix.githubagent.dto.GitHubAppResponse
-import net.leanix.githubagent.handler.BrokerStompSessionHandler
-import net.leanix.githubagent.services.CachingService
-import net.leanix.githubagent.services.GitHubAuthenticationService
-import net.leanix.githubagent.services.GitHubEnterpriseService
-import net.leanix.githubagent.services.GitHubScanningService
-import net.leanix.githubagent.services.SyncLogService
-import net.leanix.githubagent.services.WebSocketService
-import net.leanix.githubagent.shared.APP_NAME_TOPIC
+import net.leanix.githubagent.services.GitHubStartService
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 class ApplicationReadyListenerTest {
 
-    private lateinit var githubAuthenticationService: GitHubAuthenticationService
-    private lateinit var webSocketService: WebSocketService
-    private lateinit var gitHubScanningService: GitHubScanningService
-    private lateinit var gitHubEnterpriseService: GitHubEnterpriseService
-    private lateinit var cachingService: CachingService
+    private lateinit var gitHubStartService: GitHubStartService
     private lateinit var applicationListener: ApplicationReadyListener
-    private lateinit var brokerStompSessionHandler: BrokerStompSessionHandler
-    private lateinit var syncLogService: SyncLogService
 
     @BeforeEach
     fun setUp() {
-        githubAuthenticationService = mockk()
-        webSocketService = mockk()
-        gitHubScanningService = mockk()
-        gitHubEnterpriseService = mockk()
-        cachingService = mockk()
-        brokerStompSessionHandler = mockk()
-        syncLogService = mockk()
+        gitHubStartService = mockk()
 
         applicationListener = ApplicationReadyListener(
-            githubAuthenticationService,
-            webSocketService,
-            gitHubScanningService,
-            gitHubEnterpriseService,
-            cachingService,
-            brokerStompSessionHandler,
-            syncLogService
+            gitHubStartService
         )
 
-        every { webSocketService.initSession() } returns Unit
-        every { webSocketService.sendMessage(any(), any()) } returns Unit
-        every { githubAuthenticationService.generateAndCacheJwtToken() } returns Unit
-        every { cachingService.get("jwtToken") } returns "jwt"
-        every { cachingService.set("runId", any(), any()) } returns Unit
-        every { cachingService.remove("runId") } returns Unit
-        every { gitHubScanningService.scanGitHubResources() } returns Unit
-        every { brokerStompSessionHandler.isConnected() } returns true
-        every { syncLogService.sendSyncLog(any(), any(), any(), any()) } returns Unit
-        every { syncLogService.sendFullScanStart(any()) } returns Unit
-        every { syncLogService.sendFullScanSuccess() } returns Unit
+        every { gitHubStartService.startAgent() } returns Unit
     }
 
     @Test
-    fun `should start syncLog and send GitHub App name`() {
-        val gitHubAppName = "appName"
-        every { gitHubEnterpriseService.getGitHubApp("jwt") } returns
-            GitHubAppResponse(
-                gitHubAppName, mapOf(), listOf()
-            )
-
+    fun `should start the agent process`() {
         applicationListener.onApplicationEvent(mockk())
 
-        verify { webSocketService.sendMessage(APP_NAME_TOPIC, gitHubAppName) }
-        verify { syncLogService.sendFullScanStart(any()) }
+        verify { gitHubStartService.startAgent() }
     }
 }

src/test/kotlin/net/leanix/githubagent/services/GitHubStartServiceTest.kt

@@ -0,0 +1,69 @@
+package net.leanix.githubagent.services
+
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import net.leanix.githubagent.dto.GitHubAppResponse
+import net.leanix.githubagent.handler.BrokerStompSessionHandler
+import net.leanix.githubagent.shared.APP_NAME_TOPIC
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+class GitHubStartServiceTest {
+
+    private lateinit var githubAuthenticationService: GitHubAuthenticationService
+    private lateinit var webSocketService: WebSocketService
+    private lateinit var gitHubScanningService: GitHubScanningService
+    private lateinit var gitHubEnterpriseService: GitHubEnterpriseService
+    private lateinit var cachingService: CachingService
+    private lateinit var gitHubStartService: GitHubStartService
+    private lateinit var brokerStompSessionHandler: BrokerStompSessionHandler
+    private lateinit var syncLogService: SyncLogService
+
+    @BeforeEach
+    fun setUp() {
+        githubAuthenticationService = mockk()
+        webSocketService = mockk()
+        gitHubScanningService = mockk()
+        gitHubEnterpriseService = mockk()
+        cachingService = mockk()
+        brokerStompSessionHandler = mockk()
+        syncLogService = mockk()
+
+        gitHubStartService = GitHubStartService(
+            githubAuthenticationService,
+            webSocketService,
+            gitHubScanningService,
+            gitHubEnterpriseService,
+            cachingService,
+            brokerStompSessionHandler,
+            syncLogService
+        )
+
+        every { webSocketService.initSession() } returns Unit
+        every { webSocketService.sendMessage(any(), any()) } returns Unit
+        every { githubAuthenticationService.generateAndCacheJwtToken() } returns Unit
+        every { cachingService.get("jwtToken") } returns "jwt"
+        every { cachingService.set("runId", any(), any()) } returns Unit
+        every { cachingService.remove("runId") } returns Unit
+        every { gitHubScanningService.scanGitHubResources() } returns Unit
+        every { brokerStompSessionHandler.isConnected() } returns true
+        every { syncLogService.sendSyncLog(any(), any(), any(), any()) } returns Unit
+        every { syncLogService.sendFullScanStart(any()) } returns Unit
+        every { syncLogService.sendFullScanSuccess() } returns Unit
+    }
+
+    @Test
+    fun `should start syncLog and send GitHub App name`() {
+        val gitHubAppName = "appName"
+        every { gitHubEnterpriseService.getGitHubApp("jwt") } returns
+            GitHubAppResponse(
+                gitHubAppName, mapOf(), listOf()
+            )
+
+        gitHubStartService.startAgent()
+
+        verify { webSocketService.sendMessage(APP_NAME_TOPIC, gitHubAppName) }
+        verify { syncLogService.sendFullScanStart(any()) }
+    }
+}