From 2e624f771b50c8da835bca58ba38d2826b3d646b Mon Sep 17 00:00:00 2001 From: Vyacheslav Gerasimov Date: Mon, 13 Aug 2018 13:41:46 +0300 Subject: [PATCH] 183: Fix MavenImportingTestCase (`MavenServerManager.setUseMaven2` signature has changed) --- .../maven/MavenImportingTestCase.java.183 | 593 ++++++++++++++++++ 1 file changed, 593 insertions(+) create mode 100644 idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/MavenImportingTestCase.java.183 diff --git a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/MavenImportingTestCase.java.183 b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/MavenImportingTestCase.java.183 new file mode 100644 index 00000000000..5a53fb684ec --- /dev/null +++ b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/MavenImportingTestCase.java.183 @@ -0,0 +1,593 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.idea.maven; + +import com.intellij.compiler.server.BuildManager; +import com.intellij.openapi.application.AccessToken; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.module.ModuleManager; +import com.intellij.openapi.progress.EmptyProgressIndicator; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl; +import com.intellij.openapi.roots.*; +import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable; +import com.intellij.openapi.roots.libraries.Library; +import com.intellij.openapi.ui.Messages; +import com.intellij.openapi.ui.TestDialog; +import com.intellij.openapi.util.AsyncResult; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.openapi.vfs.VfsUtil; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess; +import com.intellij.testFramework.IdeaTestUtil; +import com.intellij.util.Consumer; +import com.intellij.util.PathUtil; +import com.intellij.util.ui.UIUtil; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.idea.maven.execution.*; +import org.jetbrains.idea.maven.model.MavenArtifact; +import org.jetbrains.idea.maven.model.MavenExplicitProfiles; +import org.jetbrains.idea.maven.project.*; +import org.jetbrains.idea.maven.server.MavenServerManager; +import org.jetbrains.jps.model.java.JavaResourceRootType; +import org.jetbrains.jps.model.java.JavaSourceRootProperties; +import org.jetbrains.jps.model.java.JavaSourceRootType; +import org.jetbrains.jps.model.module.JpsModuleSourceRootType; + +import java.io.File; +import java.io.IOException; +import java.util.*; +import java.util.concurrent.atomic.AtomicInteger; + +public abstract class MavenImportingTestCase extends MavenTestCase { + protected MavenProjectsTree myProjectsTree; + protected MavenProjectsManager myProjectsManager; + private File myGlobalSettingsFile; + + @Override + protected void setUp() throws Exception { + VfsRootAccess.allowRootAccess(PathManager.getConfigPath()); + super.setUp(); + myGlobalSettingsFile = + MavenWorkspaceSettingsComponent.getInstance(myProject).getSettings().generalSettings.getEffectiveGlobalSettingsIoFile(); + if (myGlobalSettingsFile != null) { + VfsRootAccess.allowRootAccess(myGlobalSettingsFile.getAbsolutePath()); + } + } + + @Override + protected void setUpInWriteAction() throws Exception { + super.setUpInWriteAction(); + myProjectsManager = MavenProjectsManager.getInstance(myProject); + removeFromLocalRepository("test"); + } + + @Override + protected void tearDown() throws Exception { + try { + if (myGlobalSettingsFile != null) { + VfsRootAccess.disallowRootAccess(myGlobalSettingsFile.getAbsolutePath()); + } + VfsRootAccess.disallowRootAccess(PathManager.getConfigPath()); + Messages.setTestDialog(TestDialog.DEFAULT); + removeFromLocalRepository("test"); + FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory().toFile()); + } + finally { + super.tearDown(); + } + } + + protected void assertModules(String... expectedNames) { + Module[] actual = ModuleManager.getInstance(myProject).getModules(); + List actualNames = new ArrayList(); + + for (Module m : actual) { + actualNames.add(m.getName()); + } + + assertUnorderedElementsAreEqual(actualNames, expectedNames); + } + + protected void assertContentRoots(String moduleName, String... expectedRoots) { + List actual = new ArrayList(); + for (ContentEntry e : getContentRoots(moduleName)) { + actual.add(e.getUrl()); + } + + for (int i = 0; i < expectedRoots.length; i++) { + expectedRoots[i] = VfsUtil.pathToUrl(expectedRoots[i]); + } + + assertUnorderedPathsAreEqual(actual, Arrays.asList(expectedRoots)); + } + + protected void assertSources(String moduleName, String... expectedSources) { + assertContentFolders(moduleName, JavaSourceRootType.SOURCE, expectedSources); + } + + protected void assertGeneratedSources(String moduleName, String... expectedSources) { + ContentEntry contentRoot = getContentRoot(moduleName); + List folders = new ArrayList(); + for (SourceFolder folder : contentRoot.getSourceFolders(JavaSourceRootType.SOURCE)) { + JavaSourceRootProperties properties = folder.getJpsElement().getProperties(JavaSourceRootType.SOURCE); + assertNotNull(properties); + if (properties.isForGeneratedSources()) { + folders.add(folder); + } + } + doAssertContentFolders(contentRoot, folders, expectedSources); + } + + protected void assertResources(String moduleName, String... expectedSources) { + assertContentFolders(moduleName, JavaResourceRootType.RESOURCE, expectedSources); + } + + protected void assertTestSources(String moduleName, String... expectedSources) { + assertContentFolders(moduleName, JavaSourceRootType.TEST_SOURCE, expectedSources); + } + + protected void assertTestResources(String moduleName, String... expectedSources) { + assertContentFolders(moduleName, JavaResourceRootType.TEST_RESOURCE, expectedSources); + } + + protected void assertExcludes(String moduleName, String... expectedExcludes) { + ContentEntry contentRoot = getContentRoot(moduleName); + doAssertContentFolders(contentRoot, Arrays.asList(contentRoot.getExcludeFolders()), expectedExcludes); + } + + protected void assertContentRootExcludes(String moduleName, String contentRoot, String... expectedExcudes) { + ContentEntry root = getContentRoot(moduleName, contentRoot); + doAssertContentFolders(root, Arrays.asList(root.getExcludeFolders()), expectedExcudes); + } + + protected void assertContentFolders(String moduleName, @NotNull JpsModuleSourceRootType rootType, String... expected) { + ContentEntry contentRoot = getContentRoot(moduleName); + doAssertContentFolders(contentRoot, contentRoot.getSourceFolders(rootType), expected); + } + + private static void doAssertContentFolders(ContentEntry e, final List folders, String... expected) { + List actual = new ArrayList(); + for (ContentFolder f : folders) { + String rootUrl = e.getUrl(); + String folderUrl = f.getUrl(); + + if (folderUrl.startsWith(rootUrl)) { + int length = rootUrl.length() + 1; + folderUrl = folderUrl.substring(Math.min(length, folderUrl.length())); + } + + actual.add(folderUrl); + } + + assertOrderedElementsAreEqual(actual, Arrays.asList(expected)); + } + + protected void assertModuleOutput(String moduleName, String output, String testOutput) { + CompilerModuleExtension e = getCompilerExtension(moduleName); + + assertFalse(e.isCompilerOutputPathInherited()); + assertEquals(output, getAbsolutePath(e.getCompilerOutputUrl())); + assertEquals(testOutput, getAbsolutePath(e.getCompilerOutputUrlForTests())); + } + + private static String getAbsolutePath(String path) { + path = VfsUtil.urlToPath(path); + path = PathUtil.getCanonicalPath(path); + return FileUtil.toSystemIndependentName(path); + } + + protected void assertProjectOutput(String module) { + assertTrue(getCompilerExtension(module).isCompilerOutputPathInherited()); + } + + protected CompilerModuleExtension getCompilerExtension(String module) { + ModuleRootManager m = getRootManager(module); + return CompilerModuleExtension.getInstance(m.getModule()); + } + + protected void assertModuleLibDep(String moduleName, String depName) { + assertModuleLibDep(moduleName, depName, null); + } + + protected void assertModuleLibDep(String moduleName, String depName, String classesPath) { + assertModuleLibDep(moduleName, depName, classesPath, null, null); + } + + protected void assertModuleLibDep(String moduleName, String depName, String classesPath, String sourcePath, String javadocPath) { + LibraryOrderEntry lib = getModuleLibDep(moduleName, depName); + + assertModuleLibDepPath(lib, OrderRootType.CLASSES, classesPath == null ? null : Collections.singletonList(classesPath)); + assertModuleLibDepPath(lib, OrderRootType.SOURCES, sourcePath == null ? null : Collections.singletonList(sourcePath)); + assertModuleLibDepPath(lib, JavadocOrderRootType.getInstance(), + javadocPath == null ? null : Collections.singletonList(javadocPath)); + } + + protected void assertModuleLibDep( + String moduleName, + String depName, + List classesPaths, + List sourcePaths, + List javadocPaths + ) { + LibraryOrderEntry lib = getModuleLibDep(moduleName, depName); + + assertModuleLibDepPath(lib, OrderRootType.CLASSES, classesPaths); + assertModuleLibDepPath(lib, OrderRootType.SOURCES, sourcePaths); + assertModuleLibDepPath(lib, JavadocOrderRootType.getInstance(), javadocPaths); + } + + private static void assertModuleLibDepPath(LibraryOrderEntry lib, OrderRootType type, List paths) { + if (paths == null) return; + assertUnorderedPathsAreEqual(Arrays.asList(lib.getRootUrls(type)), paths); + // also check the library because it may contain slight different set of urls (e.g. with duplicates) + assertUnorderedPathsAreEqual(Arrays.asList(lib.getLibrary().getUrls(type)), paths); + } + + protected void assertModuleLibDepScope(String moduleName, String depName, DependencyScope scope) { + LibraryOrderEntry dep = getModuleLibDep(moduleName, depName); + assertEquals(scope, dep.getScope()); + } + + private LibraryOrderEntry getModuleLibDep(String moduleName, String depName) { + return getModuleDep(moduleName, depName, LibraryOrderEntry.class); + } + + protected void assertModuleLibDeps(String moduleName, String... expectedDeps) { + assertModuleDeps(moduleName, LibraryOrderEntry.class, expectedDeps); + } + + protected void assertExportedDeps(String moduleName, String... expectedDeps) { + final List actual = new ArrayList(); + + getRootManager(moduleName).orderEntries().withoutSdk().withoutModuleSourceEntries().exportedOnly() + .process(new RootPolicy() { + @Override + public Object visitModuleOrderEntry(ModuleOrderEntry e, Object value) { + actual.add(e.getModuleName()); + return null; + } + + @Override + public Object visitLibraryOrderEntry(LibraryOrderEntry e, Object value) { + actual.add(e.getLibraryName()); + return null; + } + }, null); + + assertOrderedElementsAreEqual(actual, expectedDeps); + } + + protected void assertModuleModuleDeps(String moduleName, String... expectedDeps) { + assertModuleDeps(moduleName, ModuleOrderEntry.class, expectedDeps); + } + + private void assertModuleDeps(String moduleName, Class clazz, String... expectedDeps) { + assertOrderedElementsAreEqual(collectModuleDepsNames(moduleName, clazz), expectedDeps); + } + + protected void assertModuleModuleDepScope(String moduleName, String depName, DependencyScope scope) { + ModuleOrderEntry dep = getModuleModuleDep(moduleName, depName); + assertEquals(scope, dep.getScope()); + } + + private ModuleOrderEntry getModuleModuleDep(String moduleName, String depName) { + return getModuleDep(moduleName, depName, ModuleOrderEntry.class); + } + + private List collectModuleDepsNames(String moduleName, Class clazz) { + List actual = new ArrayList(); + + for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) { + if (clazz.isInstance(e)) { + actual.add(e.getPresentableName()); + } + } + return actual; + } + + private T getModuleDep(String moduleName, String depName, Class clazz) { + T dep = null; + + for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) { + if (clazz.isInstance(e) && e.getPresentableName().equals(depName)) { + dep = (T) e; + } + } + assertNotNull("Dependency not found: " + depName + + "\namong: " + collectModuleDepsNames(moduleName, clazz), + dep); + return dep; + } + + public void assertProjectLibraries(String... expectedNames) { + List actualNames = new ArrayList(); + for (Library each : ProjectLibraryTable.getInstance(myProject).getLibraries()) { + String name = each.getName(); + actualNames.add(name == null ? "" : name); + } + assertUnorderedElementsAreEqual(actualNames, expectedNames); + } + + protected void assertModuleGroupPath(String moduleName, String... expected) { + String[] path = ModuleManager.getInstance(myProject).getModuleGroupPath(getModule(moduleName)); + + if (expected.length == 0) { + assertNull(path); + } + else { + assertNotNull(path); + assertOrderedElementsAreEqual(Arrays.asList(path), expected); + } + } + + protected Module getModule(final String name) { + AccessToken accessToken = ApplicationManager.getApplication().acquireReadActionLock(); + try { + Module m = ModuleManager.getInstance(myProject).findModuleByName(name); + assertNotNull("Module " + name + " not found", m); + return m; + } + finally { + accessToken.finish(); + } + } + + private ContentEntry getContentRoot(String moduleName) { + ContentEntry[] ee = getContentRoots(moduleName); + List roots = new ArrayList(); + for (ContentEntry e : ee) { + roots.add(e.getUrl()); + } + + String message = "Several content roots found: [" + StringUtil.join(roots, ", ") + "]"; + assertEquals(message, 1, ee.length); + + return ee[0]; + } + + private ContentEntry getContentRoot(String moduleName, String path) { + for (ContentEntry e : getContentRoots(moduleName)) { + if (e.getUrl().equals(VfsUtil.pathToUrl(path))) return e; + } + throw new AssertionError("content root not found"); + } + + public ContentEntry[] getContentRoots(String moduleName) { + return getRootManager(moduleName).getContentEntries(); + } + + private ModuleRootManager getRootManager(String module) { + return ModuleRootManager.getInstance(getModule(module)); + } + + protected void importProject(@NonNls String xml) throws IOException { + createProjectPom(xml); + importProject(); + } + + protected void importProject() { + importProjectWithProfiles(); + } + + protected void importProjectWithProfiles(String... profiles) { + doImportProjects(true, Collections.singletonList(myProjectPom), profiles); + } + + protected void importProject(VirtualFile file) { + importProjects(file); + } + + protected void importProjects(VirtualFile... files) { + doImportProjects(true, Arrays.asList(files)); + } + + protected void importProjectWithMaven3(@NonNls String xml) throws IOException { + createProjectPom(xml); + importProjectWithMaven3(); + } + + protected void importProjectWithMaven3() { + importProjectWithMaven3WithProfiles(); + } + + protected void importProjectWithMaven3WithProfiles(String... profiles) { + doImportProjects(false, Collections.singletonList(myProjectPom), profiles); + } + + private void doImportProjects(boolean useMaven2, final List files, String... profiles) { + if (useMaven2) + MavenServerManager.getInstance().setUseMaven2(); + + initProjectsManager(false); + + readProjects(files, profiles); + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + myProjectsManager.waitForResolvingCompletion(); + myProjectsManager.scheduleImportInTests(files); + myProjectsManager.importProjects(); + } + }); + + for (MavenProject each : myProjectsTree.getProjects()) { + if (each.hasReadingProblems()) { + System.out.println(each + " has problems: " + each.getProblems()); + } + } + } + + protected void readProjects(List files, String... profiles) { + myProjectsManager.resetManagedFilesAndProfilesInTests(files, new MavenExplicitProfiles(Arrays.asList(profiles))); + waitForReadingCompletion(); + } + + protected void updateProjectsAndImport(VirtualFile... files) { + readProjects(files); + myProjectsManager.performScheduledImportInTests(); + } + + protected void initProjectsManager(boolean enableEventHandling) { + myProjectsManager.initForTests(); + myProjectsTree = myProjectsManager.getProjectsTreeForTests(); + if (enableEventHandling) myProjectsManager.listenForExternalChanges(); + } + + protected void scheduleResolveAll() { + myProjectsManager.scheduleResolveAllInTests(); + } + + protected void waitForReadingCompletion() { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + try { + myProjectsManager.waitForReadingCompletion(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + protected void readProjects() { + readProjects(myProjectsManager.getProjectsFiles()); + } + + protected void readProjects(VirtualFile... files) { + List projects = new ArrayList(); + for (VirtualFile each : files) { + projects.add(myProjectsManager.findProject(each)); + } + myProjectsManager.forceUpdateProjects(projects); + waitForReadingCompletion(); + } + + protected void resolveDependenciesAndImport() { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + myProjectsManager.waitForResolvingCompletion(); + myProjectsManager.performScheduledImportInTests(); + } + }); + } + + protected void resolveFoldersAndImport() { + myProjectsManager.scheduleFoldersResolveForAllProjects(); + myProjectsManager.waitForFoldersResolvingCompletion(); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + myProjectsManager.performScheduledImportInTests(); + } + }); + } + + protected void resolvePlugins() { + myProjectsManager.waitForPluginsResolvingCompletion(); + } + + protected void downloadArtifacts() { + downloadArtifacts(myProjectsManager.getProjects(), null); + } + + protected MavenArtifactDownloader.DownloadResult downloadArtifacts( + Collection projects, + List artifacts + ) { + final MavenArtifactDownloader.DownloadResult[] unresolved = new MavenArtifactDownloader.DownloadResult[1]; + + AsyncResult result = new AsyncResult(); + result.doWhenDone(new Consumer() { + @Override + public void consume(MavenArtifactDownloader.DownloadResult unresolvedArtifacts) { + unresolved[0] = unresolvedArtifacts; + } + }); + + myProjectsManager.scheduleArtifactsDownloading(projects, artifacts, true, true, result); + myProjectsManager.waitForArtifactsDownloadingCompletion(); + + return unresolved[0]; + } + + protected void performPostImportTasks() { + myProjectsManager.waitForPostImportTasksCompletion(); + } + + protected void executeGoal(String relativePath, String goal) { + VirtualFile dir = myProjectRoot.findFileByRelativePath(relativePath); + + MavenRunnerParameters rp = new MavenRunnerParameters(true, dir.getPath(), Arrays.asList(goal), Collections.emptyList()); + MavenRunnerSettings rs = new MavenRunnerSettings(); + MavenExecutor e = new MavenExternalExecutor(myProject, rp, getMavenGeneralSettings(), rs, new SoutMavenConsole()); + + e.execute(new EmptyProgressIndicator()); + } + + protected void removeFromLocalRepository(String relativePath) throws IOException { + FileUtil.delete(new File(getRepositoryPath(), relativePath)); + } + + protected void setupJdkForModules(String... moduleNames) { + for (String each : moduleNames) { + setupJdkForModule(each); + } + } + + protected Sdk setupJdkForModule(final String moduleName) { + final Sdk sdk = JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk(); + ModuleRootModificationUtil.setModuleSdk(getModule(moduleName), sdk); + return sdk; + } + + protected static Sdk createJdk(String versionName) { + return IdeaTestUtil.getMockJdk17(versionName); + } + + protected static AtomicInteger configConfirmationForYesAnswer() { + final AtomicInteger counter = new AtomicInteger(); + Messages.setTestDialog(new TestDialog() { + @Override + public int show(String message) { + counter.set(counter.get() + 1); + return 0; + } + }); + return counter; + } + + protected static AtomicInteger configConfirmationForNoAnswer() { + final AtomicInteger counter = new AtomicInteger(); + Messages.setTestDialog(new TestDialog() { + @Override + public int show(String message) { + counter.set(counter.get() + 1); + return 1; + } + }); + return counter; + } +}