IDEA-95898 Gradle based projects should offer Auto-Import as Maven projects do

Revive gradle tests after auto-import introduction (change service dependencies and api)

plugins/gradle/testSources/org/jetbrains/plugins/gradle/config/GradleConfigurableTest.groovy

@@ -29,7 +29,7 @@ public class GradleConfigurableTest {
   void setUp() {
     helper = [
       getSettings : { settings[it] },
-      applySettings: {linkedProjectPath, gradleHomePath, preferLocalInstallationToWrapper, serviceDirectoryPath, project -> },
+      applySettings: {linkedProjectPath, gradleHomePath, preferLocalInstallationToWrapper, autoImport, serviceDirectoryPath, project -> },
       applyPreferLocalInstallationToWrapper: { preferLocalInstallationToWrapper, project -> },
       getGradleHome: { new File(VALID_GRADLE_HOME) },
       getDefaultProject: { defaultProject },

plugins/gradle/testSources/org/jetbrains/plugins/gradle/manage/GradleLocalNodeManageHelperTest.groovy

@@ -1,158 +0,0 @@
-package org.jetbrains.plugins.gradle.manage;
-
-
-import org.jetbrains.plugins.gradle.model.id.GradleEntityIdMapper
-import org.jetbrains.plugins.gradle.testutil.AbstractGradleTest
-import org.junit.Before
-import org.junit.Test
-import org.picocontainer.MutablePicoContainer
-
-import javax.swing.tree.TreeNode
-
-import static org.junit.Assert.fail
-
-/**
- * @author Denis Zhdanov
- * @since 02/10/2012
- */
-public class GradleLocalNodeManageHelperTest extends AbstractGradleTest {
-
-  private GradleLocalNodeManageHelper myHelper
-
-  @Before
-  public void setUp() {
-    super.setUp();
-    clearChangePostProcessors()
-  }
-  
-  @Override
-  protected void configureContainer(MutablePicoContainer container) {
-    container.registerComponentImplementation(GradleLocalNodeManageHelper)
-    container.registerComponentImplementation(GradleModuleManager)
-    container.registerComponentImplementation(GradleContentRootManager)
-  }
-
-  @Test
-  public void "library dependency causes module and library to be transitively imported as well"() {
-    doTest {
-      project {
-        module('module1', transitive: true, order: 0) { // Mark that the module should be imported
-          dependencies {
-            library('lib1', initial: true, order: 2) // Mark that this node should be given as initially selected
-            library('lib2') // No mark here. Means that the node should not be imported
-        } }
-        library('lib1', transitive: true, order: 1) // Mark that the library should be imported
-        library('lib2') // No mark here. Means that the library should not be imported
-    } }
-  }
-
-  @Test
-  public void "module import covers content root"() {
-    doTest {
-      project {
-        module('module1', initial: true, order: 0) {
-          contentRoot('1', transitive: true, order: 1)
-    } } }
-  }
-
-  @SuppressWarnings("GroovyAssignabilityCheck")
-  private def doTest(Closure c) {
-    myHelper = container.getComponentInstance(GradleLocalNodeManageHelper)
-    def compositeBuilder = new CompositeProjectBuilder(gradleBuilder: gradle, intellijBuilder: intellij)
-    c.delegate = compositeBuilder
-    c.call()
-    init()
-    myHelper
-    def nodes = collectNodes(treeModel.root as TreeNode, compositeBuilder.initial)
-    def expectedEntities = compositeBuilder.expected.sort{ a, b -> a[0].compareTo(b[0]) }.collect { it[1] }
-    def actual = myHelper.deriveEntitiesToImport(nodes)
-    if (expectedEntities == actual) {
-      return
-    }
-    fail("""\
-Mismatched 'import nodes with dependencies'.
-  Initial: ${out -> nodes.each { out << "\n    * $it"}}
-  Expected ordered graph: ${out -> expectedEntities.eachWithIndex { val, i -> out << "\n    $i) $val"}}
-  Actual ordered grapth: ${out -> actual.eachWithIndex { val, i -> out << "\n    $i) $val"}}
-""")
-  }
-
-  private List collectNodes(TreeNode node, initial, holder = []) {
-    if (initial.contains(node.descriptor.element)) {
-      holder << node
-    }
-    for (child in node) {
-      collectNodes(child, initial, holder)
-    }
-    holder
-  }
-  
-  class CompositeProjectBuilder extends BuilderSupport {
-    
-    def gradleBuilder
-    def intellijBuilder
-    def initial = [].toSet()
-    def expected = []
-    private def gradleLocalRoot
-    private def gradleStack = new Stack()
-    private def intellijStack = new Stack()
-
-    @Override
-    protected void setParent(Object parent, Object child) { }
-
-    @Override
-    protected void nodeCompleted(Object parent, Object node) {
-      gradleStack.pop()
-      if (node == gradleLocalRoot) {
-        gradleLocalRoot = null
-      }
-      if (!gradleLocalRoot && !intellijStack.isEmpty()) {
-        intellijStack.pop()
-      }
-    }
-
-    @Override
-    protected def createNode(Object name) { createNode(name, [:], '') }
-
-    @Override
-    protected def createNode(Object name, Object value) { createNode(name, [:], value) }
-
-    @Override
-    protected def createNode(Object name, Map attributes) {
-      throw new UnsupportedOperationException()
-    }
-
-    @Override
-    protected def createNode(Object nodeName, Map attributes, name) {
-      if (!gradleStack.isEmpty()) {
-        gradleBuilder.current = gradleStack.peek()
-      }
-      def result = gradleBuilder."$nodeName"([name: name] + attributes)
-      gradleStack.push(result)
-      if (attributes.transitive || attributes.initial) {
-        registerTargetEntity(attributes, result)
-        if (attributes.initial) {
-          // We need to match the entity to the object that is stored at the gradle sync project changes tree.
-          initial << GradleEntityIdMapper.mapEntityToId(result)
-        }
-      }
-      if (!gradleLocalRoot) {
-        if (!intellijStack.isEmpty()) {
-          intellijBuilder.current = intellijStack.peek()
-        }
-        intellijStack.push(intellijBuilder."$nodeName"([name: name] + attributes))
-      }
-      result
-    }
-
-    private void registerTargetEntity(Map attributes, entity) {
-      if (attributes.order == null) {
-        throw new IllegalArgumentException("Detected 'initial' entity with undefined 'order' property: $entity")
-      }
-      expected << [attributes.order, entity]
-      if (!gradleLocalRoot) {
-        gradleLocalRoot = entity
-      }
-    }
-  }
-}

plugins/gradle/testSources/org/jetbrains/plugins/gradle/sync/GradleMovedJarsPostProcessorTest.groovy

@@ -24,6 +24,7 @@ import org.jetbrains.plugins.gradle.testutil.AbstractGradleTest
 import org.jetbrains.plugins.gradle.util.GradleUtil
 import org.jetbrains.plugins.gradle.util.TestGradleJarManager
 import org.junit.Assert
+import org.junit.Before
 import org.junit.Test
 
 /**

plugins/gradle/testSources/org/jetbrains/plugins/gradle/testutil/AbstractGradleTest.groovy

@@ -1,12 +1,16 @@
 package org.jetbrains.plugins.gradle.testutil
 
+import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.editor.colors.TextAttributesKey
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.libraries.Library
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.plugins.gradle.action.AbstractGradleSyncTreeFilterAction
+import org.jetbrains.plugins.gradle.autoimport.GradleAutoImporter
 import org.jetbrains.plugins.gradle.config.GradleColorAndFontDescriptorsProvider
+import org.jetbrains.plugins.gradle.config.GradleLocalSettings
+import org.jetbrains.plugins.gradle.config.GradleSettings
 import org.jetbrains.plugins.gradle.config.PlatformFacade
 import org.jetbrains.plugins.gradle.diff.GradleStructureChangesCalculator
 import org.jetbrains.plugins.gradle.diff.contentroot.GradleContentRootStructureChangesCalculator
@@ -16,8 +20,10 @@ import org.jetbrains.plugins.gradle.diff.library.GradleLibraryStructureChangesCa
 import org.jetbrains.plugins.gradle.diff.module.GradleModuleStructureChangesCalculator
 import org.jetbrains.plugins.gradle.diff.project.GradleProjectStructureChangesCalculator
 import org.jetbrains.plugins.gradle.manage.GradleDependencyManager
+import org.jetbrains.plugins.gradle.manage.GradleEntityManageHelper
 import org.jetbrains.plugins.gradle.manage.GradleJarManager
 import org.jetbrains.plugins.gradle.manage.GradleLibraryManager
+import org.jetbrains.plugins.gradle.manage.GradleProjectManager
 import org.jetbrains.plugins.gradle.model.GradleEntityOwner
 import org.jetbrains.plugins.gradle.model.gradle.GradleLibrary
 import org.jetbrains.plugins.gradle.model.gradle.LibraryPathType
@@ -89,9 +95,14 @@ public abstract class AbstractGradleTest {
     container.registerComponentImplementation(GradleDependencyManager)
     container.registerComponentImplementation(GradleLibraryManager)
     container.registerComponentImplementation(GradleJarManager, TestGradleJarManager)
+    container.registerComponentImplementation(GradleProjectManager)
     container.registerComponentImplementation(GradleDuplicateLibrariesPreProcessor)
     container.registerComponentImplementation(GradleMovedJarsPostProcessor, TestGradleMovedJarsPostProcessor)
     container.registerComponentImplementation(GradleOutdatedLibraryVersionPostProcessor)
+    container.registerComponentImplementation(GradleAutoImporter)
+    container.registerComponentImplementation(GradleSettings)
+    container.registerComponentImplementation(GradleLocalSettings)
+    container.registerComponentImplementation(GradleEntityManageHelper)
     configureContainer(container)
     
     intellij.projectStub.getComponent = { clazz -> container.getComponentInstance(clazz) }
@@ -102,6 +113,9 @@ public abstract class AbstractGradleTest {
     for (d in GradleColorAndFontDescriptorsProvider.DESCRIPTORS) {
       treeFilters[d.key] = AbstractGradleSyncTreeFilterAction.createFilter(d.key)
     }
+
+    def settings = ServiceManager.getService(intellij.project, GradleSettings.class)
+    settings.useAutoImport = false
   }
 
   protected void clearChangePostProcessors() {