plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java

   1 /*
   2  * User: anna
   3  * Date: 06-Jun-2007
   4  */
   5 package com.theoryinpractice.testng.configuration;
   6
   7 import com.intellij.execution.PsiLocation;
   8 import com.intellij.execution.RunManagerEx;
   9 import com.intellij.execution.RunnerAndConfigurationSettings;
  10 import com.intellij.execution.configurations.RunConfiguration;
  11 import com.intellij.execution.impl.RunManagerImpl;
  12 import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
  13 import com.intellij.openapi.application.PathManager;
  14 import com.intellij.openapi.application.Result;
  15 import com.intellij.openapi.command.WriteCommandAction;
  16 import com.intellij.openapi.project.Project;
  17 import com.intellij.openapi.util.io.FileUtil;
  18 import com.intellij.psi.PsiClass;
  19 import com.intellij.psi.PsiManager;
  20 import com.intellij.psi.PsiMethod;
  21 import com.intellij.refactoring.RefactoringFactory;
  22 import com.intellij.refactoring.RenameRefactoring;
  23 import com.intellij.testFramework.builders.JavaModuleFixtureBuilder;
  24 import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
  25 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory;
  26 import com.intellij.testFramework.fixtures.TempDirTestFixture;
  27 import com.intellij.testFramework.fixtures.TestFixtureBuilder;
  28 import com.intellij.util.PathUtil;
  29 import com.theoryinpractice.testng.model.TestType;
  30 import org.testng.Assert;
  31 import org.testng.annotations.AfterMethod;
  32 import org.testng.annotations.BeforeMethod;
  33 import org.testng.annotations.Test;
  34
  35 import java.io.File;
  36
  37 public class ConfigurationsTest {
  38   private TempDirTestFixture myFixture;
  39   private IdeaProjectTestFixture myProjectFixture;
  40
  41
  42   @BeforeMethod
  43   public void setUp() throws Exception {
  44     final IdeaTestFixtureFactory fixtureFactory = IdeaTestFixtureFactory.getFixtureFactory();
  45     final TestFixtureBuilder<IdeaProjectTestFixture> testFixtureBuilder = fixtureFactory.createFixtureBuilder();
  46     myFixture = fixtureFactory.createTempDirTestFixture();
  47     myFixture.setUp();
  48
  49     FileUtil.copyDir(new File(PathManager.getHomePath() + "/svnPlugins/testng/testData/runConfiguration/module1"),
  50                      new File(myFixture.getTempDirPath()), false);
  51
  52     myProjectFixture = testFixtureBuilder.getFixture();
  53     final JavaModuleFixtureBuilder javaModuleFixtureBuilder = testFixtureBuilder.addModule(JavaModuleFixtureBuilder.class);
  54     javaModuleFixtureBuilder.addContentRoot(myFixture.getTempDirPath()).addSourceRoot("src");
  55     javaModuleFixtureBuilder.addLibrary("testng", PathUtil.getJarPathForClass(AfterMethod.class));
  56     myProjectFixture.setUp();
  57     ((RunManagerImpl)RunManagerEx.getInstanceEx(myProjectFixture.getProject())).installRefactoringListener();
  58   }
  59
  60   @AfterMethod
  61   public void tearDown() throws Exception {
  62     ((RunManagerImpl)RunManagerEx.getInstanceEx(myProjectFixture.getProject())).uninstallRefactoringListener();
  63     myProjectFixture.tearDown();
  64     myProjectFixture = null;
  65     myFixture.tearDown();
  66     myFixture = null;
  67   }
  68
  69   @Test
  70   public void testClassRename() {
  71     final Project project = myProjectFixture.getProject();
  72     final PsiClass psiClass = findTestClass(project);
  73     final TestNGConfiguration configuration = createConfiguration(project);
  74     configuration.setClassConfiguration(psiClass);
  75     final String newName = "Testt1";
  76     final RenameRefactoring renameClass = RefactoringFactory.getInstance(project).createRename(psiClass, newName);
  77     renameClass.setSearchInComments(false);
  78     renameClass.setSearchInNonJavaFiles(false);
  79     new WriteCommandAction(project) {
  80       protected void run(final Result result) throws Throwable {
  81         renameClass.run();
  82       }
  83     }.execute();
  84     Assert.assertEquals(newName, configuration.getPersistantData().getMainClassName());
  85
  86     final PsiMethod notATestMethod = findNotATestMethod(psiClass);
  87
  88     final RenameRefactoring renameNotATestMethod = RefactoringFactory.getInstance(project).createRename(notATestMethod, "aaaa");
  89     renameNotATestMethod.setSearchInComments(false);
  90     renameNotATestMethod.setSearchInNonJavaFiles(false);
  91     new WriteCommandAction(project) {
  92       protected void run(final Result result) throws Throwable {
  93         renameNotATestMethod.run();
  94       }
  95     }.execute();
  96     Assert.assertEquals(configuration.getPersistantData().getMainClassName(), newName);
  97     Assert.assertEquals(configuration.getPersistantData().getMethodName(), "");
  98     Assert.assertEquals(configuration.getPersistantData().TEST_OBJECT, TestType.CLASS.getType());
  99   }
 100
 101
 102   @Test
 103   public void testRenameMethod() {
 104     final Project project = myProjectFixture.getProject();
 105     final PsiClass psiClass = findTestClass(project);
 106     final String className = psiClass.getName();
 107     final TestNGConfiguration configuration = createConfiguration(project);
 108
 109     final PsiMethod method = findTestMethod(psiClass);
 110     configuration.setMethodConfiguration(new PsiLocation<PsiMethod>(project, method));
 111     final String newMethodName = "renamedTest";
 112     final RenameRefactoring renameMethod = RefactoringFactory.getInstance(project).createRename(method, newMethodName);
 113     renameMethod.setSearchInComments(false);
 114     renameMethod.setSearchInNonJavaFiles(false);
 115     new WriteCommandAction(project) {
 116       protected void run(final Result result) throws Throwable {
 117         renameMethod.run();
 118       }
 119     }.execute();
 120
 121     Assert.assertEquals(className, configuration.getPersistantData().getMainClassName());
 122     Assert.assertEquals(newMethodName, configuration.getPersistantData().getMethodName());
 123
 124     final PsiMethod notATestMethod = findNotATestMethod(psiClass);
 125     final RenameRefactoring renameNotATestMethod1 = RefactoringFactory.getInstance(project).createRename(notATestMethod, "bbbbb");
 126     renameNotATestMethod1.setSearchInComments(false);
 127     renameNotATestMethod1.setSearchInNonJavaFiles(false);
 128     new WriteCommandAction(project) {
 129       protected void run(final Result result) throws Throwable {
 130         renameNotATestMethod1.run();
 131       }
 132     }.execute();
 133     Assert.assertEquals(className, configuration.getPersistantData().getMainClassName());
 134     Assert.assertEquals(newMethodName, configuration.getPersistantData().getMethodName());
 135   }
 136
 137   private PsiMethod findTestMethod(final PsiClass psiClass) {
 138     final PsiMethod[] psiMethods = psiClass.findMethodsByName("test", false);
 139     assert psiMethods.length == 1;
 140     return psiMethods[0];
 141   }
 142
 143   @Test
 144   public void testReuseOrCreateNewConfiguration() {
 145     final Project project = myProjectFixture.getProject();
 146     final PsiClass psiClass = findTestClass(project);
 147     final TestNGConfiguration configuration = createConfiguration(project);
 148     final TestNGConfigurationType type = (TestNGConfigurationType)configuration.getFactory().getType();
 149
 150     //class config
 151     configuration.setClassConfiguration(psiClass);
 152     Assert.assertTrue(type.isConfigurationByElement(configuration, project, psiClass));
 153     final PsiMethod testMethod = findTestMethod(psiClass);
 154     Assert.assertFalse(type.isConfigurationByElement(configuration, project, testMethod));
 155
 156     //method config
 157     configuration.setMethodConfiguration(new PsiLocation<PsiMethod>(project, testMethod));
 158     Assert.assertTrue(type.isConfigurationByElement(configuration, project, testMethod));
 159     Assert.assertFalse(type.isConfigurationByElement(configuration, project, psiClass));
 160   }
 161
 162   @Test
 163   public void testCreateFromContext() {
 164     final Project project = myProjectFixture.getProject();
 165     final PsiClass psiClass = findTestClass(project);
 166     final TestNGInClassConfigurationProducer producer = new TestNGInClassConfigurationProducer();
 167     final RunnerAndConfigurationSettingsImpl config = producer.createConfigurationByElement(new PsiLocation<PsiClass>(project, psiClass), null);
 168     assert config != null;
 169     final RunConfiguration runConfiguration = config.getConfiguration();
 170     Assert.assertTrue(runConfiguration instanceof TestNGConfiguration);
 171     Assert.assertTrue(((TestNGConfigurationType)runConfiguration.getType()).isConfigurationByElement(runConfiguration, project, psiClass));
 172   }
 173
 174   private PsiClass findTestClass(final Project project) {
 175     final PsiClass psiClass = PsiManager.getInstance(project).findClass("Testt");
 176     assert psiClass != null;
 177     return psiClass;
 178   }
 179
 180   private PsiMethod findNotATestMethod(final PsiClass psiClass) {
 181     final PsiMethod[] notATestMethods = psiClass.findMethodsByName("notATest", false);
 182     assert notATestMethods.length == 1;
 183     return notATestMethods[0];
 184   }
 185
 186   private TestNGConfiguration createConfiguration(final Project project) {
 187     final RunManagerEx manager = RunManagerEx.getInstanceEx(project);
 188     final RunnerAndConfigurationSettings settings =
 189       manager.createRunConfiguration("testt", TestNGConfigurationType.getInstance().getConfigurationFactories()[0]);
 190     manager.addConfiguration((RunnerAndConfigurationSettingsImpl)settings, false);
 191     return (TestNGConfiguration)settings.getConfiguration();
 192   }
 193 }