grails: skip grails-gradle test for Gradle newer than 2.1
[idea/community.git] / plugins / gradle / tooling-extension-impl / testSources / org / jetbrains / plugins / gradle / tooling / builder / AbstractModelBuilderTest.java
1 /*
2  * Copyright 2000-2014 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.plugins.gradle.tooling.builder;
17
18 import com.intellij.openapi.externalSystem.model.ExternalProject;
19 import com.intellij.openapi.util.Pair;
20 import com.intellij.openapi.util.io.FileUtil;
21 import com.intellij.testFramework.UsefulTestCase;
22 import com.intellij.util.Function;
23 import com.intellij.util.containers.ContainerUtil;
24 import org.gradle.tooling.BuildActionExecuter;
25 import org.gradle.tooling.GradleConnector;
26 import org.gradle.tooling.ProjectConnection;
27 import org.gradle.tooling.internal.consumer.DefaultGradleConnector;
28 import org.gradle.tooling.model.DomainObjectSet;
29 import org.gradle.tooling.model.idea.IdeaModule;
30 import org.gradle.util.GradleVersion;
31 import org.jetbrains.annotations.NotNull;
32 import org.jetbrains.plugins.gradle.VersionMatcherRule;
33 import org.jetbrains.plugins.gradle.model.BuildScriptClasspathModel;
34 import org.jetbrains.plugins.gradle.model.ClasspathEntryModel;
35 import org.jetbrains.plugins.gradle.model.ProjectImportAction;
36 import org.jetbrains.plugins.gradle.service.project.GradleExecutionHelper;
37 import org.jetbrains.plugins.gradle.util.GradleConstants;
38 import org.junit.After;
39 import org.junit.Before;
40 import org.junit.Rule;
41 import org.junit.rules.TestName;
42 import org.junit.runner.RunWith;
43 import org.junit.runners.Parameterized;
44
45 import java.io.File;
46 import java.io.IOException;
47 import java.net.URI;
48 import java.net.URISyntaxException;
49 import java.util.*;
50 import java.util.concurrent.TimeUnit;
51 import java.util.regex.Matcher;
52 import java.util.regex.Pattern;
53
54 import static org.junit.Assert.assertEquals;
55 import static org.junit.Assert.assertNotNull;
56 import static org.junit.Assume.assumeThat;
57
58 /**
59  * @author Vladislav.Soroka
60  * @since 11/29/13
61  */
62 @RunWith(value = Parameterized.class)
63 public abstract class AbstractModelBuilderTest {
64
65   public static final Object[][] SUPPORTED_GRADLE_VERSIONS = {
66     {"1.9"}, {"1.10"}, {"1.11"}, {"1.12"},
67     {"2.0"}, {"2.1"}, {"2.2"}
68   };
69
70   public static final Pattern TEST_METHOD_NAME_PATTERN = Pattern.compile("(.*)\\[(\\d*: with Gradle-.*)\\]");
71
72   private static File ourTempDir;
73
74   @NotNull
75   protected final String gradleVersion;
76   protected File testDir;
77   protected ProjectImportAction.AllModels allModels;
78
79   @Rule public TestName name = new TestName();
80   @Rule public VersionMatcherRule versionMatcherRule = new VersionMatcherRule();
81
82   public AbstractModelBuilderTest(@NotNull String gradleVersion) {
83     this.gradleVersion = gradleVersion;
84   }
85
86   @Parameterized.Parameters(name = "{index}: with Gradle-{0}")
87   public static Collection<Object[]> data() {
88     return Arrays.asList(SUPPORTED_GRADLE_VERSIONS);
89   }
90
91
92   @Before
93   public void setUp() throws Exception {
94     assumeThat(gradleVersion, versionMatcherRule.getMatcher());
95
96     ensureTempDirCreated();
97
98     String methodName = name.getMethodName();
99     Matcher m = TEST_METHOD_NAME_PATTERN.matcher(methodName);
100     if (m.matches()) {
101       methodName = m.group(1);
102     }
103
104     testDir = new File(ourTempDir, methodName);
105     FileUtil.ensureExists(testDir);
106
107     FileUtil.writeToFile(
108       new File(testDir, GradleConstants.DEFAULT_SCRIPT_NAME),
109       FileUtil.loadTextAndClose(getClass().getResourceAsStream("/" + methodName + "/" + GradleConstants.DEFAULT_SCRIPT_NAME))
110     );
111
112     FileUtil.writeToFile(
113       new File(testDir, GradleConstants.SETTINGS_FILE_NAME),
114       FileUtil.loadTextAndClose(getClass().getResourceAsStream("/" + methodName + "/" + GradleConstants.SETTINGS_FILE_NAME))
115     );
116
117     GradleConnector connector = GradleConnector.newConnector();
118
119     final URI distributionUri = new DistributionLocator().getDistributionFor(GradleVersion.version(gradleVersion));
120     connector.useDistribution(distributionUri);
121     connector.forProjectDirectory(testDir);
122     int daemonMaxIdleTime = 10;
123     try {
124       daemonMaxIdleTime = Integer.parseInt(System.getProperty("gradleDaemonMaxIdleTime", "10"));
125     }
126     catch (NumberFormatException ignore) {}
127
128     ((DefaultGradleConnector)connector).daemonMaxIdleTime(daemonMaxIdleTime, TimeUnit.SECONDS);
129     ProjectConnection connection = connector.connect();
130
131     try {
132       final ProjectImportAction projectImportAction = new ProjectImportAction(false);
133       projectImportAction.addExtraProjectModelClasses(getModels());
134       BuildActionExecuter<ProjectImportAction.AllModels> buildActionExecutor = connection.action(projectImportAction);
135       File initScript = GradleExecutionHelper.generateInitScript(false, getToolingExtensionClasses());
136       assertNotNull(initScript);
137       buildActionExecutor.setJvmArguments("-Xmx64m", "-XX:MaxPermSize=64m");
138       buildActionExecutor.withArguments("--info", "--recompile-scripts", GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());
139       allModels = buildActionExecutor.run();
140       assertNotNull(allModels);
141     } finally {
142       connection.close();
143     }
144   }
145
146   @NotNull
147   private Set<Class> getToolingExtensionClasses() {
148     final Set<Class> classes = ContainerUtil.<Class>set(
149       ExternalProject.class,
150       // gradle-tooling-extension-api jar
151       ProjectImportAction.class,
152       // gradle-tooling-extension-impl jar
153       ModelBuildScriptClasspathBuilderImpl.class
154     );
155
156     ContainerUtil.addAllNotNull(classes, doGetToolingExtensionClasses());
157     return classes;
158   }
159
160   @NotNull
161   protected Set<Class> doGetToolingExtensionClasses() {
162     return Collections.emptySet();
163   }
164
165   @After
166   public void tearDown() throws Exception {
167     if (testDir != null) {
168       FileUtil.delete(testDir);
169     }
170   }
171
172   protected abstract Set<Class> getModels();
173
174
175   protected <T> Map<String, T> getModulesMap(final Class<T> aClass) {
176     final DomainObjectSet<? extends IdeaModule> ideaModules = allModels.getIdeaProject().getModules();
177
178     final String filterKey = "to_filter";
179     final Map<String, T> map = ContainerUtil.map2Map(ideaModules, new Function<IdeaModule, Pair<String, T>>() {
180       @Override
181       public Pair<String, T> fun(IdeaModule module) {
182         final T value = allModels.getExtraProject(module, aClass);
183         final String key = value != null ? module.getGradleProject().getPath() : filterKey;
184         return Pair.create(key, value);
185       }
186     });
187
188     map.remove(filterKey);
189     return map;
190   }
191
192   protected void assertBuildClasspath(String projectPath, String... classpath) {
193     final Map<String, BuildScriptClasspathModel> classpathModelMap = getModulesMap(BuildScriptClasspathModel.class);
194     final BuildScriptClasspathModel classpathModel = classpathModelMap.get(projectPath);
195
196     assertNotNull(classpathModel);
197
198     final List<? extends ClasspathEntryModel> classpathEntryModels = classpathModel.getClasspath().getAll();
199     assertEquals(classpath.length, classpathEntryModels.size());
200
201     for (int i = 0, length = classpath.length; i < length; i++) {
202       String classpathEntry = classpath[i];
203       final ClasspathEntryModel classpathEntryModel = classpathEntryModels.get(i);
204       assertNotNull(classpathEntryModel);
205       assertEquals(1, classpathEntryModel.getClasses().size());
206       final String path = classpathEntryModel.getClasses().iterator().next();
207       assertEquals(classpathEntry, new File(path).getName());
208     }
209   }
210
211   private static void ensureTempDirCreated() throws IOException {
212     if (ourTempDir != null) return;
213
214     ourTempDir = new File(FileUtil.getTempDirectory(), "gradleTests");
215     FileUtil.delete(ourTempDir);
216     FileUtil.ensureExists(ourTempDir);
217   }
218
219   public static class DistributionLocator {
220     private static final String RELEASE_REPOSITORY_ENV = "GRADLE_RELEASE_REPOSITORY";
221     private static final String SNAPSHOT_REPOSITORY_ENV = "GRADLE_SNAPSHOT_REPOSITORY";
222     private static final String INTELLIJ_LABS_GRADLE_RELEASE_MIRROR =
223       "http://services.gradle.org-mirror.labs.intellij.net/distributions";
224     private static final String INTELLIJ_LABS_GRADLE_SNAPSHOT_MIRROR =
225       "http://services.gradle.org-mirror.labs.intellij.net/distributions-snapshots";
226     private static final String GRADLE_RELEASE_REPO = "http://services.gradle.org/distributions";
227     private static final String GRADLE_SNAPSHOT_REPO = "http://services.gradle.org/distributions-snapshots";
228
229     @NotNull private final String myReleaseRepoUrl;
230     @NotNull private final String mySnapshotRepoUrl;
231
232     public DistributionLocator() {
233       this(DistributionLocator.getRepoUrl(false), DistributionLocator.getRepoUrl(true));
234     }
235
236     public DistributionLocator(@NotNull String releaseRepoUrl, @NotNull String snapshotRepoUrl) {
237       myReleaseRepoUrl = releaseRepoUrl;
238       mySnapshotRepoUrl = snapshotRepoUrl;
239     }
240
241     @NotNull
242     public URI getDistributionFor(@NotNull GradleVersion version) throws URISyntaxException {
243       return getDistribution(getDistributionRepository(version), version, "gradle", "bin");
244     }
245
246     @NotNull
247     private String getDistributionRepository(@NotNull GradleVersion version) {
248       return version.isSnapshot() ? mySnapshotRepoUrl : myReleaseRepoUrl;
249     }
250
251     private static URI getDistribution(@NotNull String repositoryUrl,
252                                        @NotNull GradleVersion version,
253                                        @NotNull String archiveName,
254                                        @NotNull String archiveClassifier) throws URISyntaxException {
255       return new URI(String.format("%s/%s-%s-%s.zip", repositoryUrl, archiveName, version.getVersion(), archiveClassifier));
256     }
257
258     @NotNull
259     public static String getRepoUrl(boolean isSnapshotUrl) {
260       final String envRepoUrl = System.getenv(isSnapshotUrl ? SNAPSHOT_REPOSITORY_ENV : RELEASE_REPOSITORY_ENV);
261       if (envRepoUrl != null) return envRepoUrl;
262
263       if (UsefulTestCase.IS_UNDER_TEAMCITY) {
264         return isSnapshotUrl ? INTELLIJ_LABS_GRADLE_SNAPSHOT_MIRROR : INTELLIJ_LABS_GRADLE_RELEASE_MIRROR;
265       }
266
267       return isSnapshotUrl ? GRADLE_SNAPSHOT_REPO : GRADLE_RELEASE_REPO;
268     }
269   }
270 }