azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AbstractConfigureKotlinTest: J2K

Browse Source
This commit is contained in:
Dmitry Jemerov
2017-07-13 12:15:01 +02:00
parent 4198a5c3ec
commit 2c2b64d44a
3 changed files with 214 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/kotlin/idea/configuration/KotlinWithLibraryConfigurator.kt
+1 -1
View File
@@ -255,7 +255,7 @@ abstract class KotlinWithLibraryConfigurator internal constructor() : KotlinProj
!File(defaultPath, getLibraryJarDescriptors(null).first().jarName).exists() !File(defaultPath, getLibraryJarDescriptors(null).first().jarName).exists()
} }
protected open fun getDefaultPathToJarFile(project: Project): String { open fun getDefaultPathToJarFile(project: Project): String {
return FileUIUtils.createRelativePath(project, project.baseDir, DEFAULT_LIBRARY_DIR) return FileUIUtils.createRelativePath(project, project.baseDir, DEFAULT_LIBRARY_DIR)
} }
idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt
+186 -199
View File
@@ -14,238 +14,225 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.idea.configuration; package org.jetbrains.kotlin.idea.configuration
import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.application.PathMacros; import com.intellij.openapi.application.PathMacros
import com.intellij.openapi.module.Module; import com.intellij.openapi.module.Module
import com.intellij.openapi.module.ModuleManager; import com.intellij.openapi.module.ModuleManager
import com.intellij.openapi.project.Project; import com.intellij.openapi.project.Project
import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.roots.ModuleRootManager; import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.roots.libraries.Library; import com.intellij.openapi.util.io.FileUtilRt
import com.intellij.openapi.util.io.FileUtil; import com.intellij.testFramework.PlatformTestCase
import com.intellij.openapi.util.io.FileUtilRt; import com.intellij.testFramework.UsefulTestCase
import com.intellij.testFramework.PlatformTestCase; import junit.framework.TestCase
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.configuration.KotlinWithLibraryConfigurator.FileState
import org.jetbrains.kotlin.idea.versions.LibraryJarDescriptor; import org.jetbrains.kotlin.utils.PathUtil
import org.jetbrains.kotlin.utils.PathUtil; import java.io.File
import java.io.IOException
import java.io.File; abstract class AbstractConfigureKotlinTest : PlatformTestCase() {
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.kotlin.idea.configuration.KotlinWithLibraryConfigurator.FileState; @Throws(Exception::class)
override fun tearDown() {
PathMacros.getInstance().removeMacro(TEMP_DIR_MACRO_KEY)
public abstract class AbstractConfigureKotlinTest extends PlatformTestCase { super.tearDown()
private static final String BASE_PATH = "idea/testData/configuration/";
private static final String TEMP_DIR_MACRO_KEY = "TEMP_TEST_DIR";
protected static final KotlinJavaModuleConfigurator JAVA_CONFIGURATOR = new KotlinJavaModuleConfigurator() {
@Override
protected String getDefaultPathToJarFile(@NotNull Project project) {
return getPathRelativeToTemp("default_jvm_lib");
} }
};
protected static final KotlinJsModuleConfigurator JS_CONFIGURATOR = new KotlinJsModuleConfigurator() {
@Override
protected String getDefaultPathToJarFile(@NotNull Project project) {
return getPathRelativeToTemp("default_js_lib");
}
};
private static void configure( @Throws(Exception::class)
@NotNull List<Module> modules, override fun initApplication() {
@NotNull FileState runtimeState, super.initApplication()
@NotNull KotlinWithLibraryConfigurator configurator,
@NotNull String jarFromDist, val tempLibDir = FileUtil.createTempDirectory("temp", null)
@NotNull String jarFromTemp PathMacros.getInstance().setMacro(TEMP_DIR_MACRO_KEY, FileUtilRt.toSystemDependentName(tempLibDir.absolutePath))
}
protected fun doTestConfigureModulesWithNonDefaultSetup(configurator: KotlinWithLibraryConfigurator) {
assertNoFilesInDefaultPaths()
val modules = modules
for (module in modules) {
assertNotConfigured(module, configurator)
}
configurator.configure(myProject, emptyList())
assertNoFilesInDefaultPaths()
for (module in modules) {
assertProperlyConfigured(module, configurator)
}
}
protected fun doTestOneJavaModule(jarState: FileState) {
doTestOneModule(jarState, JAVA_CONFIGURATOR)
}
protected fun doTestOneJsModule(jarState: FileState) {
doTestOneModule(jarState, JS_CONFIGURATOR)
}
private fun doTestOneModule(jarState: FileState, configurator: KotlinWithLibraryConfigurator) {
val module = module
assertNotConfigured(module, configurator)
configure(module, jarState, configurator)
assertProperlyConfigured(module, configurator)
}
override fun getModule(): Module {
val modules = ModuleManager.getInstance(myProject).modules
assert(modules.size == 1) { "One module should be loaded " + modules.size }
myModule = modules[0]
return super.getModule()
}
val modules: Array<Module>
get() = ModuleManager.getInstance(myProject).modules
@Throws(IOException::class)
override fun getIprFile(): File {
val projectFilePath = projectRoot + "/projectFile.ipr"
TestCase.assertTrue("Project file should exists " + projectFilePath, File(projectFilePath).exists())
return File(projectFilePath)
}
@Throws(Exception::class)
override fun doCreateProject(projectFile: File): Project? {
return myProjectManager.loadProject(projectFile.path)
}
private val projectName: String
get() {
val testName = getTestName(true)
return if (testName.contains("_")) {
testName.substring(0, testName.indexOf("_"))
}
else testName
}
protected val projectRoot: String
get() = BASE_PATH + projectName
override fun setUpModule() {}
private fun assertNoFilesInDefaultPaths() {
UsefulTestCase.assertDoesntExist(File(JAVA_CONFIGURATOR.getDefaultPathToJarFile(project)))
UsefulTestCase.assertDoesntExist(File(JS_CONFIGURATOR.getDefaultPathToJarFile(project)))
}
companion object {
private val BASE_PATH = "idea/testData/configuration/"
private val TEMP_DIR_MACRO_KEY = "TEMP_TEST_DIR"
protected val JAVA_CONFIGURATOR: KotlinJavaModuleConfigurator = object : KotlinJavaModuleConfigurator() {
override fun getDefaultPathToJarFile(project: Project): String {
return getPathRelativeToTemp("default_jvm_lib")
}
}
protected val JS_CONFIGURATOR: KotlinJsModuleConfigurator = object : KotlinJsModuleConfigurator() {
override fun getDefaultPathToJarFile(project: Project): String {
return getPathRelativeToTemp("default_js_lib")
}
}
private fun configure(
modules: List<Module>,
runtimeState: FileState,
configurator: KotlinWithLibraryConfigurator,
jarFromDist: String,
jarFromTemp: String
) { ) {
Project project = modules.iterator().next().getProject(); val project = modules.iterator().next().project
NotificationMessageCollector collector = NotificationMessageCollectorKt.createConfigureKotlinNotificationCollector(project); val collector = createConfigureKotlinNotificationCollector(project)
for (Module module : modules) { for (module in modules) {
Library library = configurator.getKotlinLibrary(module); var library = configurator.getKotlinLibrary(module)
if (library == null) { if (library == null) {
library = configurator.createNewLibrary(project, collector); library = configurator.createNewLibrary(project, collector)
} }
String pathToJar = getPathToJar(runtimeState, jarFromDist, jarFromTemp); val pathToJar = getPathToJar(runtimeState, jarFromDist, jarFromTemp)
Sdk sdk = ModuleRootManager.getInstance(module).getSdk(); val sdk = ModuleRootManager.getInstance(module).sdk
Library.ModifiableModel model = library.getModifiableModel(); val model = library.modifiableModel
for (LibraryJarDescriptor descriptor : configurator.getLibraryJarDescriptors(sdk)) { for (descriptor in configurator.getLibraryJarDescriptors(sdk)) {
configurator.configureLibraryJar(model, runtimeState, pathToJar, descriptor, collector); configurator.configureLibraryJar(model, runtimeState, pathToJar, descriptor, collector)
} }
ApplicationManager.getApplication().runWriteAction(model::commit); ApplicationManager.getApplication().runWriteAction { model.commit() }
configurator.addLibraryToModuleIfNeeded(module, library, collector); configurator.addLibraryToModuleIfNeeded(module, library, collector)
} }
collector.showNotification(); collector.showNotification()
} }
@NotNull private fun getPathToJar(runtimeState: FileState, jarFromDist: String, jarFromTemp: String): String {
private static String getPathToJar(@NotNull FileState runtimeState, @NotNull String jarFromDist, @NotNull String jarFromTemp) { when (runtimeState) {
switch (runtimeState) { KotlinWithLibraryConfigurator.FileState.EXISTS -> return jarFromDist
case EXISTS: KotlinWithLibraryConfigurator.FileState.COPY -> return jarFromTemp
return jarFromDist; KotlinWithLibraryConfigurator.FileState.DO_NOT_COPY -> return jarFromDist
case COPY:
return jarFromTemp;
case DO_NOT_COPY:
return jarFromDist;
} }
return jarFromDist; return jarFromDist
} }
protected static void configure(@NotNull Module module, @NotNull FileState jarState, @NotNull KotlinProjectConfigurator configurator) { protected fun configure(module: Module, jarState: FileState, configurator: KotlinProjectConfigurator) {
if (configurator instanceof KotlinJavaModuleConfigurator) { if (configurator is KotlinJavaModuleConfigurator) {
configure(Collections.singletonList(module), jarState, configure(listOf(module), jarState,
(KotlinWithLibraryConfigurator) configurator, configurator as KotlinWithLibraryConfigurator,
getPathToExistentRuntimeJar(), getPathToNonexistentRuntimeJar()); pathToExistentRuntimeJar, pathToNonexistentRuntimeJar)
} }
if (configurator instanceof KotlinJsModuleConfigurator) { if (configurator is KotlinJsModuleConfigurator) {
configure(Collections.singletonList(module), jarState, configure(listOf(module), jarState,
(KotlinWithLibraryConfigurator) configurator, configurator as KotlinWithLibraryConfigurator,
getPathToExistentJsJar(), getPathToNonexistentJsJar()); pathToExistentJsJar, pathToNonexistentJsJar)
} }
} }
private static String getPathToNonexistentRuntimeJar() { private val pathToNonexistentRuntimeJar: String
String pathToTempKotlinRuntimeJar = FileUtil.getTempDirectory() + "/" + PathUtil.KOTLIN_JAVA_RUNTIME_JAR; get() {
myFilesToDelete.add(new File(pathToTempKotlinRuntimeJar)); val pathToTempKotlinRuntimeJar = FileUtil.getTempDirectory() + "/" + PathUtil.KOTLIN_JAVA_RUNTIME_JAR
return pathToTempKotlinRuntimeJar; PlatformTestCase.myFilesToDelete.add(File(pathToTempKotlinRuntimeJar))
return pathToTempKotlinRuntimeJar
} }
private static String getPathToNonexistentJsJar() { private val pathToNonexistentJsJar: String
String pathToTempKotlinRuntimeJar = FileUtil.getTempDirectory() + "/" + PathUtil.JS_LIB_JAR_NAME; get() {
myFilesToDelete.add(new File(pathToTempKotlinRuntimeJar)); val pathToTempKotlinRuntimeJar = FileUtil.getTempDirectory() + "/" + PathUtil.JS_LIB_JAR_NAME
return pathToTempKotlinRuntimeJar; PlatformTestCase.myFilesToDelete.add(File(pathToTempKotlinRuntimeJar))
return pathToTempKotlinRuntimeJar
} }
private static String getPathToExistentRuntimeJar() { private val pathToExistentRuntimeJar: String
return PathUtil.getKotlinPathsForDistDirectory().getStdlibPath().getParent(); get() = PathUtil.getKotlinPathsForDistDirectory().stdlibPath.parent
private val pathToExistentJsJar: String
get() = PathUtil.getKotlinPathsForDistDirectory().jsStdLibJarPath.parent
protected fun assertNotConfigured(module: Module, configurator: KotlinWithLibraryConfigurator) {
TestCase.assertFalse(
String.format("Module %s should not be configured as %s Module", module.name, configurator.presentableText),
configurator.isConfigured(module))
} }
private static String getPathToExistentJsJar() { protected fun assertConfigured(module: Module, configurator: KotlinWithLibraryConfigurator) {
return PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath().getParent(); TestCase.assertTrue(String.format("Module %s should be configured with configurator '%s'", module.name,
configurator.presentableText),
configurator.isConfigured(module))
} }
protected static void assertNotConfigured(Module module, KotlinWithLibraryConfigurator configurator) { protected fun assertProperlyConfigured(module: Module, configurator: KotlinWithLibraryConfigurator) {
assertFalse( assertConfigured(module, configurator)
String.format("Module %s should not be configured as %s Module", module.getName(), configurator.getPresentableText()), assertNotConfigured(module, getOppositeConfigurator(configurator))
configurator.isConfigured(module));
} }
protected static void assertConfigured(Module module, KotlinWithLibraryConfigurator configurator) { private fun getOppositeConfigurator(configurator: KotlinWithLibraryConfigurator): KotlinWithLibraryConfigurator {
assertTrue(String.format("Module %s should be configured with configurator '%s'", module.getName(), if (configurator === JAVA_CONFIGURATOR) return JS_CONFIGURATOR
configurator.getPresentableText()), if (configurator === JS_CONFIGURATOR) return JAVA_CONFIGURATOR
configurator.isConfigured(module));
throw IllegalArgumentException("Only JS_CONFIGURATOR and JAVA_CONFIGURATOR are supported")
} }
protected static void assertProperlyConfigured(Module module, KotlinWithLibraryConfigurator configurator) { private fun getPathRelativeToTemp(relativePath: String): String {
assertConfigured(module, configurator); val tempPath = PathMacros.getInstance().getValue(TEMP_DIR_MACRO_KEY)
assertNotConfigured(module, getOppositeConfigurator(configurator)); return tempPath + '/' + relativePath
} }
private static KotlinWithLibraryConfigurator getOppositeConfigurator(KotlinWithLibraryConfigurator configurator) {
if (configurator == JAVA_CONFIGURATOR) return JS_CONFIGURATOR;
if (configurator == JS_CONFIGURATOR) return JAVA_CONFIGURATOR;
throw new IllegalArgumentException("Only JS_CONFIGURATOR and JAVA_CONFIGURATOR are supported");
}
private static String getPathRelativeToTemp(String relativePath) {
String tempPath = PathMacros.getInstance().getValue(TEMP_DIR_MACRO_KEY);
return tempPath + '/' + relativePath;
}
@Override
protected void tearDown() throws Exception {
PathMacros.getInstance().removeMacro(TEMP_DIR_MACRO_KEY);
super.tearDown();
}
@Override
protected void initApplication() throws Exception {
super.initApplication();
File tempLibDir = FileUtil.createTempDirectory("temp", null);
PathMacros.getInstance().setMacro(TEMP_DIR_MACRO_KEY, FileUtilRt.toSystemDependentName(tempLibDir.getAbsolutePath()));
}
protected void doTestConfigureModulesWithNonDefaultSetup(KotlinWithLibraryConfigurator configurator) {
assertNoFilesInDefaultPaths();
Module[] modules = getModules();
for (Module module : modules) {
assertNotConfigured(module, configurator);
}
configurator.configure(myProject, Collections.<Module>emptyList());
assertNoFilesInDefaultPaths();
for (Module module : modules) {
assertProperlyConfigured(module, configurator);
}
}
protected void doTestOneJavaModule(@NotNull FileState jarState) {
doTestOneModule(jarState, JAVA_CONFIGURATOR);
}
protected void doTestOneJsModule(@NotNull FileState jarState) {
doTestOneModule(jarState, JS_CONFIGURATOR);
}
private void doTestOneModule(@NotNull FileState jarState, @NotNull KotlinWithLibraryConfigurator configurator) {
Module module = getModule();
assertNotConfigured(module, configurator);
configure(module, jarState, configurator);
assertProperlyConfigured(module, configurator);
}
@Override
public Module getModule() {
Module[] modules = ModuleManager.getInstance(myProject).getModules();
assert modules.length == 1 : "One module should be loaded " + modules.length;
myModule = modules[0];
return super.getModule();
}
public Module[] getModules() {
return ModuleManager.getInstance(myProject).getModules();
}
@Override
protected File getIprFile() throws IOException {
String projectFilePath = getProjectRoot() + "/projectFile.ipr";
assertTrue("Project file should exists " + projectFilePath, new File(projectFilePath).exists());
return new File(projectFilePath);
}
@Override
protected Project doCreateProject(@NotNull File projectFile) throws Exception {
return myProjectManager.loadProject(projectFile.getPath());
}
private String getProjectName() {
String testName = getTestName(true);
if (testName.contains("_")) {
return testName.substring(0, testName.indexOf("_"));
}
return testName;
}
protected String getProjectRoot() {
return BASE_PATH + getProjectName();
}
@Override
protected void setUpModule() {
}
private void assertNoFilesInDefaultPaths() {
assertDoesntExist(new File(JAVA_CONFIGURATOR.getDefaultPathToJarFile(getProject())));
assertDoesntExist(new File(JS_CONFIGURATOR.getDefaultPathToJarFile(getProject())));
} }
} }
idea/tests/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinTest.java
+13 -13
View File
@@ -63,13 +63,13 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
Module[] modules = getModules(); Module[] modules = getModules();
for (Module module : modules) { for (Module module : modules) {
if (module.getName().equals("module1")) { if (module.getName().equals("module1")) {
configure(module, KotlinWithLibraryConfigurator.FileState.DO_NOT_COPY, JAVA_CONFIGURATOR); Companion.configure(module, KotlinWithLibraryConfigurator.FileState.DO_NOT_COPY, Companion.getJAVA_CONFIGURATOR());
assertConfigured(module, JAVA_CONFIGURATOR); Companion.assertConfigured(module, Companion.getJAVA_CONFIGURATOR());
} }
else if (module.getName().equals("module2")) { else if (module.getName().equals("module2")) {
assertNotConfigured(module, JAVA_CONFIGURATOR); Companion.assertNotConfigured(module, Companion.getJAVA_CONFIGURATOR());
configure(module, KotlinWithLibraryConfigurator.FileState.EXISTS, JAVA_CONFIGURATOR); Companion.configure(module, KotlinWithLibraryConfigurator.FileState.EXISTS, Companion.getJAVA_CONFIGURATOR());
assertConfigured(module, JAVA_CONFIGURATOR); Companion.assertConfigured(module, Companion.getJAVA_CONFIGURATOR());
} }
} }
} }
@@ -80,21 +80,21 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
// Move fake runtime jar to default library path to pretend library is already configured // Move fake runtime jar to default library path to pretend library is already configured
FileUtil.copy( FileUtil.copy(
new File(getProject().getBasePath() + "/lib/kotlin-runtime.jar"), new File(getProject().getBasePath() + "/lib/kotlin-runtime.jar"),
new File(JAVA_CONFIGURATOR.getDefaultPathToJarFile(getProject()) + "/kotlin-runtime.jar")); new File(Companion.getJAVA_CONFIGURATOR().getDefaultPathToJarFile(getProject()) + "/kotlin-runtime.jar"));
assertNotConfigured(module, JAVA_CONFIGURATOR); Companion.assertNotConfigured(module, Companion.getJAVA_CONFIGURATOR());
JAVA_CONFIGURATOR.configure(myProject, Collections.<Module>emptyList()); Companion.getJAVA_CONFIGURATOR().configure(myProject, Collections.<Module>emptyList());
assertProperlyConfigured(module, JAVA_CONFIGURATOR); Companion.assertProperlyConfigured(module, Companion.getJAVA_CONFIGURATOR());
} }
public void testTwoModulesWithNonDefaultPath_doNotCopyInDefault() throws IOException { public void testTwoModulesWithNonDefaultPath_doNotCopyInDefault() throws IOException {
doTestConfigureModulesWithNonDefaultSetup(JAVA_CONFIGURATOR); doTestConfigureModulesWithNonDefaultSetup(Companion.getJAVA_CONFIGURATOR());
assertEmpty(ConfigureKotlinInProjectUtilsKt.getCanBeConfiguredModules(myProject, JS_CONFIGURATOR)); assertEmpty(ConfigureKotlinInProjectUtilsKt.getCanBeConfiguredModules(myProject, Companion.getJS_CONFIGURATOR()));
} }
public void testTwoModulesWithJSNonDefaultPath_doNotCopyInDefault() throws IOException { public void testTwoModulesWithJSNonDefaultPath_doNotCopyInDefault() throws IOException {
doTestConfigureModulesWithNonDefaultSetup(JS_CONFIGURATOR); doTestConfigureModulesWithNonDefaultSetup(Companion.getJS_CONFIGURATOR());
assertEmpty(ConfigureKotlinInProjectUtilsKt.getCanBeConfiguredModules(myProject, JAVA_CONFIGURATOR)); assertEmpty(ConfigureKotlinInProjectUtilsKt.getCanBeConfiguredModules(myProject, Companion.getJAVA_CONFIGURATOR()));
} }
public void testNewLibrary_jarExists_js() { public void testNewLibrary_jarExists_js() {