Make LaunchTaskRunner Support Warnings

Change the semantics of LaunchTask to support reporting warnings and make LaunchTaskRunner report these warnings to the console & as a notification.

Warnings do not prevent the launch from succeeding.

Bug: 37083213
Test: Added
Change-Id: I9a880377005db8d4d046086d47a28ff8d1893aad

5 files changed, 72 insertions, 39 deletions

diff --git a/android/testSrc/com/android/tools/idea/run/LaunchTaskRunnerTest.kt b/android/testSrc/com/android/tools/idea/run/LaunchTaskRunnerTest.kt
index a31bcb29a79..6cd1439b33a 100644
--- a/android/testSrc/com/android/tools/idea/run/LaunchTaskRunnerTest.kt
+++ b/android/testSrc/com/android/tools/idea/run/LaunchTaskRunnerTest.kt
@@ -106,6 +106,16 @@ class LaunchTaskRunnerTest {
       any())).thenReturn(listOf(failingTask))
   }
 
+  private fun setWarningLaunchTask(targetDevice: IDevice? = null) {
+    val warningTask = mock<LaunchTask>()
+    `when`(warningTask.shouldRun(any())).thenReturn(true)
+    `when`(warningTask.run(any())).thenReturn(LaunchResult.warning(""))
+    `when`(mockLaunchTasksProvider.getTasks(
+      targetDevice?.let { eq(targetDevice) } ?: any(),
+      any(),
+      any())).thenReturn(listOf(warningTask))
+  }
+
   private fun setSwapInfo() {
     `when`(mockExecutionEnvironment.getUserData(eq(SwapInfo.SWAP_INFO_KEY))).thenReturn(SwapInfo(SwapInfo.SwapType.APPLY_CHANGES, null))
   }
@@ -143,6 +153,26 @@ class LaunchTaskRunnerTest {
   }
 
   @Test
+  fun runWithWarnings() {
+    // Ideally, we would like to assert that the warning text is emitted to the console and the notifications expose it, but the current
+    // test infra doesn't have mechanism to do that so all we can do is assert that the warnings do not fail the launch.
+    val deviceFutures = createDeviceFutures()
+    setWarningLaunchTask()
+    val runner = createLaunchTaskRunner(deviceFutures)
+
+    runner.run(progressIndicator)
+
+    verify(mockProcessHandler).addTargetDevice(eq(deviceFutures.get()[0].get()))
+    // we should have two force-stop calls for APIs <= 25, which the mock IDevice is
+    verify(deviceFutures.get()[0].get(), times(2)).forceStop(any())
+    verify(mockProcessHandler, never()).detachDevice(any())
+    verify(mockProcessHandler, never()).detachProcess()
+    verify(mockProcessHandler, never()).destroyProcess()
+
+    verify(mockRunStats).endLaunchTasks()
+  }
+
+  @Test
   fun swapRunSucceeded() {
     val deviceFutures = createDeviceFutures()
     val runner = createLaunchTaskRunner(deviceFutures)
diff --git a/android/testSrc/com/android/tools/idea/run/tasks/ActivityLaunchTaskTest.kt b/android/testSrc/com/android/tools/idea/run/tasks/ActivityLaunchTaskTest.kt
index 5e05df3acb9..52621aee155 100644
--- a/android/testSrc/com/android/tools/idea/run/tasks/ActivityLaunchTaskTest.kt
+++ b/android/testSrc/com/android/tools/idea/run/tasks/ActivityLaunchTaskTest.kt
@@ -55,10 +55,10 @@ class ActivityLaunchTaskTest {
       description = "test launching activity"
     ) { true }
     val result = launchTask.run(LaunchContext(project, executor, device, launchStatus, printer, handler, indicator))
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     assertThat(result.errorId).isEmpty()
-    assertThat(result.error).isEmpty()
-    assertThat(result.consoleError).isEmpty()
+    assertThat(result.message).isEmpty()
+    assertThat(result.consoleMessage).isEmpty()
   }
 
   @Test
@@ -69,10 +69,10 @@ class ActivityLaunchTaskTest {
       description = "test launching activity"
     ) { false }
     val result = launchTask.run(LaunchContext(project, executor, device, launchStatus, printer, handler, indicator))
-    assertThat(result.success).isFalse()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.ERROR)
     assertThat(result.errorId).isEqualTo(ActivityLaunchTask.UNABLE_TO_DETERMINE_LAUNCH_ACTIVITY)
-    assertThat(result.error).isEqualTo("Error test launching activity")
-    assertThat(result.consoleError).isEqualTo("Error while test launching activity")
+    assertThat(result.message).isEqualTo("Error test launching activity")
+    assertThat(result.consoleMessage).isEqualTo("Error while test launching activity")
   }
 
   @Test
@@ -86,10 +86,10 @@ class ActivityLaunchTaskTest {
       false
     }
     val result = launchTask.run(LaunchContext(project, executor, device, launchStatus, printer, handler, indicator))
