android/testSrc/com/android/tools/idea/gradle/project/GradleProjectImporterTest.java

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * 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 com.android.tools.idea.gradle.project;

import com.android.SdkConstants;
import com.android.tools.idea.gradle.IdeaAndroidProject;
import com.android.tools.idea.gradle.IdeaGradleProject;
import com.android.tools.idea.gradle.IdeaJavaProject;
import com.android.tools.idea.gradle.facet.AndroidGradleFacet;
import com.android.tools.idea.gradle.facet.JavaGradleFacet;
import com.intellij.facet.FacetManager;
import com.intellij.facet.ModifiableFacetModel;
import com.intellij.openapi.externalSystem.model.DataNode;
import com.intellij.openapi.externalSystem.model.ProjectKeys;
import com.intellij.openapi.externalSystem.model.project.ModuleData;
import com.intellij.openapi.externalSystem.model.project.ProjectData;
import com.intellij.openapi.externalSystem.service.project.ExternalProjectRefreshCallback;
import com.intellij.openapi.externalSystem.service.execution.ProgressExecutionMode;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.project.Project;
import com.intellij.testFramework.CompositeException;
import com.intellij.testFramework.IdeaTestCase;
import org.jetbrains.android.facet.AndroidFacet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.gradle.util.GradleConstants;

import java.io.File;

import static com.android.tools.idea.gradle.AndroidProjectKeys.*;
import static com.intellij.openapi.module.StdModuleTypes.JAVA;
import static org.easymock.classextension.EasyMock.createMock;

/**
 * Tests for {@link GradleProjectImporter}.
 */
public class GradleProjectImporterTest extends IdeaTestCase {
  private String myProjectName;
  private File myProjectRootDir;
  private DataNode<ProjectData> myCachedProject;

  private GradleProjectImporter myImporter;
  private DataNode<ModuleData> myCachedModule;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    myProjectName = "test";
    myProjectRootDir = createTempDir(myProjectName);

    String projectRootDirPath = myProjectRootDir.getPath();
    final File projectFile = new File(myProjectRootDir, SdkConstants.FN_BUILD_GRADLE);
    final String configPath = projectFile.getPath();
    ProjectData projectData = new ProjectData(GradleConstants.SYSTEM_ID, myProjectName, projectRootDirPath, configPath);
    myCachedProject = new DataNode<ProjectData>(ProjectKeys.PROJECT, projectData, null);

    ModuleData moduleData =
      new ModuleData("", GradleConstants.SYSTEM_ID, JAVA.getId(), myModule.getName(), projectRootDirPath, configPath);
    myCachedModule = myCachedProject.createChild(ProjectKeys.MODULE, moduleData);

    GradleProjectImporter.ImporterDelegate delegate = new GradleProjectImporter.ImporterDelegate() {
      @Override
      void importProject(@NotNull Project project,
                         @NotNull ExternalProjectRefreshCallback callback,
                         @NotNull final ProgressExecutionMode progressTaskMode) throws ConfigurationException {
        assertNotNull(project);
        assertEquals(myProjectName, project.getName());
        callback.onSuccess(myCachedProject);
      }
    };

    myImporter = new GradleProjectImporter(delegate);
  }

  @Override
  protected void tearDown() throws Exception {
    Project[] projects = myProjectManager.getOpenProjects();
    for (Project project : projects) {
      if (project != getProject()) {
        myProjectManager.closeAndDispose(project);
      }
    }
    super.tearDown();
  }

  @Override
  protected CompositeException checkForSettingsDamage() throws Exception {
    return new CompositeException();
  }

  public void testImportNewlyCreatedProject() throws Exception {
    MyGradleSyncListener callback = new MyGradleSyncListener();
    myImporter.importNewlyCreatedProject(myProjectName, myProjectRootDir, callback, null, null);
  }

  public void testIsCacheMissingModelsWhenCacheHasAndroidModel() {
    FacetManager facetManager = FacetManager.getInstance(myModule);
    ModifiableFacetModel model = facetManager.createModifiableModel();
    try {
      model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
      model.addFacet(facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null));
    } finally {
      model.commit();
    }

    myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
    myCachedModule.createChild(IDE_ANDROID_PROJECT, createMock(IdeaAndroidProject.class));
    assertFalse(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
  }

  public void testIsCacheMissingModelsWhenCacheHasJavaModel() {
    FacetManager facetManager = FacetManager.getInstance(myModule);
    ModifiableFacetModel model = facetManager.createModifiableModel();
    try {
      model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
      model.addFacet(facetManager.createFacet(JavaGradleFacet.getFacetType(), JavaGradleFacet.NAME, null));
    } finally {
      model.commit();
    }

    myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
    myCachedModule.createChild(IDE_JAVA_PROJECT, createMock(IdeaJavaProject.class));
    assertFalse(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
  }

  public void testIsCacheMissingModelsWhenCacheIsMissingAndroidModel() {
    FacetManager facetManager = FacetManager.getInstance(myModule);
    ModifiableFacetModel model = facetManager.createModifiableModel();
    try {
      model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
      model.addFacet(facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null));
    } finally {
      model.commit();
    }

    myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
    assertTrue(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
  }

  public void testIsCacheMissingModelsWhenCacheIsMissingJavaModel() {
    FacetManager facetManager = FacetManager.getInstance(myModule);
    ModifiableFacetModel model = facetManager.createModifiableModel();
    try {
      model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
      model.addFacet(facetManager.createFacet(JavaGradleFacet.getFacetType(), JavaGradleFacet.NAME, null));
    } finally {
      model.commit();
    }

    myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
    assertTrue(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
  }

  private class MyGradleSyncListener extends GradleSyncListener.Adapter {
    @Override
    public void syncSucceeded(@NotNull Project project) {
      disposeOnTearDown(project);
      // Verify that project was imported correctly.
      assertEquals(myProjectName, project.getName());
      assertEquals(myProjectRootDir.getPath(), project.getBasePath());

      // Verify that '.idea' directory was created.
      File ideaProjectDir = new File(myProjectRootDir, Project.DIRECTORY_STORE_FOLDER);
      assertTrue(ideaProjectDir.isDirectory());

      // Verify that module was created.
      ModuleManager moduleManager = ModuleManager.getInstance(project);
      Module[] modules = moduleManager.getModules();
      assertEquals(1, modules.length);
      assertEquals(myModule.getName(), modules[0].getName());
    }

    @Override
    public void syncFailed(@NotNull Project project, @NotNull String errorMessage) {
      fail(errorMessage);
    }
  }
}