| /* |
| * Copyright 2016 The Bazel Authors. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.google.idea.blaze.android.run.testrecorder; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.android.tools.idea.run.editor.AndroidDebugger; |
| import com.android.tools.idea.run.editor.AndroidJavaDebugger; |
| import com.android.tools.idea.run.editor.DeployTargetProvider; |
| import com.android.tools.idea.run.editor.ShowChooserTargetProvider; |
| import com.google.common.collect.ImmutableList; |
| import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxy; |
| import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxyProvider; |
| import com.google.gct.testrecorder.ui.TestRecorderAction; |
| import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationHandler; |
| import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationHandlerProvider; |
| import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationState; |
| import com.google.idea.blaze.base.BlazeTestCase; |
| import com.google.idea.blaze.base.bazel.BuildSystemProvider; |
| import com.google.idea.blaze.base.bazel.WorkspaceRootProvider; |
| import com.google.idea.blaze.base.command.info.BlazeInfo; |
| import com.google.idea.blaze.base.ideinfo.TargetIdeInfo; |
| import com.google.idea.blaze.base.lang.buildfile.language.semantics.RuleDefinition; |
| import com.google.idea.blaze.base.model.BlazeVersionData; |
| import com.google.idea.blaze.base.model.primitives.Kind; |
| import com.google.idea.blaze.base.model.primitives.Label; |
| import com.google.idea.blaze.base.model.primitives.WorkspaceRoot; |
| import com.google.idea.blaze.base.run.BlazeBeforeRunTaskProvider; |
| import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration; |
| import com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType; |
| import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationHandler; |
| import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationHandlerProvider; |
| import com.google.idea.blaze.base.run.targetfinder.TargetFinder; |
| import com.google.idea.blaze.base.settings.Blaze; |
| import com.google.idea.blaze.base.settings.Blaze.BuildSystem; |
| import com.google.idea.blaze.base.settings.BlazeImportSettings; |
| import com.google.idea.blaze.base.settings.BlazeImportSettingsManager; |
| import com.intellij.execution.BeforeRunTaskProvider; |
| import com.intellij.execution.RunManager; |
| import com.intellij.execution.RunManagerEx; |
| import com.intellij.execution.configurations.ConfigurationType; |
| import com.intellij.execution.configurations.RunConfiguration; |
| import com.intellij.execution.impl.RunManagerImpl; |
| import com.intellij.ide.util.ProjectPropertiesComponentImpl; |
| import com.intellij.mock.MockModule; |
| import com.intellij.mock.MockProject; |
| import com.intellij.openapi.extensions.ExtensionPoint; |
| import com.intellij.openapi.extensions.ExtensionPointName; |
| import com.intellij.openapi.extensions.Extensions; |
| import com.intellij.openapi.extensions.impl.ExtensionPointImpl; |
| import com.intellij.openapi.extensions.impl.ExtensionsAreaImpl; |
| import com.intellij.openapi.fileTypes.FileNameMatcher; |
| import com.intellij.openapi.module.Module; |
| import com.intellij.openapi.project.Project; |
| import java.io.File; |
| import java.util.List; |
| import java.util.function.Predicate; |
| import javax.annotation.Nullable; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** Test cases for {@link TestRecorderBlazeCommandRunConfiguration}. */ |
| @RunWith(JUnit4.class) |
| public class BlazeConfigurationsTest extends BlazeTestCase { |
| |
| @Override |
| protected void initTest(Container applicationServices, Container projectServices) { |
| super.initTest(applicationServices, projectServices); |
| |
| mockBlazeImportSettings(projectServices); |
| applicationServices.register(TargetFinder.class, new MockTargetFinder()); |
| |
| ExtensionPoint<ConfigurationType> configurationTypeExtensionPoint = |
| registerExtensionPoint(ConfigurationType.CONFIGURATION_TYPE_EP, ConfigurationType.class); |
| configurationTypeExtensionPoint.registerExtension(new BlazeCommandRunConfigurationType()); |
| |
| ExtensionPoint<BlazeCommandRunConfigurationHandlerProvider> handlerProviderExtensionPoint = |
| registerExtensionPoint( |
| BlazeCommandRunConfigurationHandlerProvider.EP_NAME, |
| BlazeCommandRunConfigurationHandlerProvider.class); |
| handlerProviderExtensionPoint.registerExtension( |
| new MockBlazeAndroidBinaryRunConfigurationHandlerProvider()); |
| |
| ExtensionPoint<BuildSystemProvider> buildSystemProviderExtensionPoint = |
| registerExtensionPoint(BuildSystemProvider.EP_NAME, BuildSystemProvider.class); |
| buildSystemProviderExtensionPoint.registerExtension(new MockBuildSystemProvider()); |
| |
| ExtensionPoint<DeployTargetProvider> deployTargetProviderExtensionPoint = |
| registerExtensionPoint( |
| ExtensionPointName.create("com.android.run.deployTargetProvider"), |
| DeployTargetProvider.class); |
| deployTargetProviderExtensionPoint.registerExtension(new ShowChooserTargetProvider()); |
| |
| ExtensionPoint<AndroidDebugger> androidDebuggerExtensionPoint = |
| registerExtensionPoint(AndroidDebugger.EP_NAME, AndroidDebugger.class); |
| androidDebuggerExtensionPoint.registerExtension(new AndroidJavaDebugger()); |
| |
| ExtensionPoint<BeforeRunTaskProvider> beforeRunTaskProviderExtensionPoint = |
| registerExtensionPoint( |
| ExtensionPointName.create("com.intellij.stepsBeforeRunProvider"), |
| BeforeRunTaskProvider.class); |
| ((ExtensionsAreaImpl) Extensions.getArea(project)) |
| .registerExtensionPoint((ExtensionPointImpl) beforeRunTaskProviderExtensionPoint); |
| beforeRunTaskProviderExtensionPoint.registerExtension(new BlazeBeforeRunTaskProvider()); |
| |
| ExtensionPoint<TestRecorderRunConfigurationProxyProvider> |
| testRecorderRunConfigurationProxyProviderExtensionPoint = |
| registerExtensionPoint( |
| ExtensionPointName.create( |
| "com.google.gct.testrecorder.run.testRecorderRunConfigurationProxyProvider"), |
| TestRecorderRunConfigurationProxyProvider.class); |
| testRecorderRunConfigurationProxyProviderExtensionPoint.registerExtension( |
| new TestRecorderBlazeCommandRunConfigurationProxyProvider()); |
| |
| ((MockProject) project) |
| .addComponent( |
| RunManager.class, new RunManagerImpl(project, new ProjectPropertiesComponentImpl())); |
| } |
| |
| @Test |
| public void testSuitableRunConfigurations() { |
| addConfigurations(); |
| |
| List<RunConfiguration> allConfigurations = |
| RunManagerEx.getInstanceEx(project).getAllConfigurationsList(); |
| assertThat(allConfigurations.size()).isEqualTo(2); |
| |
| List<RunConfiguration> suitableConfigurations = |
| TestRecorderAction.getSuitableRunConfigurations(project); |
| assertThat(suitableConfigurations.size()).isEqualTo(1); |
| assertThat(suitableConfigurations.get(0).getName()).isEqualTo("AndroidBinaryConfiguration"); |
| } |
| |
| @Test |
| public void testLaunchActivityClass() { |
| BlazeCommandRunConfiguration blazeConfiguration = |
| BlazeCommandRunConfigurationType.getInstance() |
| .getFactory() |
| .createTemplateConfiguration(project); |
| blazeConfiguration.setTarget(Label.create("//label:android_binary_rule")); |
| BlazeAndroidBinaryRunConfigurationState configurationState = |
| ((BlazeAndroidBinaryRunConfigurationHandler) blazeConfiguration.getHandler()).getState(); |
| configurationState.setMode(BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY); |
| configurationState.setActivityClass("MyAppMainActivity"); |
| |
| TestRecorderRunConfigurationProxy proxy = |
| TestRecorderRunConfigurationProxy.getInstance(blazeConfiguration); |
| assertThat(proxy).isNotNull(); |
| assertThat(proxy.getLaunchActivityClass()).isEqualTo("MyAppMainActivity"); |
| } |
| |
| private void mockBlazeImportSettings(Container projectServices) { |
| BlazeImportSettingsManager importSettingsManager = new BlazeImportSettingsManager(); |
| importSettingsManager.setImportSettings( |
| new BlazeImportSettings("", "", "", "", Blaze.BuildSystem.Blaze)); |
| projectServices.register(BlazeImportSettingsManager.class, importSettingsManager); |
| } |
| |
| private void addConfigurations() { |
| RunManagerImpl runManager = (RunManagerImpl) RunManagerEx.getInstanceEx(project); |
| BlazeCommandRunConfigurationType.BlazeCommandRunConfigurationFactory configurationFactory = |
| BlazeCommandRunConfigurationType.getInstance().getFactory(); |
| |
| BlazeCommandRunConfiguration blazeAndroidBinaryConfiguration = |
| configurationFactory.createTemplateConfiguration(project); |
| blazeAndroidBinaryConfiguration.setName("AndroidBinaryConfiguration"); |
| blazeAndroidBinaryConfiguration.setTarget(Label.create("//label:android_binary_rule")); |
| |
| BlazeCommandRunConfiguration blazeAndroidTestConfiguration = |
| configurationFactory.createTemplateConfiguration(project); |
| blazeAndroidTestConfiguration.setName("AndroidTestConfiguration"); |
| blazeAndroidTestConfiguration.setTarget(Label.create("//label:android_test_rule")); |
| |
| runManager.addConfiguration( |
| runManager.createConfiguration(blazeAndroidBinaryConfiguration, configurationFactory), |
| true); |
| runManager.addConfiguration( |
| runManager.createConfiguration(blazeAndroidTestConfiguration, configurationFactory), true); |
| } |
| |
| private static class MockTargetFinder extends TargetFinder { |
| @Override |
| public List<TargetIdeInfo> findTargets(Project project, Predicate<TargetIdeInfo> predicate) { |
| return null; |
| } |
| |
| @Override |
| public TargetIdeInfo targetForLabel(Project project, final Label label) { |
| TargetIdeInfo.Builder builder = TargetIdeInfo.builder().setLabel(label); |
| if (label.equals(Label.create("//label:android_binary_rule"))) { |
| builder.setKind(Kind.ANDROID_BINARY); |
| } else if (label.equals(Label.create("//label:android_test_rule"))) { |
| builder.setKind(Kind.ANDROID_TEST); |
| } |
| return builder.build(); |
| } |
| } |
| |
| private class MockBlazeAndroidBinaryRunConfigurationHandlerProvider |
| extends BlazeAndroidBinaryRunConfigurationHandlerProvider { |
| @Override |
| public boolean canHandleKind(Kind kind) { |
| return true; |
| } |
| |
| @Override |
| public BlazeCommandRunConfigurationHandler createHandler(BlazeCommandRunConfiguration config) { |
| return new MockBlazeAndroidBinaryRunConfigurationHandler(config); |
| } |
| } |
| |
| private class MockBlazeAndroidBinaryRunConfigurationHandler |
| extends BlazeAndroidBinaryRunConfigurationHandler { |
| private final MockModule mockModule; |
| |
| MockBlazeAndroidBinaryRunConfigurationHandler(BlazeCommandRunConfiguration configuration) { |
| super(configuration); |
| mockModule = new MockModule(project, () -> {}); |
| } |
| |
| @Nullable |
| @Override |
| public Module getModule() { |
| Label label = getLabel(); |
| if (label != null && label.equals(Label.create("//label:android_binary_rule"))) { |
| return mockModule; |
| } |
| |
| return null; |
| } |
| } |
| |
| private static class MockBuildSystemProvider implements BuildSystemProvider { |
| @Override |
| public Blaze.BuildSystem buildSystem() { |
| return Blaze.BuildSystem.Blaze; |
| } |
| |
| @Override |
| public String getBinaryPath() { |
| return "/usr/bin/blaze"; |
| } |
| |
| @Override |
| public WorkspaceRootProvider getWorkspaceRootProvider() { |
| return null; |
| } |
| |
| @Override |
| public ImmutableList<String> buildArtifactDirectories(WorkspaceRoot root) { |
| return null; |
| } |
| |
| @Nullable |
| @Override |
| public String getRuleDocumentationUrl(RuleDefinition rule) { |
| return null; |
| } |
| |
| @Nullable |
| @Override |
| public String getProjectViewDocumentationUrl() { |
| return null; |
| } |
| |
| @Override |
| public String getLanguageSupportDocumentationUrl(String relativeDocName) { |
| return null; |
| } |
| |
| @Override |
| public boolean isBuildFile(String fileName) { |
| return false; |
| } |
| |
| @Nullable |
| @Override |
| public File findBuildFileInDirectory(File directory) { |
| return null; |
| } |
| |
| @Override |
| public ImmutableList<FileNameMatcher> buildLanguageFileTypeMatchers() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public void populateBlazeVersionData( |
| BuildSystem buildSystem, |
| WorkspaceRoot workspaceRoot, |
| BlazeInfo blazeInfo, |
| BlazeVersionData.Builder builder) {} |
| } |
| } |