-    assertThat(result.success).isFalse()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.ERROR)
     assertThat(result.errorId).isEqualTo(ActivityLaunchTask.ACTIVITY_DOES_NOT_EXIST)
-    assertThat(result.error).isEqualTo("Error test launching activity")
-    assertThat(result.consoleError).isEqualTo("Error while test launching activity")
+    assertThat(result.message).isEqualTo("Error test launching activity")
+    assertThat(result.consoleMessage).isEqualTo("Error while test launching activity")
   }
 
   @Test
@@ -103,10 +103,10 @@ class ActivityLaunchTaskTest {
       false
     }
     val result = launchTask.run(LaunchContext(project, executor, device, launchStatus, printer, handler, indicator))
-    assertThat(result.success).isFalse()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.ERROR)
     assertThat(result.errorId).isEqualTo(UNKNOWN_ACTIVITY_LAUNCH_TASK_ERROR)
-    assertThat(result.error).isEqualTo("Error test launching activity")
-    assertThat(result.consoleError).isEqualTo("Error while test launching activity")
+    assertThat(result.message).isEqualTo("Error test launching activity")
+    assertThat(result.consoleMessage).isEqualTo("Error while test launching activity")
   }
 }
 
diff --git a/android/testSrc/com/android/tools/idea/run/tasks/RunInstantAppTaskTest.java b/android/testSrc/com/android/tools/idea/run/tasks/RunInstantAppTaskTest.java
index c25054a4eec..2308ce550bb 100644
--- a/android/testSrc/com/android/tools/idea/run/tasks/RunInstantAppTaskTest.java
+++ b/android/testSrc/com/android/tools/idea/run/tasks/RunInstantAppTaskTest.java
@@ -15,6 +15,14 @@
  */
 package com.android.tools.idea.run.tasks;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
 import com.android.ddmlib.IDevice;
 import com.android.tools.idea.instantapp.InstantAppSdks;
 import com.android.tools.idea.run.ApkFileUnit;
@@ -22,28 +30,21 @@ import com.android.tools.idea.run.ApkInfo;
 import com.android.tools.idea.run.ConsolePrinter;
 import com.android.tools.idea.run.util.LaunchStatus;
 import com.android.tools.idea.testing.IdeComponents;
-import com.google.android.instantapps.sdk.api.RunHandler;
 import com.google.android.instantapps.sdk.api.ExtendedSdk;
+import com.google.android.instantapps.sdk.api.RunHandler;
 import com.google.android.instantapps.sdk.api.StatusCode;
 import com.google.common.collect.ImmutableList;
 import com.intellij.execution.Executor;
 import com.intellij.execution.process.ProcessHandler;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.project.Project;
+import java.io.File;
+import java.net.URL;
 import org.jetbrains.android.AndroidTestCase;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
-import java.io.File;
-import java.net.URL;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.ArgumentMatchers.*;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
 public class RunInstantAppTaskTest extends AndroidTestCase {
   private final String DEVICE_ID = "dev1234";
   private final File zipFile = new File("/tmp/fake.zip");
@@ -77,16 +78,16 @@ public class RunInstantAppTaskTest extends AndroidTestCase {
     when(launchStatus.isLaunchTerminated()).thenReturn(true);
 
     RunInstantAppTask task = new RunInstantAppTask(apkInfoListForZip, "");
-    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getSuccess())
-      .isFalse();
+    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getResult())
+      .isEqualTo(LaunchResult.Result.ERROR);
     verifyNoMoreInteractions(runHandler);
   }
 
   @Test
   public void testPerformWithNoZipFile() {
     RunInstantAppTask task = new RunInstantAppTask(ImmutableList.of(), "");
-    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getSuccess())
-      .isFalse();
+    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getResult())
+      .isEqualTo(LaunchResult.Result.ERROR);
     verifyNoMoreInteractions(runHandler);
   }
 
@@ -103,8 +104,8 @@ public class RunInstantAppTaskTest extends AndroidTestCase {
       /* resultStream= */ any(),
       /* progressIndicator= */ any()))
       .thenReturn(StatusCode.SUCCESS);
-    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getSuccess())
-      .isTrue();
+    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getResult())
+      .isEqualTo(LaunchResult.Result.SUCCESS);
   }
 
   @Test
@@ -119,8 +120,8 @@ public class RunInstantAppTaskTest extends AndroidTestCase {
       /* resultStream= */ any(),
       /* progressIndicator= */ any()))
       .thenReturn(StatusCode.SUCCESS);
-    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getSuccess())
-      .isTrue();
+    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getResult())
+      .isEqualTo(LaunchResult.Result.SUCCESS);
   }
 
   @Test
@@ -147,8 +148,8 @@ public class RunInstantAppTaskTest extends AndroidTestCase {
       /* progressIndicator= */ any()))
       .thenReturn(StatusCode.SUCCESS);
 
