Improve fuzzer & test exports/imports in JavaScript module

utbot-cli-js/src/main/kotlin/org/utbot/cli/js/JsGenerateTestsCommand.kt

@@ -6,7 +6,7 @@ import com.github.ajalt.clikt.parameters.options.*
 import com.github.ajalt.clikt.parameters.types.choice
 import mu.KotlinLogging
 import org.utbot.cli.js.JsUtils.makeAbsolutePath
-import service.CoverageMode
+import service.coverage.CoverageMode
 import settings.JsDynamicSettings
 import settings.JsExportsSettings.endComment
 import settings.JsExportsSettings.startComment
@@ -82,6 +82,7 @@ class JsGenerateTestsCommand :
             val sourceFileAbsolutePath = makeAbsolutePath(sourceCodeFile)
             logger.info { "Generating tests for [$sourceFileAbsolutePath] - started" }
             val fileText = File(sourceCodeFile).readText()
+            currentFileText = fileText
             val outputAbsolutePath = output?.let { makeAbsolutePath(it) }
             val testGenerator = JsTestGenerator(
                 fileText = fileText,
@@ -118,36 +119,31 @@ class JsGenerateTestsCommand :
         }
     }
 
-    private fun manageExports(exports: List<String>) {
-        val exportSection = exports.joinToString("\n") { "exports.$it = $it" }
+    // Needed for continuous exports managing
+    private var currentFileText = ""
+
+    private fun manageExports(swappedText: (String?, String) -> String) {
         val file = File(sourceCodeFile)
-        val fileText = file.readText()
         when {
-            fileText.contains(exportSection) -> {}
 
-            fileText.contains(startComment) && !fileText.contains(exportSection) -> {
+            currentFileText.contains(startComment) -> {
                 val regex = Regex("$startComment((\\r\\n|\\n|\\r|.)*)$endComment")
-                regex.find(fileText)?.groups?.get(1)?.value?.let { existingSection ->
-                    val exportRegex = Regex("exports[.](.*) =")
-                    val existingExports = existingSection.split("\n").filter { it.contains(exportRegex) }
-                    val existingExportsSet = existingExports.map { rawLine ->
-                        exportRegex.find(rawLine)?.groups?.get(1)?.value ?: throw IllegalStateException()
-                    }.toSet()
-                    val resultSet = existingExportsSet + exports.toSet()
-                    val resSection = resultSet.joinToString("\n") { "exports.$it = $it" }
-                    val swappedText = fileText.replace(existingSection, "\n$resSection\n")
-                    file.writeText(swappedText)
+                regex.find(currentFileText)?.groups?.get(1)?.value?.let { existingSection ->
+                    val newText = swappedText(existingSection, currentFileText)
+                    file.writeText(newText)
+                    currentFileText = newText
                 }
             }
 
             else -> {
                 val line = buildString {
-                    append("\n$startComment\n")
-                    append(exportSection)
-                    append("\n$endComment")
+                    append("\n$startComment")
+                    append(swappedText(null, currentFileText))
+                    append(endComment)
                 }
                 file.appendText(line)
+                currentFileText = file.readText()
             }
         }
     }
-}
+}

utbot-intellij-js/src/main/kotlin/org/utbot/intellij/plugin/language/js/CoverageModeButtons.kt

@@ -1,8 +1,8 @@
 package org.utbot.intellij.plugin.language.js
 
-import service.CoverageMode
 import javax.swing.ButtonGroup
 import javax.swing.JRadioButton
+import service.coverage.CoverageMode
 
 object CoverageModeButtons {
 

utbot-intellij-js/src/main/kotlin/org/utbot/intellij/plugin/language/js/JsDialogProcessor.kt

@@ -144,6 +144,13 @@ object JsDialogProcessor {
 
     private fun createDialog(jsTestsModel: JsTestsModel?) = jsTestsModel?.let { JsDialogWindow(it) }
 
+    private fun unblockDocument(project: Project, document: Document) {
+        PsiDocumentManager.getInstance(project).apply {
+            commitDocument(document)
+            doPostponedOperationsAndUnblockDocument(document)
+        }
+    }
+
     private fun createTests(model: JsTestsModel, containingFilePath: String, editor: Editor?, contents: String) {
         val normalizedContainingFilePath = containingFilePath.replace(File.separator, "/")
         (object : Task.Backgroundable(model.project, "Generate tests") {
@@ -154,7 +161,9 @@ object JsDialogProcessor {
                     model.testSourceRoot!!
                 )
                 val testFileName = normalizedContainingFilePath.substringAfterLast("/").replace(Regex(".js"), "Test.js")
-                val testGenerator = JsTestGenerator(fileText = contents,
+                currentFileText = model.file.getContent()
+                val testGenerator = JsTestGenerator(
+                    fileText = contents,
                     sourceFilePath = normalizedContainingFilePath,
                     projectPath = model.project.basePath?.replace(File.separator, "/")
                         ?: throw IllegalStateException("Can't access project path."),
@@ -208,44 +217,6 @@ object JsDialogProcessor {
 
     private fun JSFile.getContent(): String = this.viewProvider.contents.toString()
 
-    private fun manageExports(
-        editor: Editor?, project: Project, model: JsTestsModel, exports: List<String>
-    ) {
-        AppExecutorUtil.getAppExecutorService().submit {
-            invokeLater {
-                val exportSection = exports.joinToString("\n") { "exports.$it = $it" }
-                val fileText = model.file.getContent()
-                when {
-                    fileText.contains(exportSection) -> {}
-
-                    fileText.contains(startComment) && !fileText.contains(exportSection) -> {
-                        val regex = Regex("$startComment((\\r\\n|\\n|\\r|.)*)$endComment")
-                        regex.find(fileText)?.groups?.get(1)?.value?.let { existingSection ->
-                            val exportRegex = Regex("exports[.](.*) =")
-                            val existingExports = existingSection.split("\n").filter { it.contains(exportRegex) }
-                            val existingExportsSet = existingExports.map { rawLine ->
-                                exportRegex.find(rawLine)?.groups?.get(1)?.value ?: throw IllegalStateException()
-                            }.toSet()
-                            val resultSet = existingExportsSet + exports.toSet()
-                            val resSection = resultSet.joinToString("\n") { "exports.$it = $it" }
-                            val swappedText = fileText.replace(existingSection, "\n$resSection\n")
-                            project.setNewText(editor, model.containingFilePath, swappedText)
-                        }
-                    }
-
-                    else -> {
-                        val line = buildString {
-                            append("\n$startComment\n")
-                            append(exportSection)
-                            append("\n$endComment")
-                        }
-                        project.setNewText(editor, model.containingFilePath, fileText + line)
-                    }
-                }
-            }
-        }
-    }
-
     private fun Project.setNewText(editor: Editor?, filePath: String, text: String) {
         editor?.let {
             runWriteAction {
@@ -261,12 +232,38 @@ object JsDialogProcessor {
         } ?: run {
             File(filePath).writeText(text)
         }
+        currentFileText = text
     }
 
-    private fun unblockDocument(project: Project, document: Document) {
-        PsiDocumentManager.getInstance(project).apply {
-            commitDocument(document)
-            doPostponedOperationsAndUnblockDocument(document)
+    // Needed for continuous exports managing
+    private var currentFileText = ""
+
+    private fun manageExports(
+        editor: Editor?,
+        project: Project,
+        model: JsTestsModel,
+        swappedText: (String?, String) -> String
+    ) {
+        AppExecutorUtil.getAppExecutorService().submit {
+            invokeLater {
+                when {
+                    currentFileText.contains(startComment) -> {
+                        val regex = Regex("$startComment((\\r\\n|\\n|\\r|.)*)$endComment")
+                        regex.find(currentFileText)?.groups?.get(1)?.value?.let { existingSection ->
+                            val newText = swappedText(existingSection, currentFileText)
+                            project.setNewText(editor, model.containingFilePath, newText)
+                        }
+                    }
+
+                    else -> {
+                        val line = buildString {
+                            append("\n")
+                            appendLine(swappedText(null, currentFileText))
+                        }
+                        project.setNewText(editor, model.containingFilePath, currentFileText + line)
+                    }
+                }
+            }
         }
     }
 }

utbot-intellij-js/src/main/kotlin/org/utbot/intellij/plugin/language/js/JsTestsModel.kt

@@ -6,7 +6,7 @@ import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import org.utbot.framework.codegen.domain.TestFramework
 import org.utbot.intellij.plugin.models.BaseTestsModel
-import service.CoverageMode
+import service.coverage.CoverageMode
 import settings.JsTestGenerationSettings.defaultTimeout
 
 class JsTestsModel(

utbot-js/build.gradle.kts

@@ -29,7 +29,6 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
     api(project(":utbot-framework"))
-    api(project(":utbot-fuzzers"))
     // https://mvnrepository.com/artifact/com.google.javascript/closure-compiler
     implementation("com.google.javascript:closure-compiler:v20221102")
 

utbot-js/samples/arrays.js

@@ -0,0 +1,30 @@
+function simpleArray(arr) {
+    if (arr[0] === 5) {
+        return 5
+    }
+    return 1
+}
+
+simpleArray([0, 2])
+
+class ObjectParameter {
+
+    constructor(a) {
+        this.first = a
+    }
+
+    performAction(value) {
+        return 2 * value
+    }
+}
+
+function arrayOfObjects(arr) {
+    if (arr[0].first === 2) {
+        return 1
+    }
+    return 10
+}
+
+let arr = []
+arr[0] = new ObjectParameter(10)
+arrayOfObjects(arr)

utbot-js/samples/mapStructure.js

@@ -0,0 +1,11 @@
+// Maps in JavaScript are untyped, so only maps with basic key/value types are feasible to support
+function simpleMap(map, compareValue) {
+    if (map.get("a") === compareValue) {
+        return 5
+    }
+    return 1
+}
+
+const map1 = new Map()
+map1.set("b", 3.0)
+simpleMap(map1, 5)

utbot-js/samples/setStructure.js

@@ -0,0 +1,12 @@
+// Sets in JavaScript are untyped, so only sets with basic value types are feasible to support
+function setTest(set, checkValue) {
+    if (set.has(checkValue)) {
+        return 5
+    }
+    return 1
+}
+
+let s = new Set()
+s.add(5)
+s.add(6)
+setTest(s, 4)