Python and JS support #1197

docs/ChoosingLanguageSpecificIDE.md

@@ -0,0 +1,23 @@
+# Choosing language specific IDE
+
+Some language-specific modules depends on specific IntelliJ IDE:
+* Python can work with IntelliJ Community, IntelliJ Ultimate, PyCharm Community, PyCharm Professional
+* JavaScript can work with IntelliJ Ultimate, PyCharm Professional and WebStorm
+* Java and Kotlin - IntelliJ Community and IntelliJ Ultimate
+
+You should select correct IDE in `gradle.properties` file:
+```
+ideType=<IU>
+ideVersion=<222.4167.29>
+```
+
+### IDE marking
+
+| Mark | Full name            | Supported plugin                       |
+|------|----------------------|----------------------------------------|
+| IC   | IntelliJ Community   | JVM, Python, AndroidStudio             |
+| IU   | IntelliJ Ultimate    | JVM, Python, JavaScript, AndroidStudio |
+| PC   | PyCharm Community    | Python                                 |
+| PY   | PyCharm Professional | Python, JavaScript                     |
+
+[IntelliJ Platform Plugin SDK documentation](https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#tasks-runpluginverifier)

gradle.properties

@@ -1,17 +1,23 @@
 kotlin.code.style=official
 
-# IU, IC, PC, PY, WS...
+# IU, IC, PC, PY
 # IC for AndroidStudio
 ideType=IC
+ideVersion=222.4167.29
+
+pythonIde=IC,IU,PC,PY
+jsIde=IU,PY,WS
 
 # In order to run Android Studion instead of Intellij Community,
 # specify the path to your Android Studio installation
 //androidStudioPath=your_path_to_android_studio
 
-pythonCommunityPluginVersion=222.4167.37
 #Version numbers: https://plugins.jetbrains.com/plugin/631-python/versions
+pythonCommunityPluginVersion=222.4167.37
 pythonUltimatePluginVersion=222.4167.37
 
+kotlinPluginVersion=222-1.7.20-release-201-IJ4167.29
+
 junit5Version=5.8.0-RC1
 junit4Version=4.13.2
 junit4PlatformVersion=1.9.0

settings.gradle.kts

@@ -0,0 +1,54 @@
+val ideType: String by settings
+
+val pythonIde: String by settings
+val jsIde: String by settings
+
+pluginManagement {
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.name == "rdgen") {
+                useModule("com.jetbrains.rd:rd-gen:${requested.version}")
+            }
+        }
+    }
+}
+
+rootProject.name = "utbot"
+
+include("utbot-core")
+include("utbot-framework")
+include("utbot-framework-api")
+include("utbot-intellij")
+include("utbot-sample")
+include("utbot-fuzzers")
+include("utbot-junit-contest")
+include("utbot-analytics")
+include("utbot-analytics-torch")
+
+include("utbot-cli")
+
+include("utbot-api")
+include("utbot-instrumentation")
+include("utbot-instrumentation-tests")
+
+include("utbot-summary")
+include("utbot-gradle")
+include("utbot-maven")
+include("utbot-summary-tests")
+include("utbot-framework-test")
+include("utbot-rd")
+include("utbot-android-studio")
+
+include("utbot-ui-commons")
+
+if (pythonIde.split(",").contains(ideType)) {
+    include("utbot-python")
+    include("utbot-cli-python")
+    include("utbot-intellij-python")
+}
+
+if (jsIde.split(",").contains(ideType)) {
+    include("utbot-js")
+    include("utbot-cli-js")
+    include("utbot-intellij-js")
+}

utbot-cli-js/build.gradle