-    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getSuccess())
-      .isTrue();
+    assertThat(task.run(new LaunchContext(project, executor, device, launchStatus, consolePrinter, handler, indicator)).getResult())
+      .isEqualTo(LaunchResult.Result.SUCCESS);
 
     verify(runHandler).runApks(
       /* apkFiles= */ eq(ImmutableList.of(apk1, apk2)),
diff --git a/android/testSrc/com/android/tools/idea/testartifacts/instrumented/AndroidTestApplicationLaunchTaskTest.kt b/android/testSrc/com/android/tools/idea/testartifacts/instrumented/AndroidTestApplicationLaunchTaskTest.kt
index c9adb5caf20..cd0a55acd6d 100644
--- a/android/testSrc/com/android/tools/idea/testartifacts/instrumented/AndroidTestApplicationLaunchTaskTest.kt
+++ b/android/testSrc/com/android/tools/idea/testartifacts/instrumented/AndroidTestApplicationLaunchTaskTest.kt
@@ -22,6 +22,7 @@ import com.android.testutils.MockitoKt.eq
 import com.android.tools.idea.run.AndroidProcessHandler
 import com.android.tools.idea.run.ConsolePrinter
 import com.android.tools.idea.run.tasks.LaunchContext
+import com.android.tools.idea.run.tasks.LaunchResult
 import com.android.tools.idea.run.util.LaunchStatus
 import com.android.tools.idea.testartifacts.instrumented.configuration.AndroidTestConfiguration
 import com.google.common.truth.Truth.assertThat
@@ -108,7 +109,7 @@ class AndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(mockLaunchContext)
 
     requireNotNull(result)
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
 
     verify(mockPrinter).stdout(eq("Running tests\n"))
     verify(mockProcessHandler).detachDevice(eq(mockDevice))
diff --git a/android/testSrc/com/android/tools/idea/testartifacts/instrumented/GradleAndroidTestApplicationLaunchTaskTest.kt b/android/testSrc/com/android/tools/idea/testartifacts/instrumented/GradleAndroidTestApplicationLaunchTaskTest.kt
index d52479408af..57820c7ae88 100644
--- a/android/testSrc/com/android/tools/idea/testartifacts/instrumented/GradleAndroidTestApplicationLaunchTaskTest.kt
+++ b/android/testSrc/com/android/tools/idea/testartifacts/instrumented/GradleAndroidTestApplicationLaunchTaskTest.kt
@@ -20,6 +20,7 @@ import com.android.testutils.MockitoKt.eq
 import com.android.tools.idea.gradle.project.model.GradleAndroidModel
 import com.android.tools.idea.run.ConsolePrinter
 import com.android.tools.idea.run.tasks.LaunchContext
+import com.android.tools.idea.run.tasks.LaunchResult
 import com.android.tools.idea.run.util.LaunchStatus
 import com.google.common.truth.Truth.assertThat
 import com.intellij.execution.Executor
@@ -74,7 +75,7 @@ class GradleAndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(
       LaunchContext(mockProject, mockExecutor, mockDevice, mockLaunchStatus, mockPrinter, mockHandler, mockIndicator))
 
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     verify(mockGradleConnectedAndroidTestInvoker).schedule(
       eq(mockProject),
       eq("taskId"),
@@ -109,7 +110,7 @@ class GradleAndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(
       LaunchContext(mockProject, mockExecutor, mockDevice, mockLaunchStatus, mockPrinter, mockHandler, mockIndicator))
 
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     verify(mockGradleConnectedAndroidTestInvoker).schedule(
       eq(mockProject),
       eq("taskId"),
@@ -144,7 +145,7 @@ class GradleAndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(
       LaunchContext(mockProject, mockExecutor, mockDevice, mockLaunchStatus, mockPrinter, mockHandler, mockIndicator))
 
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     verify(mockGradleConnectedAndroidTestInvoker).schedule(
       eq(mockProject),
       eq("taskId"),
@@ -180,7 +181,7 @@ class GradleAndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(
       LaunchContext(mockProject, mockExecutor, mockDevice, mockLaunchStatus, mockPrinter, mockHandler, mockIndicator))
 
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     verify(mockGradleConnectedAndroidTestInvoker).schedule(
       eq(mockProject),
       eq("taskId"),
@@ -216,7 +217,7 @@ class GradleAndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(
       LaunchContext(mockProject, mockExecutor, mockDevice, mockLaunchStatus, mockPrinter, mockHandler, mockIndicator))
 
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     verify(mockGradleConnectedAndroidTestInvoker).schedule(
       eq(mockProject),
       eq("taskId"),
@@ -250,7 +251,7 @@ class GradleAndroidTestApplicationLaunchTaskTest {
     val result = launchTask.run(
       LaunchContext(mockProject, mockExecutor, mockDevice, mockLaunchStatus, mockPrinter, mockHandler, mockIndicator))
 
-    assertThat(result.success).isTrue()
+    assertThat(result.result).isEqualTo(LaunchResult.Result.SUCCESS)
     verify(mockGradleConnectedAndroidTestInvoker).schedule(
       eq(mockProject),
       eq("taskId"),