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 }