@@ -0,0 +1,75 @@
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_11
+        freeCompilerArgs += ["-Xallow-result-return-type", "-Xsam-conversions=class"]
+    }
+}
+
+tasks.withType(JavaCompile) {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+configurations {
+    fetchInstrumentationJar
+}
+
+dependencies {
+    implementation project(':utbot-framework')
+    implementation project(':utbot-cli')
+    implementation project(':utbot-js')
+
+    // Without this dependency testng tests do not run.
+    implementation group: 'com.beust', name: 'jcommander', version: '1.48'
+    implementation group: 'org.junit.platform', name: 'junit-platform-console-standalone', version: junit4PlatformVersion
+    implementation group: 'io.github.microutils', name: 'kotlin-logging', version: kotlinLoggingVersion
+    implementation group: 'com.github.ajalt.clikt', name: 'clikt', version: cliktVersion
+    implementation group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: junit5Version
+    implementation group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: junit5Version
+    implementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: log4j2Version
+    implementation group: 'org.apache.logging.log4j', name: 'log4j-api', version: log4j2Version
+    implementation group: 'org.json', name: 'json', version: '20220320'
+    //noinspection GroovyAssignabilityCheck
+    fetchInstrumentationJar project(path: ':utbot-instrumentation', configuration: 'instrumentationArchive')
+}
+
+processResources {
+    from(configurations.fetchInstrumentationJar) {
+        into "lib"
+    }
+}
+
+task createProperties(dependsOn: processResources) {
+    doLast {
+        new File("$buildDir/resources/main/version.properties").withWriter { w ->
+            Properties properties = new Properties()
+            //noinspection GroovyAssignabilityCheck
+            properties['version'] = project.version.toString()
+            properties.store w, null
+        }
+    }
+}
+
+classes {
+    dependsOn createProperties
+}
+
+jar {
+    manifest {
+        attributes 'Main-Class': 'org.utbot.cli.js.ApplicationKt'
+        attributes 'Bundle-SymbolicName': 'org.utbot.cli.js'
+        attributes 'Bundle-Version': "${project.version}"
+        attributes 'Implementation-Title': 'UtBot JavaScript CLI'
+        attributes 'JAR-Type': 'Fat JAR'
+    }
+
+    archiveVersion.set(project.version as String)
+
+    dependsOn configurations.runtimeClasspath
+    from {
+        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
+    }
+
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+

utbot-cli-js/src/README.md

@@ -0,0 +1,87 @@
+## Build
+
+.jar file can be built in GitHub Actions with script publish-plugin-and-cli-from-branch.
+
+## Requirements
+
+* NodeJs 10.0.0 or higher (available to download https://nodejs.org/en/download/)
+* Java 11 or higher (available to download https://www.oracle.com/java/technologies/downloads/)
+* Nyc 15.1.0 or higher (`> npm install -g nyc`)
+* Mocha 10.0.0 or higher (`> npm install -g mocha`)
+
+## Basic usage
+
+Generate tests:
+
+    java -jar utbot-cli.jar generate_js --source="dir/file_with_sources.js" --output="dir/generated_tests.js"
+
+This will generate tests for top-level functions from `file_with_sources.js`.
+
+Run generated tests:
+
+    java -jar utbot-cli.jar run_js --fileOrDir="generated_tests.js"
+
+This will run generated tests from file or directory.
+
+Generate coverage report:
+
+    java -jar utbot-cli.jar coverage_js --source=dir/generated_tests.js
+
+This will generate coverage report from generated tests and print in `StdOut`
+
+## `generate_js` options
+
+- `-s, --source <path>`
+
+  (required) Source code file for a test generation.
+- `-c, --class <classname>`
+
+  If not specified, tests for top-level functions or single class are generated, otherwise for the specified class.
+
+- `-o, --output <dir/filename>`
+
+  File for generated tests.
+- `-p, --print-test`
+
+  Specifies whether test should be printed out to `StdOut` (default = false)
+- `-t, --timeout <seconds>`
+
+  Timeout for a single test case to generate in seconds (default = 15)
+- `--coverage-mode <BASIC/FAST>`
+
+  Specifies the coverage mode for test generation. Fast mode can't find timeouts, but works faster (default = FAST)
+- `--path-to-node <path>`
+
+  Sets path to Node.js executable (default = "node")
+- `--path-to-nyc <path>`
+
+  Sets path to nyc executable (default = "nyc")
+- `--path-to-npm <path>`
+
+  Sets path to npm executable (default = "npm")
+
+## `run_js` options
+
+- `-f, --fileOrDir`
+
+  (required) File or directory with tests.
+- `-o, --output`
+
+  Specifies output of .txt file for test framework result (If empty prints to `StdOut`)
+
+- `-t, --test-framework <name>`
+
+  Test framework of tests to run. (default = "Mocha")
+
+## `coverage_js` options
+
+- `-s, --source <file>`
+
+  (required) File with tests to generate a report.
+
+- `-o, --output`
+
+  Specifies output .json file for generated tests (If empty prints .json to `StdOut`)
+- `--path-to-nyc <path>`
+
+  Sets path to nyc executable (default = "nyc")

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

@@ -0,0 +1,35 @@
+package org.utbot.cli.js
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.subcommands
+import com.github.ajalt.clikt.parameters.options.default
+import com.github.ajalt.clikt.parameters.options.option
+import com.github.ajalt.clikt.parameters.options.versionOption
+import com.github.ajalt.clikt.parameters.types.enum
+import org.slf4j.event.Level
+import org.utbot.cli.getVersion
+import org.utbot.cli.setVerbosity
+import kotlin.system.exitProcess
+
+class UtBotJsCli : CliktCommand(name = "UnitTestBot JavaScript Command Line Interface") {
+    private val verbosity by option("--verbosity", help = "Changes verbosity level, case insensitive")
+        .enum<Level>(ignoreCase = true)
+        .default(Level.INFO)
+
+    override fun run() = setVerbosity(verbosity)
+
+    init {
+        versionOption(getVersion())
+    }
+}
+
+fun main(args: Array<String>) = try {
+    UtBotJsCli().subcommands(
+        JsCoverageCommand(),
+        JsGenerateTestsCommand(),
+        JsRunTestsCommand(),
+    ).main(args)
+} catch (ex: Throwable) {
+    ex.printStackTrace()
+    exitProcess(1)
+}