b8105d9fea41b29dc17d2aabf1413688b01c59d3
[idea/community.git] / platform / lang-impl / testSources / com / intellij / execution / impl / ModuleRunConfigurationManagerTest.java
1 /*
2  * Copyright 2000-2015 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 com.intellij.execution.impl;
17
18 import com.intellij.ProjectTopics;
19 import com.intellij.execution.*;
20 import com.intellij.execution.configuration.EmptyRunProfileState;
21 import com.intellij.execution.configurations.*;
22 import com.intellij.execution.executors.DefaultRunExecutor;
23 import com.intellij.execution.process.ProcessHandler;
24 import com.intellij.execution.runners.ExecutionEnvironment;
25 import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
26 import com.intellij.execution.runners.GenericProgramRunner;
27 import com.intellij.execution.runners.RunContentBuilder;
28 import com.intellij.execution.ui.RunContentDescriptor;
29 import com.intellij.ide.util.PropertiesComponent;
30 import com.intellij.openapi.module.Module;
31 import com.intellij.openapi.options.SettingsEditor;
32 import com.intellij.openapi.project.Project;
33 import com.intellij.openapi.util.Disposer;
34 import com.intellij.testFramework.LightPlatformTestCase;
35 import com.intellij.util.containers.ContainerUtil;
36 import com.intellij.util.messages.MessageBus;
37 import com.intellij.util.messages.MessageBusConnection;
38 import org.jdom.Element;
39 import org.jetbrains.annotations.NotNull;
40 import org.jetbrains.annotations.Nullable;
41 import org.jmock.Expectations;
42 import org.jmock.Mockery;
43
44 import javax.swing.*;
45 import java.io.OutputStream;
46 import java.util.Collection;
47 import java.util.Collections;
48 import java.util.List;
49
50 public class ModuleRunConfigurationManagerTest extends LightPlatformTestCase {
51
52   private ModuleRunConfigurationManager myManager;
53   private final Mockery context = new Mockery();
54   private Module myModule;
55   private Collection<? extends RunnerAndConfigurationSettings> myConfigurations;
56   private final List<RunnerAndConfigurationSettings> myRemovedSettings = ContainerUtil.newArrayList();
57   private RunnerAndConfigurationSettings mySettings;
58   private final List<RunnerAndConfigurationSettings> myAddedElements = ContainerUtil.newArrayList();
59
60   @Override
61   public void setUp() throws Exception {
62     super.setUp();
63     myModule = context.mock(Module.class, "myModule");
64     context.checking(new Expectations() {{
65       allowing(myModule).getName(); will(returnValue("my-module"));
66     }});
67     myManager = new ModuleRunConfigurationManager(myModule, new MyRunManagerImpl());
68
69     mySettings = createSettings("my-module-run", new MyModuleBasedConfiguration("my-module-run-config", getProject(), myModule));
70     final List<? extends RunnerAndConfigurationSettings> configs = ContainerUtil.newArrayList(
71       createSettings("other-run", context.mock(RunConfiguration.class, "other-run-run-config")),
72       createSettings("other-module-run", new MyModuleBasedConfiguration("other-module-run-config", getProject(), getModule())),
73       mySettings
74     );
75     myConfigurations = Collections.unmodifiableCollection(configs);
76   }
77
78   @NotNull
79   private RunnerAndConfigurationSettings createSettings(@NotNull final String name, @NotNull final RunConfiguration runConfiguration) {
80     final RunnerAndConfigurationSettings settings = context.mock(RunnerAndConfigurationSettings.class, name);
81     context.checking(new Expectations() {{
82       allowing(settings).getConfiguration(); will(returnValue(runConfiguration));
83     }});
84     return settings;
85   }
86
87   @Override
88   public void tearDown() throws Exception {
89     myManager = null;
90     super.tearDown();
91   }
92
93   public void testInitComponentSubscribesForModulesTopic() throws Exception {
94     context.checking(new Expectations() {{
95       final MessageBus messageBus = context.mock(MessageBus.class, "messageBus");
96       final MessageBusConnection messageBusConnection = context.mock(MessageBusConnection.class, "messageBusConnection");
97       oneOf(myModule).getMessageBus();
98       will(returnValue(messageBus));
99       oneOf(messageBus).connect(myModule); will(returnValue(messageBusConnection));
100       oneOf(messageBusConnection).subscribe(ProjectTopics.MODULES, myManager);
101     }});
102     myManager.initComponent();
103     context.assertIsSatisfied();
104   }
105
106   public void testGetState() throws Exception {
107     myAddedElements.clear();
108     myManager.getState();
109     assertSameElements("One config should be added to state", myAddedElements, Collections.singleton(mySettings));
110   }
111
112   public void testBeforeOtherModuleRemoved() throws Exception {
113     myRemovedSettings.clear();
114     myManager.beforeModuleRemoved(getProject(), getModule());
115     assertEmpty("No settings should be removed", myRemovedSettings);
116   }
117
118   public void testBeforeMyModuleRemoved() throws Exception {
119     myRemovedSettings.clear();
120     myManager.beforeModuleRemoved(getProject(), myModule);
121     assertSameElements("one run config should be removed", myRemovedSettings, Collections.singleton(mySettings));
122   }
123
124   public void testSuppressToolwindowActivation() throws Exception {
125     RunnerAndConfigurationSettings settings = new RunnerAndConfigurationSettingsImpl(
126       new MyRunManagerImpl(), new MyModuleBasedConfiguration("my-name", getProject(), getModule()), false
127     );
128     settings.setActivateToolWindowBeforeRun(true);
129     MockProgramRunner programRunner = new MockProgramRunner();
130     ExecutionEnvironment env = new ExecutionEnvironmentBuilder(getProject(), DefaultRunExecutor.getRunExecutorInstance())
131       .runnerAndSettings(programRunner, settings)
132       .build();
133     RunContentDescriptor descriptorToReuse = new RunContentDescriptor(null, null, new JPanel(), "name");
134     descriptorToReuse.setActivateToolWindowWhenAdded(false);
135     descriptorToReuse.setReuseToolWindowActivation(true);
136     env.setContentToReuse(descriptorToReuse);
137     env.getRunner().execute(env);
138     RunContentDescriptor lastDescriptor = programRunner.getLastDescriptor();
139     assertNotNull(lastDescriptor);
140     assertFalse(lastDescriptor.isActivateToolWindowWhenAdded());
141     Disposer.dispose(descriptorToReuse);
142   }
143
144   private static final class MyRunConfigurationModule extends RunConfigurationModule {
145     private final Module myModule;
146     public MyRunConfigurationModule(@NotNull final Project project, @NotNull final Module module) {
147       super(project);
148       setModule(module);
149       myModule = module;
150     }
151
152     @Nullable
153     @Override
154     public Module getModule() {
155       return myModule;
156     }
157   }
158
159   private final class MyRunManagerImpl extends RunManagerImpl {
160     public MyRunManagerImpl() {
161       super(LightPlatformTestCase.getProject(), PropertiesComponent.getInstance(LightPlatformTestCase.getProject()));
162     }
163
164     @NotNull
165     @Override
166     Collection<? extends RunnerAndConfigurationSettings> getConfigurationSettings() {
167       return myConfigurations;
168     }
169
170     @Override
171     public void removeConfiguration(@Nullable RunnerAndConfigurationSettings settings) {
172       myRemovedSettings.add(settings);
173     }
174
175     @Override
176     void addConfigurationElement(@NotNull Element parentNode, RunnerAndConfigurationSettings template) {
177       myAddedElements.add(template);
178     }
179   }
180
181   private static final class MyModuleBasedConfiguration extends ModuleBasedConfiguration<RunConfigurationModule> {
182     public MyModuleBasedConfiguration(@NotNull final String name, @NotNull final Project project, @NotNull final Module module) {
183       super(name, new MyRunConfigurationModule(project, module), new MockConfigurationFactory());
184     }
185
186     @Override
187     public Collection<Module> getValidModules() {
188       return null;
189     }
190
191     @NotNull
192     @Override
193     public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
194       return null;
195     }
196
197     @Nullable
198     @Override
199     public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment env) throws ExecutionException {
200       return EmptyRunProfileState.INSTANCE;
201     }
202   }
203
204   private static class MockConfigurationFactory extends ConfigurationFactory {
205     public MockConfigurationFactory() {
206       super(new MyConfigurationType());
207     }
208
209     @Override
210     public RunConfiguration createTemplateConfiguration(Project project) {
211       throw new UnsupportedOperationException("Not Implemented");
212     }
213
214   }
215
216   private static class MyConfigurationType implements ConfigurationType {
217     @Override
218     public String getDisplayName() {
219       return "mock";
220     }
221
222     @Override
223     public String getConfigurationTypeDescription() {
224       return "mock type";
225     }
226
227     @Override
228     public Icon getIcon() {
229       return null;
230     }
231
232     @Override
233     @NotNull
234     public String getId() {
235       return "MockRuntimeConfiguration";
236     }
237
238     @Override
239     public ConfigurationFactory[] getConfigurationFactories() {
240       return new ConfigurationFactory[0];
241     }
242   }
243
244   private static class MockProgramRunner extends GenericProgramRunner {
245     private RunContentDescriptor myLastDescriptor;
246
247     @NotNull
248     @Override
249     public String getRunnerId() {
250       return "MockProgramRunner";
251     }
252
253     @Override
254     protected RunContentDescriptor doExecute(@NotNull RunProfileState state, @NotNull ExecutionEnvironment env) throws ExecutionException {
255       ExecutionResult executionResult = new DefaultExecutionResult(null, new NopProcessHandler());
256       myLastDescriptor = new RunContentBuilder(executionResult, env).showRunContent(env.getContentToReuse());
257       return myLastDescriptor;
258     }
259
260     @Override
261     public boolean canRun(@NotNull String executorId, @NotNull RunProfile profile) {
262       return true;
263     }
264
265     public RunContentDescriptor getLastDescriptor() {
266       return myLastDescriptor;
267     }
268   }
269
270   public static class NopProcessHandler extends ProcessHandler {
271     @Override
272     protected void destroyProcessImpl() {
273       notifyProcessTerminated(0);
274     }
275
276     @Override
277     protected void detachProcessImpl() {
278     }
279
280     @Override
281     public boolean detachIsDefault() {
282       return false;
283     }
284
285     @Nullable
286     @Override
287     public OutputStream getProcessInput() {
288       return null;
289     }
290   }
291 }