d40f19f327ada15aad594dc41dba67b735572bb2
[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.ExecutionException;
20 import com.intellij.execution.Executor;
21 import com.intellij.execution.RunnerAndConfigurationSettings;
22 import com.intellij.execution.configurations.*;
23 import com.intellij.execution.runners.ExecutionEnvironment;
24 import com.intellij.ide.util.PropertiesComponent;
25 import com.intellij.openapi.module.Module;
26 import com.intellij.openapi.options.SettingsEditor;
27 import com.intellij.openapi.project.Project;
28 import com.intellij.testFramework.LightPlatformTestCase;
29 import com.intellij.util.containers.ContainerUtil;
30 import com.intellij.util.messages.MessageBus;
31 import com.intellij.util.messages.MessageBusConnection;
32 import org.jdom.Element;
33 import org.jetbrains.annotations.NotNull;
34 import org.jetbrains.annotations.Nullable;
35 import org.jmock.Expectations;
36 import org.jmock.Mockery;
37
38 import javax.swing.*;
39 import java.util.Collection;
40 import java.util.Collections;
41 import java.util.List;
42
43 public class ModuleRunConfigurationManagerTest extends LightPlatformTestCase {
44
45   private ModuleRunConfigurationManager myManager;
46   private final Mockery context = new Mockery();
47   private Module myModule;
48   private Collection<? extends RunnerAndConfigurationSettings> myConfigurations;
49   private final List<RunnerAndConfigurationSettings> myRemovedSettings = ContainerUtil.newArrayList();
50   private RunnerAndConfigurationSettings mySettings;
51   private final List<RunnerAndConfigurationSettings> myAddedElements = ContainerUtil.newArrayList();
52
53   @Override
54   public void setUp() throws Exception {
55     super.setUp();
56     myModule = context.mock(Module.class, "myModule");
57     context.checking(new Expectations() {{
58       allowing(myModule).getName(); will(returnValue("my-module"));
59     }});
60     myManager = new ModuleRunConfigurationManager(myModule, new MyRunManagerImpl());
61
62     mySettings = createSettings("my-module-run", new MyModuleBasedConfiguration("my-module-run-config", getProject(), myModule));
63     final List<? extends RunnerAndConfigurationSettings> configs = ContainerUtil.newArrayList(
64       createSettings("other-run", context.mock(RunConfiguration.class, "other-run-run-config")),
65       createSettings("other-module-run", new MyModuleBasedConfiguration("other-module-run-config", getProject(), getModule())),
66       mySettings
67     );
68     myConfigurations = Collections.unmodifiableCollection(configs);
69   }
70
71   @NotNull
72   private RunnerAndConfigurationSettings createSettings(@NotNull final String name, @NotNull final RunConfiguration runConfiguration) {
73     final RunnerAndConfigurationSettings settings = context.mock(RunnerAndConfigurationSettings.class, name);
74     context.checking(new Expectations() {{
75       allowing(settings).getConfiguration(); will(returnValue(runConfiguration));
76     }});
77     return settings;
78   }
79
80   @Override
81   public void tearDown() throws Exception {
82     myManager = null;
83     super.tearDown();
84   }
85
86   public void testInitComponentSubscribesForModulesTopic() throws Exception {
87     context.checking(new Expectations() {{
88       final MessageBus messageBus = context.mock(MessageBus.class, "messageBus");
89       final MessageBusConnection messageBusConnection = context.mock(MessageBusConnection.class, "messageBusConnection");
90       oneOf(myModule).getMessageBus();
91       will(returnValue(messageBus));
92       oneOf(messageBus).connect(myModule); will(returnValue(messageBusConnection));
93       oneOf(messageBusConnection).subscribe(ProjectTopics.MODULES, myManager);
94     }});
95     myManager.initComponent();
96     context.assertIsSatisfied();
97   }
98
99   public void testGetState() throws Exception {
100     myAddedElements.clear();
101     myManager.getState();
102     assertSameElements("One config should be added to state", myAddedElements, Collections.singleton(mySettings));
103   }
104
105   public void testBeforeOtherModuleRemoved() throws Exception {
106     myRemovedSettings.clear();
107     myManager.beforeModuleRemoved(getProject(), getModule());
108     assertEmpty("No settings should be removed", myRemovedSettings);
109   }
110
111   public void testBeforeMyModuleRemoved() throws Exception {
112     myRemovedSettings.clear();
113     myManager.beforeModuleRemoved(getProject(), myModule);
114     assertSameElements("one run config should be removed", myRemovedSettings, Collections.singleton(mySettings));
115   }
116
117   private static final class MyRunConfigurationModule extends RunConfigurationModule {
118     private final Module myModule;
119     public MyRunConfigurationModule(@NotNull final Project project, @NotNull final Module module) {
120       super(project);
121       setModule(module);
122       myModule = module;
123     }
124
125     @Nullable
126     @Override
127     public Module getModule() {
128       return myModule;
129     }
130   }
131
132   private final class MyRunManagerImpl extends RunManagerImpl {
133     public MyRunManagerImpl() {
134       super(LightPlatformTestCase.getProject(), PropertiesComponent.getInstance(LightPlatformTestCase.getProject()));
135     }
136
137     @NotNull
138     @Override
139     Collection<? extends RunnerAndConfigurationSettings> getConfigurationSettings() {
140       return myConfigurations;
141     }
142
143     @Override
144     public void removeConfiguration(@Nullable RunnerAndConfigurationSettings settings) {
145       myRemovedSettings.add(settings);
146     }
147
148     @Override
149     void addConfigurationElement(@NotNull Element parentNode, RunnerAndConfigurationSettings template) {
150       myAddedElements.add(template);
151     }
152   }
153
154   private static final class MyModuleBasedConfiguration extends ModuleBasedConfiguration<RunConfigurationModule> {
155     public MyModuleBasedConfiguration(@NotNull final String name, @NotNull final Project project, @NotNull final Module module) {
156       super(name, new MyRunConfigurationModule(project, module), new MockConfigurationFactory());
157     }
158
159     @Override
160     public Collection<Module> getValidModules() {
161       return null;
162     }
163
164     @NotNull
165     @Override
166     public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
167       return null;
168     }
169
170     @Nullable
171     @Override
172     public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment env) throws ExecutionException {
173       return null;
174     }
175   }
176
177   private static class MockConfigurationFactory extends ConfigurationFactory {
178     public MockConfigurationFactory() {
179       super(new MyConfigurationType());
180     }
181
182     @Override
183     public RunConfiguration createTemplateConfiguration(Project project) {
184       throw new UnsupportedOperationException("Not Implemented");
185     }
186
187   }
188
189   private static class MyConfigurationType implements ConfigurationType {
190     @Override
191     public String getDisplayName() {
192       return "mock";
193     }
194
195     @Override
196     public String getConfigurationTypeDescription() {
197       return "mock type";
198     }
199
200     @Override
201     public Icon getIcon() {
202       return null;
203     }
204
205     @Override
206     @NotNull
207     public String getId() {
208       return "MockRuntimeConfiguration";
209     }
210
211     @Override
212     public ConfigurationFactory[] getConfigurationFactories() {
213       return new ConfigurationFactory[0];
214     }
215   }
216 }