DEBUG - add wait on progress listener

Author: lfkellogg

firebase-appdistribution/src/main/java/com/google/firebase/appdistribution/impl/AabUpdater.java

@@ -96,6 +96,7 @@ UpdateTaskImpl updateAab(@NonNull AppDistributionReleaseInternal newRelease) {
       // On a background thread, fetch the redirect URL and open it in the Play app
       runAsyncInTask(executor, () -> fetchDownloadRedirectUrl(newRelease.getDownloadUrl()))
           .onSuccessTask(
+              executor,
               redirectUrl ->
                   lifecycleNotifier.consumeForegroundActivity(
                       activity -> openRedirectUrlInPlay(redirectUrl, activity)))

firebase-appdistribution/src/main/java/com/google/firebase/appdistribution/impl/FirebaseAppDistributionLifecycleNotifier.java

@@ -125,12 +125,14 @@ <T> Task<T> applyToForegroundActivity(ActivityFunction<T> function) {
 
   /** A version of {@link #applyToForegroundActivity} that does not produce a value. */
   Task<Void> consumeForegroundActivity(ActivityConsumer consumer) {
+    System.err.println("DEBUGGING: in consumeForegroundActivity");
     return getForegroundActivity()
         .onSuccessTask(
             // Use direct executor to ensure the consumer is called while Activity is in foreground
             DIRECT_EXECUTOR,
             activity -> {
               try {
+                System.err.println("DEBUGGING: consuming Foreground activity");
                 consumer.consume(activity);
                 return Tasks.forResult(null);
               } catch (Throwable t) {

firebase-appdistribution/src/test/java/com/google/firebase/appdistribution/impl/AabUpdaterTest.java

@@ -13,6 +13,7 @@
 // limitations under the License.
 package com.google.firebase.appdistribution.impl;
 
+import static android.os.Looper.getMainLooper;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.firebase.appdistribution.impl.TestUtils.assertTaskFailure;
 import static com.google.firebase.appdistribution.impl.TestUtils.awaitAsyncOperations;
@@ -36,7 +37,9 @@
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.TimeoutException;
 import javax.net.ssl.HttpsURLConnection;
+import junit.framework.AssertionFailedError;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -53,6 +56,8 @@
 public class AabUpdaterTest {
   private static final String TEST_URL = "https://test-url";
   private static final String REDIRECT_TO_PLAY = "https://redirect-to-play-url";
+  private static final int SLEEP_PER_LOOP_MS = 100;
+  private static final int MAX_LOOPS = 50;
 
   private static final AppDistributionReleaseInternal TEST_RELEASE_NEWER_AAB_INTERNAL =
       AppDistributionReleaseInternal.builder()
@@ -143,11 +148,9 @@ public void updateAppTask_emptyLocationHeader_setsDownloadFailure() throws Inter
 
   @Test
   public void updateAppTask_whenAabReleaseAvailable_redirectsToPlay() throws Exception {
-    List<UpdateProgress> progressEvents = new ArrayList<>();
-
     UpdateTask updateTask = aabUpdater.updateAab(TEST_RELEASE_NEWER_AAB_INTERNAL);
-    updateTask.addOnProgressListener(testExecutor, progressEvents::add);
-    awaitAsyncOperations(testExecutor);
+
+    List<UpdateProgress> progressEvents = awaitProgressUpdates(updateTask, 1);
 
     // Task is not completed in this case, because app is expected to terminate during update
     assertThat(shadowActivity.getNextStartedActivity().getData())
@@ -182,4 +185,22 @@ public void updateApp_whenCalledMultipleTimesWithAAB_returnsSameUpdateTask() {
 
     assertEquals(updateTask1, updateTask2);
   }
+
+  private List<UpdateProgress> awaitProgressUpdates(UpdateTask updateTask, int expectedUpdateCount)
+      throws InterruptedException, TimeoutException {
+    List<UpdateProgress> progressEvents = new ArrayList<>();
+    updateTask.addOnProgressListener(testExecutor, progressEvents::add);
+    awaitAsyncOperations(testExecutor);
+
+    // int loopCount = 0;
+    // while (progressEvents.size() < expectedUpdateCount && loopCount < MAX_LOOPS) {
+    //   // shadowOf(getMainLooper()).idle();
+    //   Thread.sleep(SLEEP_PER_LOOP_MS);
+    //   loopCount++;
+    // }
+    if (progressEvents.size() < expectedUpdateCount) {
+      throw new TimeoutException(String.format("Timed out waiting for updates (expected = %d, actual = %d)", expectedUpdateCount, progressEvents.size()));
+    }
+    return progressEvents;
+  }
 }

firebase-appdistribution/src/test/java/com/google/firebase/appdistribution/impl/TestOnProgressListener.java

@@ -0,0 +1,65 @@
+// Copyright 2021 Google LLC
+//
+// 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.firebase.appdistribution.impl;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.tasks.OnCanceledListener;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.appdistribution.FirebaseAppDistributionException;
+import com.google.firebase.appdistribution.OnProgressListener;
+import com.google.firebase.appdistribution.UpdateProgress;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Helper listener that awaits a specific number of progress events on a {@code UpdateTask}.
+ *
+ * This works around a limitation of the Tasks API where await() cannot be called on
+ * the main thread. This listener works around it by running itself on a different thread, thus
+ * allowing the main thread to be woken up when the Tasks complete.
+ *
+ * <p>Note: Calling {@link #await()} from a Robolectric test does block the main thread, since those
+ * tests are executed on the main thread.
+ */
+class TestOnProgressListener implements OnProgressListener {
+  private static final long TIMEOUT_MS = 5000;
+  private final int expectedProgressCount;
+  private final CountDownLatch latch;
+  private final List<UpdateProgress> progressUpdates = new ArrayList<>();
+
+  TestOnProgressListener(int expectedProgressCount) {
+    this.expectedProgressCount = expectedProgressCount;
+    this.latch = new CountDownLatch(expectedProgressCount);
+  }
+
+  @Override
+  public void onProgressUpdate(@NonNull UpdateProgress updateProgress) {
+    progressUpdates.add(updateProgress);
+    latch.countDown();
+  }
+
+  /** Blocks until the {@link #onProgressUpdate} is called the expected number of times. */
+  List<UpdateProgress> await() throws InterruptedException {
+    if (!latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+      throw new InterruptedException(String.format("Timed out waiting for progress events (expected = %d, actual = %d)", expectedProgressCount, progressUpdates.size()));
+    }
+    return progressUpdates;
+  }
+}