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