plugins/maven/src/test/java/org/jetbrains/idea/maven/MavenTestCase.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.jetbrains.idea.maven;
  17
  18 import com.intellij.openapi.application.ApplicationManager;
  19 import com.intellij.openapi.application.Result;
  20 import com.intellij.openapi.application.WriteAction;
  21 import com.intellij.openapi.module.Module;
  22 import com.intellij.openapi.module.ModuleManager;
  23 import com.intellij.openapi.module.ModuleType;
  24 import com.intellij.openapi.module.StdModuleTypes;
  25 import com.intellij.openapi.progress.EmptyProgressIndicator;
  26 import com.intellij.openapi.project.Project;
  27 import com.intellij.openapi.roots.ModifiableRootModel;
  28 import com.intellij.openapi.roots.ModuleRootManager;
  29 import com.intellij.openapi.util.io.FileUtil;
  30 import com.intellij.openapi.vfs.LocalFileSystem;
  31 import com.intellij.openapi.vfs.VirtualFile;
  32 import com.intellij.testFramework.UsefulTestCase;
  33 import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
  34 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory;
  35 import org.intellij.lang.annotations.Language;
  36 import org.jetbrains.idea.maven.embedder.MavenConsole;
  37 import org.jetbrains.idea.maven.project.*;
  38 import org.jetbrains.idea.maven.utils.MavenProgressIndicator;
  39
  40 import java.io.File;
  41 import java.io.IOException;
  42 import java.lang.reflect.Field;
  43 import java.lang.reflect.Modifier;
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.Collection;
  47 import java.util.List;
  48
  49 public abstract class MavenTestCase extends UsefulTestCase {
  50   protected static final MavenConsole NULL_MAVEN_CONSOLE = new NullMavenConsole();
  51   protected static final MavenProgressIndicator EMPTY_MAVEN_PROCESS = new MavenProgressIndicator(new EmptyProgressIndicator());
  52
  53   private static File ourTempDir;
  54
  55   protected IdeaProjectTestFixture myTestFixture;
  56
  57   protected Project myProject;
  58
  59   protected File myDir;
  60   protected VirtualFile myProjectRoot;
  61
  62   protected VirtualFile myProjectPom;
  63   protected List<VirtualFile> myAllPoms = new ArrayList<VirtualFile>();
  64
  65   @Override
  66   protected void setUp() throws Exception {
  67     super.setUp();
  68
  69     ensureTempDirCreated();
  70
  71     myDir = FileUtil.createTempFile(ourTempDir, "test", "", false);
  72     myDir.mkdirs();
  73
  74     setUpFixtures();
  75
  76     myProject = myTestFixture.getProject();
  77
  78     MavenWorkspaceSettingsComponent.getInstance(myProject).loadState(new MavenWorkspaceSettings());
  79
  80     String home = getTestMavenHome();
  81     if (home != null) {
  82       getMavenGeneralSettings().setMavenHome(home);
  83     }
  84
  85     restoreSettingsFile();
  86
  87     ApplicationManager.getApplication().runWriteAction(new Runnable() {
  88       public void run() {
  89         try {
  90           setUpInWriteAction();
  91         }
  92         catch (Exception e) {
  93           throw new RuntimeException(e);
  94         }
  95       }
  96     });
  97   }
  98
  99   private void ensureTempDirCreated() {
 100     if (ourTempDir != null) return;
 101
 102     ourTempDir = new File(FileUtil.getTempDirectory(), "mavenTests");
 103     FileUtil.delete(ourTempDir);
 104     ourTempDir.mkdirs();
 105   }
 106
 107   protected void setUpFixtures() throws Exception {
 108     myTestFixture = IdeaTestFixtureFactory.getFixtureFactory().createFixtureBuilder().getFixture();
 109     myTestFixture.setUp();
 110   }
 111
 112   protected void setUpInWriteAction() throws Exception {
 113     File projectDir = new File(myDir, "project");
 114     projectDir.mkdirs();
 115     myProjectRoot = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(projectDir);
 116   }
 117
 118   @Override
 119   protected void tearDown() throws Exception {
 120     tearDownFixtures();
 121
 122     if (!FileUtil.delete(myDir)) {
 123       System.out.println("Cannot delete " + myDir);
 124       myDir.deleteOnExit();
 125     }
 126
 127     resetClassFields(getClass());
 128     super.tearDown();
 129   }
 130
 131   protected void tearDownFixtures() throws Exception {
 132     myTestFixture.tearDown();
 133   }
 134
 135   private void resetClassFields(final Class<?> aClass) {
 136     if (aClass == null) return;
 137
 138     final Field[] fields = aClass.getDeclaredFields();
 139     for (Field field : fields) {
 140       final int modifiers = field.getModifiers();
 141       if ((modifiers & Modifier.FINAL) == 0
 142           && (modifiers & Modifier.STATIC) == 0
 143           && !field.getType().isPrimitive()) {
 144         field.setAccessible(true);
 145         try {
 146           field.set(this, null);
 147         }
 148         catch (IllegalAccessException e) {
 149           e.printStackTrace();
 150         }
 151       }
 152     }
 153
 154     if (aClass == MavenTestCase.class) return;
 155     resetClassFields(aClass.getSuperclass());
 156   }
 157
 158   @Override
 159   protected void runTest() throws Throwable {
 160     if (runInWriteAction()) {
 161       new WriteAction() {
 162         protected void run(Result result) throws Throwable {
 163           MavenTestCase.super.runTest();
 164         }
 165       }.executeSilently().throwException();
 166     }
 167     else {
 168       MavenTestCase.super.runTest();
 169     }
 170   }
 171
 172   protected boolean runInWriteAction() {
 173     return true;
 174   }
 175
 176   protected MavenGeneralSettings getMavenGeneralSettings() {
 177     return MavenProjectsManager.getInstance(myProject).getGeneralSettings();
 178   }
 179
 180   protected MavenImportingSettings getMavenImporterSettings() {
 181     return MavenProjectsManager.getInstance(myProject).getImportingSettings();
 182   }
 183
 184   protected String getRepositoryPath() {
 185     String path = getRepositoryFile().getPath();
 186     return FileUtil.toSystemIndependentName(path);
 187   }
 188
 189   protected File getRepositoryFile() {
 190     return getMavenGeneralSettings().getEffectiveLocalRepository();
 191   }
 192
 193   protected void setRepositoryPath(String path) {
 194     getMavenGeneralSettings().setLocalRepository(path);
 195   }
 196
 197   protected String getProjectPath() {
 198     return myProjectRoot.getPath();
 199   }
 200
 201   protected String getParentPath() {
 202     return myProjectRoot.getParent().getPath();
 203   }
 204
 205   protected String pathFromBasedir(String relPath) {
 206     return pathFromBasedir(myProjectRoot, relPath);
 207   }
 208
 209   protected String pathFromBasedir(VirtualFile root, String relPath) {
 210     return FileUtil.toSystemIndependentName(root.getPath() + "/" + relPath);
 211   }
 212
 213   protected VirtualFile updateSettingsXml(String content) throws IOException {
 214     return updateSettingsXmlFully(createSettingsXmlContent(content));
 215   }
 216
 217   protected VirtualFile updateSettingsXmlFully(String content) throws IOException {
 218     File ioFile = new File(myDir, "settings.xml");
 219     ioFile.createNewFile();
 220     VirtualFile f = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(ioFile);
 221     setFileContent(f, content);
 222     getMavenGeneralSettings().setMavenSettingsFile(f.getPath());
 223     return f;
 224   }
 225
 226   protected void deleteSettingsXml() throws IOException {
 227     VirtualFile f = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(myDir, "settings.xml"));
 228     if (f != null) f.delete(this);
 229   }
 230
 231   private String createSettingsXmlContent(String content) {
 232     String mirror = System.getProperty("idea.maven.test.mirror",
 233                                        "http://maven.labs.intellij.net:8081/nexus/content/groups/public/");
 234     return "<settings>" +
 235            content +
 236            "<mirrors>" +
 237            "  <mirror>" +
 238            "    <id>Nexus</id>" +
 239            "    <name>Nexus Public Mirror</name>" +
 240            "    <url>" + mirror + "</url>" +
 241            "    <mirrorOf>*</mirrorOf>" +
 242            "  </mirror>" +
 243            "</mirrors>" +
 244            "</settings>";
 245   }
 246
 247   protected void restoreSettingsFile() throws IOException {
 248     updateSettingsXml("");
 249   }
 250
 251   protected Module createModule(String name) throws IOException {
 252     return createModule(name, StdModuleTypes.JAVA);
 253   }
 254
 255   protected Module createModule(String name, ModuleType type) throws IOException {
 256     VirtualFile f = createProjectSubFile(name + "/" + name + ".iml");
 257     Module module = ModuleManager.getInstance(myProject).newModule(f.getPath(), type);
 258     ModifiableRootModel model = ModuleRootManager.getInstance(module).getModifiableModel();
 259     model.addContentEntry(f.getParent());
 260     model.commit();
 261     return module;
 262   }
 263
 264   protected void createProjectPom(String xml) throws IOException {
 265     myProjectPom = createPomFile(myProjectRoot, xml);
 266   }
 267
 268   protected VirtualFile createModulePom(String relativePath, String xml) throws IOException {
 269     return createPomFile(createProjectSubDir(relativePath), xml);
 270   }
 271
 272   protected VirtualFile createPomFile(VirtualFile dir, String xml) throws IOException {
 273     VirtualFile f = dir.findChild("pom.xml");
 274     if (f == null) {
 275       f = dir.createChildData(null, "pom.xml");
 276       myAllPoms.add(f);
 277     }
 278     setFileContent(f, createPomXml(xml));
 279     return f;
 280   }
 281
 282   protected String createPomXml(String xml) {
 283     return "<?xml version=\"1.0\"?>" +
 284            "<project xmlns=\"http://maven.apache.org/POM/4.0.0\"" +
 285            "         xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" +
 286            "         xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\">" +
 287            "  <modelVersion>4.0.0</modelVersion>" +
 288            xml +
 289            "</project>";
 290   }
 291
 292   protected VirtualFile createProfilesXmlOldStyle(String xml) throws IOException {
 293     return createProfilesFile(myProjectRoot, xml, true);
 294   }
 295
 296   protected VirtualFile createProfilesXmlOldStyle(String relativePath, String xml) throws IOException {
 297     return createProfilesFile(createProjectSubDir(relativePath), xml, true);
 298   }
 299
 300   protected VirtualFile createProfilesXml(String xml) throws IOException {
 301     return createProfilesFile(myProjectRoot, xml, false);
 302   }
 303
 304   protected VirtualFile createProfilesXml(String relativePath, String xml) throws IOException {
 305     return createProfilesFile(createProjectSubDir(relativePath), xml, false);
 306   }
 307
 308   private VirtualFile createProfilesFile(VirtualFile dir, String xml, boolean oldStyle) throws IOException {
 309     VirtualFile f = dir.findChild("profiles.xml");
 310     if (f == null) {
 311       f = dir.createChildData(null, "profiles.xml");
 312     }
 313     setFileContent(f, createValidProfiles(xml, oldStyle));
 314     return f;
 315   }
 316
 317   private String createValidProfiles(String xml, boolean oldStyle) {
 318     if (oldStyle) {
 319       return "<?xml version=\"1.0\"?>" +
 320              "<profiles>" +
 321              xml +
 322              "</profiles>";
 323     }
 324     return "<?xml version=\"1.0\"?>" +
 325            "<profilesXml>" +
 326            "<profiles>" +
 327            xml +
 328            "</profiles>" +
 329            "</profilesXml>";
 330   }
 331
 332   protected void deleteProfilesXml() throws IOException {
 333     VirtualFile f = myProjectRoot.findChild("profiles.xml");
 334     if (f != null) f.delete(this);
 335   }
 336
 337   protected void createStdProjectFolders() {
 338     createProjectSubDirs("src/main/java",
 339                          "src/main/resources",
 340                          "src/test/java",
 341                          "src/test/resources");
 342   }
 343
 344   protected void createProjectSubDirs(String... relativePaths) {
 345     for (String path : relativePaths) {
 346       createProjectSubDir(path);
 347     }
 348   }
 349
 350   protected VirtualFile createProjectSubDir(String relativePath) {
 351     File f = new File(getProjectPath(), relativePath);
 352     f.mkdirs();
 353     return LocalFileSystem.getInstance().refreshAndFindFileByIoFile(f);
 354   }
 355
 356   protected VirtualFile createProjectSubFile(String relativePath) throws IOException {
 357     File f = new File(getProjectPath(), relativePath);
 358     f.getParentFile().mkdirs();
 359     f.createNewFile();
 360     return LocalFileSystem.getInstance().refreshAndFindFileByIoFile(f);
 361   }
 362
 363   protected VirtualFile createProjectSubFile(String relativePath, String content) throws IOException {
 364     VirtualFile file = createProjectSubFile(relativePath);
 365     setFileContent(file, content);
 366     return file;
 367   }
 368
 369   private void setFileContent(VirtualFile file, String content) throws IOException {
 370     file.setBinaryContent(content.getBytes(), -1, file.getTimeStamp() + 1000);
 371   }
 372
 373   protected void assertPathEquals(String expected, String actual) {
 374     if (expected != null) expected = FileUtil.toSystemIndependentName(expected);
 375     if (actual != null) actual = FileUtil.toSystemIndependentName(actual);
 376     assertEquals(expected, actual);
 377   }
 378
 379   protected <T, U> void assertOrderedElementsAreEqual(Collection<U> actual, Collection<T> expected) {
 380     assertOrderedElementsAreEqual(actual, expected.toArray());
 381   }
 382
 383   protected <T, U> void assertUnorderedElementsAreEqual(Collection<U> actual, Collection<T> expected) {
 384     assertUnorderedElementsAreEqual(actual, expected.toArray());
 385   }
 386
 387   protected <T, U> void assertUnorderedElementsAreEqual(U[] actual, T... expected) {
 388     assertUnorderedElementsAreEqual(Arrays.asList(actual), expected);
 389   }
 390
 391   protected <T, U> void assertUnorderedElementsAreEqual(Collection<U> actual, T... expected) {
 392     String s = "\nexpected: " + Arrays.asList(expected) + "\nactual: " + new ArrayList<U>(actual);
 393     assertEquals(s, expected.length, actual.size());
 394
 395     for (T eachExpected : expected) {
 396       boolean found = false;
 397       for (U eachActual : actual) {
 398         if (eachExpected.equals(eachActual)) {
 399           found = true;
 400           break;
 401         }
 402       }
 403       assertTrue(s, found);
 404     }
 405   }
 406
 407   protected <T, U> void assertOrderedElementsAreEqual(Collection<U> actual, T... expected) {
 408     String s = "\nexpected: " + Arrays.asList(expected) + "\nactual: " + new ArrayList<U>(actual);
 409     assertEquals(s, expected.length, actual.size());
 410
 411     List<U> actualList = new ArrayList<U>(actual);
 412     for (int i = 0; i < expected.length; i++) {
 413       T expectedElement = expected[i];
 414       U actualElement = actualList.get(i);
 415       assertTrue(s, expectedElement.equals(actualElement));
 416     }
 417   }
 418
 419   protected boolean ignore() {
 420     System.out.println("Ignored: " + getClass().getSimpleName() + "." + getName());
 421     return true;
 422   }
 423
 424   protected boolean hasMavenInstallation() {
 425     boolean result = getTestMavenHome() != null;
 426     if (!result) System.out.println("Ignored, because Maven installation not found: " + getClass().getSimpleName() + "." + getName());
 427     return result;
 428   }
 429
 430   private String getTestMavenHome() {
 431     return System.getProperty("idea.maven.test.home");
 432   }
 433 }